| /* |
| * 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 com.android.server.job.JobSchedulerService.sElapsedRealtimeClock; |
| import static com.android.server.job.JobSchedulerService.sSystemClock; |
| |
| import android.annotation.Nullable; |
| import android.app.ActivityManager; |
| import android.app.IActivityManager; |
| import android.app.job.JobInfo; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.net.NetworkRequest; |
| import android.os.Environment; |
| import android.os.Handler; |
| import android.os.PersistableBundle; |
| import android.os.Process; |
| import android.os.SystemClock; |
| import android.os.UserHandle; |
| import android.text.format.DateUtils; |
| import android.util.ArraySet; |
| import android.util.AtomicFile; |
| import android.util.Pair; |
| import android.util.Slog; |
| import android.util.SparseArray; |
| import android.util.Xml; |
| |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.util.ArrayUtils; |
| import com.android.internal.util.BitUtils; |
| import com.android.internal.util.FastXmlSerializer; |
| import com.android.server.IoThread; |
| import com.android.server.LocalServices; |
| import com.android.server.job.JobSchedulerInternal.JobStorePersistStats; |
| import com.android.server.job.controllers.JobStatus; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| import org.xmlpull.v1.XmlSerializer; |
| |
| 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.nio.charset.StandardCharsets; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.function.Consumer; |
| import java.util.function.Predicate; |
| |
| /** |
| * Maintains the master list of jobs that the job scheduler is tracking. These jobs are compared by |
| * reference, so none of the functions in this class should make a copy. |
| * Also handles read/write of persisted jobs. |
| * |
| * 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.job.JobStore.WriteJobsMapToDiskRunnable} |
| * and {@link com.android.server.job.JobStore.ReadJobMapFromDiskRunnable} lock on that |
| * object. |
| * |
| * Test: |
| * atest $ANDROID_BUILD_TOP/frameworks/base/services/tests/servicestests/src/com/android/server/job/JobStoreTest.java |
| */ |
| public final class JobStore { |
| private static final String TAG = "JobStore"; |
| private static final boolean DEBUG = JobSchedulerService.DEBUG; |
| |
| /** Threshold to adjust how often we want to write to the db. */ |
| private static final long JOB_PERSIST_DELAY = 2000L; |
| |
| final Object mLock; |
| final Object mWriteScheduleLock; // used solely for invariants around write scheduling |
| final JobSet mJobSet; // per-caller-uid and per-source-uid tracking |
| final Context mContext; |
| |
| // Bookkeeping around incorrect boot-time system clock |
| private final long mXmlTimestamp; |
| private boolean mRtcGood; |
| |
| @GuardedBy("mWriteScheduleLock") |
| private boolean mWriteScheduled; |
| |
| @GuardedBy("mWriteScheduleLock") |
| private boolean mWriteInProgress; |
| |
| private static final Object sSingletonLock = new Object(); |
| private final AtomicFile mJobsFile; |
| /** Handler backed by IoThread for writing to disk. */ |
| private final Handler mIoHandler = IoThread.getHandler(); |
| private static JobStore sSingleton; |
| |
| private JobStorePersistStats mPersistInfo = new JobStorePersistStats(); |
| |
| /** Used by the {@link JobSchedulerService} to instantiate the JobStore. */ |
| static JobStore initAndGet(JobSchedulerService jobManagerService) { |
| synchronized (sSingletonLock) { |
| if (sSingleton == null) { |
| sSingleton = new JobStore(jobManagerService.getContext(), |
| jobManagerService.getLock(), Environment.getDataDirectory()); |
| } |
| return sSingleton; |
| } |
| } |
| |
| /** |
| * @return A freshly initialized job store object, with no loaded jobs. |
| */ |
| @VisibleForTesting |
| public static JobStore initAndGetForTesting(Context context, File dataDir) { |
| JobStore jobStoreUnderTest = new JobStore(context, new Object(), dataDir); |
| jobStoreUnderTest.clear(); |
| return jobStoreUnderTest; |
| } |
| |
| /** |
| * Construct the instance of the job store. This results in a blocking read from disk. |
| */ |
| private JobStore(Context context, Object lock, File dataDir) { |
| mLock = lock; |
| mWriteScheduleLock = new Object(); |
| mContext = context; |
| |
| File systemDir = new File(dataDir, "system"); |
| File jobDir = new File(systemDir, "job"); |
| jobDir.mkdirs(); |
| mJobsFile = new AtomicFile(new File(jobDir, "jobs.xml"), "jobs"); |
| |
| mJobSet = new JobSet(); |
| |
| // If the current RTC is earlier than the timestamp on our persisted jobs file, |
| // we suspect that the RTC is uninitialized and so we cannot draw conclusions |
| // about persisted job scheduling. |
| // |
| // Note that if the persisted jobs file does not exist, we proceed with the |
| // assumption that the RTC is good. This is less work and is safe: if the |
| // clock updates to sanity then we'll be saving the persisted jobs file in that |
| // correct state, which is normal; or we'll wind up writing the jobs file with |
| // an incorrect historical timestamp. That's fine; at worst we'll reboot with |
| // a *correct* timestamp, see a bunch of overdue jobs, and run them; then |
| // settle into normal operation. |
| mXmlTimestamp = mJobsFile.getLastModifiedTime(); |
| mRtcGood = (sSystemClock.millis() > mXmlTimestamp); |
| |
| readJobMapFromDisk(mJobSet, mRtcGood); |
| } |
| |
| public boolean jobTimesInflatedValid() { |
| return mRtcGood; |
| } |
| |
| public boolean clockNowValidToInflate(long now) { |
| return now >= mXmlTimestamp; |
| } |
| |
| /** |
| * Find all the jobs that were affected by RTC clock uncertainty at boot time. Returns |
| * parallel lists of the existing JobStatus objects and of new, equivalent JobStatus instances |
| * with now-corrected time bounds. |
| */ |
| public void getRtcCorrectedJobsLocked(final ArrayList<JobStatus> toAdd, |
| final ArrayList<JobStatus> toRemove) { |
| final long elapsedNow = sElapsedRealtimeClock.millis(); |
| final IActivityManager am = ActivityManager.getService(); |
| |
| // Find the jobs that need to be fixed up, collecting them for post-iteration |
| // replacement with their new versions |
| forEachJob(job -> { |
| final Pair<Long, Long> utcTimes = job.getPersistedUtcTimes(); |
| if (utcTimes != null) { |
| Pair<Long, Long> elapsedRuntimes = |
| convertRtcBoundsToElapsed(utcTimes, elapsedNow); |
| JobStatus newJob = new JobStatus(job, job.getBaseHeartbeat(), |
| elapsedRuntimes.first, elapsedRuntimes.second, |
| 0, job.getLastSuccessfulRunTime(), job.getLastFailedRunTime()); |
| newJob.prepareLocked(am); |
| toAdd.add(newJob); |
| toRemove.add(job); |
| } |
| }); |
| } |
| |
| /** |
| * Add a job to the master list, persisting it if necessary. If the JobStatus already exists, |
| * it will be replaced. |
| * @param jobStatus Job to add. |
| * @return Whether or not an equivalent JobStatus was replaced by this operation. |
| */ |
| public boolean add(JobStatus jobStatus) { |
| boolean replaced = mJobSet.remove(jobStatus); |
| mJobSet.add(jobStatus); |
| if (jobStatus.isPersisted()) { |
| maybeWriteStatusToDiskAsync(); |
| } |
| if (DEBUG) { |
| Slog.d(TAG, "Added job status to store: " + jobStatus); |
| } |
| return replaced; |
| } |
| |
| boolean containsJob(JobStatus jobStatus) { |
| return mJobSet.contains(jobStatus); |
| } |
| |
| public int size() { |
| return mJobSet.size(); |
| } |
| |
| public JobStorePersistStats getPersistStats() { |
| return mPersistInfo; |
| } |
| |
| public int countJobsForUid(int uid) { |
| return mJobSet.countJobsForUid(uid); |
| } |
| |
| /** |
| * Remove the provided job. Will also delete the job if it was persisted. |
| * @param writeBack If true, the job will be deleted (if it was persisted) immediately. |
| * @return Whether or not the job existed to be removed. |
| */ |
| public boolean remove(JobStatus jobStatus, boolean writeBack) { |
| boolean removed = mJobSet.remove(jobStatus); |
| if (!removed) { |
| if (DEBUG) { |
| Slog.d(TAG, "Couldn't remove job: didn't exist: " + jobStatus); |
| } |
| return false; |
| } |
| if (writeBack && jobStatus.isPersisted()) { |
| maybeWriteStatusToDiskAsync(); |
| } |
| return removed; |
| } |
| |
| /** |
| * Remove the jobs of users not specified in the whitelist. |
| * @param whitelist Array of User IDs whose jobs are not to be removed. |
| */ |
| public void removeJobsOfNonUsers(int[] whitelist) { |
| mJobSet.removeJobsOfNonUsers(whitelist); |
| } |
| |
| @VisibleForTesting |
| public void clear() { |
| mJobSet.clear(); |
| maybeWriteStatusToDiskAsync(); |
| } |
| |
| /** |
| * @param userHandle User for whom we are querying the list of jobs. |
| * @return A list of all the jobs scheduled for the provided user. Never null. |
| */ |
| public List<JobStatus> getJobsByUser(int userHandle) { |
| return mJobSet.getJobsByUser(userHandle); |
| } |
| |
| /** |
| * @param uid Uid of the requesting app. |
| * @return All JobStatus objects for a given uid from the master list. Never null. |
| */ |
| public List<JobStatus> getJobsByUid(int uid) { |
| return mJobSet.getJobsByUid(uid); |
| } |
| |
| /** |
| * @param uid Uid of the requesting app. |
| * @param jobId Job id, specified at schedule-time. |
| * @return the JobStatus that matches the provided uId and jobId, or null if none found. |
| */ |
| public JobStatus getJobByUidAndJobId(int uid, int jobId) { |
| return mJobSet.get(uid, jobId); |
| } |
| |
| /** |
| * Iterate over the set of all jobs, invoking the supplied functor on each. This is for |
| * customers who need to examine each job; we'd much rather not have to generate |
| * transient unified collections for them to iterate over and then discard, or creating |
| * iterators every time a client needs to perform a sweep. |
| */ |
| public void forEachJob(Consumer<JobStatus> functor) { |
| mJobSet.forEachJob(null, functor); |
| } |
| |
| public void forEachJob(@Nullable Predicate<JobStatus> filterPredicate, |
| Consumer<JobStatus> functor) { |
| mJobSet.forEachJob(filterPredicate, functor); |
| } |
| |
| public void forEachJob(int uid, Consumer<JobStatus> functor) { |
| mJobSet.forEachJob(uid, functor); |
| } |
| |
| public void forEachJobForSourceUid(int sourceUid, Consumer<JobStatus> functor) { |
| mJobSet.forEachJobForSourceUid(sourceUid, functor); |
| } |
| |
| /** Version of the db schema. */ |
| private static final int JOBS_FILE_VERSION = 0; |
| /** Tag corresponds to constraints this job 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 jobs in one swath, instead of trying to |
| * track incremental changes. |
| */ |
| private void maybeWriteStatusToDiskAsync() { |
| synchronized (mWriteScheduleLock) { |
| if (!mWriteScheduled) { |
| if (DEBUG) { |
| Slog.v(TAG, "Scheduling persist of jobs to disk."); |
| } |
| mIoHandler.postDelayed(mWriteRunnable, JOB_PERSIST_DELAY); |
| mWriteScheduled = mWriteInProgress = true; |
| } |
| } |
| } |
| |
| @VisibleForTesting |
| public void readJobMapFromDisk(JobSet jobSet, boolean rtcGood) { |
| new ReadJobMapFromDiskRunnable(jobSet, rtcGood).run(); |
| } |
| |
| /** |
| * Wait for any pending write to the persistent store to clear |
| * @param maxWaitMillis Maximum time from present to wait |
| * @return {@code true} if I/O cleared as expected, {@code false} if the wait |
| * timed out before the pending write completed. |
| */ |
| @VisibleForTesting |
| public boolean waitForWriteToCompleteForTesting(long maxWaitMillis) { |
| final long start = SystemClock.uptimeMillis(); |
| final long end = start + maxWaitMillis; |
| synchronized (mWriteScheduleLock) { |
| while (mWriteInProgress) { |
| final long now = SystemClock.uptimeMillis(); |
| if (now >= end) { |
| // still not done and we've hit the end; failure |
| return false; |
| } |
| try { |
| mWriteScheduleLock.wait(now - start + maxWaitMillis); |
| } catch (InterruptedException e) { |
| // Spurious; keep waiting |
| break; |
| } |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Runnable that writes {@link #mJobSet} out to xml. |
| * NOTE: This Runnable locks on mLock |
| */ |
| private final Runnable mWriteRunnable = new Runnable() { |
| @Override |
| public void run() { |
| final long startElapsed = sElapsedRealtimeClock.millis(); |
| final List<JobStatus> storeCopy = new ArrayList<JobStatus>(); |
| // Intentionally allow new scheduling of a write operation *before* we clone |
| // the job set. If we reset it to false after cloning, there's a window in |
| // which no new write will be scheduled but mLock is not held, i.e. a new |
| // job might appear and fail to be recognized as needing a persist. The |
| // potential cost is one redundant write of an identical set of jobs in the |
| // rare case of that specific race, but by doing it this way we avoid quite |
| // a bit of lock contention. |
| synchronized (mWriteScheduleLock) { |
| mWriteScheduled = false; |
| } |
| synchronized (mLock) { |
| // Clone the jobs so we can release the lock before writing. |
| mJobSet.forEachJob(null, (job) -> { |
| if (job.isPersisted()) { |
| storeCopy.add(new JobStatus(job)); |
| } |
| }); |
| } |
| writeJobsMapImpl(storeCopy); |
| if (DEBUG) { |
| Slog.v(TAG, "Finished writing, took " + (sElapsedRealtimeClock.millis() |
| - startElapsed) + "ms"); |
| } |
| synchronized (mWriteScheduleLock) { |
| mWriteInProgress = false; |
| mWriteScheduleLock.notifyAll(); |
| } |
| } |
| |
| private void writeJobsMapImpl(List<JobStatus> jobList) { |
| int numJobs = 0; |
| int numSystemJobs = 0; |
| int numSyncJobs = 0; |
| try { |
| final long startTime = SystemClock.uptimeMillis(); |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| XmlSerializer out = new FastXmlSerializer(); |
| out.setOutput(baos, StandardCharsets.UTF_8.name()); |
| out.startDocument(null, true); |
| out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); |
| |
| out.startTag(null, "job-info"); |
| out.attribute(null, "version", Integer.toString(JOBS_FILE_VERSION)); |
| for (int i=0; i<jobList.size(); i++) { |
| JobStatus jobStatus = jobList.get(i); |
| if (DEBUG) { |
| Slog.d(TAG, "Saving job " + jobStatus.getJobId()); |
| } |
| out.startTag(null, "job"); |
| addAttributesToJobTag(out, jobStatus); |
| writeConstraintsToXml(out, jobStatus); |
| writeExecutionCriteriaToXml(out, jobStatus); |
| writeBundleToXml(jobStatus.getJob().getExtras(), out); |
| out.endTag(null, "job"); |
| |
| numJobs++; |
| if (jobStatus.getUid() == Process.SYSTEM_UID) { |
| numSystemJobs++; |
| if (isSyncJob(jobStatus)) { |
| numSyncJobs++; |
| } |
| } |
| } |
| out.endTag(null, "job-info"); |
| out.endDocument(); |
| |
| // Write out to disk in one fell swoop. |
| FileOutputStream fos = mJobsFile.startWrite(startTime); |
| fos.write(baos.toByteArray()); |
| mJobsFile.finishWrite(fos); |
| } catch (IOException e) { |
| if (DEBUG) { |
| Slog.v(TAG, "Error writing out job data.", e); |
| } |
| } catch (XmlPullParserException e) { |
| if (DEBUG) { |
| Slog.d(TAG, "Error persisting bundle.", e); |
| } |
| } finally { |
| mPersistInfo.countAllJobsSaved = numJobs; |
| mPersistInfo.countSystemServerJobsSaved = numSystemJobs; |
| mPersistInfo.countSystemSyncManagerJobsSaved = numSyncJobs; |
| } |
| } |
| |
| /** Write out a tag with data comprising the required fields and priority of this job and |
| * its client. |
| */ |
| private void addAttributesToJobTag(XmlSerializer out, JobStatus jobStatus) |
| throws IOException { |
| out.attribute(null, "jobid", Integer.toString(jobStatus.getJobId())); |
| out.attribute(null, "package", jobStatus.getServiceComponent().getPackageName()); |
| out.attribute(null, "class", jobStatus.getServiceComponent().getClassName()); |
| if (jobStatus.getSourcePackageName() != null) { |
| out.attribute(null, "sourcePackageName", jobStatus.getSourcePackageName()); |
| } |
| if (jobStatus.getSourceTag() != null) { |
| out.attribute(null, "sourceTag", jobStatus.getSourceTag()); |
| } |
| out.attribute(null, "sourceUserId", String.valueOf(jobStatus.getSourceUserId())); |
| out.attribute(null, "uid", Integer.toString(jobStatus.getUid())); |
| out.attribute(null, "priority", String.valueOf(jobStatus.getPriority())); |
| out.attribute(null, "flags", String.valueOf(jobStatus.getFlags())); |
| if (jobStatus.getInternalFlags() != 0) { |
| out.attribute(null, "internalFlags", String.valueOf(jobStatus.getInternalFlags())); |
| } |
| |
| out.attribute(null, "lastSuccessfulRunTime", |
| String.valueOf(jobStatus.getLastSuccessfulRunTime())); |
| out.attribute(null, "lastFailedRunTime", |
| String.valueOf(jobStatus.getLastFailedRunTime())); |
| } |
| |
| private void writeBundleToXml(PersistableBundle extras, XmlSerializer out) |
| throws IOException, XmlPullParserException { |
| out.startTag(null, XML_TAG_EXTRAS); |
| PersistableBundle extrasCopy = deepCopyBundle(extras, 10); |
| extrasCopy.saveToXml(out); |
| out.endTag(null, XML_TAG_EXTRAS); |
| } |
| |
| private PersistableBundle deepCopyBundle(PersistableBundle bundle, int maxDepth) { |
| if (maxDepth <= 0) { |
| return null; |
| } |
| PersistableBundle copy = (PersistableBundle) bundle.clone(); |
| Set<String> keySet = bundle.keySet(); |
| for (String key: keySet) { |
| Object o = copy.get(key); |
| if (o instanceof PersistableBundle) { |
| PersistableBundle bCopy = deepCopyBundle((PersistableBundle) o, maxDepth-1); |
| copy.putPersistableBundle(key, bCopy); |
| } |
| } |
| return copy; |
| } |
| |
| /** |
| * Write out a tag with data identifying this job's constraints. If the constraint isn't here |
| * it doesn't apply. |
| */ |
| private void writeConstraintsToXml(XmlSerializer out, JobStatus jobStatus) throws IOException { |
| out.startTag(null, XML_TAG_PARAMS_CONSTRAINTS); |
| if (jobStatus.hasConnectivityConstraint()) { |
| final NetworkRequest network = jobStatus.getJob().getRequiredNetwork(); |
| out.attribute(null, "net-capabilities", Long.toString( |
| BitUtils.packBits(network.networkCapabilities.getCapabilities()))); |
| out.attribute(null, "net-unwanted-capabilities", Long.toString( |
| BitUtils.packBits(network.networkCapabilities.getUnwantedCapabilities()))); |
| |
| out.attribute(null, "net-transport-types", Long.toString( |
| BitUtils.packBits(network.networkCapabilities.getTransportTypes()))); |
| } |
| if (jobStatus.hasIdleConstraint()) { |
| out.attribute(null, "idle", Boolean.toString(true)); |
| } |
| if (jobStatus.hasChargingConstraint()) { |
| out.attribute(null, "charging", Boolean.toString(true)); |
| } |
| if (jobStatus.hasBatteryNotLowConstraint()) { |
| out.attribute(null, "battery-not-low", Boolean.toString(true)); |
| } |
| out.endTag(null, XML_TAG_PARAMS_CONSTRAINTS); |
| } |
| |
| private void writeExecutionCriteriaToXml(XmlSerializer out, JobStatus jobStatus) |
| throws IOException { |
| final JobInfo job = jobStatus.getJob(); |
| if (jobStatus.getJob().isPeriodic()) { |
| out.startTag(null, XML_TAG_PERIODIC); |
| out.attribute(null, "period", Long.toString(job.getIntervalMillis())); |
| out.attribute(null, "flex", Long.toString(job.getFlexMillis())); |
| } else { |
| out.startTag(null, XML_TAG_ONEOFF); |
| } |
| |
| // If we still have the persisted times, we need to record those directly because |
| // we haven't yet been able to calculate the usual elapsed-timebase bounds |
| // correctly due to wall-clock uncertainty. |
| Pair <Long, Long> utcJobTimes = jobStatus.getPersistedUtcTimes(); |
| if (DEBUG && utcJobTimes != null) { |
| Slog.i(TAG, "storing original UTC timestamps for " + jobStatus); |
| } |
| |
| final long nowRTC = sSystemClock.millis(); |
| final long nowElapsed = sElapsedRealtimeClock.millis(); |
| if (jobStatus.hasDeadlineConstraint()) { |
| // Wall clock deadline. |
| final long deadlineWallclock = (utcJobTimes == null) |
| ? nowRTC + (jobStatus.getLatestRunTimeElapsed() - nowElapsed) |
| : utcJobTimes.second; |
| out.attribute(null, "deadline", Long.toString(deadlineWallclock)); |
| } |
| if (jobStatus.hasTimingDelayConstraint()) { |
| final long delayWallclock = (utcJobTimes == null) |
| ? nowRTC + (jobStatus.getEarliestRunTime() - nowElapsed) |
| : utcJobTimes.first; |
| 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 job is idle -> these aren't allowed to specify |
| // back-off. |
| if (jobStatus.getJob().getInitialBackoffMillis() != JobInfo.DEFAULT_INITIAL_BACKOFF_MILLIS |
| || jobStatus.getJob().getBackoffPolicy() != JobInfo.DEFAULT_BACKOFF_POLICY) { |
| out.attribute(null, "backoff-policy", Integer.toString(job.getBackoffPolicy())); |
| out.attribute(null, "initial-backoff", Long.toString(job.getInitialBackoffMillis())); |
| } |
| if (job.isPeriodic()) { |
| out.endTag(null, XML_TAG_PERIODIC); |
| } else { |
| out.endTag(null, XML_TAG_ONEOFF); |
| } |
| } |
| }; |
| |
| /** |
| * Translate the supplied RTC times to the elapsed timebase, with clamping appropriate |
| * to interpreting them as a job's delay + deadline times for alarm-setting purposes. |
| * @param rtcTimes a Pair<Long, Long> in which {@code first} is the "delay" earliest |
| * allowable runtime for the job, and {@code second} is the "deadline" time at which |
| * the job becomes overdue. |
| */ |
| private static Pair<Long, Long> convertRtcBoundsToElapsed(Pair<Long, Long> rtcTimes, |
| long nowElapsed) { |
| final long nowWallclock = sSystemClock.millis(); |
| final long earliest = (rtcTimes.first > JobStatus.NO_EARLIEST_RUNTIME) |
| ? nowElapsed + Math.max(rtcTimes.first - nowWallclock, 0) |
| : JobStatus.NO_EARLIEST_RUNTIME; |
| final long latest = (rtcTimes.second < JobStatus.NO_LATEST_RUNTIME) |
| ? nowElapsed + Math.max(rtcTimes.second - nowWallclock, 0) |
| : JobStatus.NO_LATEST_RUNTIME; |
| return Pair.create(earliest, latest); |
| } |
| |
| private static boolean isSyncJob(JobStatus status) { |
| return com.android.server.content.SyncJobService.class.getName() |
| .equals(status.getServiceComponent().getClassName()); |
| } |
| |
| /** |
| * Runnable that reads list of persisted job from xml. This is run once at start up, so doesn't |
| * need to go through {@link JobStore#add(com.android.server.job.controllers.JobStatus)}. |
| */ |
| private final class ReadJobMapFromDiskRunnable implements Runnable { |
| private final JobSet jobSet; |
| private final boolean rtcGood; |
| |
| /** |
| * @param jobSet Reference to the (empty) set of JobStatus objects that back the JobStore, |
| * so that after disk read we can populate it directly. |
| */ |
| ReadJobMapFromDiskRunnable(JobSet jobSet, boolean rtcIsGood) { |
| this.jobSet = jobSet; |
| this.rtcGood = rtcIsGood; |
| } |
| |
| @Override |
| public void run() { |
| int numJobs = 0; |
| int numSystemJobs = 0; |
| int numSyncJobs = 0; |
| try { |
| List<JobStatus> jobs; |
| FileInputStream fis = mJobsFile.openRead(); |
| synchronized (mLock) { |
| jobs = readJobMapImpl(fis, rtcGood); |
| if (jobs != null) { |
| long now = sElapsedRealtimeClock.millis(); |
| IActivityManager am = ActivityManager.getService(); |
| for (int i=0; i<jobs.size(); i++) { |
| JobStatus js = jobs.get(i); |
| js.prepareLocked(am); |
| js.enqueueTime = now; |
| this.jobSet.add(js); |
| |
| numJobs++; |
| if (js.getUid() == Process.SYSTEM_UID) { |
| numSystemJobs++; |
| if (isSyncJob(js)) { |
| numSyncJobs++; |
| } |
| } |
| } |
| } |
| } |
| fis.close(); |
| } catch (FileNotFoundException e) { |
| if (DEBUG) { |
| Slog.d(TAG, "Could not find jobs file, probably there was nothing to load."); |
| } |
| } catch (XmlPullParserException | IOException e) { |
| Slog.wtf(TAG, "Error jobstore xml.", e); |
| } finally { |
| if (mPersistInfo.countAllJobsLoaded < 0) { // Only set them once. |
| mPersistInfo.countAllJobsLoaded = numJobs; |
| mPersistInfo.countSystemServerJobsLoaded = numSystemJobs; |
| mPersistInfo.countSystemSyncManagerJobsLoaded = numSyncJobs; |
| } |
| } |
| Slog.i(TAG, "Read " + numJobs + " jobs"); |
| } |
| |
| private List<JobStatus> readJobMapImpl(FileInputStream fis, boolean rtcIsGood) |
| throws XmlPullParserException, IOException { |
| XmlPullParser parser = Xml.newPullParser(); |
| parser.setInput(fis, StandardCharsets.UTF_8.name()); |
| |
| int eventType = parser.getEventType(); |
| while (eventType != XmlPullParser.START_TAG && |
| eventType != XmlPullParser.END_DOCUMENT) { |
| eventType = parser.next(); |
| Slog.d(TAG, "Start tag: " + parser.getName()); |
| } |
| if (eventType == XmlPullParser.END_DOCUMENT) { |
| if (DEBUG) { |
| Slog.d(TAG, "No persisted jobs."); |
| } |
| return null; |
| } |
| |
| String tagName = parser.getName(); |
| if ("job-info".equals(tagName)) { |
| final List<JobStatus> jobs = new ArrayList<JobStatus>(); |
| // Read in version info. |
| try { |
| int version = Integer.parseInt(parser.getAttributeValue(null, "version")); |
| if (version != JOBS_FILE_VERSION) { |
| Slog.d(TAG, "Invalid version number, aborting jobs file read."); |
| return null; |
| } |
| } catch (NumberFormatException e) { |
| Slog.e(TAG, "Invalid version number, aborting jobs file read."); |
| return null; |
| } |
| eventType = parser.next(); |
| do { |
| // Read each <job/> |
| if (eventType == XmlPullParser.START_TAG) { |
| tagName = parser.getName(); |
| // Start reading job. |
| if ("job".equals(tagName)) { |
| JobStatus persistedJob = restoreJobFromXml(rtcIsGood, parser); |
| if (persistedJob != null) { |
| if (DEBUG) { |
| Slog.d(TAG, "Read out " + persistedJob); |
| } |
| jobs.add(persistedJob); |
| } else { |
| Slog.d(TAG, "Error reading job from file."); |
| } |
| } |
| } |
| eventType = parser.next(); |
| } while (eventType != XmlPullParser.END_DOCUMENT); |
| return jobs; |
| } |
| return null; |
| } |
| |
| /** |
| * @param parser Xml parser at the beginning of a "<job/>" tag. The next "parser.next()" call |
| * will take the parser into the body of the job tag. |
| * @return Newly instantiated job holding all the information we just read out of the xml tag. |
| */ |
| private JobStatus restoreJobFromXml(boolean rtcIsGood, XmlPullParser parser) |
| throws XmlPullParserException, IOException { |
| JobInfo.Builder jobBuilder; |
| int uid, sourceUserId; |
| long lastSuccessfulRunTime; |
| long lastFailedRunTime; |
| int internalFlags = 0; |
| |
| // Read out job identifier attributes and priority. |
| try { |
| jobBuilder = buildBuilderFromXml(parser); |
| jobBuilder.setPersisted(true); |
| uid = Integer.parseInt(parser.getAttributeValue(null, "uid")); |
| |
| String val = parser.getAttributeValue(null, "priority"); |
| if (val != null) { |
| jobBuilder.setPriority(Integer.parseInt(val)); |
| } |
| val = parser.getAttributeValue(null, "flags"); |
| if (val != null) { |
| jobBuilder.setFlags(Integer.parseInt(val)); |
| } |
| val = parser.getAttributeValue(null, "internalFlags"); |
| if (val != null) { |
| internalFlags = Integer.parseInt(val); |
| } |
| val = parser.getAttributeValue(null, "sourceUserId"); |
| sourceUserId = val == null ? -1 : Integer.parseInt(val); |
| |
| val = parser.getAttributeValue(null, "lastSuccessfulRunTime"); |
| lastSuccessfulRunTime = val == null ? 0 : Long.parseLong(val); |
| |
| val = parser.getAttributeValue(null, "lastFailedRunTime"); |
| lastFailedRunTime = val == null ? 0 : Long.parseLong(val); |
| } catch (NumberFormatException e) { |
| Slog.e(TAG, "Error parsing job's required fields, skipping"); |
| return null; |
| } |
| |
| String sourcePackageName = parser.getAttributeValue(null, "sourcePackageName"); |
| final String sourceTag = parser.getAttributeValue(null, "sourceTag"); |
| |
| 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(jobBuilder, 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; |
| } |
| |
| // Tuple of (earliest runtime, latest runtime) in UTC. |
| final Pair<Long, Long> rtcRuntimes; |
| try { |
| rtcRuntimes = buildRtcExecutionTimesFromXml(parser); |
| } catch (NumberFormatException e) { |
| if (DEBUG) { |
| Slog.d(TAG, "Error parsing execution time parameters, skipping."); |
| } |
| return null; |
| } |
| |
| final long elapsedNow = sElapsedRealtimeClock.millis(); |
| Pair<Long, Long> elapsedRuntimes = convertRtcBoundsToElapsed(rtcRuntimes, elapsedNow); |
| |
| if (XML_TAG_PERIODIC.equals(parser.getName())) { |
| try { |
| String val = parser.getAttributeValue(null, "period"); |
| final long periodMillis = Long.parseLong(val); |
| val = parser.getAttributeValue(null, "flex"); |
| final long flexMillis = (val != null) ? Long.valueOf(val) : periodMillis; |
| jobBuilder.setPeriodic(periodMillis, flexMillis); |
| // As a sanity check, cap the recreated run time to be no later than flex+period |
| // from now. This is the latest the periodic could be pushed out. This could |
| // happen if the periodic ran early (at flex time before period), and then the |
| // device rebooted. |
| if (elapsedRuntimes.second > elapsedNow + periodMillis + flexMillis) { |
| final long clampedLateRuntimeElapsed = elapsedNow + flexMillis |
| + periodMillis; |
| final long clampedEarlyRuntimeElapsed = clampedLateRuntimeElapsed |
| - flexMillis; |
| Slog.w(TAG, |
| String.format("Periodic job for uid='%d' persisted run-time is" + |
| " too big [%s, %s]. Clamping to [%s,%s]", |
| uid, |
| DateUtils.formatElapsedTime(elapsedRuntimes.first / 1000), |
| DateUtils.formatElapsedTime(elapsedRuntimes.second / 1000), |
| DateUtils.formatElapsedTime( |
| clampedEarlyRuntimeElapsed / 1000), |
| DateUtils.formatElapsedTime( |
| clampedLateRuntimeElapsed / 1000)) |
| ); |
| elapsedRuntimes = |
| Pair.create(clampedEarlyRuntimeElapsed, clampedLateRuntimeElapsed); |
| } |
| } catch (NumberFormatException e) { |
| Slog.d(TAG, "Error reading periodic execution criteria, skipping."); |
| return null; |
| } |
| } else if (XML_TAG_ONEOFF.equals(parser.getName())) { |
| try { |
| if (elapsedRuntimes.first != JobStatus.NO_EARLIEST_RUNTIME) { |
| jobBuilder.setMinimumLatency(elapsedRuntimes.first - elapsedNow); |
| } |
| if (elapsedRuntimes.second != JobStatus.NO_LATEST_RUNTIME) { |
| jobBuilder.setOverrideDeadline( |
| elapsedRuntimes.second - elapsedNow); |
| } |
| } catch (NumberFormatException e) { |
| Slog.d(TAG, "Error reading job 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(jobBuilder, 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); |
| jobBuilder.setExtras(extras); |
| parser.nextTag(); // Consume </extras> |
| |
| // Migrate sync jobs forward from earlier, incomplete representation |
| if ("android".equals(sourcePackageName) |
| && extras != null |
| && extras.getBoolean("SyncManagerJob", false)) { |
| sourcePackageName = extras.getString("owningPackage", sourcePackageName); |
| if (DEBUG) { |
| Slog.i(TAG, "Fixing up sync job source package name from 'android' to '" |
| + sourcePackageName + "'"); |
| } |
| } |
| |
| // And now we're done |
| JobSchedulerInternal service = LocalServices.getService(JobSchedulerInternal.class); |
| final int appBucket = JobSchedulerService.standbyBucketForPackage(sourcePackageName, |
| sourceUserId, elapsedNow); |
| long currentHeartbeat = service != null ? service.currentHeartbeat() : 0; |
| JobStatus js = new JobStatus( |
| jobBuilder.build(), uid, sourcePackageName, sourceUserId, |
| appBucket, currentHeartbeat, sourceTag, |
| elapsedRuntimes.first, elapsedRuntimes.second, |
| lastSuccessfulRunTime, lastFailedRunTime, |
| (rtcIsGood) ? null : rtcRuntimes, internalFlags); |
| return js; |
| } |
| |
| private JobInfo.Builder buildBuilderFromXml(XmlPullParser parser) throws NumberFormatException { |
| // Pull out required fields from <job> attributes. |
| int jobId = Integer.parseInt(parser.getAttributeValue(null, "jobid")); |
| String packageName = parser.getAttributeValue(null, "package"); |
| String className = parser.getAttributeValue(null, "class"); |
| ComponentName cname = new ComponentName(packageName, className); |
| |
| return new JobInfo.Builder(jobId, cname); |
| } |
| |
| private void buildConstraintsFromXml(JobInfo.Builder jobBuilder, XmlPullParser parser) { |
| String val; |
| |
| final String netCapabilities = parser.getAttributeValue(null, "net-capabilities"); |
| final String netUnwantedCapabilities = parser.getAttributeValue( |
| null, "net-unwanted-capabilities"); |
| final String netTransportTypes = parser.getAttributeValue(null, "net-transport-types"); |
| if (netCapabilities != null && netTransportTypes != null) { |
| final NetworkRequest request = new NetworkRequest.Builder().build(); |
| final long unwantedCapabilities = netUnwantedCapabilities != null |
| ? Long.parseLong(netUnwantedCapabilities) |
| : BitUtils.packBits(request.networkCapabilities.getUnwantedCapabilities()); |
| |
| // We're okay throwing NFE here; caught by caller |
| request.networkCapabilities.setCapabilities( |
| BitUtils.unpackBits(Long.parseLong(netCapabilities)), |
| BitUtils.unpackBits(unwantedCapabilities)); |
| request.networkCapabilities.setTransportTypes( |
| BitUtils.unpackBits(Long.parseLong(netTransportTypes))); |
| jobBuilder.setRequiredNetwork(request); |
| } else { |
| // Read legacy values |
| val = parser.getAttributeValue(null, "connectivity"); |
| if (val != null) { |
| jobBuilder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY); |
| } |
| val = parser.getAttributeValue(null, "metered"); |
| if (val != null) { |
| jobBuilder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_METERED); |
| } |
| val = parser.getAttributeValue(null, "unmetered"); |
| if (val != null) { |
| jobBuilder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED); |
| } |
| val = parser.getAttributeValue(null, "not-roaming"); |
| if (val != null) { |
| jobBuilder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_NOT_ROAMING); |
| } |
| } |
| |
| val = parser.getAttributeValue(null, "idle"); |
| if (val != null) { |
| jobBuilder.setRequiresDeviceIdle(true); |
| } |
| val = parser.getAttributeValue(null, "charging"); |
| if (val != null) { |
| jobBuilder.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 job was first scheduled. |
| */ |
| private void maybeBuildBackoffPolicyFromXml(JobInfo.Builder jobBuilder, XmlPullParser parser) { |
| String val = parser.getAttributeValue(null, "initial-backoff"); |
| if (val != null) { |
| long initialBackoff = Long.parseLong(val); |
| val = parser.getAttributeValue(null, "backoff-policy"); |
| int backoffPolicy = Integer.parseInt(val); // Will throw NFE which we catch higher up. |
| jobBuilder.setBackoffCriteria(initialBackoff, backoffPolicy); |
| } |
| } |
| |
| /** |
| * Extract a job's earliest/latest run time data from XML. These are returned in |
| * unadjusted UTC wall clock time, because we do not yet know whether the system |
| * clock is reliable for purposes of calculating deltas from 'now'. |
| * |
| * @param parser |
| * @return A Pair of timestamps in UTC wall-clock time. The first is the earliest |
| * time at which the job is to become runnable, and the second is the deadline at |
| * which it becomes overdue to execute. |
| * @throws NumberFormatException |
| */ |
| private Pair<Long, Long> buildRtcExecutionTimesFromXml(XmlPullParser parser) |
| throws NumberFormatException { |
| String val; |
| // Pull out execution time data. |
| val = parser.getAttributeValue(null, "delay"); |
| final long earliestRunTimeRtc = (val != null) |
| ? Long.parseLong(val) |
| : JobStatus.NO_EARLIEST_RUNTIME; |
| val = parser.getAttributeValue(null, "deadline"); |
| final long latestRunTimeRtc = (val != null) |
| ? Long.parseLong(val) |
| : JobStatus.NO_LATEST_RUNTIME; |
| return Pair.create(earliestRunTimeRtc, latestRunTimeRtc); |
| } |
| } |
| |
| static final class JobSet { |
| @VisibleForTesting // Key is the getUid() originator of the jobs in each sheaf |
| final SparseArray<ArraySet<JobStatus>> mJobs; |
| |
| @VisibleForTesting // Same data but with the key as getSourceUid() of the jobs in each sheaf |
| final SparseArray<ArraySet<JobStatus>> mJobsPerSourceUid; |
| |
| public JobSet() { |
| mJobs = new SparseArray<ArraySet<JobStatus>>(); |
| mJobsPerSourceUid = new SparseArray<>(); |
| } |
| |
| public List<JobStatus> getJobsByUid(int uid) { |
| ArrayList<JobStatus> matchingJobs = new ArrayList<JobStatus>(); |
| ArraySet<JobStatus> jobs = mJobs.get(uid); |
| if (jobs != null) { |
| matchingJobs.addAll(jobs); |
| } |
| return matchingJobs; |
| } |
| |
| // By user, not by uid, so we need to traverse by key and check |
| public List<JobStatus> getJobsByUser(int userId) { |
| final ArrayList<JobStatus> result = new ArrayList<JobStatus>(); |
| for (int i = mJobsPerSourceUid.size() - 1; i >= 0; i--) { |
| if (UserHandle.getUserId(mJobsPerSourceUid.keyAt(i)) == userId) { |
| final ArraySet<JobStatus> jobs = mJobsPerSourceUid.valueAt(i); |
| if (jobs != null) { |
| result.addAll(jobs); |
| } |
| } |
| } |
| return result; |
| } |
| |
| public boolean add(JobStatus job) { |
| final int uid = job.getUid(); |
| final int sourceUid = job.getSourceUid(); |
| ArraySet<JobStatus> jobs = mJobs.get(uid); |
| if (jobs == null) { |
| jobs = new ArraySet<JobStatus>(); |
| mJobs.put(uid, jobs); |
| } |
| ArraySet<JobStatus> jobsForSourceUid = mJobsPerSourceUid.get(sourceUid); |
| if (jobsForSourceUid == null) { |
| jobsForSourceUid = new ArraySet<>(); |
| mJobsPerSourceUid.put(sourceUid, jobsForSourceUid); |
| } |
| final boolean added = jobs.add(job); |
| final boolean addedInSource = jobsForSourceUid.add(job); |
| if (added != addedInSource) { |
| Slog.wtf(TAG, "mJobs and mJobsPerSourceUid mismatch; caller= " + added |
| + " source= " + addedInSource); |
| } |
| return added || addedInSource; |
| } |
| |
| public boolean remove(JobStatus job) { |
| final int uid = job.getUid(); |
| final ArraySet<JobStatus> jobs = mJobs.get(uid); |
| final int sourceUid = job.getSourceUid(); |
| final ArraySet<JobStatus> jobsForSourceUid = mJobsPerSourceUid.get(sourceUid); |
| final boolean didRemove = jobs != null && jobs.remove(job); |
| final boolean sourceRemove = jobsForSourceUid != null && jobsForSourceUid.remove(job); |
| if (didRemove != sourceRemove) { |
| Slog.wtf(TAG, "Job presence mismatch; caller=" + didRemove |
| + " source=" + sourceRemove); |
| } |
| if (didRemove || sourceRemove) { |
| // no more jobs for this uid? let the now-empty set objects be GC'd. |
| if (jobs != null && jobs.size() == 0) { |
| mJobs.remove(uid); |
| } |
| if (jobsForSourceUid != null && jobsForSourceUid.size() == 0) { |
| mJobsPerSourceUid.remove(sourceUid); |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Removes the jobs of all users not specified by the whitelist of user ids. |
| * This will remove jobs scheduled *by* non-existent users as well as jobs scheduled *for* |
| * non-existent users |
| */ |
| public void removeJobsOfNonUsers(final int[] whitelist) { |
| final Predicate<JobStatus> noSourceUser = |
| job -> !ArrayUtils.contains(whitelist, job.getSourceUserId()); |
| final Predicate<JobStatus> noCallingUser = |
| job -> !ArrayUtils.contains(whitelist, job.getUserId()); |
| removeAll(noSourceUser.or(noCallingUser)); |
| } |
| |
| private void removeAll(Predicate<JobStatus> predicate) { |
| for (int jobSetIndex = mJobs.size() - 1; jobSetIndex >= 0; jobSetIndex--) { |
| final ArraySet<JobStatus> jobs = mJobs.valueAt(jobSetIndex); |
| for (int jobIndex = jobs.size() - 1; jobIndex >= 0; jobIndex--) { |
| if (predicate.test(jobs.valueAt(jobIndex))) { |
| jobs.removeAt(jobIndex); |
| } |
| } |
| if (jobs.size() == 0) { |
| mJobs.removeAt(jobSetIndex); |
| } |
| } |
| for (int jobSetIndex = mJobsPerSourceUid.size() - 1; jobSetIndex >= 0; jobSetIndex--) { |
| final ArraySet<JobStatus> jobs = mJobsPerSourceUid.valueAt(jobSetIndex); |
| for (int jobIndex = jobs.size() - 1; jobIndex >= 0; jobIndex--) { |
| if (predicate.test(jobs.valueAt(jobIndex))) { |
| jobs.removeAt(jobIndex); |
| } |
| } |
| if (jobs.size() == 0) { |
| mJobsPerSourceUid.removeAt(jobSetIndex); |
| } |
| } |
| } |
| |
| public boolean contains(JobStatus job) { |
| final int uid = job.getUid(); |
| ArraySet<JobStatus> jobs = mJobs.get(uid); |
| return jobs != null && jobs.contains(job); |
| } |
| |
| public JobStatus get(int uid, int jobId) { |
| ArraySet<JobStatus> jobs = mJobs.get(uid); |
| if (jobs != null) { |
| for (int i = jobs.size() - 1; i >= 0; i--) { |
| JobStatus job = jobs.valueAt(i); |
| if (job.getJobId() == jobId) { |
| return job; |
| } |
| } |
| } |
| return null; |
| } |
| |
| // Inefficient; use only for testing |
| public List<JobStatus> getAllJobs() { |
| ArrayList<JobStatus> allJobs = new ArrayList<JobStatus>(size()); |
| for (int i = mJobs.size() - 1; i >= 0; i--) { |
| ArraySet<JobStatus> jobs = mJobs.valueAt(i); |
| if (jobs != null) { |
| // Use a for loop over the ArraySet, so we don't need to make its |
| // optional collection class iterator implementation or have to go |
| // through a temporary array from toArray(). |
| for (int j = jobs.size() - 1; j >= 0; j--) { |
| allJobs.add(jobs.valueAt(j)); |
| } |
| } |
| } |
| return allJobs; |
| } |
| |
| public void clear() { |
| mJobs.clear(); |
| mJobsPerSourceUid.clear(); |
| } |
| |
| public int size() { |
| int total = 0; |
| for (int i = mJobs.size() - 1; i >= 0; i--) { |
| total += mJobs.valueAt(i).size(); |
| } |
| return total; |
| } |
| |
| // We only want to count the jobs that this uid has scheduled on its own |
| // behalf, not those that the app has scheduled on someone else's behalf. |
| public int countJobsForUid(int uid) { |
| int total = 0; |
| ArraySet<JobStatus> jobs = mJobs.get(uid); |
| if (jobs != null) { |
| for (int i = jobs.size() - 1; i >= 0; i--) { |
| JobStatus job = jobs.valueAt(i); |
| if (job.getUid() == job.getSourceUid()) { |
| total++; |
| } |
| } |
| } |
| return total; |
| } |
| |
| public void forEachJob(@Nullable Predicate<JobStatus> filterPredicate, |
| Consumer<JobStatus> functor) { |
| for (int uidIndex = mJobs.size() - 1; uidIndex >= 0; uidIndex--) { |
| ArraySet<JobStatus> jobs = mJobs.valueAt(uidIndex); |
| if (jobs != null) { |
| for (int i = jobs.size() - 1; i >= 0; i--) { |
| final JobStatus jobStatus = jobs.valueAt(i); |
| if ((filterPredicate == null) || filterPredicate.test(jobStatus)) { |
| functor.accept(jobStatus); |
| } |
| } |
| } |
| } |
| } |
| |
| public void forEachJob(int callingUid, Consumer<JobStatus> functor) { |
| ArraySet<JobStatus> jobs = mJobs.get(callingUid); |
| if (jobs != null) { |
| for (int i = jobs.size() - 1; i >= 0; i--) { |
| functor.accept(jobs.valueAt(i)); |
| } |
| } |
| } |
| |
| public void forEachJobForSourceUid(int sourceUid, Consumer<JobStatus> functor) { |
| final ArraySet<JobStatus> jobs = mJobsPerSourceUid.get(sourceUid); |
| if (jobs != null) { |
| for (int i = jobs.size() - 1; i >= 0; i--) { |
| functor.accept(jobs.valueAt(i)); |
| } |
| } |
| } |
| } |
| } |