| /* |
| * 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.content.pm.PackageManager; |
| import android.content.SyncAdapterType; |
| import android.content.SyncAdaptersCache; |
| import android.content.pm.RegisteredServicesCache.ServiceInfo; |
| import android.os.Bundle; |
| import android.os.SystemClock; |
| import android.text.format.DateUtils; |
| import android.util.Log; |
| import android.util.Pair; |
| |
| import com.google.android.collect.Maps; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| |
| /** |
| * Queue of pending sync operations. Not inherently thread safe, external |
| * callers are responsible for locking. |
| * |
| * @hide |
| */ |
| public class SyncQueue { |
| private static final String TAG = "SyncManager"; |
| private final SyncStorageEngine mSyncStorageEngine; |
| private final SyncAdaptersCache mSyncAdapters; |
| private final PackageManager mPackageManager; |
| |
| // A Map of SyncOperations operationKey -> SyncOperation that is designed for |
| // quick lookup of an enqueued SyncOperation. |
| private final HashMap<String, SyncOperation> mOperationsMap = Maps.newHashMap(); |
| |
| public SyncQueue(PackageManager packageManager, SyncStorageEngine syncStorageEngine, |
| final SyncAdaptersCache syncAdapters) { |
| mPackageManager = packageManager; |
| mSyncStorageEngine = syncStorageEngine; |
| mSyncAdapters = syncAdapters; |
| } |
| |
| public void addPendingOperations(int userId) { |
| for (SyncStorageEngine.PendingOperation op : mSyncStorageEngine.getPendingOperations()) { |
| final SyncStorageEngine.EndPoint info = op.target; |
| if (info.userId != userId) continue; |
| |
| final Pair<Long, Long> backoff = mSyncStorageEngine.getBackoff(info); |
| SyncOperation operationToAdd; |
| if (info.target_provider) { |
| final ServiceInfo<SyncAdapterType> syncAdapterInfo = mSyncAdapters.getServiceInfo( |
| SyncAdapterType.newKey(info.provider, info.account.type), info.userId); |
| if (syncAdapterInfo == null) { |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, "Missing sync adapter info for authority " + op.target); |
| } |
| continue; |
| } |
| operationToAdd = new SyncOperation( |
| info.account, info.userId, op.reason, op.syncSource, info.provider, |
| op.extras, |
| op.expedited ? -1 : 0 /* delay */, |
| 0 /* flex */, |
| backoff != null ? backoff.first : 0L, |
| mSyncStorageEngine.getDelayUntilTime(info), |
| syncAdapterInfo.type.allowParallelSyncs()); |
| operationToAdd.pendingOperation = op; |
| add(operationToAdd, op); |
| } else if (info.target_service) { |
| try { |
| mPackageManager.getServiceInfo(info.service, 0); |
| } catch (PackageManager.NameNotFoundException e) { |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.w(TAG, "Missing sync service for authority " + op.target); |
| } |
| continue; |
| } |
| operationToAdd = new SyncOperation( |
| info.service, info.userId, op.reason, op.syncSource, |
| op.extras, |
| op.expedited ? -1 : 0 /* delay */, |
| 0 /* flex */, |
| backoff != null ? backoff.first : 0, |
| mSyncStorageEngine.getDelayUntilTime(info)); |
| operationToAdd.pendingOperation = op; |
| add(operationToAdd, op); |
| } |
| } |
| } |
| |
| public boolean add(SyncOperation operation) { |
| return add(operation, null /* this is not coming from the database */); |
| } |
| |
| /** |
| * Adds a SyncOperation to the queue and creates a PendingOperation object to track that sync. |
| * If an operation is added that already exists, the existing operation is updated if the newly |
| * added operation occurs before (or the interval overlaps). |
| */ |
| private boolean add(SyncOperation operation, |
| SyncStorageEngine.PendingOperation pop) { |
| // If an operation with the same key exists and this one should run sooner/overlaps, |
| // replace the run interval of the existing operation with this new one. |
| // Complications: what if the existing operation is expedited but the new operation has an |
| // earlier run time? Will not be a problem for periodic syncs (no expedited flag), and for |
| // one-off syncs we only change it if the new sync is sooner. |
| final String operationKey = operation.key; |
| final SyncOperation existingOperation = mOperationsMap.get(operationKey); |
| |
| if (existingOperation != null) { |
| boolean changed = false; |
| if (operation.compareTo(existingOperation) <= 0 ) { |
| long newRunTime = |
| Math.min(existingOperation.latestRunTime, operation.latestRunTime); |
| // Take smaller runtime. |
| existingOperation.latestRunTime = newRunTime; |
| // Take newer flextime. |
| existingOperation.flexTime = operation.flexTime; |
| changed = true; |
| } |
| return changed; |
| } |
| |
| operation.pendingOperation = pop; |
| // Don't update the PendingOp if one already exists. This really is just a placeholder, |
| // no actual scheduling info is placed here. |
| if (operation.pendingOperation == null) { |
| pop = mSyncStorageEngine.insertIntoPending(operation); |
| if (pop == null) { |
| throw new IllegalStateException("error adding pending sync operation " |
| + operation); |
| } |
| operation.pendingOperation = pop; |
| } |
| |
| mOperationsMap.put(operationKey, operation); |
| return true; |
| } |
| |
| public void removeUserLocked(int userId) { |
| ArrayList<SyncOperation> opsToRemove = new ArrayList<SyncOperation>(); |
| for (SyncOperation op : mOperationsMap.values()) { |
| if (op.target.userId == userId) { |
| opsToRemove.add(op); |
| } |
| } |
| for (SyncOperation op : opsToRemove) { |
| remove(op); |
| } |
| } |
| |
| /** |
| * Remove the specified operation if it is in the queue. |
| * @param operation the operation to remove |
| */ |
| public void remove(SyncOperation operation) { |
| boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE); |
| SyncOperation operationToRemove = mOperationsMap.remove(operation.key); |
| if (isLoggable) { |
| Log.v(TAG, "Attempting to remove: " + operation.key); |
| } |
| if (operationToRemove == null) { |
| if (isLoggable) { |
| Log.v(TAG, "Could not find: " + operation.key); |
| } |
| return; |
| } |
| if (!mSyncStorageEngine.deleteFromPending(operationToRemove.pendingOperation)) { |
| final String errorMessage = "unable to find pending row for " + operationToRemove; |
| Log.e(TAG, errorMessage, new IllegalStateException(errorMessage)); |
| } |
| } |
| |
| /** Reset backoffs for all operations in the queue. */ |
| public void clearBackoffs() { |
| for (SyncOperation op : mOperationsMap.values()) { |
| op.backoff = 0L; |
| op.updateEffectiveRunTime(); |
| } |
| } |
| |
| public void onBackoffChanged(SyncStorageEngine.EndPoint target, long backoff) { |
| // For each op that matches the target of the changed op, update its |
| // backoff and effectiveStartTime |
| for (SyncOperation op : mOperationsMap.values()) { |
| if (op.target.matchesSpec(target)) { |
| op.backoff = backoff; |
| op.updateEffectiveRunTime(); |
| } |
| } |
| } |
| |
| public void onDelayUntilTimeChanged(SyncStorageEngine.EndPoint target, long delayUntil) { |
| // for each op that matches the target info of the provided op, change the delay time. |
| for (SyncOperation op : mOperationsMap.values()) { |
| if (op.target.matchesSpec(target)) { |
| op.delayUntil = delayUntil; |
| op.updateEffectiveRunTime(); |
| } |
| } |
| } |
| |
| /** |
| * Remove all of the SyncOperations associated with a given target. |
| * |
| * @param info target object provided here can have null Account/provider. This is the case |
| * where you want to remove all ops associated with a provider (null Account) or all ops |
| * associated with an account (null provider). |
| * @param extras option bundle to include to further specify which operation to remove. If this |
| * bundle contains sync settings flags, they are ignored. |
| */ |
| public void remove(final SyncStorageEngine.EndPoint info, Bundle extras) { |
| Iterator<Map.Entry<String, SyncOperation>> entries = mOperationsMap.entrySet().iterator(); |
| while (entries.hasNext()) { |
| Map.Entry<String, SyncOperation> entry = entries.next(); |
| SyncOperation syncOperation = entry.getValue(); |
| final SyncStorageEngine.EndPoint opInfo = syncOperation.target; |
| if (!opInfo.matchesSpec(info)) { |
| continue; |
| } |
| if (extras != null |
| && !SyncManager.syncExtrasEquals( |
| syncOperation.extras, |
| extras, |
| false /* no config flags*/)) { |
| continue; |
| } |
| entries.remove(); |
| if (!mSyncStorageEngine.deleteFromPending(syncOperation.pendingOperation)) { |
| final String errorMessage = "unable to find pending row for " + syncOperation; |
| Log.e(TAG, errorMessage, new IllegalStateException(errorMessage)); |
| } |
| } |
| } |
| |
| public Collection<SyncOperation> getOperations() { |
| return mOperationsMap.values(); |
| } |
| |
| public void dump(StringBuilder sb) { |
| final long now = SystemClock.elapsedRealtime(); |
| sb.append("SyncQueue: ").append(mOperationsMap.size()).append(" operation(s)\n"); |
| for (SyncOperation operation : mOperationsMap.values()) { |
| sb.append(" "); |
| if (operation.effectiveRunTime <= now) { |
| sb.append("READY"); |
| } else { |
| sb.append(DateUtils.formatElapsedTime((operation.effectiveRunTime - now) / 1000)); |
| } |
| sb.append(" - "); |
| sb.append(operation.dump(mPackageManager, false)).append("\n"); |
| } |
| } |
| } |