/* * 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.job; import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED; import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; import java.util.List; import android.app.Activity; import android.app.ActivityManager; import android.app.AppGlobals; import android.app.IUidObserver; import android.app.job.JobInfo; import android.app.job.JobParameters; import android.app.job.JobScheduler; import android.app.job.JobService; import android.app.job.IJobScheduler; import android.app.job.JobWorkItem; import android.content.BroadcastReceiver; import android.content.ComponentName; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.pm.IPackageManager; import android.content.pm.PackageManager; import android.content.pm.ServiceInfo; import android.content.pm.PackageManager.NameNotFoundException; import android.database.ContentObserver; import android.net.Uri; import android.os.BatteryStats; import android.os.Binder; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.os.Process; import android.os.PowerManager; import android.os.RemoteException; import android.os.ResultReceiver; import android.os.ServiceManager; import android.os.ShellCallback; import android.os.SystemClock; import android.os.UserHandle; import android.os.UserManagerInternal; import android.provider.Settings; import android.util.KeyValueListParser; import android.util.Slog; import android.util.SparseArray; import android.util.SparseIntArray; import android.util.TimeUtils; import com.android.internal.app.IBatteryStats; import com.android.internal.app.procstats.ProcessStats; import com.android.internal.util.ArrayUtils; import com.android.internal.util.DumpUtils; import com.android.server.DeviceIdleController; import com.android.server.FgThread; import com.android.server.LocalServices; import com.android.server.job.JobStore.JobStatusFunctor; import com.android.server.job.controllers.AppIdleController; import com.android.server.job.controllers.BatteryController; import com.android.server.job.controllers.ConnectivityController; import com.android.server.job.controllers.ContentObserverController; import com.android.server.job.controllers.DeviceIdleJobsController; import com.android.server.job.controllers.IdleController; import com.android.server.job.controllers.JobStatus; import com.android.server.job.controllers.StateController; import com.android.server.job.controllers.StorageController; import com.android.server.job.controllers.TimeController; import libcore.util.EmptyArray; /** * Responsible for taking jobs representing work to be performed by a client app, and determining * based on the criteria specified when that job should be run against the client application's * endpoint. * Implements logic for scheduling, and rescheduling jobs. The JobSchedulerService knows nothing * about constraints, or the state of active jobs. It receives callbacks from the various * controllers and completed jobs and operates accordingly. * * Note on locking: Any operations that manipulate {@link #mJobs} need to lock on that object. * Any function with the suffix 'Locked' also needs to lock on {@link #mJobs}. * @hide */ public final class JobSchedulerService extends com.android.server.SystemService implements StateChangedListener, JobCompletedListener { static final String TAG = "JobSchedulerService"; public static final boolean DEBUG = false; /** The maximum number of concurrent jobs we run at one time. */ private static final int MAX_JOB_CONTEXTS_COUNT = 16; /** Enforce a per-app limit on scheduled jobs? */ private static final boolean ENFORCE_MAX_JOBS = true; /** The maximum number of jobs that we allow an unprivileged app to schedule */ private static final int MAX_JOBS_PER_APP = 100; /** Global local for all job scheduler state. */ final Object mLock = new Object(); /** Master list of jobs. */ final JobStore mJobs; /** Tracking amount of time each package runs for. */ final JobPackageTracker mJobPackageTracker = new JobPackageTracker(); static final int MSG_JOB_EXPIRED = 0; static final int MSG_CHECK_JOB = 1; static final int MSG_STOP_JOB = 2; static final int MSG_CHECK_JOB_GREEDY = 3; /** * Track Services that have currently active or pending jobs. The index is provided by * {@link JobStatus#getServiceToken()} */ final List mActiveServices = new ArrayList<>(); /** List of controllers that will notify this service of updates to jobs. */ List mControllers; /** Need direct access to this for testing. */ BatteryController mBatteryController; /** Need direct access to this for testing. */ StorageController mStorageController; /** * Queue of pending jobs. The JobServiceContext class will receive jobs from this list * when ready to execute them. */ final ArrayList mPendingJobs = new ArrayList<>(); int[] mStartedUsers = EmptyArray.INT; final JobHandler mHandler; final JobSchedulerStub mJobSchedulerStub; IBatteryStats mBatteryStats; PowerManager mPowerManager; DeviceIdleController.LocalService mLocalDeviceIdleController; /** * Set to true once we are allowed to run third party apps. */ boolean mReadyToRock; /** * What we last reported to DeviceIdleController about whether we are active. */ boolean mReportedActive; /** * Current limit on the number of concurrent JobServiceContext entries we want to * keep actively running a job. */ int mMaxActiveJobs = 1; /** * Which uids are currently in the foreground. */ final SparseIntArray mUidPriorityOverride = new SparseIntArray(); /** * Which uids are currently performing backups, so we shouldn't allow their jobs to run. */ final SparseIntArray mBackingUpUids = new SparseIntArray(); // -- Pre-allocated temporaries only for use in assignJobsToContextsLocked -- /** * This array essentially stores the state of mActiveServices array. * The ith index stores the job present on the ith JobServiceContext. * We manipulate this array until we arrive at what jobs should be running on * what JobServiceContext. */ JobStatus[] mTmpAssignContextIdToJobMap = new JobStatus[MAX_JOB_CONTEXTS_COUNT]; /** * Indicates whether we need to act on this jobContext id */ boolean[] mTmpAssignAct = new boolean[MAX_JOB_CONTEXTS_COUNT]; /** * The uid whose jobs we would like to assign to a context. */ int[] mTmpAssignPreferredUidForContext = new int[MAX_JOB_CONTEXTS_COUNT]; /** * All times are in milliseconds. These constants are kept synchronized with the system * global Settings. Any access to this class or its fields should be done while * holding the JobSchedulerService.mLock lock. */ private final class Constants extends ContentObserver { // Key names stored in the settings value. private static final String KEY_MIN_IDLE_COUNT = "min_idle_count"; private static final String KEY_MIN_CHARGING_COUNT = "min_charging_count"; private static final String KEY_MIN_BATTERY_NOT_LOW_COUNT = "min_battery_not_low_count"; private static final String KEY_MIN_STORAGE_NOT_LOW_COUNT = "min_storage_not_low_count"; private static final String KEY_MIN_CONNECTIVITY_COUNT = "min_connectivity_count"; private static final String KEY_MIN_CONTENT_COUNT = "min_content_count"; private static final String KEY_MIN_READY_JOBS_COUNT = "min_ready_jobs_count"; private static final String KEY_HEAVY_USE_FACTOR = "heavy_use_factor"; private static final String KEY_MODERATE_USE_FACTOR = "moderate_use_factor"; private static final String KEY_FG_JOB_COUNT = "fg_job_count"; private static final String KEY_BG_NORMAL_JOB_COUNT = "bg_normal_job_count"; private static final String KEY_BG_MODERATE_JOB_COUNT = "bg_moderate_job_count"; private static final String KEY_BG_LOW_JOB_COUNT = "bg_low_job_count"; private static final String KEY_BG_CRITICAL_JOB_COUNT = "bg_critical_job_count"; private static final String KEY_MAX_STANDARD_RESCHEDULE_COUNT = "max_standard_reschedule_count"; private static final String KEY_MAX_WORK_RESCHEDULE_COUNT = "max_work_reschedule_count"; private static final String KEY_MIN_LINEAR_BACKOFF_TIME = "min_linear_backoff_time"; private static final String KEY_MIN_EXP_BACKOFF_TIME = "min_exp_backoff_time"; private static final int DEFAULT_MIN_IDLE_COUNT = 1; private static final int DEFAULT_MIN_CHARGING_COUNT = 1; private static final int DEFAULT_MIN_BATTERY_NOT_LOW_COUNT = 1; private static final int DEFAULT_MIN_STORAGE_NOT_LOW_COUNT = 1; private static final int DEFAULT_MIN_CONNECTIVITY_COUNT = 1; private static final int DEFAULT_MIN_CONTENT_COUNT = 1; private static final int DEFAULT_MIN_READY_JOBS_COUNT = 1; private static final float DEFAULT_HEAVY_USE_FACTOR = .9f; private static final float DEFAULT_MODERATE_USE_FACTOR = .5f; private static final int DEFAULT_FG_JOB_COUNT = 4; private static final int DEFAULT_BG_NORMAL_JOB_COUNT = 6; private static final int DEFAULT_BG_MODERATE_JOB_COUNT = 4; private static final int DEFAULT_BG_LOW_JOB_COUNT = 1; private static final int DEFAULT_BG_CRITICAL_JOB_COUNT = 1; private static final int DEFAULT_MAX_STANDARD_RESCHEDULE_COUNT = Integer.MAX_VALUE; private static final int DEFAULT_MAX_WORK_RESCHEDULE_COUNT = Integer.MAX_VALUE; private static final long DEFAULT_MIN_LINEAR_BACKOFF_TIME = JobInfo.MIN_BACKOFF_MILLIS; private static final long DEFAULT_MIN_EXP_BACKOFF_TIME = JobInfo.MIN_BACKOFF_MILLIS; /** * Minimum # of idle jobs that must be ready in order to force the JMS to schedule things * early. */ int MIN_IDLE_COUNT = DEFAULT_MIN_IDLE_COUNT; /** * Minimum # of charging jobs that must be ready in order to force the JMS to schedule * things early. */ int MIN_CHARGING_COUNT = DEFAULT_MIN_CHARGING_COUNT; /** * Minimum # of "battery not low" jobs that must be ready in order to force the JMS to * schedule things early. */ int MIN_BATTERY_NOT_LOW_COUNT = DEFAULT_MIN_BATTERY_NOT_LOW_COUNT; /** * Minimum # of "storage not low" jobs that must be ready in order to force the JMS to * schedule things early. */ int MIN_STORAGE_NOT_LOW_COUNT = DEFAULT_MIN_STORAGE_NOT_LOW_COUNT; /** * Minimum # of connectivity jobs that must be ready in order to force the JMS to schedule * things early. 1 == Run connectivity jobs as soon as ready. */ int MIN_CONNECTIVITY_COUNT = DEFAULT_MIN_CONNECTIVITY_COUNT; /** * Minimum # of content trigger jobs that must be ready in order to force the JMS to * schedule things early. */ int MIN_CONTENT_COUNT = DEFAULT_MIN_CONTENT_COUNT; /** * Minimum # of jobs (with no particular constraints) for which the JMS will be happy * running some work early. This (and thus the other min counts) is now set to 1, to * prevent any batching at this level. Since we now do batching through doze, that is * a much better mechanism. */ int MIN_READY_JOBS_COUNT = DEFAULT_MIN_READY_JOBS_COUNT; /** * This is the job execution factor that is considered to be heavy use of the system. */ float HEAVY_USE_FACTOR = DEFAULT_HEAVY_USE_FACTOR; /** * This is the job execution factor that is considered to be moderate use of the system. */ float MODERATE_USE_FACTOR = DEFAULT_MODERATE_USE_FACTOR; /** * The number of MAX_JOB_CONTEXTS_COUNT we reserve for the foreground app. */ int FG_JOB_COUNT = DEFAULT_FG_JOB_COUNT; /** * The maximum number of background jobs we allow when the system is in a normal * memory state. */ int BG_NORMAL_JOB_COUNT = DEFAULT_BG_NORMAL_JOB_COUNT; /** * The maximum number of background jobs we allow when the system is in a moderate * memory state. */ int BG_MODERATE_JOB_COUNT = DEFAULT_BG_MODERATE_JOB_COUNT; /** * The maximum number of background jobs we allow when the system is in a low * memory state. */ int BG_LOW_JOB_COUNT = DEFAULT_BG_LOW_JOB_COUNT; /** * The maximum number of background jobs we allow when the system is in a critical * memory state. */ int BG_CRITICAL_JOB_COUNT = DEFAULT_BG_CRITICAL_JOB_COUNT; /** * The maximum number of times we allow a job to have itself rescheduled before * giving up on it, for standard jobs. */ int MAX_STANDARD_RESCHEDULE_COUNT = DEFAULT_MAX_STANDARD_RESCHEDULE_COUNT; /** * The maximum number of times we allow a job to have itself rescheduled before * giving up on it, for jobs that are executing work. */ int MAX_WORK_RESCHEDULE_COUNT = DEFAULT_MAX_WORK_RESCHEDULE_COUNT; /** * The minimum backoff time to allow for linear backoff. */ long MIN_LINEAR_BACKOFF_TIME = DEFAULT_MIN_LINEAR_BACKOFF_TIME; /** * The minimum backoff time to allow for exponential backoff. */ long MIN_EXP_BACKOFF_TIME = DEFAULT_MIN_EXP_BACKOFF_TIME; private ContentResolver mResolver; private final KeyValueListParser mParser = new KeyValueListParser(','); public Constants(Handler handler) { super(handler); } public void start(ContentResolver resolver) { mResolver = resolver; mResolver.registerContentObserver(Settings.Global.getUriFor( Settings.Global.JOB_SCHEDULER_CONSTANTS), false, this); updateConstants(); } @Override public void onChange(boolean selfChange, Uri uri) { updateConstants(); } private void updateConstants() { synchronized (mLock) { try { mParser.setString(Settings.Global.getString(mResolver, Settings.Global.JOB_SCHEDULER_CONSTANTS)); } catch (IllegalArgumentException e) { // Failed to parse the settings string, log this and move on // with defaults. Slog.e(TAG, "Bad jobscheduler settings", e); } MIN_IDLE_COUNT = mParser.getInt(KEY_MIN_IDLE_COUNT, DEFAULT_MIN_IDLE_COUNT); MIN_CHARGING_COUNT = mParser.getInt(KEY_MIN_CHARGING_COUNT, DEFAULT_MIN_CHARGING_COUNT); MIN_BATTERY_NOT_LOW_COUNT = mParser.getInt(KEY_MIN_BATTERY_NOT_LOW_COUNT, DEFAULT_MIN_BATTERY_NOT_LOW_COUNT); MIN_STORAGE_NOT_LOW_COUNT = mParser.getInt(KEY_MIN_STORAGE_NOT_LOW_COUNT, DEFAULT_MIN_STORAGE_NOT_LOW_COUNT); MIN_CONNECTIVITY_COUNT = mParser.getInt(KEY_MIN_CONNECTIVITY_COUNT, DEFAULT_MIN_CONNECTIVITY_COUNT); MIN_CONTENT_COUNT = mParser.getInt(KEY_MIN_CONTENT_COUNT, DEFAULT_MIN_CONTENT_COUNT); MIN_READY_JOBS_COUNT = mParser.getInt(KEY_MIN_READY_JOBS_COUNT, DEFAULT_MIN_READY_JOBS_COUNT); HEAVY_USE_FACTOR = mParser.getFloat(KEY_HEAVY_USE_FACTOR, DEFAULT_HEAVY_USE_FACTOR); MODERATE_USE_FACTOR = mParser.getFloat(KEY_MODERATE_USE_FACTOR, DEFAULT_MODERATE_USE_FACTOR); FG_JOB_COUNT = mParser.getInt(KEY_FG_JOB_COUNT, DEFAULT_FG_JOB_COUNT); BG_NORMAL_JOB_COUNT = mParser.getInt(KEY_BG_NORMAL_JOB_COUNT, DEFAULT_BG_NORMAL_JOB_COUNT); if ((FG_JOB_COUNT+BG_NORMAL_JOB_COUNT) > MAX_JOB_CONTEXTS_COUNT) { BG_NORMAL_JOB_COUNT = MAX_JOB_CONTEXTS_COUNT - FG_JOB_COUNT; } BG_MODERATE_JOB_COUNT = mParser.getInt(KEY_BG_MODERATE_JOB_COUNT, DEFAULT_BG_MODERATE_JOB_COUNT); if ((FG_JOB_COUNT+BG_MODERATE_JOB_COUNT) > MAX_JOB_CONTEXTS_COUNT) { BG_MODERATE_JOB_COUNT = MAX_JOB_CONTEXTS_COUNT - FG_JOB_COUNT; } BG_LOW_JOB_COUNT = mParser.getInt(KEY_BG_LOW_JOB_COUNT, DEFAULT_BG_LOW_JOB_COUNT); if ((FG_JOB_COUNT+BG_LOW_JOB_COUNT) > MAX_JOB_CONTEXTS_COUNT) { BG_LOW_JOB_COUNT = MAX_JOB_CONTEXTS_COUNT - FG_JOB_COUNT; } BG_CRITICAL_JOB_COUNT = mParser.getInt(KEY_BG_CRITICAL_JOB_COUNT, DEFAULT_BG_CRITICAL_JOB_COUNT); if ((FG_JOB_COUNT+BG_CRITICAL_JOB_COUNT) > MAX_JOB_CONTEXTS_COUNT) { BG_CRITICAL_JOB_COUNT = MAX_JOB_CONTEXTS_COUNT - FG_JOB_COUNT; } MAX_STANDARD_RESCHEDULE_COUNT = mParser.getInt(KEY_MAX_STANDARD_RESCHEDULE_COUNT, DEFAULT_MAX_STANDARD_RESCHEDULE_COUNT); MAX_WORK_RESCHEDULE_COUNT = mParser.getInt(KEY_MAX_WORK_RESCHEDULE_COUNT, DEFAULT_MAX_WORK_RESCHEDULE_COUNT); MIN_LINEAR_BACKOFF_TIME = mParser.getLong(KEY_MIN_LINEAR_BACKOFF_TIME, DEFAULT_MIN_LINEAR_BACKOFF_TIME); MIN_EXP_BACKOFF_TIME = mParser.getLong(KEY_MIN_EXP_BACKOFF_TIME, DEFAULT_MIN_EXP_BACKOFF_TIME); } } void dump(PrintWriter pw) { pw.println(" Settings:"); pw.print(" "); pw.print(KEY_MIN_IDLE_COUNT); pw.print("="); pw.print(MIN_IDLE_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MIN_CHARGING_COUNT); pw.print("="); pw.print(MIN_CHARGING_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MIN_BATTERY_NOT_LOW_COUNT); pw.print("="); pw.print(MIN_BATTERY_NOT_LOW_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MIN_STORAGE_NOT_LOW_COUNT); pw.print("="); pw.print(MIN_STORAGE_NOT_LOW_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MIN_CONNECTIVITY_COUNT); pw.print("="); pw.print(MIN_CONNECTIVITY_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MIN_CONTENT_COUNT); pw.print("="); pw.print(MIN_CONTENT_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MIN_READY_JOBS_COUNT); pw.print("="); pw.print(MIN_READY_JOBS_COUNT); pw.println(); pw.print(" "); pw.print(KEY_HEAVY_USE_FACTOR); pw.print("="); pw.print(HEAVY_USE_FACTOR); pw.println(); pw.print(" "); pw.print(KEY_MODERATE_USE_FACTOR); pw.print("="); pw.print(MODERATE_USE_FACTOR); pw.println(); pw.print(" "); pw.print(KEY_FG_JOB_COUNT); pw.print("="); pw.print(FG_JOB_COUNT); pw.println(); pw.print(" "); pw.print(KEY_BG_NORMAL_JOB_COUNT); pw.print("="); pw.print(BG_NORMAL_JOB_COUNT); pw.println(); pw.print(" "); pw.print(KEY_BG_MODERATE_JOB_COUNT); pw.print("="); pw.print(BG_MODERATE_JOB_COUNT); pw.println(); pw.print(" "); pw.print(KEY_BG_LOW_JOB_COUNT); pw.print("="); pw.print(BG_LOW_JOB_COUNT); pw.println(); pw.print(" "); pw.print(KEY_BG_CRITICAL_JOB_COUNT); pw.print("="); pw.print(BG_CRITICAL_JOB_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MAX_STANDARD_RESCHEDULE_COUNT); pw.print("="); pw.print(MAX_STANDARD_RESCHEDULE_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MAX_WORK_RESCHEDULE_COUNT); pw.print("="); pw.print(MAX_WORK_RESCHEDULE_COUNT); pw.println(); pw.print(" "); pw.print(KEY_MIN_LINEAR_BACKOFF_TIME); pw.print("="); pw.print(MIN_LINEAR_BACKOFF_TIME); pw.println(); pw.print(" "); pw.print(KEY_MIN_EXP_BACKOFF_TIME); pw.print("="); pw.print(MIN_EXP_BACKOFF_TIME); pw.println(); } } final Constants mConstants; static final Comparator mEnqueueTimeComparator = (o1, o2) -> { if (o1.enqueueTime < o2.enqueueTime) { return -1; } return o1.enqueueTime > o2.enqueueTime ? 1 : 0; }; static void addOrderedItem(ArrayList array, T newItem, Comparator comparator) { int where = Collections.binarySearch(array, newItem, comparator); if (where < 0) { where = ~where; } array.add(where, newItem); } /** * Cleans up outstanding jobs when a package is removed. Even if it's being replaced later we * still clean up. On reinstall the package will have a new uid. */ private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { final String action = intent.getAction(); if (DEBUG) { Slog.d(TAG, "Receieved: " + action); } final String pkgName = getPackageName(intent); final int pkgUid = intent.getIntExtra(Intent.EXTRA_UID, -1); if (Intent.ACTION_PACKAGE_CHANGED.equals(action)) { // Purge the app's jobs if the whole package was just disabled. When this is // the case the component name will be a bare package name. if (pkgName != null && pkgUid != -1) { final String[] changedComponents = intent.getStringArrayExtra( Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST); if (changedComponents != null) { for (String component : changedComponents) { if (component.equals(pkgName)) { if (DEBUG) { Slog.d(TAG, "Package state change: " + pkgName); } try { final int userId = UserHandle.getUserId(pkgUid); IPackageManager pm = AppGlobals.getPackageManager(); final int state = pm.getApplicationEnabledSetting(pkgName, userId); if (state == COMPONENT_ENABLED_STATE_DISABLED || state == COMPONENT_ENABLED_STATE_DISABLED_USER) { if (DEBUG) { Slog.d(TAG, "Removing jobs for package " + pkgName + " in user " + userId); } cancelJobsForPackageAndUid(pkgName, pkgUid, "app disabled"); } } catch (RemoteException|IllegalArgumentException e) { /* * IllegalArgumentException means that the package doesn't exist. * This arises when PACKAGE_CHANGED broadcast delivery has lagged * behind outright uninstall, so by the time we try to act it's gone. * We don't need to act on this PACKAGE_CHANGED when this happens; * we'll get a PACKAGE_REMOVED later and clean up then. * * RemoteException can't actually happen; the package manager is * running in this same process. */ } break; } } } } else { Slog.w(TAG, "PACKAGE_CHANGED for " + pkgName + " / uid " + pkgUid); } } else if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) { // If this is an outright uninstall rather than the first half of an // app update sequence, cancel the jobs associated with the app. if (!intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) { int uidRemoved = intent.getIntExtra(Intent.EXTRA_UID, -1); if (DEBUG) { Slog.d(TAG, "Removing jobs for uid: " + uidRemoved); } cancelJobsForPackageAndUid(pkgName, uidRemoved, "app uninstalled"); } } else if (Intent.ACTION_USER_REMOVED.equals(action)) { final int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 0); if (DEBUG) { Slog.d(TAG, "Removing jobs for user: " + userId); } cancelJobsForUser(userId); } else if (Intent.ACTION_QUERY_PACKAGE_RESTART.equals(action)) { // Has this package scheduled any jobs, such that we will take action // if it were to be force-stopped? if (pkgUid != -1) { List jobsForUid; synchronized (mLock) { jobsForUid = mJobs.getJobsByUid(pkgUid); } for (int i = jobsForUid.size() - 1; i >= 0; i--) { if (jobsForUid.get(i).getSourcePackageName().equals(pkgName)) { if (DEBUG) { Slog.d(TAG, "Restart query: package " + pkgName + " at uid " + pkgUid + " has jobs"); } setResultCode(Activity.RESULT_OK); break; } } } } else if (Intent.ACTION_PACKAGE_RESTARTED.equals(action)) { // possible force-stop if (pkgUid != -1) { if (DEBUG) { Slog.d(TAG, "Removing jobs for pkg " + pkgName + " at uid " + pkgUid); } cancelJobsForPackageAndUid(pkgName, pkgUid, "app force stopped"); } } } }; private String getPackageName(Intent intent) { Uri uri = intent.getData(); String pkg = uri != null ? uri.getSchemeSpecificPart() : null; return pkg; } final private IUidObserver mUidObserver = new IUidObserver.Stub() { @Override public void onUidStateChanged(int uid, int procState, long procStateSeq) { updateUidState(uid, procState); } @Override public void onUidGone(int uid, boolean disabled) { updateUidState(uid, ActivityManager.PROCESS_STATE_CACHED_EMPTY); if (disabled) { cancelJobsForUid(uid, "uid gone"); } } @Override public void onUidActive(int uid) throws RemoteException { } @Override public void onUidIdle(int uid, boolean disabled) { if (disabled) { cancelJobsForUid(uid, "app uid idle"); } } @Override public void onUidCachedChanged(int uid, boolean cached) { } }; public Object getLock() { return mLock; } public JobStore getJobStore() { return mJobs; } @Override public void onStartUser(int userHandle) { mStartedUsers = ArrayUtils.appendInt(mStartedUsers, userHandle); // Let's kick any outstanding jobs for this user. mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget(); } @Override public void onUnlockUser(int userHandle) { // Let's kick any outstanding jobs for this user. mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget(); } @Override public void onStopUser(int userHandle) { mStartedUsers = ArrayUtils.removeInt(mStartedUsers, userHandle); } public int scheduleAsPackage(JobInfo job, JobWorkItem work, int uId, String packageName, int userId, String tag) { try { if (ActivityManager.getService().isAppStartModeDisabled(uId, job.getService().getPackageName())) { Slog.w(TAG, "Not scheduling job " + uId + ":" + job.toString() + " -- package not allowed to start"); return JobScheduler.RESULT_FAILURE; } } catch (RemoteException e) { } synchronized (mLock) { final JobStatus toCancel = mJobs.getJobByUidAndJobId(uId, job.getId()); if (work != null && toCancel != null) { // Fast path: we are adding work to an existing job, and the JobInfo is not // changing. We can just directly enqueue this work in to the job. if (toCancel.getJob().equals(job)) { toCancel.enqueueWorkLocked(ActivityManager.getService(), work); return JobScheduler.RESULT_SUCCESS; } } JobStatus jobStatus = JobStatus.createFromJobInfo(job, uId, packageName, userId, tag); if (DEBUG) Slog.d(TAG, "SCHEDULE: " + jobStatus.toShortString()); // Jobs on behalf of others don't apply to the per-app job cap if (ENFORCE_MAX_JOBS && packageName == null) { if (mJobs.countJobsForUid(uId) > MAX_JOBS_PER_APP) { Slog.w(TAG, "Too many jobs for uid " + uId); throw new IllegalStateException("Apps may not schedule more than " + MAX_JOBS_PER_APP + " distinct jobs"); } } // This may throw a SecurityException. jobStatus.prepareLocked(ActivityManager.getService()); if (toCancel != null) { cancelJobImplLocked(toCancel, jobStatus, "job rescheduled by app"); } if (work != null) { // If work has been supplied, enqueue it into the new job. jobStatus.enqueueWorkLocked(ActivityManager.getService(), work); } startTrackingJobLocked(jobStatus, toCancel); // If the job is immediately ready to run, then we can just immediately // put it in the pending list and try to schedule it. This is especially // important for jobs with a 0 deadline constraint, since they will happen a fair // amount, we want to handle them as quickly as possible, and semantically we want to // make sure we have started holding the wake lock for the job before returning to // the caller. // If the job is not yet ready to run, there is nothing more to do -- we are // now just waiting for one of its controllers to change state and schedule // the job appropriately. if (isReadyToBeExecutedLocked(jobStatus)) { // This is a new job, we can just immediately put it on the pending // list and try to run it. mJobPackageTracker.notePending(jobStatus); addOrderedItem(mPendingJobs, jobStatus, mEnqueueTimeComparator); maybeRunPendingJobsLocked(); } } return JobScheduler.RESULT_SUCCESS; } public List getPendingJobs(int uid) { synchronized (mLock) { List jobs = mJobs.getJobsByUid(uid); ArrayList outList = new ArrayList(jobs.size()); for (int i = jobs.size() - 1; i >= 0; i--) { JobStatus job = jobs.get(i); outList.add(job.getJob()); } return outList; } } public JobInfo getPendingJob(int uid, int jobId) { synchronized (mLock) { List jobs = mJobs.getJobsByUid(uid); for (int i = jobs.size() - 1; i >= 0; i--) { JobStatus job = jobs.get(i); if (job.getJobId() == jobId) { return job.getJob(); } } return null; } } void cancelJobsForUser(int userHandle) { synchronized (mLock) { final List jobsForUser = mJobs.getJobsByUser(userHandle); for (int i=0; i jobsForUid = mJobs.getJobsByUid(uid); for (int i = jobsForUid.size() - 1; i >= 0; i--) { final JobStatus job = jobsForUid.get(i); if (job.getSourcePackageName().equals(pkgName)) { cancelJobImplLocked(job, null, reason); } } } } /** * Entry point from client to cancel all jobs originating from their uid. * This will remove the job from the master list, and cancel the job if it was staged for * execution or being executed. * @param uid Uid to check against for removal of a job. * */ public void cancelJobsForUid(int uid, String reason) { if (uid == Process.SYSTEM_UID) { Slog.wtfStack(TAG, "Can't cancel all jobs for system uid"); return; } synchronized (mLock) { final List jobsForUid = mJobs.getJobsByUid(uid); for (int i=0; i 0; if (mPendingJobs.size() <= 0) { for (int i=0; i * Subclasses must define a single argument constructor that accepts the context * and passes it to super. *

* * @param context The system server context. */ public JobSchedulerService(Context context) { super(context); mHandler = new JobHandler(context.getMainLooper()); mConstants = new Constants(mHandler); mJobSchedulerStub = new JobSchedulerStub(); mJobs = JobStore.initAndGet(this); // Create the controllers. mControllers = new ArrayList(); mControllers.add(ConnectivityController.get(this)); mControllers.add(TimeController.get(this)); mControllers.add(IdleController.get(this)); mBatteryController = BatteryController.get(this); mControllers.add(mBatteryController); mStorageController = StorageController.get(this); mControllers.add(mStorageController); mControllers.add(AppIdleController.get(this)); mControllers.add(ContentObserverController.get(this)); mControllers.add(DeviceIdleJobsController.get(this)); // If the job store determined that it can't yet reschedule persisted jobs, // we need to start watching the clock. if (!mJobs.jobTimesInflatedValid()) { Slog.w(TAG, "!!! RTC not yet good; tracking time updates for job scheduling"); context.registerReceiver(mTimeSetReceiver, new IntentFilter(Intent.ACTION_TIME_CHANGED)); } } private final BroadcastReceiver mTimeSetReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if (Intent.ACTION_TIME_CHANGED.equals(intent.getAction())) { // When we reach clock sanity, recalculate the temporal windows // of all affected jobs. if (mJobs.clockNowValidToInflate(System.currentTimeMillis())) { Slog.i(TAG, "RTC now valid; recalculating persisted job windows"); // We've done our job now, so stop watching the time. context.unregisterReceiver(this); // And kick off the work to update the affected jobs, using a secondary // thread instead of chugging away here on the main looper thread. FgThread.getHandler().post(mJobTimeUpdater); } } } }; private final Runnable mJobTimeUpdater = () -> { final ArrayList toRemove = new ArrayList<>(); final ArrayList toAdd = new ArrayList<>(); synchronized (mLock) { // Note: we intentionally both look up the existing affected jobs and replace them // with recalculated ones inside the same lock lifetime. getJobStore().getRtcCorrectedJobsLocked(toAdd, toRemove); // Now, at each position [i], we have both the existing JobStatus // and the one that replaces it. final int N = toAdd.size(); for (int i = 0; i < N; i++) { final JobStatus oldJob = toRemove.get(i); final JobStatus newJob = toAdd.get(i); if (DEBUG) { Slog.v(TAG, " replacing " + oldJob + " with " + newJob); } cancelJobImplLocked(oldJob, newJob, "deferred rtc calculation"); } } }; @Override public void onStart() { publishLocalService(JobSchedulerInternal.class, new LocalService()); publishBinderService(Context.JOB_SCHEDULER_SERVICE, mJobSchedulerStub); } @Override public void onBootPhase(int phase) { if (PHASE_SYSTEM_SERVICES_READY == phase) { mConstants.start(getContext().getContentResolver()); // Register br for package removals and user removals. final IntentFilter filter = new IntentFilter(); filter.addAction(Intent.ACTION_PACKAGE_REMOVED); filter.addAction(Intent.ACTION_PACKAGE_CHANGED); filter.addAction(Intent.ACTION_PACKAGE_RESTARTED); filter.addAction(Intent.ACTION_QUERY_PACKAGE_RESTART); filter.addDataScheme("package"); getContext().registerReceiverAsUser( mBroadcastReceiver, UserHandle.ALL, filter, null, null); final IntentFilter userFilter = new IntentFilter(Intent.ACTION_USER_REMOVED); getContext().registerReceiverAsUser( mBroadcastReceiver, UserHandle.ALL, userFilter, null, null); mPowerManager = (PowerManager)getContext().getSystemService(Context.POWER_SERVICE); try { ActivityManager.getService().registerUidObserver(mUidObserver, ActivityManager.UID_OBSERVER_PROCSTATE | ActivityManager.UID_OBSERVER_GONE | ActivityManager.UID_OBSERVER_IDLE, ActivityManager.PROCESS_STATE_UNKNOWN, null); } catch (RemoteException e) { // ignored; both services live in system_server } // Remove any jobs that are not associated with any of the current users. cancelJobsForNonExistentUsers(); } else if (phase == PHASE_THIRD_PARTY_APPS_CAN_START) { synchronized (mLock) { // Let's go! mReadyToRock = true; mBatteryStats = IBatteryStats.Stub.asInterface(ServiceManager.getService( BatteryStats.SERVICE_NAME)); mLocalDeviceIdleController = LocalServices.getService(DeviceIdleController.LocalService.class); // Create the "runners". for (int i = 0; i < MAX_JOB_CONTEXTS_COUNT; i++) { mActiveServices.add( new JobServiceContext(this, mBatteryStats, mJobPackageTracker, getContext().getMainLooper())); } // Attach jobs to their controllers. mJobs.forEachJob(new JobStatusFunctor() { @Override public void process(JobStatus job) { for (int controller = 0; controller < mControllers.size(); controller++) { final StateController sc = mControllers.get(controller); sc.maybeStartTrackingJobLocked(job, null); } } }); // GO GO GO! mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget(); } } } /** * Called when we have a job status object that we need to insert in our * {@link com.android.server.job.JobStore}, and make sure all the relevant controllers know * about. */ private void startTrackingJobLocked(JobStatus jobStatus, JobStatus lastJob) { if (!jobStatus.isPreparedLocked()) { Slog.wtf(TAG, "Not yet prepared when started tracking: " + jobStatus); } jobStatus.enqueueTime = SystemClock.elapsedRealtime(); final boolean update = mJobs.add(jobStatus); if (mReadyToRock) { for (int i = 0; i < mControllers.size(); i++) { StateController controller = mControllers.get(i); if (update) { controller.maybeStopTrackingJobLocked(jobStatus, null, true); } controller.maybeStartTrackingJobLocked(jobStatus, lastJob); } } } /** * Called when we want to remove a JobStatus object that we've finished executing. Returns the * object removed. */ private boolean stopTrackingJobLocked(JobStatus jobStatus, JobStatus incomingJob, boolean writeBack) { // Deal with any remaining work items in the old job. jobStatus.stopTrackingJobLocked(ActivityManager.getService(), incomingJob); // Remove from store as well as controllers. final boolean removed = mJobs.remove(jobStatus, writeBack); if (removed && mReadyToRock) { for (int i=0; i jobs) { for (int i = jobs.size() - 1; i >= 0; i--) { JobStatus job = jobs.get(i); mJobPackageTracker.notePending(job); } } void noteJobsNonpending(List jobs) { for (int i = jobs.size() - 1; i >= 0; i--) { JobStatus job = jobs.get(i); mJobPackageTracker.noteNonpending(job); } } /** * Reschedules the given job based on the job's backoff policy. It doesn't make sense to * specify an override deadline on a failed job (the failed job will run even though it's not * ready), so we reschedule it with {@link JobStatus#NO_LATEST_RUNTIME}, but specify that any * ready job with {@link JobStatus#numFailures} > 0 will be executed. * * @param failureToReschedule Provided job status that we will reschedule. * @return A newly instantiated JobStatus with the same constraints as the last job except * with adjusted timing constraints. * * @see #maybeQueueReadyJobsForExecutionLocked */ private JobStatus getRescheduleJobForFailureLocked(JobStatus failureToReschedule) { final long elapsedNowMillis = SystemClock.elapsedRealtime(); final JobInfo job = failureToReschedule.getJob(); final long initialBackoffMillis = job.getInitialBackoffMillis(); final int backoffAttempts = failureToReschedule.getNumFailures() + 1; long delayMillis; if (failureToReschedule.hasWorkLocked()) { if (backoffAttempts > mConstants.MAX_WORK_RESCHEDULE_COUNT) { Slog.w(TAG, "Not rescheduling " + failureToReschedule + ": attempt #" + backoffAttempts + " > work limit " + mConstants.MAX_STANDARD_RESCHEDULE_COUNT); return null; } } else if (backoffAttempts > mConstants.MAX_STANDARD_RESCHEDULE_COUNT) { Slog.w(TAG, "Not rescheduling " + failureToReschedule + ": attempt #" + backoffAttempts + " > std limit " + mConstants.MAX_STANDARD_RESCHEDULE_COUNT); return null; } switch (job.getBackoffPolicy()) { case JobInfo.BACKOFF_POLICY_LINEAR: { long backoff = initialBackoffMillis; if (backoff < mConstants.MIN_LINEAR_BACKOFF_TIME) { backoff = mConstants.MIN_LINEAR_BACKOFF_TIME; } delayMillis = backoff * backoffAttempts; } break; default: if (DEBUG) { Slog.v(TAG, "Unrecognised back-off policy, defaulting to exponential."); } case JobInfo.BACKOFF_POLICY_EXPONENTIAL: { long backoff = initialBackoffMillis; if (backoff < mConstants.MIN_EXP_BACKOFF_TIME) { backoff = mConstants.MIN_EXP_BACKOFF_TIME; } delayMillis = (long) Math.scalb(backoff, backoffAttempts - 1); } break; } delayMillis = Math.min(delayMillis, JobInfo.MAX_BACKOFF_DELAY_MILLIS); JobStatus newJob = new JobStatus(failureToReschedule, elapsedNowMillis + delayMillis, JobStatus.NO_LATEST_RUNTIME, backoffAttempts, failureToReschedule.getLastSuccessfulRunTime(), System.currentTimeMillis()); for (int ic=0; ic newReadyJobs; @Override public void process(JobStatus job) { if (isReadyToBeExecutedLocked(job)) { if (DEBUG) { Slog.d(TAG, " queued " + job.toShortString()); } if (newReadyJobs == null) { newReadyJobs = new ArrayList(); } newReadyJobs.add(job); } } public void postProcess() { if (newReadyJobs != null) { noteJobsPending(newReadyJobs); mPendingJobs.addAll(newReadyJobs); if (mPendingJobs.size() > 1) { mPendingJobs.sort(mEnqueueTimeComparator); } } newReadyJobs = null; } } private final ReadyJobQueueFunctor mReadyQueueFunctor = new ReadyJobQueueFunctor(); /** * The state of at least one job has changed. Here is where we could enforce various * policies on when we want to execute jobs. * Right now the policy is such: * If >1 of the ready jobs is idle mode we send all of them off * if more than 2 network connectivity jobs are ready we send them all off. * If more than 4 jobs total are ready we send them all off. * TODO: It would be nice to consolidate these sort of high-level policies somewhere. */ final class MaybeReadyJobQueueFunctor implements JobStatusFunctor { int chargingCount; int batteryNotLowCount; int storageNotLowCount; int idleCount; int backoffCount; int connectivityCount; int contentCount; List runnableJobs; public MaybeReadyJobQueueFunctor() { reset(); } // Functor method invoked for each job via JobStore.forEachJob() @Override public void process(JobStatus job) { if (isReadyToBeExecutedLocked(job)) { try { if (ActivityManager.getService().isAppStartModeDisabled(job.getUid(), job.getJob().getService().getPackageName())) { Slog.w(TAG, "Aborting job " + job.getUid() + ":" + job.getJob().toString() + " -- package not allowed to start"); mHandler.obtainMessage(MSG_STOP_JOB, job).sendToTarget(); return; } } catch (RemoteException e) { } if (job.getNumFailures() > 0) { backoffCount++; } if (job.hasIdleConstraint()) { idleCount++; } if (job.hasConnectivityConstraint()) { connectivityCount++; } if (job.hasChargingConstraint()) { chargingCount++; } if (job.hasBatteryNotLowConstraint()) { batteryNotLowCount++; } if (job.hasStorageNotLowConstraint()) { storageNotLowCount++; } if (job.hasContentTriggerConstraint()) { contentCount++; } if (runnableJobs == null) { runnableJobs = new ArrayList<>(); } runnableJobs.add(job); } } public void postProcess() { if (backoffCount > 0 || idleCount >= mConstants.MIN_IDLE_COUNT || connectivityCount >= mConstants.MIN_CONNECTIVITY_COUNT || chargingCount >= mConstants.MIN_CHARGING_COUNT || batteryNotLowCount >= mConstants.MIN_BATTERY_NOT_LOW_COUNT || storageNotLowCount >= mConstants.MIN_STORAGE_NOT_LOW_COUNT || contentCount >= mConstants.MIN_CONTENT_COUNT || (runnableJobs != null && runnableJobs.size() >= mConstants.MIN_READY_JOBS_COUNT)) { if (DEBUG) { Slog.d(TAG, "maybeQueueReadyJobsForExecutionLocked: Running jobs."); } noteJobsPending(runnableJobs); mPendingJobs.addAll(runnableJobs); if (mPendingJobs.size() > 1) { mPendingJobs.sort(mEnqueueTimeComparator); } } else { if (DEBUG) { Slog.d(TAG, "maybeQueueReadyJobsForExecutionLocked: Not running anything."); } } // Be ready for next time reset(); } private void reset() { chargingCount = 0; idleCount = 0; backoffCount = 0; connectivityCount = 0; batteryNotLowCount = 0; storageNotLowCount = 0; contentCount = 0; runnableJobs = null; } } private final MaybeReadyJobQueueFunctor mMaybeQueueFunctor = new MaybeReadyJobQueueFunctor(); private void maybeQueueReadyJobsForExecutionLocked() { if (DEBUG) Slog.d(TAG, "Maybe queuing ready jobs..."); noteJobsNonpending(mPendingJobs); mPendingJobs.clear(); stopNonReadyActiveJobsLocked(); mJobs.forEachJob(mMaybeQueueFunctor); mMaybeQueueFunctor.postProcess(); } /** * Criteria for moving a job into the pending queue: * - It's ready. * - It's not pending. * - It's not already running on a JSC. * - The user that requested the job is running. * - The component is enabled and runnable. */ private boolean isReadyToBeExecutedLocked(JobStatus job) { final boolean jobReady = job.isReady(); if (DEBUG) { Slog.v(TAG, "isReadyToBeExecutedLocked: " + job.toShortString() + " ready=" + jobReady); } // This is a condition that is very likely to be false (most jobs that are // scheduled are sitting there, not ready yet) and very cheap to check (just // a few conditions on data in JobStatus). if (!jobReady) { return false; } final boolean jobExists = mJobs.containsJob(job); final int userId = job.getUserId(); final boolean userStarted = ArrayUtils.contains(mStartedUsers, userId); if (DEBUG) { Slog.v(TAG, "isReadyToBeExecutedLocked: " + job.toShortString() + " exists=" + jobExists + " userStarted=" + userStarted); } // These are also fairly cheap to check, though they typically will not // be conditions we fail. if (!jobExists || !userStarted) { return false; } final boolean jobPending = mPendingJobs.contains(job); final boolean jobActive = isCurrentlyActiveLocked(job); if (DEBUG) { Slog.v(TAG, "isReadyToBeExecutedLocked: " + job.toShortString() + " pending=" + jobPending + " active=" + jobActive); } // These can be a little more expensive (especially jobActive, since we need to // go through the array of all potentially active jobs), so we are doing them // later... but still before checking with the package manager! if (jobPending || jobActive) { return false; } final boolean componentPresent; try { componentPresent = (AppGlobals.getPackageManager().getServiceInfo( job.getServiceComponent(), PackageManager.MATCH_DEBUG_TRIAGED_MISSING, userId) != null); } catch (RemoteException e) { throw e.rethrowAsRuntimeException(); } if (DEBUG) { Slog.v(TAG, "isReadyToBeExecutedLocked: " + job.toShortString() + " componentPresent=" + componentPresent); } // Everything else checked out so far, so this is the final yes/no check return componentPresent; } /** * Reconcile jobs in the pending queue against available execution contexts. * A controller can force a job into the pending queue even if it's already running, but * here is where we decide whether to actually execute it. */ private void maybeRunPendingJobsLocked() { if (DEBUG) { Slog.d(TAG, "pending queue: " + mPendingJobs.size() + " jobs."); } assignJobsToContextsLocked(); reportActiveLocked(); } private int adjustJobPriority(int curPriority, JobStatus job) { if (curPriority < JobInfo.PRIORITY_TOP_APP) { float factor = mJobPackageTracker.getLoadFactor(job); if (factor >= mConstants.HEAVY_USE_FACTOR) { curPriority += JobInfo.PRIORITY_ADJ_ALWAYS_RUNNING; } else if (factor >= mConstants.MODERATE_USE_FACTOR) { curPriority += JobInfo.PRIORITY_ADJ_OFTEN_RUNNING; } } return curPriority; } private int evaluateJobPriorityLocked(JobStatus job) { int priority = job.getPriority(); if (priority >= JobInfo.PRIORITY_FOREGROUND_APP) { return adjustJobPriority(priority, job); } int override = mUidPriorityOverride.get(job.getSourceUid(), 0); if (override != 0) { return adjustJobPriority(override, job); } return adjustJobPriority(priority, job); } /** * Takes jobs from pending queue and runs them on available contexts. * If no contexts are available, preempts lower priority jobs to * run higher priority ones. * Lock on mJobs before calling this function. */ private void assignJobsToContextsLocked() { if (DEBUG) { Slog.d(TAG, printPendingQueue()); } int memLevel; try { memLevel = ActivityManager.getService().getMemoryTrimLevel(); } catch (RemoteException e) { memLevel = ProcessStats.ADJ_MEM_FACTOR_NORMAL; } switch (memLevel) { case ProcessStats.ADJ_MEM_FACTOR_MODERATE: mMaxActiveJobs = mConstants.BG_MODERATE_JOB_COUNT; break; case ProcessStats.ADJ_MEM_FACTOR_LOW: mMaxActiveJobs = mConstants.BG_LOW_JOB_COUNT; break; case ProcessStats.ADJ_MEM_FACTOR_CRITICAL: mMaxActiveJobs = mConstants.BG_CRITICAL_JOB_COUNT; break; default: mMaxActiveJobs = mConstants.BG_NORMAL_JOB_COUNT; break; } JobStatus[] contextIdToJobMap = mTmpAssignContextIdToJobMap; boolean[] act = mTmpAssignAct; int[] preferredUidForContext = mTmpAssignPreferredUidForContext; int numActive = 0; int numForeground = 0; for (int i=0; i= JobInfo.PRIORITY_TOP_APP) { numForeground++; } } act[i] = false; preferredUidForContext[i] = js.getPreferredUid(); } if (DEBUG) { Slog.d(TAG, printContextIdToJobMap(contextIdToJobMap, "running jobs initial")); } for (int i=0; i= JobInfo.PRIORITY_TOP_APP && numForeground < mConstants.FG_JOB_COUNT)) && (preferredUid == nextPending.getUid() || preferredUid == JobServiceContext.NO_PREFERRED_UID)) { // This slot is free, and we haven't yet hit the limit on // concurrent jobs... we can just throw the job in to here. minPriorityContextId = j; break; } // No job on this context, but nextPending can't run here because // the context has a preferred Uid or we have reached the limit on // concurrent jobs. continue; } if (job.getUid() != nextPending.getUid()) { continue; } if (evaluateJobPriorityLocked(job) >= nextPending.lastEvaluatedPriority) { continue; } if (minPriority > nextPending.lastEvaluatedPriority) { minPriority = nextPending.lastEvaluatedPriority; minPriorityContextId = j; } } if (minPriorityContextId != -1) { contextIdToJobMap[minPriorityContextId] = nextPending; act[minPriorityContextId] = true; numActive++; if (priority >= JobInfo.PRIORITY_TOP_APP) { numForeground++; } } } if (DEBUG) { Slog.d(TAG, printContextIdToJobMap(contextIdToJobMap, "running jobs final")); } mJobPackageTracker.noteConcurrency(numActive, numForeground); for (int i=0; i getSystemScheduledPendingJobs() { synchronized (mLock) { final List pendingJobs = new ArrayList(); mJobs.forEachJob(Process.SYSTEM_UID, new JobStatusFunctor() { @Override public void process(JobStatus job) { if (job.getJob().isPeriodic() || !isCurrentlyActiveLocked(job)) { pendingJobs.add(job.getJob()); } } }); return pendingJobs; } } @Override public void addBackingUpUid(int uid) { synchronized (mLock) { // No need to actually do anything here, since for a full backup the // activity manager will kill the process which will kill the job (and // cause it to restart, but now it can't run). mBackingUpUids.put(uid, uid); } } @Override public void removeBackingUpUid(int uid) { synchronized (mLock) { mBackingUpUids.delete(uid); // If there are any jobs for this uid, we need to rebuild the pending list // in case they are now ready to run. if (mJobs.countJobsForUid(uid) > 0) { mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget(); } } } @Override public void clearAllBackingUpUids() { synchronized (mLock) { if (mBackingUpUids.size() > 0) { mBackingUpUids.clear(); mHandler.obtainMessage(MSG_CHECK_JOB).sendToTarget(); } } } @Override public JobStorePersistStats getPersistStats() { synchronized (mLock) { return new JobStorePersistStats(mJobs.getPersistStats()); } } } /** * Binder stub trampoline implementation */ final class JobSchedulerStub extends IJobScheduler.Stub { /** Cache determination of whether a given app can persist jobs * key is uid of the calling app; value is undetermined/true/false */ private final SparseArray mPersistCache = new SparseArray(); // Enforce that only the app itself (or shared uid participant) can schedule a // job that runs one of the app's services, as well as verifying that the // named service properly requires the BIND_JOB_SERVICE permission private void enforceValidJobRequest(int uid, JobInfo job) { final IPackageManager pm = AppGlobals.getPackageManager(); final ComponentName service = job.getService(); try { ServiceInfo si = pm.getServiceInfo(service, PackageManager.MATCH_DIRECT_BOOT_AWARE | PackageManager.MATCH_DIRECT_BOOT_UNAWARE, UserHandle.getUserId(uid)); if (si == null) { throw new IllegalArgumentException("No such service " + service); } if (si.applicationInfo.uid != uid) { throw new IllegalArgumentException("uid " + uid + " cannot schedule job in " + service.getPackageName()); } if (!JobService.PERMISSION_BIND.equals(si.permission)) { throw new IllegalArgumentException("Scheduled service " + service + " does not require android.permission.BIND_JOB_SERVICE permission"); } } catch (RemoteException e) { // Can't happen; the Package Manager is in this same process } } private boolean canPersistJobs(int pid, int uid) { // If we get this far we're good to go; all we need to do now is check // whether the app is allowed to persist its scheduled work. final boolean canPersist; synchronized (mPersistCache) { Boolean cached = mPersistCache.get(uid); if (cached != null) { canPersist = cached.booleanValue(); } else { // Persisting jobs is tantamount to running at boot, so we permit // it when the app has declared that it uses the RECEIVE_BOOT_COMPLETED // permission int result = getContext().checkPermission( android.Manifest.permission.RECEIVE_BOOT_COMPLETED, pid, uid); canPersist = (result == PackageManager.PERMISSION_GRANTED); mPersistCache.put(uid, canPersist); } } return canPersist; } // IJobScheduler implementation @Override public int schedule(JobInfo job) throws RemoteException { if (DEBUG) { Slog.d(TAG, "Scheduling job: " + job.toString()); } final int pid = Binder.getCallingPid(); final int uid = Binder.getCallingUid(); enforceValidJobRequest(uid, job); if (job.isPersisted()) { if (!canPersistJobs(pid, uid)) { throw new IllegalArgumentException("Error: requested job be persisted without" + " holding RECEIVE_BOOT_COMPLETED permission."); } } if ((job.getFlags() & JobInfo.FLAG_WILL_BE_FOREGROUND) != 0) { getContext().enforceCallingOrSelfPermission( android.Manifest.permission.CONNECTIVITY_INTERNAL, TAG); } long ident = Binder.clearCallingIdentity(); try { return JobSchedulerService.this.scheduleAsPackage(job, null, uid, null, -1, null); } finally { Binder.restoreCallingIdentity(ident); } } // IJobScheduler implementation @Override public int enqueue(JobInfo job, JobWorkItem work) throws RemoteException { if (DEBUG) { Slog.d(TAG, "Enqueueing job: " + job.toString() + " work: " + work); } final int pid = Binder.getCallingPid(); final int uid = Binder.getCallingUid(); enforceValidJobRequest(uid, job); if (job.isPersisted()) { throw new IllegalArgumentException("Can't enqueue work for persisted jobs"); } if (work == null) { throw new NullPointerException("work is null"); } if ((job.getFlags() & JobInfo.FLAG_WILL_BE_FOREGROUND) != 0) { getContext().enforceCallingOrSelfPermission( android.Manifest.permission.CONNECTIVITY_INTERNAL, TAG); } long ident = Binder.clearCallingIdentity(); try { return JobSchedulerService.this.scheduleAsPackage(job, work, uid, null, -1, null); } finally { Binder.restoreCallingIdentity(ident); } } @Override public int scheduleAsPackage(JobInfo job, String packageName, int userId, String tag) throws RemoteException { final int callerUid = Binder.getCallingUid(); if (DEBUG) { Slog.d(TAG, "Caller uid " + callerUid + " scheduling job: " + job.toString() + " on behalf of " + packageName); } if (packageName == null) { throw new NullPointerException("Must specify a package for scheduleAsPackage()"); } int mayScheduleForOthers = getContext().checkCallingOrSelfPermission( android.Manifest.permission.UPDATE_DEVICE_STATS); if (mayScheduleForOthers != PackageManager.PERMISSION_GRANTED) { throw new SecurityException("Caller uid " + callerUid + " not permitted to schedule jobs for other apps"); } if ((job.getFlags() & JobInfo.FLAG_WILL_BE_FOREGROUND) != 0) { getContext().enforceCallingOrSelfPermission( android.Manifest.permission.CONNECTIVITY_INTERNAL, TAG); } long ident = Binder.clearCallingIdentity(); try { return JobSchedulerService.this.scheduleAsPackage(job, null, callerUid, packageName, userId, tag); } finally { Binder.restoreCallingIdentity(ident); } } @Override public List getAllPendingJobs() throws RemoteException { final int uid = Binder.getCallingUid(); long ident = Binder.clearCallingIdentity(); try { return JobSchedulerService.this.getPendingJobs(uid); } finally { Binder.restoreCallingIdentity(ident); } } @Override public JobInfo getPendingJob(int jobId) throws RemoteException { final int uid = Binder.getCallingUid(); long ident = Binder.clearCallingIdentity(); try { return JobSchedulerService.this.getPendingJob(uid, jobId); } finally { Binder.restoreCallingIdentity(ident); } } @Override public void cancelAll() throws RemoteException { final int uid = Binder.getCallingUid(); long ident = Binder.clearCallingIdentity(); try { JobSchedulerService.this.cancelJobsForUid(uid, "cancelAll() called by app"); } finally { Binder.restoreCallingIdentity(ident); } } @Override public void cancel(int jobId) throws RemoteException { final int uid = Binder.getCallingUid(); long ident = Binder.clearCallingIdentity(); try { JobSchedulerService.this.cancelJob(uid, jobId); } finally { Binder.restoreCallingIdentity(ident); } } /** * "dumpsys" infrastructure */ @Override public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { if (!DumpUtils.checkDumpAndUsageStatsPermission(getContext(), TAG, pw)) return; long identityToken = Binder.clearCallingIdentity(); try { JobSchedulerService.this.dumpInternal(pw, args); } finally { Binder.restoreCallingIdentity(identityToken); } } @Override public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err, String[] args, ShellCallback callback, ResultReceiver resultReceiver) { (new JobSchedulerShellCommand(JobSchedulerService.this)).exec( this, in, out, err, args, callback, resultReceiver); } }; // Shell command infrastructure: run the given job immediately int executeRunCommand(String pkgName, int userId, int jobId, boolean force) { if (DEBUG) { Slog.v(TAG, "executeRunCommand(): " + pkgName + "/" + userId + " " + jobId + " f=" + force); } try { final int uid = AppGlobals.getPackageManager().getPackageUid(pkgName, 0, userId != UserHandle.USER_ALL ? userId : UserHandle.USER_SYSTEM); if (uid < 0) { return JobSchedulerShellCommand.CMD_ERR_NO_PACKAGE; } synchronized (mLock) { final JobStatus js = mJobs.getJobByUidAndJobId(uid, jobId); if (js == null) { return JobSchedulerShellCommand.CMD_ERR_NO_JOB; } js.overrideState = (force) ? JobStatus.OVERRIDE_FULL : JobStatus.OVERRIDE_SOFT; if (!js.isConstraintsSatisfied()) { js.overrideState = 0; return JobSchedulerShellCommand.CMD_ERR_CONSTRAINTS; } queueReadyJobsForExecutionLocked(); maybeRunPendingJobsLocked(); } } catch (RemoteException e) { // can't happen } return 0; } // Shell command infrastructure: immediately timeout currently executing jobs int executeTimeoutCommand(PrintWriter pw, String pkgName, int userId, boolean hasJobId, int jobId) { if (DEBUG) { Slog.v(TAG, "executeTimeoutCommand(): " + pkgName + "/" + userId + " " + jobId); } synchronized (mLock) { boolean foundSome = false; for (int i=0; i= 0) { if (printed) { pw.print(" "); } printed = true; pw.println("backing-up"); } boolean componentPresent = false; try { componentPresent = (AppGlobals.getPackageManager().getServiceInfo( js.getServiceComponent(), PackageManager.MATCH_DEBUG_TRIAGED_MISSING, js.getUserId()) != null); } catch (RemoteException e) { } if (!componentPresent) { if (printed) { pw.print(" "); } printed = true; pw.println("no-component"); } if (js.isReady()) { if (printed) { pw.print(" "); } printed = true; pw.println("ready"); } if (!printed) { pw.print("waiting"); } pw.println(); } } catch (RemoteException e) { // can't happen } return 0; } private String printContextIdToJobMap(JobStatus[] map, String initial) { StringBuilder s = new StringBuilder(initial + ": "); for (int i=0; i it = mPendingJobs.iterator(); while (it.hasNext()) { JobStatus js = it.next(); s.append("(") .append(js.getJob().getId()) .append(", ") .append(js.getUid()) .append(") "); } return s.toString(); } static void dumpHelp(PrintWriter pw) { pw.println("Job Scheduler (jobscheduler) dump options:"); pw.println(" [-h] [package] ..."); pw.println(" -h: print this help"); pw.println(" [package] is an optional package name to limit the output to."); } void dumpInternal(final PrintWriter pw, String[] args) { int filterUid = -1; if (!ArrayUtils.isEmpty(args)) { int opti = 0; while (opti < args.length) { String arg = args[opti]; if ("-h".equals(arg)) { dumpHelp(pw); return; } else if ("-a".equals(arg)) { // Ignore, we always dump all. } else if (arg.length() > 0 && arg.charAt(0) == '-') { pw.println("Unknown option: " + arg); return; } else { break; } opti++; } if (opti < args.length) { String pkg = args[opti]; try { filterUid = getContext().getPackageManager().getPackageUid(pkg, PackageManager.MATCH_ANY_USER); } catch (NameNotFoundException ignored) { pw.println("Invalid package: " + pkg); return; } } } final int filterUidFinal = UserHandle.getAppId(filterUid); final long nowElapsed = SystemClock.elapsedRealtime(); final long nowUptime = SystemClock.uptimeMillis(); synchronized (mLock) { mConstants.dump(pw); pw.println(); pw.println("Started users: " + Arrays.toString(mStartedUsers)); pw.print("Registered "); pw.print(mJobs.size()); pw.println(" jobs:"); if (mJobs.size() > 0) { final List jobs = mJobs.mJobSet.getAllJobs(); Collections.sort(jobs, new Comparator() { @Override public int compare(JobStatus o1, JobStatus o2) { int uid1 = o1.getUid(); int uid2 = o2.getUid(); int id1 = o1.getJobId(); int id2 = o2.getJobId(); if (uid1 != uid2) { return uid1 < uid2 ? -1 : 1; } return id1 < id2 ? -1 : (id1 > id2 ? 1 : 0); } }); for (JobStatus job : jobs) { pw.print(" JOB #"); job.printUniqueId(pw); pw.print(": "); pw.println(job.toShortStringExceptUniqueId()); // Skip printing details if the caller requested a filter if (!job.shouldDump(filterUidFinal)) { continue; } job.dump(pw, " ", true, nowElapsed); pw.print(" Ready: "); pw.print(isReadyToBeExecutedLocked(job)); pw.print(" (job="); pw.print(job.isReady()); pw.print(" user="); pw.print(ArrayUtils.contains(mStartedUsers, job.getUserId())); pw.print(" !pending="); pw.print(!mPendingJobs.contains(job)); pw.print(" !active="); pw.print(!isCurrentlyActiveLocked(job)); pw.print(" !backingup="); pw.print(!(mBackingUpUids.indexOfKey(job.getSourceUid()) >= 0)); pw.print(" comp="); boolean componentPresent = false; try { componentPresent = (AppGlobals.getPackageManager().getServiceInfo( job.getServiceComponent(), PackageManager.MATCH_DEBUG_TRIAGED_MISSING, job.getUserId()) != null); } catch (RemoteException e) { } pw.print(componentPresent); pw.println(")"); } } else { pw.println(" None."); } for (int i=0; i 0) { pw.println(); pw.println("Backing up uids:"); boolean first = true; for (int i = 0; i < mBackingUpUids.size(); i++) { int uid = mBackingUpUids.keyAt(i); if (filterUidFinal == -1 || filterUidFinal == UserHandle.getAppId(uid)) { if (first) { pw.print(" "); first = false; } else { pw.print(", "); } pw.print(UserHandle.formatUid(uid)); } } pw.println(); } pw.println(); mJobPackageTracker.dump(pw, "", filterUidFinal); pw.println(); if (mJobPackageTracker.dumpHistory(pw, "", filterUidFinal)) { pw.println(); } pw.println("Pending queue:"); for (int i=0; i