| /* |
| * 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 android.content; |
| |
| import android.os.SystemClock; |
| import com.google.android.collect.Maps; |
| |
| import android.util.Pair; |
| import android.util.Log; |
| import android.accounts.Account; |
| |
| import java.util.HashMap; |
| import java.util.ArrayList; |
| import java.util.Map; |
| import java.util.Iterator; |
| |
| /** |
| * |
| * @hide |
| */ |
| public class SyncQueue { |
| private static final String TAG = "SyncManager"; |
| private SyncStorageEngine mSyncStorageEngine; |
| |
| // 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(SyncStorageEngine syncStorageEngine) { |
| mSyncStorageEngine = syncStorageEngine; |
| ArrayList<SyncStorageEngine.PendingOperation> ops |
| = mSyncStorageEngine.getPendingOperations(); |
| final int N = ops.size(); |
| for (int i=0; i<N; i++) { |
| SyncStorageEngine.PendingOperation op = ops.get(i); |
| SyncOperation syncOperation = new SyncOperation( |
| op.account, op.syncSource, op.authority, op.extras, 0 /* delay */); |
| syncOperation.expedited = op.expedited; |
| syncOperation.pendingOperation = op; |
| add(syncOperation, op); |
| } |
| } |
| |
| public boolean add(SyncOperation operation) { |
| return add(operation, null /* this is not coming from the database */); |
| } |
| |
| private boolean add(SyncOperation operation, |
| SyncStorageEngine.PendingOperation pop) { |
| // - if an operation with the same key exists and this one should run earlier, |
| // update the earliestRunTime of the existing to the new time |
| // - if an operation with the same key exists and if this one should run |
| // later, ignore it |
| // - if no operation exists then add the new one |
| final String operationKey = operation.key; |
| final SyncOperation existingOperation = mOperationsMap.get(operationKey); |
| |
| if (existingOperation != null) { |
| boolean changed = false; |
| if (existingOperation.expedited == operation.expedited) { |
| final long newRunTime = |
| Math.min(existingOperation.earliestRunTime, operation.earliestRunTime); |
| if (existingOperation.earliestRunTime != newRunTime) { |
| existingOperation.earliestRunTime = newRunTime; |
| changed = true; |
| } |
| } else { |
| if (operation.expedited) { |
| existingOperation.expedited = true; |
| changed = true; |
| } |
| } |
| return changed; |
| } |
| |
| operation.pendingOperation = pop; |
| if (operation.pendingOperation == null) { |
| pop = new SyncStorageEngine.PendingOperation( |
| operation.account, operation.syncSource, |
| operation.authority, operation.extras, operation.expedited); |
| pop = mSyncStorageEngine.insertIntoPending(pop); |
| if (pop == null) { |
| throw new IllegalStateException("error adding pending sync operation " |
| + operation); |
| } |
| operation.pendingOperation = pop; |
| } |
| |
| mOperationsMap.put(operationKey, operation); |
| return true; |
| } |
| |
| /** |
| * Remove the specified operation if it is in the queue. |
| * @param operation the operation to remove |
| */ |
| public void remove(SyncOperation operation) { |
| SyncOperation operationToRemove = mOperationsMap.remove(operation.key); |
| if (operationToRemove == null) { |
| return; |
| } |
| if (!mSyncStorageEngine.deleteFromPending(operationToRemove.pendingOperation)) { |
| final String errorMessage = "unable to find pending row for " + operationToRemove; |
| Log.e(TAG, errorMessage, new IllegalStateException(errorMessage)); |
| } |
| } |
| |
| /** |
| * Find the operation that should run next. Operations are sorted by their earliestRunTime, |
| * prioritizing first those with a syncable state of "unknown" that aren't retries then |
| * expedited operations. |
| * The earliestRunTime is adjusted by the sync adapter's backoff and delayUntil times, if any. |
| * @return the operation that should run next and when it should run. The time may be in |
| * the future. It is expressed in milliseconds since boot. |
| */ |
| public Pair<SyncOperation, Long> nextOperation() { |
| SyncOperation best = null; |
| long bestRunTime = 0; |
| boolean bestIsInitial = false; |
| for (SyncOperation op : mOperationsMap.values()) { |
| final long opRunTime = getOpTime(op); |
| final boolean opIsInitial = getIsInitial(op); |
| if (isOpBetter(best, bestRunTime, bestIsInitial, op, opRunTime, opIsInitial)) { |
| best = op; |
| bestIsInitial = opIsInitial; |
| bestRunTime = opRunTime; |
| } |
| } |
| if (best == null) { |
| return null; |
| } |
| return Pair.create(best, bestRunTime); |
| } |
| |
| // VisibleForTesting |
| long getOpTime(SyncOperation op) { |
| long opRunTime = op.earliestRunTime; |
| if (!op.extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, false)) { |
| Pair<Long, Long> backoff = mSyncStorageEngine.getBackoff(op.account, op.authority); |
| long delayUntil = mSyncStorageEngine.getDelayUntilTime(op.account, op.authority); |
| opRunTime = Math.max( |
| Math.max(opRunTime, delayUntil), |
| backoff != null ? backoff.first : 0); |
| } |
| return opRunTime; |
| } |
| |
| // VisibleForTesting |
| boolean getIsInitial(SyncOperation op) { |
| // Initial op is defined as an op with an unknown syncable that is not a retry. |
| // We know a sync is a retry if the intialization flag is set, since that will only |
| // be set by the sync dispatching code, thus if it is set it must have already been |
| // dispatched |
| return !op.extras.getBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, false) |
| && mSyncStorageEngine.getIsSyncable(op.account, op.authority) < 0; |
| } |
| |
| // return true if op is a better candidate than best. Rules: |
| // if the "Initial" state differs, make the current the best if it is "Initial". |
| // else, if the expedited state differs, pick the expedited unless it is backed off and the |
| // non-expedited isn't |
| // VisibleForTesting |
| boolean isOpBetter( |
| SyncOperation best, long bestRunTime, boolean bestIsInitial, |
| SyncOperation op, long opRunTime, boolean opIsInitial) { |
| boolean setBest = false; |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, "nextOperation: Processing op: " + op); |
| } |
| if (best == null) { |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, " First op selected"); |
| } |
| setBest = true; |
| } else if (bestIsInitial == opIsInitial) { |
| if (best.expedited == op.expedited) { |
| if (opRunTime < bestRunTime) { |
| // if both have same level, earlier time wins |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, " Same expedite level - new op selected"); |
| } |
| setBest = true; |
| } |
| } else { |
| final long now = SystemClock.elapsedRealtime(); |
| if (op.expedited) { |
| if (opRunTime <= now || bestRunTime > now) { |
| // if op is expedited, it wins unless op can't run yet and best can |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, " New op is expedited and can run - new op selected"); |
| } |
| setBest = true; |
| } else { |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, " New op is expedited but can't run and best can"); |
| } |
| } |
| } else { |
| if (bestRunTime > now && opRunTime <= now) { |
| // if best is expedited but can't run yet and op can run, op wins |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, |
| " New op is not expedited but can run - new op selected"); |
| } |
| setBest = true; |
| } |
| } |
| } |
| } else { |
| if (opIsInitial) { |
| if (Log.isLoggable(TAG, Log.VERBOSE)) { |
| Log.v(TAG, " New op is init - new op selected"); |
| } |
| setBest = true; |
| } |
| } |
| return setBest; |
| } |
| |
| /** |
| * Find and return the SyncOperation that should be run next and is ready to run. |
| * @param now the current {@link android.os.SystemClock#elapsedRealtime()}, used to |
| * decide if the sync operation is ready to run |
| * @return the SyncOperation that should be run next and is ready to run. |
| */ |
| public Pair<SyncOperation, Long> nextReadyToRun(long now) { |
| Pair<SyncOperation, Long> nextOpAndRunTime = nextOperation(); |
| if (nextOpAndRunTime == null || nextOpAndRunTime.second > now) { |
| return null; |
| } |
| return nextOpAndRunTime; |
| } |
| |
| public void remove(Account account, String authority) { |
| Iterator<Map.Entry<String, SyncOperation>> entries = mOperationsMap.entrySet().iterator(); |
| while (entries.hasNext()) { |
| Map.Entry<String, SyncOperation> entry = entries.next(); |
| SyncOperation syncOperation = entry.getValue(); |
| if (account != null && !syncOperation.account.equals(account)) { |
| continue; |
| } |
| if (authority != null && !syncOperation.authority.equals(authority)) { |
| 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 void dump(StringBuilder sb) { |
| sb.append("SyncQueue: ").append(mOperationsMap.size()).append(" operation(s)\n"); |
| for (SyncOperation operation : mOperationsMap.values()) { |
| sb.append(operation).append("\n"); |
| } |
| } |
| } |