/*
|
* Copyright (C) 2009 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.annotation.Nullable;
|
import android.app.backup.BackupManager;
|
import android.content.ComponentName;
|
import android.content.ContentResolver;
|
import android.content.ContentResolver.SyncExemption;
|
import android.content.Context;
|
import android.content.ISyncStatusObserver;
|
import android.content.PeriodicSync;
|
import android.content.SyncInfo;
|
import android.content.SyncRequest;
|
import android.content.SyncStatusInfo;
|
import android.content.pm.PackageManager;
|
import android.os.Bundle;
|
import android.os.Environment;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.os.Message;
|
import android.os.Parcel;
|
import android.os.RemoteCallbackList;
|
import android.os.RemoteException;
|
import android.os.UserHandle;
|
import android.util.ArrayMap;
|
import android.util.ArraySet;
|
import android.util.AtomicFile;
|
import android.util.EventLog;
|
import android.util.Log;
|
import android.util.Pair;
|
import android.util.Slog;
|
import android.util.SparseArray;
|
import android.util.Xml;
|
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.util.ArrayUtils;
|
import com.android.internal.util.FastXmlSerializer;
|
import com.android.internal.util.IntPair;
|
|
import org.xmlpull.v1.XmlPullParser;
|
import org.xmlpull.v1.XmlPullParserException;
|
import org.xmlpull.v1.XmlSerializer;
|
|
import java.io.File;
|
import java.io.FileInputStream;
|
import java.io.FileOutputStream;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Calendar;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Random;
|
import java.util.TimeZone;
|
|
/**
|
* Singleton that tracks the sync data and overall sync
|
* history on the device.
|
*
|
* @hide
|
*/
|
public class SyncStorageEngine {
|
|
private static final String TAG = "SyncManager";
|
private static final String TAG_FILE = "SyncManagerFile";
|
|
private static final String XML_ATTR_NEXT_AUTHORITY_ID = "nextAuthorityId";
|
private static final String XML_ATTR_LISTEN_FOR_TICKLES = "listen-for-tickles";
|
private static final String XML_ATTR_SYNC_RANDOM_OFFSET = "offsetInSeconds";
|
private static final String XML_ATTR_ENABLED = "enabled";
|
private static final String XML_ATTR_USER = "user";
|
private static final String XML_TAG_LISTEN_FOR_TICKLES = "listenForTickles";
|
|
/** Default time for a periodic sync. */
|
private static final long DEFAULT_POLL_FREQUENCY_SECONDS = 60 * 60 * 24; // One day
|
|
/** Percentage of period that is flex by default, if no flexMillis is set. */
|
private static final double DEFAULT_FLEX_PERCENT_SYNC = 0.04;
|
|
/** Lower bound on sync time from which we assign a default flex time. */
|
private static final long DEFAULT_MIN_FLEX_ALLOWED_SECS = 5;
|
|
@VisibleForTesting
|
static final long MILLIS_IN_4WEEKS = 1000L * 60 * 60 * 24 * 7 * 4;
|
|
/** Enum value for a sync start event. */
|
public static final int EVENT_START = 0;
|
|
/** Enum value for a sync stop event. */
|
public static final int EVENT_STOP = 1;
|
|
/** Enum value for a sync with other sources. */
|
public static final int SOURCE_OTHER = 0;
|
|
/** Enum value for a local-initiated sync. */
|
public static final int SOURCE_LOCAL = 1;
|
|
/** Enum value for a poll-based sync (e.g., upon connection to network) */
|
public static final int SOURCE_POLL = 2;
|
|
/** Enum value for a user-initiated sync. */
|
public static final int SOURCE_USER = 3;
|
|
/** Enum value for a periodic sync. */
|
public static final int SOURCE_PERIODIC = 4;
|
|
/** Enum a sync with a "feed" extra */
|
public static final int SOURCE_FEED = 5;
|
|
public static final long NOT_IN_BACKOFF_MODE = -1;
|
|
/**
|
* String names for the sync source types.
|
*
|
* KEEP THIS AND {@link SyncStatusInfo#SOURCE_COUNT} IN SYNC.
|
*/
|
public static final String[] SOURCES = {
|
"OTHER",
|
"LOCAL",
|
"POLL",
|
"USER",
|
"PERIODIC",
|
"FEED"};
|
|
// The MESG column will contain one of these or one of the Error types.
|
public static final String MESG_SUCCESS = "success";
|
public static final String MESG_CANCELED = "canceled";
|
|
public static final int MAX_HISTORY = 100;
|
|
private static final int MSG_WRITE_STATUS = 1;
|
private static final long WRITE_STATUS_DELAY = 1000*60*10; // 10 minutes
|
|
private static final int MSG_WRITE_STATISTICS = 2;
|
private static final long WRITE_STATISTICS_DELAY = 1000*60*30; // 1/2 hour
|
|
private static final boolean SYNC_ENABLED_DEFAULT = false;
|
|
// the version of the accounts xml file format
|
private static final int ACCOUNTS_VERSION = 3;
|
|
private static HashMap<String, String> sAuthorityRenames;
|
private static PeriodicSyncAddedListener mPeriodicSyncAddedListener;
|
|
private volatile boolean mIsClockValid;
|
|
static {
|
sAuthorityRenames = new HashMap<String, String>();
|
sAuthorityRenames.put("contacts", "com.android.contacts");
|
sAuthorityRenames.put("calendar", "com.android.calendar");
|
}
|
|
static class AccountInfo {
|
final AccountAndUser accountAndUser;
|
final HashMap<String, AuthorityInfo> authorities =
|
new HashMap<String, AuthorityInfo>();
|
|
AccountInfo(AccountAndUser accountAndUser) {
|
this.accountAndUser = accountAndUser;
|
}
|
}
|
|
/** Bare bones representation of a sync target. */
|
public static class EndPoint {
|
public final static EndPoint USER_ALL_PROVIDER_ALL_ACCOUNTS_ALL =
|
new EndPoint(null, null, UserHandle.USER_ALL);
|
final Account account;
|
final int userId;
|
final String provider;
|
|
public EndPoint(Account account, String provider, int userId) {
|
this.account = account;
|
this.provider = provider;
|
this.userId = userId;
|
}
|
|
/**
|
* An Endpoint for a sync matches if it targets the same sync adapter for the same user.
|
*
|
* @param spec the Endpoint to match. If the spec has null fields, they indicate a wildcard
|
* and match any.
|
*/
|
public boolean matchesSpec(EndPoint spec) {
|
if (userId != spec.userId
|
&& userId != UserHandle.USER_ALL
|
&& spec.userId != UserHandle.USER_ALL) {
|
return false;
|
}
|
boolean accountsMatch;
|
if (spec.account == null) {
|
accountsMatch = true;
|
} else {
|
accountsMatch = account.equals(spec.account);
|
}
|
boolean providersMatch;
|
if (spec.provider == null) {
|
providersMatch = true;
|
} else {
|
providersMatch = provider.equals(spec.provider);
|
}
|
return accountsMatch && providersMatch;
|
}
|
|
public String toString() {
|
StringBuilder sb = new StringBuilder();
|
sb.append(account == null ? "ALL ACCS" : account.name)
|
.append("/")
|
.append(provider == null ? "ALL PDRS" : provider);
|
sb.append(":u" + userId);
|
return sb.toString();
|
}
|
|
public String toSafeString() {
|
StringBuilder sb = new StringBuilder();
|
sb.append(account == null ? "ALL ACCS" : logSafe(account))
|
.append("/")
|
.append(provider == null ? "ALL PDRS" : provider);
|
sb.append(":u" + userId);
|
return sb.toString();
|
}
|
}
|
|
public static class AuthorityInfo {
|
// Legal values of getIsSyncable
|
|
/**
|
* The syncable state is undefined.
|
*/
|
public static final int UNDEFINED = -2;
|
|
/**
|
* Default state for a newly installed adapter. An uninitialized adapter will receive an
|
* initialization sync which are governed by a different set of rules to that of regular
|
* syncs.
|
*/
|
public static final int NOT_INITIALIZED = -1;
|
/**
|
* The adapter will not receive any syncs. This is behaviourally equivalent to
|
* setSyncAutomatically -> false. However setSyncAutomatically is surfaced to the user
|
* while this is generally meant to be controlled by the developer.
|
*/
|
public static final int NOT_SYNCABLE = 0;
|
/**
|
* The adapter is initialized and functioning. This is the normal state for an adapter.
|
*/
|
public static final int SYNCABLE = 1;
|
/**
|
* The adapter is syncable but still requires an initialization sync. For example an adapter
|
* than has been restored from a previous device will be in this state. Not meant for
|
* external use.
|
*/
|
public static final int SYNCABLE_NOT_INITIALIZED = 2;
|
|
/**
|
* The adapter is syncable but does not have access to the synced account and needs a
|
* user access approval.
|
*/
|
public static final int SYNCABLE_NO_ACCOUNT_ACCESS = 3;
|
|
final EndPoint target;
|
final int ident;
|
boolean enabled;
|
int syncable;
|
/** Time at which this sync will run, taking into account backoff. */
|
long backoffTime;
|
/** Amount of delay due to backoff. */
|
long backoffDelay;
|
/** Time offset to add to any requests coming to this target. */
|
long delayUntil;
|
|
final ArrayList<PeriodicSync> periodicSyncs;
|
|
/**
|
* Copy constructor for making deep-ish copies. Only the bundles stored
|
* in periodic syncs can make unexpected changes.
|
*
|
* @param toCopy AuthorityInfo to be copied.
|
*/
|
AuthorityInfo(AuthorityInfo toCopy) {
|
target = toCopy.target;
|
ident = toCopy.ident;
|
enabled = toCopy.enabled;
|
syncable = toCopy.syncable;
|
backoffTime = toCopy.backoffTime;
|
backoffDelay = toCopy.backoffDelay;
|
delayUntil = toCopy.delayUntil;
|
periodicSyncs = new ArrayList<PeriodicSync>();
|
for (PeriodicSync sync : toCopy.periodicSyncs) {
|
// Still not a perfect copy, because we are just copying the mappings.
|
periodicSyncs.add(new PeriodicSync(sync));
|
}
|
}
|
|
AuthorityInfo(EndPoint info, int id) {
|
target = info;
|
ident = id;
|
enabled = SYNC_ENABLED_DEFAULT;
|
periodicSyncs = new ArrayList<PeriodicSync>();
|
defaultInitialisation();
|
}
|
|
private void defaultInitialisation() {
|
syncable = NOT_INITIALIZED; // default to "unknown"
|
backoffTime = -1; // if < 0 then we aren't in backoff mode
|
backoffDelay = -1; // if < 0 then we aren't in backoff mode
|
|
if (mPeriodicSyncAddedListener != null) {
|
mPeriodicSyncAddedListener.onPeriodicSyncAdded(target, new Bundle(),
|
DEFAULT_POLL_FREQUENCY_SECONDS,
|
calculateDefaultFlexTime(DEFAULT_POLL_FREQUENCY_SECONDS));
|
}
|
}
|
|
@Override
|
public String toString() {
|
return target + ", enabled=" + enabled + ", syncable=" + syncable + ", backoff="
|
+ backoffTime + ", delay=" + delayUntil;
|
}
|
}
|
|
public static class SyncHistoryItem {
|
int authorityId;
|
int historyId;
|
long eventTime;
|
long elapsedTime;
|
int source;
|
int event;
|
long upstreamActivity;
|
long downstreamActivity;
|
String mesg;
|
boolean initialization;
|
Bundle extras;
|
int reason;
|
int syncExemptionFlag;
|
}
|
|
public static class DayStats {
|
public final int day;
|
public int successCount;
|
public long successTime;
|
public int failureCount;
|
public long failureTime;
|
|
public DayStats(int day) {
|
this.day = day;
|
}
|
}
|
|
interface OnSyncRequestListener {
|
|
/** Called when a sync is needed on an account(s) due to some change in state. */
|
public void onSyncRequest(EndPoint info, int reason, Bundle extras,
|
@SyncExemption int syncExemptionFlag, int callingUid, int callingPid);
|
}
|
|
interface PeriodicSyncAddedListener {
|
/** Called when a periodic sync is added. */
|
void onPeriodicSyncAdded(EndPoint target, Bundle extras, long pollFrequency, long flex);
|
}
|
|
interface OnAuthorityRemovedListener {
|
/** Called when an authority is removed. */
|
void onAuthorityRemoved(EndPoint removedAuthority);
|
}
|
|
/**
|
* Validator that maintains a lazy cache of accounts and providers to tell if an authority or
|
* account is valid.
|
*/
|
private static class AccountAuthorityValidator {
|
final private AccountManager mAccountManager;
|
final private PackageManager mPackageManager;
|
final private SparseArray<Account[]> mAccountsCache;
|
final private SparseArray<ArrayMap<String, Boolean>> mProvidersPerUserCache;
|
|
AccountAuthorityValidator(Context context) {
|
mAccountManager = context.getSystemService(AccountManager.class);
|
mPackageManager = context.getPackageManager();
|
mAccountsCache = new SparseArray<>();
|
mProvidersPerUserCache = new SparseArray<>();
|
}
|
|
// An account is valid if an installed authenticator has previously created that account
|
// on the device
|
boolean isAccountValid(Account account, int userId) {
|
Account[] accountsForUser = mAccountsCache.get(userId);
|
if (accountsForUser == null) {
|
accountsForUser = mAccountManager.getAccountsAsUser(userId);
|
mAccountsCache.put(userId, accountsForUser);
|
}
|
return ArrayUtils.contains(accountsForUser, account);
|
}
|
|
// An authority is only valid if it has a content provider installed on the system
|
boolean isAuthorityValid(String authority, int userId) {
|
ArrayMap<String, Boolean> authorityMap = mProvidersPerUserCache.get(userId);
|
if (authorityMap == null) {
|
authorityMap = new ArrayMap<>();
|
mProvidersPerUserCache.put(userId, authorityMap);
|
}
|
if (!authorityMap.containsKey(authority)) {
|
authorityMap.put(authority, mPackageManager.resolveContentProviderAsUser(authority,
|
PackageManager.MATCH_DIRECT_BOOT_AWARE
|
| PackageManager.MATCH_DIRECT_BOOT_UNAWARE, userId) != null);
|
}
|
return authorityMap.get(authority);
|
}
|
}
|
|
// Primary list of all syncable authorities. Also our global lock.
|
private final SparseArray<AuthorityInfo> mAuthorities =
|
new SparseArray<AuthorityInfo>();
|
|
private final HashMap<AccountAndUser, AccountInfo> mAccounts
|
= new HashMap<AccountAndUser, AccountInfo>();
|
|
private final SparseArray<ArrayList<SyncInfo>> mCurrentSyncs
|
= new SparseArray<ArrayList<SyncInfo>>();
|
|
private final SparseArray<SyncStatusInfo> mSyncStatus =
|
new SparseArray<SyncStatusInfo>();
|
|
private final ArrayList<SyncHistoryItem> mSyncHistory =
|
new ArrayList<SyncHistoryItem>();
|
|
private final RemoteCallbackList<ISyncStatusObserver> mChangeListeners
|
= new RemoteCallbackList<ISyncStatusObserver>();
|
|
/** Reverse mapping for component name -> <userid -> target id>. */
|
private final ArrayMap<ComponentName, SparseArray<AuthorityInfo>> mServices =
|
new ArrayMap<ComponentName, SparseArray<AuthorityInfo>>();
|
|
private int mNextAuthorityId = 0;
|
|
// We keep 4 weeks of stats.
|
private final DayStats[] mDayStats = new DayStats[7*4];
|
private final Calendar mCal;
|
private int mYear;
|
private int mYearInDays;
|
|
private final Context mContext;
|
|
private static volatile SyncStorageEngine sSyncStorageEngine = null;
|
|
private int mSyncRandomOffset;
|
|
/**
|
* This file contains the core engine state: all accounts and the
|
* settings for them. It must never be lost, and should be changed
|
* infrequently, so it is stored as an XML file.
|
*/
|
private final AtomicFile mAccountInfoFile;
|
|
/**
|
* This file contains the current sync status. We would like to retain
|
* it across boots, but its loss is not the end of the world, so we store
|
* this information as binary data.
|
*/
|
private final AtomicFile mStatusFile;
|
|
/**
|
* This file contains sync statistics. This is purely debugging information
|
* so is written infrequently and can be thrown away at any time.
|
*/
|
private final AtomicFile mStatisticsFile;
|
|
private int mNextHistoryId = 0;
|
private SparseArray<Boolean> mMasterSyncAutomatically = new SparseArray<Boolean>();
|
private boolean mDefaultMasterSyncAutomatically;
|
|
private OnSyncRequestListener mSyncRequestListener;
|
private OnAuthorityRemovedListener mAuthorityRemovedListener;
|
|
private boolean mGrantSyncAdaptersAccountAccess;
|
|
private final MyHandler mHandler;
|
private final SyncLogger mLogger;
|
|
private SyncStorageEngine(Context context, File dataDir, Looper looper) {
|
mHandler = new MyHandler(looper);
|
mContext = context;
|
sSyncStorageEngine = this;
|
mLogger = SyncLogger.getInstance();
|
|
mCal = Calendar.getInstance(TimeZone.getTimeZone("GMT+0"));
|
|
mDefaultMasterSyncAutomatically = mContext.getResources().getBoolean(
|
com.android.internal.R.bool.config_syncstorageengine_masterSyncAutomatically);
|
|
File systemDir = new File(dataDir, "system");
|
File syncDir = new File(systemDir, "sync");
|
syncDir.mkdirs();
|
|
maybeDeleteLegacyPendingInfoLocked(syncDir);
|
|
mAccountInfoFile = new AtomicFile(new File(syncDir, "accounts.xml"), "sync-accounts");
|
mStatusFile = new AtomicFile(new File(syncDir, "status.bin"), "sync-status");
|
mStatisticsFile = new AtomicFile(new File(syncDir, "stats.bin"), "sync-stats");
|
|
readAccountInfoLocked();
|
readStatusLocked();
|
readStatisticsLocked();
|
|
if (mLogger.enabled()) {
|
final int size = mAuthorities.size();
|
mLogger.log("Loaded ", size, " items");
|
for (int i = 0; i < size; i++) {
|
mLogger.log(mAuthorities.valueAt(i));
|
}
|
}
|
}
|
|
public static SyncStorageEngine newTestInstance(Context context) {
|
return new SyncStorageEngine(context, context.getFilesDir(), Looper.getMainLooper());
|
}
|
|
public static void init(Context context, Looper looper) {
|
if (sSyncStorageEngine != null) {
|
return;
|
}
|
File dataDir = Environment.getDataDirectory();
|
sSyncStorageEngine = new SyncStorageEngine(context, dataDir, looper);
|
}
|
|
public static SyncStorageEngine getSingleton() {
|
if (sSyncStorageEngine == null) {
|
throw new IllegalStateException("not initialized");
|
}
|
return sSyncStorageEngine;
|
}
|
|
protected void setOnSyncRequestListener(OnSyncRequestListener listener) {
|
if (mSyncRequestListener == null) {
|
mSyncRequestListener = listener;
|
}
|
}
|
|
protected void setOnAuthorityRemovedListener(OnAuthorityRemovedListener listener) {
|
if (mAuthorityRemovedListener == null) {
|
mAuthorityRemovedListener = listener;
|
}
|
}
|
|
protected void setPeriodicSyncAddedListener(PeriodicSyncAddedListener listener) {
|
if (mPeriodicSyncAddedListener == null) {
|
mPeriodicSyncAddedListener = listener;
|
}
|
}
|
|
private class MyHandler extends Handler {
|
public MyHandler(Looper looper) {
|
super(looper);
|
}
|
|
@Override
|
public void handleMessage(Message msg) {
|
if (msg.what == MSG_WRITE_STATUS) {
|
synchronized (mAuthorities) {
|
writeStatusLocked();
|
}
|
} else if (msg.what == MSG_WRITE_STATISTICS) {
|
synchronized (mAuthorities) {
|
writeStatisticsLocked();
|
}
|
}
|
}
|
}
|
|
public int getSyncRandomOffset() {
|
return mSyncRandomOffset;
|
}
|
|
public void addStatusChangeListener(int mask, int userId, ISyncStatusObserver callback) {
|
synchronized (mAuthorities) {
|
final long cookie = IntPair.of(userId, mask);
|
mChangeListeners.register(callback, cookie);
|
}
|
}
|
|
public void removeStatusChangeListener(ISyncStatusObserver callback) {
|
synchronized (mAuthorities) {
|
mChangeListeners.unregister(callback);
|
}
|
}
|
|
/**
|
* Figure out a reasonable flex time for cases where none is provided (old api calls).
|
* @param syncTimeSeconds requested sync time from now.
|
* @return amount of seconds before syncTimeSeconds that the sync can occur.
|
* I.e.
|
* earliest_sync_time = syncTimeSeconds - calculateDefaultFlexTime(syncTimeSeconds)
|
* The flex time is capped at a percentage of the {@link #DEFAULT_POLL_FREQUENCY_SECONDS}.
|
*/
|
public static long calculateDefaultFlexTime(long syncTimeSeconds) {
|
if (syncTimeSeconds < DEFAULT_MIN_FLEX_ALLOWED_SECS) {
|
// Small enough sync request time that we don't add flex time - developer probably
|
// wants to wait for an operation to occur before syncing so we honour the
|
// request time.
|
return 0L;
|
} else if (syncTimeSeconds < DEFAULT_POLL_FREQUENCY_SECONDS) {
|
return (long) (syncTimeSeconds * DEFAULT_FLEX_PERCENT_SYNC);
|
} else {
|
// Large enough sync request time that we cap the flex time.
|
return (long) (DEFAULT_POLL_FREQUENCY_SECONDS * DEFAULT_FLEX_PERCENT_SYNC);
|
}
|
}
|
|
void reportChange(int which, int callingUserId) {
|
ArrayList<ISyncStatusObserver> reports = null;
|
synchronized (mAuthorities) {
|
int i = mChangeListeners.beginBroadcast();
|
while (i > 0) {
|
i--;
|
final long cookie = (long) mChangeListeners.getBroadcastCookie(i);
|
final int userId = IntPair.first(cookie);
|
final int mask = IntPair.second(cookie);
|
if ((which & mask) == 0 || callingUserId != userId) {
|
continue;
|
}
|
if (reports == null) {
|
reports = new ArrayList<ISyncStatusObserver>(i);
|
}
|
reports.add(mChangeListeners.getBroadcastItem(i));
|
}
|
mChangeListeners.finishBroadcast();
|
}
|
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "reportChange " + which + " to: " + reports);
|
}
|
|
if (reports != null) {
|
int i = reports.size();
|
while (i > 0) {
|
i--;
|
try {
|
reports.get(i).onStatusChanged(which);
|
} catch (RemoteException e) {
|
// The remote callback list will take care of this for us.
|
}
|
}
|
}
|
}
|
|
public boolean getSyncAutomatically(Account account, int userId, String providerName) {
|
synchronized (mAuthorities) {
|
if (account != null) {
|
AuthorityInfo authority = getAuthorityLocked(
|
new EndPoint(account, providerName, userId),
|
"getSyncAutomatically");
|
return authority != null && authority.enabled;
|
}
|
|
int i = mAuthorities.size();
|
while (i > 0) {
|
i--;
|
AuthorityInfo authorityInfo = mAuthorities.valueAt(i);
|
if (authorityInfo.target.matchesSpec(new EndPoint(account, providerName, userId))
|
&& authorityInfo.enabled) {
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
|
public void setSyncAutomatically(Account account, int userId, String providerName,
|
boolean sync, @SyncExemption int syncExemptionFlag, int callingUid, int callingPid) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.d(TAG, "setSyncAutomatically: " + /* account + */" provider " + providerName
|
+ ", user " + userId + " -> " + sync);
|
}
|
mLogger.log("Set sync auto account=", account,
|
" user=", userId,
|
" authority=", providerName,
|
" value=", Boolean.toString(sync),
|
" cuid=", callingUid,
|
" cpid=", callingPid
|
);
|
synchronized (mAuthorities) {
|
AuthorityInfo authority =
|
getOrCreateAuthorityLocked(
|
new EndPoint(account, providerName, userId),
|
-1 /* ident */,
|
false);
|
if (authority.enabled == sync) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.d(TAG, "setSyncAutomatically: already set to " + sync + ", doing nothing");
|
}
|
return;
|
}
|
// If the adapter was syncable but missing its initialization sync, set it to
|
// uninitialized now. This is to give it a chance to run any one-time initialization
|
// logic.
|
if (sync && authority.syncable == AuthorityInfo.SYNCABLE_NOT_INITIALIZED) {
|
authority.syncable = AuthorityInfo.NOT_INITIALIZED;
|
}
|
authority.enabled = sync;
|
writeAccountInfoLocked();
|
}
|
|
if (sync) {
|
requestSync(account, userId, SyncOperation.REASON_SYNC_AUTO, providerName,
|
new Bundle(),
|
syncExemptionFlag, callingUid, callingPid);
|
}
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, userId);
|
queueBackup();
|
}
|
|
public int getIsSyncable(Account account, int userId, String providerName) {
|
synchronized (mAuthorities) {
|
if (account != null) {
|
AuthorityInfo authority = getAuthorityLocked(
|
new EndPoint(account, providerName, userId),
|
"get authority syncable");
|
if (authority == null) {
|
return AuthorityInfo.NOT_INITIALIZED;
|
}
|
return authority.syncable;
|
}
|
|
int i = mAuthorities.size();
|
while (i > 0) {
|
i--;
|
AuthorityInfo authorityInfo = mAuthorities.valueAt(i);
|
if (authorityInfo.target != null
|
&& authorityInfo.target.provider.equals(providerName)) {
|
return authorityInfo.syncable;
|
}
|
}
|
return AuthorityInfo.NOT_INITIALIZED;
|
}
|
}
|
|
public void setIsSyncable(Account account, int userId, String providerName, int syncable,
|
int callingUid, int callingPid) {
|
setSyncableStateForEndPoint(new EndPoint(account, providerName, userId), syncable,
|
callingUid, callingPid);
|
}
|
|
/**
|
* An enabled sync service and a syncable provider's adapter both get resolved to the same
|
* persisted variable - namely the "syncable" attribute for an AuthorityInfo in accounts.xml.
|
* @param target target to set value for.
|
* @param syncable 0 indicates unsyncable, <0 unknown, >0 is active/syncable.
|
*/
|
private void setSyncableStateForEndPoint(EndPoint target, int syncable,
|
int callingUid, int callingPid) {
|
AuthorityInfo aInfo;
|
mLogger.log("Set syncable ", target, " value=", Integer.toString(syncable),
|
" cuid=", callingUid,
|
" cpid=", callingPid);
|
synchronized (mAuthorities) {
|
aInfo = getOrCreateAuthorityLocked(target, -1, false);
|
if (syncable < AuthorityInfo.NOT_INITIALIZED) {
|
syncable = AuthorityInfo.NOT_INITIALIZED;
|
}
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.d(TAG, "setIsSyncable: " + aInfo.toString() + " -> " + syncable);
|
}
|
if (aInfo.syncable == syncable) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.d(TAG, "setIsSyncable: already set to " + syncable + ", doing nothing");
|
}
|
return;
|
}
|
aInfo.syncable = syncable;
|
writeAccountInfoLocked();
|
}
|
if (syncable == AuthorityInfo.SYNCABLE) {
|
requestSync(aInfo, SyncOperation.REASON_IS_SYNCABLE, new Bundle(),
|
ContentResolver.SYNC_EXEMPTION_NONE, callingUid, callingPid);
|
}
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, target.userId);
|
}
|
|
public Pair<Long, Long> getBackoff(EndPoint info) {
|
synchronized (mAuthorities) {
|
AuthorityInfo authority = getAuthorityLocked(info, "getBackoff");
|
if (authority != null) {
|
return Pair.create(authority.backoffTime, authority.backoffDelay);
|
}
|
return null;
|
}
|
}
|
|
/**
|
* Update the backoff for the given endpoint. The endpoint may be for a provider/account and
|
* the account or provider info be null, which signifies all accounts or providers.
|
*/
|
public void setBackoff(EndPoint info, long nextSyncTime, long nextDelay) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "setBackoff: " + info
|
+ " -> nextSyncTime " + nextSyncTime + ", nextDelay " + nextDelay);
|
}
|
boolean changed;
|
synchronized (mAuthorities) {
|
if (info.account == null || info.provider == null) {
|
// Do more work for a provider sync if the provided info has specified all
|
// accounts/providers.
|
changed = setBackoffLocked(
|
info.account /* may be null */,
|
info.userId,
|
info.provider /* may be null */,
|
nextSyncTime, nextDelay);
|
} else {
|
AuthorityInfo authorityInfo =
|
getOrCreateAuthorityLocked(info, -1 /* ident */, true);
|
if (authorityInfo.backoffTime == nextSyncTime
|
&& authorityInfo.backoffDelay == nextDelay) {
|
changed = false;
|
} else {
|
authorityInfo.backoffTime = nextSyncTime;
|
authorityInfo.backoffDelay = nextDelay;
|
changed = true;
|
}
|
}
|
}
|
if (changed) {
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, info.userId);
|
}
|
}
|
|
/**
|
* Either set backoff for a specific authority, or set backoff for all the
|
* accounts on a specific adapter/all adapters.
|
*
|
* @param account account for which to set backoff. Null to specify all accounts.
|
* @param userId id of the user making this request.
|
* @param providerName provider for which to set backoff. Null to specify all providers.
|
* @return true if a change occured.
|
*/
|
private boolean setBackoffLocked(Account account, int userId, String providerName,
|
long nextSyncTime, long nextDelay) {
|
boolean changed = false;
|
for (AccountInfo accountInfo : mAccounts.values()) {
|
if (account != null && !account.equals(accountInfo.accountAndUser.account)
|
&& userId != accountInfo.accountAndUser.userId) {
|
continue;
|
}
|
for (AuthorityInfo authorityInfo : accountInfo.authorities.values()) {
|
if (providerName != null
|
&& !providerName.equals(authorityInfo.target.provider)) {
|
continue;
|
}
|
if (authorityInfo.backoffTime != nextSyncTime
|
|| authorityInfo.backoffDelay != nextDelay) {
|
authorityInfo.backoffTime = nextSyncTime;
|
authorityInfo.backoffDelay = nextDelay;
|
changed = true;
|
}
|
}
|
}
|
return changed;
|
}
|
|
public void clearAllBackoffsLocked() {
|
final ArraySet<Integer> changedUserIds = new ArraySet<>();
|
synchronized (mAuthorities) {
|
// Clear backoff for all sync adapters.
|
for (AccountInfo accountInfo : mAccounts.values()) {
|
for (AuthorityInfo authorityInfo : accountInfo.authorities.values()) {
|
if (authorityInfo.backoffTime != NOT_IN_BACKOFF_MODE
|
|| authorityInfo.backoffDelay != NOT_IN_BACKOFF_MODE) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "clearAllBackoffsLocked:"
|
+ " authority:" + authorityInfo.target
|
+ " account:" + accountInfo.accountAndUser.account.name
|
+ " user:" + accountInfo.accountAndUser.userId
|
+ " backoffTime was: " + authorityInfo.backoffTime
|
+ " backoffDelay was: " + authorityInfo.backoffDelay);
|
}
|
authorityInfo.backoffTime = NOT_IN_BACKOFF_MODE;
|
authorityInfo.backoffDelay = NOT_IN_BACKOFF_MODE;
|
changedUserIds.add(accountInfo.accountAndUser.userId);
|
}
|
}
|
}
|
}
|
|
for (int i = changedUserIds.size() - 1; i > 0; i--) {
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, changedUserIds.valueAt(i));
|
}
|
}
|
|
public long getDelayUntilTime(EndPoint info) {
|
synchronized (mAuthorities) {
|
AuthorityInfo authority = getAuthorityLocked(info, "getDelayUntil");
|
if (authority == null) {
|
return 0;
|
}
|
return authority.delayUntil;
|
}
|
}
|
|
public void setDelayUntilTime(EndPoint info, long delayUntil) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "setDelayUntil: " + info
|
+ " -> delayUntil " + delayUntil);
|
}
|
synchronized (mAuthorities) {
|
AuthorityInfo authority = getOrCreateAuthorityLocked(info, -1, true);
|
if (authority.delayUntil == delayUntil) {
|
return;
|
}
|
authority.delayUntil = delayUntil;
|
}
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, info.userId);
|
}
|
|
/**
|
* Restore all periodic syncs read from persisted files. Used to restore periodic syncs
|
* after an OS update.
|
*/
|
boolean restoreAllPeriodicSyncs() {
|
if (mPeriodicSyncAddedListener == null) {
|
return false;
|
}
|
synchronized (mAuthorities) {
|
for (int i=0; i<mAuthorities.size(); i++) {
|
AuthorityInfo authority = mAuthorities.valueAt(i);
|
for (PeriodicSync periodicSync: authority.periodicSyncs) {
|
mPeriodicSyncAddedListener.onPeriodicSyncAdded(authority.target,
|
periodicSync.extras, periodicSync.period, periodicSync.flexTime);
|
}
|
authority.periodicSyncs.clear();
|
}
|
writeAccountInfoLocked();
|
}
|
return true;
|
}
|
|
public void setMasterSyncAutomatically(boolean flag, int userId,
|
@SyncExemption int syncExemptionFlag, int callingUid, int callingPid) {
|
mLogger.log("Set master enabled=", flag, " user=", userId,
|
" cuid=", callingUid,
|
" cpid=", callingPid);
|
synchronized (mAuthorities) {
|
Boolean auto = mMasterSyncAutomatically.get(userId);
|
if (auto != null && auto.equals(flag)) {
|
return;
|
}
|
mMasterSyncAutomatically.put(userId, flag);
|
writeAccountInfoLocked();
|
}
|
if (flag) {
|
requestSync(null, userId, SyncOperation.REASON_MASTER_SYNC_AUTO, null,
|
new Bundle(),
|
syncExemptionFlag, callingUid, callingPid);
|
}
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, userId);
|
mContext.sendBroadcast(ContentResolver.ACTION_SYNC_CONN_STATUS_CHANGED);
|
queueBackup();
|
}
|
|
public boolean getMasterSyncAutomatically(int userId) {
|
synchronized (mAuthorities) {
|
Boolean auto = mMasterSyncAutomatically.get(userId);
|
return auto == null ? mDefaultMasterSyncAutomatically : auto;
|
}
|
}
|
|
public int getAuthorityCount() {
|
synchronized (mAuthorities) {
|
return mAuthorities.size();
|
}
|
}
|
|
public AuthorityInfo getAuthority(int authorityId) {
|
synchronized (mAuthorities) {
|
return mAuthorities.get(authorityId);
|
}
|
}
|
|
/**
|
* Returns true if there is currently a sync operation being actively processed for the given
|
* target.
|
*/
|
public boolean isSyncActive(EndPoint info) {
|
synchronized (mAuthorities) {
|
for (SyncInfo syncInfo : getCurrentSyncs(info.userId)) {
|
AuthorityInfo ainfo = getAuthority(syncInfo.authorityId);
|
if (ainfo != null && ainfo.target.matchesSpec(info)) {
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
public void markPending(EndPoint info, boolean pendingValue) {
|
synchronized (mAuthorities) {
|
AuthorityInfo authority = getOrCreateAuthorityLocked(info,
|
-1 /* desired identifier */,
|
true /* write accounts to storage */);
|
if (authority == null) {
|
return;
|
}
|
SyncStatusInfo status = getOrCreateSyncStatusLocked(authority.ident);
|
status.pending = pendingValue;
|
}
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_PENDING, info.userId);
|
}
|
|
/**
|
* Called when the set of account has changed, given the new array of
|
* active accounts.
|
*/
|
public void removeStaleAccounts(@Nullable Account[] currentAccounts, int userId) {
|
synchronized (mAuthorities) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "Updating for new accounts...");
|
}
|
SparseArray<AuthorityInfo> removing = new SparseArray<AuthorityInfo>();
|
Iterator<AccountInfo> accIt = mAccounts.values().iterator();
|
while (accIt.hasNext()) {
|
AccountInfo acc = accIt.next();
|
if (acc.accountAndUser.userId != userId) {
|
continue; // Irrelevant user.
|
}
|
if ((currentAccounts == null)
|
|| !ArrayUtils.contains(currentAccounts, acc.accountAndUser.account)) {
|
// This account no longer exists...
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "Account removed: " + acc.accountAndUser);
|
}
|
for (AuthorityInfo auth : acc.authorities.values()) {
|
removing.put(auth.ident, auth);
|
}
|
accIt.remove();
|
}
|
}
|
|
// Clean out all data structures.
|
int i = removing.size();
|
if (i > 0) {
|
while (i > 0) {
|
i--;
|
int ident = removing.keyAt(i);
|
AuthorityInfo auth = removing.valueAt(i);
|
if (mAuthorityRemovedListener != null) {
|
mAuthorityRemovedListener.onAuthorityRemoved(auth.target);
|
}
|
mAuthorities.remove(ident);
|
int j = mSyncStatus.size();
|
while (j > 0) {
|
j--;
|
if (mSyncStatus.keyAt(j) == ident) {
|
mSyncStatus.remove(mSyncStatus.keyAt(j));
|
}
|
}
|
j = mSyncHistory.size();
|
while (j > 0) {
|
j--;
|
if (mSyncHistory.get(j).authorityId == ident) {
|
mSyncHistory.remove(j);
|
}
|
}
|
}
|
writeAccountInfoLocked();
|
writeStatusLocked();
|
writeStatisticsLocked();
|
}
|
}
|
}
|
|
/**
|
* Called when a sync is starting. Supply a valid ActiveSyncContext with information
|
* about the sync.
|
*/
|
public SyncInfo addActiveSync(SyncManager.ActiveSyncContext activeSyncContext) {
|
final SyncInfo syncInfo;
|
synchronized (mAuthorities) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "setActiveSync: account="
|
+ " auth=" + activeSyncContext.mSyncOperation.target
|
+ " src=" + activeSyncContext.mSyncOperation.syncSource
|
+ " extras=" + activeSyncContext.mSyncOperation.extras);
|
}
|
final EndPoint info = activeSyncContext.mSyncOperation.target;
|
AuthorityInfo authorityInfo = getOrCreateAuthorityLocked(
|
info,
|
-1 /* assign a new identifier if creating a new target */,
|
true /* write to storage if this results in a change */);
|
syncInfo = new SyncInfo(
|
authorityInfo.ident,
|
authorityInfo.target.account,
|
authorityInfo.target.provider,
|
activeSyncContext.mStartTime);
|
getCurrentSyncs(authorityInfo.target.userId).add(syncInfo);
|
}
|
reportActiveChange(activeSyncContext.mSyncOperation.target.userId);
|
return syncInfo;
|
}
|
|
/**
|
* Called to indicate that a previously active sync is no longer active.
|
*/
|
public void removeActiveSync(SyncInfo syncInfo, int userId) {
|
synchronized (mAuthorities) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "removeActiveSync: account=" + syncInfo.account
|
+ " user=" + userId
|
+ " auth=" + syncInfo.authority);
|
}
|
getCurrentSyncs(userId).remove(syncInfo);
|
}
|
|
reportActiveChange(userId);
|
}
|
|
/**
|
* To allow others to send active change reports, to poke clients.
|
*/
|
public void reportActiveChange(int userId) {
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE, userId);
|
}
|
|
/**
|
* Note that sync has started for the given operation.
|
*/
|
public long insertStartSyncEvent(SyncOperation op, long now) {
|
long id;
|
synchronized (mAuthorities) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "insertStartSyncEvent: " + op);
|
}
|
AuthorityInfo authority = getAuthorityLocked(op.target, "insertStartSyncEvent");
|
if (authority == null) {
|
return -1;
|
}
|
SyncHistoryItem item = new SyncHistoryItem();
|
item.initialization = op.isInitialization();
|
item.authorityId = authority.ident;
|
item.historyId = mNextHistoryId++;
|
if (mNextHistoryId < 0) mNextHistoryId = 0;
|
item.eventTime = now;
|
item.source = op.syncSource;
|
item.reason = op.reason;
|
item.extras = op.extras;
|
item.event = EVENT_START;
|
item.syncExemptionFlag = op.syncExemptionFlag;
|
mSyncHistory.add(0, item);
|
while (mSyncHistory.size() > MAX_HISTORY) {
|
mSyncHistory.remove(mSyncHistory.size()-1);
|
}
|
id = item.historyId;
|
if (Log.isLoggable(TAG, Log.VERBOSE)) Slog.v(TAG, "returning historyId " + id);
|
}
|
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_STATUS, op.target.userId);
|
return id;
|
}
|
|
public void stopSyncEvent(long historyId, long elapsedTime, String resultMessage,
|
long downstreamActivity, long upstreamActivity, int userId) {
|
synchronized (mAuthorities) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "stopSyncEvent: historyId=" + historyId);
|
}
|
SyncHistoryItem item = null;
|
int i = mSyncHistory.size();
|
while (i > 0) {
|
i--;
|
item = mSyncHistory.get(i);
|
if (item.historyId == historyId) {
|
break;
|
}
|
item = null;
|
}
|
|
if (item == null) {
|
Slog.w(TAG, "stopSyncEvent: no history for id " + historyId);
|
return;
|
}
|
|
item.elapsedTime = elapsedTime;
|
item.event = EVENT_STOP;
|
item.mesg = resultMessage;
|
item.downstreamActivity = downstreamActivity;
|
item.upstreamActivity = upstreamActivity;
|
|
SyncStatusInfo status = getOrCreateSyncStatusLocked(item.authorityId);
|
|
status.maybeResetTodayStats(isClockValid(), /*force=*/ false);
|
|
status.totalStats.numSyncs++;
|
status.todayStats.numSyncs++;
|
status.totalStats.totalElapsedTime += elapsedTime;
|
status.todayStats.totalElapsedTime += elapsedTime;
|
switch (item.source) {
|
case SOURCE_LOCAL:
|
status.totalStats.numSourceLocal++;
|
status.todayStats.numSourceLocal++;
|
break;
|
case SOURCE_POLL:
|
status.totalStats.numSourcePoll++;
|
status.todayStats.numSourcePoll++;
|
break;
|
case SOURCE_USER:
|
status.totalStats.numSourceUser++;
|
status.todayStats.numSourceUser++;
|
break;
|
case SOURCE_OTHER:
|
status.totalStats.numSourceOther++;
|
status.todayStats.numSourceOther++;
|
break;
|
case SOURCE_PERIODIC:
|
status.totalStats.numSourcePeriodic++;
|
status.todayStats.numSourcePeriodic++;
|
break;
|
case SOURCE_FEED:
|
status.totalStats.numSourceFeed++;
|
status.todayStats.numSourceFeed++;
|
break;
|
}
|
|
boolean writeStatisticsNow = false;
|
int day = getCurrentDayLocked();
|
if (mDayStats[0] == null) {
|
mDayStats[0] = new DayStats(day);
|
} else if (day != mDayStats[0].day) {
|
System.arraycopy(mDayStats, 0, mDayStats, 1, mDayStats.length-1);
|
mDayStats[0] = new DayStats(day);
|
writeStatisticsNow = true;
|
} else if (mDayStats[0] == null) {
|
}
|
final DayStats ds = mDayStats[0];
|
|
final long lastSyncTime = (item.eventTime + elapsedTime);
|
boolean writeStatusNow = false;
|
if (MESG_SUCCESS.equals(resultMessage)) {
|
// - if successful, update the successful columns
|
if (status.lastSuccessTime == 0 || status.lastFailureTime != 0) {
|
writeStatusNow = true;
|
}
|
status.setLastSuccess(item.source, lastSyncTime);
|
ds.successCount++;
|
ds.successTime += elapsedTime;
|
} else if (!MESG_CANCELED.equals(resultMessage)) {
|
if (status.lastFailureTime == 0) {
|
writeStatusNow = true;
|
}
|
status.totalStats.numFailures++;
|
status.todayStats.numFailures++;
|
|
status.setLastFailure(item.source, lastSyncTime, resultMessage);
|
|
ds.failureCount++;
|
ds.failureTime += elapsedTime;
|
} else {
|
// Cancel
|
status.totalStats.numCancels++;
|
status.todayStats.numCancels++;
|
writeStatusNow = true;
|
}
|
final StringBuilder event = new StringBuilder();
|
event.append("" + resultMessage + " Source=" + SyncStorageEngine.SOURCES[item.source]
|
+ " Elapsed=");
|
SyncManager.formatDurationHMS(event, elapsedTime);
|
event.append(" Reason=");
|
event.append(SyncOperation.reasonToString(null, item.reason));
|
if (item.syncExemptionFlag != ContentResolver.SYNC_EXEMPTION_NONE) {
|
event.append(" Exemption=");
|
switch (item.syncExemptionFlag) {
|
case ContentResolver.SYNC_EXEMPTION_PROMOTE_BUCKET:
|
event.append("fg");
|
break;
|
case ContentResolver.SYNC_EXEMPTION_PROMOTE_BUCKET_WITH_TEMP:
|
event.append("top");
|
break;
|
default:
|
event.append(item.syncExemptionFlag);
|
break;
|
}
|
}
|
event.append(" Extras=");
|
SyncOperation.extrasToStringBuilder(item.extras, event);
|
|
status.addEvent(event.toString());
|
|
if (writeStatusNow) {
|
writeStatusLocked();
|
} else if (!mHandler.hasMessages(MSG_WRITE_STATUS)) {
|
mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_WRITE_STATUS),
|
WRITE_STATUS_DELAY);
|
}
|
if (writeStatisticsNow) {
|
writeStatisticsLocked();
|
} else if (!mHandler.hasMessages(MSG_WRITE_STATISTICS)) {
|
mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_WRITE_STATISTICS),
|
WRITE_STATISTICS_DELAY);
|
}
|
}
|
|
reportChange(ContentResolver.SYNC_OBSERVER_TYPE_STATUS, userId);
|
}
|
|
/**
|
* Return a list of the currently active syncs. Note that the returned
|
* items are the real, live active sync objects, so be careful what you do
|
* with it.
|
*/
|
private List<SyncInfo> getCurrentSyncs(int userId) {
|
synchronized (mAuthorities) {
|
return getCurrentSyncsLocked(userId);
|
}
|
}
|
|
/**
|
* @param userId Id of user to return current sync info.
|
* @param canAccessAccounts Determines whether to redact Account information from the result.
|
* @return a copy of the current syncs data structure. Will not return null.
|
*/
|
public List<SyncInfo> getCurrentSyncsCopy(int userId, boolean canAccessAccounts) {
|
synchronized (mAuthorities) {
|
final List<SyncInfo> syncs = getCurrentSyncsLocked(userId);
|
final List<SyncInfo> syncsCopy = new ArrayList<SyncInfo>();
|
for (SyncInfo sync : syncs) {
|
SyncInfo copy;
|
if (!canAccessAccounts) {
|
copy = SyncInfo.createAccountRedacted(
|
sync.authorityId, sync.authority, sync.startTime);
|
} else {
|
copy = new SyncInfo(sync);
|
}
|
syncsCopy.add(copy);
|
}
|
return syncsCopy;
|
}
|
}
|
|
private List<SyncInfo> getCurrentSyncsLocked(int userId) {
|
ArrayList<SyncInfo> syncs = mCurrentSyncs.get(userId);
|
if (syncs == null) {
|
syncs = new ArrayList<SyncInfo>();
|
mCurrentSyncs.put(userId, syncs);
|
}
|
return syncs;
|
}
|
|
/**
|
* Return a copy of the specified target with the corresponding sync status
|
*/
|
public Pair<AuthorityInfo, SyncStatusInfo> getCopyOfAuthorityWithSyncStatus(EndPoint info) {
|
synchronized (mAuthorities) {
|
AuthorityInfo authorityInfo = getOrCreateAuthorityLocked(info,
|
-1 /* assign a new identifier if creating a new target */,
|
true /* write to storage if this results in a change */);
|
return createCopyPairOfAuthorityWithSyncStatusLocked(authorityInfo);
|
}
|
}
|
|
/**
|
* Returns the status that matches the target.
|
*
|
* @param info the endpoint target we are querying status info for.
|
* @return the SyncStatusInfo for the endpoint.
|
*/
|
public SyncStatusInfo getStatusByAuthority(EndPoint info) {
|
if (info.account == null || info.provider == null) {
|
return null;
|
}
|
synchronized (mAuthorities) {
|
final int N = mSyncStatus.size();
|
for (int i = 0; i < N; i++) {
|
SyncStatusInfo cur = mSyncStatus.valueAt(i);
|
AuthorityInfo ainfo = mAuthorities.get(cur.authorityId);
|
if (ainfo != null
|
&& ainfo.target.matchesSpec(info)) {
|
return cur;
|
}
|
}
|
return null;
|
}
|
}
|
|
/** Return true if the pending status is true of any matching authorities. */
|
public boolean isSyncPending(EndPoint info) {
|
synchronized (mAuthorities) {
|
final int N = mSyncStatus.size();
|
for (int i = 0; i < N; i++) {
|
SyncStatusInfo cur = mSyncStatus.valueAt(i);
|
AuthorityInfo ainfo = mAuthorities.get(cur.authorityId);
|
if (ainfo == null) {
|
continue;
|
}
|
if (!ainfo.target.matchesSpec(info)) {
|
continue;
|
}
|
if (cur.pending) {
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
|
/**
|
* Return an array of the current sync status for all authorities. Note
|
* that the objects inside the array are the real, live status objects,
|
* so be careful what you do with them.
|
*/
|
public ArrayList<SyncHistoryItem> getSyncHistory() {
|
synchronized (mAuthorities) {
|
final int N = mSyncHistory.size();
|
ArrayList<SyncHistoryItem> items = new ArrayList<SyncHistoryItem>(N);
|
for (int i=0; i<N; i++) {
|
items.add(mSyncHistory.get(i));
|
}
|
return items;
|
}
|
}
|
|
/**
|
* Return an array of the current per-day statistics. Note
|
* that the objects inside the array are the real, live status objects,
|
* so be careful what you do with them.
|
*/
|
public DayStats[] getDayStatistics() {
|
synchronized (mAuthorities) {
|
DayStats[] ds = new DayStats[mDayStats.length];
|
System.arraycopy(mDayStats, 0, ds, 0, ds.length);
|
return ds;
|
}
|
}
|
|
private Pair<AuthorityInfo, SyncStatusInfo> createCopyPairOfAuthorityWithSyncStatusLocked(
|
AuthorityInfo authorityInfo) {
|
SyncStatusInfo syncStatusInfo = getOrCreateSyncStatusLocked(authorityInfo.ident);
|
return Pair.create(new AuthorityInfo(authorityInfo), new SyncStatusInfo(syncStatusInfo));
|
}
|
|
private int getCurrentDayLocked() {
|
mCal.setTimeInMillis(System.currentTimeMillis());
|
final int dayOfYear = mCal.get(Calendar.DAY_OF_YEAR);
|
if (mYear != mCal.get(Calendar.YEAR)) {
|
mYear = mCal.get(Calendar.YEAR);
|
mCal.clear();
|
mCal.set(Calendar.YEAR, mYear);
|
mYearInDays = (int)(mCal.getTimeInMillis()/86400000);
|
}
|
return dayOfYear + mYearInDays;
|
}
|
|
/**
|
* Retrieve a target's full info, returning null if one does not exist.
|
*
|
* @param info info of the target to look up.
|
* @param tag If non-null, this will be used in a log message if the
|
* requested target does not exist.
|
*/
|
private AuthorityInfo getAuthorityLocked(EndPoint info, String tag) {
|
AccountAndUser au = new AccountAndUser(info.account, info.userId);
|
AccountInfo accountInfo = mAccounts.get(au);
|
if (accountInfo == null) {
|
if (tag != null) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, tag + ": unknown account " + au);
|
}
|
}
|
return null;
|
}
|
AuthorityInfo authority = accountInfo.authorities.get(info.provider);
|
if (authority == null) {
|
if (tag != null) {
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, tag + ": unknown provider " + info.provider);
|
}
|
}
|
return null;
|
}
|
return authority;
|
}
|
|
/**
|
* @param info info identifying target.
|
* @param ident unique identifier for target. -1 for none.
|
* @param doWrite if true, update the accounts.xml file on the disk.
|
* @return the authority that corresponds to the provided sync target, creating it if none
|
* exists.
|
*/
|
private AuthorityInfo getOrCreateAuthorityLocked(EndPoint info, int ident, boolean doWrite) {
|
AuthorityInfo authority = null;
|
AccountAndUser au = new AccountAndUser(info.account, info.userId);
|
AccountInfo account = mAccounts.get(au);
|
if (account == null) {
|
account = new AccountInfo(au);
|
mAccounts.put(au, account);
|
}
|
authority = account.authorities.get(info.provider);
|
if (authority == null) {
|
authority = createAuthorityLocked(info, ident, doWrite);
|
account.authorities.put(info.provider, authority);
|
}
|
return authority;
|
}
|
|
private AuthorityInfo createAuthorityLocked(EndPoint info, int ident, boolean doWrite) {
|
AuthorityInfo authority;
|
if (ident < 0) {
|
ident = mNextAuthorityId;
|
mNextAuthorityId++;
|
doWrite = true;
|
}
|
if (Log.isLoggable(TAG, Log.VERBOSE)) {
|
Slog.v(TAG, "created a new AuthorityInfo for " + info);
|
}
|
authority = new AuthorityInfo(info, ident);
|
mAuthorities.put(ident, authority);
|
if (doWrite) {
|
writeAccountInfoLocked();
|
}
|
return authority;
|
}
|
|
public void removeAuthority(EndPoint info) {
|
synchronized (mAuthorities) {
|
removeAuthorityLocked(info.account, info.userId, info.provider, true /* doWrite */);
|
}
|
}
|
|
|
/**
|
* Remove an authority associated with a provider. Needs to be a standalone function for
|
* backward compatibility.
|
*/
|
private void removeAuthorityLocked(Account account, int userId, String authorityName,
|
boolean doWrite) {
|
AccountInfo accountInfo = mAccounts.get(new AccountAndUser(account, userId));
|
if (accountInfo != null) {
|
final AuthorityInfo authorityInfo = accountInfo.authorities.remove(authorityName);
|
if (authorityInfo != null) {
|
if (mAuthorityRemovedListener != null) {
|
mAuthorityRemovedListener.onAuthorityRemoved(authorityInfo.target);
|
}
|
mAuthorities.remove(authorityInfo.ident);
|
if (doWrite) {
|
writeAccountInfoLocked();
|
}
|
}
|
}
|
}
|
|
private SyncStatusInfo getOrCreateSyncStatusLocked(int authorityId) {
|
SyncStatusInfo status = mSyncStatus.get(authorityId);
|
if (status == null) {
|
status = new SyncStatusInfo(authorityId);
|
mSyncStatus.put(authorityId, status);
|
}
|
return status;
|
}
|
|
public void writeAllState() {
|
synchronized (mAuthorities) {
|
// Account info is always written so no need to do it here.
|
writeStatusLocked();
|
writeStatisticsLocked();
|
}
|
}
|
|
public boolean shouldGrantSyncAdaptersAccountAccess() {
|
return mGrantSyncAdaptersAccountAccess;
|
}
|
|
/**
|
* public for testing
|
*/
|
public void clearAndReadState() {
|
synchronized (mAuthorities) {
|
mAuthorities.clear();
|
mAccounts.clear();
|
mServices.clear();
|
mSyncStatus.clear();
|
mSyncHistory.clear();
|
|
readAccountInfoLocked();
|
readStatusLocked();
|
readStatisticsLocked();
|
writeAccountInfoLocked();
|
writeStatusLocked();
|
writeStatisticsLocked();
|
}
|
}
|
|
/**
|
* Read all account information back in to the initial engine state.
|
*/
|
private void readAccountInfoLocked() {
|
int highestAuthorityId = -1;
|
FileInputStream fis = null;
|
try {
|
fis = mAccountInfoFile.openRead();
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG_FILE, "Reading " + mAccountInfoFile.getBaseFile());
|
}
|
XmlPullParser parser = Xml.newPullParser();
|
parser.setInput(fis, StandardCharsets.UTF_8.name());
|
int eventType = parser.getEventType();
|
while (eventType != XmlPullParser.START_TAG &&
|
eventType != XmlPullParser.END_DOCUMENT) {
|
eventType = parser.next();
|
}
|
if (eventType == XmlPullParser.END_DOCUMENT) {
|
Slog.i(TAG, "No initial accounts");
|
return;
|
}
|
|
String tagName = parser.getName();
|
if ("accounts".equals(tagName)) {
|
String listen = parser.getAttributeValue(null, XML_ATTR_LISTEN_FOR_TICKLES);
|
String versionString = parser.getAttributeValue(null, "version");
|
int version;
|
try {
|
version = (versionString == null) ? 0 : Integer.parseInt(versionString);
|
} catch (NumberFormatException e) {
|
version = 0;
|
}
|
|
if (version < 3) {
|
mGrantSyncAdaptersAccountAccess = true;
|
}
|
|
String nextIdString = parser.getAttributeValue(null, XML_ATTR_NEXT_AUTHORITY_ID);
|
try {
|
int id = (nextIdString == null) ? 0 : Integer.parseInt(nextIdString);
|
mNextAuthorityId = Math.max(mNextAuthorityId, id);
|
} catch (NumberFormatException e) {
|
// don't care
|
}
|
String offsetString = parser.getAttributeValue(null, XML_ATTR_SYNC_RANDOM_OFFSET);
|
try {
|
mSyncRandomOffset = (offsetString == null) ? 0 : Integer.parseInt(offsetString);
|
} catch (NumberFormatException e) {
|
mSyncRandomOffset = 0;
|
}
|
if (mSyncRandomOffset == 0) {
|
Random random = new Random(System.currentTimeMillis());
|
mSyncRandomOffset = random.nextInt(86400);
|
}
|
mMasterSyncAutomatically.put(0, listen == null || Boolean.parseBoolean(listen));
|
eventType = parser.next();
|
AuthorityInfo authority = null;
|
PeriodicSync periodicSync = null;
|
AccountAuthorityValidator validator = new AccountAuthorityValidator(mContext);
|
do {
|
if (eventType == XmlPullParser.START_TAG) {
|
tagName = parser.getName();
|
if (parser.getDepth() == 2) {
|
if ("authority".equals(tagName)) {
|
authority = parseAuthority(parser, version, validator);
|
periodicSync = null;
|
if (authority != null) {
|
if (authority.ident > highestAuthorityId) {
|
highestAuthorityId = authority.ident;
|
}
|
} else {
|
EventLog.writeEvent(0x534e4554, "26513719", -1,
|
"Malformed authority");
|
}
|
} else if (XML_TAG_LISTEN_FOR_TICKLES.equals(tagName)) {
|
parseListenForTickles(parser);
|
}
|
} else if (parser.getDepth() == 3) {
|
if ("periodicSync".equals(tagName) && authority != null) {
|
periodicSync = parsePeriodicSync(parser, authority);
|
}
|
} else if (parser.getDepth() == 4 && periodicSync != null) {
|
if ("extra".equals(tagName)) {
|
parseExtra(parser, periodicSync.extras);
|
}
|
}
|
}
|
eventType = parser.next();
|
} while (eventType != XmlPullParser.END_DOCUMENT);
|
}
|
} catch (XmlPullParserException e) {
|
Slog.w(TAG, "Error reading accounts", e);
|
return;
|
} catch (java.io.IOException e) {
|
if (fis == null) Slog.i(TAG, "No initial accounts");
|
else Slog.w(TAG, "Error reading accounts", e);
|
return;
|
} finally {
|
mNextAuthorityId = Math.max(highestAuthorityId + 1, mNextAuthorityId);
|
if (fis != null) {
|
try {
|
fis.close();
|
} catch (java.io.IOException e1) {
|
}
|
}
|
}
|
|
maybeMigrateSettingsForRenamedAuthorities();
|
}
|
|
/**
|
* Ensure the old pending.bin is deleted, as it has been changed to pending.xml.
|
* pending.xml was used starting in KLP.
|
* @param syncDir directory where the sync files are located.
|
*/
|
private void maybeDeleteLegacyPendingInfoLocked(File syncDir) {
|
File file = new File(syncDir, "pending.bin");
|
if (!file.exists()) {
|
return;
|
} else {
|
file.delete();
|
}
|
}
|
|
/**
|
* some authority names have changed. copy over their settings and delete the old ones
|
* @return true if a change was made
|
*/
|
private boolean maybeMigrateSettingsForRenamedAuthorities() {
|
boolean writeNeeded = false;
|
|
ArrayList<AuthorityInfo> authoritiesToRemove = new ArrayList<AuthorityInfo>();
|
final int N = mAuthorities.size();
|
for (int i = 0; i < N; i++) {
|
AuthorityInfo authority = mAuthorities.valueAt(i);
|
// skip this authority if it isn't one of the renamed ones
|
final String newAuthorityName = sAuthorityRenames.get(authority.target.provider);
|
if (newAuthorityName == null) {
|
continue;
|
}
|
|
// remember this authority so we can remove it later. we can't remove it
|
// now without messing up this loop iteration
|
authoritiesToRemove.add(authority);
|
|
// this authority isn't enabled, no need to copy it to the new authority name since
|
// the default is "disabled"
|
if (!authority.enabled) {
|
continue;
|
}
|
|
// if we already have a record of this new authority then don't copy over the settings
|
EndPoint newInfo =
|
new EndPoint(authority.target.account,
|
newAuthorityName,
|
authority.target.userId);
|
if (getAuthorityLocked(newInfo, "cleanup") != null) {
|
continue;
|
}
|
|
AuthorityInfo newAuthority =
|
getOrCreateAuthorityLocked(newInfo, -1 /* ident */, false /* doWrite */);
|
newAuthority.enabled = true;
|
writeNeeded = true;
|
}
|
|
for (AuthorityInfo authorityInfo : authoritiesToRemove) {
|
removeAuthorityLocked(
|
authorityInfo.target.account,
|
authorityInfo.target.userId,
|
authorityInfo.target.provider,
|
false /* doWrite */);
|
writeNeeded = true;
|
}
|
|
return writeNeeded;
|
}
|
|
private void parseListenForTickles(XmlPullParser parser) {
|
String user = parser.getAttributeValue(null, XML_ATTR_USER);
|
int userId = 0;
|
try {
|
userId = Integer.parseInt(user);
|
} catch (NumberFormatException e) {
|
Slog.e(TAG, "error parsing the user for listen-for-tickles", e);
|
} catch (NullPointerException e) {
|
Slog.e(TAG, "the user in listen-for-tickles is null", e);
|
}
|
String enabled = parser.getAttributeValue(null, XML_ATTR_ENABLED);
|
boolean listen = enabled == null || Boolean.parseBoolean(enabled);
|
mMasterSyncAutomatically.put(userId, listen);
|
}
|
|
private AuthorityInfo parseAuthority(XmlPullParser parser, int version,
|
AccountAuthorityValidator validator) {
|
AuthorityInfo authority = null;
|
int id = -1;
|
try {
|
id = Integer.parseInt(parser.getAttributeValue(null, "id"));
|
} catch (NumberFormatException e) {
|
Slog.e(TAG, "error parsing the id of the authority", e);
|
} catch (NullPointerException e) {
|
Slog.e(TAG, "the id of the authority is null", e);
|
}
|
if (id >= 0) {
|
String authorityName = parser.getAttributeValue(null, "authority");
|
String enabled = parser.getAttributeValue(null, XML_ATTR_ENABLED);
|
String syncable = parser.getAttributeValue(null, "syncable");
|
String accountName = parser.getAttributeValue(null, "account");
|
String accountType = parser.getAttributeValue(null, "type");
|
String user = parser.getAttributeValue(null, XML_ATTR_USER);
|
String packageName = parser.getAttributeValue(null, "package");
|
String className = parser.getAttributeValue(null, "class");
|
int userId = user == null ? 0 : Integer.parseInt(user);
|
if (accountType == null && packageName == null) {
|
accountType = "com.google";
|
syncable = String.valueOf(AuthorityInfo.NOT_INITIALIZED);
|
}
|
authority = mAuthorities.get(id);
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG_FILE, "Adding authority:"
|
+ " account=" + accountName
|
+ " accountType=" + accountType
|
+ " auth=" + authorityName
|
+ " package=" + packageName
|
+ " class=" + className
|
+ " user=" + userId
|
+ " enabled=" + enabled
|
+ " syncable=" + syncable);
|
}
|
if (authority == null) {
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG_FILE, "Creating authority entry");
|
}
|
if (accountName != null && authorityName != null) {
|
EndPoint info = new EndPoint(
|
new Account(accountName, accountType),
|
authorityName, userId);
|
if (validator.isAccountValid(info.account, userId)
|
&& validator.isAuthorityValid(authorityName, userId)) {
|
authority = getOrCreateAuthorityLocked(info, id, false);
|
// If the version is 0 then we are upgrading from a file format that did not
|
// know about periodic syncs. In that case don't clear the list since we
|
// want the default, which is a daily periodic sync.
|
// Otherwise clear out this default list since we will populate it later
|
// with
|
// the periodic sync descriptions that are read from the configuration file.
|
if (version > 0) {
|
authority.periodicSyncs.clear();
|
}
|
} else {
|
EventLog.writeEvent(0x534e4554, "35028827", -1,
|
"account:" + info.account + " provider:" + authorityName + " user:"
|
+ userId);
|
}
|
}
|
}
|
if (authority != null) {
|
authority.enabled = enabled == null || Boolean.parseBoolean(enabled);
|
try {
|
authority.syncable = (syncable == null) ?
|
AuthorityInfo.NOT_INITIALIZED : Integer.parseInt(syncable);
|
} catch (NumberFormatException e) {
|
// On L we stored this as {"unknown", "true", "false"} so fall back to this
|
// format.
|
if ("unknown".equals(syncable)) {
|
authority.syncable = AuthorityInfo.NOT_INITIALIZED;
|
} else {
|
authority.syncable = Boolean.parseBoolean(syncable) ?
|
AuthorityInfo.SYNCABLE : AuthorityInfo.NOT_SYNCABLE;
|
}
|
|
}
|
} else {
|
Slog.w(TAG, "Failure adding authority:"
|
+ " auth=" + authorityName
|
+ " enabled=" + enabled
|
+ " syncable=" + syncable);
|
}
|
}
|
return authority;
|
}
|
|
/**
|
* Parse a periodic sync from accounts.xml. Sets the bundle to be empty.
|
*/
|
private PeriodicSync parsePeriodicSync(XmlPullParser parser, AuthorityInfo authorityInfo) {
|
Bundle extras = new Bundle(); // Gets filled in later.
|
String periodValue = parser.getAttributeValue(null, "period");
|
String flexValue = parser.getAttributeValue(null, "flex");
|
final long period;
|
long flextime;
|
try {
|
period = Long.parseLong(periodValue);
|
} catch (NumberFormatException e) {
|
Slog.e(TAG, "error parsing the period of a periodic sync", e);
|
return null;
|
} catch (NullPointerException e) {
|
Slog.e(TAG, "the period of a periodic sync is null", e);
|
return null;
|
}
|
try {
|
flextime = Long.parseLong(flexValue);
|
} catch (NumberFormatException e) {
|
flextime = calculateDefaultFlexTime(period);
|
Slog.e(TAG, "Error formatting value parsed for periodic sync flex: " + flexValue
|
+ ", using default: "
|
+ flextime);
|
} catch (NullPointerException expected) {
|
flextime = calculateDefaultFlexTime(period);
|
Slog.d(TAG, "No flex time specified for this sync, using a default. period: "
|
+ period + " flex: " + flextime);
|
}
|
PeriodicSync periodicSync;
|
periodicSync =
|
new PeriodicSync(authorityInfo.target.account,
|
authorityInfo.target.provider,
|
extras,
|
period, flextime);
|
authorityInfo.periodicSyncs.add(periodicSync);
|
return periodicSync;
|
}
|
|
private void parseExtra(XmlPullParser parser, Bundle extras) {
|
String name = parser.getAttributeValue(null, "name");
|
String type = parser.getAttributeValue(null, "type");
|
String value1 = parser.getAttributeValue(null, "value1");
|
String value2 = parser.getAttributeValue(null, "value2");
|
|
try {
|
if ("long".equals(type)) {
|
extras.putLong(name, Long.parseLong(value1));
|
} else if ("integer".equals(type)) {
|
extras.putInt(name, Integer.parseInt(value1));
|
} else if ("double".equals(type)) {
|
extras.putDouble(name, Double.parseDouble(value1));
|
} else if ("float".equals(type)) {
|
extras.putFloat(name, Float.parseFloat(value1));
|
} else if ("boolean".equals(type)) {
|
extras.putBoolean(name, Boolean.parseBoolean(value1));
|
} else if ("string".equals(type)) {
|
extras.putString(name, value1);
|
} else if ("account".equals(type)) {
|
extras.putParcelable(name, new Account(value1, value2));
|
}
|
} catch (NumberFormatException e) {
|
Slog.e(TAG, "error parsing bundle value", e);
|
} catch (NullPointerException e) {
|
Slog.e(TAG, "error parsing bundle value", e);
|
}
|
}
|
|
/**
|
* Write all account information to the account file.
|
*/
|
private void writeAccountInfoLocked() {
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG_FILE, "Writing new " + mAccountInfoFile.getBaseFile());
|
}
|
FileOutputStream fos = null;
|
|
try {
|
fos = mAccountInfoFile.startWrite();
|
XmlSerializer out = new FastXmlSerializer();
|
out.setOutput(fos, StandardCharsets.UTF_8.name());
|
out.startDocument(null, true);
|
out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
|
|
out.startTag(null, "accounts");
|
out.attribute(null, "version", Integer.toString(ACCOUNTS_VERSION));
|
out.attribute(null, XML_ATTR_NEXT_AUTHORITY_ID, Integer.toString(mNextAuthorityId));
|
out.attribute(null, XML_ATTR_SYNC_RANDOM_OFFSET, Integer.toString(mSyncRandomOffset));
|
|
// Write the Sync Automatically flags for each user
|
final int M = mMasterSyncAutomatically.size();
|
for (int m = 0; m < M; m++) {
|
int userId = mMasterSyncAutomatically.keyAt(m);
|
Boolean listen = mMasterSyncAutomatically.valueAt(m);
|
out.startTag(null, XML_TAG_LISTEN_FOR_TICKLES);
|
out.attribute(null, XML_ATTR_USER, Integer.toString(userId));
|
out.attribute(null, XML_ATTR_ENABLED, Boolean.toString(listen));
|
out.endTag(null, XML_TAG_LISTEN_FOR_TICKLES);
|
}
|
|
final int N = mAuthorities.size();
|
for (int i = 0; i < N; i++) {
|
AuthorityInfo authority = mAuthorities.valueAt(i);
|
EndPoint info = authority.target;
|
out.startTag(null, "authority");
|
out.attribute(null, "id", Integer.toString(authority.ident));
|
out.attribute(null, XML_ATTR_USER, Integer.toString(info.userId));
|
out.attribute(null, XML_ATTR_ENABLED, Boolean.toString(authority.enabled));
|
out.attribute(null, "account", info.account.name);
|
out.attribute(null, "type", info.account.type);
|
out.attribute(null, "authority", info.provider);
|
out.attribute(null, "syncable", Integer.toString(authority.syncable));
|
out.endTag(null, "authority");
|
}
|
out.endTag(null, "accounts");
|
out.endDocument();
|
mAccountInfoFile.finishWrite(fos);
|
} catch (java.io.IOException e1) {
|
Slog.w(TAG, "Error writing accounts", e1);
|
if (fos != null) {
|
mAccountInfoFile.failWrite(fos);
|
}
|
}
|
}
|
|
public static final int STATUS_FILE_END = 0;
|
public static final int STATUS_FILE_ITEM = 100;
|
|
/**
|
* Read all sync status back in to the initial engine state.
|
*/
|
private void readStatusLocked() {
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG_FILE, "Reading " + mStatusFile.getBaseFile());
|
}
|
try {
|
byte[] data = mStatusFile.readFully();
|
Parcel in = Parcel.obtain();
|
in.unmarshall(data, 0, data.length);
|
in.setDataPosition(0);
|
int token;
|
while ((token=in.readInt()) != STATUS_FILE_END) {
|
if (token == STATUS_FILE_ITEM) {
|
SyncStatusInfo status = new SyncStatusInfo(in);
|
if (mAuthorities.indexOfKey(status.authorityId) >= 0) {
|
status.pending = false;
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG_FILE, "Adding status for id " + status.authorityId);
|
}
|
mSyncStatus.put(status.authorityId, status);
|
}
|
} else {
|
// Ooops.
|
Slog.w(TAG, "Unknown status token: " + token);
|
break;
|
}
|
}
|
} catch (java.io.IOException e) {
|
Slog.i(TAG, "No initial status");
|
}
|
}
|
|
/**
|
* Write all sync status to the sync status file.
|
*/
|
private void writeStatusLocked() {
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG_FILE, "Writing new " + mStatusFile.getBaseFile());
|
}
|
|
// The file is being written, so we don't need to have a scheduled
|
// write until the next change.
|
mHandler.removeMessages(MSG_WRITE_STATUS);
|
|
FileOutputStream fos = null;
|
try {
|
fos = mStatusFile.startWrite();
|
Parcel out = Parcel.obtain();
|
final int N = mSyncStatus.size();
|
for (int i=0; i<N; i++) {
|
SyncStatusInfo status = mSyncStatus.valueAt(i);
|
out.writeInt(STATUS_FILE_ITEM);
|
status.writeToParcel(out, 0);
|
}
|
out.writeInt(STATUS_FILE_END);
|
fos.write(out.marshall());
|
out.recycle();
|
|
mStatusFile.finishWrite(fos);
|
} catch (java.io.IOException e1) {
|
Slog.w(TAG, "Error writing status", e1);
|
if (fos != null) {
|
mStatusFile.failWrite(fos);
|
}
|
}
|
}
|
|
private void requestSync(AuthorityInfo authorityInfo, int reason, Bundle extras,
|
@SyncExemption int syncExemptionFlag, int callingUid, int callingPid) {
|
if (android.os.Process.myUid() == android.os.Process.SYSTEM_UID
|
&& mSyncRequestListener != null) {
|
mSyncRequestListener.onSyncRequest(authorityInfo.target, reason, extras,
|
syncExemptionFlag, callingUid, callingPid);
|
} else {
|
SyncRequest.Builder req =
|
new SyncRequest.Builder()
|
.syncOnce()
|
.setExtras(extras);
|
req.setSyncAdapter(authorityInfo.target.account, authorityInfo.target.provider);
|
ContentResolver.requestSync(req.build());
|
}
|
}
|
|
private void requestSync(Account account, int userId, int reason, String authority,
|
Bundle extras, @SyncExemption int syncExemptionFlag, int callingUid, int callingPid) {
|
// If this is happening in the system process, then call the syncrequest listener
|
// to make a request back to the SyncManager directly.
|
// If this is probably a test instance, then call back through the ContentResolver
|
// which will know which userId to apply based on the Binder id.
|
if (android.os.Process.myUid() == android.os.Process.SYSTEM_UID
|
&& mSyncRequestListener != null) {
|
mSyncRequestListener.onSyncRequest(
|
new EndPoint(account, authority, userId),
|
reason, extras, syncExemptionFlag, callingUid, callingPid);
|
} else {
|
ContentResolver.requestSync(account, authority, extras);
|
}
|
}
|
|
public static final int STATISTICS_FILE_END = 0;
|
public static final int STATISTICS_FILE_ITEM_OLD = 100;
|
public static final int STATISTICS_FILE_ITEM = 101;
|
|
/**
|
* Read all sync statistics back in to the initial engine state.
|
*/
|
private void readStatisticsLocked() {
|
try {
|
byte[] data = mStatisticsFile.readFully();
|
Parcel in = Parcel.obtain();
|
in.unmarshall(data, 0, data.length);
|
in.setDataPosition(0);
|
int token;
|
int index = 0;
|
while ((token=in.readInt()) != STATISTICS_FILE_END) {
|
if (token == STATISTICS_FILE_ITEM
|
|| token == STATISTICS_FILE_ITEM_OLD) {
|
int day = in.readInt();
|
if (token == STATISTICS_FILE_ITEM_OLD) {
|
day = day - 2009 + 14245; // Magic!
|
}
|
DayStats ds = new DayStats(day);
|
ds.successCount = in.readInt();
|
ds.successTime = in.readLong();
|
ds.failureCount = in.readInt();
|
ds.failureTime = in.readLong();
|
if (index < mDayStats.length) {
|
mDayStats[index] = ds;
|
index++;
|
}
|
} else {
|
// Ooops.
|
Slog.w(TAG, "Unknown stats token: " + token);
|
break;
|
}
|
}
|
} catch (java.io.IOException e) {
|
Slog.i(TAG, "No initial statistics");
|
}
|
}
|
|
/**
|
* Write all sync statistics to the sync status file.
|
*/
|
private void writeStatisticsLocked() {
|
if (Log.isLoggable(TAG_FILE, Log.VERBOSE)) {
|
Slog.v(TAG, "Writing new " + mStatisticsFile.getBaseFile());
|
}
|
|
// The file is being written, so we don't need to have a scheduled
|
// write until the next change.
|
mHandler.removeMessages(MSG_WRITE_STATISTICS);
|
|
FileOutputStream fos = null;
|
try {
|
fos = mStatisticsFile.startWrite();
|
Parcel out = Parcel.obtain();
|
final int N = mDayStats.length;
|
for (int i=0; i<N; i++) {
|
DayStats ds = mDayStats[i];
|
if (ds == null) {
|
break;
|
}
|
out.writeInt(STATISTICS_FILE_ITEM);
|
out.writeInt(ds.day);
|
out.writeInt(ds.successCount);
|
out.writeLong(ds.successTime);
|
out.writeInt(ds.failureCount);
|
out.writeLong(ds.failureTime);
|
}
|
out.writeInt(STATISTICS_FILE_END);
|
fos.write(out.marshall());
|
out.recycle();
|
|
mStatisticsFile.finishWrite(fos);
|
} catch (java.io.IOException e1) {
|
Slog.w(TAG, "Error writing stats", e1);
|
if (fos != null) {
|
mStatisticsFile.failWrite(fos);
|
}
|
}
|
}
|
|
/**
|
* Let the BackupManager know that account sync settings have changed. This will trigger
|
* {@link com.android.server.backup.SystemBackupAgent} to run.
|
*/
|
public void queueBackup() {
|
BackupManager.dataChanged("android");
|
}
|
|
public void setClockValid() {
|
if (!mIsClockValid) {
|
mIsClockValid = true;
|
Slog.w(TAG, "Clock is valid now.");
|
}
|
}
|
|
public boolean isClockValid() {
|
return mIsClockValid;
|
}
|
|
public void resetTodayStats(boolean force) {
|
if (force) {
|
Log.w(TAG, "Force resetting today stats.");
|
}
|
synchronized (mAuthorities) {
|
final int N = mSyncStatus.size();
|
for (int i = 0; i < N; i++) {
|
SyncStatusInfo cur = mSyncStatus.valueAt(i);
|
cur.maybeResetTodayStats(isClockValid(), force);
|
}
|
writeStatusLocked();
|
}
|
}
|
}
|
