com/android/server/content/SyncOperation.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright (C) 2010 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 android.accounts.Account;
 import android.app.job.JobInfo;
 import android.content.ContentResolver;
 import android.content.ContentResolver.SyncExemption;
 import android.content.pm.PackageManager;
 import android.os.Bundle;
 import android.os.PersistableBundle;
 import android.os.SystemClock;
 import android.os.UserHandle;
 import android.util.Slog;

 /**
  * Value type that represents a sync operation.
  * This holds all information related to a sync operation - both one off and periodic.
  * Data stored in this is used to schedule a job with the JobScheduler.
  * {@hide}
  */
 public class SyncOperation {
     public static final String TAG = "SyncManager";

     /**
      * This is used in the {@link #sourcePeriodicId} field if the operation is not initiated by a failed
      * periodic sync.
      */
     public static final int NO_JOB_ID = -1;

     public static final int REASON_BACKGROUND_DATA_SETTINGS_CHANGED = -1;
     public static final int REASON_ACCOUNTS_UPDATED = -2;
     public static final int REASON_SERVICE_CHANGED = -3;
     public static final int REASON_PERIODIC = -4;
     /** Sync started because it has just been set to isSyncable. */
     public static final int REASON_IS_SYNCABLE = -5;
     /** Sync started because it has just been set to sync automatically. */
     public static final int REASON_SYNC_AUTO = -6;
     /** Sync started because master sync automatically has been set to true. */
     public static final int REASON_MASTER_SYNC_AUTO = -7;
     public static final int REASON_USER_START = -8;

     private static String[] REASON_NAMES = new String[] {
             "DataSettingsChanged",
             "AccountsUpdated",
             "ServiceChanged",
             "Periodic",
             "IsSyncable",
             "AutoSync",
             "MasterSyncAuto",
             "UserStart",
     };

     /** Identifying info for the target for this operation. */
     public final SyncStorageEngine.EndPoint target;
     public final int owningUid;
     public final String owningPackage;
     /** Why this sync was kicked off. {@link #REASON_NAMES} */
     public final int reason;
     /** Where this sync was initiated. */
     public final int syncSource;
     public final boolean allowParallelSyncs;
     public final Bundle extras;
     public final boolean isPeriodic;
     /** jobId of the periodic SyncOperation that initiated this one */
     public final int sourcePeriodicId;
     /** Operations are considered duplicates if keys are equal */
     public final String key;

     /** Poll frequency of periodic sync in milliseconds */
     public final long periodMillis;
     /** Flex time of periodic sync in milliseconds */
     public final long flexMillis;
     /** Descriptive string key for this operation */
     public String wakeLockName;
     /**
      * Used when duplicate pending syncs are present. The one with the lowest expectedRuntime
      * is kept, others are discarded.
      */
     public long expectedRuntime;

     /** Stores the number of times this sync operation failed and had to be retried. */
     int retries;

     /** jobId of the JobScheduler job corresponding to this sync */
     public int jobId;

     @SyncExemption
     public int syncExemptionFlag;

     public SyncOperation(Account account, int userId, int owningUid, String owningPackage,
                          int reason, int source, String provider, Bundle extras,
                          boolean allowParallelSyncs, @SyncExemption int syncExemptionFlag) {
         this(new SyncStorageEngine.EndPoint(account, provider, userId), owningUid, owningPackage,
                 reason, source, extras, allowParallelSyncs, syncExemptionFlag);
     }

     private SyncOperation(SyncStorageEngine.EndPoint info, int owningUid, String owningPackage,
             int reason, int source, Bundle extras, boolean allowParallelSyncs,
             @SyncExemption int syncExemptionFlag) {
         this(info, owningUid, owningPackage, reason, source, extras, allowParallelSyncs, false,
                 NO_JOB_ID, 0, 0, syncExemptionFlag);
     }

     public SyncOperation(SyncOperation op, long periodMillis, long flexMillis) {
         this(op.target, op.owningUid, op.owningPackage, op.reason, op.syncSource,
                 new Bundle(op.extras), op.allowParallelSyncs, op.isPeriodic, op.sourcePeriodicId,
                 periodMillis, flexMillis, ContentResolver.SYNC_EXEMPTION_NONE);
     }

     public SyncOperation(SyncStorageEngine.EndPoint info, int owningUid, String owningPackage,
                          int reason, int source, Bundle extras, boolean allowParallelSyncs,
                          boolean isPeriodic, int sourcePeriodicId, long periodMillis,
                          long flexMillis, @SyncExemption int syncExemptionFlag) {
         this.target = info;
         this.owningUid = owningUid;
         this.owningPackage = owningPackage;
         this.reason = reason;
         this.syncSource = source;
         this.extras = new Bundle(extras);
         this.allowParallelSyncs = allowParallelSyncs;
         this.isPeriodic = isPeriodic;
         this.sourcePeriodicId = sourcePeriodicId;
         this.periodMillis = periodMillis;
         this.flexMillis = flexMillis;
         this.jobId = NO_JOB_ID;
         this.key = toKey();
         this.syncExemptionFlag = syncExemptionFlag;
     }

     /* Get a one off sync operation instance from a periodic sync. */
     public SyncOperation createOneTimeSyncOperation() {
         if (!isPeriodic) {
             return null;
         }
         SyncOperation op = new SyncOperation(target, owningUid, owningPackage, reason, syncSource,
                 new Bundle(extras), allowParallelSyncs, false, jobId /* sourcePeriodicId */,
                 periodMillis, flexMillis, ContentResolver.SYNC_EXEMPTION_NONE);
         return op;
     }

     public SyncOperation(SyncOperation other) {
         target = other.target;
         owningUid = other.owningUid;
         owningPackage = other.owningPackage;
         reason = other.reason;
         syncSource = other.syncSource;
         allowParallelSyncs = other.allowParallelSyncs;
         extras = new Bundle(other.extras);
         wakeLockName = other.wakeLockName();
         isPeriodic = other.isPeriodic;
         sourcePeriodicId = other.sourcePeriodicId;
         periodMillis = other.periodMillis;
         flexMillis = other.flexMillis;
         this.key = other.key;
         syncExemptionFlag = other.syncExemptionFlag;
     }

     /**
      * All fields are stored in a corresponding key in the persistable bundle.
      *
      * {@link #extras} is a Bundle and can contain parcelable objects. But only the type Account
      * is allowed {@link ContentResolver#validateSyncExtrasBundle(Bundle)} that can't be stored in
      * a PersistableBundle. For every value of type Account with key 'key', we store a
      * PersistableBundle containing account information at key 'ACCOUNT:key'. The Account object
      * can be reconstructed using this.
      *
      * We put a flag with key 'SyncManagerJob', to identify while reconstructing a sync operation
      * from a bundle whether the bundle actually contains information about a sync.
      * @return A persistable bundle containing all information to re-construct the sync operation.
      */
     PersistableBundle toJobInfoExtras() {
         // This will be passed as extras bundle to a JobScheduler job.
         PersistableBundle jobInfoExtras = new PersistableBundle();

         PersistableBundle syncExtrasBundle = new PersistableBundle();
         for (String key: extras.keySet()) {
             Object value = extras.get(key);
             if (value instanceof Account) {
                 Account account = (Account) value;
                 PersistableBundle accountBundle = new PersistableBundle();
                 accountBundle.putString("accountName", account.name);
                 accountBundle.putString("accountType", account.type);
                 // This is stored in jobInfoExtras so that we don't override a user specified
                 // sync extra with the same key.
                 jobInfoExtras.putPersistableBundle("ACCOUNT:" + key, accountBundle);
             } else if (value instanceof Long) {
                 syncExtrasBundle.putLong(key, (Long) value);
             } else if (value instanceof Integer) {
                 syncExtrasBundle.putInt(key, (Integer) value);
             } else if (value instanceof Boolean) {
                 syncExtrasBundle.putBoolean(key, (Boolean) value);
             } else if (value instanceof Float) {
                 syncExtrasBundle.putDouble(key, (double) (float) value);
             } else if (value instanceof Double) {
                 syncExtrasBundle.putDouble(key, (Double) value);
             } else if (value instanceof String) {
                 syncExtrasBundle.putString(key, (String) value);
             } else if (value == null) {
                 syncExtrasBundle.putString(key, null);
             } else {
                 Slog.e(TAG, "Unknown extra type.");
             }
         }
         jobInfoExtras.putPersistableBundle("syncExtras", syncExtrasBundle);

         jobInfoExtras.putBoolean("SyncManagerJob", true);

         jobInfoExtras.putString("provider", target.provider);
         jobInfoExtras.putString("accountName", target.account.name);
         jobInfoExtras.putString("accountType", target.account.type);
         jobInfoExtras.putInt("userId", target.userId);
         jobInfoExtras.putInt("owningUid", owningUid);
         jobInfoExtras.putString("owningPackage", owningPackage);
         jobInfoExtras.putInt("reason", reason);
         jobInfoExtras.putInt("source", syncSource);
         jobInfoExtras.putBoolean("allowParallelSyncs", allowParallelSyncs);
         jobInfoExtras.putInt("jobId", jobId);
         jobInfoExtras.putBoolean("isPeriodic", isPeriodic);
         jobInfoExtras.putInt("sourcePeriodicId", sourcePeriodicId);
         jobInfoExtras.putLong("periodMillis", periodMillis);
         jobInfoExtras.putLong("flexMillis", flexMillis);
         jobInfoExtras.putLong("expectedRuntime", expectedRuntime);
         jobInfoExtras.putInt("retries", retries);
         jobInfoExtras.putInt("syncExemptionFlag", syncExemptionFlag);
         return jobInfoExtras;
     }

     /**
      * Reconstructs a sync operation from an extras Bundle. Returns null if the bundle doesn't
      * contain a valid sync operation.
      */
     static SyncOperation maybeCreateFromJobExtras(PersistableBundle jobExtras) {
         if (jobExtras == null) {
             return null;
         }
         String accountName, accountType;
         String provider;
         int userId, owningUid;
         String owningPackage;
         int reason, source;
         int initiatedBy;
         Bundle extras;
         boolean allowParallelSyncs, isPeriodic;
         long periodMillis, flexMillis;
         int syncExemptionFlag;

         if (!jobExtras.getBoolean("SyncManagerJob", false)) {
             return null;
         }

         accountName = jobExtras.getString("accountName");
         accountType = jobExtras.getString("accountType");
         provider = jobExtras.getString("provider");
         userId = jobExtras.getInt("userId", Integer.MAX_VALUE);
         owningUid = jobExtras.getInt("owningUid");
         owningPackage = jobExtras.getString("owningPackage");
         reason = jobExtras.getInt("reason", Integer.MAX_VALUE);
         source = jobExtras.getInt("source", Integer.MAX_VALUE);
         allowParallelSyncs = jobExtras.getBoolean("allowParallelSyncs", false);
         isPeriodic = jobExtras.getBoolean("isPeriodic", false);
         initiatedBy = jobExtras.getInt("sourcePeriodicId", NO_JOB_ID);
         periodMillis = jobExtras.getLong("periodMillis");
         flexMillis = jobExtras.getLong("flexMillis");
         syncExemptionFlag = jobExtras.getInt("syncExemptionFlag",
                 ContentResolver.SYNC_EXEMPTION_NONE);
         extras = new Bundle();

         PersistableBundle syncExtras = jobExtras.getPersistableBundle("syncExtras");
         if (syncExtras != null) {
             extras.putAll(syncExtras);
         }

         for (String key: jobExtras.keySet()) {
             if (key!= null && key.startsWith("ACCOUNT:")) {
                 String newKey = key.substring(8); // Strip off the 'ACCOUNT:' prefix.
                 PersistableBundle accountsBundle = jobExtras.getPersistableBundle(key);
                 Account account = new Account(accountsBundle.getString("accountName"),
                         accountsBundle.getString("accountType"));
                 extras.putParcelable(newKey, account);
             }
         }

         Account account = new Account(accountName, accountType);
         SyncStorageEngine.EndPoint target =
                 new SyncStorageEngine.EndPoint(account, provider, userId);
         SyncOperation op = new SyncOperation(target, owningUid, owningPackage, reason, source,
                 extras, allowParallelSyncs, isPeriodic, initiatedBy, periodMillis, flexMillis,
                 syncExemptionFlag);
         op.jobId = jobExtras.getInt("jobId");
         op.expectedRuntime = jobExtras.getLong("expectedRuntime");
         op.retries = jobExtras.getInt("retries");
         return op;
     }

     /**
      * Determine whether if this sync operation is running, the provided operation would conflict
      * with it.
      * Parallel syncs allow multiple accounts to be synced at the same time.
      */
     boolean isConflict(SyncOperation toRun) {
         final SyncStorageEngine.EndPoint other = toRun.target;
         return target.account.type.equals(other.account.type)
                 && target.provider.equals(other.provider)
                 && target.userId == other.userId
                 && (!allowParallelSyncs
                 || target.account.name.equals(other.account.name));
     }

     boolean isReasonPeriodic() {
         return reason == REASON_PERIODIC;
     }

     boolean matchesPeriodicOperation(SyncOperation other) {
         return target.matchesSpec(other.target)
                 && SyncManager.syncExtrasEquals(extras, other.extras, true)
                 && periodMillis == other.periodMillis && flexMillis == other.flexMillis;
     }

     boolean isDerivedFromFailedPeriodicSync() {
         return sourcePeriodicId != NO_JOB_ID;
     }

     int findPriority() {
         if (isInitialization()) {
             return JobInfo.PRIORITY_SYNC_INITIALIZATION;
         } else if (isExpedited()) {
             return JobInfo.PRIORITY_SYNC_EXPEDITED;
         }
         return JobInfo.PRIORITY_DEFAULT;
     }

     private String toKey() {
         StringBuilder sb = new StringBuilder();
         sb.append("provider: ").append(target.provider);
         sb.append(" account {name=" + target.account.name
                 + ", user="
                 + target.userId
                 + ", type="
                 + target.account.type
                 + "}");
         sb.append(" isPeriodic: ").append(isPeriodic);
         sb.append(" period: ").append(periodMillis);
         sb.append(" flex: ").append(flexMillis);
         sb.append(" extras: ");
         extrasToStringBuilder(extras, sb);
         return sb.toString();
     }

     @Override
     public String toString() {
         return dump(null, true, null, false);
     }

     public String toSafeString() {
         return dump(null, true, null, true);
     }

     String dump(PackageManager pm, boolean shorter, SyncAdapterStateFetcher appStates,
             boolean logSafe) {
         StringBuilder sb = new StringBuilder();
         sb.append("JobId=").append(jobId)
                 .append(" ")
                 .append(logSafe ? "***" : target.account.name)
                 .append("/")
                 .append(target.account.type)
                 .append(" u")
                 .append(target.userId)
                 .append(" [")
                 .append(target.provider)
                 .append("] ");
         sb.append(SyncStorageEngine.SOURCES[syncSource]);
         if (expectedRuntime != 0) {
             sb.append(" ExpectedIn=");
             SyncManager.formatDurationHMS(sb,
                     (expectedRuntime - SystemClock.elapsedRealtime()));
         }
         if (extras.getBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, false)) {
             sb.append(" EXPEDITED");
         }
         switch (syncExemptionFlag) {
             case ContentResolver.SYNC_EXEMPTION_NONE:
                 break;
             case ContentResolver.SYNC_EXEMPTION_PROMOTE_BUCKET:
                 sb.append(" STANDBY-EXEMPTED");
                 break;
             case ContentResolver.SYNC_EXEMPTION_PROMOTE_BUCKET_WITH_TEMP:
                 sb.append(" STANDBY-EXEMPTED(TOP)");
                 break;
             default:
                 sb.append(" ExemptionFlag=" + syncExemptionFlag);
                 break;
         }
         sb.append(" Reason=");
         sb.append(reasonToString(pm, reason));
         if (isPeriodic) {
             sb.append(" (period=");
             SyncManager.formatDurationHMS(sb, periodMillis);
             sb.append(" flex=");
             SyncManager.formatDurationHMS(sb, flexMillis);
             sb.append(")");
         }
         if (retries > 0) {
             sb.append(" Retries=");
             sb.append(retries);
         }
         if (!shorter) {
             sb.append(" Owner={");
             UserHandle.formatUid(sb, owningUid);
             sb.append(" ");
             sb.append(owningPackage);
             if (appStates != null) {
                 sb.append(" [");
                 sb.append(appStates.getStandbyBucket(
                         UserHandle.getUserId(owningUid), owningPackage));
                 sb.append("]");

                 if (appStates.isAppActive(owningUid)) {
                     sb.append(" [ACTIVE]");
                 }
             }
             sb.append("}");
             if (!extras.keySet().isEmpty()) {
                 sb.append(" ");
                 extrasToStringBuilder(extras, sb);
             }
         }
         return sb.toString();
     }

     static String reasonToString(PackageManager pm, int reason) {
         if (reason >= 0) {
             if (pm != null) {
                 final String[] packages = pm.getPackagesForUid(reason);
                 if (packages != null && packages.length == 1) {
                     return packages[0];
                 }
                 final String name = pm.getNameForUid(reason);
                 if (name != null) {
                     return name;
                 }
                 return String.valueOf(reason);
             } else {
                 return String.valueOf(reason);
             }
         } else {
             final int index = -reason - 1;
             if (index >= REASON_NAMES.length) {
                 return String.valueOf(reason);
             } else {
                 return REASON_NAMES[index];
             }
         }
     }

     boolean isInitialization() {
         return extras.getBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, false);
     }

     boolean isExpedited() {
         return extras.getBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, false);
     }

     boolean ignoreBackoff() {
         return extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, false);
     }

     boolean isNotAllowedOnMetered() {
         return extras.getBoolean(ContentResolver.SYNC_EXTRAS_DISALLOW_METERED, false);
     }

     boolean isManual() {
         return extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false);
     }

     boolean isIgnoreSettings() {
         return extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS, false);
     }

     boolean isAppStandbyExempted() {
         return syncExemptionFlag != ContentResolver.SYNC_EXEMPTION_NONE;
     }

     static void extrasToStringBuilder(Bundle bundle, StringBuilder sb) {
         if (bundle == null) {
             sb.append("null");
             return;
         }
         sb.append("[");
         for (String key : bundle.keySet()) {
             sb.append(key).append("=").append(bundle.get(key)).append(" ");
         }
         sb.append("]");
     }

     static String extrasToString(Bundle bundle) {
         final StringBuilder sb = new StringBuilder();
         extrasToStringBuilder(bundle, sb);
         return sb.toString();
     }

     String wakeLockName() {
         if (wakeLockName != null) {
             return wakeLockName;
         }
         return (wakeLockName = target.provider
                 + "/" + target.account.type
                 + "/" + target.account.name);
     }

     // TODO: Test this to make sure that casting to object doesn't lose the type info for EventLog.
     public Object[] toEventLog(int event) {
         Object[] logArray = new Object[4];
         logArray[1] = event;
         logArray[2] = syncSource;
         logArray[0] = target.provider;
         logArray[3] = target.account.name.hashCode();
         return logArray;
     }
 }
	/*
	* Copyright (C) 2010 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 android.accounts.Account;
	import android.app.job.JobInfo;
	import android.content.ContentResolver;
	import android.content.ContentResolver.SyncExemption;
	import android.content.pm.PackageManager;
	import android.os.Bundle;
	import android.os.PersistableBundle;
	import android.os.SystemClock;
	import android.os.UserHandle;
	import android.util.Slog;

	/**
	* Value type that represents a sync operation.
	* This holds all information related to a sync operation - both one off and periodic.
	* Data stored in this is used to schedule a job with the JobScheduler.
	* {@hide}
	*/
	public class SyncOperation {
	public static final String TAG = "SyncManager";

	/**
	* This is used in the {@link #sourcePeriodicId} field if the operation is not initiated by a failed
	* periodic sync.
	*/
	public static final int NO_JOB_ID = -1;

	public static final int REASON_BACKGROUND_DATA_SETTINGS_CHANGED = -1;
	public static final int REASON_ACCOUNTS_UPDATED = -2;
	public static final int REASON_SERVICE_CHANGED = -3;
	public static final int REASON_PERIODIC = -4;
	/** Sync started because it has just been set to isSyncable. */
	public static final int REASON_IS_SYNCABLE = -5;
	/** Sync started because it has just been set to sync automatically. */
	public static final int REASON_SYNC_AUTO = -6;
	/** Sync started because master sync automatically has been set to true. */
	public static final int REASON_MASTER_SYNC_AUTO = -7;
	public static final int REASON_USER_START = -8;

	private static String[] REASON_NAMES = new String[] {
	"DataSettingsChanged",
	"AccountsUpdated",
	"ServiceChanged",
	"Periodic",
	"IsSyncable",
	"AutoSync",
	"MasterSyncAuto",
	"UserStart",
	};

	/** Identifying info for the target for this operation. */
	public final SyncStorageEngine.EndPoint target;
	public final int owningUid;
	public final String owningPackage;
	/** Why this sync was kicked off. {@link #REASON_NAMES} */
	public final int reason;
	/** Where this sync was initiated. */
	public final int syncSource;
	public final boolean allowParallelSyncs;
	public final Bundle extras;
	public final boolean isPeriodic;
	/** jobId of the periodic SyncOperation that initiated this one */
	public final int sourcePeriodicId;
	/** Operations are considered duplicates if keys are equal */
	public final String key;

	/** Poll frequency of periodic sync in milliseconds */
	public final long periodMillis;
	/** Flex time of periodic sync in milliseconds */
	public final long flexMillis;
	/** Descriptive string key for this operation */
	public String wakeLockName;
	/**
	* Used when duplicate pending syncs are present. The one with the lowest expectedRuntime
	* is kept, others are discarded.
	*/
	public long expectedRuntime;

	/** Stores the number of times this sync operation failed and had to be retried. */
	int retries;

	/** jobId of the JobScheduler job corresponding to this sync */
	public int jobId;

	@SyncExemption
	public int syncExemptionFlag;

	public SyncOperation(Account account, int userId, int owningUid, String owningPackage,
	int reason, int source, String provider, Bundle extras,
	boolean allowParallelSyncs, @SyncExemption int syncExemptionFlag) {
	this(new SyncStorageEngine.EndPoint(account, provider, userId), owningUid, owningPackage,
	reason, source, extras, allowParallelSyncs, syncExemptionFlag);
	}

	private SyncOperation(SyncStorageEngine.EndPoint info, int owningUid, String owningPackage,
	int reason, int source, Bundle extras, boolean allowParallelSyncs,
	@SyncExemption int syncExemptionFlag) {
	this(info, owningUid, owningPackage, reason, source, extras, allowParallelSyncs, false,
	NO_JOB_ID, 0, 0, syncExemptionFlag);
	}

	public SyncOperation(SyncOperation op, long periodMillis, long flexMillis) {
	this(op.target, op.owningUid, op.owningPackage, op.reason, op.syncSource,
	new Bundle(op.extras), op.allowParallelSyncs, op.isPeriodic, op.sourcePeriodicId,
	periodMillis, flexMillis, ContentResolver.SYNC_EXEMPTION_NONE);
	}

	public SyncOperation(SyncStorageEngine.EndPoint info, int owningUid, String owningPackage,
	int reason, int source, Bundle extras, boolean allowParallelSyncs,
	boolean isPeriodic, int sourcePeriodicId, long periodMillis,
	long flexMillis, @SyncExemption int syncExemptionFlag) {
	this.target = info;
	this.owningUid = owningUid;
	this.owningPackage = owningPackage;
	this.reason = reason;
	this.syncSource = source;
	this.extras = new Bundle(extras);
	this.allowParallelSyncs = allowParallelSyncs;
	this.isPeriodic = isPeriodic;
	this.sourcePeriodicId = sourcePeriodicId;
	this.periodMillis = periodMillis;
	this.flexMillis = flexMillis;
	this.jobId = NO_JOB_ID;
	this.key = toKey();
	this.syncExemptionFlag = syncExemptionFlag;
	}

	/* Get a one off sync operation instance from a periodic sync. */
	public SyncOperation createOneTimeSyncOperation() {
	if (!isPeriodic) {
	return null;
	}
	SyncOperation op = new SyncOperation(target, owningUid, owningPackage, reason, syncSource,
	new Bundle(extras), allowParallelSyncs, false, jobId /* sourcePeriodicId */,
	periodMillis, flexMillis, ContentResolver.SYNC_EXEMPTION_NONE);
	return op;
	}

	public SyncOperation(SyncOperation other) {
	target = other.target;
	owningUid = other.owningUid;
	owningPackage = other.owningPackage;
	reason = other.reason;
	syncSource = other.syncSource;
	allowParallelSyncs = other.allowParallelSyncs;
	extras = new Bundle(other.extras);
	wakeLockName = other.wakeLockName();
	isPeriodic = other.isPeriodic;
	sourcePeriodicId = other.sourcePeriodicId;
	periodMillis = other.periodMillis;
	flexMillis = other.flexMillis;
	this.key = other.key;
	syncExemptionFlag = other.syncExemptionFlag;
	}

	/**
	* All fields are stored in a corresponding key in the persistable bundle.
	*
	* {@link #extras} is a Bundle and can contain parcelable objects. But only the type Account
	* is allowed {@link ContentResolver#validateSyncExtrasBundle(Bundle)} that can't be stored in
	* a PersistableBundle. For every value of type Account with key 'key', we store a
	* PersistableBundle containing account information at key 'ACCOUNT:key'. The Account object
	* can be reconstructed using this.
	*
	* We put a flag with key 'SyncManagerJob', to identify while reconstructing a sync operation
	* from a bundle whether the bundle actually contains information about a sync.
	* @return A persistable bundle containing all information to re-construct the sync operation.
	*/
	PersistableBundle toJobInfoExtras() {
	// This will be passed as extras bundle to a JobScheduler job.
	PersistableBundle jobInfoExtras = new PersistableBundle();

	PersistableBundle syncExtrasBundle = new PersistableBundle();
	for (String key: extras.keySet()) {
	Object value = extras.get(key);
	if (value instanceof Account) {
	Account account = (Account) value;
	PersistableBundle accountBundle = new PersistableBundle();
	accountBundle.putString("accountName", account.name);
	accountBundle.putString("accountType", account.type);
	// This is stored in jobInfoExtras so that we don't override a user specified
	// sync extra with the same key.
	jobInfoExtras.putPersistableBundle("ACCOUNT:" + key, accountBundle);
	} else if (value instanceof Long) {
	syncExtrasBundle.putLong(key, (Long) value);
	} else if (value instanceof Integer) {
	syncExtrasBundle.putInt(key, (Integer) value);
	} else if (value instanceof Boolean) {
	syncExtrasBundle.putBoolean(key, (Boolean) value);
	} else if (value instanceof Float) {
	syncExtrasBundle.putDouble(key, (double) (float) value);
	} else if (value instanceof Double) {
	syncExtrasBundle.putDouble(key, (Double) value);
	} else if (value instanceof String) {
	syncExtrasBundle.putString(key, (String) value);
	} else if (value == null) {
	syncExtrasBundle.putString(key, null);
	} else {
	Slog.e(TAG, "Unknown extra type.");
	}
	}
	jobInfoExtras.putPersistableBundle("syncExtras", syncExtrasBundle);

	jobInfoExtras.putBoolean("SyncManagerJob", true);

	jobInfoExtras.putString("provider", target.provider);
	jobInfoExtras.putString("accountName", target.account.name);
	jobInfoExtras.putString("accountType", target.account.type);
	jobInfoExtras.putInt("userId", target.userId);
	jobInfoExtras.putInt("owningUid", owningUid);
	jobInfoExtras.putString("owningPackage", owningPackage);
	jobInfoExtras.putInt("reason", reason);
	jobInfoExtras.putInt("source", syncSource);
	jobInfoExtras.putBoolean("allowParallelSyncs", allowParallelSyncs);
	jobInfoExtras.putInt("jobId", jobId);
	jobInfoExtras.putBoolean("isPeriodic", isPeriodic);
	jobInfoExtras.putInt("sourcePeriodicId", sourcePeriodicId);
	jobInfoExtras.putLong("periodMillis", periodMillis);
	jobInfoExtras.putLong("flexMillis", flexMillis);
	jobInfoExtras.putLong("expectedRuntime", expectedRuntime);
	jobInfoExtras.putInt("retries", retries);
	jobInfoExtras.putInt("syncExemptionFlag", syncExemptionFlag);
	return jobInfoExtras;
	}

	/**
	* Reconstructs a sync operation from an extras Bundle. Returns null if the bundle doesn't
	* contain a valid sync operation.
	*/
	static SyncOperation maybeCreateFromJobExtras(PersistableBundle jobExtras) {
	if (jobExtras == null) {
	return null;
	}
	String accountName, accountType;
	String provider;
	int userId, owningUid;
	String owningPackage;
	int reason, source;
	int initiatedBy;
	Bundle extras;
	boolean allowParallelSyncs, isPeriodic;
	long periodMillis, flexMillis;
	int syncExemptionFlag;

	if (!jobExtras.getBoolean("SyncManagerJob", false)) {
	return null;
	}

	accountName = jobExtras.getString("accountName");
	accountType = jobExtras.getString("accountType");
	provider = jobExtras.getString("provider");
	userId = jobExtras.getInt("userId", Integer.MAX_VALUE);
	owningUid = jobExtras.getInt("owningUid");
	owningPackage = jobExtras.getString("owningPackage");
	reason = jobExtras.getInt("reason", Integer.MAX_VALUE);
	source = jobExtras.getInt("source", Integer.MAX_VALUE);
	allowParallelSyncs = jobExtras.getBoolean("allowParallelSyncs", false);
	isPeriodic = jobExtras.getBoolean("isPeriodic", false);
	initiatedBy = jobExtras.getInt("sourcePeriodicId", NO_JOB_ID);
	periodMillis = jobExtras.getLong("periodMillis");
	flexMillis = jobExtras.getLong("flexMillis");
	syncExemptionFlag = jobExtras.getInt("syncExemptionFlag",
	ContentResolver.SYNC_EXEMPTION_NONE);
	extras = new Bundle();

	PersistableBundle syncExtras = jobExtras.getPersistableBundle("syncExtras");
	if (syncExtras != null) {
	extras.putAll(syncExtras);
	}

	for (String key: jobExtras.keySet()) {
	if (key!= null && key.startsWith("ACCOUNT:")) {
	String newKey = key.substring(8); // Strip off the 'ACCOUNT:' prefix.
	PersistableBundle accountsBundle = jobExtras.getPersistableBundle(key);
	Account account = new Account(accountsBundle.getString("accountName"),
	accountsBundle.getString("accountType"));
	extras.putParcelable(newKey, account);
	}
	}

	Account account = new Account(accountName, accountType);
	SyncStorageEngine.EndPoint target =
	new SyncStorageEngine.EndPoint(account, provider, userId);
	SyncOperation op = new SyncOperation(target, owningUid, owningPackage, reason, source,
	extras, allowParallelSyncs, isPeriodic, initiatedBy, periodMillis, flexMillis,
	syncExemptionFlag);
	op.jobId = jobExtras.getInt("jobId");
	op.expectedRuntime = jobExtras.getLong("expectedRuntime");
	op.retries = jobExtras.getInt("retries");
	return op;
	}

	/**
	* Determine whether if this sync operation is running, the provided operation would conflict
	* with it.
	* Parallel syncs allow multiple accounts to be synced at the same time.
	*/
	boolean isConflict(SyncOperation toRun) {
	final SyncStorageEngine.EndPoint other = toRun.target;
	return target.account.type.equals(other.account.type)
	&& target.provider.equals(other.provider)
	&& target.userId == other.userId
	&& (!allowParallelSyncs
	\|\| target.account.name.equals(other.account.name));
	}

	boolean isReasonPeriodic() {
	return reason == REASON_PERIODIC;
	}

	boolean matchesPeriodicOperation(SyncOperation other) {
	return target.matchesSpec(other.target)
	&& SyncManager.syncExtrasEquals(extras, other.extras, true)
	&& periodMillis == other.periodMillis && flexMillis == other.flexMillis;
	}

	boolean isDerivedFromFailedPeriodicSync() {
	return sourcePeriodicId != NO_JOB_ID;
	}

	int findPriority() {
	if (isInitialization()) {
	return JobInfo.PRIORITY_SYNC_INITIALIZATION;
	} else if (isExpedited()) {
	return JobInfo.PRIORITY_SYNC_EXPEDITED;
	}
	return JobInfo.PRIORITY_DEFAULT;
	}

	private String toKey() {
	StringBuilder sb = new StringBuilder();
	sb.append("provider: ").append(target.provider);
	sb.append(" account {name=" + target.account.name
	+ ", user="
	+ target.userId
	+ ", type="
	+ target.account.type
	+ "}");
	sb.append(" isPeriodic: ").append(isPeriodic);
	sb.append(" period: ").append(periodMillis);
	sb.append(" flex: ").append(flexMillis);
	sb.append(" extras: ");
	extrasToStringBuilder(extras, sb);
	return sb.toString();
	}

	@Override
	public String toString() {
	return dump(null, true, null, false);
	}

	public String toSafeString() {
	return dump(null, true, null, true);
	}

	String dump(PackageManager pm, boolean shorter, SyncAdapterStateFetcher appStates,
	boolean logSafe) {
	StringBuilder sb = new StringBuilder();
	sb.append("JobId=").append(jobId)
	.append(" ")
	.append(logSafe ? "***" : target.account.name)
	.append("/")
	.append(target.account.type)
	.append(" u")
	.append(target.userId)
	.append(" [")
	.append(target.provider)
	.append("] ");
	sb.append(SyncStorageEngine.SOURCES[syncSource]);
	if (expectedRuntime != 0) {
	sb.append(" ExpectedIn=");
	SyncManager.formatDurationHMS(sb,
	(expectedRuntime - SystemClock.elapsedRealtime()));
	}
	if (extras.getBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, false)) {
	sb.append(" EXPEDITED");
	}
	switch (syncExemptionFlag) {
	case ContentResolver.SYNC_EXEMPTION_NONE:
	break;
	case ContentResolver.SYNC_EXEMPTION_PROMOTE_BUCKET:
	sb.append(" STANDBY-EXEMPTED");
	break;
	case ContentResolver.SYNC_EXEMPTION_PROMOTE_BUCKET_WITH_TEMP:
	sb.append(" STANDBY-EXEMPTED(TOP)");
	break;
	default:
	sb.append(" ExemptionFlag=" + syncExemptionFlag);
	break;
	}
	sb.append(" Reason=");
	sb.append(reasonToString(pm, reason));
	if (isPeriodic) {
	sb.append(" (period=");
	SyncManager.formatDurationHMS(sb, periodMillis);
	sb.append(" flex=");
	SyncManager.formatDurationHMS(sb, flexMillis);
	sb.append(")");
	}
	if (retries > 0) {
	sb.append(" Retries=");
	sb.append(retries);
	}
	if (!shorter) {
	sb.append(" Owner={");
	UserHandle.formatUid(sb, owningUid);
	sb.append(" ");
	sb.append(owningPackage);
	if (appStates != null) {
	sb.append(" [");
	sb.append(appStates.getStandbyBucket(
	UserHandle.getUserId(owningUid), owningPackage));
	sb.append("]");

	if (appStates.isAppActive(owningUid)) {
	sb.append(" [ACTIVE]");
	}
	}
	sb.append("}");
	if (!extras.keySet().isEmpty()) {
	sb.append(" ");
	extrasToStringBuilder(extras, sb);
	}
	}
	return sb.toString();
	}

	static String reasonToString(PackageManager pm, int reason) {
	if (reason >= 0) {
	if (pm != null) {
	final String[] packages = pm.getPackagesForUid(reason);
	if (packages != null && packages.length == 1) {
	return packages[0];
	}
	final String name = pm.getNameForUid(reason);
	if (name != null) {
	return name;
	}
	return String.valueOf(reason);
	} else {
	return String.valueOf(reason);
	}
	} else {
	final int index = -reason - 1;
	if (index >= REASON_NAMES.length) {
	return String.valueOf(reason);
	} else {
	return REASON_NAMES[index];
	}
	}
	}

	boolean isInitialization() {
	return extras.getBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, false);
	}

	boolean isExpedited() {
	return extras.getBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, false);
	}

	boolean ignoreBackoff() {
	return extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, false);
	}

	boolean isNotAllowedOnMetered() {
	return extras.getBoolean(ContentResolver.SYNC_EXTRAS_DISALLOW_METERED, false);
	}

	boolean isManual() {
	return extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false);
	}

	boolean isIgnoreSettings() {
	return extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS, false);
	}

	boolean isAppStandbyExempted() {
	return syncExemptionFlag != ContentResolver.SYNC_EXEMPTION_NONE;
	}

	static void extrasToStringBuilder(Bundle bundle, StringBuilder sb) {
	if (bundle == null) {
	sb.append("null");
	return;
	}
	sb.append("[");
	for (String key : bundle.keySet()) {
	sb.append(key).append("=").append(bundle.get(key)).append(" ");
	}
	sb.append("]");
	}

	static String extrasToString(Bundle bundle) {
	final StringBuilder sb = new StringBuilder();
	extrasToStringBuilder(bundle, sb);
	return sb.toString();
	}

	String wakeLockName() {
	if (wakeLockName != null) {
	return wakeLockName;
	}
	return (wakeLockName = target.provider
	+ "/" + target.account.type
	+ "/" + target.account.name);
	}

	// TODO: Test this to make sure that casting to object doesn't lose the type info for EventLog.
	public Object[] toEventLog(int event) {
	Object[] logArray = new Object[4];
	logArray[1] = event;
	logArray[2] = syncSource;
	logArray[0] = target.provider;
	logArray[3] = target.account.name.hashCode();
	return logArray;
	}
	}