services/core/java/com/android/server/content/SyncQueue.java - platform/frameworks/base - Git at Google

 /*
  * 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");
         }
     }
 }
	/*
	* 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");
	}
	}
	}