+ * The OnAlarmListener's {@link OnAlarmListener#onAlarm() onAlarm()} method will be + * invoked via the specified target Handler, or on the application's main looper + * if {@code null} is passed as the {@code targetHandler} parameter. + * + * @hide + */ + public void set(int type, long triggerAtMillis, long windowMillis, long intervalMillis, + String tag, OnAlarmListener listener, Handler targetHandler, WorkSource workSource) { + setImpl(type, triggerAtMillis, windowMillis, intervalMillis, 0, null, listener, tag, + targetHandler, workSource, null); + } + /** * Direct callback version of {@link #set(int, long, long, long, PendingIntent, WorkSource)}. * Note that repeating alarms must use the PendingIntent variant, not an OnAlarmListener. diff --git a/core/java/android/app/job/JobInfo.java b/core/java/android/app/job/JobInfo.java index 61790ea92ed9d..63c1dbb99d824 100644 --- a/core/java/android/app/job/JobInfo.java +++ b/core/java/android/app/job/JobInfo.java @@ -192,7 +192,8 @@ public class JobInfo implements Parcelable { private final int flags; /** - * Unique job id associated with this class. This is assigned to your job by the scheduler. + * Unique job id associated with this application (uid). This is the same job ID + * you supplied in the {@link Builder} constructor. */ public int getId() { return jobId; @@ -524,9 +525,9 @@ public class JobInfo implements Parcelable { /** Builder class for constructing {@link JobInfo} objects. */ public static final class Builder { - private int mJobId; + private final int mJobId; + private final ComponentName mJobService; private PersistableBundle mExtras = PersistableBundle.EMPTY; - private ComponentName mJobService; private int mPriority = PRIORITY_DEFAULT; private int mFlags; // Requirements. @@ -553,11 +554,15 @@ public class JobInfo implements Parcelable { private boolean mBackoffPolicySet = false; /** + * Initialize a new Builder to construct a {@link JobInfo}. + * * @param jobId Application-provided id for this job. Subsequent calls to cancel, or - * jobs created with the same jobId, will update the pre-existing job with - * the same id. + * jobs created with the same jobId, will update the pre-existing job with + * the same id. This ID must be unique across all clients of the same uid + * (not just the same package). You will want to make sure this is a stable + * id across app updates, so probably not based on a resource ID. * @param jobService The endpoint that you implement that will receive the callback from the - * JobScheduler. + * JobScheduler. */ public Builder(int jobId, ComponentName jobService) { mJobService = jobService; diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java index f867fb0246867..e408cca4e330d 100755 --- a/core/java/android/provider/Settings.java +++ b/core/java/android/provider/Settings.java @@ -8017,6 +8017,36 @@ public final class Settings { */ public static final String ALARM_MANAGER_CONSTANTS = "alarm_manager_constants"; + /** + * Job scheduler specific settings. + * This is encoded as a key=value list, separated by commas. Ex: + * + * "min_ready_jobs_count=2,moderate_use_factor=.5" + * + * The following keys are supported: + * + *
+ * min_idle_count (int) + * min_charging_count (int) + * min_connectivity_count (int) + * min_content_count (int) + * min_ready_jobs_count (int) + * heavy_use_factor (float) + * moderate_use_factor (float) + * fg_job_count (int) + * bg_normal_job_count (int) + * bg_moderate_job_count (int) + * bg_low_job_count (int) + * bg_critical_job_count (int) + *+ * + *
+ * Type: string
+ * @hide
+ * @see com.android.server.job.JobSchedulerService.Constants
+ */
+ public static final String JOB_SCHEDULER_CONSTANTS = "job_scheduler_constants";
+
/**
* ShortcutManager specific settings.
* This is encoded as a key=value list, separated by commas. Ex:
diff --git a/core/java/android/util/KeyValueListParser.java b/core/java/android/util/KeyValueListParser.java
index 4abdde00e6c69..e4c025dece49c 100644
--- a/core/java/android/util/KeyValueListParser.java
+++ b/core/java/android/util/KeyValueListParser.java
@@ -62,6 +62,24 @@ public class KeyValueListParser {
}
}
+ /**
+ * Get the value for key as an int.
+ * @param key The key to lookup.
+ * @param def The value to return if the key was not found, or the value was not a long.
+ * @return the int value associated with the key.
+ */
+ public int getInt(String key, int def) {
+ String value = mValues.get(key);
+ if (value != null) {
+ try {
+ return Integer.parseInt(value);
+ } catch (NumberFormatException e) {
+ // fallthrough
+ }
+ }
+ return def;
+ }
+
/**
* Get the value for key as a long.
* @param key The key to lookup.
diff --git a/services/core/java/com/android/server/job/JobPackageTracker.java b/services/core/java/com/android/server/job/JobPackageTracker.java
index eb5edd38d8a91..ba96b7494bba5 100644
--- a/services/core/java/com/android/server/job/JobPackageTracker.java
+++ b/services/core/java/com/android/server/job/JobPackageTracker.java
@@ -105,6 +105,8 @@ public final class JobPackageTracker {
final long mStartElapsedTime;
final long mStartClockTime;
long mSummedTime;
+ int mMaxTotalActive;
+ int mMaxFgActive;
public DataSet(DataSet otherTimes) {
mStartUptimeTime = otherTimes.mStartUptimeTime;
@@ -257,6 +259,12 @@ public final class JobPackageTracker {
}
}
}
+ if (mMaxTotalActive > out.mMaxTotalActive) {
+ out.mMaxTotalActive = mMaxTotalActive;
+ }
+ if (mMaxFgActive > out.mMaxFgActive) {
+ out.mMaxFgActive = mMaxFgActive;
+ }
}
void printDuration(PrintWriter pw, long period, long duration, int count, String suffix) {
@@ -317,6 +325,9 @@ public final class JobPackageTracker {
pw.println();
}
}
+ pw.print(prefix); pw.print(" Max concurrency: ");
+ pw.print(mMaxTotalActive); pw.print(" total, ");
+ pw.print(mMaxFgActive); pw.println(" foreground");
}
}
@@ -366,6 +377,15 @@ public final class JobPackageTracker {
addEvent(EVENT_STOP_JOB, job.getSourceUid(), job.getBatteryName());
}
+ public void noteConcurrency(int totalActive, int fgActive) {
+ if (totalActive > mCurDataSet.mMaxTotalActive) {
+ mCurDataSet.mMaxTotalActive = totalActive;
+ }
+ if (fgActive > mCurDataSet.mMaxFgActive) {
+ mCurDataSet.mMaxFgActive = fgActive;
+ }
+ }
+
public float getLoadFactor(JobStatus job) {
final int uid = job.getSourceUid();
final String pkg = job.getSourcePackageName();
diff --git a/services/core/java/com/android/server/job/JobSchedulerService.java b/services/core/java/com/android/server/job/JobSchedulerService.java
index 1b8eccb431f54..5e212b0ef6631 100644
--- a/services/core/java/com/android/server/job/JobSchedulerService.java
+++ b/services/core/java/com/android/server/job/JobSchedulerService.java
@@ -23,6 +23,8 @@ 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;
@@ -37,6 +39,7 @@ import android.app.job.JobService;
import android.app.job.IJobScheduler;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
+import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
@@ -44,6 +47,7 @@ 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;
@@ -57,6 +61,8 @@ import android.os.ResultReceiver;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.os.UserHandle;
+import android.provider.Settings;
+import android.util.KeyValueListParser;
import android.util.Slog;
import android.util.SparseArray;
import android.util.SparseIntArray;
@@ -98,17 +104,12 @@ public final class JobSchedulerService extends com.android.server.SystemService
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 = 12;
- /** The number of MAX_JOB_CONTEXTS_COUNT we reserve for the foreground app. */
- private static final int FG_JOB_CONTEXTS_COUNT = 4;
+ 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;
- /** This is the job execution factor that is considered to be heavy use of the system. */
- private static final float HEAVY_USE_FACTOR = .9f;
- /** This is the job execution factor that is considered to be moderate use of the system. */
- private static final float MODERATE_USE_FACTOR = .5f;
+
/** Global local for all job scheduler state. */
final Object mLock = new Object();
@@ -122,34 +123,6 @@ public final class JobSchedulerService extends com.android.server.SystemService
static final int MSG_STOP_JOB = 2;
static final int MSG_CHECK_JOB_GREEDY = 3;
- // Policy constants
- /**
- * Minimum # of idle jobs that must be ready in order to force the JMS to schedule things
- * early.
- */
- static final int MIN_IDLE_COUNT = 1;
- /**
- * Minimum # of charging jobs that must be ready in order to force the JMS to schedule things
- * early.
- */
- static final int MIN_CHARGING_COUNT = 1;
- /**
- * Minimum # of connectivity jobs that must be ready in order to force the JMS to schedule
- * things early.
- */
- static final int MIN_CONNECTIVITY_COUNT = 1; // Run connectivity jobs as soon as ready.
- /**
- * Minimum # of content trigger jobs that must be ready in order to force the JMS to schedule
- * things early.
- */
- static final int MIN_CONTENT_COUNT = 1;
- /**
- * Minimum # of jobs (with no particular constraints) for which the JMS will be happy running
- * some work early.
- * This is correlated with the amount of batching we'll be able to do.
- */
- static final int MIN_READY_JOBS_COUNT = 2;
-
/**
* Track Services that have currently active or pending jobs. The index is provided by
* {@link JobStatus#getServiceToken()}
@@ -186,7 +159,7 @@ public final class JobSchedulerService extends com.android.server.SystemService
* Current limit on the number of concurrent JobServiceContext entries we want to
* keep actively running a job.
*/
- int mMaxActiveJobs = MAX_JOB_CONTEXTS_COUNT - FG_JOB_CONTEXTS_COUNT;
+ int mMaxActiveJobs = 1;
/**
* Which uids are currently in the foreground.
@@ -211,6 +184,211 @@ public final class JobSchedulerService extends com.android.server.SystemService
*/
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_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 int DEFAULT_MIN_IDLE_COUNT = 1;
+ private static final int DEFAULT_MIN_CHARGING_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 = 2;
+ private static final int DEFAULT_BG_CRITICAL_JOB_COUNT = 1;
+
+ /**
+ * 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 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;
+
+ 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.ALARM_MANAGER_CONSTANTS));
+ } catch (IllegalArgumentException e) {
+ // Failed to parse the settings string, log this and move on
+ // with defaults.
+ Slog.e(TAG, "Bad device idle 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_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;
+ }
+ }
+ }
+
+ 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_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();
+ }
+ }
+
+ final Constants mConstants;
+
/**
* 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.
@@ -550,6 +728,7 @@ public final class JobSchedulerService extends com.android.server.SystemService
mControllers.add(DeviceIdleJobsController.get(this));
mHandler = new JobHandler(context.getMainLooper());
+ mConstants = new Constants(mHandler);
mJobSchedulerStub = new JobSchedulerStub();
mJobs = JobStore.initAndGet(this);
}
@@ -563,6 +742,7 @@ public final class JobSchedulerService extends com.android.server.SystemService
@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);
@@ -994,11 +1174,12 @@ public final class JobSchedulerService extends com.android.server.SystemService
public void postProcess() {
if (backoffCount > 0 ||
- idleCount >= MIN_IDLE_COUNT ||
- connectivityCount >= MIN_CONNECTIVITY_COUNT ||
- chargingCount >= MIN_CHARGING_COUNT ||
- contentCount >= MIN_CONTENT_COUNT ||
- (runnableJobs != null && runnableJobs.size() >= MIN_READY_JOBS_COUNT)) {
+ idleCount >= mConstants.MIN_IDLE_COUNT ||
+ connectivityCount >= mConstants.MIN_CONNECTIVITY_COUNT ||
+ chargingCount >= mConstants.MIN_CHARGING_COUNT ||
+ contentCount >= mConstants.MIN_CONTENT_COUNT ||
+ (runnableJobs != null
+ && runnableJobs.size() >= mConstants.MIN_READY_JOBS_COUNT)) {
if (DEBUG) {
Slog.d(TAG, "maybeQueueReadyJobsForExecutionLockedH: Running jobs.");
}
@@ -1095,9 +1276,9 @@ public final class JobSchedulerService extends com.android.server.SystemService
private int adjustJobPriority(int curPriority, JobStatus job) {
if (curPriority < JobInfo.PRIORITY_TOP_APP) {
float factor = mJobPackageTracker.getLoadFactor(job);
- if (factor >= HEAVY_USE_FACTOR) {
+ if (factor >= mConstants.HEAVY_USE_FACTOR) {
curPriority += JobInfo.PRIORITY_ADJ_ALWAYS_RUNNING;
- } else if (factor >= MODERATE_USE_FACTOR) {
+ } else if (factor >= mConstants.MODERATE_USE_FACTOR) {
curPriority += JobInfo.PRIORITY_ADJ_OFTEN_RUNNING;
}
}
@@ -1135,16 +1316,16 @@ public final class JobSchedulerService extends com.android.server.SystemService
}
switch (memLevel) {
case ProcessStats.ADJ_MEM_FACTOR_MODERATE:
- mMaxActiveJobs = ((MAX_JOB_CONTEXTS_COUNT - FG_JOB_CONTEXTS_COUNT) * 2) / 3;
+ mMaxActiveJobs = mConstants.BG_MODERATE_JOB_COUNT;
break;
case ProcessStats.ADJ_MEM_FACTOR_LOW:
- mMaxActiveJobs = (MAX_JOB_CONTEXTS_COUNT - FG_JOB_CONTEXTS_COUNT) / 3;
+ mMaxActiveJobs = mConstants.BG_LOW_JOB_COUNT;
break;
case ProcessStats.ADJ_MEM_FACTOR_CRITICAL:
- mMaxActiveJobs = 1;
+ mMaxActiveJobs = mConstants.BG_CRITICAL_JOB_COUNT;
break;
default:
- mMaxActiveJobs = MAX_JOB_CONTEXTS_COUNT - FG_JOB_CONTEXTS_COUNT;
+ mMaxActiveJobs = mConstants.BG_NORMAL_JOB_COUNT;
break;
}
@@ -1152,10 +1333,15 @@ public final class JobSchedulerService extends com.android.server.SystemService
boolean[] act = mTmpAssignAct;
int[] preferredUidForContext = mTmpAssignPreferredUidForContext;
int numActive = 0;
+ int numForeground = 0;
for (int i=0; i