1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
package android.content;
import com.google.android.collect.Maps;
import android.os.Bundle;
import android.os.SystemClock;
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);
// -1 is a special value that means expedited
final int delay = op.expedited ? -1 : 0;
SyncOperation syncOperation = new SyncOperation(
op.account, op.syncSource, op.authority, op.extras, delay);
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;
}
public void remove(SyncOperation operation) {
SyncOperation operationToRemove = mOperationsMap.remove(operation.key);
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 expedited operations. The earliestRunTime is adjusted by the sync adapter's
* backoff and delayUntil times, if any.
* @param now the current {@link android.os.SystemClock#elapsedRealtime()}
* @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.
*/
private Pair<SyncOperation, Long> nextOperation(long now) {
SyncOperation lowestOp = null;
long lowestOpRunTime = 0;
for (SyncOperation op : mOperationsMap.values()) {
// effectiveRunTime:
// - backoffTime > currentTime : backoffTime
// - backoffTime <= currentTime : op.runTime
Pair<Long, Long> backoff = null;
long delayUntilTime = 0;
final boolean isManualSync =
op.extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false);
if (!isManualSync) {
backoff = mSyncStorageEngine.getBackoff(op.account, op.authority);
delayUntilTime = mSyncStorageEngine.getDelayUntilTime(op.account, op.authority);
}
long backoffTime = Math.max(backoff != null ? backoff.first : 0, delayUntilTime);
long opRunTime = backoffTime > now ? backoffTime : op.earliestRunTime;
if (lowestOp == null
|| (lowestOp.expedited == op.expedited
? opRunTime < lowestOpRunTime
: op.expedited)) {
lowestOp = op;
lowestOpRunTime = opRunTime;
}
}
if (lowestOp == null) {
return null;
}
return Pair.create(lowestOp, lowestOpRunTime);
}
/**
* Return when the next SyncOperation will be ready to run or null if there are
* none.
* @param now the current {@link android.os.SystemClock#elapsedRealtime()}, used to
* decide if the sync operation is ready to run
* @return when the next SyncOperation will be ready to run, expressed in elapsedRealtime()
*/
public Long nextRunTime(long now) {
Pair<SyncOperation, Long> nextOpAndRunTime = nextOperation(now);
if (nextOpAndRunTime == null) {
return null;
}
return nextOpAndRunTime.second;
}
/**
* 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 SyncOperation nextReadyToRun(long now) {
Pair<SyncOperation, Long> nextOpAndRunTime = nextOperation(now);
if (nextOpAndRunTime == null || nextOpAndRunTime.second > now) {
return null;
}
return nextOpAndRunTime.first;
}
public void clear(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");
}
}
}
|
