Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Add persistence of tasks for TaskManager & BatteryController" into lmp-preview-dev

Browse Source
This commit is contained in:
Matthew Williams
2014-06-05 19:15:25 +00:00
committed by Android (Google) Code Review
parent 71f507bbe9 3d86fd2bb9
commit afcece8115
13 changed files with 1138 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
api/current.txt
View File

@@ -5362,7 +5362,7 @@ package android.app.task {
public class Task implements android.os.Parcelable {
method public int describeContents();
method public int getBackoffPolicy();
method public android.os.Bundle getExtras();
method public android.os.PersistableBundle getExtras();
method public int getId();
method public long getInitialBackoffMillis();
method public long getIntervalMillis();
@@ -5386,7 +5386,7 @@ package android.app.task {
ctor public Task.Builder(int, android.content.ComponentName);
method public android.app.task.Task build();
method public android.app.task.Task.Builder setBackoffCriteria(long, int);
method public android.app.task.Task.Builder setExtras(android.os.Bundle);
method public android.app.task.Task.Builder setExtras(android.os.PersistableBundle);
method public android.app.task.Task.Builder setMinimumLatency(long);
method public android.app.task.Task.Builder setOverrideDeadline(long);
method public android.app.task.Task.Builder setPeriodic(long);
@@ -5413,7 +5413,7 @@ package android.app.task {
public class TaskParams implements android.os.Parcelable {
method public int describeContents();
method public android.os.Bundle getExtras();
method public android.os.PersistableBundle getExtras();
method public int getTaskId();
method public void writeToParcel(android.os.Parcel, int);
field public static final android.os.Parcelable.Creator CREATOR;

46
core/java/android/app/task/Task.java
View File

@@ -20,6 +20,7 @@ import android.content.ComponentName;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.PersistableBundle;
/**
* Container of data passed to the {@link android.app.task.TaskManager} fully encapsulating the
@@ -36,6 +37,18 @@ public class Task implements Parcelable {
public final int UNMETERED = 2;
}
/**
* Amount of backoff a task has initially by default, in milliseconds.
* @hide.
*/
public static final long DEFAULT_INITIAL_BACKOFF_MILLIS = 5000L;
/**
* Default type of backoff.
* @hide
*/
public static final int DEFAULT_BACKOFF_POLICY = BackoffPolicy.EXPONENTIAL;
/**
* Linear: retry_time(failure_time, t) = failure_time + initial_retry_delay * t, t >= 1
* Expon: retry_time(failure_time, t) = failure_time + initial_retry_delay ^ t, t >= 1
@@ -47,7 +60,7 @@ public class Task implements Parcelable {
private final int taskId;
// TODO: Change this to use PersistableBundle when that lands in master.
private final Bundle extras;
private final PersistableBundle extras;
private final ComponentName service;
private final boolean requireCharging;
private final boolean requireDeviceIdle;
@@ -71,7 +84,7 @@ public class Task implements Parcelable {
/**
* Bundle of extras which are returned to your application at execution time.
*/
public Bundle getExtras() {
public PersistableBundle getExtras() {
return extras;
}
@@ -171,7 +184,7 @@ public class Task implements Parcelable {
private Task(Parcel in) {
taskId = in.readInt();
extras = in.readBundle();
extras = in.readPersistableBundle();
service = ComponentName.readFromParcel(in);
requireCharging = in.readInt() == 1;
requireDeviceIdle = in.readInt() == 1;
@@ -188,7 +201,7 @@ public class Task implements Parcelable {
private Task(Task.Builder b) {
taskId = b.mTaskId;
extras = new Bundle(b.mExtras);
extras = new PersistableBundle(b.mExtras);
service = b.mTaskService;
requireCharging = b.mRequiresCharging;
requireDeviceIdle = b.mRequiresDeviceIdle;
@@ -211,7 +224,7 @@ public class Task implements Parcelable {
@Override
public void writeToParcel(Parcel out, int flags) {
out.writeInt(taskId);
out.writeBundle(extras);
out.writePersistableBundle(extras);
ComponentName.writeToParcel(service, out);
out.writeInt(requireCharging ? 1 : 0);
out.writeInt(requireDeviceIdle ? 1 : 0);
@@ -238,12 +251,10 @@ public class Task implements Parcelable {
}
};
/**
* Builder class for constructing {@link Task} objects.
*/
/** Builder class for constructing {@link Task} objects. */
public static final class Builder {
private int mTaskId;
private Bundle mExtras;
private PersistableBundle mExtras = PersistableBundle.EMPTY;
private ComponentName mTaskService;
// Requirements.
private boolean mRequiresCharging;
@@ -258,8 +269,8 @@ public class Task implements Parcelable {
private boolean mHasLateConstraint;
private long mIntervalMillis;
// Back-off parameters.
private long mInitialBackoffMillis = 5000L;
private int mBackoffPolicy = BackoffPolicy.EXPONENTIAL;
private long mInitialBackoffMillis = DEFAULT_INITIAL_BACKOFF_MILLIS;
private int mBackoffPolicy = DEFAULT_BACKOFF_POLICY;
/** Easy way to track whether the client has tried to set a back-off policy. */
private boolean mBackoffPolicySet = false;
@@ -279,7 +290,7 @@ public class Task implements Parcelable {
* Set optional extras. This is persisted, so we only allow primitive types.
* @param extras Bundle containing extras you want the scheduler to hold on to for you.
*/
public Builder setExtras(Bundle extras) {
public Builder setExtras(PersistableBundle extras) {
mExtras = extras;
return this;
}
@@ -394,18 +405,13 @@ public class Task implements Parcelable {
* @return The task object to hand to the TaskManager. This object is immutable.
*/
public Task build() {
if (mExtras == null) {
mExtras = Bundle.EMPTY;
}
if (mTaskId < 0) {
throw new IllegalArgumentException("Task id must be greater than 0.");
}
mExtras = new PersistableBundle(mExtras); // Make our own copy.
// Check that a deadline was not set on a periodic task.
if (mIsPeriodic && mHasLateConstraint) {
if (mIsPeriodic && (mMaxExecutionDelayMillis != 0L)) {
throw new IllegalArgumentException("Can't call setOverrideDeadline() on a " +
"periodic task.");
}
if (mIsPeriodic && mHasEarlyConstraint) {
if (mIsPeriodic && (mMinLatencyMillis != 0L)) {
throw new IllegalArgumentException("Can't call setMinimumLatency() on a " +
"periodic task");
}

14
core/java/android/app/task/TaskParams.java
View File

@@ -16,10 +16,10 @@
package android.app.task;
import android.os.Bundle;
import android.os.IBinder;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.PersistableBundle;
/**
* Contains the parameters used to configure/identify your task. You do not create this object
@@ -28,11 +28,11 @@ import android.os.Parcelable;
public class TaskParams implements Parcelable {
private final int taskId;
private final Bundle extras;
private final PersistableBundle extras;
private final IBinder callback;
/** @hide */
public TaskParams(int taskId, Bundle extras, IBinder callback) {
public TaskParams(int taskId, PersistableBundle extras, IBinder callback) {
this.taskId = taskId;
this.extras = extras;
this.callback = callback;
@@ -47,10 +47,10 @@ public class TaskParams implements Parcelable {
/**
* @return The extras you passed in when constructing this task with
* {@link android.app.task.Task.Builder#setExtras(android.os.Bundle)}. This will
* {@link android.app.task.Task.Builder#setExtras(android.os.PersistableBundle)}. This will
* never be null. If you did not set any extras this will be an empty bundle.
*/
public Bundle getExtras() {
public PersistableBundle getExtras() {
return extras;
}
@@ -61,7 +61,7 @@ public class TaskParams implements Parcelable {
private TaskParams(Parcel in) {
taskId = in.readInt();
extras = in.readBundle();
extras = in.readPersistableBundle();
callback = in.readStrongBinder();
}
@@ -73,7 +73,7 @@ public class TaskParams implements Parcelable {
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(taskId);
dest.writeBundle(extras);
dest.writePersistableBundle(extras);
dest.writeStrongBinder(callback);
}

56
services/core/java/com/android/server/task/TaskManagerService.java
View File

@@ -36,6 +36,7 @@ import android.os.SystemClock;
import android.util.Slog;
import android.util.SparseArray;
import com.android.server.task.controllers.BatteryController;
import com.android.server.task.controllers.ConnectivityController;
import com.android.server.task.controllers.IdleController;
import com.android.server.task.controllers.StateController;
@@ -48,12 +49,19 @@ import java.util.LinkedList;
* Responsible for taking tasks representing work to be performed by a client app, and determining
* based on the criteria specified when that task should be run against the client application's
* endpoint.
* Implements logic for scheduling, and rescheduling tasks. The TaskManagerService knows nothing
* about constraints, or the state of active tasks. It receives callbacks from the various
* controllers and completed tasks and operates accordingly.
*
* Note on locking: Any operations that manipulate {@link #mTasks} need to lock on that object, and
* similarly for {@link #mActiveServices}. If both locks need to be held take mTasksSet first and then
* mActiveService afterwards.
* @hide
*/
public class TaskManagerService extends com.android.server.SystemService
implements StateChangedListener, TaskCompletedListener {
implements StateChangedListener, TaskCompletedListener, TaskMapReadFinishedListener {
// TODO: Switch this off for final version.
private static final boolean DEBUG = true;
static final boolean DEBUG = true;
/** The number of concurrent tasks we run at one time. */
private static final int MAX_TASK_CONTEXTS_COUNT = 3;
static final String TAG = "TaskManager";
@@ -113,8 +121,8 @@ public class TaskManagerService extends com.android.server.SystemService
*/
public int schedule(Task task, int uId, boolean canPersistTask) {
TaskStatus taskStatus = new TaskStatus(task, uId, canPersistTask);
return startTrackingTask(taskStatus) ?
TaskManager.RESULT_SUCCESS : TaskManager.RESULT_FAILURE;
startTrackingTask(taskStatus);
return TaskManager.RESULT_SUCCESS;
}
public List<Task> getPendingTasks(int uid) {
@@ -210,7 +218,7 @@ public class TaskManagerService extends com.android.server.SystemService
*/
public TaskManagerService(Context context) {
super(context);
mTasks = new TaskStore(context);
mTasks = TaskStore.initAndGet(this);
mHandler = new TaskHandler(context.getMainLooper());
mTaskManagerStub = new TaskManagerStub();
// Create the "runners".
@@ -218,12 +226,12 @@ public class TaskManagerService extends com.android.server.SystemService
mActiveServices.add(
new TaskServiceContext(this, context.getMainLooper()));
}
// Create the controllers.
mControllers = new LinkedList<StateController>();
mControllers.add(ConnectivityController.get(this));
mControllers.add(TimeController.get(this));
mControllers.add(IdleController.get(this));
// TODO: Add BatteryStateController when implemented.
mControllers.add(BatteryController.get(this));
}
@Override
@@ -236,17 +244,14 @@ public class TaskManagerService extends com.android.server.SystemService
* {@link com.android.server.task.TaskStore}, and make sure all the relevant controllers know
* about.
*/
private boolean startTrackingTask(TaskStatus taskStatus) {
boolean added = false;
private void startTrackingTask(TaskStatus taskStatus) {
synchronized (mTasks) {
added = mTasks.add(taskStatus);
mTasks.add(taskStatus);
}
if (added) {
for (StateController controller : mControllers) {
controller.maybeStartTrackingTask(taskStatus);
}
for (StateController controller : mControllers) {
controller.maybeStartTrackingTask(taskStatus);
}
return added;
}
/**
@@ -404,6 +409,27 @@ public class TaskManagerService extends com.android.server.SystemService
mHandler.obtainMessage(MSG_TASK_EXPIRED, taskStatus);
}
/**
* Disk I/O is finished, take the list of tasks we read from disk and add them to our
* {@link TaskStore}.
* This is run on the {@link com.android.server.IoThread} instance, which is a separate thread,
* and is called once at boot.
*/
@Override
public void onTaskMapReadFinished(List<TaskStatus> tasks) {
synchronized (mTasks) {
for (TaskStatus ts : tasks) {
if (mTasks.contains(ts)) {
// An app with BOOT_COMPLETED *might* have decided to reschedule their task, in
// the same amount of time it took us to read it from disk. If this is the case
// we leave it be.
continue;
}
startTrackingTask(ts);
}
}
}
private class TaskHandler extends Handler {
public TaskHandler(Looper looper) {

574
services/core/java/com/android/server/task/TaskStore.java
View File

@@ -16,17 +16,37 @@
package com.android.server.task;
import android.content.ComponentName;
import android.app.task.Task;
import android.content.Context;
import android.os.Environment;
import android.os.Handler;
import android.os.PersistableBundle;
import android.os.SystemClock;
import android.util.AtomicFile;
import android.util.ArraySet;
import android.util.Pair;
import android.util.Slog;
import android.util.SparseArray;
import android.util.Xml;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.FastXmlSerializer;
import com.android.server.IoThread;
import com.android.server.task.controllers.TaskStatus;
import java.util.HashSet;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.List;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;
/**
* Maintain a list of classes, and accessor methods/logic for these tasks.
@@ -38,57 +58,108 @@ import java.util.Set;
* - Handles rescheduling of tasks.
* - When a periodic task is executed and must be re-added.
* - When a task fails and the client requests that it be retried with backoff.
* - This class is <strong>not</strong> thread-safe.
* - This class <strong>is not</strong> thread-safe.
*
* Note on locking:
* All callers to this class must <strong>lock on the class object they are calling</strong>.
* This is important b/c {@link com.android.server.task.TaskStore.WriteTasksMapToDiskRunnable}
* and {@link com.android.server.task.TaskStore.ReadTaskMapFromDiskRunnable} lock on that
* object.
*/
public class TaskStore {
private static final String TAG = "TaskManagerStore";
private static final boolean DEBUG = TaskManagerService.DEBUG;
/** Threshold to adjust how often we want to write to the db. */
private static final int MAX_OPS_BEFORE_WRITE = 1;
final ArraySet<TaskStatus> mTasks;
final ArraySet<TaskStatus> mTasksSet;
final Context mContext;
private int mDirtyOperations;
TaskStore(Context context) {
mTasks = intialiseTasksFromDisk();
private static final Object sSingletonLock = new Object();
private final AtomicFile mTasksFile;
/** Handler backed by IoThread for writing to disk. */
private final Handler mIoHandler = IoThread.getHandler();
private static TaskStore sSingleton;
/** Used by the {@Link TaskManagerService} to instantiate the TaskStore. */
static TaskStore initAndGet(TaskManagerService taskManagerService) {
synchronized (sSingletonLock) {
if (sSingleton == null) {
sSingleton = new TaskStore(taskManagerService.getContext(),
Environment.getDataDirectory(), taskManagerService);
}
return sSingleton;
}
}
@VisibleForTesting
public static TaskStore initAndGetForTesting(Context context, File dataDir,
TaskMapReadFinishedListener callback) {
return new TaskStore(context, dataDir, callback);
}
private TaskStore(Context context, File dataDir, TaskMapReadFinishedListener callback) {
mContext = context;
mDirtyOperations = 0;
File systemDir = new File(dataDir, "system");
File taskDir = new File(systemDir, "task");
taskDir.mkdirs();
mTasksFile = new AtomicFile(new File(taskDir, "tasks.xml"));
mTasksSet = new ArraySet<TaskStatus>();
readTaskMapFromDiskAsync(callback);
}
/**
* Add a task to the master list, persisting it if necessary. If the TaskStatus already exists,
* it will be replaced.
* @param taskStatus Task to add.
* @return true if the operation succeeded.
* @return Whether or not an equivalent TaskStatus was replaced by this operation.
*/
public boolean add(TaskStatus taskStatus) {
boolean replaced = mTasksSet.remove(taskStatus);
mTasksSet.add(taskStatus);
if (taskStatus.isPersisted()) {
if (!maybeWriteStatusToDisk()) {
return false;
}
maybeWriteStatusToDiskAsync();
}
mTasks.remove(taskStatus);
mTasks.add(taskStatus);
return true;
return replaced;
}
/**
* Whether this taskStatus object already exists in the TaskStore.
*/
public boolean contains(TaskStatus taskStatus) {
return mTasksSet.contains(taskStatus);
}
public int size() {
return mTasks.size();
return mTasksSet.size();
}
/**
* Remove the provided task. Will also delete the task if it was persisted.
* @return The TaskStatus that was removed, or null if an invalid token was provided.
* @return Whether or not the task existed to be removed.
*/
public boolean remove(TaskStatus taskStatus) {
boolean removed = mTasks.remove(taskStatus);
boolean removed = mTasksSet.remove(taskStatus);
if (!removed) {
Slog.e(TAG, "Error removing task: " + taskStatus);
if (DEBUG) {
Slog.d(TAG, "Couldn't remove task: didn't exist: " + taskStatus);
}
return false;
} else {
maybeWriteStatusToDisk();
}
return true;
maybeWriteStatusToDiskAsync();
return removed;
}
@VisibleForTesting
public void clear() {
mTasksSet.clear();
maybeWriteStatusToDiskAsync();
}
/**
@@ -100,19 +171,16 @@ public class TaskStore {
* was found.
*/
public boolean removeAllByUid(int uid) {
Iterator<TaskStatus> it = mTasks.iterator();
boolean removed = false;
Iterator<TaskStatus> it = mTasksSet.iterator();
while (it.hasNext()) {
TaskStatus ts = it.next();
if (ts.getUid() == uid) {
it.remove();
removed = true;
maybeWriteStatusToDiskAsync();
return true;
}
}
if (removed) {
maybeWriteStatusToDisk();
}
return removed;
return false;
}
/**
@@ -124,48 +192,464 @@ public class TaskStore {
* @return true if a removal occurred, false if the provided parameters didn't match anything.
*/
public boolean remove(int uid, int taskId) {
Iterator<TaskStatus> it = mTasks.iterator();
boolean changed = false;
Iterator<TaskStatus> it = mTasksSet.iterator();
while (it.hasNext()) {
TaskStatus ts = it.next();
if (ts.getUid() == uid && ts.getTaskId() == taskId) {
it.remove();
maybeWriteStatusToDisk();
return true;
changed = true;
}
}
return false;
if (changed) {
maybeWriteStatusToDiskAsync();
}
return changed;
}
/**
* @return The live array of TaskStatus objects.
*/
public Set<TaskStatus> getTasks() {
return mTasks;
public ArraySet<TaskStatus> getTasks() {
return mTasksSet;
}
/** Version of the db schema. */
private static final int TASKS_FILE_VERSION = 0;
/** Tag corresponds to constraints this task needs. */
private static final String XML_TAG_PARAMS_CONSTRAINTS = "constraints";
/** Tag corresponds to execution parameters. */
private static final String XML_TAG_PERIODIC = "periodic";
private static final String XML_TAG_ONEOFF = "one-off";
private static final String XML_TAG_EXTRAS = "extras";
/**
* Every time the state changes we write all the tasks in one swathe, instead of trying to
* track incremental changes.
* @return Whether the operation was successful. This will only fail for e.g. if the system is
* low on storage. If this happens, we continue as normal
*/
private boolean maybeWriteStatusToDisk() {
private void maybeWriteStatusToDiskAsync() {
mDirtyOperations++;
if (mDirtyOperations > MAX_OPS_BEFORE_WRITE) {
for (TaskStatus ts : mTasks) {
//
if (mDirtyOperations >= MAX_OPS_BEFORE_WRITE) {
if (DEBUG) {
Slog.v(TAG, "Writing tasks to disk.");
}
mDirtyOperations = 0;
mIoHandler.post(new WriteTasksMapToDiskRunnable());
}
return true;
}
private void readTaskMapFromDiskAsync(TaskMapReadFinishedListener callback) {
mIoHandler.post(new ReadTaskMapFromDiskRunnable(callback));
}
public void readTaskMapFromDisk(TaskMapReadFinishedListener callback) {
new ReadTaskMapFromDiskRunnable(callback).run();
}
/**
*
* @return
* Runnable that writes {@link #mTasksSet} out to xml.
* NOTE: This Runnable locks on TaskStore.this
*/
// TODO: Implement this.
private ArraySet<TaskStatus> intialiseTasksFromDisk() {
return new ArraySet<TaskStatus>();
private class WriteTasksMapToDiskRunnable implements Runnable {
@Override
public void run() {
final long startElapsed = SystemClock.elapsedRealtime();
synchronized (TaskStore.this) {
writeTasksMapImpl();
}
if (TaskManagerService.DEBUG) {
Slog.v(TAG, "Finished writing, took " + (SystemClock.elapsedRealtime()
- startElapsed) + "ms");
}
}
private void writeTasksMapImpl() {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
XmlSerializer out = new FastXmlSerializer();
out.setOutput(baos, "utf-8");
out.startDocument(null, true);
out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
out.startTag(null, "task-info");
out.attribute(null, "version", Integer.toString(TASKS_FILE_VERSION));
for (int i = 0; i < mTasksSet.size(); i++) {
final TaskStatus taskStatus = mTasksSet.valueAt(i);
if (DEBUG) {
Slog.d(TAG, "Saving task " + taskStatus.getTaskId());
}
out.startTag(null, "task");
addIdentifierAttributesToTaskTag(out, taskStatus);
writeConstraintsToXml(out, taskStatus);
writeExecutionCriteriaToXml(out, taskStatus);
writeBundleToXml(taskStatus.getExtras(), out);
out.endTag(null, "task");
}
out.endTag(null, "task-info");
out.endDocument();
// Write out to disk in one fell sweep.
FileOutputStream fos = mTasksFile.startWrite();
fos.write(baos.toByteArray());
mTasksFile.finishWrite(fos);
mDirtyOperations = 0;
} catch (IOException e) {
if (DEBUG) {
Slog.v(TAG, "Error writing out task data.", e);
}
} catch (XmlPullParserException e) {
if (DEBUG) {
Slog.d(TAG, "Error persisting bundle.", e);
}
}
}
/** Write out a tag with data comprising the required fields of this task and its client. */
private void addIdentifierAttributesToTaskTag(XmlSerializer out, TaskStatus taskStatus)
throws IOException {
out.attribute(null, "taskid", Integer.toString(taskStatus.getTaskId()));
out.attribute(null, "package", taskStatus.getServiceComponent().getPackageName());
out.attribute(null, "class", taskStatus.getServiceComponent().getClassName());
out.attribute(null, "uid", Integer.toString(taskStatus.getUid()));
}
private void writeBundleToXml(PersistableBundle extras, XmlSerializer out)
throws IOException, XmlPullParserException {
out.startTag(null, XML_TAG_EXTRAS);
extras.saveToXml(out);
out.endTag(null, XML_TAG_EXTRAS);
}
/**
* Write out a tag with data identifying this tasks constraints. If the constraint isn't here
* it doesn't apply.
*/
private void writeConstraintsToXml(XmlSerializer out, TaskStatus taskStatus) throws IOException {
out.startTag(null, XML_TAG_PARAMS_CONSTRAINTS);
if (taskStatus.hasMeteredConstraint()) {
out.attribute(null, "unmetered", Boolean.toString(true));
}
if (taskStatus.hasConnectivityConstraint()) {
out.attribute(null, "connectivity", Boolean.toString(true));
}
if (taskStatus.hasIdleConstraint()) {
out.attribute(null, "idle", Boolean.toString(true));
}
if (taskStatus.hasChargingConstraint()) {
out.attribute(null, "charging", Boolean.toString(true));
}
out.endTag(null, XML_TAG_PARAMS_CONSTRAINTS);
}
private void writeExecutionCriteriaToXml(XmlSerializer out, TaskStatus taskStatus)
throws IOException {
final Task task = taskStatus.getTask();
if (taskStatus.getTask().isPeriodic()) {
out.startTag(null, XML_TAG_PERIODIC);
out.attribute(null, "period", Long.toString(task.getIntervalMillis()));
} else {
out.startTag(null, XML_TAG_ONEOFF);
}
if (taskStatus.hasDeadlineConstraint()) {
// Wall clock deadline.
final long deadlineWallclock = System.currentTimeMillis() +
(taskStatus.getLatestRunTimeElapsed() - SystemClock.elapsedRealtime());
out.attribute(null, "deadline", Long.toString(deadlineWallclock));
}
if (taskStatus.hasTimingDelayConstraint()) {
final long delayWallclock = System.currentTimeMillis() +
(taskStatus.getEarliestRunTime() - SystemClock.elapsedRealtime());
out.attribute(null, "delay", Long.toString(delayWallclock));
}
// Only write out back-off policy if it differs from the default.
// This also helps the case where the task is idle -> these aren't allowed to specify
// back-off.
if (taskStatus.getTask().getInitialBackoffMillis() != Task.DEFAULT_INITIAL_BACKOFF_MILLIS
|| taskStatus.getTask().getBackoffPolicy() != Task.DEFAULT_BACKOFF_POLICY) {
out.attribute(null, "backoff-policy", Integer.toString(task.getBackoffPolicy()));
out.attribute(null, "initial-backoff", Long.toString(task.getInitialBackoffMillis()));
}
if (task.isPeriodic()) {
out.endTag(null, XML_TAG_PERIODIC);
} else {
out.endTag(null, XML_TAG_ONEOFF);
}
}
}
/**
* Runnable that reads list of persisted task from xml.
* NOTE: This Runnable locks on TaskStore.this
*/
private class ReadTaskMapFromDiskRunnable implements Runnable {
private TaskMapReadFinishedListener mCallback;
public ReadTaskMapFromDiskRunnable(TaskMapReadFinishedListener callback) {
mCallback = callback;
}
@Override
public void run() {
try {
List<TaskStatus> tasks;
synchronized (TaskStore.this) {
tasks = readTaskMapImpl();
}
if (tasks != null) {
mCallback.onTaskMapReadFinished(tasks);
}
} catch (FileNotFoundException e) {
if (TaskManagerService.DEBUG) {
Slog.d(TAG, "Could not find tasks file, probably there was nothing to load.");
}
} catch (XmlPullParserException e) {
if (TaskManagerService.DEBUG) {
Slog.d(TAG, "Error parsing xml.", e);
}
} catch (IOException e) {
if (TaskManagerService.DEBUG) {
Slog.d(TAG, "Error parsing xml.", e);
}
}
}
private List<TaskStatus> readTaskMapImpl() throws XmlPullParserException, IOException {
FileInputStream fis = mTasksFile.openRead();
XmlPullParser parser = Xml.newPullParser();
parser.setInput(fis, null);
int eventType = parser.getEventType();
while (eventType != XmlPullParser.START_TAG &&
eventType != XmlPullParser.END_DOCUMENT) {
eventType = parser.next();
Slog.d(TAG, parser.getName());
}
if (eventType == XmlPullParser.END_DOCUMENT) {
if (DEBUG) {
Slog.d(TAG, "No persisted tasks.");
}
return null;
}
String tagName = parser.getName();
if ("task-info".equals(tagName)) {
final List<TaskStatus> tasks = new ArrayList<TaskStatus>();
// Read in version info.
try {
int version = Integer.valueOf(parser.getAttributeValue(null, "version"));
if (version != TASKS_FILE_VERSION) {
Slog.d(TAG, "Invalid version number, aborting tasks file read.");
return null;
}
} catch (NumberFormatException e) {
Slog.e(TAG, "Invalid version number, aborting tasks file read.");
return null;
}
eventType = parser.next();
do {
// Read each <task/>
if (eventType == XmlPullParser.START_TAG) {
tagName = parser.getName();
// Start reading task.
if ("task".equals(tagName)) {
TaskStatus persistedTask = restoreTaskFromXml(parser);
if (persistedTask != null) {
if (DEBUG) {
Slog.d(TAG, "Read out " + persistedTask);
}
tasks.add(persistedTask);
} else {
Slog.d(TAG, "Error reading task from file.");
}
}
}
eventType = parser.next();
} while (eventType != XmlPullParser.END_DOCUMENT);
return tasks;
}
return null;
}
/**
* @param parser Xml parser at the beginning of a "<task/>" tag. The next "parser.next()" call
* will take the parser into the body of the task tag.
* @return Newly instantiated task holding all the information we just read out of the xml tag.
*/
private TaskStatus restoreTaskFromXml(XmlPullParser parser) throws XmlPullParserException,
IOException {
Task.Builder taskBuilder;
int uid;
// Read out task identifier attributes.
try {
taskBuilder = buildBuilderFromXml(parser);
uid = Integer.valueOf(parser.getAttributeValue(null, "uid"));
} catch (NumberFormatException e) {
Slog.e(TAG, "Error parsing task's required fields, skipping");
return null;
}
int eventType;
// Read out constraints tag.
do {
eventType = parser.next();
} while (eventType == XmlPullParser.TEXT); // Push through to next START_TAG.
if (!(eventType == XmlPullParser.START_TAG &&
XML_TAG_PARAMS_CONSTRAINTS.equals(parser.getName()))) {
// Expecting a <constraints> start tag.
return null;
}
try {
buildConstraintsFromXml(taskBuilder, parser);
} catch (NumberFormatException e) {
Slog.d(TAG, "Error reading constraints, skipping.");
return null;
}
parser.next(); // Consume </constraints>
// Read out execution parameters tag.
do {
eventType = parser.next();
} while (eventType == XmlPullParser.TEXT);
if (eventType != XmlPullParser.START_TAG) {
return null;
}
Pair<Long, Long> runtimes;
try {
runtimes = buildExecutionTimesFromXml(parser);
} catch (NumberFormatException e) {
if (DEBUG) {
Slog.d(TAG, "Error parsing execution time parameters, skipping.");
}
return null;
}
if (XML_TAG_PERIODIC.equals(parser.getName())) {
try {
String val = parser.getAttributeValue(null, "period");
taskBuilder.setPeriodic(Long.valueOf(val));
} catch (NumberFormatException e) {
Slog.d(TAG, "Error reading periodic execution criteria, skipping.");
return null;
}
} else if (XML_TAG_ONEOFF.equals(parser.getName())) {
try {
if (runtimes.first != TaskStatus.DEFAULT_EARLIEST_RUNTIME) {
taskBuilder.setMinimumLatency(runtimes.first - SystemClock.elapsedRealtime());
}
if (runtimes.second != TaskStatus.DEFAULT_LATEST_RUNTIME) {
taskBuilder.setOverrideDeadline(
runtimes.second - SystemClock.elapsedRealtime());
}
} catch (NumberFormatException e) {
Slog.d(TAG, "Error reading task execution criteria, skipping.");
return null;
}
} else {
if (DEBUG) {
Slog.d(TAG, "Invalid parameter tag, skipping - " + parser.getName());
}
// Expecting a parameters start tag.
return null;
}
maybeBuildBackoffPolicyFromXml(taskBuilder, parser);
parser.nextTag(); // Consume parameters end tag.
// Read out extras Bundle.
do {
eventType = parser.next();
} while (eventType == XmlPullParser.TEXT);
if (!(eventType == XmlPullParser.START_TAG && XML_TAG_EXTRAS.equals(parser.getName()))) {
if (DEBUG) {
Slog.d(TAG, "Error reading extras, skipping.");
}
return null;
}
PersistableBundle extras = PersistableBundle.restoreFromXml(parser);
taskBuilder.setExtras(extras);
parser.nextTag(); // Consume </extras>
return new TaskStatus(taskBuilder.build(), uid, runtimes.first, runtimes.second);
}
private Task.Builder buildBuilderFromXml(XmlPullParser parser) throws NumberFormatException {
// Pull out required fields from <task> attributes.
int taskId = Integer.valueOf(parser.getAttributeValue(null, "taskid"));
String packageName = parser.getAttributeValue(null, "package");
String className = parser.getAttributeValue(null, "class");
ComponentName cname = new ComponentName(packageName, className);
return new Task.Builder(taskId, cname);
}
private void buildConstraintsFromXml(Task.Builder taskBuilder, XmlPullParser parser) {
String val = parser.getAttributeValue(null, "unmetered");
if (val != null) {
taskBuilder.setRequiredNetworkCapabilities(Task.NetworkType.UNMETERED);
}
val = parser.getAttributeValue(null, "connectivity");
if (val != null) {
taskBuilder.setRequiredNetworkCapabilities(Task.NetworkType.ANY);
}
val = parser.getAttributeValue(null, "idle");
if (val != null) {
taskBuilder.setRequiresDeviceIdle(true);
}
val = parser.getAttributeValue(null, "charging");
if (val != null) {
taskBuilder.setRequiresCharging(true);
}
}
/**
* Builds the back-off policy out of the params tag. These attributes may not exist, depending
* on whether the back-off was set when the task was first scheduled.
*/
private void maybeBuildBackoffPolicyFromXml(Task.Builder taskBuilder, XmlPullParser parser) {
String val = parser.getAttributeValue(null, "initial-backoff");
if (val != null) {
long initialBackoff = Long.valueOf(val);
val = parser.getAttributeValue(null, "backoff-policy");
int backoffPolicy = Integer.valueOf(val); // Will throw NFE which we catch higher up.
taskBuilder.setBackoffCriteria(initialBackoff, backoffPolicy);
}
}
/**
* Convenience function to read out and convert deadline and delay from xml into elapsed real
* time.
* @return A {@link android.util.Pair}, where the first value is the earliest elapsed runtime
* and the second is the latest elapsed runtime.
*/
private Pair<Long, Long> buildExecutionTimesFromXml(XmlPullParser parser)
throws NumberFormatException {
// Pull out execution time data.
final long nowWallclock = System.currentTimeMillis();
final long nowElapsed = SystemClock.elapsedRealtime();
long earliestRunTimeElapsed = TaskStatus.DEFAULT_EARLIEST_RUNTIME;
long latestRunTimeElapsed = TaskStatus.DEFAULT_LATEST_RUNTIME;
String val = parser.getAttributeValue(null, "deadline");
if (val != null) {
long latestRuntimeWallclock = Long.valueOf(val);
long maxDelayElapsed =
Math.max(latestRuntimeWallclock - nowWallclock, 0);
latestRunTimeElapsed = nowElapsed + maxDelayElapsed;
}
val = parser.getAttributeValue(null, "delay");
if (val != null) {
long earliestRuntimeWallclock = Long.valueOf(val);
long minDelayElapsed =
Math.max(earliestRuntimeWallclock - nowWallclock, 0);
earliestRunTimeElapsed = nowElapsed + minDelayElapsed;
}
return Pair.create(earliestRunTimeElapsed, latestRunTimeElapsed);
}
}
}

213
services/core/java/com/android/server/task/controllers/BatteryController.java Normal file
View File

@@ -0,0 +1,213 @@
/*
* Copyright (C) 2014 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.task.controllers;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.BatteryManager;
import android.os.BatteryProperty;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.util.Slog;
import com.android.internal.annotations.VisibleForTesting;
import com.android.server.BatteryService;
import com.android.server.task.StateChangedListener;
import com.android.server.task.TaskManagerService;
import java.util.ArrayList;
import java.util.List;
/**
* Simple controller that tracks whether the phone is charging or not. The phone is considered to
* be charging when it's been plugged in for more than two minutes, and the system has broadcast
* ACTION_BATTERY_OK.
*/
public class BatteryController extends StateController {
private static final String TAG = "BatteryController";
private static final Object sCreationLock = new Object();
private static volatile BatteryController sController;
private static final String ACTION_CHARGING_STABLE =
"com.android.server.task.controllers.BatteryController.ACTION_CHARGING_STABLE";
/** Wait this long after phone is plugged in before doing any work. */
private static final long STABLE_CHARGING_THRESHOLD_MILLIS = 2 * 60 * 1000; // 2 minutes.
private List<TaskStatus> mTrackedTasks = new ArrayList<TaskStatus>();
private ChargingTracker mChargeTracker;
public static BatteryController get(TaskManagerService taskManagerService) {
synchronized (sCreationLock) {
if (sController == null) {
sController = new BatteryController(taskManagerService,
taskManagerService.getContext());
}
}
return sController;
}
@VisibleForTesting
public ChargingTracker getTracker() {
return mChargeTracker;
}
@VisibleForTesting
public static BatteryController getForTesting(StateChangedListener stateChangedListener,
Context context) {
return new BatteryController(stateChangedListener, context);
}
private BatteryController(StateChangedListener stateChangedListener, Context context) {
super(stateChangedListener, context);
mChargeTracker = new ChargingTracker();
mChargeTracker.startTracking();
}
@Override
public void maybeStartTrackingTask(TaskStatus taskStatus) {
if (taskStatus.hasChargingConstraint()) {
synchronized (mTrackedTasks) {
mTrackedTasks.add(taskStatus);
taskStatus.chargingConstraintSatisfied.set(mChargeTracker.isOnStablePower());
}
}
}
@Override
public void maybeStopTrackingTask(TaskStatus taskStatus) {
if (taskStatus.hasChargingConstraint()) {
synchronized (mTrackedTasks) {
mTrackedTasks.remove(taskStatus);
}
}
}
private void maybeReportNewChargingState() {
final boolean stablePower = mChargeTracker.isOnStablePower();
boolean reportChange = false;
synchronized (mTrackedTasks) {
for (TaskStatus ts : mTrackedTasks) {
boolean previous = ts.chargingConstraintSatisfied.getAndSet(stablePower);
if (previous != stablePower) {
reportChange = true;
}
}
}
if (reportChange) {
mStateChangedListener.onControllerStateChanged();
}
}
public class ChargingTracker extends BroadcastReceiver {
private final AlarmManager mAlarm;
private final PendingIntent mStableChargingTriggerIntent;
/**
* Track whether we're "charging", where charging means that we're ready to commit to
* doing work.
*/
private boolean mCharging;
/** Keep track of whether the battery is charged enough that we want to do work. */
private boolean mBatteryHealthy;
public ChargingTracker() {
mAlarm = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(ACTION_CHARGING_STABLE)
.setComponent(new ComponentName(mContext, this.getClass()));
mStableChargingTriggerIntent = PendingIntent.getBroadcast(mContext, 0, intent, 0);
}
public void startTracking() {
IntentFilter filter = new IntentFilter();
// Battery health.
filter.addAction(Intent.ACTION_BATTERY_LOW);
filter.addAction(Intent.ACTION_BATTERY_OKAY);
// Charging/not charging.
filter.addAction(Intent.ACTION_POWER_CONNECTED);
filter.addAction(Intent.ACTION_POWER_DISCONNECTED);
mContext.registerReceiver(this, filter);
// Initialise tracker state.
BatteryService batteryService = (BatteryService) ServiceManager.getService("battery");
if (batteryService != null) {
mBatteryHealthy = !batteryService.isBatteryLow();
mCharging = batteryService.isPowered(BatteryManager.BATTERY_PLUGGED_ANY);
} else {
// Unavailable for some reason, we default to false and let ACTION_BATTERY_[OK,LOW]
// sort it out.
}
}
boolean isOnStablePower() {
return mCharging && mBatteryHealthy;
}
@Override
public void onReceive(Context context, Intent intent) {
onReceiveInternal(intent);
}
@VisibleForTesting
public void onReceiveInternal(Intent intent) {
final String action = intent.getAction();
if (Intent.ACTION_BATTERY_LOW.equals(action)) {
if (DEBUG) {
Slog.d(TAG, "Battery life too low to do work. @ "
+ SystemClock.elapsedRealtime());
}
// If we get this action, the battery is discharging => it isn't plugged in so
// there's no work to cancel. We track this variable for the case where it is
// charging, but hasn't been for long enough to be healthy.
mBatteryHealthy = false;
} else if (Intent.ACTION_BATTERY_OKAY.equals(action)) {
if (DEBUG) {
Slog.d(TAG, "Battery life healthy enough to do work. @ "
+ SystemClock.elapsedRealtime());
}
mBatteryHealthy = true;
maybeReportNewChargingState();
} else if (Intent.ACTION_POWER_CONNECTED.equals(action)) {
// Set up an alarm for ACTION_CHARGING_STABLE - we don't want to kick off tasks
// here if the user unplugs the phone immediately.
mAlarm.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
SystemClock.elapsedRealtime() + STABLE_CHARGING_THRESHOLD_MILLIS,
mStableChargingTriggerIntent);
mCharging = true;
} else if (Intent.ACTION_POWER_DISCONNECTED.equals(action)) {
// If an alarm is set, breathe a sigh of relief and cancel it - crisis averted.
mAlarm.cancel(mStableChargingTriggerIntent);
mCharging = false;
maybeReportNewChargingState();
}else if (ACTION_CHARGING_STABLE.equals(action)) {
// Here's where we actually do the notify for a task being ready.
if (DEBUG) {
Slog.d(TAG, "Battery connected fired @ " + SystemClock.elapsedRealtime());
}
if (mCharging) { // Should never receive this intent if mCharging is false.
maybeReportNewChargingState();
}
}
}
}
}

8
services/core/java/com/android/server/task/controllers/ConnectivityController.java
View File

@@ -27,6 +27,7 @@ import android.os.UserHandle;
import android.util.Log;
import android.util.Slog;
import com.android.server.task.StateChangedListener;
import com.android.server.task.TaskManagerService;
import java.util.LinkedList;
@@ -39,7 +40,6 @@ import java.util.List;
*/
public class ConnectivityController extends StateController {
private static final String TAG = "TaskManager.Connectivity";
private static final boolean DEBUG = true;
private final List<TaskStatus> mTrackedTasks = new LinkedList<TaskStatus>();
private final BroadcastReceiver mConnectivityChangedReceiver =
@@ -54,13 +54,13 @@ public class ConnectivityController extends StateController {
public static synchronized ConnectivityController get(TaskManagerService taskManager) {
if (mSingleton == null) {
mSingleton = new ConnectivityController(taskManager);
mSingleton = new ConnectivityController(taskManager, taskManager.getContext());
}
return mSingleton;
}
private ConnectivityController(TaskManagerService service) {
super(service);
private ConnectivityController(StateChangedListener stateChangedListener, Context context) {
super(stateChangedListener, context);
// Register connectivity changed BR.
IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);

8
services/core/java/com/android/server/task/controllers/IdleController.java
View File

@@ -28,11 +28,11 @@ import android.content.IntentFilter;
import android.os.SystemClock;
import android.util.Slog;
import com.android.server.task.StateChangedListener;
import com.android.server.task.TaskManagerService;
public class IdleController extends StateController {
private static final String TAG = "IdleController";
private static final boolean DEBUG = false;
// Policy: we decide that we're "idle" if the device has been unused /
// screen off or dreaming for at least this long
@@ -52,14 +52,14 @@ public class IdleController extends StateController {
public static IdleController get(TaskManagerService service) {
synchronized (sCreationLock) {
if (sController == null) {
sController = new IdleController(service);
sController = new IdleController(service, service.getContext());
}
return sController;
}
}
private IdleController(TaskManagerService service) {
super(service);
private IdleController(StateChangedListener stateChangedListener, Context context) {
super(stateChangedListener, context);
initIdleStateTracking();
}

8
services/core/java/com/android/server/task/controllers/StateController.java
View File

@@ -27,13 +27,13 @@ import com.android.server.task.TaskManagerService;
* are ready to run, or whether they must be stopped.
*/
public abstract class StateController {
protected static final boolean DEBUG = true;
protected Context mContext;
protected StateChangedListener mStateChangedListener;
public StateController(TaskManagerService service) {
mStateChangedListener = service;
mContext = service.getContext();
public StateController(StateChangedListener stateChangedListener, Context context) {
mStateChangedListener = stateChangedListener;
mContext = context;
}
/**

57
services/core/java/com/android/server/task/controllers/TaskStatus.java
View File

@@ -18,7 +18,7 @@ package com.android.server.task.controllers;
import android.app.task.Task;
import android.content.ComponentName;
import android.os.Bundle;
import android.os.PersistableBundle;
import android.os.SystemClock;
import android.os.UserHandle;
@@ -37,6 +37,9 @@ import java.util.concurrent.atomic.AtomicBoolean;
* @hide
*/
public class TaskStatus {
public static final long DEFAULT_LATEST_RUNTIME = Long.MAX_VALUE;
public static final long DEFAULT_EARLIEST_RUNTIME = 0L;
final Task task;
final int uId;
@@ -61,7 +64,7 @@ public class TaskStatus {
* indicates there is no deadline constraint. See {@link #hasDeadlineConstraint()}.
*/
private long latestRunTimeElapsedMillis;
/** How many times this task has failed, used to compute back-off. */
private final int numFailures;
/** Provide a handle to the service that this task will be run on. */
@@ -69,36 +72,52 @@ public class TaskStatus {
return uId;
}
/** Create a newly scheduled task. */
public TaskStatus(Task task, int uId, boolean persisted) {
private TaskStatus(Task task, int uId, boolean persisted, int numFailures) {
this.task = task;
this.uId = uId;
this.numFailures = 0;
this.numFailures = numFailures;
this.persisted = persisted;
}
/** Create a newly scheduled task. */
public TaskStatus(Task task, int uId, boolean persisted) {
this(task, uId, persisted, 0);
final long elapsedNow = SystemClock.elapsedRealtime();
// Timing constraints
if (task.isPeriodic()) {
earliestRunTimeElapsedMillis = elapsedNow;
latestRunTimeElapsedMillis = elapsedNow + task.getIntervalMillis();
} else {
earliestRunTimeElapsedMillis = task.hasEarlyConstraint() ?
elapsedNow + task.getMinLatencyMillis() : 0L;
elapsedNow + task.getMinLatencyMillis() : DEFAULT_EARLIEST_RUNTIME;
latestRunTimeElapsedMillis = task.hasLateConstraint() ?
elapsedNow + task.getMaxExecutionDelayMillis() : Long.MAX_VALUE;
elapsedNow + task.getMaxExecutionDelayMillis() : DEFAULT_LATEST_RUNTIME;
}
}
public TaskStatus(TaskStatus rescheduling, long newEarliestRuntimeElapsed,
long newLatestRuntimeElapsed, int backoffAttempt) {
this.task = rescheduling.task;
/**
* Create a new TaskStatus that was loaded from disk. We ignore the provided
* {@link android.app.task.Task} time criteria because we can load a persisted periodic task
* from the {@link com.android.server.task.TaskStore} and still want to respect its
* wallclock runtime rather than resetting it on every boot.
* We consider a freshly loaded task to no longer be in back-off.
*/
public TaskStatus(Task task, int uId, long earliestRunTimeElapsedMillis,
long latestRunTimeElapsedMillis) {
this(task, uId, true, 0);
this.uId = rescheduling.getUid();
this.persisted = rescheduling.isPersisted();
this.numFailures = backoffAttempt;
this.earliestRunTimeElapsedMillis = earliestRunTimeElapsedMillis;
this.latestRunTimeElapsedMillis = latestRunTimeElapsedMillis;
}
earliestRunTimeElapsedMillis = newEarliestRuntimeElapsed;
latestRunTimeElapsedMillis = newLatestRuntimeElapsed;
/** Create a new task to be rescheduled with the provided parameters. */
public TaskStatus(TaskStatus rescheduling, long newEarliestRuntimeElapsedMillis,
long newLatestRuntimeElapsedMillis, int backoffAttempt) {
this(rescheduling.task, rescheduling.getUid(), rescheduling.isPersisted(), backoffAttempt);
earliestRunTimeElapsedMillis = newEarliestRuntimeElapsedMillis;
latestRunTimeElapsedMillis = newLatestRuntimeElapsedMillis;
}
public Task getTask() {
@@ -125,7 +144,7 @@ public class TaskStatus {
return uId;
}
public Bundle getExtras() {
public PersistableBundle getExtras() {
return task.getExtras();
}
@@ -142,11 +161,11 @@ public class TaskStatus {
}
public boolean hasTimingDelayConstraint() {
return earliestRunTimeElapsedMillis != 0L;
return earliestRunTimeElapsedMillis != DEFAULT_EARLIEST_RUNTIME;
}
public boolean hasDeadlineConstraint() {
return latestRunTimeElapsedMillis != Long.MAX_VALUE;
return latestRunTimeElapsedMillis != DEFAULT_LATEST_RUNTIME;
}
public boolean hasIdleConstraint() {

7
services/core/java/com/android/server/task/controllers/TimeController.java
View File

@@ -24,6 +24,7 @@ import android.content.Intent;
import android.content.IntentFilter;
import android.os.SystemClock;
import com.android.server.task.StateChangedListener;
import com.android.server.task.TaskManagerService;
import java.util.Iterator;
@@ -58,13 +59,13 @@ public class TimeController extends StateController {
public static synchronized TimeController get(TaskManagerService taskManager) {
if (mSingleton == null) {
mSingleton = new TimeController(taskManager);
mSingleton = new TimeController(taskManager, taskManager.getContext());
}
return mSingleton;
}
private TimeController(TaskManagerService service) {
super(service);
private TimeController(StateChangedListener stateChangedListener, Context context) {
super(stateChangedListener, context);
mTaskExpiredAlarmIntent =
PendingIntent.getBroadcast(mContext, 0 /* ignored */,
new Intent(ACTION_TASK_EXPIRED), 0);

199
services/tests/servicestests/src/com/android/server/task/TaskStoreTest.java Normal file
View File

@@ -0,0 +1,199 @@
package com.android.server.task;
import android.content.ComponentName;
import android.content.Context;
import android.app.task.Task;
import android.app.task.Task.Builder;
import android.os.PersistableBundle;
import android.test.AndroidTestCase;
import android.test.RenamingDelegatingContext;
import android.util.Log;
import com.android.server.task.controllers.TaskStatus;
import java.util.List;
import static com.android.server.task.TaskStore.initAndGet;
/**
* Test reading and writing correctly from file.
*/
public class TaskStoreTest extends AndroidTestCase {
private static final String TAG = "TaskStoreTest";
private static final String TEST_PREFIX = "_test_";
// private static final int USER_NON_0 = 3;
private static final int SOME_UID = 34234;
private ComponentName mComponent;
private static final long IO_WAIT = 600L;
TaskStore mTaskStoreUnderTest;
Context mTestContext;
TaskMapReadFinishedListener mTaskMapReadFinishedListenerStub =
new TaskMapReadFinishedListener() {
@Override
public void onTaskMapReadFinished(List<TaskStatus> tasks) {
// do nothing.
}
};
@Override
public void setUp() throws Exception {
mTestContext = new RenamingDelegatingContext(getContext(), TEST_PREFIX);
Log.d(TAG, "Saving tasks to '" + mTestContext.getFilesDir() + "'");
mTaskStoreUnderTest = TaskStore.initAndGetForTesting(mTestContext,
mTestContext.getFilesDir(), mTaskMapReadFinishedListenerStub);
mComponent = new ComponentName(getContext().getPackageName(), StubClass.class.getName());
}
@Override
public void tearDown() throws Exception {
mTaskStoreUnderTest.clear();
}
public void testMaybeWriteStatusToDisk() throws Exception {
int taskId = 5;
long runByMillis = 20000L; // 20s
long runFromMillis = 2000L; // 2s
long initialBackoff = 10000L; // 10s
final Task task = new Builder(taskId, mComponent)
.setRequiresCharging(true)
.setRequiredNetworkCapabilities(Task.NetworkType.ANY)
.setBackoffCriteria(initialBackoff, Task.BackoffPolicy.EXPONENTIAL)
.setOverrideDeadline(runByMillis)
.setMinimumLatency(runFromMillis)
.build();
final TaskStatus ts = new TaskStatus(task, SOME_UID, true /* persisted */);
mTaskStoreUnderTest.add(ts);
Thread.sleep(IO_WAIT);
// Manually load tasks from xml file.
mTaskStoreUnderTest.readTaskMapFromDisk(new TaskMapReadFinishedListener() {
@Override
public void onTaskMapReadFinished(List<TaskStatus> tasks) {
assertEquals("Didn't get expected number of persisted tasks.", 1, tasks.size());
TaskStatus loadedTaskStatus = tasks.get(0);
assertTasksEqual(task, loadedTaskStatus.getTask());
assertEquals("Different uids.", SOME_UID, tasks.get(0).getUid());
compareTimestampsSubjectToIoLatency("Early run-times not the same after read.",
ts.getEarliestRunTime(), loadedTaskStatus.getEarliestRunTime());
compareTimestampsSubjectToIoLatency("Late run-times not the same after read.",
ts.getLatestRunTimeElapsed(), loadedTaskStatus.getLatestRunTimeElapsed());
}
});
}
public void testWritingTwoFilesToDisk() throws Exception {
final Task task1 = new Builder(8, mComponent)
.setRequiresDeviceIdle(true)
.setPeriodic(10000L)
.setRequiresCharging(true)
.build();
final Task task2 = new Builder(12, mComponent)
.setMinimumLatency(5000L)
.setBackoffCriteria(15000L, Task.BackoffPolicy.LINEAR)
.setOverrideDeadline(30000L)
.setRequiredNetworkCapabilities(Task.NetworkType.UNMETERED)
.build();
final TaskStatus taskStatus1 = new TaskStatus(task1, SOME_UID, true /* persisted */);
final TaskStatus taskStatus2 = new TaskStatus(task2, SOME_UID, true /* persisted */);
mTaskStoreUnderTest.add(taskStatus1);
mTaskStoreUnderTest.add(taskStatus2);
Thread.sleep(IO_WAIT);
mTaskStoreUnderTest.readTaskMapFromDisk(new TaskMapReadFinishedListener() {
@Override
public void onTaskMapReadFinished(List<TaskStatus> tasks) {
assertEquals("Incorrect # of persisted tasks.", 2, tasks.size());
TaskStatus loaded1 = tasks.get(0);
TaskStatus loaded2 = tasks.get(1);
assertTasksEqual(task1, loaded1.getTask());
assertTasksEqual(task2, loaded2.getTask());
// Check that the loaded task has the correct runtimes.
compareTimestampsSubjectToIoLatency("Early run-times not the same after read.",
taskStatus1.getEarliestRunTime(), loaded1.getEarliestRunTime());
compareTimestampsSubjectToIoLatency("Late run-times not the same after read.",
taskStatus1.getLatestRunTimeElapsed(), loaded1.getLatestRunTimeElapsed());
compareTimestampsSubjectToIoLatency("Early run-times not the same after read.",
taskStatus2.getEarliestRunTime(), loaded2.getEarliestRunTime());
compareTimestampsSubjectToIoLatency("Late run-times not the same after read.",
taskStatus2.getLatestRunTimeElapsed(), loaded2.getLatestRunTimeElapsed());
}
});
}
public void testWritingTaskWithExtras() throws Exception {
Task.Builder b = new Builder(8, mComponent)
.setRequiresDeviceIdle(true)
.setPeriodic(10000L)
.setRequiresCharging(true);
PersistableBundle extras = new PersistableBundle();
extras.putDouble("hello", 3.2);
extras.putString("hi", "there");
extras.putInt("into", 3);
b.setExtras(extras);
final Task task = b.build();
TaskStatus taskStatus = new TaskStatus(task, SOME_UID, true /* persisted */);
mTaskStoreUnderTest.add(taskStatus);
Thread.sleep(IO_WAIT);
mTaskStoreUnderTest.readTaskMapFromDisk(new TaskMapReadFinishedListener() {
@Override
public void onTaskMapReadFinished(List<TaskStatus> tasks) {
assertEquals("Incorrect # of persisted tasks.", 1, tasks.size());
TaskStatus loaded = tasks.get(0);
assertTasksEqual(task, loaded.getTask());
}
});
}
/**
* Helper function to throw an error if the provided task and TaskStatus objects are not equal.
*/
private void assertTasksEqual(Task first, Task second) {
assertEquals("Different task ids.", first.getId(), second.getId());
assertEquals("Different components.", first.getService(), second.getService());
assertEquals("Different periodic status.", first.isPeriodic(), second.isPeriodic());
assertEquals("Different period.", first.getIntervalMillis(), second.getIntervalMillis());
assertEquals("Different inital backoff.", first.getInitialBackoffMillis(),
second.getInitialBackoffMillis());
assertEquals("Different backoff policy.", first.getBackoffPolicy(),
second.getBackoffPolicy());
assertEquals("Invalid charging constraint.", first.isRequireCharging(),
second.isRequireCharging());
assertEquals("Invalid idle constraint.", first.isRequireDeviceIdle(),
second.isRequireDeviceIdle());
assertEquals("Invalid unmetered constraint.",
first.getNetworkCapabilities() == Task.NetworkType.UNMETERED,
second.getNetworkCapabilities() == Task.NetworkType.UNMETERED);
assertEquals("Invalid connectivity constraint.",
first.getNetworkCapabilities() == Task.NetworkType.ANY,
second.getNetworkCapabilities() == Task.NetworkType.ANY);
assertEquals("Invalid deadline constraint.",
first.hasLateConstraint(),
second.hasLateConstraint());
assertEquals("Invalid delay constraint.",
first.hasEarlyConstraint(),
second.hasEarlyConstraint());
assertEquals("Extras don't match",
first.getExtras().toString(), second.getExtras().toString());
}
/**
* When comparing timestamps before and after DB read/writes (to make sure we're saving/loading
* the correct values), there is some latency involved that terrorises a naive assertEquals().
* We define a <code>DELTA_MILLIS</code> as a function variable here to make this comparision
* more reasonable.
*/
private void compareTimestampsSubjectToIoLatency(String error, long ts1, long ts2) {
final long DELTA_MILLIS = 700L; // We allow up to 700ms of latency for IO read/writes.
assertTrue(error, Math.abs(ts1 - ts2) < DELTA_MILLIS + IO_WAIT);
}
private static class StubClass {}
}

66
services/tests/servicestests/src/com/android/server/task/controllers/BatteryControllerTest.java Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright (C) 2014 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.task.controllers;
import android.content.ComponentName;
import android.content.Intent;
import android.test.AndroidTestCase;
import com.android.server.task.StateChangedListener;
import static com.android.server.task.controllers.BatteryController.getForTesting;
import static org.mockito.Mockito.*;
/**
*
*/
public class BatteryControllerTest extends AndroidTestCase {
BatteryController mBatteryControllerUnderTest;
StateChangedListener mStateChangedListenerStub = new StateChangedListener() {
@Override
public void onControllerStateChanged() {
}
@Override
public void onTaskDeadlineExpired(TaskStatus taskStatus) {
}
};
BatteryController.ChargingTracker mTrackerUnderTest;
public void setUp() throws Exception {
mBatteryControllerUnderTest = getForTesting(mStateChangedListenerStub, getTestContext());
mTrackerUnderTest = mBatteryControllerUnderTest.getTracker();
}
public void testSendBatteryChargingIntent() throws Exception {
Intent batteryConnectedIntent = new Intent(Intent.ACTION_POWER_CONNECTED)
.setComponent(new ComponentName(getContext(), mTrackerUnderTest.getClass()));
Intent batteryHealthyIntent = new Intent(Intent.ACTION_BATTERY_OKAY)
.setComponent(new ComponentName(getContext(), mTrackerUnderTest.getClass()));
mTrackerUnderTest.onReceiveInternal(batteryConnectedIntent);
mTrackerUnderTest.onReceiveInternal(batteryHealthyIntent);
assertTrue(mTrackerUnderTest.isOnStablePower());
}
}