content: /*
   * Copyright (C) 2008 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.android.server.content;
  
  import static com.android.server.content.SyncLogger.logSafe;
  
  import android.accounts.Account;
  import android.accounts.AccountAndUser;
  import android.accounts.AccountManager;
  import android.accounts.AccountManagerInternal;
  import android.annotation.NonNull;
  import android.annotation.Nullable;
  import android.annotation.UserIdInt;
  import android.app.ActivityManager;
  import android.app.AppGlobals;
  import android.app.Notification;
  import android.app.NotificationManager;
  import android.app.PendingIntent;
  import android.app.job.JobInfo;
  import android.app.job.JobScheduler;
  import android.app.usage.UsageStatsManagerInternal;
  import android.content.BroadcastReceiver;
  import android.content.ComponentName;
  import android.content.ContentResolver;
  import android.content.ContentResolver.SyncExemption;
  import android.content.Context;
  import android.content.ISyncAdapter;
  import android.content.ISyncAdapterUnsyncableAccountCallback;
  import android.content.ISyncContext;
  import android.content.Intent;
  import android.content.IntentFilter;
  import android.content.PeriodicSync;
  import android.content.ServiceConnection;
  import android.content.SyncActivityTooManyDeletes;
  import android.content.SyncAdapterType;
  import android.content.SyncAdaptersCache;
  import android.content.SyncInfo;
  import android.content.SyncResult;
  import android.content.SyncStatusInfo;
  import android.content.SyncStatusInfo.Stats;
  import android.content.pm.ApplicationInfo;
  import android.content.pm.PackageInfo;
  import android.content.pm.PackageManager;
  import android.content.pm.PackageManager.NameNotFoundException;
  import android.content.pm.PackageManagerInternal;
  import android.content.pm.ProviderInfo;
  import android.content.pm.RegisteredServicesCache;
  import android.content.pm.RegisteredServicesCacheListener;
  import android.content.pm.ResolveInfo;
  import android.content.pm.UserInfo;
  import android.database.ContentObserver;
  import android.net.ConnectivityManager;
  import android.net.NetworkInfo;
  import android.net.TrafficStats;
  import android.os.BatteryStats;
  import android.os.Binder;
  import android.os.Build;
  import android.os.Bundle;
  import android.os.Handler;
  import android.os.HandlerThread;
  import android.os.IBinder;
  import android.os.Looper;
  import android.os.Message;
  import android.os.PowerManager;
  import android.os.Process;
  import android.os.RemoteCallback;
  import android.os.RemoteException;
  import android.os.ServiceManager;
  import android.os.SystemClock;
  import android.os.SystemProperties;
  import android.os.UserHandle;
  import android.os.UserManager;
  import android.os.WorkSource;
  import android.provider.Settings;
  import android.text.format.Time;
  import android.util.EventLog;
  import android.util.Log;
  import android.util.Pair;
  import android.util.Slog;
  import android.util.SparseBooleanArray;
  
  import com.android.internal.R;
  import com.android.internal.annotations.GuardedBy;
  import com.android.internal.app.IBatteryStats;
  import com.android.internal.messages.nano.SystemMessageProto.SystemMessage;
  import com.android.internal.notification.SystemNotificationChannels;
  import com.android.internal.os.BackgroundThread;
  import com.android.internal.util.ArrayUtils;
  import com.android.internal.util.IndentingPrintWriter;
  import com.android.internal.util.function.QuadConsumer;
  import com.android.server.DeviceIdleController;
  import com.android.server.LocalServices;
  import com.android.server.SystemService;
  import com.android.server.accounts.AccountManagerService;
  import com.android.server.backup.AccountSyncSettingsBackupHelper;
  import com.android.server.content.SyncStorageEngine.AuthorityInfo;
  import com.android.server.content.SyncStorageEngine.EndPoint;
  import com.android.server.content.SyncStorageEngine.OnSyncRequestListener;
  import com.android.server.job.JobSchedulerInternal;
  
  import com.google.android.collect.Lists;
  import com.google.android.collect.Maps;
  
  import java.io.FileDescriptor;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Random;
  import java.util.Set;
  import java.util.function.Function;
  import java.util.function.Predicate;
  
  /**
   * Implementation details:
   * All scheduled syncs will be passed on to JobScheduler as jobs
   * (See {@link #scheduleSyncOperationH(SyncOperation, long)}. This function schedules a job
   * with JobScheduler with appropriate delay and constraints (according to backoffs and extras).
   * The scheduleSyncOperationH function also assigns a unique jobId to each
   * SyncOperation.
   *
   * Periodic Syncs:
   * Each periodic sync is scheduled as a periodic job. If a periodic sync fails, we create a new
   * one off SyncOperation and set its {@link SyncOperation#sourcePeriodicId} field to the jobId of the
   * periodic sync. We don't allow the periodic job to run while any job initiated by it is pending.
   *
   * Backoffs:
   * Each {@link EndPoint} has a backoff associated with it. When a SyncOperation fails, we increase
   * the backoff on the authority. Then we reschedule all syncs associated with that authority to
   * run at a later time. Similarly, when a sync succeeds, backoff is cleared and all associated syncs
   * are rescheduled. A rescheduled sync will get a new jobId.
   *
   * @hide
   */
  public class SyncManager {
      static final String TAG = "SyncManager";
  
      private static final boolean DEBUG_ACCOUNT_ACCESS = false;
  
      // Only do the check on a debuggable build.
      private static final boolean ENABLE_SUSPICIOUS_CHECK = Build.IS_DEBUGGABLE;
  
      /** Delay a sync due to local changes this long. In milliseconds */
      private static final long LOCAL_SYNC_DELAY;
  
      static {
          LOCAL_SYNC_DELAY =
                  SystemProperties.getLong("sync.local_sync_delay", 30 * 1000 /* 30 seconds */);
      }
  
      /**
       * How long to wait before retrying a sync that failed due to one already being in progress.
       */
      private static final int DELAY_RETRY_SYNC_IN_PROGRESS_IN_SECONDS = 10;
  
      /**
       * How often to periodically poll network traffic for an adapter performing a sync to determine
       * whether progress is being made.
       */
      private static final long SYNC_MONITOR_WINDOW_LENGTH_MILLIS = 60 * 1000; // 60 seconds
  
      /**
       * How many bytes must be transferred (Tx + Rx) over the period of time defined by
       * {@link #SYNC_MONITOR_WINDOW_LENGTH_MILLIS} for the sync to be considered to be making
       * progress.
       */
      private static final int SYNC_MONITOR_PROGRESS_THRESHOLD_BYTES = 10; // 10 bytes
  
      /**
       * If a previously scheduled sync becomes ready and we are low on storage, it gets
       * pushed back for this amount of time.
       */
      private static final long SYNC_DELAY_ON_LOW_STORAGE = 60*60*1000;   // 1 hour
  
      /**
       * If a sync becomes ready and it conflicts with an already running sync, it gets
       * pushed back for this amount of time.
       */
      private static final long SYNC_DELAY_ON_CONFLICT = 10*1000; // 10 seconds
  
      /**
       * Generate job ids in the range [MIN_SYNC_JOB_ID, MAX_SYNC_JOB_ID) to avoid conflicts with
       * other jobs scheduled by the system process.
       */
      private static final int MIN_SYNC_JOB_ID = 100000;
      private static final int MAX_SYNC_JOB_ID = 110000;
  
      private static final String SYNC_WAKE_LOCK_PREFIX = "*sync*/";
      private static final String HANDLE_SYNC_ALARM_WAKE_LOCK = "SyncManagerHandleSyncAlarm";
      private static final String SYNC_LOOP_WAKE_LOCK = "SyncLoopWakeLock";
  
  
      private static final int SYNC_OP_STATE_VALID = 0;
      private static final int SYNC_OP_STATE_INVALID = 1;
      private static final int SYNC_OP_STATE_INVALID_NO_ACCOUNT_ACCESS = 2;
  
      /** Flags used when connecting to a sync adapter service */
      private static final int SYNC_ADAPTER_CONNECTION_FLAGS = Context.BIND_AUTO_CREATE
              | Context.BIND_NOT_FOREGROUND | Context.BIND_ALLOW_OOM_MANAGEMENT;
  
      /** Singleton instance. */
      @GuardedBy("SyncManager.class")
      private static SyncManager sInstance;
  
      private Context mContext;
  
      private static final AccountAndUser[] INITIAL_ACCOUNTS_ARRAY = new AccountAndUser[0];
  
      // TODO: add better locking around mRunningAccounts
      private volatile AccountAndUser[] mRunningAccounts = INITIAL_ACCOUNTS_ARRAY;
  
      volatile private PowerManager.WakeLock mSyncManagerWakeLock;
      volatile private boolean mDataConnectionIsConnected = false;
      volatile private boolean mStorageIsLow = false;
      volatile private boolean mDeviceIsIdle = false;
      volatile private boolean mReportedSyncActive = false;
  
      private final NotificationManager mNotificationMgr;
      private final IBatteryStats mBatteryStats;
      private JobScheduler mJobScheduler;
      private JobSchedulerInternal mJobSchedulerInternal;
  
      private SyncStorageEngine mSyncStorageEngine;
  
      protected final ArrayList<ActiveSyncContext> mActiveSyncContexts = Lists.newArrayList();
  
      // Synchronized on "this". Instead of using this directly one should instead call
      // its accessor, getConnManager().
      private ConnectivityManager mConnManagerDoNotUseDirectly;
  
      /** Track whether the device has already been provisioned. */
      private volatile boolean mProvisioned;
  
      protected final SyncAdaptersCache mSyncAdapters;
  
      private final Random mRand;
  
      private final SyncLogger mLogger;
  
      private boolean isJobIdInUseLockedH(int jobId, List<JobInfo> pendingJobs) {
          for (JobInfo job: pendingJobs) {
              if (job.getId() == jobId) {
                  return true;
              }
          }
          for (ActiveSyncContext asc: mActiveSyncContexts) {
              if (asc.mSyncOperation.jobId == jobId) {
                  return true;
              }
          }
          return false;
      }
  
      private int getUnusedJobIdH() {
          int newJobId;
          do {
              newJobId = MIN_SYNC_JOB_ID + mRand.nextInt(MAX_SYNC_JOB_ID - MIN_SYNC_JOB_ID);
          } while (isJobIdInUseLockedH(newJobId,
                  mJobSchedulerInternal.getSystemScheduledPendingJobs()));
          return newJobId;
      }
  
      private List<SyncOperation> getAllPendingSyncs() {
          verifyJobScheduler();
          List<JobInfo> pendingJobs = mJobSchedulerInternal.getSystemScheduledPendingJobs();
          List<SyncOperation> pendingSyncs = new ArrayList<SyncOperation>(pendingJobs.size());
          for (JobInfo job: pendingJobs) {
              SyncOperation op = SyncOperation.maybeCreateFromJobExtras(job.getExtras());
              if (op != null) {
                  pendingSyncs.add(op);
              }
          }
          return pendingSyncs;
      }
  
      private final BroadcastReceiver mStorageIntentReceiver =
              new BroadcastReceiver() {
                  @Override
                  public void onReceive(Context context, Intent intent) {
                      String action = intent.getAction();
                      if (Intent.ACTION_DEVICE_STORAGE_LOW.equals(action)) {
                          if (Log.isLoggable(TAG, Log.VERBOSE)) {
                              Slog.v(TAG, "Internal storage is low.");
                          }
                          mStorageIsLow = true;
                          cancelActiveSync(
                                  SyncStorageEngine.EndPoint.USER_ALL_PROVIDER_ALL_ACCOUNTS_ALL,
                                  null /* any sync */,
                                  "storage low");
                      } else if (Intent.ACTION_DEVICE_STORAGE_OK.equals(action)) {
                          if (Log.isLoggable(TAG, Log.VERBOSE)) {
                              Slog.v(TAG, "Internal storage is ok.");
                          }
                          mStorageIsLow = false;
                          rescheduleSyncs(EndPoint.USER_ALL_PROVIDER_ALL_ACCOUNTS_ALL,
                                  "storage ok");
                      }
                  }
              };
  
      private final BroadcastReceiver mAccountsUpdatedReceiver = new BroadcastReceiver() {
          @Override
          public void onReceive(Context context, Intent intent) {
              EndPoint target = new EndPoint(null, null, getSendingUserId());
              updateRunningAccounts(target /* sync targets for user */);
          }
      };
  
      private final PowerManager mPowerManager;
  
      private final UserManager mUserManager;
  
      private final AccountManager mAccountManager;
  
      private final AccountManagerInternal mAccountManagerInternal;
  
      private final PackageManagerInternal mPackageManagerInternal;
  
      private List<UserInfo> getAllUsers() {
          return mUserManager.getUsers();
      }
  
      private boolean containsAccountAndUser(AccountAndUser[] accounts, Account account, int userId) {
          boolean found = false;
          for (int i = 0; i < accounts.length; i++) {
              if (accounts[i].userId == userId
                      && accounts[i].account.equals(account)) {
                  found = true;
                  break;
              }
          }
          return found;
      }
  
      /** target indicates endpoints that should be synced after account info is updated. */
      private void updateRunningAccounts(EndPoint target) {
          if (Log.isLoggable(TAG, Log.VERBOSE)) Slog.v(TAG, "sending MESSAGE_ACCOUNTS_UPDATED");
          // Update accounts in handler thread.
          Message m = mSyncHandler.obtainMessage(SyncHandler.MESSAGE_ACCOUNTS_UPDATED);
          m.obj = target;
          m.sendToTarget();
      }
  
      private void removeStaleAccounts() {
          for (UserInfo user : mUserManager.getUsers(true)) {
              // Skip any partially created/removed users
              if (user.partial) continue;
              Account[] accountsForUser = AccountManagerService.getSingleton().getAccounts(
                      user.id, mContext.getOpPackageName());
  
              mSyncStorageEngine.removeStaleAccounts(accountsForUser, user.id);
          }
      }
  
      private BroadcastReceiver mConnectivityIntentReceiver =
              new BroadcastReceiver() {
                  @Override
                  public void onReceive(Context context, Intent intent) {
                      final boolean wasConnected = mDataConnectionIsConnected;
  
                      // Don't use the intent to figure out if network is connected, just check
                      // ConnectivityManager directly.
                      mDataConnectionIsConnected = readDataConnectionState();
                      if (mDataConnectionIsConnected) {
                          if (!wasConnected) {
                              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                                  Slog.v(TAG, "Reconnection detected: clearing all backoffs");
                              }
                              // Note the location of this code was wrong from nyc to oc; fixed in DR.
                              clearAllBackoffs("network reconnect");
                          }
                      }
                  }
              };
  
      private void clearAllBackoffs(String why) {
          mSyncStorageEngine.clearAllBackoffsLocked();
          rescheduleSyncs(EndPoint.USER_ALL_PROVIDER_ALL_ACCOUNTS_ALL, why);
      }
  
      private boolean readDataConnectionState() {
          NetworkInfo networkInfo = getConnectivityManager().getActiveNetworkInfo();
          return (networkInfo != null) && networkInfo.isConnected();
      }
  
      private String getJobStats() {
          JobSchedulerInternal js = LocalServices.getService(JobSchedulerInternal.class);
          return "JobStats: "
                  + ((js == null) ? "(JobSchedulerInternal==null)"
                  : js.getPersistStats().toString());
      }
  
      private BroadcastReceiver mShutdownIntentReceiver =
              new BroadcastReceiver() {
                  @Override
                  public void onReceive(Context context, Intent intent) {
                      Log.w(TAG, "Writing sync state before shutdown...");
                      getSyncStorageEngine().writeAllState();
  
                      mLogger.log(getJobStats());
                      mLogger.log("Shutting down.");
                  }
              };
  
      private final BroadcastReceiver mOtherIntentsReceiver =
              new BroadcastReceiver() {
                  @Override
                  public void onReceive(Context context, Intent intent) {
                      if (Intent.ACTION_TIME_CHANGED.equals(intent.getAction())) {
                          mSyncStorageEngine.setClockValid();
                          return;
                      }
                  }
              };
  
      private BroadcastReceiver mUserIntentReceiver = new BroadcastReceiver() {
          @Override
          public void onReceive(Context context, Intent intent) {
              String action = intent.getAction();
              final int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
              if (userId == UserHandle.USER_NULL) return;
  
              if (Intent.ACTION_USER_REMOVED.equals(action)) {
                  onUserRemoved(userId);
              } else if (Intent.ACTION_USER_UNLOCKED.equals(action)) {
                  onUserUnlocked(userId);
              } else if (Intent.ACTION_USER_STOPPED.equals(action)) {
                  onUserStopped(userId);
              }
          }
      };
  
      private final HandlerThread mThread;
      private final SyncHandler mSyncHandler;
      private final SyncManagerConstants mConstants;
  
      @GuardedBy("mUnlockedUsers")
      private final SparseBooleanArray mUnlockedUsers = new SparseBooleanArray();
  
      private ConnectivityManager getConnectivityManager() {
          synchronized (this) {
              if (mConnManagerDoNotUseDirectly == null) {
                  mConnManagerDoNotUseDirectly = (ConnectivityManager)mContext.getSystemService(
                          Context.CONNECTIVITY_SERVICE);
              }
              return mConnManagerDoNotUseDirectly;
          }
      }
  
      /**
       * Cancel all unnecessary jobs. This function will be run once after every boot.
       */
      private void cleanupJobs() {
          // O(n^2) in number of jobs, so we run this on the background thread.
          mSyncHandler.postAtFrontOfQueue(new Runnable() {
              @Override
              public void run() {
                  List<SyncOperation> ops = getAllPendingSyncs();
                  Set<String> cleanedKeys = new HashSet<String>();
                  for (SyncOperation opx: ops) {
                      if (cleanedKeys.contains(opx.key)) {
                          continue;
                      }
                      cleanedKeys.add(opx.key);
                      for (SyncOperation opy: ops) {
                          if (opx == opy) {
                              continue;
                          }
                          if (opx.key.equals(opy.key)) {
                              mLogger.log("Removing duplicate sync: ", opy);
                              cancelJob(opy, "cleanupJobs() x=" + opx + " y=" + opy);
                          }
                      }
                  }
              }
          });
      }
  
      private synchronized void verifyJobScheduler() {
          if (mJobScheduler != null) {
              return;
          }
          final long token = Binder.clearCallingIdentity();
          try {
              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                  Log.d(TAG, "initializing JobScheduler object.");
              }
              mJobScheduler = (JobScheduler) mContext.getSystemService(
                      Context.JOB_SCHEDULER_SERVICE);
              mJobSchedulerInternal = LocalServices.getService(JobSchedulerInternal.class);
              // Get all persisted syncs from JobScheduler
              List<JobInfo> pendingJobs = mJobScheduler.getAllPendingJobs();
  
              int numPersistedPeriodicSyncs = 0;
              int numPersistedOneshotSyncs = 0;
              for (JobInfo job : pendingJobs) {
                  SyncOperation op = SyncOperation.maybeCreateFromJobExtras(job.getExtras());
                  if (op != null) {
                      if (op.isPeriodic) {
                          numPersistedPeriodicSyncs++;
                      } else {
                          numPersistedOneshotSyncs++;
                          // Set the pending status of this EndPoint to true. Pending icon is
                          // shown on the settings activity.
                          mSyncStorageEngine.markPending(op.target, true);
                      }
                  }
              }
              final String summary = "Loaded persisted syncs: "
                      + numPersistedPeriodicSyncs + " periodic syncs, "
                      + numPersistedOneshotSyncs + " oneshot syncs, "
                      + (pendingJobs.size()) + " total system server jobs, "
                      + getJobStats();
              Slog.i(TAG, summary);
              mLogger.log(summary);
  
              cleanupJobs();
  
              if (ENABLE_SUSPICIOUS_CHECK &&
                      (numPersistedPeriodicSyncs == 0) && likelyHasPeriodicSyncs()) {
                  Slog.wtf(TAG, "Device booted with no persisted periodic syncs: " + summary);
              }
          } finally {
              Binder.restoreCallingIdentity(token);
          }
      }
  
      /**
       * @return whether the device most likely has some periodic syncs.
       */
      private boolean likelyHasPeriodicSyncs() {
          try {
              // Each sync adapter has a daily periodic sync by default, but sync adapters can remove
              // them by themselves. So here, we use an arbitrary threshold. If there are more than
              // this many sync endpoints, surely one of them should have a periodic sync...
              return mSyncStorageEngine.getAuthorityCount() >= 6;
          } catch (Throwable th) {
              // Just in case.
          }
          return false;
      }
  
      private JobScheduler getJobScheduler() {
          verifyJobScheduler();
          return mJobScheduler;
      }
  
      public SyncManager(Context context, boolean factoryTest) {
          synchronized (SyncManager.class) {
              if (sInstance == null) {
                  sInstance = this;
              } else {
                  Slog.wtf(TAG, "SyncManager instantiated multiple times");
              }
          }
  
          // Initialize the SyncStorageEngine first, before registering observers
          // and creating threads and so on; it may fail if the disk is full.
          mContext = context;
  
          mLogger = SyncLogger.getInstance();
  
          SyncStorageEngine.init(context, BackgroundThread.get().getLooper());
          mSyncStorageEngine = SyncStorageEngine.getSingleton();
          mSyncStorageEngine.setOnSyncRequestListener(new OnSyncRequestListener() {
              @Override
              public void onSyncRequest(SyncStorageEngine.EndPoint info, int reason, Bundle extras,
                      @SyncExemption int syncExemptionFlag, int callingUid, int callingPid) {
                  scheduleSync(info.account, info.userId, reason, info.provider, extras,
                          AuthorityInfo.UNDEFINED, syncExemptionFlag, callingUid, callingPid, null);
              }
          });
  
          mSyncStorageEngine.setPeriodicSyncAddedListener(
                  new SyncStorageEngine.PeriodicSyncAddedListener() {
                      @Override
                      public void onPeriodicSyncAdded(EndPoint target, Bundle extras, long pollFrequency,
                              long flex) {
                          updateOrAddPeriodicSync(target, pollFrequency, flex, extras);
                      }
                  });
  
          mSyncStorageEngine.setOnAuthorityRemovedListener(new SyncStorageEngine.OnAuthorityRemovedListener() {
              @Override
              public void onAuthorityRemoved(EndPoint removedAuthority) {
                  removeSyncsForAuthority(removedAuthority, "onAuthorityRemoved");
              }
          });
  
          mSyncAdapters = new SyncAdaptersCache(mContext);
  
          mThread = new HandlerThread("SyncManager", android.os.Process.THREAD_PRIORITY_BACKGROUND);
          mThread.start();
          mSyncHandler = new SyncHandler(mThread.getLooper());
  
          mSyncAdapters.setListener(new RegisteredServicesCacheListener<SyncAdapterType>() {
              @Override
              public void onServiceChanged(SyncAdapterType type, int userId, boolean removed) {
                  if (!removed) {
                      scheduleSync(null, UserHandle.USER_ALL,
                              SyncOperation.REASON_SERVICE_CHANGED,
                              type.authority, null, AuthorityInfo.UNDEFINED,
                              ContentResolver.SYNC_EXEMPTION_NONE,
                              Process.myUid(), -1, null);
                  }
              }
          }, mSyncHandler);
  
          mRand = new Random(System.currentTimeMillis());
          mConstants = new SyncManagerConstants(context);
  
          IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
          context.registerReceiver(mConnectivityIntentReceiver, intentFilter);
  
          intentFilter = new IntentFilter(Intent.ACTION_DEVICE_STORAGE_LOW);
          intentFilter.addAction(Intent.ACTION_DEVICE_STORAGE_OK);
          context.registerReceiver(mStorageIntentReceiver, intentFilter);
  
          intentFilter = new IntentFilter(Intent.ACTION_SHUTDOWN);
          intentFilter.setPriority(100);
          context.registerReceiver(mShutdownIntentReceiver, intentFilter);
  
          intentFilter = new IntentFilter();
          intentFilter.addAction(Intent.ACTION_USER_REMOVED);
          intentFilter.addAction(Intent.ACTION_USER_UNLOCKED);
          intentFilter.addAction(Intent.ACTION_USER_STOPPED);
          mContext.registerReceiverAsUser(
                  mUserIntentReceiver, UserHandle.ALL, intentFilter, null, null);
  
          intentFilter = new IntentFilter(Intent.ACTION_TIME_CHANGED);
          context.registerReceiver(mOtherIntentsReceiver, intentFilter);
  
          if (!factoryTest) {
              mNotificationMgr = (NotificationManager)
                      context.getSystemService(Context.NOTIFICATION_SERVICE);
          } else {
              mNotificationMgr = null;
          }
          mPowerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
          mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
          mAccountManager = (AccountManager) mContext.getSystemService(Context.ACCOUNT_SERVICE);
          mAccountManagerInternal = LocalServices.getService(AccountManagerInternal.class);
          mPackageManagerInternal = LocalServices.getService(PackageManagerInternal.class);
  
          mAccountManagerInternal.addOnAppPermissionChangeListener((Account account, int uid) -> {
              // If the UID gained access to the account kick-off syncs lacking account access
              if (mAccountManagerInternal.hasAccountAccess(account, uid)) {
                  scheduleSync(account, UserHandle.getUserId(uid),
                          SyncOperation.REASON_ACCOUNTS_UPDATED,
                          null, null, AuthorityInfo.SYNCABLE_NO_ACCOUNT_ACCESS,
                          ContentResolver.SYNC_EXEMPTION_NONE,
                          Process.myUid(), -2, null);
              }
          });
  
          mBatteryStats = IBatteryStats.Stub.asInterface(ServiceManager.getService(
                  BatteryStats.SERVICE_NAME));
  
          // This WakeLock is used to ensure that we stay awake while running the sync loop
          // message handler. Normally we will hold a sync adapter wake lock while it is being
          // synced but during the execution of the sync loop it might finish a sync for
          // one sync adapter before starting the sync for the other sync adapter and we
          // don't want the device to go to sleep during that window.
          mSyncManagerWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
                  SYNC_LOOP_WAKE_LOCK);
          mSyncManagerWakeLock.setReferenceCounted(false);
  
          mProvisioned = isDeviceProvisioned();
          if (!mProvisioned) {
              final ContentResolver resolver = context.getContentResolver();
              ContentObserver provisionedObserver =
                      new ContentObserver(null /* current thread */) {
                          public void onChange(boolean selfChange) {
                              mProvisioned |= isDeviceProvisioned();
                              if (mProvisioned) {
                                  resolver.unregisterContentObserver(this);
                              }
                          }
                      };
  
              synchronized (mSyncHandler) {
                  resolver.registerContentObserver(
                          Settings.Global.getUriFor(Settings.Global.DEVICE_PROVISIONED),
                          false /* notifyForDescendents */,
                          provisionedObserver);
  
                  // The device *may* have been provisioned while we were registering above observer.
                  // Check again to make sure.
                  mProvisioned |= isDeviceProvisioned();
                  if (mProvisioned) {
                      resolver.unregisterContentObserver(provisionedObserver);
                  }
              }
          }
  
          if (!factoryTest) {
              // Register for account list updates for all users
              mContext.registerReceiverAsUser(mAccountsUpdatedReceiver,
                      UserHandle.ALL,
                      new IntentFilter(AccountManager.LOGIN_ACCOUNTS_CHANGED_ACTION),
                      null, null);
          }
  
          // Sync adapters were able to access the synced account without the accounts
          // permission which circumvents our permission model. Therefore, we require
          // sync adapters that don't have access to the account to get user consent.
          // This can be noisy, therefore we will white-list sync adapters installed
          // before we started checking for account access because they already know
          // the account (they run before) which is the genie is out of the bottle.
          whiteListExistingSyncAdaptersIfNeeded();
  
          mLogger.log("Sync manager initialized: " + Build.FINGERPRINT);
      }
  
      public void onStartUser(int userId) {
          // Log on the handler to avoid slowing down device boot.
          mSyncHandler.post(() -> mLogger.log("onStartUser: user=", userId));
      }
  
      public void onUnlockUser(int userId) {
          synchronized (mUnlockedUsers) {
              mUnlockedUsers.put(userId, true);
          }
          // Log on the handler to avoid slowing down device boot.
          mSyncHandler.post(() -> mLogger.log("onUnlockUser: user=", userId));
      }
  
      public void onStopUser(int userId) {
          synchronized (mUnlockedUsers) {
              mUnlockedUsers.put(userId, false);
          }
          // Log on the handler to avoid slowing down user switch.
          mSyncHandler.post(() -> mLogger.log("onStopUser: user=", userId));
      }
  
      private boolean isUserUnlocked(int userId) {
          synchronized (mUnlockedUsers) {
              return mUnlockedUsers.get(userId);
          }
      }
  
      public void onBootPhase(int phase) {
          // Note SyncManager only receives PHASE_ACTIVITY_MANAGER_READY and after.
          switch (phase) {
              case SystemService.PHASE_ACTIVITY_MANAGER_READY:
                  mConstants.start();
                  break;
          }
      }
  
      private void whiteListExistingSyncAdaptersIfNeeded() {
          if (!mSyncStorageEngine.shouldGrantSyncAdaptersAccountAccess()) {
              return;
          }
          List<UserInfo> users = mUserManager.getUsers(true);
          final int userCount = users.size();
          for (int i = 0; i < userCount; i++) {
              UserHandle userHandle = users.get(i).getUserHandle();
              final int userId = userHandle.getIdentifier();
              for (RegisteredServicesCache.ServiceInfo<SyncAdapterType> service
                      : mSyncAdapters.getAllServices(userId)) {
                  String packageName = service.componentName.getPackageName();
                  for (Account account : mAccountManager.getAccountsByTypeAsUser(
                          service.type.accountType, userHandle)) {
                      if (!canAccessAccount(account, packageName, userId)) {
                          mAccountManager.updateAppPermission(account,
                                  AccountManager.ACCOUNT_ACCESS_TOKEN_TYPE, service.uid, true);
                      }
                  }
              }
          }
      }
  
      private boolean isDeviceProvisioned() {
          final ContentResolver resolver = mContext.getContentResolver();
          return (Settings.Global.getInt(resolver, Settings.Global.DEVICE_PROVISIONED, 0) != 0);
      }
      /**
       * Return a random value v that satisfies minValue <= v < maxValue. The difference between
       * maxValue and minValue must be less than Integer.MAX_VALUE.
       */
      private long jitterize(long minValue, long maxValue) {
          Random random = new Random(SystemClock.elapsedRealtime());
          long spread = maxValue - minValue;
          if (spread > Integer.MAX_VALUE) {
              throw new IllegalArgumentException("the difference between the maxValue and the "
                      + "minValue must be less than " + Integer.MAX_VALUE);
          }
          return minValue + random.nextInt((int)spread);
      }
  
      public SyncStorageEngine getSyncStorageEngine() {
          return mSyncStorageEngine;
      }
  
      private int getIsSyncable(Account account, int userId, String providerName) {
          int isSyncable = mSyncStorageEngine.getIsSyncable(account, userId, providerName);
          UserInfo userInfo = UserManager.get(mContext).getUserInfo(userId);
  
          // If it's not a restricted user, return isSyncable.
          if (userInfo == null || !userInfo.isRestricted()) return isSyncable;
  
          // Else check if the sync adapter has opted-in or not.
          RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo =
                  mSyncAdapters.getServiceInfo(
                          SyncAdapterType.newKey(providerName, account.type), userId);
          if (syncAdapterInfo == null) return AuthorityInfo.NOT_SYNCABLE;
  
          PackageInfo pInfo = null;
          try {
              pInfo = AppGlobals.getPackageManager().getPackageInfo(
                      syncAdapterInfo.componentName.getPackageName(), 0, userId);
              if (pInfo == null) return AuthorityInfo.NOT_SYNCABLE;
          } catch (RemoteException re) {
              // Shouldn't happen.
              return AuthorityInfo.NOT_SYNCABLE;
          }
          if (pInfo.restrictedAccountType != null
                  && pInfo.restrictedAccountType.equals(account.type)) {
              return isSyncable;
          } else {
              return AuthorityInfo.NOT_SYNCABLE;
          }
      }
  
      private void setAuthorityPendingState(EndPoint info) {
          List<SyncOperation> ops = getAllPendingSyncs();
          for (SyncOperation op: ops) {
              if (!op.isPeriodic && op.target.matchesSpec(info)) {
                  getSyncStorageEngine().markPending(info, true);
                  return;
              }
          }
          getSyncStorageEngine().markPending(info, false);
      }
  
      /**
       * Initiate a sync. This can start a sync for all providers
       * (pass null to url, set onlyTicklable to false), only those
       * providers that are marked as ticklable (pass null to url,
       * set onlyTicklable to true), or a specific provider (set url
       * to the content url of the provider).
       *
       * <p>If the ContentResolver.SYNC_EXTRAS_UPLOAD boolean in extras is
       * true then initiate a sync that just checks for local changes to send
       * to the server, otherwise initiate a sync that first gets any
       * changes from the server before sending local changes back to
       * the server.
       *
       * <p>If a specific provider is being synced (the url is non-null)
       * then the extras can contain SyncAdapter-specific information
       * to control what gets synced (e.g. which specific feed to sync).
       *
       * <p>You'll start getting callbacks after this.
       *
       * @param requestedAccount the account to sync, may be null to signify all accounts
       * @param userId the id of the user whose accounts are to be synced. If userId is USER_ALL,
       *          then all users' accounts are considered.
       * @param reason for sync request. If this is a positive integer, it is the Linux uid
       * assigned to the process that requested the sync. If it's negative, the sync was requested by
       * the SyncManager itself and could be one of the following:
       *      {@link SyncOperation#REASON_BACKGROUND_DATA_SETTINGS_CHANGED}
       *      {@link SyncOperation#REASON_ACCOUNTS_UPDATED}
       *      {@link SyncOperation#REASON_SERVICE_CHANGED}
       *      {@link SyncOperation#REASON_PERIODIC}
       *      {@link SyncOperation#REASON_IS_SYNCABLE}
       *      {@link SyncOperation#REASON_SYNC_AUTO}
       *      {@link SyncOperation#REASON_MASTER_SYNC_AUTO}
       *      {@link SyncOperation#REASON_USER_START}
       * @param requestedAuthority the authority to sync, may be null to indicate all authorities
       * @param extras a Map of SyncAdapter-specific information to control
       *          syncs of a specific provider. Can be null. Is ignored
       *          if the url is null.
       * @param targetSyncState Only sync authorities that have the specified sync state.
       *           Use {@link AuthorityInfo#UNDEFINED} to sync all authorities.
       */
      public void scheduleSync(Account requestedAccount, int userId, int reason,
              String requestedAuthority, Bundle extras, int targetSyncState,
              @SyncExemption int syncExemptionFlag, int callingUid, int callingPid,
              String callingPackage) {
          scheduleSync(requestedAccount, userId, reason, requestedAuthority, extras, targetSyncState,
                  0 /* min delay */, true /* checkIfAccountReady */, syncExemptionFlag,
                  callingUid, callingPid, callingPackage);
      }
  
      /**
       * @param minDelayMillis The sync can't land before this delay expires.
       */
      private void scheduleSync(Account requestedAccount, int userId, int reason,
              String requestedAuthority, Bundle extras, int targetSyncState,
              final long minDelayMillis, boolean checkIfAccountReady,
              @SyncExemption int syncExemptionFlag,
              int callingUid, int callingPid, String callingPackage) {
          if (extras == null) {
              extras = new Bundle();
          }
          extras.size(); // Force unpacel.
          if (Log.isLoggable(TAG, Log.VERBOSE)) {
              mLogger.log("scheduleSync: account=", requestedAccount,
                      " u", userId,
                      " authority=", requestedAuthority,
                      " reason=", reason,
                      " extras=", extras,
                      " cuid=", callingUid, " cpid=", callingPid, " cpkg=", callingPackage,
                      " mdm=", minDelayMillis,
                      " ciar=", checkIfAccountReady,
                      " sef=", syncExemptionFlag);
          }
  
          AccountAndUser[] accounts = null;
          if (requestedAccount != null) {
              if (userId != UserHandle.USER_ALL) {
                  accounts = new AccountAndUser[]{new AccountAndUser(requestedAccount, userId)};
              } else {
                  for (AccountAndUser runningAccount : mRunningAccounts) {
                      if (requestedAccount.equals(runningAccount.account)) {
                          accounts = ArrayUtils.appendElement(AccountAndUser.class,
                                  accounts, runningAccount);
                      }
                  }
              }
          } else {
              accounts = mRunningAccounts;
          }
  
          if (ArrayUtils.isEmpty(accounts)) {
              mLogger.log("scheduleSync: no accounts configured, dropping");
              return;
          }
  
          final boolean uploadOnly = extras.getBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, false);
          final boolean manualSync = extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false);
          if (manualSync) {
              extras.putBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, true);
              extras.putBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS, true);
          }
          final boolean ignoreSettings =
                  extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS, false);
  
          int source;
          if (uploadOnly) {
              source = SyncStorageEngine.SOURCE_LOCAL;
          } else if (manualSync) {
              source = SyncStorageEngine.SOURCE_USER;
          } else if (requestedAuthority == null) {
              source = SyncStorageEngine.SOURCE_POLL;
          } else {
              if (extras.containsKey("feed")) {
                  source = SyncStorageEngine.SOURCE_FEED;
              } else{
                  // This isn't strictly server, since arbitrary callers can (and do) request
                  // a non-forced two-way sync on a specific url.
                  source = SyncStorageEngine.SOURCE_OTHER;
              }
          }
  
          for (AccountAndUser account : accounts) {
              // If userId is specified, do not sync accounts of other users
              if (userId >= UserHandle.USER_SYSTEM && account.userId >= UserHandle.USER_SYSTEM
                      && userId != account.userId) {
                  continue;
              }
              // Compile a list of authorities that have sync adapters.
              // For each authority sync each account that matches a sync adapter.
              final HashSet<String> syncableAuthorities = new HashSet<String>();
              for (RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapter :
                      mSyncAdapters.getAllServices(account.userId)) {
                  syncableAuthorities.add(syncAdapter.type.authority);
              }
  
              // If the url was specified then replace the list of authorities
              // with just this authority or clear it if this authority isn't
              // syncable.
              if (requestedAuthority != null) {
                  final boolean hasSyncAdapter = syncableAuthorities.contains(requestedAuthority);
                  syncableAuthorities.clear();
                  if (hasSyncAdapter) syncableAuthorities.add(requestedAuthority);
              }
  
              for (String authority : syncableAuthorities) {
                  int isSyncable = computeSyncable(account.account, account.userId, authority,
                          !checkIfAccountReady);
  
                  if (isSyncable == AuthorityInfo.NOT_SYNCABLE) {
                      continue;
                  }
  
                  final RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo =
                          mSyncAdapters.getServiceInfo(SyncAdapterType.newKey(authority,
                                  account.account.type), account.userId);
                  if (syncAdapterInfo == null) {
                      continue;
                  }
  
                  final int owningUid = syncAdapterInfo.uid;
  
                  if (isSyncable == AuthorityInfo.SYNCABLE_NO_ACCOUNT_ACCESS) {
                      mLogger.log("scheduleSync: Not scheduling sync operation: "
                                  + "isSyncable == SYNCABLE_NO_ACCOUNT_ACCESS");
                      Bundle finalExtras = new Bundle(extras);
                      String packageName = syncAdapterInfo.componentName.getPackageName();
                      // If the app did not run and has no account access, done
                      if (!wasPackageEverLaunched(packageName, userId)) {
                          continue;
                      }
                      mAccountManagerInternal.requestAccountAccess(account.account,
                              packageName, userId,
                              new RemoteCallback((Bundle result) -> {
                                  if (result != null
                                          && result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT)) {
                                      scheduleSync(account.account, userId, reason, authority,
                                              finalExtras, targetSyncState, minDelayMillis,
                                              true /* checkIfAccountReady */,
                                              syncExemptionFlag, callingUid, callingPid,
                                              callingPackage);
                                  }
                              }
                          ));
                      continue;
                  }
  
                  final boolean allowParallelSyncs = syncAdapterInfo.type.allowParallelSyncs();
                  final boolean isAlwaysSyncable = syncAdapterInfo.type.isAlwaysSyncable();
                  if (!checkIfAccountReady && isSyncable < 0 && isAlwaysSyncable) {
                      mSyncStorageEngine.setIsSyncable(
                              account.account, account.userId, authority, AuthorityInfo.SYNCABLE,
                              callingUid, callingPid);
                      isSyncable = AuthorityInfo.SYNCABLE;
                  }
  
                  if (targetSyncState != AuthorityInfo.UNDEFINED && targetSyncState != isSyncable) {
                      continue;
                  }
  
                  if (!syncAdapterInfo.type.supportsUploading() && uploadOnly) {
                      continue;
                  }
  
                  boolean syncAllowed =
                          (isSyncable < 0) // Always allow if the isSyncable state is unknown.
                                  || ignoreSettings
                                  || (mSyncStorageEngine.getMasterSyncAutomatically(account.userId)
                                  && mSyncStorageEngine.getSyncAutomatically(account.account,
                                  account.userId, authority));
                  if (!syncAllowed) {
                      mLogger.log("scheduleSync: sync of ", account, " ", authority,
                              " is not allowed, dropping request");
                      continue;
                  }
                  SyncStorageEngine.EndPoint info =
                          new SyncStorageEngine.EndPoint(
                                  account.account, authority, account.userId);
                  long delayUntil =
                          mSyncStorageEngine.getDelayUntilTime(info);
  
                  final String owningPackage = syncAdapterInfo.componentName.getPackageName();
  
                  if (isSyncable == AuthorityInfo.NOT_INITIALIZED) {
                      if (checkIfAccountReady) {
                          Bundle finalExtras = new Bundle(extras);
  
                          sendOnUnsyncableAccount(mContext, syncAdapterInfo, account.userId,
                                  () -> scheduleSync(account.account, account.userId, reason,
                                          authority, finalExtras, targetSyncState, minDelayMillis,
                                          false, syncExemptionFlag, callingUid, callingPid,
                                          callingPackage));
                      } else {
                          // Initialisation sync.
                          Bundle newExtras = new Bundle();
                          newExtras.putBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, true);
  
                          mLogger.log("scheduleSync: schedule initialisation sync ",
                                  account, " ", authority);
  
                          postScheduleSyncMessage(
                                  new SyncOperation(account.account, account.userId,
                                          owningUid, owningPackage, reason, source,
                                          authority, newExtras, allowParallelSyncs,
                                          syncExemptionFlag),
                                  minDelayMillis
                          );
                      }
                  } else if (targetSyncState == AuthorityInfo.UNDEFINED
                          || targetSyncState == isSyncable) {
                      mLogger.log("scheduleSync: scheduling sync ",
                              account, " ", authority);
                      postScheduleSyncMessage(
                              new SyncOperation(account.account, account.userId,
                                      owningUid, owningPackage, reason, source,
                                      authority, extras, allowParallelSyncs, syncExemptionFlag),
                              minDelayMillis
                      );
                  } else {
                      mLogger.log("scheduleSync: not handling ",
                              account, " ", authority);
                  }
              }
          }
      }
  
      public int computeSyncable(Account account, int userId, String authority,
              boolean checkAccountAccess) {
          final int status = getIsSyncable(account, userId, authority);
          if (status == AuthorityInfo.NOT_SYNCABLE) {
              return AuthorityInfo.NOT_SYNCABLE;
          }
          final SyncAdapterType type = SyncAdapterType.newKey(authority, account.type);
          final RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo =
                  mSyncAdapters.getServiceInfo(type, userId);
          if (syncAdapterInfo == null) {
              return AuthorityInfo.NOT_SYNCABLE;
          }
          final int owningUid = syncAdapterInfo.uid;
          final String owningPackage = syncAdapterInfo.componentName.getPackageName();
          try {
              if (ActivityManager.getService().isAppStartModeDisabled(owningUid, owningPackage)) {
                  Slog.w(TAG, "Not scheduling job " + syncAdapterInfo.uid + ":"
                          + syncAdapterInfo.componentName
                          + " -- package not allowed to start");
                  return AuthorityInfo.NOT_SYNCABLE;
              }
          } catch (RemoteException e) {
              /* ignore - local call */
          }
          if (checkAccountAccess && !canAccessAccount(account, owningPackage, owningUid)) {
              Log.w(TAG, "Access to " + logSafe(account) + " denied for package "
                      + owningPackage + " in UID " + syncAdapterInfo.uid);
              return AuthorityInfo.SYNCABLE_NO_ACCOUNT_ACCESS;
          }
  
          return status;
      }
  
      private boolean canAccessAccount(Account account, String packageName, int uid) {
          if (mAccountManager.hasAccountAccess(account, packageName,
                  UserHandle.getUserHandleForUid(uid))) {
              return true;
          }
          // We relax the account access rule to also include the system apps as
          // they are trusted and we want to minimize the cases where the user
          // involvement is required to grant access to the synced account.
          try {
              mContext.getPackageManager().getApplicationInfoAsUser(packageName,
                      PackageManager.MATCH_SYSTEM_ONLY, UserHandle.getUserId(uid));
              return true;
          } catch (NameNotFoundException e) {
              return false;
          }
      }
  
      private void removeSyncsForAuthority(EndPoint info, String why) {
          mLogger.log("removeSyncsForAuthority: ", info, why);
          verifyJobScheduler();
          List<SyncOperation> ops = getAllPendingSyncs();
          for (SyncOperation op: ops) {
              if (op.target.matchesSpec(info)) {
                  mLogger.log("canceling: ", op);
                  cancelJob(op, why);
              }
          }
      }
  
      /**
       * Remove a specific periodic sync identified by its target and extras.
       */
      public void removePeriodicSync(EndPoint target, Bundle extras, String why) {
          Message m = mSyncHandler.obtainMessage(mSyncHandler.MESSAGE_REMOVE_PERIODIC_SYNC,
                  Pair.create(target, why));
          m.setData(extras);
          m.sendToTarget();
      }
  
      /**
       * Add a periodic sync. If a sync with same target and extras exists, its period and
       * flexMillis will be updated.
       */
      public void updateOrAddPeriodicSync(EndPoint target, long pollFrequency, long flex,
              Bundle extras) {
          UpdatePeriodicSyncMessagePayload payload = new UpdatePeriodicSyncMessagePayload(target,
                  pollFrequency, flex, extras);
          mSyncHandler.obtainMessage(SyncHandler.MESSAGE_UPDATE_PERIODIC_SYNC, payload)
                  .sendToTarget();
      }
  
      /**
       * Get a list of periodic syncs corresponding to the given target.
       */
      public List<PeriodicSync> getPeriodicSyncs(EndPoint target) {
          List<SyncOperation> ops = getAllPendingSyncs();
          List<PeriodicSync> periodicSyncs = new ArrayList<PeriodicSync>();
  
          for (SyncOperation op: ops) {
              if (op.isPeriodic && op.target.matchesSpec(target)) {
                  periodicSyncs.add(new PeriodicSync(op.target.account, op.target.provider,
                          op.extras, op.periodMillis / 1000, op.flexMillis / 1000));
              }
          }
  
          return periodicSyncs;
      }
  
      /**
       * Schedule sync based on local changes to a provider. We wait for at least LOCAL_SYNC_DELAY
       * ms to batch syncs.
       */
      public void scheduleLocalSync(Account account, int userId, int reason, String authority,
              @SyncExemption int syncExemptionFlag,
              int callingUid, int callingPid, String callingPackage) {
          final Bundle extras = new Bundle();
          extras.putBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, true);
          scheduleSync(account, userId, reason, authority, extras,
                  AuthorityInfo.UNDEFINED, LOCAL_SYNC_DELAY, true /* checkIfAccountReady */,
                  syncExemptionFlag, callingUid, callingPid, callingPackage);
      }
  
      public SyncAdapterType[] getSyncAdapterTypes(int userId) {
          final Collection<RegisteredServicesCache.ServiceInfo<SyncAdapterType>> serviceInfos;
          serviceInfos = mSyncAdapters.getAllServices(userId);
          SyncAdapterType[] types = new SyncAdapterType[serviceInfos.size()];
          int i = 0;
          for (RegisteredServicesCache.ServiceInfo<SyncAdapterType> serviceInfo : serviceInfos) {
              types[i] = serviceInfo.type;
              ++i;
          }
          return types;
      }
  
      public String[] getSyncAdapterPackagesForAuthorityAsUser(String authority, int userId) {
          return mSyncAdapters.getSyncAdapterPackagesForAuthority(authority, userId);
      }
  
      private void sendSyncFinishedOrCanceledMessage(ActiveSyncContext syncContext,
              SyncResult syncResult) {
          if (Log.isLoggable(TAG, Log.VERBOSE)) Slog.v(TAG, "sending MESSAGE_SYNC_FINISHED");
          Message msg = mSyncHandler.obtainMessage();
          msg.what = SyncHandler.MESSAGE_SYNC_FINISHED;
          msg.obj = new SyncFinishedOrCancelledMessagePayload(syncContext, syncResult);
          mSyncHandler.sendMessage(msg);
      }
  
      private void sendCancelSyncsMessage(final SyncStorageEngine.EndPoint info, Bundle extras,
              String why) {
          if (Log.isLoggable(TAG, Log.VERBOSE)) Slog.v(TAG, "sending MESSAGE_CANCEL");
  
          mLogger.log("sendCancelSyncsMessage() ep=", info, " why=", why);
  
          Message msg = mSyncHandler.obtainMessage();
          msg.what = SyncHandler.MESSAGE_CANCEL;
          msg.setData(extras);
          msg.obj = info;
          mSyncHandler.sendMessage(msg);
      }
  
      /**
       * Post a delayed message that will monitor the given sync context by periodically checking how
       * much network has been used by the uid.
       */
      private void postMonitorSyncProgressMessage(ActiveSyncContext activeSyncContext) {
          if (Log.isLoggable(TAG, Log.VERBOSE)) {
              Slog.v(TAG, "posting MESSAGE_SYNC_MONITOR in " +
                      (SYNC_MONITOR_WINDOW_LENGTH_MILLIS/1000) + "s");
          }
  
          activeSyncContext.mBytesTransferredAtLastPoll =
                  getTotalBytesTransferredByUid(activeSyncContext.mSyncAdapterUid);
          activeSyncContext.mLastPolledTimeElapsed = SystemClock.elapsedRealtime();
          Message monitorMessage =
                  mSyncHandler.obtainMessage(
                          SyncHandler.MESSAGE_MONITOR_SYNC,
                          activeSyncContext);
          mSyncHandler.sendMessageDelayed(monitorMessage, SYNC_MONITOR_WINDOW_LENGTH_MILLIS);
      }
  
      private void postScheduleSyncMessage(SyncOperation syncOperation, long minDelayMillis) {
          ScheduleSyncMessagePayload payload =
                  new ScheduleSyncMessagePayload(syncOperation, minDelayMillis);
          mSyncHandler.obtainMessage(mSyncHandler.MESSAGE_SCHEDULE_SYNC, payload).sendToTarget();
      }
  
      /**
       * Monitor sync progress by calculating how many bytes it is managing to send to and fro.
       */
      private long getTotalBytesTransferredByUid(int uid) {
          return (TrafficStats.getUidRxBytes(uid) + TrafficStats.getUidTxBytes(uid));
      }
  
      /**
       * Convenience class for passing parameters for a finished or cancelled sync to the handler
       * to be processed.
       */
      private class SyncFinishedOrCancelledMessagePayload {
          public final ActiveSyncContext activeSyncContext;
          public final SyncResult syncResult;
  
          SyncFinishedOrCancelledMessagePayload(ActiveSyncContext syncContext,
                  SyncResult syncResult) {
              this.activeSyncContext = syncContext;
              this.syncResult = syncResult;
          }
      }
  
      private class UpdatePeriodicSyncMessagePayload {
          public final EndPoint target;
          public final long pollFrequency;
          public final long flex;
          public final Bundle extras;
  
          UpdatePeriodicSyncMessagePayload(EndPoint target, long pollFrequency, long flex,
                  Bundle extras) {
              this.target = target;
              this.pollFrequency = pollFrequency;
              this.flex = flex;
              this.extras = extras;
          }
      }
  
      private static class ScheduleSyncMessagePayload {
          final SyncOperation syncOperation;
          final long minDelayMillis;
  
          ScheduleSyncMessagePayload(SyncOperation syncOperation, long minDelayMillis) {
              this.syncOperation = syncOperation;
              this.minDelayMillis = minDelayMillis;
          }
      }
  
      private void clearBackoffSetting(EndPoint target, String why) {
          Pair<Long, Long> backoff = mSyncStorageEngine.getBackoff(target);
          if (backoff != null && backoff.first == SyncStorageEngine.NOT_IN_BACKOFF_MODE &&
                  backoff.second == SyncStorageEngine.NOT_IN_BACKOFF_MODE) {
              return;
          }
          if (Log.isLoggable(TAG, Log.VERBOSE)) {
              Slog.v(TAG, "Clearing backoffs for " + target);
          }
          mSyncStorageEngine.setBackoff(target,
                  SyncStorageEngine.NOT_IN_BACKOFF_MODE,
                  SyncStorageEngine.NOT_IN_BACKOFF_MODE);
  
          rescheduleSyncs(target, why);
      }
  
      private void increaseBackoffSetting(EndPoint target) {
          final long now = SystemClock.elapsedRealtime();
  
          final Pair<Long, Long> previousSettings =
                  mSyncStorageEngine.getBackoff(target);
          long newDelayInMs = -1;
          if (previousSettings != null) {
              // Don't increase backoff before current backoff is expired. This will happen for op's
              // with ignoreBackoff set.
              if (now < previousSettings.first) {
                  if (Log.isLoggable(TAG, Log.VERBOSE)) {
                      Slog.v(TAG, "Still in backoff, do not increase it. "
                              + "Remaining: " + ((previousSettings.first - now) / 1000) + " seconds.");
                  }
                  return;
              }
              // Subsequent delays are the double of the previous delay.
              newDelayInMs =
                      (long) (previousSettings.second * mConstants.getRetryTimeIncreaseFactor());
          }
          if (newDelayInMs <= 0) {
              // The initial delay is the jitterized INITIAL_SYNC_RETRY_TIME_IN_MS.
              final long initialRetryMs = mConstants.getInitialSyncRetryTimeInSeconds() * 1000;
              newDelayInMs = jitterize(initialRetryMs, (long)(initialRetryMs * 1.1));
          }
  
          // Cap the delay.
          final long maxSyncRetryTimeInSeconds = mConstants.getMaxSyncRetryTimeInSeconds();
  
          if (newDelayInMs > maxSyncRetryTimeInSeconds * 1000) {
              newDelayInMs = maxSyncRetryTimeInSeconds * 1000;
          }
  
          final long backoff = now + newDelayInMs;
          if (Log.isLoggable(TAG, Log.VERBOSE)) {
              Slog.v(TAG, "Backoff until: " + backoff + ", delayTime: " + newDelayInMs);
          }
          mSyncStorageEngine.setBackoff(target, backoff, newDelayInMs);
          rescheduleSyncs(target, "increaseBackoffSetting");
      }
  
      /**
       * Reschedule all scheduled syncs for this EndPoint. The syncs will be scheduled according
       * to current backoff and delayUntil values of this EndPoint.
       */
      private void rescheduleSyncs(EndPoint target, String why) {
          mLogger.log("rescheduleSyncs() ep=", target, " why=", why);
  
          List<SyncOperation> ops = getAllPendingSyncs();
          int count = 0;
          for (SyncOperation op: ops) {
              if (!op.isPeriodic && op.target.matchesSpec(target)) {
                  count++;
                  cancelJob(op, why);
                  postScheduleSyncMessage(op, 0 /* min delay */);
              }
          }
          if (Log.isLoggable(TAG, Log.VERBOSE)) {
              Slog.v(TAG, "Rescheduled " + count + " syncs for " + target);
          }
      }
  
      private void setDelayUntilTime(EndPoint target, long delayUntilSeconds) {
          final long delayUntil = delayUntilSeconds * 1000;
          final long absoluteNow = System.currentTimeMillis();
          long newDelayUntilTime;
          if (delayUntil > absoluteNow) {
              newDelayUntilTime = SystemClock.elapsedRealtime() + (delayUntil - absoluteNow);
          } else {
              newDelayUntilTime = 0;
          }
          mSyncStorageEngine.setDelayUntilTime(target, newDelayUntilTime);
          if (Log.isLoggable(TAG, Log.VERBOSE)) {
              Slog.v(TAG, "Delay Until time set to " + newDelayUntilTime + " for " + target);
          }
          rescheduleSyncs(target, "delayUntil newDelayUntilTime: " + newDelayUntilTime);
      }
  
      private boolean isAdapterDelayed(EndPoint target) {
          long now = SystemClock.elapsedRealtime();
          Pair<Long, Long> backoff = mSyncStorageEngine.getBackoff(target);
          if (backoff != null && backoff.first != SyncStorageEngine.NOT_IN_BACKOFF_MODE
                  && backoff.first > now) {
              return true;
          }
          if (mSyncStorageEngine.getDelayUntilTime(target) > now) {
              return true;
          }
          return false;
      }
  
      /**
       * Cancel the active sync if it matches the target.
       * @param info object containing info about which syncs to cancel. The target can
       * have null account/provider info to specify all accounts/providers.
       * @param extras if non-null, specifies the exact sync to remove.
       */
      public void cancelActiveSync(SyncStorageEngine.EndPoint info, Bundle extras, String why) {
          sendCancelSyncsMessage(info, extras, why);
      }
  
      /**
       * Schedule a sync operation with JobScheduler.
       */
      private void scheduleSyncOperationH(SyncOperation syncOperation) {
          scheduleSyncOperationH(syncOperation, 0L);
      }
  
      private void scheduleSyncOperationH(SyncOperation syncOperation, long minDelay) {
          final boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE);
          if (syncOperation == null) {
              Slog.e(TAG, "Can't schedule null sync operation.");
              return;
          }
          if (!syncOperation.ignoreBackoff()) {
              Pair<Long, Long> backoff = mSyncStorageEngine.getBackoff(syncOperation.target);
              if (backoff == null) {
                  Slog.e(TAG, "Couldn't find backoff values for "
                          + logSafe(syncOperation.target));
                  backoff = new Pair<Long, Long>(SyncStorageEngine.NOT_IN_BACKOFF_MODE,
                          SyncStorageEngine.NOT_IN_BACKOFF_MODE);
              }
              long now = SystemClock.elapsedRealtime();
              long backoffDelay = backoff.first == SyncStorageEngine.NOT_IN_BACKOFF_MODE ? 0
                      : backoff.first - now;
              long delayUntil = mSyncStorageEngine.getDelayUntilTime(syncOperation.target);
              long delayUntilDelay = delayUntil > now ? delayUntil - now : 0;
              if (isLoggable) {
                  Slog.v(TAG, "backoff delay:" + backoffDelay
                          + " delayUntil delay:" + delayUntilDelay);
              }
              minDelay = Math.max(minDelay, Math.max(backoffDelay, delayUntilDelay));
          }
  
          if (minDelay < 0) {
              minDelay = 0;
          }
  
          // Check if duplicate syncs are pending. If found, keep one with least expected run time.
  
          // If any of the duplicate ones has exemption, then we inherit it.
          if (!syncOperation.isPeriodic) {
              int inheritedSyncExemptionFlag = ContentResolver.SYNC_EXEMPTION_NONE;
  
              // Check currently running syncs
              for (ActiveSyncContext asc: mActiveSyncContexts) {
                  if (asc.mSyncOperation.key.equals(syncOperation.key)) {
                      if (isLoggable) {
                          Log.v(TAG, "Duplicate sync is already running. Not scheduling "
                                  + syncOperation);
                      }
                      return;
                  }
              }
  
              int duplicatesCount = 0;
              long now = SystemClock.elapsedRealtime();
              syncOperation.expectedRuntime = now + minDelay;
              List<SyncOperation> pending = getAllPendingSyncs();
              SyncOperation syncToRun = syncOperation;
              for (SyncOperation op : pending) {
                  if (op.isPeriodic) {
                      continue;
                  }
                  if (op.key.equals(syncOperation.key)) {
                      if (syncToRun.expectedRuntime > op.expectedRuntime) {
                          syncToRun = op;
                      }
                      duplicatesCount++;
                  }
              }
              if (duplicatesCount > 1) {
                  Slog.e(TAG, "FATAL ERROR! File a bug if you see this.");
              }
  
              if (syncOperation != syncToRun) {
                  // If there's a duplicate with an earlier run time that's not exempted,
                  // and if the current operation is exempted with no minDelay,
                  // cancel the duplicate one and keep the current one.
                  //
                  // This means the duplicate one has a negative expected run time, but it hasn't
                  // been executed possibly because of app-standby.
  
                  if ((minDelay == 0)
                          && (syncToRun.syncExemptionFlag < syncOperation.syncExemptionFlag)) {
                      syncToRun = syncOperation;
                      inheritedSyncExemptionFlag =
                              Math.max(inheritedSyncExemptionFlag, syncToRun.syncExemptionFlag);
                  }
              }
  
              // Cancel all other duplicate syncs.
              for (SyncOperation op : pending) {
                  if (op.isPeriodic) {
                      continue;
                  }
                  if (op.key.equals(syncOperation.key)) {
                      if (op != syncToRun) {
                          if (isLoggable) {
                              Slog.v(TAG, "Cancelling duplicate sync " + op);
                          }
                          inheritedSyncExemptionFlag =
                                  Math.max(inheritedSyncExemptionFlag, op.syncExemptionFlag);
                          cancelJob(op, "scheduleSyncOperationH-duplicate");
                      }
                  }
              }
              if (syncToRun != syncOperation) {
                  // Don't schedule because a duplicate sync with earlier expected runtime exists.
                  if (isLoggable) {
                      Slog.v(TAG, "Not scheduling because a duplicate exists.");
                  }
  
                  // TODO Should we give the winning one SYNC_EXTRAS_APP_STANDBY_EXEMPTED
                  // if the current one has it?
                  return;
              }
  
              // If any of the duplicates had exemption, we exempt the current one.
              //
              if (inheritedSyncExemptionFlag > ContentResolver.SYNC_EXEMPTION_NONE) {
                  syncOperation.syncExemptionFlag = inheritedSyncExemptionFlag;
              }
          }
  
          // Syncs that are re-scheduled shouldn't get a new job id.
          if (syncOperation.jobId == SyncOperation.NO_JOB_ID) {
              syncOperation.jobId = getUnusedJobIdH();
          }
  
          if (isLoggable) {
              Slog.v(TAG, "scheduling sync operation " + syncOperation.toString());
          }
  
          int priority = syncOperation.findPriority();
  
          final int networkType = syncOperation.isNotAllowedOnMetered() ?
                  JobInfo.NETWORK_TYPE_UNMETERED : JobInfo.NETWORK_TYPE_ANY;
  
          // Note this logic means when an exempted sync fails,
          // the back-off one will inherit it too, and will be exempted from app-standby.
          final int jobFlags = syncOperation.isAppStandbyExempted()
                  ? JobInfo.FLAG_EXEMPT_FROM_APP_STANDBY : 0;
  
          JobInfo.Builder b = new JobInfo.Builder(syncOperation.jobId,
                  new ComponentName(mContext, SyncJobService.class))
                  .setExtras(syncOperation.toJobInfoExtras())
                  .setRequiredNetworkType(networkType)
                  .setPersisted(true)
                  .setPriority(priority)
                  .setFlags(jobFlags);
  
          if (syncOperation.isPeriodic) {
              b.setPeriodic(syncOperation.periodMillis, syncOperation.flexMillis);
          } else {
              if (minDelay > 0) {
                  b.setMinimumLatency(minDelay);
              }
              getSyncStorageEngine().markPending(syncOperation.target, true);
          }
  
          if (syncOperation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_REQUIRE_CHARGING)) {
              b.setRequiresCharging(true);
          }
  
          if (syncOperation.syncExemptionFlag
                  == ContentResolver.SYNC_EXEMPTION_PROMOTE_BUCKET_WITH_TEMP) {
              DeviceIdleController.LocalService dic =
                      LocalServices.getService(DeviceIdleController.LocalService.class);
              if (dic != null) {
                  dic.addPowerSaveTempWhitelistApp(Process.SYSTEM_UID,
                          syncOperation.owningPackage,
                          mConstants.getKeyExemptionTempWhitelistDurationInSeconds() * 1000,
                          UserHandle.getUserId(syncOperation.owningUid),
                          /* sync=*/ false, "sync by top app");
              }
          }
  
          final UsageStatsManagerInternal usmi =
                  LocalServices.getService(UsageStatsManagerInternal.class);
          if (usmi != null) {
              usmi.reportSyncScheduled(syncOperation.owningPackage,
                      UserHandle.getUserId(syncOperation.owningUid),
                      syncOperation.isAppStandbyExempted());
          }
  
          getJobScheduler().scheduleAsPackage(b.build(), syncOperation.owningPackage,
                  syncOperation.target.userId, syncOperation.wakeLockName());
      }
  
      /**
       * Remove scheduled sync operations.
       * @param info limit the removals to operations that match this target. The target can
       * have null account/provider info to specify all accounts/providers.
       */
      public void clearScheduledSyncOperations(SyncStorageEngine.EndPoint info) {
          List<SyncOperation> ops = getAllPendingSyncs();
          for (SyncOperation op: ops) {
              if (!op.isPeriodic && op.target.matchesSpec(info)) {
                  cancelJob(op, "clearScheduledSyncOperations");
                  getSyncStorageEngine().markPending(op.target, false);
              }
          }
          mSyncStorageEngine.setBackoff(info,
                  SyncStorageEngine.NOT_IN_BACKOFF_MODE, SyncStorageEngine.NOT_IN_BACKOFF_MODE);
      }
  
      /**
       * Remove a specified sync, if it exists.
       * @param info Authority for which the sync is to be removed.
       * @param extras extras bundle to uniquely identify sync.
       */
      public void cancelScheduledSyncOperation(SyncStorageEngine.EndPoint info, Bundle extras) {
          List<SyncOperation> ops = getAllPendingSyncs();
          for (SyncOperation op: ops) {
              if (!op.isPeriodic && op.target.matchesSpec(info)
                      && syncExtrasEquals(extras, op.extras, false)) {
                  cancelJob(op, "cancelScheduledSyncOperation");
              }
          }
          setAuthorityPendingState(info);
          // Reset the back-off if there are no more syncs pending.
          if (!mSyncStorageEngine.isSyncPending(info)) {
              mSyncStorageEngine.setBackoff(info,
                      SyncStorageEngine.NOT_IN_BACKOFF_MODE, SyncStorageEngine.NOT_IN_BACKOFF_MODE);
          }
      }
  
      private void maybeRescheduleSync(SyncResult syncResult, SyncOperation operation) {
          final boolean isLoggable = Log.isLoggable(TAG, Log.DEBUG);
          if (isLoggable) {
              Log.d(TAG, "encountered error(s) during the sync: " + syncResult + ", " + operation);
          }
  
          // The SYNC_EXTRAS_IGNORE_BACKOFF only applies to the first attempt to sync a given
          // request. Retries of the request will always honor the backoff, so clear the
          // flag in case we retry this request.
          if (operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, false)) {
              operation.extras.remove(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF);
          }
  
          if (operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_DO_NOT_RETRY, false)
                  && !syncResult.syncAlreadyInProgress) {
              // syncAlreadyInProgress flag is set by AbstractThreadedSyncAdapter. The sync adapter
              // has no way of knowing that a sync error occured. So we DO retry if the error is
              // syncAlreadyInProgress.
              if (isLoggable) {
                  Log.d(TAG, "not retrying sync operation because SYNC_EXTRAS_DO_NOT_RETRY was specified "
                          + operation);
              }
          } else if (operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, false)
                  && !syncResult.syncAlreadyInProgress) {
              // If this was an upward sync then schedule a two-way sync immediately.
              operation.extras.remove(ContentResolver.SYNC_EXTRAS_UPLOAD);
              if (isLoggable) {
                  Log.d(TAG, "retrying sync operation as a two-way sync because an upload-only sync "
                          + "encountered an error: " + operation);
              }
              scheduleSyncOperationH(operation);
          } else if (syncResult.tooManyRetries) {
              // If this sync aborted because the internal sync loop retried too many times then
              //   don't reschedule. Otherwise we risk getting into a retry loop.
              if (isLoggable) {
                  Log.d(TAG, "not retrying sync operation because it retried too many times: "
                          + operation);
              }
          } else if (syncResult.madeSomeProgress()) {
              // If the operation succeeded to some extent then retry immediately.
              if (isLoggable) {
                  Log.d(TAG, "retrying sync operation because even though it had an error "
                          + "it achieved some success");
              }
              scheduleSyncOperationH(operation);
          } else if (syncResult.syncAlreadyInProgress) {
              if (isLoggable) {
                  Log.d(TAG, "retrying sync operation that failed because there was already a "
                          + "sync in progress: " + operation);
              }
              scheduleSyncOperationH(operation, DELAY_RETRY_SYNC_IN_PROGRESS_IN_SECONDS * 1000);
          } else if (syncResult.hasSoftError()) {
              // If this was a two-way sync then retry soft errors with an exponential backoff.
              if (isLoggable) {
                  Log.d(TAG, "retrying sync operation because it encountered a soft error: "
                          + operation);
              }
              scheduleSyncOperationH(operation);
          } else {
              // Otherwise do not reschedule.
              Log.e(TAG, "not retrying sync operation because the error is a hard error: "
                      + logSafe(operation));
          }
      }
  
      private void onUserUnlocked(int userId) {
          // Make sure that accounts we're about to use are valid.
          AccountManagerService.getSingleton().validateAccounts(userId);
  
          mSyncAdapters.invalidateCache(userId);
  
          EndPoint target = new EndPoint(null, null, userId);
          updateRunningAccounts(target);
  
          // Schedule sync for any accounts under started user, but only the NOT_INITIALIZED adapters.
          final Account[] accounts = AccountManagerService.getSingleton().getAccounts(userId,
                  mContext.getOpPackageName());
          for (Account account : accounts) {
              scheduleSync(account, userId, SyncOperation.REASON_USER_START, null, null,
                      AuthorityInfo.NOT_INITIALIZED, ContentResolver.SYNC_EXEMPTION_NONE,
                      Process.myUid(), -3, null);
          }
      }
  
      private void onUserStopped(int userId) {
          updateRunningAccounts(null /* Don't sync any target */);
  
          cancelActiveSync(
                  new SyncStorageEngine.EndPoint(
                          null /* any account */,
                          null /* any authority */,
                          userId),
                  null /* any sync. */,
                  "onUserStopped"
          );
      }
  
      private void onUserRemoved(int userId) {
          mLogger.log("onUserRemoved: u", userId);
          updateRunningAccounts(null /* Don't sync any target */);
  
          // Clean up the storage engine database
          mSyncStorageEngine.removeStaleAccounts(null, userId);
          List<SyncOperation> ops = getAllPendingSyncs();
          for (SyncOperation op: ops) {
              if (op.target.userId == userId) {
                  cancelJob(op, "user removed u" + userId);
              }
          }
      }
  
      /**
       * Construct intent used to bind to an adapter.
       *
       * @param context Context to create intent for
       * @param syncAdapterComponent The adapter description
       * @param userId The user the adapter belongs to
       *
       * @return The intent required to bind to the adapter
       */
      static @NonNull Intent getAdapterBindIntent(@NonNull Context context,
              @NonNull ComponentName syncAdapterComponent, @UserIdInt int userId) {
          final Intent intent = new Intent();
          intent.setAction("android.content.SyncAdapter");
          intent.setComponent(syncAdapterComponent);
          intent.putExtra(Intent.EXTRA_CLIENT_LABEL,
                  com.android.internal.R.string.sync_binding_label);
          intent.putExtra(Intent.EXTRA_CLIENT_INTENT, PendingIntent.getActivityAsUser(context, 0,
                  new Intent(Settings.ACTION_SYNC_SETTINGS), 0, null, UserHandle.of(userId)));
  
          return intent;
      }
  
      /**
       * @hide
       */
      class ActiveSyncContext extends ISyncContext.Stub
              implements ServiceConnection, IBinder.DeathRecipient {
          final SyncOperation mSyncOperation;
          final long mHistoryRowId;
          ISyncAdapter mSyncAdapter;
          final long mStartTime;
          long mTimeoutStartTime;
          boolean mBound;
          final PowerManager.WakeLock mSyncWakeLock;
          final int mSyncAdapterUid;
          SyncInfo mSyncInfo;
          boolean mIsLinkedToDeath = false;
          String mEventName;
  
          /** Total bytes transferred, counted at {@link #mLastPolledTimeElapsed} */
          long mBytesTransferredAtLastPoll;
          /**
           * Last point in {@link SystemClock#elapsedRealtime()} at which we checked the # of bytes
           * transferred to/fro by this adapter.
           */
          long mLastPolledTimeElapsed;
  
          /**
           * Create an ActiveSyncContext for an impending sync and grab the wakelock for that
           * sync adapter. Since this grabs the wakelock you need to be sure to call
           * close() when you are done with this ActiveSyncContext, whether the sync succeeded
           * or not.
           * @param syncOperation the SyncOperation we are about to sync
           * @param historyRowId the row in which to record the history info for this sync
           * @param syncAdapterUid the UID of the application that contains the sync adapter
           * for this sync. This is used to attribute the wakelock hold to that application.
           */
          public ActiveSyncContext(SyncOperation syncOperation, long historyRowId,
                  int syncAdapterUid) {
              super();
              mSyncAdapterUid = syncAdapterUid;
              mSyncOperation = syncOperation;
              mHistoryRowId = historyRowId;
              mSyncAdapter = null;
              mStartTime = SystemClock.elapsedRealtime();
              mTimeoutStartTime = mStartTime;
              mSyncWakeLock = mSyncHandler.getSyncWakeLock(mSyncOperation);
              mSyncWakeLock.setWorkSource(new WorkSource(syncAdapterUid));
              mSyncWakeLock.acquire();
          }
  
          public void sendHeartbeat() {
              // Heartbeats are no longer used.
          }
  
          public void onFinished(SyncResult result) {
              if (Log.isLoggable(TAG, Log.VERBOSE)) Slog.v(TAG, "onFinished: " + this);
              // Include "this" in the message so that the handler can ignore it if this
              // ActiveSyncContext is no longer the mActiveSyncContext at message handling
              // time.
              mLogger.log("onFinished result=", result, " endpoint=",
                      (mSyncOperation == null ? "null" : mSyncOperation.target));
              sendSyncFinishedOrCanceledMessage(this, result);
          }
  
          public void toString(StringBuilder sb, boolean logSafe) {
              sb.append("startTime ").append(mStartTime)
                      .append(", mTimeoutStartTime ").append(mTimeoutStartTime)
                      .append(", mHistoryRowId ").append(mHistoryRowId)
                      .append(", syncOperation ").append(
                          logSafe ? logSafe(mSyncOperation) : mSyncOperation);
          }
  
          public void onServiceConnected(ComponentName name, IBinder service) {
              Message msg = mSyncHandler.obtainMessage();
              msg.what = SyncHandler.MESSAGE_SERVICE_CONNECTED;
              msg.obj = new ServiceConnectionData(this, service);
              mSyncHandler.sendMessage(msg);
          }
  
          public void onServiceDisconnected(ComponentName name) {
              Message msg = mSyncHandler.obtainMessage();
              msg.what = SyncHandler.MESSAGE_SERVICE_DISCONNECTED;
              msg.obj = new ServiceConnectionData(this, null);
              mSyncHandler.sendMessage(msg);
          }
  
          boolean bindToSyncAdapter(ComponentName serviceComponent, int userId) {
              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                  Log.d(TAG, "bindToSyncAdapter: " + serviceComponent + ", connection " + this);
              }
              Intent intent = getAdapterBindIntent(mContext, serviceComponent, userId);
  
              mBound = true;
              final boolean bindResult = mContext.bindServiceAsUser(intent, this,
                      SYNC_ADAPTER_CONNECTION_FLAGS, new UserHandle(mSyncOperation.target.userId));
              mLogger.log("bindService() returned=", mBound, " for ", this);
              if (!bindResult) {
                  mBound = false;
              } else {
                  try {
                      mEventName = mSyncOperation.wakeLockName();
                      mBatteryStats.noteSyncStart(mEventName, mSyncAdapterUid);
                  } catch (RemoteException e) {
                  }
              }
              return bindResult;
          }
  
          /**
           * Performs the required cleanup, which is the releasing of the wakelock and
           * unbinding from the sync adapter (if actually bound).
           */
          protected void close() {
              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                  Log.d(TAG, "unBindFromSyncAdapter: connection " + this);
              }
              if (mBound) {
                  mBound = false;
                  mLogger.log("unbindService for ", this);
                  mContext.unbindService(this);
                  try {
                      mBatteryStats.noteSyncFinish(mEventName, mSyncAdapterUid);
                  } catch (RemoteException e) {
                  }
              }
              mSyncWakeLock.release();
              mSyncWakeLock.setWorkSource(null);
          }
  
          public String toString() {
              StringBuilder sb = new StringBuilder();
              toString(sb, false);
              return sb.toString();
          }
  
          public String toSafeString() {
              StringBuilder sb = new StringBuilder();
              toString(sb, true);
              return sb.toString();
          }
  
          @Override
          public void binderDied() {
              sendSyncFinishedOrCanceledMessage(this, null);
          }
      }
  
      protected void dump(FileDescriptor fd, PrintWriter pw, boolean dumpAll) {
          final IndentingPrintWriter ipw = new IndentingPrintWriter(pw, "  ");
  
          final SyncAdapterStateFetcher buckets = new SyncAdapterStateFetcher();
  
          dumpSyncState(ipw, buckets);
          mConstants.dump(pw, "");
          dumpSyncAdapters(ipw);
  
          if (dumpAll) {
              ipw.println("Detailed Sync History");
              mLogger.dumpAll(pw);
          }
      }
  
      static String formatTime(long time) {
          if (time == 0) {
              return "N/A";
          }
          Time tobj = new Time();
          tobj.set(time);
          return tobj.format("%Y-%m-%d %H:%M:%S");
      }
  
      private final static Comparator<SyncOperation> sOpDumpComparator = (op1, op2) -> {
          int res = Integer.compare(op1.target.userId, op2.target.userId);
          if (res != 0) return res;
  
          final Comparator<String> stringComparator = String.CASE_INSENSITIVE_ORDER;
  
          res = stringComparator.compare(op1.target.account.type, op2.target.account.type);
          if (res != 0) return res;
  
          res = stringComparator.compare(op1.target.account.name, op2.target.account.name);
          if (res != 0) return res;
  
          res = stringComparator.compare(op1.target.provider, op2.target.provider);
          if (res != 0) return res;
  
          res = Integer.compare(op1.reason, op2.reason);
          if (res != 0) return res;
  
          res = Long.compare(op1.periodMillis, op2.periodMillis);
          if (res != 0) return res;
  
          res = Long.compare(op1.expectedRuntime, op2.expectedRuntime);
          if (res != 0) return res;
  
          res = Long.compare(op1.jobId, op2.jobId);
          if (res != 0) return res;
  
          return 0;
      };
  
      private final static Comparator<SyncOperation> sOpRuntimeComparator = (op1, op2) -> {
          int res = Long.compare(op1.expectedRuntime, op2.expectedRuntime);
          if (res != 0) return res;
  
          return sOpDumpComparator.compare(op1, op2);
      };
  
      private static <T> int countIf(Collection<T> col, Predicate<T> p) {
          int ret = 0;
          for (T item : col) {
              if (p.test(item)) ret++;
          }
          return ret;
      }
  
      protected void dumpPendingSyncs(PrintWriter pw, SyncAdapterStateFetcher buckets) {
          List<SyncOperation> pendingSyncs = getAllPendingSyncs();
  
          pw.print("Pending Syncs: ");
          pw.println(countIf(pendingSyncs, op -> !op.isPeriodic));
  
          Collections.sort(pendingSyncs, sOpRuntimeComparator);
          int count = 0;
          for (SyncOperation op: pendingSyncs) {
              if (!op.isPeriodic) {
                  pw.println(op.dump(null, false, buckets, /*logSafe=*/ false));
                  count++;
              }
          }
          pw.println();
      }
  
      protected void dumpPeriodicSyncs(PrintWriter pw, SyncAdapterStateFetcher buckets) {
          List<SyncOperation> pendingSyncs = getAllPendingSyncs();
  
          pw.print("Periodic Syncs: ");
          pw.println(countIf(pendingSyncs, op -> op.isPeriodic));
  
          Collections.sort(pendingSyncs, sOpDumpComparator);
          int count = 0;
          for (SyncOperation op: pendingSyncs) {
              if (op.isPeriodic) {
                  pw.println(op.dump(null, false, buckets, /*logSafe=*/ false));
                  count++;
              }
          }
          pw.println();
      }
  
      /**
       * Similar to {@link android.util.TimeUtils#formatDuration}, but it's more suitable and concise
       * for the sync manager dumpsys.  (Don't add the leading + sign, don't show milliseconds.)
       */
      public static StringBuilder formatDurationHMS(StringBuilder sb, long duration) {
          duration /= 1000;
          if (duration < 0) {
              sb.append('-');
              duration = -duration;
          }
          final long seconds = duration % 60;
          duration /= 60;
  
          final long minutes = duration % 60;
          duration /= 60;
  
          final long hours = duration % 24;
          duration /= 24;
  
          final long days = duration;
  
          boolean print = false;
          if (days > 0) {
              sb.append(days);
              sb.append('d');
              print = true;
          }
          print = printTwoDigitNumber(sb, hours, 'h', print);
          print = printTwoDigitNumber(sb, minutes, 'm', print);
          print = printTwoDigitNumber(sb, seconds, 's', print);
          if (!print) {
              sb.append("0s");
          }
  
          return sb;
      }
  
      private static boolean printTwoDigitNumber(StringBuilder sb, long value, char unit,
              boolean always) {
          if (!always && (value == 0)) {
              return false;
          }
          if (always && (value < 10)) {
              sb.append('0');
          }
          sb.append(value);
          sb.append(unit);
          return true;
      }
  
      protected void dumpSyncState(PrintWriter pw, SyncAdapterStateFetcher buckets) {
          final StringBuilder sb = new StringBuilder();
  
          pw.print("Data connected: "); pw.println(mDataConnectionIsConnected);
          pw.print("Battery saver: ");
          pw.println((mPowerManager != null) && mPowerManager.isPowerSaveMode());
  
          pw.print("Background network restriction: ");
          {
              final ConnectivityManager cm = getConnectivityManager();
              final int status = (cm == null) ? -1 : cm.getRestrictBackgroundStatus();
              switch (status) {
                  case ConnectivityManager.RESTRICT_BACKGROUND_STATUS_DISABLED:
                      pw.println(" disabled");
                      break;
                  case ConnectivityManager.RESTRICT_BACKGROUND_STATUS_WHITELISTED:
                      pw.println(" whitelisted");
                      break;
                  case ConnectivityManager.RESTRICT_BACKGROUND_STATUS_ENABLED:
                      pw.println(" enabled");
                      break;
                  default:
                      pw.print("Unknown(");
                      pw.print(status);
                      pw.println(")");
                      break;
              }
          }
  
          pw.print("Auto sync: ");
          List<UserInfo> users = getAllUsers();
          if (users != null) {
              for (UserInfo user : users) {
                  pw.print("u" + user.id + "="
                          + mSyncStorageEngine.getMasterSyncAutomatically(user.id) + " ");
              }
              pw.println();
          }
          pw.print("Memory low: "); pw.println(mStorageIsLow);
          pw.print("Device idle: "); pw.println(mDeviceIsIdle);
          pw.print("Reported active: "); pw.println(mReportedSyncActive);
          pw.print("Clock valid: "); pw.println(mSyncStorageEngine.isClockValid());
  
          final AccountAndUser[] accounts = AccountManagerService.getSingleton().getAllAccounts();
  
          pw.print("Accounts: ");
          if (accounts != INITIAL_ACCOUNTS_ARRAY) {
              pw.println(accounts.length);
          } else {
              pw.println("not known yet");
          }
          final long now = SystemClock.elapsedRealtime();
          pw.print("Now: "); pw.print(now);
          pw.println(" (" + formatTime(System.currentTimeMillis()) + ")");
  
          sb.setLength(0);
          pw.print("Uptime: "); pw.print(formatDurationHMS(sb, now));
          pw.println();
          pw.print("Time spent syncing: ");
  
          sb.setLength(0);
          pw.print(formatDurationHMS(sb,
                  mSyncHandler.mSyncTimeTracker.timeSpentSyncing()));
          pw.print(", sync ");
          pw.print(mSyncHandler.mSyncTimeTracker.mLastWasSyncing ? "" : "not ");
          pw.println("in progress");
  
          pw.println();
          pw.println("Active Syncs: " + mActiveSyncContexts.size());
          final PackageManager pm = mContext.getPackageManager();
          for (SyncManager.ActiveSyncContext activeSyncContext : mActiveSyncContexts) {
              final long durationInSeconds = (now - activeSyncContext.mStartTime);
              pw.print("  ");
              sb.setLength(0);
              pw.print(formatDurationHMS(sb, durationInSeconds));
              pw.print(" - ");
              pw.print(activeSyncContext.mSyncOperation.dump(pm, false, buckets, /*logSafe=*/ false));
              pw.println();
          }
          pw.println();
  
          dumpPendingSyncs(pw, buckets);
          dumpPeriodicSyncs(pw, buckets);
  
          // Join the installed sync adapter with the accounts list and emit for everything.
          pw.println("Sync Status");
  
          final ArrayList<Pair<EndPoint, SyncStatusInfo>> statuses = new ArrayList<>();
  
          mSyncStorageEngine.resetTodayStats(/* force=*/ false);
  
          for (AccountAndUser account : accounts) {
              final boolean unlocked;
              synchronized (mUnlockedUsers) {
                  unlocked = mUnlockedUsers.get(account.userId);
              }
              pw.printf("Account %s u%d %s%s\n",
                      account.account.name, account.userId, account.account.type,
                      (unlocked ? "" : " (locked)"));
  
              pw.println("=======================================================================");
              final PrintTable table = new PrintTable(16);
              table.set(0, 0,
                      "Authority", // 0
                      "Syncable",  // 1
                      "Enabled",   // 2
  
                      "Stats",     // 3 "Total", "Today" or "Yesterday".
  
                      "Loc",       // 4 # of syncs with local sources. (including failures/cancels. )
                      "Poll",      // 5 "poll" syncs.
                      "Per",       // 6 Periodic syncs.
                      "Feed",      // 7 Syncs with a "feed" extra. (subscribedfeeds?)
                      "User",      // 8 User-initiated
                      "Othr",      // 9 Other sources.
  
                      "Tot",       // 10 Total syncs (including failures / cancels)
                      "Fail",      // 11 (Failure)
                      "Can",       // 12 (Cancel)
  
                      "Time",      // 13 Total time
                      "Last Sync", // 14
                      "Backoff"    // 15
              );
  
              final List<RegisteredServicesCache.ServiceInfo<SyncAdapterType>> sorted =
                      Lists.newArrayList();
              sorted.addAll(mSyncAdapters.getAllServices(account.userId));
              Collections.sort(sorted,
                      new Comparator<RegisteredServicesCache.ServiceInfo<SyncAdapterType>>() {
                          @Override
                          public int compare(RegisteredServicesCache.ServiceInfo<SyncAdapterType> lhs,
                                  RegisteredServicesCache.ServiceInfo<SyncAdapterType> rhs) {
                              return lhs.type.authority.compareTo(rhs.type.authority);
                          }
                      });
              for (RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterType : sorted) {
                  if (!syncAdapterType.type.accountType.equals(account.account.type)) {
                      continue;
                  }
                  int row = table.getNumRows();
                  Pair<AuthorityInfo, SyncStatusInfo> syncAuthoritySyncStatus =
                          mSyncStorageEngine.getCopyOfAuthorityWithSyncStatus(
                                  new SyncStorageEngine.EndPoint(
                                          account.account,
                                          syncAdapterType.type.authority,
                                          account.userId));
                  SyncStorageEngine.AuthorityInfo settings = syncAuthoritySyncStatus.first;
                  SyncStatusInfo status = syncAuthoritySyncStatus.second;
                  statuses.add(Pair.create(settings.target, status));
                  String authority = settings.target.provider;
                  if (authority.length() > 50) {
                      authority = authority.substring(authority.length() - 50);
                  }
                  table.set(row, 0, authority, settings.syncable, settings.enabled);
  
                  QuadConsumer<String, Stats, Function<Integer, String>, Integer> c =
                          (label, stats, filter, r) -> {
                      sb.setLength(0);
                      table.set(r, 3,
                              label,
                              filter.apply(stats.numSourceLocal),
                              filter.apply(stats.numSourcePoll),
                              filter.apply(stats.numSourcePeriodic),
                              filter.apply(stats.numSourceFeed),
                              filter.apply(stats.numSourceUser),
                              filter.apply(stats.numSourceOther),
                              filter.apply(stats.numSyncs),
                              filter.apply(stats.numFailures),
                              filter.apply(stats.numCancels),
                              formatDurationHMS(sb, stats.totalElapsedTime));
                  };
                  c.accept("Total", status.totalStats, (i) -> Integer.toString(i), row);
                  c.accept("Today", status.todayStats, this::zeroToEmpty, row + 1);
                  c.accept("Yestr", status.yesterdayStats, this::zeroToEmpty, row + 2);
  
                  final int LAST_SYNC = 14;
                  final int BACKOFF = LAST_SYNC + 1;
  
                  int row1 = row;
                  if (settings.delayUntil > now) {
                      table.set(row1++, BACKOFF, "D: " + (settings.delayUntil - now) / 1000);
                      if (settings.backoffTime > now) {
                          table.set(row1++, BACKOFF, "B: " + (settings.backoffTime - now) / 1000);
                          table.set(row1++, BACKOFF, settings.backoffDelay / 1000);
                      }
                  }
  
                  row1 = row;
                  if (status.lastSuccessTime != 0) {
                      table.set(row1++, LAST_SYNC, SyncStorageEngine.SOURCES[status.lastSuccessSource]
                              + " " + "SUCCESS");
                      table.set(row1++, LAST_SYNC, formatTime(status.lastSuccessTime));
                  }
                  if (status.lastFailureTime != 0) {
                      table.set(row1++, LAST_SYNC, SyncStorageEngine.SOURCES[status.lastFailureSource]
                              + " " + "FAILURE");
                      table.set(row1++, LAST_SYNC, formatTime(status.lastFailureTime));
                      //noinspection UnusedAssignment
                      table.set(row1++, LAST_SYNC, status.lastFailureMesg);
                  }
              }
              table.writeTo(pw);
          }
  
          dumpSyncHistory(pw);
  
          pw.println();
          pw.println("Per Adapter History");
          pw.println("(SERVER is now split up to FEED and OTHER)");
  
          for (int i = 0; i < statuses.size(); i++) {
              final Pair<EndPoint, SyncStatusInfo> event = statuses.get(i);
  
              pw.print("  ");
              pw.print(event.first.account.name);
              pw.print('/');
              pw.print(event.first.account.type);
              pw.print(" u");
              pw.print(event.first.userId);
              pw.print(" [");
              pw.print(event.first.provider);
              pw.print("]");
              pw.println();
  
              pw.println("    Per source last syncs:");
              for (int j = 0; j < SyncStorageEngine.SOURCES.length; j++) {
                  pw.print("      ");
                  pw.print(String.format("%8s", SyncStorageEngine.SOURCES[j]));
                  pw.print("  Success: ");
                  pw.print(formatTime(event.second.perSourceLastSuccessTimes[j]));
  
                  pw.print("  Failure: ");
                  pw.println(formatTime(event.second.perSourceLastFailureTimes[j]));
              }
  
              pw.println("    Last syncs:");
              for (int j = 0; j < event.second.getEventCount(); j++) {
                  pw.print("      ");
                  pw.print(formatTime(event.second.getEventTime(j)));
                  pw.print(' ');
                  pw.print(event.second.getEvent(j));
                  pw.println();
              }
              if (event.second.getEventCount() == 0) {
                  pw.println("      N/A");
              }
          }
      }
  
      private String zeroToEmpty(int value) {
          return (value != 0) ? Integer.toString(value) : "";
      }
  
      private void dumpTimeSec(PrintWriter pw, long time) {
          pw.print(time/1000); pw.print('.'); pw.print((time/100)%10);
          pw.print('s');
      }
  
      private void dumpDayStatistic(PrintWriter pw, SyncStorageEngine.DayStats ds) {
          pw.print("Success ("); pw.print(ds.successCount);
          if (ds.successCount > 0) {
              pw.print(" for "); dumpTimeSec(pw, ds.successTime);
              pw.print(" avg="); dumpTimeSec(pw, ds.successTime/ds.successCount);
          }
          pw.print(") Failure ("); pw.print(ds.failureCount);
          if (ds.failureCount > 0) {
              pw.print(" for "); dumpTimeSec(pw, ds.failureTime);
              pw.print(" avg="); dumpTimeSec(pw, ds.failureTime/ds.failureCount);
          }
          pw.println(")");
      }
  
      protected void dumpSyncHistory(PrintWriter pw) {
          dumpRecentHistory(pw);
          dumpDayStatistics(pw);
      }
  
      private void dumpRecentHistory(PrintWriter pw) {
          final ArrayList<SyncStorageEngine.SyncHistoryItem> items
                  = mSyncStorageEngine.getSyncHistory();
          if (items != null && items.size() > 0) {
              final Map<String, AuthoritySyncStats> authorityMap = Maps.newHashMap();
              long totalElapsedTime = 0;
              long totalTimes = 0;
              final int N = items.size();
  
              int maxAuthority = 0;
              int maxAccount = 0;
              for (SyncStorageEngine.SyncHistoryItem item : items) {
                  SyncStorageEngine.AuthorityInfo authorityInfo
                          = mSyncStorageEngine.getAuthority(item.authorityId);
                  final String authorityName;
                  final String accountKey;
                  if (authorityInfo != null) {
                      authorityName = authorityInfo.target.provider;
                      accountKey = authorityInfo.target.account.name + "/"
                              + authorityInfo.target.account.type
                              + " u" + authorityInfo.target.userId;
                  } else {
                      authorityName = "Unknown";
                      accountKey = "Unknown";
                  }
  
                  int length = authorityName.length();
                  if (length > maxAuthority) {
                      maxAuthority = length;
                  }
                  length = accountKey.length();
                  if (length > maxAccount) {
                      maxAccount = length;
                  }
  
                  final long elapsedTime = item.elapsedTime;
                  totalElapsedTime += elapsedTime;
                  totalTimes++;
                  AuthoritySyncStats authoritySyncStats = authorityMap.get(authorityName);
                  if (authoritySyncStats == null) {
                      authoritySyncStats = new AuthoritySyncStats(authorityName);
                      authorityMap.put(authorityName, authoritySyncStats);
                  }
                  authoritySyncStats.elapsedTime += elapsedTime;
                  authoritySyncStats.times++;
                  final Map<String, AccountSyncStats> accountMap = authoritySyncStats.accountMap;
                  AccountSyncStats accountSyncStats = accountMap.get(accountKey);
                  if (accountSyncStats == null) {
                      accountSyncStats = new AccountSyncStats(accountKey);
                      accountMap.put(accountKey, accountSyncStats);
                  }
                  accountSyncStats.elapsedTime += elapsedTime;
                  accountSyncStats.times++;
  
              }
  
              if (totalElapsedTime > 0) {
                  pw.println();
                  pw.printf("Detailed Statistics (Recent history):  "
                                  + "%d (# of times) %ds (sync time)\n",
                          totalTimes, totalElapsedTime / 1000);
  
                  final List<AuthoritySyncStats> sortedAuthorities =
                          new ArrayList<AuthoritySyncStats>(authorityMap.values());
                  Collections.sort(sortedAuthorities, new Comparator<AuthoritySyncStats>() {
                      @Override
                      public int compare(AuthoritySyncStats lhs, AuthoritySyncStats rhs) {
                          // reverse order
                          int compare = Integer.compare(rhs.times, lhs.times);
                          if (compare == 0) {
                              compare = Long.compare(rhs.elapsedTime, lhs.elapsedTime);
                          }
                          return compare;
                      }
                  });
  
                  final int maxLength = Math.max(maxAuthority, maxAccount + 3);
                  final int padLength = 2 + 2 + maxLength + 2 + 10 + 11;
                  final char chars[] = new char[padLength];
                  Arrays.fill(chars, '-');
                  final String separator = new String(chars);
  
                  final String authorityFormat =
                          String.format("  %%-%ds: %%-9s  %%-11s\n", maxLength + 2);
                  final String accountFormat =
                          String.format("    %%-%ds:   %%-9s  %%-11s\n", maxLength);
  
                  pw.println(separator);
                  for (AuthoritySyncStats authoritySyncStats : sortedAuthorities) {
                      String name = authoritySyncStats.name;
                      long elapsedTime;
                      int times;
                      String timeStr;
                      String timesStr;
  
                      elapsedTime = authoritySyncStats.elapsedTime;
                      times = authoritySyncStats.times;
                      timeStr = String.format("%ds/%d%%",
                              elapsedTime / 1000,
                              elapsedTime * 100 / totalElapsedTime);
                      timesStr = String.format("%d/%d%%",
                              times,
                              times * 100 / totalTimes);
                      pw.printf(authorityFormat, name, timesStr, timeStr);
  
                      final List<AccountSyncStats> sortedAccounts =
                              new ArrayList<AccountSyncStats>(
                                      authoritySyncStats.accountMap.values());
                      Collections.sort(sortedAccounts, new Comparator<AccountSyncStats>() {
                          @Override
                          public int compare(AccountSyncStats lhs, AccountSyncStats rhs) {
                              // reverse order
                              int compare = Integer.compare(rhs.times, lhs.times);
                              if (compare == 0) {
                                  compare = Long.compare(rhs.elapsedTime, lhs.elapsedTime);
                              }
                              return compare;
                          }
                      });
                      for (AccountSyncStats stats: sortedAccounts) {
                          elapsedTime = stats.elapsedTime;
                          times = stats.times;
                          timeStr = String.format("%ds/%d%%",
                                  elapsedTime / 1000,
                                  elapsedTime * 100 / totalElapsedTime);
                          timesStr = String.format("%d/%d%%",
                                  times,
                                  times * 100 / totalTimes);
                          pw.printf(accountFormat, stats.name, timesStr, timeStr);
                      }
                      pw.println(separator);
                  }
              }
  
              pw.println();
              pw.println("Recent Sync History");
              pw.println("(SERVER is now split up to FEED and OTHER)");
              final String format = "  %-" + maxAccount + "s  %-" + maxAuthority + "s %s\n";
              final Map<String, Long> lastTimeMap = Maps.newHashMap();
              final PackageManager pm = mContext.getPackageManager();
              for (int i = 0; i < N; i++) {
                  SyncStorageEngine.SyncHistoryItem item = items.get(i);
                  SyncStorageEngine.AuthorityInfo authorityInfo
                          = mSyncStorageEngine.getAuthority(item.authorityId);
                  final String authorityName;
                  final String accountKey;
                  if (authorityInfo != null) {
                      authorityName = authorityInfo.target.provider;
                      accountKey = authorityInfo.target.account.name + "/"
                              + authorityInfo.target.account.type
                              + " u" + authorityInfo.target.userId;
                  } else {
                      authorityName = "Unknown";
                      accountKey = "Unknown";
                  }
                  final long elapsedTime = item.elapsedTime;
                  final Time time = new Time();
                  final long eventTime = item.eventTime;
                  time.set(eventTime);
  
                  final String key = authorityName + "/" + accountKey;
                  final Long lastEventTime = lastTimeMap.get(key);
                  final String diffString;
                  if (lastEventTime == null) {
                      diffString = "";
                  } else {
                      final long diff = (lastEventTime - eventTime) / 1000;
                      if (diff < 60) {
                          diffString = String.valueOf(diff);
                      } else if (diff < 3600) {
                          diffString = String.format("%02d:%02d", diff / 60, diff % 60);
                      } else {
                          final long sec = diff % 3600;
                          diffString = String.format("%02d:%02d:%02d",
                                  diff / 3600, sec / 60, sec % 60);
                      }
                  }
                  lastTimeMap.put(key, eventTime);
  
                  pw.printf("  #%-3d: %s %8s  %5.1fs  %8s",
                          i + 1,
                          formatTime(eventTime),
                          SyncStorageEngine.SOURCES[item.source],
                          ((float) elapsedTime) / 1000,
                          diffString);
                  pw.printf(format, accountKey, authorityName,
                          SyncOperation.reasonToString(pm, item.reason));
  
                  if (item.event != SyncStorageEngine.EVENT_STOP
                          || item.upstreamActivity != 0
                          || item.downstreamActivity != 0) {
                      pw.printf("    event=%d upstreamActivity=%d downstreamActivity=%d\n",
                              item.event,
                              item.upstreamActivity,
                              item.downstreamActivity);
                  }
                  if (item.mesg != null
                          && !SyncStorageEngine.MESG_SUCCESS.equals(item.mesg)) {
                      pw.printf("    mesg=%s\n", item.mesg);
                  }
              }
              pw.println();
              pw.println("Recent Sync History Extras");
              pw.println("(SERVER is now split up to FEED and OTHER)");
              for (int i = 0; i < N; i++) {
                  final SyncStorageEngine.SyncHistoryItem item = items.get(i);
                  final Bundle extras = item.extras;
                  if (extras == null || extras.size() == 0) {
                      continue;
                  }
                  final SyncStorageEngine.AuthorityInfo authorityInfo
                          = mSyncStorageEngine.getAuthority(item.authorityId);
                  final String authorityName;
                  final String accountKey;
                  if (authorityInfo != null) {
                      authorityName = authorityInfo.target.provider;
                      accountKey = authorityInfo.target.account.name + "/"
                              + authorityInfo.target.account.type
                              + " u" + authorityInfo.target.userId;
                  } else {
                      authorityName = "Unknown";
                      accountKey = "Unknown";
                  }
                  final Time time = new Time();
                  final long eventTime = item.eventTime;
                  time.set(eventTime);
  
                  pw.printf("  #%-3d: %s %8s ",
                          i + 1,
                          formatTime(eventTime),
                          SyncStorageEngine.SOURCES[item.source]);
  
                  pw.printf(format, accountKey, authorityName, extras);
              }
          }
      }
  
      private void dumpDayStatistics(PrintWriter pw) {
          SyncStorageEngine.DayStats dses[] = mSyncStorageEngine.getDayStatistics();
          if (dses != null && dses[0] != null) {
              pw.println();
              pw.println("Sync Statistics");
              pw.print("  Today:  "); dumpDayStatistic(pw, dses[0]);
              int today = dses[0].day;
              int i;
              SyncStorageEngine.DayStats ds;
  
              // Print each day in the current week.
              for (i=1; i<=6 && i < dses.length; i++) {
                  ds = dses[i];
                  if (ds == null) break;
                  int delta = today-ds.day;
                  if (delta > 6) break;
  
                  pw.print("  Day-"); pw.print(delta); pw.print(":  ");
                  dumpDayStatistic(pw, ds);
              }
  
              // Aggregate all following days into weeks and print totals.
              int weekDay = today;
              while (i < dses.length) {
                  SyncStorageEngine.DayStats aggr = null;
                  weekDay -= 7;
                  while (i < dses.length) {
                      ds = dses[i];
                      if (ds == null) {
                          i = dses.length;
                          break;
                      }
                      int delta = weekDay-ds.day;
                      if (delta > 6) break;
                      i++;
  
                      if (aggr == null) {
                          aggr = new SyncStorageEngine.DayStats(weekDay);
                      }
                      aggr.successCount += ds.successCount;
                      aggr.successTime += ds.successTime;
                      aggr.failureCount += ds.failureCount;
                      aggr.failureTime += ds.failureTime;
                  }
                  if (aggr != null) {
                      pw.print("  Week-"); pw.print((today-weekDay)/7); pw.print(": ");
                      dumpDayStatistic(pw, aggr);
                  }
              }
          }
      }
  
      private void dumpSyncAdapters(IndentingPrintWriter pw) {
          pw.println();
          final List<UserInfo> users = getAllUsers();
          if (users != null) {
              for (UserInfo user : users) {
                  pw.println("Sync adapters for " + user + ":");
                  pw.increaseIndent();
                  for (RegisteredServicesCache.ServiceInfo<?> info :
                          mSyncAdapters.getAllServices(user.id)) {
                      pw.println(info);
                  }
                  pw.decreaseIndent();
                  pw.println();
              }
          }
      }
  
      private static class AuthoritySyncStats {
          String name;
          long elapsedTime;
          int times;
          Map<String, AccountSyncStats> accountMap = Maps.newHashMap();
  
          private AuthoritySyncStats(String name) {
              this.name = name;
          }
      }
  
      private static class AccountSyncStats {
          String name;
          long elapsedTime;
          int times;
  
          private AccountSyncStats(String name) {
              this.name = name;
          }
      }
  
      interface OnReadyCallback {
          void onReady();
      }
  
      static void sendOnUnsyncableAccount(@NonNull Context context,
              @NonNull RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo,
              @UserIdInt int userId, @NonNull OnReadyCallback onReadyCallback) {
          OnUnsyncableAccountCheck connection = new OnUnsyncableAccountCheck(syncAdapterInfo,
                  onReadyCallback);
  
          boolean isBound = context.bindServiceAsUser(
                  getAdapterBindIntent(context, syncAdapterInfo.componentName, userId),
                  connection, SYNC_ADAPTER_CONNECTION_FLAGS, UserHandle.of(userId));
  
          if (isBound) {
              // Unbind after SERVICE_BOUND_TIME_MILLIS to not leak the connection.
              (new Handler(Looper.getMainLooper())).postDelayed(
                      () -> context.unbindService(connection),
                      OnUnsyncableAccountCheck.SERVICE_BOUND_TIME_MILLIS);
          } else {
                  /*
                   * The default implementation of adapter.onUnsyncableAccount returns true. Hence if
                   * there the service cannot be bound, assume the default behavior.
                   */
              connection.onReady();
          }
      }
  
  
      /**
       * Helper class for calling ISyncAdapter.onUnsyncableAccountDone.
       *
       * If this returns {@code true} the onReadyCallback is called. Otherwise nothing happens.
       */
      private static class OnUnsyncableAccountCheck implements ServiceConnection {
          static final long SERVICE_BOUND_TIME_MILLIS = 5000;
  
          private final @NonNull OnReadyCallback mOnReadyCallback;
          private final @NonNull RegisteredServicesCache.ServiceInfo<SyncAdapterType>
                  mSyncAdapterInfo;
  
          OnUnsyncableAccountCheck(
                  @NonNull RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo,
                  @NonNull OnReadyCallback onReadyCallback) {
              mSyncAdapterInfo = syncAdapterInfo;
              mOnReadyCallback = onReadyCallback;
          }
  
          private void onReady() {
              long identity = Binder.clearCallingIdentity();
              try {
                  mOnReadyCallback.onReady();
              } finally {
                  Binder.restoreCallingIdentity(identity);
              }
          }
  
          @Override
          public void onServiceConnected(ComponentName name, IBinder service) {
              final ISyncAdapter adapter = ISyncAdapter.Stub.asInterface(service);
  
              try {
                  adapter.onUnsyncableAccount(new ISyncAdapterUnsyncableAccountCallback.Stub() {
                      @Override
                      public void onUnsyncableAccountDone(boolean isReady) {
                          if (isReady) {
                              onReady();
                          }
                      }
                  });
              } catch (RemoteException e) {
                  Slog.e(TAG, "Could not call onUnsyncableAccountDone " + mSyncAdapterInfo, e);
                  /*
                   * The default implementation of adapter.onUnsyncableAccount returns true. Hence if
                   * there is a crash in the implementation, assume the default behavior.
                   */
                  onReady();
              }
          }
  
          @Override
          public void onServiceDisconnected(ComponentName name) {
              // Wait until the service connects again
          }
      }
  
      /**
       * A helper object to keep track of the time we have spent syncing since the last boot
       */
      private class SyncTimeTracker {
          /** True if a sync was in progress on the most recent call to update() */
          boolean mLastWasSyncing = false;
          /** Used to track when lastWasSyncing was last set */
          long mWhenSyncStarted = 0;
          /** The cumulative time we have spent syncing */
          private long mTimeSpentSyncing;
  
          /** Call to let the tracker know that the sync state may have changed */
          public synchronized void update() {
              final boolean isSyncInProgress = !mActiveSyncContexts.isEmpty();
              if (isSyncInProgress == mLastWasSyncing) return;
              final long now = SystemClock.elapsedRealtime();
              if (isSyncInProgress) {
                  mWhenSyncStarted = now;
              } else {
                  mTimeSpentSyncing += now - mWhenSyncStarted;
              }
              mLastWasSyncing = isSyncInProgress;
          }
  
          /** Get how long we have been syncing, in ms */
          public synchronized long timeSpentSyncing() {
              if (!mLastWasSyncing) return mTimeSpentSyncing;
  
              final long now = SystemClock.elapsedRealtime();
              return mTimeSpentSyncing + (now - mWhenSyncStarted);
          }
      }
  
      class ServiceConnectionData {
          public final ActiveSyncContext activeSyncContext;
          public final IBinder adapter;
  
          ServiceConnectionData(ActiveSyncContext activeSyncContext, IBinder adapter) {
              this.activeSyncContext = activeSyncContext;
              this.adapter = adapter;
          }
      }
  
      @Nullable
      private static SyncManager getInstance() {
          synchronized (SyncManager.class) {
              if (sInstance == null) {
                  Slog.wtf(TAG, "sInstance == null"); // Maybe called too early?
              }
              return sInstance;
          }
      }
  
      /**
       * @return whether the device is ready to run sync jobs for a given user.
       */
      public static boolean readyToSync(int userId) {
          final SyncManager instance = getInstance();
          return (instance != null) && SyncJobService.isReady()
                  && instance.mProvisioned && instance.isUserUnlocked(userId);
      }
  
      public static void sendMessage(Message message) {
          final SyncManager instance = getInstance();
          if (instance != null) {
              instance.mSyncHandler.sendMessage(message);
          }
      }
  
      /**
       * Handles SyncOperation Messages that are posted to the associated
       * HandlerThread.
       */
      class SyncHandler extends Handler {
          // Messages that can be sent on mHandler.
          private static final int MESSAGE_SYNC_FINISHED = 1;
          private static final int MESSAGE_SERVICE_CONNECTED = 4;
          private static final int MESSAGE_SERVICE_DISCONNECTED = 5;
          private static final int MESSAGE_CANCEL = 6;
          static final int MESSAGE_START_SYNC = 10;
          static final int MESSAGE_STOP_SYNC = 11;
          static final int MESSAGE_SCHEDULE_SYNC = 12;
          static final int MESSAGE_UPDATE_PERIODIC_SYNC = 13;
          static final int MESSAGE_REMOVE_PERIODIC_SYNC = 14;
  
          /**
           * Posted periodically to monitor network process for long-running syncs.
           * obj: {@link com.android.server.content.SyncManager.ActiveSyncContext}
           */
          private static final int MESSAGE_MONITOR_SYNC = 8;
          private static final int MESSAGE_ACCOUNTS_UPDATED = 9;
  
          public final SyncTimeTracker mSyncTimeTracker = new SyncTimeTracker();
          private final HashMap<String, PowerManager.WakeLock> mWakeLocks = Maps.newHashMap();
  
          public SyncHandler(Looper looper) {
              super(looper);
          }
  
          public void handleMessage(Message msg) {
              // TODO Do we really need this wake lock?? If we actually needed it, this is probably
              // not the best place to acquire the lock -- it's probably too late, because the device
              // could have gone to sleep before we reach here.
              mSyncManagerWakeLock.acquire();
              try {
                  handleSyncMessage(msg);
              } finally {
                  mSyncManagerWakeLock.release();
              }
          }
  
          private void handleSyncMessage(Message msg) {
              final boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE);
  
              try {
                  mDataConnectionIsConnected = readDataConnectionState();
                  switch (msg.what) {
                      case MESSAGE_ACCOUNTS_UPDATED:
                          if (Log.isLoggable(TAG, Log.VERBOSE)) {
                              Slog.v(TAG, "handleSyncHandlerMessage: MESSAGE_ACCOUNTS_UPDATED");
                          }
                          EndPoint targets = (EndPoint) msg.obj;
                          updateRunningAccountsH(targets);
                          break;
                      case MESSAGE_SCHEDULE_SYNC:
                          ScheduleSyncMessagePayload syncPayload =
                                  (ScheduleSyncMessagePayload) msg.obj;
                          SyncOperation op = syncPayload.syncOperation;
                          scheduleSyncOperationH(op, syncPayload.minDelayMillis);
                          break;
  
                      case MESSAGE_START_SYNC:
                          op = (SyncOperation) msg.obj;
                          startSyncH(op);
                          break;
  
                      case MESSAGE_STOP_SYNC:
                          op = (SyncOperation) msg.obj;
                          if (isLoggable) {
                              Slog.v(TAG, "Stop sync received.");
                          }
                          ActiveSyncContext asc = findActiveSyncContextH(op.jobId);
                          if (asc != null) {
                              runSyncFinishedOrCanceledH(null /* no result */, asc);
                              boolean reschedule = msg.arg1 != 0;
                              boolean applyBackoff = msg.arg2 != 0;
                              if (isLoggable) {
                                  Slog.v(TAG, "Stopping sync. Reschedule: " + reschedule
                                          + "Backoff: " + applyBackoff);
                              }
                              if (applyBackoff) {
                                  increaseBackoffSetting(op.target);
                              }
                              if (reschedule) {
                                  deferStoppedSyncH(op, 0);
                              }
                          }
                          break;
  
                      case MESSAGE_UPDATE_PERIODIC_SYNC:
                          UpdatePeriodicSyncMessagePayload data =
                                  (UpdatePeriodicSyncMessagePayload) msg.obj;
                          updateOrAddPeriodicSyncH(data.target, data.pollFrequency,
                                  data.flex, data.extras);
                          break;
                      case MESSAGE_REMOVE_PERIODIC_SYNC:
                          Pair<EndPoint, String> args = (Pair<EndPoint, String>) (msg.obj);
                          removePeriodicSyncH(args.first, msg.getData(), args.second);
                          break;
  
                      case SyncHandler.MESSAGE_CANCEL:
                          SyncStorageEngine.EndPoint endpoint = (SyncStorageEngine.EndPoint) msg.obj;
                          Bundle extras = msg.peekData();
                          if (isLoggable) {
                              Log.d(TAG, "handleSyncHandlerMessage: MESSAGE_CANCEL: "
                                      + endpoint + " bundle: " + extras);
                          }
                          cancelActiveSyncH(endpoint, extras, "MESSAGE_CANCEL");
                          break;
  
                      case SyncHandler.MESSAGE_SYNC_FINISHED:
                          SyncFinishedOrCancelledMessagePayload payload =
                                  (SyncFinishedOrCancelledMessagePayload) msg.obj;
                          if (!isSyncStillActiveH(payload.activeSyncContext)) {
                              if (isLoggable) {
                                  Log.d(TAG, "handleSyncHandlerMessage: dropping since the "
                                          + "sync is no longer active: "
                                          + payload.activeSyncContext);
                              }
                              break;
                          }
                          if (isLoggable) {
                              Slog.v(TAG, "syncFinished" + payload.activeSyncContext.mSyncOperation);
                          }
                          SyncJobService.callJobFinished(
                                  payload.activeSyncContext.mSyncOperation.jobId, false,
                                  "sync finished");
                          runSyncFinishedOrCanceledH(payload.syncResult,
                                  payload.activeSyncContext);
                          break;
  
                      case SyncHandler.MESSAGE_SERVICE_CONNECTED: {
                          ServiceConnectionData msgData = (ServiceConnectionData) msg.obj;
                          if (isLoggable) {
                              Log.d(TAG, "handleSyncHandlerMessage: MESSAGE_SERVICE_CONNECTED: "
                                      + msgData.activeSyncContext);
                          }
                          // Check that this isn't an old message.
                          if (isSyncStillActiveH(msgData.activeSyncContext)) {
                              runBoundToAdapterH(
                                      msgData.activeSyncContext,
                                      msgData.adapter);
                          }
                          break;
                      }
  
                      case SyncHandler.MESSAGE_SERVICE_DISCONNECTED: {
                          final ActiveSyncContext currentSyncContext =
                                  ((ServiceConnectionData) msg.obj).activeSyncContext;
                          if (isLoggable) {
                              Log.d(TAG, "handleSyncHandlerMessage: MESSAGE_SERVICE_DISCONNECTED: "
                                      + currentSyncContext);
                          }
                          // Check that this isn't an old message.
                          if (isSyncStillActiveH(currentSyncContext)) {
                              // cancel the sync if we have a syncadapter, which means one is
                              // outstanding
                              try {
                                  if (currentSyncContext.mSyncAdapter != null) {
                                      mLogger.log("Calling cancelSync for SERVICE_DISCONNECTED ",
                                              currentSyncContext,
                                              " adapter=", currentSyncContext.mSyncAdapter);
                                      currentSyncContext.mSyncAdapter.cancelSync(currentSyncContext);
                                      mLogger.log("Canceled");
                                  }
                              } catch (RemoteException e) {
                                  mLogger.log("RemoteException ", Log.getStackTraceString(e));
                                  // We don't need to retry this in this case.
                              }
  
                              // Pretend that the sync failed with an IOException,
                              // which is a soft error.
                              SyncResult syncResult = new SyncResult();
                              syncResult.stats.numIoExceptions++;
                              SyncJobService.callJobFinished(
                                      currentSyncContext.mSyncOperation.jobId, false,
                                      "service disconnected");
                              runSyncFinishedOrCanceledH(syncResult, currentSyncContext);
                          }
                          break;
                      }
  
                      case SyncHandler.MESSAGE_MONITOR_SYNC:
                          ActiveSyncContext monitoredSyncContext = (ActiveSyncContext) msg.obj;
                          if (isLoggable) {
                              Log.d(TAG, "handleSyncHandlerMessage: MESSAGE_MONITOR_SYNC: " +
                                      monitoredSyncContext.mSyncOperation.target);
                          }
  
                          if (isSyncNotUsingNetworkH(monitoredSyncContext)) {
                              Log.w(TAG, String.format(
                                      "Detected sync making no progress for %s. cancelling.",
                                      logSafe(monitoredSyncContext)));
                              SyncJobService.callJobFinished(
                                      monitoredSyncContext.mSyncOperation.jobId, false,
                                      "no network activity");
                              runSyncFinishedOrCanceledH(
                                      null /* cancel => no result */, monitoredSyncContext);
                          } else {
                              // Repost message to check again.
                              postMonitorSyncProgressMessage(monitoredSyncContext);
                          }
                          break;
  
                  }
              } finally {
                  mSyncTimeTracker.update();
              }
          }
  
          private PowerManager.WakeLock getSyncWakeLock(SyncOperation operation) {
              final String wakeLockKey = operation.wakeLockName();
              PowerManager.WakeLock wakeLock = mWakeLocks.get(wakeLockKey);
              if (wakeLock == null) {
                  final String name = SYNC_WAKE_LOCK_PREFIX + wakeLockKey;
                  wakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, name);
                  wakeLock.setReferenceCounted(false);
                  mWakeLocks.put(wakeLockKey, wakeLock);
              }
              return wakeLock;
          }
  
          /**
           * Defer the specified SyncOperation by rescheduling it on the JobScheduler with some
           * delay. This is equivalent to a failure. If this is a periodic sync, a delayed one-off
           * sync will be scheduled.
           */
          private void deferSyncH(SyncOperation op, long delay, String why) {
              mLogger.log("deferSyncH() ", (op.isPeriodic ? "periodic " : ""),
                      "sync.  op=", op, " delay=", delay, " why=", why);
              SyncJobService.callJobFinished(op.jobId, false, why);
              if (op.isPeriodic) {
                  scheduleSyncOperationH(op.createOneTimeSyncOperation(), delay);
              } else {
                  // mSyncJobService.callJobFinished is async, so cancel the job to ensure we don't
                  // find the this job in the pending jobs list while looking for duplicates
                  // before scheduling it at a later time.
                  cancelJob(op, "deferSyncH()");
                  scheduleSyncOperationH(op, delay);
              }
          }
  
          /* Same as deferSyncH, but assumes that job is no longer running on JobScheduler. */
          private void deferStoppedSyncH(SyncOperation op, long delay) {
              if (op.isPeriodic) {
                  scheduleSyncOperationH(op.createOneTimeSyncOperation(), delay);
              } else {
                  scheduleSyncOperationH(op, delay);
              }
          }
  
          /**
           * Cancel an active sync and reschedule it on the JobScheduler with some delay.
           */
          private void deferActiveSyncH(ActiveSyncContext asc, String why) {
              SyncOperation op = asc.mSyncOperation;
              runSyncFinishedOrCanceledH(null, asc);
              deferSyncH(op, SYNC_DELAY_ON_CONFLICT, why);
          }
  
          private void startSyncH(SyncOperation op) {
              final boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE);
              if (isLoggable) Slog.v(TAG, op.toString());
  
              // At this point, we know the device has been connected to the server, so
              // assume the clock is correct.
              mSyncStorageEngine.setClockValid();
  
              SyncJobService.markSyncStarted(op.jobId);
  
              if (mStorageIsLow) {
                  deferSyncH(op, SYNC_DELAY_ON_LOW_STORAGE, "storage low");
                  return;
              }
  
              if (op.isPeriodic) {
                  // Don't allow this periodic to run if a previous instance failed and is currently
                  // scheduled according to some backoff criteria.
                  List<SyncOperation> ops = getAllPendingSyncs();
                  for (SyncOperation syncOperation: ops) {
                      if (syncOperation.sourcePeriodicId == op.jobId) {
                          SyncJobService.callJobFinished(op.jobId, false,
                                  "periodic sync, pending");
                          return;
                      }
                  }
                  // Don't allow this periodic to run if a previous instance failed and is currently
                  // executing according to some backoff criteria.
                  for (ActiveSyncContext asc: mActiveSyncContexts) {
                      if (asc.mSyncOperation.sourcePeriodicId == op.jobId) {
                          SyncJobService.callJobFinished(op.jobId, false,
                                  "periodic sync, already running");
                          return;
                      }
                  }
                  // Check for adapter delays.
                  if (isAdapterDelayed(op.target)) {
                      deferSyncH(op, 0 /* No minimum delay */, "backing off");
                      return;
                  }
              }
  
              // Check for conflicting syncs.
              for (ActiveSyncContext asc: mActiveSyncContexts) {
                  if (asc.mSyncOperation.isConflict(op)) {
                      // If the provided SyncOperation conflicts with a running one, the lower
                      // priority sync is pre-empted.
                      if (asc.mSyncOperation.findPriority() >= op.findPriority()) {
                          if (isLoggable) {
                              Slog.v(TAG, "Rescheduling sync due to conflict " + op.toString());
                          }
                          deferSyncH(op, SYNC_DELAY_ON_CONFLICT, "delay on conflict");
                          return;
                      } else {
                          if (isLoggable) {
                              Slog.v(TAG, "Pushing back running sync due to a higher priority sync");
                          }
                          deferActiveSyncH(asc, "preempted");
                          break;
                      }
                  }
              }
  
              final int syncOpState = computeSyncOpState(op);
              switch (syncOpState) {
                  case SYNC_OP_STATE_INVALID_NO_ACCOUNT_ACCESS:
                  case SYNC_OP_STATE_INVALID: {
                      SyncJobService.callJobFinished(op.jobId, false,
                              "invalid op state: " + syncOpState);
                  } return;
              }
  
              if (!dispatchSyncOperation(op)) {
                  SyncJobService.callJobFinished(op.jobId, false, "dispatchSyncOperation() failed");
              }
  
              setAuthorityPendingState(op.target);
          }
  
          private ActiveSyncContext findActiveSyncContextH(int jobId) {
              for (ActiveSyncContext asc: mActiveSyncContexts) {
                  SyncOperation op = asc.mSyncOperation;
                  if (op != null && op.jobId == jobId) {
                      return asc;
                  }
              }
              return null;
          }
  
          private void updateRunningAccountsH(EndPoint syncTargets) {
              AccountAndUser[] oldAccounts = mRunningAccounts;
              mRunningAccounts = AccountManagerService.getSingleton().getRunningAccounts();
              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                  Slog.v(TAG, "Accounts list: ");
                  for (AccountAndUser acc : mRunningAccounts) {
                      Slog.v(TAG, acc.toString());
                  }
              }
              if (mLogger.enabled()) {
                  mLogger.log("updateRunningAccountsH: ", Arrays.toString(mRunningAccounts));
              }
              removeStaleAccounts();
  
              AccountAndUser[] accounts = mRunningAccounts;
              for (ActiveSyncContext currentSyncContext : mActiveSyncContexts) {
                  if (!containsAccountAndUser(accounts,
                          currentSyncContext.mSyncOperation.target.account,
                          currentSyncContext.mSyncOperation.target.userId)) {
                      Log.d(TAG, "canceling sync since the account is no longer running");
                      sendSyncFinishedOrCanceledMessage(currentSyncContext,
                              null /* no result since this is a cancel */);
                  }
              }
  
              if (syncTargets != null) {
                  // On account add, check if there are any settings to be restored.
                  for (AccountAndUser aau : mRunningAccounts) {
                      if (!containsAccountAndUser(oldAccounts, aau.account, aau.userId)) {
                          if (Log.isLoggable(TAG, Log.DEBUG)) {
                              Log.d(TAG, "Account " + aau.account
                                      + " added, checking sync restore data");
                          }
                          AccountSyncSettingsBackupHelper.accountAdded(mContext, syncTargets.userId);
                          break;
                      }
                  }
              }
  
              // Cancel all jobs from non-existent accounts.
              AccountAndUser[] allAccounts = AccountManagerService.getSingleton().getAllAccounts();
              List<SyncOperation> ops = getAllPendingSyncs();
              for (SyncOperation op: ops) {
                  if (!containsAccountAndUser(allAccounts, op.target.account, op.target.userId)) {
                      mLogger.log("canceling: ", op);
                      cancelJob(op, "updateRunningAccountsH()");
                  }
              }
  
              if (syncTargets != null) {
                  scheduleSync(syncTargets.account, syncTargets.userId,
                          SyncOperation.REASON_ACCOUNTS_UPDATED, syncTargets.provider,
                          null, AuthorityInfo.NOT_INITIALIZED,
                          ContentResolver.SYNC_EXEMPTION_NONE, Process.myUid(), -4, null);
              }
          }
  
          /**
           * The given SyncOperation will be removed and a new one scheduled in its place if
           * an updated period or flex is specified.
           * @param syncOperation SyncOperation whose period and flex is to be updated.
           * @param pollFrequencyMillis new period in milliseconds.
           * @param flexMillis new flex time in milliseconds.
           */
          private void maybeUpdateSyncPeriodH(SyncOperation syncOperation, long pollFrequencyMillis,
                  long flexMillis) {
              if (!(pollFrequencyMillis == syncOperation.periodMillis
                      && flexMillis == syncOperation.flexMillis)) {
                  if (Log.isLoggable(TAG, Log.VERBOSE)) {
                      Slog.v(TAG, "updating period " + syncOperation + " to " + pollFrequencyMillis
                              + " and flex to " + flexMillis);
                  }
                  SyncOperation newOp = new SyncOperation(syncOperation, pollFrequencyMillis,
                          flexMillis);
                  newOp.jobId = syncOperation.jobId;
                  scheduleSyncOperationH(newOp);
              }
          }
  
          private void updateOrAddPeriodicSyncH(EndPoint target, long pollFrequency, long flex,
                  Bundle extras) {
              final boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE);
              verifyJobScheduler();  // Will fill in mScheduledSyncs cache if it is not already filled.
              final long pollFrequencyMillis = pollFrequency * 1000L;
              final long flexMillis = flex * 1000L;
              if (isLoggable) {
                  Slog.v(TAG, "Addition to periodic syncs requested: " + target
                          + " period: " + pollFrequency
                          + " flexMillis: " + flex
                          + " extras: " + extras.toString());
              }
              List<SyncOperation> ops = getAllPendingSyncs();
              for (SyncOperation op: ops) {
                  if (op.isPeriodic && op.target.matchesSpec(target)
                          && syncExtrasEquals(op.extras, extras, true /* includeSyncSettings */)) {
                      maybeUpdateSyncPeriodH(op, pollFrequencyMillis, flexMillis);
                      return;
                  }
              }
  
              if (isLoggable) {
                  Slog.v(TAG, "Adding new periodic sync: " + target
                          + " period: " + pollFrequency
                          + " flexMillis: " + flex
                          + " extras: " + extras.toString());
              }
  
              final RegisteredServicesCache.ServiceInfo<SyncAdapterType>
                      syncAdapterInfo = mSyncAdapters.getServiceInfo(
                      SyncAdapterType.newKey(
                              target.provider, target.account.type),
                      target.userId);
              if (syncAdapterInfo == null) {
                  return;
              }
  
              SyncOperation op = new SyncOperation(target, syncAdapterInfo.uid,
                      syncAdapterInfo.componentName.getPackageName(), SyncOperation.REASON_PERIODIC,
                      SyncStorageEngine.SOURCE_PERIODIC, extras,
                      syncAdapterInfo.type.allowParallelSyncs(), true, SyncOperation.NO_JOB_ID,
                      pollFrequencyMillis, flexMillis, ContentResolver.SYNC_EXEMPTION_NONE);
  
              final int syncOpState = computeSyncOpState(op);
              switch (syncOpState) {
                  case SYNC_OP_STATE_INVALID_NO_ACCOUNT_ACCESS: {
                      String packageName = op.owningPackage;
                      final int userId = UserHandle.getUserId(op.owningUid);
                      // If the app did not run and has no account access, done
                      if (!wasPackageEverLaunched(packageName, userId)) {
                          return;
                      }
                      mAccountManagerInternal.requestAccountAccess(op.target.account,
                              packageName, userId, new RemoteCallback((Bundle result) -> {
                                  if (result != null
                                          && result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT)) {
                                      updateOrAddPeriodicSync(target, pollFrequency, flex, extras);
                                  }
                              }
                          ));
                  } return;
  
                  case SYNC_OP_STATE_INVALID: {
                      return;
                  }
              }
  
              scheduleSyncOperationH(op);
              mSyncStorageEngine.reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS,
                      target.userId);
          }
  
          /**
           * Remove this periodic sync operation and all one-off operations initiated by it.
           */
          private void removePeriodicSyncInternalH(SyncOperation syncOperation, String why) {
              // Remove this periodic sync and all one-off syncs initiated by it.
              List<SyncOperation> ops = getAllPendingSyncs();
              for (SyncOperation op: ops) {
                  if (op.sourcePeriodicId == syncOperation.jobId || op.jobId == syncOperation.jobId) {
                      ActiveSyncContext asc = findActiveSyncContextH(syncOperation.jobId);
                      if (asc != null) {
                          SyncJobService.callJobFinished(syncOperation.jobId, false,
                                  "removePeriodicSyncInternalH");
                          runSyncFinishedOrCanceledH(null, asc);
                      }
                      mLogger.log("removePeriodicSyncInternalH-canceling: ", op);
                      cancelJob(op, why);
                  }
              }
          }
  
          private void removePeriodicSyncH(EndPoint target, Bundle extras, String why) {
              verifyJobScheduler();
              List<SyncOperation> ops = getAllPendingSyncs();
              for (SyncOperation op: ops) {
                  if (op.isPeriodic && op.target.matchesSpec(target)
                          && syncExtrasEquals(op.extras, extras, true /* includeSyncSettings */)) {
                      removePeriodicSyncInternalH(op, why);
                  }
              }
          }
  
          private boolean isSyncNotUsingNetworkH(ActiveSyncContext activeSyncContext) {
              final long bytesTransferredCurrent =
                      getTotalBytesTransferredByUid(activeSyncContext.mSyncAdapterUid);
              final long deltaBytesTransferred =
                      bytesTransferredCurrent - activeSyncContext.mBytesTransferredAtLastPoll;
  
              if (Log.isLoggable(TAG, Log.DEBUG)) {
                  // Bytes transferred
                  long remainder = deltaBytesTransferred;
                  long mb = remainder / (1024 * 1024);
                  remainder %= 1024 * 1024;
                  long kb = remainder / 1024;
                  remainder %= 1024;
                  long b = remainder;
                  Log.d(TAG, String.format(
                          "Time since last update: %ds. Delta transferred: %dMBs,%dKBs,%dBs",
                          (SystemClock.elapsedRealtime()
                                  - activeSyncContext.mLastPolledTimeElapsed)/1000,
                          mb, kb, b)
                  );
              }
              return (deltaBytesTransferred <= SYNC_MONITOR_PROGRESS_THRESHOLD_BYTES);
          }
  
          /**
           * Determine if a sync is no longer valid and should be dropped.
           */
          private int computeSyncOpState(SyncOperation op) {
              final boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE);
              int state;
              final EndPoint target = op.target;
  
              // Drop the sync if the account of this operation no longer exists.
              AccountAndUser[] accounts = mRunningAccounts;
              if (!containsAccountAndUser(accounts, target.account, target.userId)) {
                  if (isLoggable) {
                      Slog.v(TAG, "    Dropping sync operation: account doesn't exist.");
                  }
                  return SYNC_OP_STATE_INVALID;
              }
              // Drop this sync request if it isn't syncable.
              state = computeSyncable(target.account, target.userId, target.provider, true);
              if (state == AuthorityInfo.SYNCABLE_NO_ACCOUNT_ACCESS) {
                  if (isLoggable) {
                      Slog.v(TAG, "    Dropping sync operation: "
                              + "isSyncable == SYNCABLE_NO_ACCOUNT_ACCESS");
                  }
                  return SYNC_OP_STATE_INVALID_NO_ACCOUNT_ACCESS;
              }
              if (state == AuthorityInfo.NOT_SYNCABLE) {
                  if (isLoggable) {
                      Slog.v(TAG, "    Dropping sync operation: isSyncable == NOT_SYNCABLE");
                  }
                  return SYNC_OP_STATE_INVALID;
              }
  
              final boolean syncEnabled = mSyncStorageEngine.getMasterSyncAutomatically(target.userId)
                      && mSyncStorageEngine.getSyncAutomatically(target.account,
                              target.userId, target.provider);
  
              // We ignore system settings that specify the sync is invalid if:
              // 1) It's manual - we try it anyway. When/if it fails it will be rescheduled.
              //      or
              // 2) it's an initialisation sync - we just need to connect to it.
              final boolean ignoreSystemConfiguration = op.isIgnoreSettings() || (state < 0);
  
              // Sync not enabled.
              if (!syncEnabled && !ignoreSystemConfiguration) {
                  if (isLoggable) {
                      Slog.v(TAG, "    Dropping sync operation: disallowed by settings/network.");
                  }
                  return SYNC_OP_STATE_INVALID;
              }
              return SYNC_OP_STATE_VALID;
          }
  
          private boolean dispatchSyncOperation(SyncOperation op) {
              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                  Slog.v(TAG, "dispatchSyncOperation: we are going to sync " + op);
                  Slog.v(TAG, "num active syncs: " + mActiveSyncContexts.size());
                  for (ActiveSyncContext syncContext : mActiveSyncContexts) {
                      Slog.v(TAG, syncContext.toString());
                  }
              }
              if (op.isAppStandbyExempted()) {
                  final UsageStatsManagerInternal usmi = LocalServices.getService(
                          UsageStatsManagerInternal.class);
                  if (usmi != null) {
                      usmi.reportExemptedSyncStart(op.owningPackage,
                              UserHandle.getUserId(op.owningUid));
                  }
              }
  
              // Connect to the sync adapter.
              int targetUid;
              ComponentName targetComponent;
              final SyncStorageEngine.EndPoint info = op.target;
              SyncAdapterType syncAdapterType =
                      SyncAdapterType.newKey(info.provider, info.account.type);
              final RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo;
              syncAdapterInfo = mSyncAdapters.getServiceInfo(syncAdapterType, info.userId);
              if (syncAdapterInfo == null) {
                  mLogger.log("dispatchSyncOperation() failed: no sync adapter info for ",
                          syncAdapterType);
                  Log.d(TAG, "can't find a sync adapter for " + syncAdapterType
                          + ", removing settings for it");
                  mSyncStorageEngine.removeAuthority(info);
                  return false;
              }
              targetUid = syncAdapterInfo.uid;
              targetComponent = syncAdapterInfo.componentName;
              ActiveSyncContext activeSyncContext =
                      new ActiveSyncContext(op, insertStartSyncEvent(op), targetUid);
              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                  Slog.v(TAG, "dispatchSyncOperation: starting " + activeSyncContext);
              }
  
              activeSyncContext.mSyncInfo = mSyncStorageEngine.addActiveSync(activeSyncContext);
              mActiveSyncContexts.add(activeSyncContext);
  
              // Post message to begin monitoring this sync's progress.
              postMonitorSyncProgressMessage(activeSyncContext);
  
              if (!activeSyncContext.bindToSyncAdapter(targetComponent, info.userId)) {
                  mLogger.log("dispatchSyncOperation() failed: bind failed. target: ",
                          targetComponent);
                  Slog.e(TAG, "Bind attempt failed - target: " + targetComponent);
                  closeActiveSyncContext(activeSyncContext);
                  return false;
              }
  
              return true;
          }
  
          private void runBoundToAdapterH(final ActiveSyncContext activeSyncContext,
                  IBinder syncAdapter) {
              final SyncOperation syncOperation = activeSyncContext.mSyncOperation;
              try {
                  activeSyncContext.mIsLinkedToDeath = true;
                  syncAdapter.linkToDeath(activeSyncContext, 0);
  
                  mLogger.log("Sync start: account=" + syncOperation.target.account,
                          " authority=", syncOperation.target.provider,
                          " reason=", SyncOperation.reasonToString(null, syncOperation.reason),
                          " extras=", SyncOperation.extrasToString(syncOperation.extras),
                          " adapter=", activeSyncContext.mSyncAdapter);
  
                  activeSyncContext.mSyncAdapter = ISyncAdapter.Stub.asInterface(syncAdapter);
                  activeSyncContext.mSyncAdapter
                          .startSync(activeSyncContext, syncOperation.target.provider,
                                  syncOperation.target.account, syncOperation.extras);
  
                  mLogger.log("Sync is running now...");
              } catch (RemoteException remoteExc) {
                  mLogger.log("Sync failed with RemoteException: ", remoteExc.toString());
                  Log.d(TAG, "maybeStartNextSync: caught a RemoteException, rescheduling", remoteExc);
                  closeActiveSyncContext(activeSyncContext);
                  increaseBackoffSetting(syncOperation.target);
                  scheduleSyncOperationH(syncOperation);
              } catch (RuntimeException exc) {
                  mLogger.log("Sync failed with RuntimeException: ", exc.toString());
                  closeActiveSyncContext(activeSyncContext);
                  Slog.e(TAG, "Caught RuntimeException while starting the sync "
                          + logSafe(syncOperation), exc);
              }
          }
  
          /**
           * Cancel the sync for the provided target that matches the given bundle.
           * @param info Can have null fields to indicate all the active syncs for that field.
           * @param extras Can be null to indicate <strong>all</strong> syncs for the given endpoint.
           */
          private void cancelActiveSyncH(SyncStorageEngine.EndPoint info, Bundle extras,
                  String why) {
              ArrayList<ActiveSyncContext> activeSyncs =
                      new ArrayList<ActiveSyncContext>(mActiveSyncContexts);
              for (ActiveSyncContext activeSyncContext : activeSyncs) {
                  if (activeSyncContext != null) {
                      final SyncStorageEngine.EndPoint opInfo =
                              activeSyncContext.mSyncOperation.target;
                      if (!opInfo.matchesSpec(info)) {
                          continue;
                      }
                      if (extras != null &&
                              !syncExtrasEquals(activeSyncContext.mSyncOperation.extras,
                                      extras,
                                      false /* no config settings */)) {
                          continue;
                      }
                      SyncJobService.callJobFinished(activeSyncContext.mSyncOperation.jobId, false,
                              why);
                      runSyncFinishedOrCanceledH(null /* cancel => no result */, activeSyncContext);
                  }
              }
          }
  
          /**
           * Should be called when a one-off instance of a periodic sync completes successfully.
           */
          private void reschedulePeriodicSyncH(SyncOperation syncOperation) {
              // Ensure that the periodic sync wasn't removed.
              SyncOperation periodicSync = null;
              List<SyncOperation> ops = getAllPendingSyncs();
              for (SyncOperation op: ops) {
                  if (op.isPeriodic && syncOperation.matchesPeriodicOperation(op)) {
                      periodicSync = op;
                      break;
                  }
              }
              if (periodicSync == null) {
                  return;
              }
              scheduleSyncOperationH(periodicSync);
          }
  
          private void runSyncFinishedOrCanceledH(SyncResult syncResult,
                  ActiveSyncContext activeSyncContext) {
              final boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE);
  
              final SyncOperation syncOperation = activeSyncContext.mSyncOperation;
              final SyncStorageEngine.EndPoint info = syncOperation.target;
  
              if (activeSyncContext.mIsLinkedToDeath) {
                  activeSyncContext.mSyncAdapter.asBinder().unlinkToDeath(activeSyncContext, 0);
                  activeSyncContext.mIsLinkedToDeath = false;
              }
              final long elapsedTime = SystemClock.elapsedRealtime() - activeSyncContext.mStartTime;
              String historyMessage;
              int downstreamActivity;
              int upstreamActivity;
  
              mLogger.log("runSyncFinishedOrCanceledH() op=", syncOperation, " result=", syncResult);
  
              if (syncResult != null) {
                  if (isLoggable) {
                      Slog.v(TAG, "runSyncFinishedOrCanceled [finished]: "
                              + syncOperation + ", result " + syncResult);
                  }
  
                  // In the non-canceled case, close the active sync context before doing the rest
                  // of the stuff.
                  closeActiveSyncContext(activeSyncContext);
  
                  // Note this part is probably okay to do before closeActiveSyncContext()...
                  // But moved here to restore OC-dev's behavior.  See b/64597061.
                  if (!syncOperation.isPeriodic) {
                      cancelJob(syncOperation, "runSyncFinishedOrCanceledH()-finished");
                  }
  
                  if (!syncResult.hasError()) {
                      historyMessage = SyncStorageEngine.MESG_SUCCESS;
                      // TODO: set these correctly when the SyncResult is extended to include it
                      downstreamActivity = 0;
                      upstreamActivity = 0;
                      clearBackoffSetting(syncOperation.target, "sync success");
  
                      // If the operation completes successfully and it was scheduled due to
                      // a periodic operation failing, we reschedule the periodic operation to
                      // start from now.
                      if (syncOperation.isDerivedFromFailedPeriodicSync()) {
                          reschedulePeriodicSyncH(syncOperation);
                      }
                  } else {
                      Log.w(TAG, "failed sync operation "
                              + logSafe(syncOperation) + ", " + syncResult);
  
                      syncOperation.retries++;
                      if (syncOperation.retries > mConstants.getMaxRetriesWithAppStandbyExemption()) {
                          syncOperation.syncExemptionFlag = ContentResolver.SYNC_EXEMPTION_NONE;
                      }
  
                      // the operation failed so increase the backoff time
                      increaseBackoffSetting(syncOperation.target);
                      if (!syncOperation.isPeriodic) {
                          // reschedule the sync if so indicated by the syncResult
                          maybeRescheduleSync(syncResult, syncOperation);
                      } else {
                          // create a normal sync instance that will respect adapter backoffs
                          postScheduleSyncMessage(syncOperation.createOneTimeSyncOperation(),
                                  0 /* min delay */);
                      }
                      historyMessage = ContentResolver.syncErrorToString(
                              syncResultToErrorNumber(syncResult));
                      // TODO: set these correctly when the SyncResult is extended to include it
                      downstreamActivity = 0;
                      upstreamActivity = 0;
                  }
                  setDelayUntilTime(syncOperation.target, syncResult.delayUntil);
              } else {
                  if (isLoggable) {
                      Slog.v(TAG, "runSyncFinishedOrCanceled [canceled]: " + syncOperation);
                  }
  
                  if (!syncOperation.isPeriodic) {
                      cancelJob(syncOperation, "runSyncFinishedOrCanceledH()-canceled");
                  }
  
                  if (activeSyncContext.mSyncAdapter != null) {
                      try {
                          mLogger.log("Calling cancelSync for runSyncFinishedOrCanceled ",
                                  activeSyncContext, "  adapter=", activeSyncContext.mSyncAdapter);
                          activeSyncContext.mSyncAdapter.cancelSync(activeSyncContext);
                          mLogger.log("Canceled");
                      } catch (RemoteException e) {
                          mLogger.log("RemoteException ", Log.getStackTraceString(e));
                          // we don't need to retry this in this case
                      }
                  }
                  historyMessage = SyncStorageEngine.MESG_CANCELED;
                  downstreamActivity = 0;
                  upstreamActivity = 0;
  
                  // In the cancel sync case, close it after calling cancelSync().
                  closeActiveSyncContext(activeSyncContext);
              }
  
              stopSyncEvent(activeSyncContext.mHistoryRowId, syncOperation, historyMessage,
                      upstreamActivity, downstreamActivity, elapsedTime);
              // Check for full-resync and schedule it after closing off the last sync.
              if (syncResult != null && syncResult.tooManyDeletions) {
                  installHandleTooManyDeletesNotification(info.account,
                          info.provider, syncResult.stats.numDeletes,
                          info.userId);
              } else {
                  mNotificationMgr.cancelAsUser(
                          Integer.toString(info.account.hashCode() ^ info.provider.hashCode()),
                          SystemMessage.NOTE_SYNC_ERROR,
                          new UserHandle(info.userId));
              }
              if (syncResult != null && syncResult.fullSyncRequested) {
                  scheduleSyncOperationH(
                          new SyncOperation(info.account, info.userId,
                                  syncOperation.owningUid, syncOperation.owningPackage,
                                  syncOperation.reason,
                                  syncOperation.syncSource, info.provider, new Bundle(),
                                  syncOperation.allowParallelSyncs,
                                  syncOperation.syncExemptionFlag));
              }
          }
  
          private void closeActiveSyncContext(ActiveSyncContext activeSyncContext) {
              activeSyncContext.close();
              mActiveSyncContexts.remove(activeSyncContext);
              mSyncStorageEngine.removeActiveSync(activeSyncContext.mSyncInfo,
                      activeSyncContext.mSyncOperation.target.userId);
  
              if (Log.isLoggable(TAG, Log.VERBOSE)) {
                  Slog.v(TAG, "removing all MESSAGE_MONITOR_SYNC & MESSAGE_SYNC_EXPIRED for "
                          + activeSyncContext.toString());
              }
              mSyncHandler.removeMessages(SyncHandler.MESSAGE_MONITOR_SYNC, activeSyncContext);
  
              mLogger.log("closeActiveSyncContext: ", activeSyncContext);
          }
  
          /**
           * Convert the error-containing SyncResult into the Sync.History error number. Since
           * the SyncResult may indicate multiple errors at once, this method just returns the
           * most "serious" error.
           * @param syncResult the SyncResult from which to read
           * @return the most "serious" error set in the SyncResult
           * @throws IllegalStateException if the SyncResult does not indicate any errors.
           *   If SyncResult.error() is true then it is safe to call this.
           */
          private int syncResultToErrorNumber(SyncResult syncResult) {
              if (syncResult.syncAlreadyInProgress)
                  return ContentResolver.SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS;
              if (syncResult.stats.numAuthExceptions > 0)
                  return ContentResolver.SYNC_ERROR_AUTHENTICATION;
              if (syncResult.stats.numIoExceptions > 0)
                  return ContentResolver.SYNC_ERROR_IO;
              if (syncResult.stats.numParseExceptions > 0)
                  return ContentResolver.SYNC_ERROR_PARSE;
              if (syncResult.stats.numConflictDetectedExceptions > 0)
                  return ContentResolver.SYNC_ERROR_CONFLICT;
              if (syncResult.tooManyDeletions)
                  return ContentResolver.SYNC_ERROR_TOO_MANY_DELETIONS;
              if (syncResult.tooManyRetries)
                  return ContentResolver.SYNC_ERROR_TOO_MANY_RETRIES;
              if (syncResult.databaseError)
                  return ContentResolver.SYNC_ERROR_INTERNAL;
              throw new IllegalStateException("we are not in an error state, " + syncResult);
          }
  
          private void installHandleTooManyDeletesNotification(Account account, String authority,
                  long numDeletes, int userId) {
              if (mNotificationMgr == null) return;
  
              final ProviderInfo providerInfo = mContext.getPackageManager().resolveContentProvider(
                      authority, 0 /* flags */);
              if (providerInfo == null) {
                  return;
              }
              CharSequence authorityName = providerInfo.loadLabel(mContext.getPackageManager());
  
              Intent clickIntent = new Intent(mContext, SyncActivityTooManyDeletes.class);
              clickIntent.putExtra("account", account);
              clickIntent.putExtra("authority", authority);
              clickIntent.putExtra("provider", authorityName.toString());
              clickIntent.putExtra("numDeletes", numDeletes);
  
              if (!isActivityAvailable(clickIntent)) {
                  Log.w(TAG, "No activity found to handle too many deletes.");
                  return;
              }
  
              UserHandle user = new UserHandle(userId);
              final PendingIntent pendingIntent = PendingIntent
                      .getActivityAsUser(mContext, 0, clickIntent,
                              PendingIntent.FLAG_CANCEL_CURRENT, null, user);
  
              CharSequence tooManyDeletesDescFormat = mContext.getResources().getText(
                      R.string.contentServiceTooManyDeletesNotificationDesc);
  
              Context contextForUser = getContextForUser(user);
              Notification notification =
                      new Notification.Builder(contextForUser, SystemNotificationChannels.ACCOUNT)
                      .setSmallIcon(R.drawable.stat_notify_sync_error)
                      .setTicker(mContext.getString(R.string.contentServiceSync))
                      .setWhen(System.currentTimeMillis())
                      .setColor(contextForUser.getColor(
                              com.android.internal.R.color.system_notification_accent_color))
                      .setContentTitle(contextForUser.getString(
                              R.string.contentServiceSyncNotificationTitle))
                      .setContentText(
                              String.format(tooManyDeletesDescFormat.toString(), authorityName))
                      .setContentIntent(pendingIntent)
                      .build();
              notification.flags |= Notification.FLAG_ONGOING_EVENT;
              mNotificationMgr.notifyAsUser(
                      Integer.toString(account.hashCode() ^ authority.hashCode()),
                      SystemMessage.NOTE_SYNC_ERROR,
                      notification, user);
          }
  
          /**
           * Checks whether an activity exists on the system image for the given intent.
           *
           * @param intent The intent for an activity.
           * @return Whether or not an activity exists.
           */
          private boolean isActivityAvailable(Intent intent) {
              PackageManager pm = mContext.getPackageManager();
              List<ResolveInfo> list = pm.queryIntentActivities(intent, 0);
              int listSize = list.size();
              for (int i = 0; i < listSize; i++) {
                  ResolveInfo resolveInfo = list.get(i);
                  if ((resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM)
                          != 0) {
                      return true;
                  }
              }
  
              return false;
          }
  
          public long insertStartSyncEvent(SyncOperation syncOperation) {
              final long now = System.currentTimeMillis();
              EventLog.writeEvent(2720,
                      syncOperation.toEventLog(SyncStorageEngine.EVENT_START));
              return mSyncStorageEngine.insertStartSyncEvent(syncOperation, now);
          }
  
          public void stopSyncEvent(long rowId, SyncOperation syncOperation, String resultMessage,
                  int upstreamActivity, int downstreamActivity, long elapsedTime) {
              EventLog.writeEvent(2720,
                      syncOperation.toEventLog(SyncStorageEngine.EVENT_STOP));
              mSyncStorageEngine.stopSyncEvent(rowId, elapsedTime,
                      resultMessage, downstreamActivity, upstreamActivity,
                      syncOperation.target.userId);
          }
      }
  
      private boolean isSyncStillActiveH(ActiveSyncContext activeSyncContext) {
          for (ActiveSyncContext sync : mActiveSyncContexts) {
              if (sync == activeSyncContext) {
                  return true;
              }
          }
          return false;
      }
  
      /**
       * Sync extra comparison function.
       * @param b1 bundle to compare
       * @param b2 other bundle to compare
       * @param includeSyncSettings if false, ignore system settings in bundle.
       */
      public static boolean syncExtrasEquals(Bundle b1, Bundle b2, boolean includeSyncSettings) {
          if (b1 == b2) {
              return true;
          }
          // Exit early if we can.
          if (includeSyncSettings && b1.size() != b2.size()) {
              return false;
          }
          Bundle bigger = b1.size() > b2.size() ? b1 : b2;
          Bundle smaller = b1.size() > b2.size() ? b2 : b1;
          for (String key : bigger.keySet()) {
              if (!includeSyncSettings && isSyncSetting(key)) {
                  continue;
              }
              if (!smaller.containsKey(key)) {
                  return false;
              }
              if (!Objects.equals(bigger.get(key), smaller.get(key))) {
                  return false;
              }
          }
          return true;
      }
  
      /**
       * @return true if the provided key is used by the SyncManager in scheduling the sync.
       */
      private static boolean isSyncSetting(String key) {
          if (key.equals(ContentResolver.SYNC_EXTRAS_EXPEDITED)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_DO_NOT_RETRY)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_MANUAL)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_UPLOAD)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_DISCARD_LOCAL_DELETIONS)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_EXPECTED_UPLOAD)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_EXPECTED_DOWNLOAD)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_PRIORITY)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_DISALLOW_METERED)) {
              return true;
          }
          if (key.equals(ContentResolver.SYNC_EXTRAS_INITIALIZE)) {
              return true;
          }
  //        if (key.equals(ContentResolver.SYNC_EXTRAS_APP_STANDBY_EXEMPTED)) {
  //            return true;
  //        }
          // No need to check virtual flags such as SYNC_VIRTUAL_EXTRAS_FORCE_FG_SYNC.
          return false;
      }
  
      static class PrintTable {
          private ArrayList<String[]> mTable = Lists.newArrayList();
          private final int mCols;
  
          PrintTable(int cols) {
              mCols = cols;
          }
  
          void set(int row, int col, Object... values) {
              if (col + values.length > mCols) {
                  throw new IndexOutOfBoundsException("Table only has " + mCols +
                          " columns. can't set " + values.length + " at column " + col);
              }
              for (int i = mTable.size(); i <= row; i++) {
                  final String[] list = new String[mCols];
                  mTable.add(list);
                  for (int j = 0; j < mCols; j++) {
                      list[j] = "";
                  }
              }
              final String[] rowArray = mTable.get(row);
              for (int i = 0; i < values.length; i++) {
                  final Object value = values[i];
                  rowArray[col + i] = (value == null) ? "" : value.toString();
              }
          }
  
          void writeTo(PrintWriter out) {
              final String[] formats = new String[mCols];
              int totalLength = 0;
              for (int col = 0; col < mCols; ++col) {
                  int maxLength = 0;
                  for (Object[] row : mTable) {
                      final int length = row[col].toString().length();
                      if (length > maxLength) {
                          maxLength = length;
                      }
                  }
                  totalLength += maxLength;
                  formats[col] = String.format("%%-%ds", maxLength);
              }
              formats[mCols - 1] = "%s";
              printRow(out, formats, mTable.get(0));
              totalLength += (mCols - 1) * 2;
              for (int i = 0; i < totalLength; ++i) {
                  out.print("-");
              }
              out.println();
              for (int i = 1, mTableSize = mTable.size(); i < mTableSize; i++) {
                  Object[] row = mTable.get(i);
                  printRow(out, formats, row);
              }
          }
  
          private void printRow(PrintWriter out, String[] formats, Object[] row) {
              for (int j = 0, rowLength = row.length; j < rowLength; j++) {
                  out.printf(String.format(formats[j], row[j].toString()));
                  out.print("  ");
              }
              out.println();
          }
  
          public int getNumRows() {
              return mTable.size();
          }
      }
  
      private Context getContextForUser(UserHandle user) {
          try {
              return mContext.createPackageContextAsUser(mContext.getPackageName(), 0, user);
          } catch (NameNotFoundException e) {
              // Default to mContext, not finding the package system is running as is unlikely.
              return mContext;
          }
      }
  
      private void cancelJob(SyncOperation op, String why) {
          if (op == null) {
              Slog.wtf(TAG, "Null sync operation detected.");
              return;
          }
          if (op.isPeriodic) {
              mLogger.log("Removing periodic sync ", op, " for ", why);
          }
          getJobScheduler().cancel(op.jobId);
      }
  
      public void resetTodayStats() {
          mSyncStorageEngine.resetTodayStats(/*force=*/ true);
      }
  
      private boolean wasPackageEverLaunched(String packageName, int userId) {
          try {
              return mPackageManagerInternal.wasPackageEverLaunched(packageName, userId);
          } catch (IllegalArgumentException e) {
              return false; // Package has been removed.
          }
      }
  }
  