chrome/browser/sync/profile_sync_service_android.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_ANDROID_H_
   6 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_ANDROID_H_
   7
   8 #include <jni.h>
   9 #include <map>
  10
  11 #include "base/android/jni_helper.h"
  12 #include "base/callback.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/time/time.h"
  15 #include "chrome/browser/sync/profile_sync_service_observer.h"
  16 #include "chrome/browser/sync/sync_prefs.h"
  17 #include "google/cacheinvalidation/include/types.h"
  18 #include "google_apis/gaia/google_service_auth_error.h"
  19
  20 class Profile;
  21 class ProfileSyncService;
  22
  23 // Android wrapper of the ProfileSyncService which provides access from the Java
  24 // layer. Note that on Android, there's only a single profile, and therefore
  25 // a single instance of this wrapper. The name of the Java class is
  26 // ProfileSyncService.
  27 // This class should only be accessed from the UI thread.
  28 class ProfileSyncServiceAndroid : public ProfileSyncServiceObserver {
  29  public:
  30
  31   ProfileSyncServiceAndroid(JNIEnv* env, jobject obj);
  32
  33   // This method should be called once right after contructing the object.
  34   void Init();
  35
  36   // Called from Java when we need to nudge native syncer. The |objectSource|,
  37   // |objectId|, |version| and |payload| values should come from an
  38   // invalidation.
  39   void NudgeSyncer(JNIEnv* env,
  40                    jobject obj,
  41                    jint objectSource,
  42                    jstring objectId,
  43                    jlong version,
  44                    jstring payload);
  45
  46   // Called from Java when we need to nudge native syncer but have lost state on
  47   // which types have changed.
  48   void NudgeSyncerForAllTypes(JNIEnv* env, jobject obj);
  49
  50   // Called from Java when the user manually enables sync
  51   void EnableSync(JNIEnv* env, jobject obj);
  52
  53   // Called from Java when the user manually disables sync
  54   void DisableSync(JNIEnv* env, jobject obj);
  55
  56   // Called from Java when the user signs in to Chrome. Starts up sync.
  57   void SignInSync(JNIEnv* env, jobject obj);
  58
  59   // Called from Java when the user signs out of Chrome
  60   void SignOutSync(JNIEnv* env, jobject obj);
  61
  62   // Returns a string version of browser_sync::SyncBackendHost::StatusSummary
  63   base::android::ScopedJavaLocalRef<jstring> QuerySyncStatusSummary(
  64       JNIEnv* env, jobject obj);
  65
  66   // Called from Java early during startup to ensure we use the correct
  67   // unique machine tag in session sync. Returns true if the machine tag was
  68   // succesfully set.
  69   // This must be called before the |SessionModelAssociator| is initialized.
  70   jboolean SetSyncSessionsId(JNIEnv* env, jobject obj, jstring tag);
  71
  72   // Returns true if the sync backend is initialized.
  73   jboolean IsSyncInitialized(JNIEnv* env, jobject obj);
  74
  75   // Returns true if the sync is currently being setup for the first time.
  76   jboolean IsFirstSetupInProgress(JNIEnv* env, jobject obj);
  77
  78   // Returns true if the user is currently encrypting everything.
  79   jboolean IsEncryptEverythingEnabled(JNIEnv* env, jobject obj);
  80
  81   // Returns true if the sync code needs a passphrase for either encryption or
  82   // decryption (can need a passphrase for encryption if the user is turning on
  83   // encryption and no passphrase has been set yet).
  84   jboolean IsPassphraseRequired(JNIEnv* env, jobject obj);
  85
  86   // Returns true if the sync code needs a decryption passphrase for one of the
  87   // currently enabled types.
  88   jboolean IsPassphraseRequiredForDecryption(JNIEnv* env, jobject obj);
  89
  90   // Returns true if the sync code needs a decryption passphrase for *any* type,
  91   // even types that aren't supported on this platform (like passwords).
  92   jboolean IsPassphraseRequiredForExternalType(JNIEnv* env, jobject obj);
  93
  94   // Returns true if the sync code needs a custom decryption passphrase.
  95   // Can not be called if the sync backend is not initialized.
  96   jboolean IsUsingSecondaryPassphrase(JNIEnv* env, jobject obj);
  97
  98   // Returns true if the decryption passphrase works (was able to decrypt the
  99   // stored sync data). Should only be called if
 100   // IsPassphraseRequiredForDecryption() returns true.
 101   jboolean SetDecryptionPassphrase(JNIEnv* env,
 102                                    jobject obj,
 103                                    jstring passphrase);
 104
 105   // Encrypts the user's data with the passed passphrase. If |is_gaia| == true
 106   // then the passphrase is treated as a google (GAIA) passphrase, otherwise
 107   // it's treated like an explicit/custom passphrase.
 108   void SetEncryptionPassphrase(JNIEnv* env,
 109                                jobject obj,
 110                                jstring passphrase,
 111                                jboolean is_gaia);
 112
 113   // Returns whether the cryptographer is ready (i.e. encrypted types can be
 114   // handled).
 115   jboolean IsCryptographerReady(JNIEnv* env, jobject);
 116
 117   // Returns the actual passphrase type being used for encryption. This is a
 118   // value from the enum defined in syncer::PassphraseType and must be matched
 119   // in Java.
 120   jint GetPassphraseType(JNIEnv* env, jobject obj);
 121
 122   // Returns true if the current explicit passphrase time is defined.
 123   jboolean HasExplicitPassphraseTime(JNIEnv* env, jobject);
 124
 125   base::android::ScopedJavaLocalRef<jstring>
 126       GetSyncEnterGooglePassphraseBodyWithDateText(
 127           JNIEnv* env, jobject);
 128
 129   base::android::ScopedJavaLocalRef<jstring>
 130       GetSyncEnterCustomPassphraseBodyWithDateText(
 131           JNIEnv* env, jobject);
 132
 133   base::android::ScopedJavaLocalRef<jstring>
 134       GetCurrentSignedInAccountText(
 135           JNIEnv* env, jobject);
 136
 137   base::android::ScopedJavaLocalRef<jstring>
 138       GetSyncEnterCustomPassphraseBodyText(
 139           JNIEnv* env, jobject);
 140
 141   // Returns true if sync has been migrated.
 142   jboolean IsSyncKeystoreMigrationDone(JNIEnv* env, jobject obj);
 143
 144   // Get the set of enabled data types. These are the types currently both
 145   // registered and preferred. Note that control types are always included here.
 146   // Returns a bit map of the values from
 147   // profile_sync_service_model_type_selection_android.h.
 148   jlong GetEnabledDataTypes(JNIEnv* env, jobject obj);
 149
 150   // Enables the passed data types.
 151   // If |sync_everything| is true, then all data types are enabled and the
 152   // contents of |model_type_selection| is
 153   // ignored.
 154   // Otherwise, the values of |model_type_selection| must contain a bit map of
 155   // values from profile_sync_service_model_type_selection_android.h.
 156   void SetPreferredDataTypes(JNIEnv* env,
 157                              jobject obj,
 158                              jboolean sync_everything,
 159                              jlong model_type_selection);
 160
 161   // Tells sync that we're currently configuring so no data types should be
 162   // downloaded yet.
 163   void SetSetupInProgress(JNIEnv* env, jobject obj, jboolean in_progress);
 164
 165   // Tells sync that sync setup is complete so we can start syncing now.
 166   void SetSyncSetupCompleted(JNIEnv* env, jobject obj);
 167
 168   // Returns true if sync setup has been completed.
 169   jboolean HasSyncSetupCompleted(JNIEnv* env, jobject obj);
 170
 171   // Returns true if sync startup is currently suppressed.
 172   jboolean IsStartSuppressed(JNIEnv* env, jobject obj);
 173
 174   // Returns true if sync is configured to "sync everything".
 175   jboolean HasKeepEverythingSynced(JNIEnv* env, jobject obj);
 176
 177   // Turns on encryption for all data types. This is an asynchronous operation
 178   // which happens after the current configuration pass is done, so a call to
 179   // this routine must be followed by a call to SetEnabledDataTypes().
 180   void EnableEncryptEverything(JNIEnv* env, jobject obj);
 181
 182   // Returns true if sync has encountered an unrecoverable error.
 183   jboolean HasUnrecoverableError(JNIEnv* env, jobject obj);
 184
 185   // Returns sync internals in a JSON-formatted Java string.
 186   base::android::ScopedJavaLocalRef<jstring> GetAboutInfoForTest(JNIEnv* env,
 187                                                                  jobject obj);
 188
 189   // Returns the integer value corresponding to the current auth error state
 190   // (GoogleServiceAuthError.State).
 191   jint GetAuthError(JNIEnv* env, jobject obj);
 192
 193   // ProfileSyncServiceObserver:
 194   virtual void OnStateChanged() OVERRIDE;
 195
 196   // Returns a timestamp for when a sync was last executed. The return value is
 197   // the internal value of base::Time.
 198   jlong GetLastSyncedTimeForTest(JNIEnv* env, jobject obj);
 199
 200   static ProfileSyncServiceAndroid* GetProfileSyncServiceAndroid();
 201
 202   // Registers the ProfileSyncServiceAndroid's native methods through JNI.
 203   static bool Register(JNIEnv* env);
 204
 205  private:
 206   typedef std::map<invalidation::ObjectId,
 207                    int64,
 208                    syncer::ObjectIdLessThan> ObjectIdVersionMap;
 209
 210   virtual ~ProfileSyncServiceAndroid();
 211   // Remove observers to profile sync service.
 212   void RemoveObserver();
 213   // Called from Java when we need to nudge native syncer. The |object_source|,
 214   // |objectId|, |version| and |payload| values should come from an
 215   // invalidation.
 216   void SendNudgeNotification(int object_source,
 217                              const std::string& str_object_id,
 218                              int64 version,
 219                              const std::string& payload);
 220
 221   Profile* profile_;
 222   ProfileSyncService* sync_service_;
 223   // The class that handles getting, setting, and persisting sync
 224   // preferences.
 225   scoped_ptr<browser_sync::SyncPrefs> sync_prefs_;
 226
 227   // Java-side ProfileSyncService object.
 228   JavaObjectWeakGlobalRef weak_java_profile_sync_service_;
 229
 230   // The invalidation API spec allows for the possibility of redundant
 231   // invalidations, so keep track of the max versions and drop
 232   // invalidations with old versions.
 233   ObjectIdVersionMap max_invalidation_versions_;
 234
 235   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceAndroid);
 236 };
 237
 238 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_ANDROID_H_