274 lines
11 KiB
Java
274 lines
11 KiB
Java
|
/*
|
||
|
|
* 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");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|