8 | signing.secretKeyRingFile=/home/yboyar/src/android-priority-jobqueue/secring.gpg
9 | GROUP=com.birbit
10 | VERSION_NAME=3.0.0
11 |
12 | POM_DESCRIPTION=a Job Queue specifically written for Android to easily schedule jobs (tasks) that run in the background, improving UX and application stability.
13 | POM_INCEPTION_YEAR=2016
14 |
15 | POM_URL=https://github.com/yigit/android-priority-jobqueue/
16 | POM_SCM_URL=https://github.com/yigit/android-priority-jobqueue/
17 | POM_SCM_CONNECTION=scm:git:git://github.com/yigit/android-priority-jobqueue.git
18 | POM_SCM_DEV_CONNECTION=scm:git:ssh://git@github.com/yigit/android-priority-jobqueue.git
19 |
20 | POM_LICENCE_NAME=The MIT License (MIT)
21 | POM_LICENCE_URL=http://opensource.org/licenses/MIT
22 | POM_LICENCE_DIST=repo
23 |
24 | POM_DEVELOPER_ID=yigit
25 | POM_DEVELOPER_NAME=Yigit Boyar
26 |
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yigit/android-priority-jobqueue/360c090857eb0f6efbdde04a7c8bb5cc31582eb9/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-6.1-all.zip
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 |
--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
1 | @rem
2 | @rem Copyright 2015 the original author or authors.
3 | @rem
4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
5 | @rem you may not use this file except in compliance with the License.
6 | @rem You may obtain a copy of the License at
7 | @rem
8 | @rem https://www.apache.org/licenses/LICENSE-2.0
9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 |
17 | @if "%DEBUG%" == "" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 |
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 |
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%" == "" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 |
32 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
33 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
34 |
35 | @rem Find java.exe
36 | if defined JAVA_HOME goto findJavaFromJavaHome
37 |
38 | set JAVA_EXE=java.exe
39 | %JAVA_EXE% -version >NUL 2>&1
40 | if "%ERRORLEVEL%" == "0" goto init
41 |
42 | echo.
43 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
44 | echo.
45 | echo Please set the JAVA_HOME variable in your environment to match the
46 | echo location of your Java installation.
47 |
48 | goto fail
49 |
50 | :findJavaFromJavaHome
51 | set JAVA_HOME=%JAVA_HOME:"=%
52 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
53 |
54 | if exist "%JAVA_EXE%" goto init
55 |
56 | echo.
57 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
58 | echo.
59 | echo Please set the JAVA_HOME variable in your environment to match the
60 | echo location of your Java installation.
61 |
62 | goto fail
63 |
64 | :init
65 | @rem Get command-line arguments, handling Windows variants
66 |
67 | if not "%OS%" == "Windows_NT" goto win9xME_args
68 |
69 | :win9xME_args
70 | @rem Slurp the command line arguments.
71 | set CMD_LINE_ARGS=
72 | set _SKIP=2
73 |
74 | :win9xME_args_slurp
75 | if "x%~1" == "x" goto execute
76 |
77 | set CMD_LINE_ARGS=%*
78 |
79 | :execute
80 | @rem Setup the command line
81 |
82 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
83 |
84 | @rem Execute Gradle
85 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
86 |
87 | :end
88 | @rem End local scope for the variables with windows NT shell
89 | if "%ERRORLEVEL%"=="0" goto mainEnd
90 |
91 | :fail
92 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
93 | rem the _cmd.exe /c_ return code!
94 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
95 | exit /b 1
96 |
97 | :mainEnd
98 | if "%OS%"=="Windows_NT" endlocal
99 |
100 | :omega
101 |
--------------------------------------------------------------------------------
/jobqueue/LICENSE.txt:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2013 Path, Inc.
4 | Copyright (c) 2014 Google, Inc.
5 |
6 | Permission is hereby granted, free of charge, to any person obtaining a copy
7 | of this software and associated documentation files (the "Software"), to deal
8 | in the Software without restriction, including without limitation the rights
9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 |
13 | The above copyright notice and this permission notice shall be included in
14 | all copies or substantial portions of the Software.
15 |
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 | THE SOFTWARE.
--------------------------------------------------------------------------------
/jobqueue/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.library'
2 | apply plugin: 'com.vanniktech.maven.publish'
3 |
4 | dependencies {
5 | testImplementation 'junit:junit:4.12'
6 | testImplementation "org.robolectric:robolectric:4.3.1"
7 | testImplementation 'org.hamcrest:hamcrest-core:1.3'
8 | testImplementation 'org.easytesting:fest-util:1.2.5'
9 | testImplementation 'org.easytesting:fest-reflect:1.4.1'
10 | testImplementation 'org.mockito:mockito-core:2.7.13'
11 | testImplementation 'androidx.core:core:1.1.0'
12 | testImplementation 'com.google.android.gms:play-services-gcm:17.0.0'
13 |
14 | implementation 'com.squareup.okio:okio:1.17.5'
15 |
16 | compileOnly 'com.google.android.gms:play-services-gcm:17.0.0'
17 | }
18 |
19 | android {
20 | compileSdkVersion 29
21 | buildTypes {
22 | debug {
23 | testCoverageEnabled = true
24 | }
25 | release {
26 | testCoverageEnabled = false
27 | }
28 | }
29 |
30 | defaultConfig {
31 | minSdkVersion 14
32 | }
33 |
34 | testOptions {
35 | unitTests.all {
36 | // All the usual Gradle options.
37 | jvmArgs '-Xmx2000m', '-XX:+HeapDumpOnOutOfMemoryError', "-XX:HeapDumpPath=${System.env.CIRCLE_ARTIFACTS == null ? "." : System.env.CIRCLE_ARTIFACTS}/oom.hprof"
38 | }
39 | }
40 |
41 | lintOptions {
42 | warning 'InvalidPackage'
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/jobqueue/gradle.properties:
--------------------------------------------------------------------------------
1 | POM_ARTIFACT_ID=android-priority-jobqueue
2 | POM_NAME=Android Priority Job Queue
3 | POM_PACKAGING=aar
--------------------------------------------------------------------------------
/jobqueue/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/AsyncAddCallback.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import android.app.Activity;
4 |
5 | /**
6 | * If you are adding the job via the async adder, you can provide a callback method to confirm when it was added.
7 | * Please keep in mind that job manager will keep a strong reference to this callback. So if the callback is an
8 | * anonymous class inside an {@link Activity} context, it may leak the activity until the job is added.
9 | */
10 | public interface AsyncAddCallback {
11 | void onAdded();
12 | }
13 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/CancelReason.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import androidx.annotation.IntDef;
4 |
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 |
8 | /**
9 | * A list of possible reasons why a Job was cancelled. A reason will be passed to {@link Job#onCancel(int, Throwable)}.
10 | */
11 | @Retention(RetentionPolicy.SOURCE)
12 | @IntDef({CancelReason.REACHED_RETRY_LIMIT,
13 | CancelReason.CANCELLED_WHILE_RUNNING,
14 | CancelReason.SINGLE_INSTANCE_WHILE_RUNNING,
15 | CancelReason.CANCELLED_VIA_SHOULD_RE_RUN,
16 | CancelReason.SINGLE_INSTANCE_ID_QUEUED,
17 | CancelReason.REACHED_DEADLINE})
18 | public @interface CancelReason {
19 | /**
20 | * Used when a job was added while another job with the same single instance ID was already
21 | * queued and not running. This job got cancelled immediately after being added and will not run.
22 | */
23 | int SINGLE_INSTANCE_ID_QUEUED = 1;
24 | /**
25 | * Used when job throws an exception in {@link Job#onRun()}
26 | * and will be cancelled because it has reached its retry limit.
27 | *
28 | * @see Job#getRetryLimit()
29 | */
30 | int REACHED_RETRY_LIMIT = JobHolder.RUN_RESULT_FAIL_RUN_LIMIT;
31 |
32 | /**
33 | * Used when a job is cancelled via {@link JobManager#cancelJobs(TagConstraint, String...)}.
34 | * It might be waiting to be run or might have thrown an exception in {@link Job#onRun()}.
35 | *
36 | * @see JobManager#cancelJobs(TagConstraint, String...)
37 | * @see JobManager#cancelJobsInBackground(CancelResult.AsyncCancelCallback, TagConstraint, String...)
38 | */
39 | int CANCELLED_WHILE_RUNNING = JobHolder.RUN_RESULT_FAIL_FOR_CANCEL;
40 |
41 | /**
42 | * Used when job throws an exception in {@link Job#onRun()}
43 | * and will be cancelled because another job with the same single instance id was
44 | * queued while it was running.
45 | *
46 | * @see Job#getSingleInstanceId()
47 | */
48 | int SINGLE_INSTANCE_WHILE_RUNNING = JobHolder.RUN_RESULT_FAIL_SINGLE_ID;
49 |
50 | /**
51 | * Used when job throws an exception in {@link Job#onRun()}
52 | * and will be cancelled because it decided not to run again via
53 | * {@link Job#shouldReRunOnThrowable(Throwable, int, int)}.
54 | */
55 | int CANCELLED_VIA_SHOULD_RE_RUN = JobHolder.RUN_RESULT_FAIL_SHOULD_RE_RUN;
56 |
57 | /**
58 | * Used when a Job is cancelled for hitting its deadline.
59 | *
60 | * This means the job's params were constructed using
61 | * {@link Params#overrideDeadlineToCancelInMs(long)}.
62 | */
63 | int REACHED_DEADLINE = JobHolder.RUN_RESULT_HIT_DEADLINE;
64 |
65 | }
66 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/CancelResult.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import java.util.Collection;
4 |
5 | /**
6 | * This class holds the result of a cancel request via {@link JobManager#cancelJobs(TagConstraint, String...)}
7 | * or {@link JobManager#cancelJobsInBackground(CancelResult.AsyncCancelCallback, TagConstraint, String...)}.
8 | *
9 | * Cancelling jobs is an expensive operation because it requires JobManager to deserializer the job
10 | * from databases and call onCancel method on it.
11 | *
12 | * When cancelling jobs, if you need to get the list of cancelled jobs, you can provide this
13 | * callback to {@link JobManager#cancelJobsInBackground(CancelResult.AsyncCancelCallback, TagConstraint, String...)}
14 | * method.
15 | */
16 | public class CancelResult {
17 | private Collection cancelledJobs;
18 | private Collection failedToCancel;
19 |
20 | public CancelResult(Collection cancelledJobs, Collection failedToCancel) {
21 | this.cancelledJobs = cancelledJobs;
22 | this.failedToCancel = failedToCancel;
23 | }
24 |
25 | /**
26 | * @return The list of jobs that are cancelled before they did run
27 | */
28 | public Collection getCancelledJobs() {
29 | return cancelledJobs;
30 | }
31 |
32 | /**
33 | * @return The list of jobs that were running when cancel was called and onFinished running
34 | * successfully before they could be cancelled.
35 | */
36 | public Collection getFailedToCancel() {
37 | return failedToCancel;
38 | }
39 |
40 | public interface AsyncCancelCallback {
41 |
42 | /**
43 | * When job cancellation is complete, this method is called by the JobManager.
44 | *
45 | * @param cancelResult The result of the cancel request
46 | */
47 | void onCancelled(CancelResult cancelResult);
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/DefaultQueueFactory.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import com.birbit.android.jobqueue.inMemoryQueue.SimpleInMemoryPriorityQueue;
4 | import com.birbit.android.jobqueue.*;
5 | import com.birbit.android.jobqueue.cachedQueue.CachedJobQueue;
6 | import com.birbit.android.jobqueue.config.Configuration;
7 | import com.birbit.android.jobqueue.persistentQueue.sqlite.SqliteJobQueue;
8 |
9 | /**
10 | * Default implementation of QueueFactory that creates one {@link SqliteJobQueue} and
11 | * one {@link SimpleInMemoryPriorityQueue} both are wrapped inside a {@link CachedJobQueue} to
12 | * improve performance
13 | */
14 | public class DefaultQueueFactory implements QueueFactory {
15 | SqliteJobQueue.JobSerializer jobSerializer;
16 |
17 | public DefaultQueueFactory() {
18 | jobSerializer = new SqliteJobQueue.JavaSerializer();
19 | }
20 |
21 | public DefaultQueueFactory(SqliteJobQueue.JobSerializer jobSerializer) {
22 | this.jobSerializer = jobSerializer;
23 | }
24 |
25 | @Override
26 | public JobQueue createPersistentQueue(Configuration configuration, long sessionId) {
27 | return new CachedJobQueue(new SqliteJobQueue(configuration, sessionId, jobSerializer));
28 | }
29 |
30 | @Override
31 | public JobQueue createNonPersistent(Configuration configuration, long sessionId) {
32 | return new CachedJobQueue(new SimpleInMemoryPriorityQueue(configuration, sessionId));
33 | }
34 | }
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/IntCallback.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | /**
4 | * Internal interface to mimic sync requests.
5 | */
6 | public interface IntCallback {
7 | void onResult(int result);
8 | interface MessageWithCallback {
9 | void setCallback(IntCallback intCallback);
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/JobStatus.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | /**
4 | * Identifies the current status of a job if it is in the queue
5 | */
6 | public enum JobStatus {
7 | /**
8 | * Job is in the queue but cannot run yet.
9 | * As of v 1.1, this might be:
10 | *
11 | * - Job requires network but there is no available network connection
12 | * - Job is delayed. We are waiting for the time to pass
13 | *
14 | */
15 | WAITING_NOT_READY,
16 | /**
17 | * Job is in the queue, ready to be run. Waiting for an available consumer.
18 | */
19 | WAITING_READY,
20 | /**
21 | * Job is being executed by one of the runners.
22 | */
23 | RUNNING,
24 | /**
25 | * Job is not known by job queue.
26 | * This might be:
27 | *
28 | * - Invalid ID
29 | * - Job has been completed
30 | * - Job has failed
31 | * - Job has just been added, about to be delivered into a queue
32 | *
33 | *
34 | */
35 | UNKNOWN
36 | }
37 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/QueueFactory.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 |
4 | import com.birbit.android.jobqueue.JobQueue;
5 | import com.birbit.android.jobqueue.config.Configuration;
6 |
7 | public interface QueueFactory {
8 | JobQueue createPersistentQueue(Configuration configuration, long sessionId);
9 | JobQueue createNonPersistent(Configuration configuration, long sessionId);
10 | }
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/RunningJobSet.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import com.birbit.android.jobqueue.log.JqLog;
4 | import com.birbit.android.jobqueue.timer.Timer;
5 |
6 | import java.util.ArrayList;
7 | import java.util.Collection;
8 | import java.util.HashMap;
9 | import java.util.Iterator;
10 | import java.util.Map;
11 | import java.util.TreeSet;
12 |
13 | /**
14 | * a util class that holds running jobs sorted by name and unique.
15 | * it behaves like CopyOnWriteLists
16 | */
17 | public class RunningJobSet {
18 | private ArrayList publicClone;
19 | private final TreeSet internalSet;
20 | private final Map groupDelays;
21 | private long groupDelayTimeout;
22 | private final Timer timer;
23 |
24 | public RunningJobSet(Timer timer) {
25 | internalSet = new TreeSet<>();
26 | groupDelays = new HashMap<>();
27 | groupDelayTimeout = Long.MAX_VALUE;
28 | this.timer = timer;
29 | }
30 |
31 | public synchronized void addGroupUntil(String group, long until) {
32 | JqLog.d("add group delay to %s until %s", group, until);
33 | Long current = groupDelays.get(group);
34 | if (current != null) {
35 | if (current > until) {
36 | return; // nothing to change
37 | }
38 | }
39 | groupDelays.put(group, until);
40 | groupDelayTimeout = calculateNextDelayForGroups();
41 | publicClone = null;
42 | }
43 |
44 | public synchronized Collection getSafe() {
45 | final long now = timer.nanoTime();
46 | if(publicClone == null || now > groupDelayTimeout) {
47 | if (groupDelays.isEmpty()) {
48 | publicClone = new ArrayList<>(internalSet);
49 | groupDelayTimeout = Long.MAX_VALUE;
50 | } else {
51 | TreeSet tmpClone = new TreeSet<>(internalSet);
52 | Iterator> itr = groupDelays.entrySet().iterator();
53 | while(itr.hasNext()) {
54 | Map.Entry entry = itr.next();
55 | if (entry.getValue() > now) {
56 | if (!tmpClone.contains(entry.getKey())) {
57 | tmpClone.add(entry.getKey());
58 | }
59 | } else {
60 | itr.remove();
61 | }
62 | }
63 | publicClone = new ArrayList<>(tmpClone);
64 | groupDelayTimeout = calculateNextDelayForGroups();
65 | }
66 | }
67 | return publicClone;
68 | }
69 | public Long getNextDelayForGroups() {
70 | if (groupDelayTimeout == Long.MAX_VALUE) {
71 | return null;
72 | }
73 | return groupDelayTimeout;
74 | }
75 | private long calculateNextDelayForGroups() {
76 | long result = Long.MAX_VALUE;
77 | for (Long value : groupDelays.values()) {
78 | if (value < result) {
79 | result = value;
80 | }
81 | }
82 | return result;
83 | }
84 |
85 | public synchronized void add(String group) {
86 | if (group == null) {
87 | return;
88 | }
89 | if(internalSet.add(group)) {
90 | publicClone = null;//invalidate
91 | }
92 | }
93 |
94 | public synchronized void remove(String group) {
95 | if (group == null) {
96 | return;
97 | }
98 | if(internalSet.remove(group)) {
99 | publicClone = null;
100 | }
101 | }
102 |
103 | public synchronized void clear() {
104 | internalSet.clear();
105 | groupDelays.clear();
106 | publicClone = null;
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/TagConstraint.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import java.util.Collection;
4 | import java.util.Set;
5 |
6 | public enum TagConstraint {
7 | ALL,
8 | ANY;
9 | public boolean matches(String[] constraintTags, Set jobTags) {
10 | if (this == TagConstraint.ANY) {
11 | for (String tag : constraintTags) {
12 | if (jobTags.contains(tag)) {
13 | return true;
14 | }
15 | }
16 | return false;
17 | } else {
18 | for (String tag : constraintTags) {
19 | if (!jobTags.contains(tag)) {
20 | return false;
21 | }
22 | }
23 | return true;
24 | }
25 | }
26 |
27 | public boolean matches(Collection constraintTags, Set jobTags) {
28 | if (this == TagConstraint.ANY) {
29 | for (String tag : constraintTags) {
30 | if (jobTags.contains(tag)) {
31 | return true;
32 | }
33 | }
34 | return false;
35 | } else {
36 | for (String tag : constraintTags) {
37 | if (!jobTags.contains(tag)) {
38 | return false;
39 | }
40 | }
41 | return true;
42 | }
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/WrongThreadException.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | /**
4 | * Called when a method is called in the wrong thread. There are 2 thread restrictions:
5 | *
6 | * Some methods of the JobManager cannot be called on its own Thread where your Job's onRun method
7 | * is executed. If you call any of these methods in that method, you'll receive this exception.
8 | *
9 | * Some methods of the JobManager may take a long time to execute. If you call these methods on
10 | * the main thread, it will thrown an exception.
11 | */
12 | public class WrongThreadException extends RuntimeException {
13 | public WrongThreadException(String detailMessage) {
14 | super(detailMessage);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/cachedQueue/CachedJobQueue.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.cachedQueue;
2 |
3 | import androidx.annotation.NonNull;
4 | import androidx.annotation.Nullable;
5 |
6 | import com.birbit.android.jobqueue.Constraint;
7 | import com.birbit.android.jobqueue.JobHolder;
8 | import com.birbit.android.jobqueue.JobQueue;
9 |
10 | import java.util.Set;
11 |
12 | /**
13 | * a class that implements {@link JobQueue} interface, wraps another {@link JobQueue} and caches
14 | * results to avoid unnecessary queries to wrapped JobQueue.
15 | * does very basic caching but should be sufficient for most of the repeated cases
16 | * element
17 | */
18 | public class CachedJobQueue implements JobQueue {
19 | private JobQueue delegate;
20 | private Integer cachedCount;
21 |
22 | public CachedJobQueue(JobQueue delegate) {
23 | this.delegate = delegate;
24 | }
25 |
26 | @Override
27 | public boolean insert(@NonNull JobHolder jobHolder) {
28 | invalidateCache();
29 | return delegate.insert(jobHolder);
30 | }
31 |
32 | private void invalidateCache() {
33 | cachedCount = null;
34 | }
35 |
36 | @Override
37 | public boolean insertOrReplace(@NonNull JobHolder jobHolder) {
38 | invalidateCache();
39 | return delegate.insertOrReplace(jobHolder);
40 | }
41 |
42 | @Override
43 | public void substitute(@NonNull JobHolder newJob, @NonNull JobHolder oldJob) {
44 | invalidateCache();
45 | delegate.substitute(newJob, oldJob);
46 | }
47 |
48 | @Override
49 | public void remove(@NonNull JobHolder jobHolder) {
50 | invalidateCache();
51 | delegate.remove(jobHolder);
52 | }
53 |
54 | @Override
55 | public int count() {
56 | if(cachedCount == null) {
57 | cachedCount = delegate.count();
58 | }
59 | return cachedCount;
60 | }
61 |
62 | private boolean isEmpty() {
63 | return cachedCount != null && cachedCount == 0;
64 | }
65 |
66 | @Override
67 | public int countReadyJobs(@NonNull Constraint constraint) {
68 | if (isEmpty()) {
69 | return 0;
70 | }
71 | return delegate.countReadyJobs(constraint);
72 | }
73 |
74 | @Override
75 | public JobHolder nextJobAndIncRunCount(@NonNull Constraint constraint) {
76 | if(isEmpty()) {
77 | return null;//we know we are empty, no need for querying
78 | }
79 | JobHolder holder = delegate.nextJobAndIncRunCount(constraint);
80 | if (holder != null && cachedCount != null) {
81 | cachedCount -= 1;
82 | }
83 | return holder;
84 | }
85 |
86 | @Override
87 | public Long getNextJobDelayUntilNs(@NonNull Constraint constraint) {
88 | return delegate.getNextJobDelayUntilNs(constraint);
89 | }
90 |
91 | @Override
92 | public void clear() {
93 | invalidateCache();
94 | delegate.clear();
95 | }
96 |
97 | @Override
98 | @NonNull
99 | public Set findJobs(@NonNull Constraint constraint) {
100 | return delegate.findJobs(constraint);
101 | }
102 |
103 | @Override
104 | public void onJobCancelled(@NonNull JobHolder holder) {
105 | invalidateCache();
106 | delegate.onJobCancelled(holder);
107 | }
108 |
109 | @Override
110 | @Nullable
111 | public JobHolder findJobById(@NonNull String id) {
112 | return delegate.findJobById(id);
113 | }
114 | }
115 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/callback/JobManagerCallbackAdapter.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.callback;
2 |
3 | import androidx.annotation.NonNull;
4 | import androidx.annotation.Nullable;
5 |
6 | import com.birbit.android.jobqueue.Job;
7 |
8 | /**
9 | * An empty implementation of {@link JobManagerCallback}. You are advice to override this one
10 | * instead so that if new methods are added to the interface, your code won't break.
11 | */
12 | public class JobManagerCallbackAdapter implements JobManagerCallback {
13 | @Override
14 | public void onJobAdded(@NonNull Job job) {
15 |
16 | }
17 |
18 | @Override
19 | public void onJobRun(@NonNull Job job, int resultCode) {
20 |
21 | }
22 |
23 | @Override
24 | public void onJobCancelled(@NonNull Job job, boolean byCancelRequest, @Nullable Throwable throwable) {
25 |
26 | }
27 |
28 | @Override
29 | public void onDone(@NonNull Job job) {
30 |
31 | }
32 |
33 | @Override
34 | public void onAfterJobRun(@NonNull Job job, int resultCode) {
35 |
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/di/DependencyInjector.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.di;
2 |
3 | import com.birbit.android.jobqueue.Job;
4 |
5 | /**
6 | * interface that can be provided to {@link com.birbit.android.jobqueue.JobManager} for dependency injection
7 | * it is called before the job's onAdded method is called. for persistent jobs, also run after job is brought
8 | * back from disk.
9 | */
10 | public interface DependencyInjector {
11 | void inject(Job job);
12 | }
13 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/log/CustomLogger.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.log;
2 |
3 | /**
4 | * You can provide your own logger implementation to {@link com.birbit.android.jobqueue.JobManager}
5 | * it is very similar to Roboguice's logger
6 | */
7 | public interface CustomLogger {
8 | /**
9 | * JobManager may call this before logging something that is (relatively) expensive to calculate
10 | * @return True if debug logs are enabled
11 | */
12 | boolean isDebugEnabled();
13 | void d(String text, Object... args);
14 | void e(Throwable t, String text, Object... args);
15 | void e(String text, Object... args);
16 | void v(String text, Object... args);
17 | }
18 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/log/JqLog.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.log;
2 |
3 | import android.util.Log;
4 |
5 | /**
6 | * Wrapper around {@link CustomLogger}. by default, logs to nowhere
7 | */
8 | public class JqLog {
9 | private static CustomLogger customLogger;
10 | static {
11 | clearLogger();
12 | }
13 |
14 | public static void clearLogger() {
15 | setCustomLogger(new CustomLogger() {
16 | @Override
17 | public boolean isDebugEnabled() {
18 | return false;
19 | }
20 |
21 | @Override
22 | public void d(String text, Object... args) {
23 | //void
24 | }
25 |
26 | @Override
27 | public void e(Throwable t, String text, Object... args) {
28 | //void
29 | }
30 |
31 | @Override
32 | public void e(String text, Object... args) {
33 | //void
34 | }
35 |
36 | @Override
37 | public void v(String text, Object... args) {
38 | //void
39 | }
40 | });
41 | }
42 |
43 | public static void setCustomLogger(CustomLogger customLogger) {
44 | JqLog.customLogger = customLogger;
45 | }
46 |
47 | public static boolean isDebugEnabled() {
48 | return customLogger.isDebugEnabled();
49 | }
50 |
51 | public static void d(String text, Object... args) {
52 | customLogger.d(text, args);
53 | }
54 |
55 | public static void e(Throwable t, String text, Object... args) {
56 | customLogger.e(t, text, args);
57 | }
58 |
59 | public static void e(String text, Object... args) {
60 | customLogger.e(text, args);
61 | }
62 |
63 | public static void v(String text, Object... args) {
64 | customLogger.v(text, args);
65 | }
66 |
67 | public static class ErrorLogger implements CustomLogger {
68 | private static final String TAG = "JobManager";
69 | @Override
70 | public boolean isDebugEnabled() {
71 | return false;
72 | }
73 |
74 | @Override
75 | public void d(String text, Object... args) {
76 |
77 | }
78 |
79 | @Override
80 | public void e(Throwable t, String text, Object... args) {
81 | Log.e(TAG, String.format(text, args), t);
82 | }
83 |
84 | @Override
85 | public void e(String text, Object... args) {
86 | Log.e(TAG, String.format(text, args));
87 | }
88 |
89 | @Override
90 | public void v(String text, Object... args) {
91 |
92 | }
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/DelayedMessageBag.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.log.JqLog;
4 |
5 | class DelayedMessageBag {
6 | Message queue = null;
7 | final MessageFactory factory;
8 |
9 | DelayedMessageBag(MessageFactory factory) {
10 | this.factory = factory;
11 | }
12 |
13 | Long flushReadyMessages(long now, MessageQueue addInto) {
14 | JqLog.d("flushing messages at time %s", now);
15 | while (queue != null && queue.readyNs <= now) {
16 | Message msg = queue;
17 | queue = msg.next;
18 | msg.next = null;
19 | addInto.post(msg);
20 | }
21 | if (queue != null) {
22 | JqLog.d("returning next ready at %d ns", (queue.readyNs - now));
23 | return queue.readyNs;
24 | }
25 | return null;
26 | }
27 | void add(Message message, long readyNs) {
28 | JqLog.d("add delayed message %s at time %s", message, readyNs);
29 | message.readyNs = readyNs;
30 | if (queue == null) {
31 | queue = message;
32 | return;
33 | }
34 | Message prev = null;
35 | Message curr = queue;
36 | while (curr != null && curr.readyNs <= readyNs) {
37 | prev = curr;
38 | curr = curr.next;
39 | }
40 | if (prev == null) {
41 | message.next = queue;
42 | queue = message;
43 | } else {
44 | prev.next = message;
45 | message.next = curr;
46 | }
47 | }
48 |
49 | public void clear() {
50 | while (queue != null) {
51 | Message curr = queue;
52 | queue = curr.next;
53 | factory.release(curr);
54 | }
55 | queue = null;
56 | }
57 |
58 | public void removeMessages(MessagePredicate predicate) {
59 | Message prev = null;
60 | Message curr = queue;
61 | while (curr != null) {
62 | final boolean remove = predicate.onMessage(curr);
63 | final Message next = curr.next;
64 | if (remove) {
65 | if (prev == null) {
66 | queue = curr.next;
67 | } else {
68 | prev.next = curr.next;
69 | }
70 | factory.release(curr);
71 | } else {
72 | prev = curr;
73 | }
74 | curr = next;
75 | }
76 | }
77 | }
78 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/Message.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | abstract public class Message {
4 | public final Type type;
5 | // used by the pool
6 | Message next;
7 | public long readyNs = Long.MIN_VALUE;
8 |
9 | protected Message(Type type) {
10 | this.type = type;
11 | }
12 |
13 | abstract protected void onRecycled();
14 |
15 | final void recycle() {
16 | next = null;
17 | readyNs = Long.MIN_VALUE;
18 | onRecycled();
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/MessageFactory.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.log.JqLog;
4 |
5 | import java.util.Arrays;
6 |
7 | public class MessageFactory {
8 | private static final int CACHE_LIMIT = 20;
9 | Message[] pools = new Message[Type.values().length];
10 | int[] counts = new int[pools.length];
11 |
12 | public MessageFactory() {
13 | Arrays.fill(counts, 0);
14 | }
15 |
16 | public T obtain(Class klass) {
17 | final Type type = Type.mapping.get(klass);
18 | //noinspection SynchronizationOnLocalVariableOrMethodParameter
19 | synchronized (type) {
20 | Message message = pools[type.ordinal()];
21 | if (message != null) {
22 | pools[type.ordinal()] = message.next;
23 | counts[type.ordinal()] -= 1;
24 | message.next = null;
25 | //noinspection unchecked
26 | return (T) message;
27 | }
28 | try {
29 | return klass.newInstance();
30 | } catch (InstantiationException e) {
31 | JqLog.e(e, "Cannot create an instance of " + klass + ". Make sure it has a empty" +
32 | " constructor.");
33 | } catch (IllegalAccessException e) {
34 | JqLog.e(e, "Cannot create an instance of " + klass + ". Make sure it has a public" +
35 | " empty constructor.");
36 | }
37 | }
38 | return null;
39 | }
40 | public void release(Message message) {
41 | final Type type = message.type;
42 | message.recycle();
43 | //noinspection SynchronizationOnLocalVariableOrMethodParameter
44 | synchronized (type) {
45 | if (counts[type.ordinal()] < CACHE_LIMIT) {
46 | message.next = pools[type.ordinal()];
47 | pools[type.ordinal()] = message;
48 | counts[type.ordinal()] += 1;
49 | }
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/MessagePredicate.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | public interface MessagePredicate {
4 | boolean onMessage(Message message);
5 | }
6 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/MessageQueue.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | public interface MessageQueue {
4 | void post(Message message);
5 | void postAt(Message message, long readyNs);
6 | void cancelMessages(MessagePredicate predicate);
7 | void stop();
8 | void consume(MessageQueueConsumer consumer);
9 | void clear();
10 | }
11 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/MessageQueueConsumer.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | public abstract class MessageQueueConsumer {
4 | abstract public void handleMessage(Message message);
5 | abstract public void onIdle();
6 | public void onStart() {
7 |
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/Type.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.messaging.message.AddJobMessage;
4 | import com.birbit.android.jobqueue.messaging.message.CallbackMessage;
5 | import com.birbit.android.jobqueue.messaging.message.CancelMessage;
6 | import com.birbit.android.jobqueue.messaging.message.CancelResultMessage;
7 | import com.birbit.android.jobqueue.messaging.message.CommandMessage;
8 | import com.birbit.android.jobqueue.messaging.message.ConstraintChangeMessage;
9 | import com.birbit.android.jobqueue.messaging.message.PublicQueryMessage;
10 | import com.birbit.android.jobqueue.messaging.message.JobConsumerIdleMessage;
11 | import com.birbit.android.jobqueue.messaging.message.RunJobMessage;
12 | import com.birbit.android.jobqueue.messaging.message.RunJobResultMessage;
13 | import com.birbit.android.jobqueue.messaging.message.SchedulerMessage;
14 |
15 | import java.util.HashMap;
16 | import java.util.Map;
17 |
18 | /**
19 | * All message types
20 | */
21 | public enum Type {
22 | CALLBACK(CallbackMessage.class, 0),
23 | CANCEL_RESULT_CALLBACK(CancelResultMessage.class, 0),
24 | RUN_JOB(RunJobMessage.class, 0),
25 | COMMAND(CommandMessage.class, 0),
26 | PUBLIC_QUERY(PublicQueryMessage.class, 0),
27 | JOB_CONSUMER_IDLE(JobConsumerIdleMessage.class, 0), // MUST ARRIVE AFTER JOB RESULT
28 | ADD_JOB(AddJobMessage.class, 1),
29 | CANCEL(CancelMessage.class, 1),
30 | CONSTRAINT_CHANGE(ConstraintChangeMessage.class, 2),
31 | RUN_JOB_RESULT(RunJobResultMessage.class, 3),
32 | SCHEDULER(SchedulerMessage.class, 4);
33 | final Class klass;
34 | final static Map, Type> mapping;
35 | final int priority; // higher is better
36 | final static int MAX_PRIORITY;
37 |
38 | Type(Class klass, int priority) {
39 | this.klass = klass;
40 | this.priority = priority;
41 | }
42 | static {
43 | int maxPriority = 0;
44 | mapping = new HashMap<>();
45 | for (Type type : Type.values()) {
46 | mapping.put(type.klass, type);
47 | if (type.priority > maxPriority) {
48 | maxPriority = type.priority;
49 | }
50 | }
51 | MAX_PRIORITY = maxPriority;
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/UnsafeMessageQueue.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.log.JqLog;
4 |
5 | import java.util.concurrent.atomic.AtomicInteger;
6 |
7 | class UnsafeMessageQueue {
8 | private Message queue = null;
9 | private Message tail = null;
10 | private static final AtomicInteger idCounter = new AtomicInteger(0);
11 | public final String logTag;
12 | private final MessageFactory factory;
13 |
14 | public UnsafeMessageQueue(MessageFactory factory, String logTag) {
15 | this.factory = factory;
16 | this.logTag = logTag + "_" + idCounter.incrementAndGet();
17 | }
18 |
19 | Message next() {
20 | final Message result = queue;
21 | JqLog.d("[%s] remove message %s", logTag, result);
22 | if (result != null) {
23 | queue = result.next;
24 | if (tail == result) {
25 | tail = null;
26 | }
27 | }
28 | return result;
29 | }
30 |
31 | protected void post(Message message) {
32 | JqLog.d("[%s] post message %s", logTag, message);
33 | if (tail == null) {
34 | queue = message;
35 | tail = message;
36 | } else {
37 | tail.next = message;
38 | tail = message;
39 | }
40 | }
41 |
42 | protected void postAtFront(Message message) {
43 | message.next = queue;
44 | if (tail == null) {
45 | tail = message;
46 | }
47 | queue = message;
48 | }
49 |
50 | protected void removeMessages(MessagePredicate predicate) {
51 | Message prev = null;
52 | Message curr = queue;
53 | while (curr != null) {
54 | final boolean remove = predicate.onMessage(curr);
55 | if (remove) {
56 | final Message next = curr.next;
57 | remove(prev, curr);
58 | curr = next;
59 | } else {
60 | prev = curr;
61 | curr = curr.next;
62 | }
63 | }
64 | }
65 |
66 | private void remove(Message prev, Message curr) {
67 | if (tail == curr) {
68 | tail = prev;
69 | }
70 | if (prev == null) {
71 | queue = curr.next;
72 | } else {
73 | prev.next = curr.next;
74 | }
75 | factory.release(curr);
76 | }
77 |
78 | public void clear() {
79 | while (queue != null) {
80 | Message curr = queue;
81 | queue = curr.next;
82 | factory.release(curr);
83 | }
84 | tail = null;
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/AddJobMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 | import com.birbit.android.jobqueue.Job;
6 |
7 | public class AddJobMessage extends Message {
8 | private Job job;
9 | public AddJobMessage() {
10 | super(Type.ADD_JOB);
11 | }
12 |
13 | public Job getJob() {
14 | return job;
15 | }
16 |
17 | public void setJob(Job job) {
18 | this.job = job;
19 | }
20 |
21 | @Override
22 | protected void onRecycled() {
23 | job = null;
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/CallbackMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import androidx.annotation.Nullable;
4 |
5 | import com.birbit.android.jobqueue.Job;
6 | import com.birbit.android.jobqueue.messaging.Message;
7 | import com.birbit.android.jobqueue.messaging.Type;
8 |
9 | /**
10 | * Used for external callbacks to user code
11 | */
12 | public class CallbackMessage extends Message {
13 | public static final int ON_ADDED = 1;
14 | public static final int ON_RUN = 2;
15 | public static final int ON_CANCEL = 3;
16 | public static final int ON_DONE = 4;
17 | public static final int ON_AFTER_RUN = 5;
18 |
19 | private int what;
20 | private int resultCode;
21 | private boolean byUserRequest;
22 | private Job job;
23 | @Nullable private Throwable throwable;
24 |
25 | public CallbackMessage() {
26 | super(Type.CALLBACK);
27 | }
28 |
29 | @Override
30 | protected void onRecycled() {
31 | job = null;
32 | throwable = null;
33 | }
34 |
35 | public void set(Job job, int what) {
36 | this.what = what;
37 | this.job = job;
38 | }
39 |
40 | public void set(Job job, int what, int resultCode) {
41 | this.what = what;
42 | this.resultCode = resultCode;
43 | this.job = job;
44 | }
45 |
46 | public void set(Job job, int what, boolean byUserRequest, @Nullable Throwable throwable) {
47 | this.what = what;
48 | this.byUserRequest = byUserRequest;
49 | this.job = job;
50 | this.throwable = throwable;
51 | }
52 |
53 | public int getWhat() {
54 | return what;
55 | }
56 |
57 | public int getResultCode() {
58 | return resultCode;
59 | }
60 |
61 | public boolean isByUserRequest() {
62 | return byUserRequest;
63 | }
64 |
65 | public Job getJob() {
66 | return job;
67 | }
68 |
69 | @Nullable
70 | public Throwable getThrowable() {
71 | return throwable;
72 | }
73 | }
74 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/CancelMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 | import com.birbit.android.jobqueue.CancelResult;
6 | import com.birbit.android.jobqueue.TagConstraint;
7 |
8 | public class CancelMessage extends Message {
9 | private TagConstraint constraint;
10 | private String[] tags;
11 | private CancelResult.AsyncCancelCallback callback;
12 |
13 | public CancelMessage() {
14 | super(Type.CANCEL);
15 | }
16 |
17 | @Override
18 | protected void onRecycled() {
19 |
20 | }
21 |
22 | public TagConstraint getConstraint() {
23 | return constraint;
24 | }
25 |
26 | public void setConstraint(TagConstraint constraint) {
27 | this.constraint = constraint;
28 | }
29 |
30 | public String[] getTags() {
31 | return tags;
32 | }
33 |
34 | public void setTags(String[] tags) {
35 | this.tags = tags;
36 | }
37 |
38 | public CancelResult.AsyncCancelCallback getCallback() {
39 | return callback;
40 | }
41 |
42 | public void setCallback(CancelResult.AsyncCancelCallback callback) {
43 | this.callback = callback;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/CancelResultMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 | import com.birbit.android.jobqueue.CancelResult;
6 |
7 | public class CancelResultMessage extends Message {
8 | CancelResult.AsyncCancelCallback callback;
9 | CancelResult result;
10 | public CancelResultMessage() {
11 | super(Type.CANCEL_RESULT_CALLBACK);
12 | }
13 |
14 | @Override
15 | protected void onRecycled() {
16 | result = null;
17 | callback = null;
18 | }
19 |
20 | public void set(CancelResult.AsyncCancelCallback callback, CancelResult result) {
21 | this.callback = callback;
22 | this.result = result;
23 | }
24 |
25 | public CancelResult.AsyncCancelCallback getCallback() {
26 | return callback;
27 | }
28 |
29 | public CancelResult getResult() {
30 | return result;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/CommandMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 |
6 | public class CommandMessage extends Message {
7 | public static final int QUIT = 1;
8 | public static final int POKE = 2; // simple message to wake it up
9 | public static final int RUNNABLE = 3; // only used in tests
10 | private int what;
11 |
12 | private Runnable runnable;
13 |
14 | public CommandMessage() {
15 | super(Type.COMMAND);
16 | }
17 |
18 | @Override
19 | protected void onRecycled() {
20 | what = -1;
21 | runnable = null;
22 | }
23 |
24 | public int getWhat() {
25 | return what;
26 | }
27 |
28 | public void set(int what) {
29 | this.what = what;
30 | }
31 |
32 | public Runnable getRunnable() {
33 | return runnable;
34 | }
35 |
36 | public void setRunnable(Runnable runnable) {
37 | this.runnable = runnable;
38 | }
39 |
40 | @Override
41 | public String toString() {
42 | return "Command[" + what + "]";
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/ConstraintChangeMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 |
6 | public class ConstraintChangeMessage extends Message {
7 | private boolean forNextJob;
8 | public ConstraintChangeMessage() {
9 | super(Type.CONSTRAINT_CHANGE);
10 | }
11 |
12 | @Override
13 | protected void onRecycled() {
14 | forNextJob = false;
15 | }
16 |
17 | public boolean isForNextJob() {
18 | return forNextJob;
19 | }
20 |
21 | public void setForNextJob(boolean forNextJob) {
22 | this.forNextJob = forNextJob;
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/JobConsumerIdleMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 |
6 | public class JobConsumerIdleMessage extends Message {
7 | private Object worker;
8 | private long lastJobCompleted;
9 |
10 | public JobConsumerIdleMessage() {
11 | super(Type.JOB_CONSUMER_IDLE);
12 | }
13 |
14 | @Override
15 | protected void onRecycled() {
16 | worker = null;
17 | }
18 |
19 | public long getLastJobCompleted() {
20 | return lastJobCompleted;
21 | }
22 |
23 | public Object getWorker() {
24 | return worker;
25 | }
26 |
27 | public void setWorker(Object worker) {
28 | this.worker = worker;
29 | }
30 |
31 | public void setLastJobCompleted(long lastJobCompleted) {
32 | this.lastJobCompleted = lastJobCompleted;
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/PublicQueryMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.IntCallback;
4 | import com.birbit.android.jobqueue.messaging.Message;
5 | import com.birbit.android.jobqueue.messaging.Type;
6 |
7 | public class PublicQueryMessage extends Message implements IntCallback.MessageWithCallback {
8 | public static final int COUNT = 0;
9 | public static final int COUNT_READY = 1;
10 | public static final int START = 2;
11 | public static final int STOP = 3;
12 | public static final int JOB_STATUS = 4;
13 | public static final int CLEAR = 5;
14 | public static final int ACTIVE_CONSUMER_COUNT = 6;
15 | public static final int SCHEDULER_START = 7;
16 | // used for testing
17 | public static final int INTERNAL_RUNNABLE = 101;
18 |
19 | private IntCallback callback;
20 | private int what = -1;
21 | private String stringArg;
22 |
23 | public PublicQueryMessage() {
24 | super(Type.PUBLIC_QUERY);
25 | }
26 |
27 | public void set(int what, IntCallback callback) {
28 | this.callback = callback;
29 | this.what = what;
30 | }
31 |
32 | public void set(int what, String stringArg, IntCallback callback) {
33 | this.what = what;
34 | this.stringArg = stringArg;
35 | this.callback = callback;
36 | }
37 |
38 | public IntCallback getCallback() {
39 | return callback;
40 | }
41 |
42 | public int getWhat() {
43 | return what;
44 | }
45 |
46 | public String getStringArg() {
47 | return stringArg;
48 | }
49 |
50 | public void setCallback(IntCallback callback) {
51 | this.callback = callback;
52 | }
53 |
54 | @Override
55 | protected void onRecycled() {
56 | callback = null;
57 | what = -1;
58 | }
59 |
60 | @Override
61 | public String toString() {
62 | return "PublicQuery[" + what + "]";
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/RunJobMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 | import com.birbit.android.jobqueue.JobHolder;
6 |
7 | public class RunJobMessage extends Message {
8 | private JobHolder jobHolder;
9 | public RunJobMessage() {
10 | super(Type.RUN_JOB);
11 | }
12 |
13 | public JobHolder getJobHolder() {
14 | return jobHolder;
15 | }
16 |
17 | public void setJobHolder(JobHolder jobHolder) {
18 | this.jobHolder = jobHolder;
19 | }
20 |
21 | @Override
22 | protected void onRecycled() {
23 | jobHolder = null;
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/RunJobResultMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import com.birbit.android.jobqueue.messaging.Message;
4 | import com.birbit.android.jobqueue.messaging.Type;
5 | import com.birbit.android.jobqueue.JobHolder;
6 |
7 | public class RunJobResultMessage extends Message {
8 | private JobHolder jobHolder;
9 | private Object worker;
10 | private int result;
11 |
12 | public RunJobResultMessage() {
13 | super(Type.RUN_JOB_RESULT);
14 | }
15 |
16 | public JobHolder getJobHolder() {
17 | return jobHolder;
18 | }
19 |
20 | public void setJobHolder(JobHolder jobHolder) {
21 | this.jobHolder = jobHolder;
22 | }
23 |
24 | @Override
25 | protected void onRecycled() {
26 | jobHolder = null;
27 | }
28 |
29 | public void setResult(int result) {
30 | this.result = result;
31 | }
32 |
33 | public int getResult() {
34 | return result;
35 | }
36 |
37 | public Object getWorker() {
38 | return worker;
39 | }
40 |
41 | public void setWorker(Object worker) {
42 | this.worker = worker;
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/messaging/message/SchedulerMessage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging.message;
2 |
3 | import androidx.annotation.NonNull;
4 |
5 | import com.birbit.android.jobqueue.messaging.Message;
6 | import com.birbit.android.jobqueue.messaging.Type;
7 | import com.birbit.android.jobqueue.scheduling.SchedulerConstraint;
8 |
9 | /**
10 | * The messages with the scheduler
11 | */
12 | public class SchedulerMessage extends Message {
13 | public static final int START = 1;
14 | public static final int STOP = 2;
15 |
16 | private int what;
17 | @SuppressWarnings("NullableProblems")
18 | @NonNull
19 | private SchedulerConstraint constraint;
20 |
21 | public SchedulerMessage() {
22 | super(Type.SCHEDULER);
23 | }
24 |
25 | public void set(int what, @NonNull SchedulerConstraint constraint) {
26 | this.what = what;
27 | this.constraint = constraint;
28 | }
29 |
30 | public int getWhat() {
31 | return what;
32 | }
33 |
34 | @NonNull
35 | public SchedulerConstraint getConstraint() {
36 | return constraint;
37 | }
38 |
39 | @Override
40 | protected void onRecycled() {
41 | //noinspection ConstantConditions
42 | constraint = null;
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/network/NetworkEventProvider.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.network;
2 |
3 | /**
4 | * An interface that NetworkUtil can implement if it supports a callback method when network state is changed
5 | * This is not mandatory but highly suggested so that {@link com.birbit.android.jobqueue.JobManager} can avoid
6 | * busy loops when there is a job waiting for network and there is no network available
7 | */
8 | public interface NetworkEventProvider {
9 | void setListener(Listener listener);
10 | interface Listener {
11 | /**
12 | * @param networkStatus {@link com.birbit.android.jobqueue.network.NetworkUtil.NetworkStatus}
13 | */
14 | void onNetworkChange(@NetworkUtil.NetworkStatus int networkStatus);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/network/NetworkUtil.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.network;
2 |
3 | import android.content.Context;
4 | import androidx.annotation.IntDef;
5 |
6 | import java.lang.annotation.Retention;
7 | import java.lang.annotation.RetentionPolicy;
8 |
9 | /**
10 | * Interface which you can implement if you want to provide a custom Network callback.
11 | * Make sure you also implement {@link NetworkEventProvider} for best performance.
12 | */
13 | public interface NetworkUtil {
14 | /**
15 | * Order of these constant values matter as they are relied upon to be incrementing in terms
16 | * of availability.
17 | */
18 | @Retention(RetentionPolicy.SOURCE)
19 | @IntDef({DISCONNECTED, METERED, UNMETERED})
20 | @interface NetworkStatus {}
21 | int DISCONNECTED = 0;
22 | int METERED = 1;
23 | int UNMETERED = 2;
24 |
25 | /**
26 | * Returns the current connection status. If you cannot detect granular network type, return
27 | * {@link #UNMETERED} if there is an internet connection or {@link #DISCONNECTED} if there is no
28 | * connection.
29 | *
30 | * @param context The application context
31 | *
32 | * @return The current connection status. It should be one of {@link #DISCONNECTED},
33 | * {@link #METERED} or {@link #UNMETERED}.
34 | */
35 | @NetworkStatus
36 | int getNetworkStatus(Context context);
37 | }
38 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/persistentQueue/sqlite/FileStorage.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.persistentQueue.sqlite;
2 |
3 |
4 | import android.content.Context;
5 | import androidx.annotation.Nullable;
6 |
7 | import com.birbit.android.jobqueue.log.JqLog;
8 |
9 | import java.io.Closeable;
10 | import java.io.File;
11 | import java.io.IOException;
12 | import java.util.Set;
13 |
14 | import okio.BufferedSink;
15 | import okio.BufferedSource;
16 | import okio.Okio;
17 |
18 | /**
19 | * Provides a toFile based storage to keep jobs.
20 | * This class is NOT thread safe and re-uses Buffers
21 | */
22 | class FileStorage {
23 | private static final String EXT = ".jobs";
24 | private final File folder;
25 | FileStorage(Context appContext, String id) {
26 | this.folder = new File(appContext.getDir("com_birbit_jobqueue_jobs", Context.MODE_PRIVATE),
27 | "files_" + id);
28 | //noinspection ResultOfMethodCallIgnored
29 | this.folder.mkdirs();
30 | }
31 |
32 | void delete(String id) {
33 | final File file = toFile(id);
34 | if (file.exists()) {
35 | //noinspection ResultOfMethodCallIgnored
36 | file.delete();
37 | }
38 | }
39 |
40 | @Nullable
41 | byte[] load(String id) throws IOException {
42 | final File file = toFile(id);
43 | if (file.exists() && file.canRead()) {
44 | BufferedSource source = Okio.buffer(Okio.source(file));
45 | try {
46 | return source.readByteArray();
47 | } finally {
48 | closeQuitely(source);
49 | }
50 |
51 | }
52 | return null;
53 | }
54 |
55 | void save(String id, byte[] data) throws IOException {
56 | final File file = toFile(id);
57 | BufferedSink sink = Okio.buffer(Okio.sink(file));
58 | try {
59 | sink.write(data).flush();
60 | } finally {
61 | closeQuitely(sink);
62 | }
63 | }
64 |
65 | private static String filename(String id) {
66 | return id + EXT;
67 | }
68 |
69 | private File toFile(String id) {
70 | return new File(folder, filename(id));
71 | }
72 |
73 | @Nullable
74 | private static String filenameToId(String filename) {
75 | if (filename.length() < EXT.length() + 1) {
76 | return null;
77 | }
78 | return filename.substring(0, filename.length() - EXT.length());
79 | }
80 |
81 | void truncateExcept(Set ids) {
82 | for (String filename : folder.list()) {
83 | if (!filename.endsWith(EXT)) {
84 | continue;
85 | }
86 | String id = filenameToId(filename);
87 | if (!ids.contains(id)) {
88 | File file = new File(folder, filename);
89 | if (!file.delete()) {
90 | JqLog.d("cannot delete unused job toFile " + file.getAbsolutePath());
91 | }
92 | }
93 | }
94 | }
95 |
96 | private static void closeQuitely(Closeable closeable) {
97 | try {
98 | closeable.close();
99 | } catch (IOException ignored) {
100 | }
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/scheduling/GcmJobSchedulerService.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.scheduling;
2 |
3 | import android.content.Context;
4 | import androidx.annotation.NonNull;
5 | import androidx.annotation.Nullable;
6 |
7 | import com.birbit.android.jobqueue.JobManager;
8 | import com.birbit.android.jobqueue.log.JqLog;
9 | import com.google.android.gms.gcm.GcmNetworkManager;
10 | import com.google.android.gms.gcm.GcmTaskService;
11 | import com.google.android.gms.gcm.TaskParams;
12 |
13 | abstract public class GcmJobSchedulerService extends GcmTaskService {
14 | /**
15 | * Creates a scheduler for the given service.
16 | * Keep in mind that there is a strict 1-1 mapping between the created scheduler and the
17 | * service. You should pass the returned scheduler to the JobManager configuration.
18 | *
19 | * @param appContext The application context
20 | * @param klass The service implementation that extends GcmJobSchedulerService.
21 | *
22 | * @return A scheduler that is associated with the given service class.
23 | */
24 | @SuppressWarnings("unused")
25 | public static GcmScheduler createSchedulerFor(Context appContext,
26 | Class klass) {
27 | if (GcmJobSchedulerService.class == klass) {
28 | throw new IllegalArgumentException("You must create a service that extends" +
29 | " GcmJobSchedulerService");
30 | }
31 | return new GcmScheduler(appContext.getApplicationContext(), klass);
32 | }
33 |
34 | @Override
35 | public int onRunTask(TaskParams taskParams) {
36 | GcmScheduler scheduler = getScheduler();
37 | if (scheduler != null) {
38 | return scheduler.onStartJob(taskParams);
39 | } else {
40 | JqLog.e("RunTask on GcmJobSchedulerService has been called but it does not have a " +
41 | "scheduler. Make sure you've initialized JobManager before the service might" +
42 | " be created.");
43 | return GcmNetworkManager.RESULT_FAILURE;
44 | }
45 |
46 | }
47 |
48 | @Nullable
49 | protected GcmScheduler getScheduler() {
50 | Scheduler scheduler = getJobManager().getScheduler();
51 | if (scheduler instanceof GcmScheduler) {
52 | return (GcmScheduler) scheduler;
53 | }
54 | JqLog.e("GcmJobSchedulerService has been created but the JobManager does not" +
55 | " have a scheduler created by GcmJobSchedulerService.");
56 | return null;
57 | }
58 |
59 | /**
60 | * Return the JobManager that is associated with this service
61 | *
62 | * @return The JobManager that is associated with this service
63 | */
64 | @NonNull
65 | protected abstract JobManager getJobManager();
66 |
67 | }
68 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/scheduling/Scheduler.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.scheduling;
2 |
3 | import android.content.Context;
4 |
5 | /**
6 | * This class handles communication and tracking with a scheduler that can wake up the app / job
7 | * manager based on external events.
8 | *
9 | * JobManager will call attached scheduler every time it thinks that the app should be waken up for
10 | * the given job. Each request comes with a {@link SchedulerConstraint} which should be reported
11 | * back to the JobManager when the system service wakes it up.
12 | */
13 | abstract public class Scheduler {
14 | private Callback callback;
15 | private Context context;
16 |
17 | protected Scheduler() {
18 |
19 | }
20 |
21 | public void init(Context context, Callback callback) {
22 | this.context = context.getApplicationContext();
23 | this.callback = callback;
24 | }
25 |
26 | Context getApplicationContext() {
27 | return context;
28 | }
29 |
30 | abstract public void request(SchedulerConstraint constraint);
31 |
32 | /**
33 | * Triggers the JobManager to handle the given constraint. JobManager always call
34 | * {@link #onFinished(SchedulerConstraint, boolean)} with an async callback.
35 | *
36 | * @param constraint The constraint
37 | * @return true if there is work to do be done, false otherwise
38 | */
39 | public final boolean start(SchedulerConstraint constraint) {
40 | if (callback == null) {
41 | throw new IllegalStateException("JobManager callback is not configured");
42 | }
43 | return callback.start(constraint);
44 | }
45 |
46 | public final boolean stop(SchedulerConstraint constraint) {
47 | if (callback == null) {
48 | throw new IllegalStateException("JobManager callback is not configured");
49 | }
50 | return callback.stop(constraint);
51 | }
52 |
53 | /**
54 | * Called by the JobManager when a scheduled constraint is handled.
55 | *
56 | * @param constraint The original constraint
57 | * @param reschedule True if the job should be rescheduled
58 | */
59 | abstract public void onFinished(SchedulerConstraint constraint, boolean reschedule);
60 |
61 | /**
62 | * When called, should cancel all pending jobs
63 | */
64 | public abstract void cancelAll();
65 |
66 | /**
67 | * Internal class that handles the communication between the JobManager and the scheduler
68 | */
69 | public interface Callback {
70 | /**
71 | * @param constraint The constraint for the jobs to be run
72 | * @return True if there are jobs to run, false otherwise
73 | */
74 | boolean start(SchedulerConstraint constraint);
75 |
76 | /**
77 | * @param constraint The constraint for the jobs to be run
78 | * @return True if job should be rescheduled, false otherwise
79 | */
80 | boolean stop(SchedulerConstraint constraint);
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/scheduling/SchedulerConstraint.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.scheduling;
2 |
3 | import androidx.annotation.Nullable;
4 |
5 | import com.birbit.android.jobqueue.network.NetworkUtil;
6 |
7 | /**
8 | * The constraints that are passed into Scheduler from JobManager
9 | */
10 | public class SchedulerConstraint {
11 | private String uuid;
12 | private long delayInMs;
13 | private int networkStatus;
14 | private Long overrideDeadlineInMs;
15 | // arbitrary data that can be used by the scheduler
16 | private Object data;
17 |
18 | public SchedulerConstraint(String uuid) {
19 | this.uuid = uuid;
20 | }
21 |
22 | /**
23 | * The unique id assigned by the job manager. This is different from the ID that is assigned
24 | * by the third party scheduler.
25 | * @return The unique id assigned by the job manager
26 | */
27 | public String getUuid() {
28 | return uuid;
29 | }
30 |
31 | public void setUuid(String uuid) {
32 | this.uuid = uuid;
33 | }
34 |
35 | /**
36 | * The delay for the job
37 | * @return The delay before running the job
38 | */
39 | public long getDelayInMs() {
40 | return delayInMs;
41 | }
42 |
43 | public void setDelayInMs(long delayInMs) {
44 | this.delayInMs = delayInMs;
45 | }
46 |
47 | /**
48 | *
49 | * @return The network status required to run the job.
50 | */
51 | @NetworkUtil.NetworkStatus
52 | public int getNetworkStatus() {
53 | return networkStatus;
54 | }
55 |
56 | public void setNetworkStatus(int networkStatus) {
57 | this.networkStatus = networkStatus;
58 | }
59 |
60 | public Object getData() {
61 | return data;
62 | }
63 |
64 | public void setData(Object data) {
65 | this.data = data;
66 | }
67 |
68 | /**
69 | * The deadline in ms after which the job should be run even if the constraints are not match.
70 | *
71 | * If there is no deadline, this will be null.
72 | *
73 | * @return The time in ms until the constraints timeout
74 | */
75 | @Nullable
76 | public Long getOverrideDeadlineInMs() {
77 | return overrideDeadlineInMs;
78 | }
79 |
80 | public void setOverrideDeadlineInMs(Long overrideDeadlineInMs) {
81 | this.overrideDeadlineInMs = overrideDeadlineInMs;
82 | }
83 |
84 | @Override
85 | public String toString() {
86 | return "SchedulerConstraint{" +
87 | "uuid='" + uuid + '\'' +
88 | ", delayInMs=" + delayInMs +
89 | ", networkStatus=" + networkStatus +
90 | ", overrideDeadlineInMs=" + overrideDeadlineInMs +
91 | ", data=" + data +
92 | '}';
93 | }
94 | }
95 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/timer/SystemTimer.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.timer;
2 |
3 | import com.birbit.android.jobqueue.log.JqLog;
4 |
5 | import java.util.concurrent.TimeUnit;
6 |
7 | public class SystemTimer implements Timer {
8 | final long startWallClock;
9 | final long startNs;
10 | public SystemTimer() {
11 | JqLog.d("creating system timer");
12 | //noinspection DIRECT_TIME_ACCESS
13 | startWallClock = TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
14 | //noinspection DIRECT_TIME_ACCESS
15 | startNs = System.nanoTime();
16 | }
17 |
18 | @Override
19 | public long nanoTime() {
20 | //noinspection DIRECT_TIME_ACCESS
21 | return System.nanoTime() - startNs + startWallClock;
22 | }
23 |
24 | @Override
25 | public void waitOnObjectUntilNs(Object object, long untilNs) throws InterruptedException {
26 | long now = nanoTime();
27 | if (now > untilNs) {
28 | //noinspection TIMED_WAIT
29 | object.wait(1);
30 | } else {
31 | TimeUnit.NANOSECONDS.timedWait(object, untilNs - now);
32 | }
33 | }
34 |
35 | @Override
36 | public void waitOnObject(Object object) throws InterruptedException {
37 | //noinspection TIMED_WAIT
38 | object.wait();
39 | }
40 |
41 | @Override
42 | public void notifyObject(Object object) {
43 | //noinspection NOTIFY_ON_OBJECT
44 | object.notifyAll();
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/jobqueue/src/main/java/com/birbit/android/jobqueue/timer/Timer.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.timer;
2 |
3 | public interface Timer {
4 | long nanoTime();
5 | void waitOnObjectUntilNs(Object object, long timeout) throws InterruptedException;
6 | void notifyObject(Object object);
7 | void waitOnObject(Object object) throws InterruptedException;
8 | }
9 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/ConsumerControllerTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | public class ConsumerControllerTest {
4 |
5 | }
6 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/JobManagerThreadRunnable.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import org.hamcrest.CoreMatchers;
4 | import org.hamcrest.MatcherAssert;
5 |
6 | import java.util.Collection;
7 | import java.util.concurrent.atomic.AtomicBoolean;
8 |
9 | public abstract class JobManagerThreadRunnable {
10 | JobManager jobManager;
11 | AtomicBoolean running = new AtomicBoolean(false);
12 | public JobManagerThreadRunnable(JobManager jobManager) {
13 | this.jobManager = jobManager;
14 | }
15 |
16 | private void assertRunning() {
17 | MatcherAssert.assertThat("can call this method only inside #onRun", running.get(),
18 | CoreMatchers.is(true));
19 | }
20 |
21 | protected JobHolder getNextJob() {
22 | assertRunning();
23 | return jobManager.jobManagerThread.getNextJobForTesting();
24 | }
25 |
26 | protected JobHolder getNextJob(Collection exclude) {
27 | assertRunning();
28 | return jobManager.jobManagerThread.getNextJobForTesting(exclude);
29 | }
30 |
31 | protected void removeJob(JobHolder jobHolder) {
32 | assertRunning();
33 | jobManager.jobManagerThread.nonPersistentJobQueue.remove(jobHolder);
34 | jobManager.jobManagerThread.persistentJobQueue.remove(jobHolder);
35 | }
36 |
37 | protected JobHolder findJobFromQueues(String id) {
38 | assertRunning();
39 | JobHolder holder = jobManager.jobManagerThread.nonPersistentJobQueue.findJobById(id);
40 | if (holder != null) {
41 | return holder;
42 | }
43 | return jobManager.jobManagerThread.persistentJobQueue.findJobById(id);
44 | }
45 |
46 | public T run() throws Throwable {
47 | final Object[] result = new Object[1];
48 | jobManager.internalRunInJobManagerThread(new Runnable() {
49 | @Override
50 | public void run() {
51 | try {
52 | running.set(true);
53 | result[0] = onRun();
54 | } finally {
55 | running.set(false);
56 | }
57 | }
58 | });
59 | //noinspection unchecked
60 | return (T) result[0];
61 | }
62 |
63 | public abstract T onRun();
64 | }
65 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/JobManagerTrojan.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | /**
4 | * Proxy class to access package locals
5 | */
6 | public class JobManagerTrojan {
7 | public static ConsumerManager getConsumerManager(JobManager jobManager) {
8 | return jobManager.jobManagerThread.consumerManager;
9 | }
10 |
11 | public static CallbackManager getCallbackManager(JobManager jobManager) {
12 | return jobManager.jobManagerThread.callbackManager;
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/SystemTimerTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import com.birbit.android.jobqueue.timer.SystemTimer;
4 |
5 | import org.hamcrest.BaseMatcher;
6 | import org.hamcrest.Description;
7 | import org.hamcrest.MatcherAssert;
8 | import org.junit.Test;
9 | import org.junit.runner.RunWith;
10 | import org.junit.runners.JUnit4;
11 |
12 | import android.annotation.SuppressLint;
13 |
14 | import java.util.concurrent.TimeUnit;
15 |
16 | @RunWith(JUnit4.class)
17 | public class SystemTimerTest {
18 | @SuppressLint({"DIRECT_TIME_ACCESS","SLEEP_IN_CODE"})
19 | @Test
20 | public void testNow() throws Throwable {
21 | SystemTimer timer = new SystemTimer();
22 | //noinspection DIRECT_TIME_ACCESS
23 | long startNs = System.nanoTime();
24 | //noinspection DIRECT_TIME_ACCESS
25 | long start = TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
26 | //noinspection SLEEP_IN_CODE
27 | Thread.sleep(3000);
28 | assertReasonable(timer.nanoTime(), System.nanoTime() - startNs + start);
29 | SystemTimer timer2 = new SystemTimer();
30 | assertReasonable(timer2.nanoTime(), System.nanoTime() - startNs + start);
31 | }
32 |
33 | @SuppressLint("DIRECT_TIME_ACCESS")
34 | @Test
35 | public void testWaitOnObject() throws Throwable {
36 | SystemTimer timer = new SystemTimer();
37 | //noinspection DIRECT_TIME_ACCESS
38 | long startRealTime = System.nanoTime();
39 | long startNs = timer.nanoTime();
40 | long waitNs = JobManager.NS_PER_MS * 3000;
41 | long waitUntil = startNs + waitNs;
42 | final Object object = new Object();
43 | synchronized (object) {
44 | timer.waitOnObjectUntilNs(object, waitUntil);
45 | }
46 | assertBetween(System.nanoTime() - startRealTime, waitNs, waitNs + 2000 * JobManager.NS_PER_MS);
47 | }
48 |
49 | public void assertBetween(long value, long min, long max) {
50 | MatcherAssert.assertThat("expected value should be in range", value,
51 | new Range(min, max));
52 | }
53 |
54 |
55 | public void assertReasonable(long value, long expected) {
56 | long deviation = JobManager.NS_PER_MS * 1500;
57 | assertBetween(value, expected - deviation, expected + deviation);
58 | }
59 |
60 | static class Range extends BaseMatcher {
61 | final long min, max;
62 | public Range(long min, long max) {
63 | this.min = min;
64 | this.max = max;
65 | }
66 |
67 | @Override
68 | public boolean matches(Object item) {
69 | long value = (long) item;
70 | return value >= min && value <= max;
71 | }
72 |
73 | @Override
74 | public void describeTo(Description description) {
75 | description.appendText("should be between").appendValue(min).appendText(" and ")
76 | .appendValue(max);
77 | }
78 | }
79 |
80 | }
81 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/TestConstraint.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue;
2 |
3 | import com.birbit.android.jobqueue.TagConstraint;
4 | import com.birbit.android.jobqueue.timer.Timer;
5 |
6 | import java.util.Collection;
7 |
8 | public class TestConstraint extends Constraint {
9 | Timer timer;
10 | public TestConstraint(Timer timer) {
11 | this.timer = timer;
12 | }
13 |
14 | @Override
15 | public void setTagConstraint(TagConstraint tagConstraint) {
16 | super.setTagConstraint(tagConstraint);
17 | }
18 |
19 | @Override
20 | public void setExcludeRunning(boolean excludeRunning) {
21 | super.setExcludeRunning(excludeRunning);
22 | }
23 |
24 | @Override
25 | public void setMaxNetworkType(int maxNetworkType) {
26 | super.setMaxNetworkType(maxNetworkType);
27 | }
28 |
29 | @Override
30 | public void setTags(String[] tags) {
31 | super.setTags(tags);
32 | }
33 |
34 | @Override
35 | public void setExcludeGroups(Collection excludeGroups) {
36 | super.setExcludeGroups(excludeGroups);
37 | }
38 |
39 | @Override
40 | public void setExcludeJobIds(Collection jobsIds) {
41 | super.setExcludeJobIds(jobsIds);
42 | }
43 |
44 | @Override
45 | public void clear() {
46 | super.clear();
47 | }
48 |
49 | @Override
50 | public long getNowInNs() {
51 | return timer.nanoTime();
52 | }
53 |
54 | @Override
55 | public void setTimeLimit(Long timeLimit) {
56 | super.setTimeLimit(timeLimit);
57 | }
58 |
59 | public static TestConstraint forTags(Timer timer, TagConstraint tagConstraint,
60 | Collection excludeIds, String... tags) {
61 | TestConstraint constraint = new TestConstraint(timer);
62 | constraint.setTagConstraint(tagConstraint);
63 | constraint.setExcludeJobIds(excludeIds);
64 | constraint.setTags(tags);
65 | return constraint;
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/config/ConfigurationBuilderTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.config;
2 |
3 | import org.junit.Before;
4 | import org.junit.Test;
5 | import org.junit.runner.RunWith;
6 | import org.junit.runners.JUnit4;
7 | import org.mockito.Mockito;
8 |
9 | import android.content.Context;
10 |
11 | import java.util.UUID;
12 |
13 | @RunWith(JUnit4.class)
14 | public class ConfigurationBuilderTest {
15 | Configuration.Builder builder;
16 | @Before
17 | public void init() {
18 | Context context = Mockito.mock(Context.class);
19 | Mockito.when(context.getApplicationContext()).thenReturn(context);
20 | builder = new Configuration.Builder(context);
21 | }
22 |
23 | @Test(expected = IllegalArgumentException.class)
24 | public void idWithSpaces() {
25 | testId("");
26 | }
27 |
28 | @Test(expected = IllegalArgumentException.class)
29 | public void nullId() {
30 | testId(null);
31 | }
32 |
33 | @Test(expected = IllegalArgumentException.class)
34 | public void idWithSpace() {
35 | testId("hello world");
36 | }
37 |
38 | @Test(expected = IllegalArgumentException.class)
39 | public void idWithBadChars() {
40 | testId("hello~world");
41 | }
42 |
43 | @Test(expected = IllegalArgumentException.class)
44 | public void idWithBadChars2() {
45 | testId("hello?world");
46 | }
47 |
48 | @Test
49 | public void goodId() {
50 | testId("blah");
51 | }
52 |
53 | @Test
54 | public void goodId2() {
55 | testId("blah123");
56 | }
57 |
58 | @Test
59 | public void goodId3() {
60 | testId("blah_123");
61 | }
62 |
63 | @Test
64 | public void goodId4() {
65 | testId("blah-123");
66 | }
67 |
68 | @Test
69 | public void goodUUID() {
70 | testId(UUID.randomUUID().toString());
71 | }
72 |
73 | private void testId(String id) {
74 | builder.id(id).build();
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/messaging/DelayedMessageBagAddTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.messaging.message.CommandMessage;
4 |
5 | import org.hamcrest.CoreMatchers;
6 | import org.junit.Test;
7 | import org.junit.runner.RunWith;
8 | import org.junit.runners.Parameterized;
9 |
10 | import java.util.ArrayList;
11 | import java.util.Arrays;
12 | import java.util.HashMap;
13 | import java.util.List;
14 | import java.util.Map;
15 |
16 | import static org.hamcrest.MatcherAssert.assertThat;
17 | import static org.mockito.Mockito.any;
18 | import static org.mockito.Mockito.mock;
19 | import static org.mockito.Mockito.times;
20 | import static org.mockito.Mockito.verify;
21 |
22 | @RunWith(Parameterized.class)
23 | public class DelayedMessageBagAddTest {
24 | MessageFactory factory = new MessageFactory();
25 | DelayedMessageBag bag = new DelayedMessageBag(factory);
26 |
27 | List ordered;
28 | Map added = new HashMap<>();
29 |
30 | public DelayedMessageBagAddTest(List ordered) {
31 | this.ordered = ordered;
32 | }
33 |
34 | @Parameterized.Parameters(name = "{0}")
35 | static public List> params() {
36 | List> result = new ArrayList<>();
37 | for (int a = 0; a < 3; a++) {
38 |
39 | for (int b = 0; b < 3; b ++) {
40 | if (b == a) {
41 | continue;
42 | }
43 | for (int c = 0; c < 3; c ++) {
44 | if (c == a || c == b) {
45 | continue;
46 | }
47 | Long[] items = new Long[3];
48 | items[a] = 1000L;
49 | items[b] = 2000L;
50 | items[c] = 3000L;
51 | result.add(Arrays.asList(items));
52 | }
53 | }
54 | }
55 | return result;
56 | }
57 |
58 | @Test
59 | public void testAddOrdered() {
60 | for (Long readyNs : ordered) {
61 | add(readyNs);
62 | }
63 | Message m1 = added.get(1000L);
64 | Message m2 = added.get(2000L);
65 | Message m3 = added.get(3000L);
66 | assertThat(m1, CoreMatchers.notNullValue());
67 | assertThat(m2, CoreMatchers.notNullValue());
68 | assertThat(m3, CoreMatchers.notNullValue());
69 | MessageQueue mq = mock(MessageQueue.class);
70 | long t1 = bag.flushReadyMessages(500, mq);
71 | assertThat(t1, CoreMatchers.is(1000L));
72 | verify(mq, times(0)).post(any(Message.class));
73 | long t2 = bag.flushReadyMessages(1000, mq);
74 | assertThat(t2, CoreMatchers.is(2000L));
75 | verify(mq).post(m1);
76 | Long t3 = bag.flushReadyMessages(3001, mq);
77 | assertThat(t3, CoreMatchers.nullValue());
78 | verify(mq).post(m2);
79 | verify(mq).post(m3);
80 | }
81 |
82 | private Message add(long readyNs) {
83 | CommandMessage msg = factory.obtain(CommandMessage.class);
84 | bag.add(msg, readyNs);
85 | added.put(readyNs, msg);
86 | return msg;
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/messaging/DelayedMessageBagRecycleTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.messaging.message.CommandMessage;
4 |
5 | import org.junit.Test;
6 | import org.junit.runner.RunWith;
7 | import org.junit.runners.JUnit4;
8 | import static org.mockito.Mockito.*;
9 | @RunWith(JUnit4.class)
10 | public class DelayedMessageBagRecycleTest {
11 | MessageFactory factory = spy(new MessageFactory());
12 | DelayedMessageBag bag = new DelayedMessageBag(factory);
13 |
14 | @Test
15 | public void recycleOnClear() {
16 | CommandMessage cm = factory.obtain(CommandMessage.class);
17 | cm.set(CommandMessage.POKE);
18 | bag.add(cm, 1000);
19 | bag.clear();
20 | verify(factory).release(cm);
21 | }
22 |
23 | @Test
24 | public void recycleOnCancel() {
25 | final CommandMessage cm = factory.obtain(CommandMessage.class);
26 | cm.set(CommandMessage.POKE);
27 | bag.add(cm, 1000);
28 |
29 | final CommandMessage cm2 = factory.obtain(CommandMessage.class);
30 | cm2.set(CommandMessage.POKE);
31 | bag.add(cm2, 1000);
32 | bag.removeMessages(new MessagePredicate() {
33 | @Override
34 | public boolean onMessage(Message message) {
35 | return message == cm;
36 | }
37 | });
38 | verify(factory).release(cm);
39 | verify(factory, times(0)).release(cm2);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/messaging/DelayedMessageBagRemoveTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.messaging.message.CommandMessage;
4 |
5 | import org.hamcrest.CoreMatchers;
6 | import org.junit.Test;
7 | import org.junit.runner.RunWith;
8 | import org.junit.runners.JUnit4;
9 |
10 | import java.util.Arrays;
11 | import java.util.HashMap;
12 | import java.util.List;
13 | import java.util.Map;
14 |
15 | import static org.hamcrest.MatcherAssert.assertThat;
16 | import static org.mockito.Matchers.same;
17 | import static org.mockito.Mockito.any;
18 | import static org.mockito.Mockito.mock;
19 | import static org.mockito.Mockito.times;
20 | import static org.mockito.Mockito.verify;
21 |
22 | @RunWith(JUnit4.class)
23 | public class DelayedMessageBagRemoveTest {
24 | MessageFactory factory = new MessageFactory();
25 | DelayedMessageBag bag = new DelayedMessageBag(factory);
26 | List items = Arrays.asList(1000L, 2000L, 3000L);
27 | Map added = new HashMap<>();
28 |
29 | @Test
30 | public void testRemoveAll() {
31 | for (Long readyNs : items) {
32 | add(readyNs);
33 | }
34 | bag.removeMessages(new MessagePredicate() {
35 | @Override
36 | public boolean onMessage(Message message) {
37 | return true;
38 | }
39 | });
40 | MessageQueue mq = mock(MessageQueue.class);
41 | Long t1 = bag.flushReadyMessages(500, mq);
42 | assertThat(t1, CoreMatchers.nullValue());
43 | bag.flushReadyMessages(4000, mq);
44 | verify(mq, times(0)).post(any(Message.class));
45 | }
46 |
47 | @Test
48 | public void testRemoveNothing() {
49 | for (Long readyNs : items) {
50 | add(readyNs);
51 | }
52 | bag.removeMessages(new MessagePredicate() {
53 | @Override
54 | public boolean onMessage(Message message) {
55 | return false;
56 | }
57 | });
58 | MessageQueue mq = mock(MessageQueue.class);
59 | long t1 = bag.flushReadyMessages(500, mq);
60 | assertThat(t1, CoreMatchers.is(1000L));
61 | bag.flushReadyMessages(4000, mq);
62 | verify(mq, times(3)).post(any(Message.class));
63 | }
64 |
65 | @Test
66 | public void testRemoveUnmatch() {
67 | testRemove(0, 1000, 2000, 3000);
68 | }
69 |
70 | @Test
71 | public void testRemove1000() {
72 | testRemove(1000, 2000, 3000);
73 | }
74 |
75 | @Test
76 | public void testRemove2000() {
77 | testRemove(2000, 1000, 3000);
78 | }
79 |
80 | @Test
81 | public void testRemove3000() {
82 | testRemove(3000, 1000, 2000);
83 | }
84 |
85 | public void testRemove(final long itemToRemove, long... toBeReceived) {
86 | for (Long readyNs : items) {
87 | add(readyNs);
88 | }
89 | bag.removeMessages(new MessagePredicate() {
90 | @Override
91 | public boolean onMessage(Message message) {
92 | return message.readyNs == itemToRemove;
93 | }
94 | });
95 | MessageQueue mq = mock(MessageQueue.class);
96 | bag.flushReadyMessages(4000, mq);
97 | for (long item : toBeReceived) {
98 | verify(mq).post(same(added.get(item)));
99 | }
100 | }
101 |
102 | private Message add(long readyNs) {
103 | CommandMessage msg = factory.obtain(CommandMessage.class);
104 | bag.add(msg, readyNs);
105 | added.put(readyNs, msg);
106 | return msg;
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/messaging/MessageFactoryTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.messaging.message.AddJobMessage;
4 | import com.birbit.android.jobqueue.messaging.message.CommandMessage;
5 |
6 | import org.junit.Test;
7 | import org.junit.runner.RunWith;
8 | import org.junit.runners.JUnit4;
9 | import static org.hamcrest.MatcherAssert.*;
10 | import static org.hamcrest.CoreMatchers.*;
11 |
12 | @RunWith(JUnit4.class)
13 | public class MessageFactoryTest {
14 | MessageFactory factory = new MessageFactory();
15 | @Test
16 | public void test() {
17 | AddJobMessage aj1 = factory.obtain(AddJobMessage.class);
18 | assertThat(aj1, isA(AddJobMessage.class));
19 | CommandMessage cm1 = factory.obtain(CommandMessage.class);
20 | assertThat(cm1, isA(CommandMessage.class));
21 | assertThat(factory.obtain(AddJobMessage.class), not(sameInstance(aj1)));
22 | assertThat(factory.obtain(CommandMessage.class), not(sameInstance(cm1)));
23 | factory.release(aj1);
24 | factory.release(cm1);
25 | assertThat(factory.obtain(AddJobMessage.class), sameInstance(aj1));
26 | assertThat(factory.obtain(CommandMessage.class), sameInstance(cm1));
27 | assertThat(factory.obtain(AddJobMessage.class), not(sameInstance(aj1)));
28 | assertThat(factory.obtain(CommandMessage.class), not(sameInstance(cm1)));
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/messaging/PriorityMessageQueueTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.messaging.message.AddJobMessage;
4 | import com.birbit.android.jobqueue.messaging.message.CommandMessage;
5 | import com.birbit.android.jobqueue.test.timer.MockTimer;
6 | import com.birbit.android.jobqueue.timer.Timer;
7 |
8 | import org.junit.Test;
9 | import org.junit.runner.RunWith;
10 | import org.junit.runners.JUnit4;
11 |
12 | import java.util.Arrays;
13 | import java.util.List;
14 |
15 | import static org.hamcrest.MatcherAssert.*;
16 | import static org.hamcrest.CoreMatchers.*;
17 |
18 | @RunWith(JUnit4.class)
19 | public class PriorityMessageQueueTest extends MessageQueueTestBase {
20 | PriorityMessageQueue mq = new PriorityMessageQueue(new MockTimer(), new MessageFactory());
21 |
22 | @Test
23 | public void test1() {
24 | CommandMessage mC1 = new CommandMessage();
25 | CommandMessage mC2 = new CommandMessage();
26 | AddJobMessage aj1 = new AddJobMessage();
27 | AddJobMessage aj2 = new AddJobMessage();
28 | mq.post(mC1);
29 | mq.post(mC2);
30 | mq.post(aj1);
31 | mq.post(aj2);
32 | final List expectedOrder = Arrays.asList(aj1, aj2, mC1, mC2);
33 | mq.consume(new MessageQueueConsumer() {
34 | int index;
35 | @Override
36 | public void handleMessage(Message message) {
37 | assertThat(message, is (expectedOrder.get(index++)));
38 | if (index == expectedOrder.size()) {
39 | mq.stop();
40 | }
41 | }
42 |
43 | @Override
44 | public void onIdle() {
45 |
46 | }
47 | });
48 | }
49 |
50 | @Override
51 | PriorityMessageQueue createMessageQueue(Timer timer, MessageFactory factory) {
52 | return new PriorityMessageQueue(timer, factory);
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/messaging/SafeMessageQueueTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.messaging;
2 |
3 | import com.birbit.android.jobqueue.timer.Timer;
4 |
5 | public class SafeMessageQueueTest extends MessageQueueTestBase {
6 |
7 | @Override
8 | SafeMessageQueue createMessageQueue(Timer timer, MessageFactory factory) {
9 | return new SafeMessageQueue(timer, factory, "test");
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/scheduling/GcmJobSchedulerServiceTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.scheduling;
2 |
3 | import android.annotation.TargetApi;
4 | import android.os.Build;
5 | import androidx.annotation.NonNull;
6 |
7 | import com.birbit.android.jobqueue.JobManager;
8 | import com.google.android.gms.gcm.TaskParams;
9 |
10 | import org.junit.Before;
11 | import org.junit.Test;
12 | import org.junit.runner.RunWith;
13 | import org.robolectric.RobolectricTestRunner;
14 | import org.robolectric.RuntimeEnvironment;
15 | import org.robolectric.annotation.Config;
16 |
17 | import static org.hamcrest.CoreMatchers.is;
18 | import static org.hamcrest.MatcherAssert.assertThat;
19 | import static org.mockito.Mockito.mock;
20 | import static org.mockito.Mockito.never;
21 | import static org.mockito.Mockito.verify;
22 | import static org.mockito.Mockito.when;
23 |
24 | @RunWith(RobolectricTestRunner.class)
25 |
26 | @TargetApi(Build.VERSION_CODES.LOLLIPOP)
27 | public class GcmJobSchedulerServiceTest {
28 | JobManager mockJobManager;
29 | GcmJobSchedulerServiceImpl service;
30 | GcmScheduler mockScheduler;
31 |
32 | @Before
33 | public void init() {
34 | mockJobManager = mock(JobManager.class);
35 | service = new GcmJobSchedulerServiceImpl();
36 | mockScheduler = mock(GcmScheduler.class);
37 | when(mockJobManager.getScheduler()).thenReturn(mockScheduler);
38 | }
39 |
40 | @Test
41 | public void createScheduler() {
42 | GcmScheduler scheduler = GcmJobSchedulerService
43 | .createSchedulerFor(RuntimeEnvironment.application,
44 | GcmJobSchedulerServiceImpl.class);
45 | assertThat(scheduler.serviceClass == GcmJobSchedulerServiceImpl.class, is(true));
46 | }
47 |
48 | @Test(expected = IllegalArgumentException.class)
49 | public void createBadScheduler() {
50 | GcmJobSchedulerService.createSchedulerFor(RuntimeEnvironment.application,
51 | GcmJobSchedulerService.class);
52 | }
53 |
54 | @Test
55 | public void onStartJob() {
56 | TaskParams params = mock(TaskParams.class);
57 | service.onRunTask(params);
58 | verify(mockScheduler).onStartJob(params);
59 | }
60 |
61 | @Test
62 | public void onStartJobWithoutScheduler() {
63 | when(mockJobManager.getScheduler()).thenReturn(null);
64 | TaskParams params = mock(TaskParams.class);
65 | service.onRunTask(params);
66 | // test sanity
67 | verify(mockScheduler, never()).onStartJob(params);
68 | }
69 |
70 | public class GcmJobSchedulerServiceImpl extends GcmJobSchedulerService {
71 |
72 | @NonNull
73 | @Override
74 | protected JobManager getJobManager() {
75 | return mockJobManager;
76 | }
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/scheduling/MockFwService.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.scheduling;
2 |
3 | import androidx.annotation.NonNull;
4 |
5 | import com.birbit.android.jobqueue.JobManager;
6 |
7 | public class MockFwService extends FrameworkJobSchedulerService {
8 | private JobManager jobManager;
9 | public MockFwService(JobManager jobManager) {
10 | this.jobManager = jobManager;
11 | }
12 |
13 | @NonNull
14 | @Override
15 | protected JobManager getJobManager() {
16 | return jobManager;
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/scheduling/MockGcmService.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.scheduling;
2 |
3 | import androidx.annotation.NonNull;
4 |
5 | import com.birbit.android.jobqueue.JobManager;
6 |
7 | public class MockGcmService extends GcmJobSchedulerService {
8 | private JobManager jobManager;
9 | public MockGcmService(JobManager jobManager) {
10 | this.jobManager = jobManager;
11 | }
12 |
13 | @NonNull
14 | @Override
15 | protected JobManager getJobManager() {
16 | return jobManager;
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/TestBase.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test;
2 |
3 | import android.util.Log;
4 |
5 | import com.birbit.android.jobqueue.testing.StackTraceRule;
6 | import com.birbit.android.jobqueue.log.CustomLogger;
7 | import com.birbit.android.jobqueue.log.JqLog;
8 |
9 | import org.junit.After;
10 | import org.junit.Before;
11 | import org.junit.Rule;
12 | import org.robolectric.shadows.ShadowLog;
13 |
14 | public class TestBase {
15 | protected static boolean ENABLE_DEBUG = false;
16 | @Rule
17 | public StackTraceRule stackTraceRule = new StackTraceRule();
18 | @Before
19 | public void setUp() throws Exception {
20 | if(ENABLE_DEBUG) {
21 | enableDebug();
22 | }
23 | }
24 |
25 | @After
26 | public void clearDebugger() {
27 | JqLog.clearLogger();
28 | }
29 |
30 | protected void enableDebug() {
31 | ShadowLog.stream = System.out;
32 | JqLog.setCustomLogger(new CustomLogger() {
33 | private String TAG = "test_logger";
34 |
35 | @Override
36 | public boolean isDebugEnabled() {
37 | return true;
38 | }
39 |
40 | @Override
41 | public void d(String text, Object... args) {
42 | Log.d(TAG, prefix() + String.format(text, args));
43 | }
44 |
45 | @Override
46 | public void e(Throwable t, String text, Object... args) {
47 | Log.e(TAG, prefix() + String.format(text, args), t);
48 | }
49 |
50 | @Override
51 | public void e(String text, Object... args) {
52 | Log.e(TAG, prefix() + String.format(text, args));
53 | }
54 |
55 | @Override
56 | public void v(String text, Object... args) {
57 | Log.v(TAG, prefix() + String.format(text, args));
58 | }
59 |
60 | private String prefix() {
61 | return Thread.currentThread().getName() + "[" + System.currentTimeMillis() + "]";
62 | }
63 | });
64 | }
65 | }
66 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/AddInBackgroundTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.JobManagerThreadRunnable;
5 | import com.birbit.android.jobqueue.AsyncAddCallback;
6 | import com.birbit.android.jobqueue.Job;
7 | import com.birbit.android.jobqueue.JobHolder;
8 | import com.birbit.android.jobqueue.Params;
9 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
10 |
11 | import org.hamcrest.CoreMatchers;
12 | import org.hamcrest.MatcherAssert;
13 | import org.junit.Test;
14 | import org.junit.runner.RunWith;
15 | import org.robolectric.ParameterizedRobolectricTestRunner;
16 | import org.robolectric.annotation.Config;
17 |
18 | import java.util.Arrays;
19 | import java.util.List;
20 | import java.util.concurrent.CountDownLatch;
21 | import java.util.concurrent.atomic.AtomicLong;
22 |
23 | @RunWith(ParameterizedRobolectricTestRunner.class)
24 |
25 | public class AddInBackgroundTest extends JobManagerTestBase {
26 |
27 | public AddInBackgroundTest(boolean delay, boolean useCallback) {
28 | this.delayed = delay;
29 | this.useCallback = useCallback;
30 | }
31 |
32 | final boolean delayed;
33 | final boolean useCallback;
34 |
35 | @ParameterizedRobolectricTestRunner.Parameters(name = "delay:{0} useCallback:{1}")
36 | public static List getParameters() {
37 | return Arrays.asList(
38 | new Object[]{false, false},
39 | new Object[]{false, true},
40 | new Object[]{true, false},
41 | new Object[]{true, true}
42 | );
43 | }
44 |
45 | @Test
46 | public void addInBackground() throws Throwable {
47 | long currentThreadId = Thread.currentThread().getId();
48 | final AtomicLong onAddedThreadId = new AtomicLong();
49 | final CountDownLatch addedLatch = new CountDownLatch(2);
50 |
51 | final Job dummyJob = new DummyJob(new Params(1).setDelayMs(delayed ? 1000 : 0)) {
52 | @Override
53 | public void onAdded() {
54 | super.onAdded();
55 | onAddedThreadId.set(Thread.currentThread().getId());
56 | addedLatch.countDown();
57 | }
58 | };
59 | JobManager jobManager = createJobManager();
60 | jobManager.stop();
61 | if(useCallback) {
62 | jobManager.addJobInBackground(dummyJob, new AsyncAddCallback() {
63 | @Override
64 | public void onAdded() {
65 | addedLatch.countDown();
66 | }
67 | });
68 | } else {
69 | addedLatch.countDown();
70 | jobManager.addJobInBackground(dummyJob);
71 | }
72 | addedLatch.await();
73 | MatcherAssert.assertThat("thread ids should be different. delayed:" + delayed,
74 | currentThreadId, CoreMatchers.not(onAddedThreadId.get()));
75 | if(useCallback) {
76 | JobHolder holder = new JobManagerThreadRunnable(jobManager) {
77 |
78 | @Override
79 | public JobHolder onRun() {
80 | return findJobFromQueues(dummyJob.getId());
81 | }
82 | }.run();
83 | MatcherAssert.assertThat("there should be a job in the holder. id:" + dummyJob.getId()
84 | +", delayed:" + delayed, holder, CoreMatchers.notNullValue());
85 | MatcherAssert.assertThat("id callback should have the proper id:", holder.getJob(),
86 | CoreMatchers.is(dummyJob));
87 | }
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/AddedCountTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.Params;
5 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
6 | import org.hamcrest.MatcherAssert;
7 | import org.junit.Test;
8 | import org.junit.runner.RunWith;
9 | import org.robolectric.RobolectricTestRunner;
10 | import org.robolectric.annotation.Config;
11 |
12 | import static org.hamcrest.CoreMatchers.equalTo;
13 |
14 | @RunWith(RobolectricTestRunner.class)
15 |
16 | public class AddedCountTest extends JobManagerTestBase {
17 | @Test
18 | public void testAddedCount() throws Exception {
19 | testAddedCount(new DummyJob(new Params(0)));
20 |
21 | }
22 |
23 | @Test
24 | public void testAddedCountPersistent() {
25 | testAddedCount(new DummyJob(new Params(0).persist()));
26 | }
27 |
28 | private void testAddedCount(DummyJob dummyJob) {
29 | JobManager jobManager = createJobManager();
30 | jobManager.stop();
31 | jobManager.addJob(dummyJob);
32 | MatcherAssert.assertThat(1, equalTo(dummyJob.getOnAddedCnt()));
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/AssertThreadsTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.Job;
4 | import com.birbit.android.jobqueue.JobManager;
5 | import com.birbit.android.jobqueue.Params;
6 | import com.birbit.android.jobqueue.TagConstraint;
7 | import com.birbit.android.jobqueue.WrongThreadException;
8 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
9 |
10 | import static org.hamcrest.CoreMatchers.*;
11 | import static org.hamcrest.MatcherAssert.assertThat;
12 | import org.junit.Test;
13 | import org.junit.runner.RunWith;
14 | import org.robolectric.RobolectricTestRunner;
15 | import org.robolectric.annotation.Config;
16 |
17 | @RunWith(RobolectricTestRunner.class)
18 |
19 | public class AssertThreadsTest extends JobManagerTestBase {
20 | JobManager jobManager;
21 |
22 | @Test
23 | public void testGetActiveConsumerCount() throws InterruptedException {
24 | assertFailure(new Runnable() {
25 | @Override
26 | public void run() {
27 | jobManager.getActiveConsumerCount();
28 | }
29 | });
30 | }
31 |
32 | @Test
33 | public void testAddJob() throws InterruptedException {
34 | assertFailure(new Runnable() {
35 | @Override
36 | public void run() {
37 | jobManager.addJob(new DummyJob(new Params(0)));
38 | }
39 | });
40 | }
41 |
42 | @Test
43 | public void testCancelJobs() throws InterruptedException {
44 | assertFailure(new Runnable() {
45 | @Override
46 | public void run() {
47 | jobManager.cancelJobs(TagConstraint.ANY, "blah");
48 | }
49 | });
50 | }
51 |
52 | @Test
53 | public void testCount() throws InterruptedException {
54 | assertFailure(new Runnable() {
55 | @Override
56 | public void run() {
57 | jobManager.count();
58 | }
59 | });
60 | }
61 |
62 | @Test
63 | public void testCountReady() throws InterruptedException {
64 | assertFailure(new Runnable() {
65 | @Override
66 | public void run() {
67 | jobManager.countReadyJobs();
68 | }
69 | });
70 | }
71 |
72 | @Test
73 | public void testJobStatus() throws InterruptedException {
74 | assertFailure(new Runnable() {
75 | @Override
76 | public void run() {
77 | jobManager.getJobStatus("abc");
78 | }
79 | });
80 | }
81 |
82 | @Test
83 | public void testClear() throws InterruptedException {
84 | assertFailure(new Runnable() {
85 | @Override
86 | public void run() {
87 | jobManager.clear();
88 | }
89 | });
90 | }
91 |
92 | private void assertFailure(final Runnable runnable) throws InterruptedException {
93 | final Throwable[] throwable = new Throwable[1];
94 | jobManager = createJobManager();
95 | final DummyJob dummyJob = new DummyJob(new Params(0)) {
96 | @Override
97 | public void onAdded() {
98 | super.onAdded();
99 | try {
100 | runnable.run();
101 | } catch (Throwable t) {
102 | throwable[0] = t;
103 | }
104 | }
105 | };
106 | waitUntilAJobIsDone(jobManager, new WaitUntilCallback() {
107 | @Override
108 | public void run() {
109 | jobManager.addJob(dummyJob);
110 | }
111 |
112 | @Override
113 | public void assertJob(Job job) {
114 | }
115 | });
116 | assertThat(throwable[0] instanceof WrongThreadException, is(true));
117 | }
118 | }
119 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/CancelWhileRunningWithGroupsTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.CancelResult;
4 | import com.birbit.android.jobqueue.JobManager;
5 | import com.birbit.android.jobqueue.Params;
6 | import com.birbit.android.jobqueue.TagConstraint;
7 | import com.birbit.android.jobqueue.config.Configuration;
8 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
9 |
10 | import org.junit.Test;
11 | import org.junit.runner.RunWith;
12 | import org.robolectric.RobolectricTestRunner;
13 | import org.robolectric.RuntimeEnvironment;
14 | import org.robolectric.annotation.Config;
15 |
16 | import java.util.concurrent.CountDownLatch;
17 | import java.util.concurrent.TimeUnit;
18 |
19 | import static org.hamcrest.CoreMatchers.is;
20 | import static org.hamcrest.MatcherAssert.assertThat;
21 |
22 | @RunWith(RobolectricTestRunner.class)
23 |
24 | public class CancelWhileRunningWithGroupsTest extends JobManagerTestBase {
25 | public static CountDownLatch[] endLatches = new CountDownLatch[]{new CountDownLatch(2), new CountDownLatch(2)};
26 | public static CountDownLatch[] startLatches = new CountDownLatch[]{new CountDownLatch(2), new CountDownLatch(2)};
27 | @Test
28 | public void testCancelBeforeRunning() throws InterruptedException {
29 | JobManager jobManager = createJobManager(
30 | new Configuration.Builder(RuntimeEnvironment.application)
31 | .minConsumerCount(5).timer(mockTimer));
32 | DummyJobWithLatches nonPersistentJob = new DummyJobWithLatches(0, new Params(1).addTags("dummyTag").groupBy("group1"));
33 | jobManager.addJob(nonPersistentJob);
34 | DummyJobWithLatches persistentJob = new DummyJobWithLatches(0, new Params(1).addTags("dummyTag").groupBy("group2").persist());
35 | jobManager.addJob(persistentJob);
36 | assertThat("both jobs should start", startLatches[0].await(2, TimeUnit.SECONDS), is(true));
37 | final CancelResult[] cancelResults = new CancelResult[1];
38 | final CountDownLatch resultLatch = new CountDownLatch(1);
39 | startLatches[0].await(2, TimeUnit.SECONDS);
40 | jobManager.cancelJobsInBackground(new CancelResult.AsyncCancelCallback() {
41 | @Override
42 | public void onCancelled(CancelResult cancelResult) {
43 | cancelResults[0] = cancelResult;
44 | resultLatch.countDown();
45 | }
46 | }, TagConstraint.ANY, "dummyTag");
47 | while (!nonPersistentJob.isCancelled()) {
48 | // wait
49 | }
50 | endLatches[0].countDown();
51 | endLatches[0].countDown();
52 |
53 | assertThat("result should come after jobs end", resultLatch.await(2, TimeUnit.SECONDS), is(true));
54 | assertThat("no jobs should be canceled", cancelResults[0].getCancelledJobs().size(), is(0));
55 | assertThat("both jobs should fail to cancel", cancelResults[0].getFailedToCancel().size(), is(2));
56 |
57 | jobManager.addJob(new DummyJobWithLatches(1, new Params(1).addTags("dummyTag").groupBy("group1")));
58 | jobManager.addJob(new DummyJobWithLatches(1, new Params(1).addTags("dummyTag").groupBy("group2").persist()));
59 | assertThat("new jobs with canceled groups should start", startLatches[1].await(10, TimeUnit.SECONDS), is(true));
60 | endLatches[1].countDown();
61 | endLatches[1].countDown();
62 | }
63 |
64 | public static class DummyJobWithLatches extends DummyJob {
65 | final int latchIndex;
66 | public DummyJobWithLatches(int latchIndex, Params params) {
67 | super(params);
68 | this.latchIndex =latchIndex;
69 | }
70 |
71 | @Override
72 | public void onRun() throws Throwable {
73 | super.onRun();
74 | startLatches[latchIndex].countDown();
75 | endLatches[latchIndex].await(10, TimeUnit.SECONDS);
76 | }
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/ClearTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.Params;
5 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
6 | import static org.hamcrest.CoreMatchers.*;
7 | import org.hamcrest.*;
8 | import org.junit.Test;
9 | import org.junit.runner.RunWith;
10 | import org.robolectric.*;
11 | import org.robolectric.annotation.Config;
12 |
13 | @RunWith(RobolectricTestRunner.class)
14 |
15 | public class ClearTest extends JobManagerTestBase {
16 | @Test
17 | public void testClear() throws Exception {
18 | JobManager jobManager = createJobManager();
19 | final int LIMIT = 20;
20 | for(int i = 0; i < LIMIT; i++) {
21 | jobManager.addJob(new DummyJob(new Params(0).setPersistent(i % 2 == 1)));
22 | }
23 | jobManager.clear();
24 | MatcherAssert.assertThat("after clear, count should be 0", jobManager.count(), equalTo(0));
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/ConsumerCountTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.Params;
5 | import com.birbit.android.jobqueue.config.Configuration;
6 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
7 | import com.birbit.android.jobqueue.timer.SystemTimer;
8 | import com.birbit.android.jobqueue.timer.Timer;
9 |
10 | import static org.hamcrest.CoreMatchers.*;
11 | import org.hamcrest.*;
12 | import org.junit.Test;
13 | import org.junit.runner.RunWith;
14 | import org.robolectric.*;
15 | import org.robolectric.annotation.Config;
16 |
17 | import java.util.ArrayList;
18 | import java.util.List;
19 | import java.util.concurrent.CountDownLatch;
20 | import java.util.concurrent.Semaphore;
21 | import java.util.concurrent.TimeUnit;
22 |
23 | @RunWith(RobolectricTestRunner.class)
24 |
25 | public class ConsumerCountTest extends JobManagerTestBase {
26 | final CountDownLatch runLock = new CountDownLatch(1);
27 | @Test
28 | public void testMaxConsumerCount() throws Exception {
29 | int maxConsumerCount = 2;
30 | JobManager jobManager = createJobManager(
31 | new Configuration.Builder(RuntimeEnvironment.application)
32 | .maxConsumerCount(maxConsumerCount)
33 | .loadFactor(maxConsumerCount)
34 | .timer(mockTimer));
35 |
36 | Semaphore semaphore = new Semaphore(maxConsumerCount);
37 | int totalJobCount = maxConsumerCount * 3;
38 | List runningJobs = new ArrayList<>(totalJobCount);
39 | for(int i = 0; i < totalJobCount; i ++) {
40 | NeverEndingDummyJob job = new NeverEndingDummyJob(new Params((int)(Math.random() * 3)), runLock, semaphore);
41 | runningJobs.add(job);
42 | jobManager.addJob(job);
43 | }
44 | Timer timer = new SystemTimer();
45 | //wait till enough jobs start
46 | long start = timer.nanoTime();
47 | long tenSeconds = TimeUnit.SECONDS.toNanos(10);
48 | while (timer.nanoTime() - start < tenSeconds && semaphore.tryAcquire()) {
49 | semaphore.release();
50 | //noinspection SLEEP_IN_CODE
51 | Thread.sleep(100);
52 | }
53 | MatcherAssert.assertThat("all consumers should start in 10 seconds",
54 | timer.nanoTime() - start > tenSeconds, is(false));
55 | //wait some more to ensure no more jobs are started
56 | //noinspection SLEEP_IN_CODE
57 | Thread.sleep(TimeUnit.SECONDS.toMillis(3));
58 | int totalRunningCount = 0;
59 | for(DummyJob job : runningJobs) {
60 | totalRunningCount += job.getOnRunCnt();
61 | }
62 | MatcherAssert.assertThat("only maxConsumerCount jobs should start", totalRunningCount,
63 | equalTo(maxConsumerCount));
64 | waitUntilJobsAreDone(jobManager, runningJobs, new Runnable() {
65 | @Override
66 | public void run() {
67 | runLock.countDown();
68 | }
69 | });
70 | MatcherAssert.assertThat("no jobs should remain", jobManager.count(), equalTo(0));
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/CountTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.Job;
4 | import com.birbit.android.jobqueue.JobManager;
5 | import com.birbit.android.jobqueue.Params;
6 | import com.birbit.android.jobqueue.callback.JobManagerCallback;
7 | import com.birbit.android.jobqueue.callback.JobManagerCallbackAdapter;
8 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
9 | import static org.hamcrest.CoreMatchers.*;
10 | import org.hamcrest.*;
11 | import org.junit.Test;
12 | import org.junit.runner.RunWith;
13 | import org.robolectric.*;
14 | import org.robolectric.annotation.Config;
15 |
16 | import android.annotation.TargetApi;
17 | import android.os.Build;
18 | import androidx.annotation.NonNull;
19 |
20 | import java.util.concurrent.CountDownLatch;
21 | import java.util.concurrent.TimeUnit;
22 |
23 | @RunWith(RobolectricTestRunner.class)
24 |
25 | public class CountTest extends JobManagerTestBase {
26 | @TargetApi(Build.VERSION_CODES.GINGERBREAD)
27 | @Test
28 | public void testCount() throws Exception {
29 | enableDebug();
30 | JobManager jobManager = createJobManager();
31 | jobManager.stop();
32 | for (int i = 0; i < 10; i++) {
33 | jobManager.addJob(new DummyJob(new Params(0).persist()));
34 | MatcherAssert.assertThat((int) jobManager.count(), equalTo(i * 2 + 1));
35 | jobManager.addJob(new DummyJob(new Params(0).persist()));
36 | MatcherAssert.assertThat((int) jobManager.count(), equalTo(i * 2 + 2));
37 | }
38 | final CountDownLatch jobsToRun = new CountDownLatch(20);
39 | jobManager.addCallback(new JobManagerCallbackAdapter() {
40 | @Override
41 | public void onAfterJobRun(@NonNull Job job, int resultCode) {
42 | if (resultCode == JobManagerCallback.RESULT_SUCCEED) {
43 | jobsToRun.countDown();
44 | }
45 | }
46 | });
47 | jobManager.start();
48 | MatcherAssert.assertThat("test sanity", jobsToRun.await(1, TimeUnit.MINUTES), is(true));
49 | MatcherAssert.assertThat((int) jobManager.count(), equalTo(0));
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/DelayTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 |
4 | import com.birbit.android.jobqueue.JobHolder;
5 | import com.birbit.android.jobqueue.JobManager;
6 | import com.birbit.android.jobqueue.Params;
7 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
8 |
9 | import static org.hamcrest.CoreMatchers.*;
10 | import org.hamcrest.*;
11 | import org.junit.Test;
12 | import org.junit.runner.RunWith;
13 | import org.robolectric.*;
14 | import org.robolectric.annotation.Config;
15 |
16 | @RunWith(RobolectricTestRunner.class)
17 |
18 | public class DelayTest extends JobManagerTestBase {
19 | @Test
20 | public void testDelay() throws Throwable {
21 | testDelay(false);
22 | }
23 |
24 | @Test
25 | public void testDelayPersistent() throws Throwable {
26 | testDelay(true);
27 | }
28 |
29 | public void testDelay(boolean persist) throws Throwable {
30 | JobManager jobManager = createJobManager();
31 | jobManager.stop();
32 | DummyJob delayedJob = new DummyJob(new Params(10).delayInMs(1000).setPersistent(persist));
33 | DummyJob nonDelayedJob = new DummyJob(new Params(0).setPersistent(persist));
34 | jobManager.addJob(delayedJob);
35 | jobManager.addJob(nonDelayedJob);
36 |
37 | JobHolder receivedJob = nextJob(jobManager);
38 | MatcherAssert.assertThat("non-delayed job should be served", receivedJob, notNullValue());
39 | MatcherAssert.assertThat("non-delayed job should id should match", receivedJob.getId(), equalTo(nonDelayedJob.getId()));
40 | removeJob(jobManager, receivedJob);
41 | MatcherAssert.assertThat("delayed job should not be served", nextJob(jobManager), nullValue());
42 | MatcherAssert.assertThat("job count should still be 1", jobManager.count(), equalTo(1));
43 | mockTimer.incrementMs(500);
44 | MatcherAssert.assertThat("delayed job should not be served", nextJob(jobManager), nullValue());
45 | MatcherAssert.assertThat("job count should still be 1", jobManager.count(), equalTo(1));
46 | mockTimer.incrementMs(2000);
47 | MatcherAssert.assertThat("job count should still be 1", jobManager.count(), equalTo(1));
48 | receivedJob = nextJob(jobManager);
49 | MatcherAssert.assertThat("now should be able to receive the delayed job.", receivedJob, notNullValue());
50 | if(receivedJob != null) {
51 | MatcherAssert.assertThat("received job should be the delayed job", receivedJob.getId(), equalTo(delayedJob.getId()));
52 | }
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/HitDeadlineAfterException.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import androidx.annotation.NonNull;
4 | import androidx.annotation.Nullable;
5 |
6 | import com.birbit.android.jobqueue.CancelReason;
7 | import com.birbit.android.jobqueue.Job;
8 | import com.birbit.android.jobqueue.JobManager;
9 | import com.birbit.android.jobqueue.Params;
10 | import com.birbit.android.jobqueue.RetryConstraint;
11 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
12 |
13 | import org.hamcrest.CoreMatchers;
14 | import org.hamcrest.MatcherAssert;
15 | import org.junit.Test;
16 | import org.junit.runner.RunWith;
17 | import org.robolectric.RobolectricTestRunner;
18 | import org.robolectric.annotation.Config;
19 |
20 | import java.util.concurrent.CountDownLatch;
21 | import java.util.concurrent.atomic.AtomicBoolean;
22 | import java.util.concurrent.atomic.AtomicInteger;
23 |
24 | @RunWith(RobolectricTestRunner.class)
25 |
26 | public class HitDeadlineAfterException extends JobManagerTestBase {
27 | @Test
28 | public void failAndHitDeadline() throws InterruptedException {
29 | final JobManager jobManager = createJobManager();
30 | final AtomicBoolean calledShouldReRun = new AtomicBoolean(false);
31 | final AtomicInteger reason = new AtomicInteger();
32 | final DummyJob job = new DummyJob(new Params(0).overrideDeadlineToCancelInMs(100)) {
33 | @Override
34 | public void onRun() throws Throwable {
35 | super.onRun();
36 | mockTimer.incrementMs(150);
37 | throw new RuntimeException("why not fail");
38 | }
39 |
40 | @Override
41 | protected void onCancel(@CancelReason int cancelReason, @Nullable Throwable throwable) {
42 | reason.set(cancelReason);
43 | super.onCancel(cancelReason, throwable);
44 | }
45 |
46 | @Override
47 | protected RetryConstraint shouldReRunOnThrowable(@NonNull Throwable throwable, int runCount, int maxRunCount) {
48 | calledShouldReRun.set(true);
49 | return RetryConstraint.RETRY;
50 | }
51 | };
52 | waitUntilAJobIsDone(jobManager, new WaitUntilCallback() {
53 | @Override
54 | public void run() {
55 | jobManager.addJob(job);
56 | }
57 |
58 | @Override
59 | public void assertJob(Job job) {
60 |
61 | }
62 | });
63 | MatcherAssert.assertThat(reason.get(), CoreMatchers.is(CancelReason.REACHED_DEADLINE));
64 | MatcherAssert.assertThat(calledShouldReRun.get(), CoreMatchers.is(false));
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/InjectorTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.Job;
4 | import com.birbit.android.jobqueue.JobHolder;
5 | import com.birbit.android.jobqueue.JobManager;
6 | import com.birbit.android.jobqueue.Params;
7 | import com.birbit.android.jobqueue.config.Configuration;
8 | import com.birbit.android.jobqueue.di.DependencyInjector;
9 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
10 | import static org.hamcrest.CoreMatchers.*;
11 | import org.hamcrest.*;
12 | import org.junit.Test;
13 | import org.junit.runner.RunWith;
14 | import org.robolectric.*;
15 | import org.robolectric.annotation.Config;
16 |
17 | import java.util.concurrent.atomic.AtomicInteger;
18 |
19 | @RunWith(RobolectricTestRunner.class)
20 |
21 | public class InjectorTest extends JobManagerTestBase {
22 | @Test
23 | public void testInjector() throws Throwable {
24 | Configuration.Builder builder = new Configuration.Builder(RuntimeEnvironment.application);
25 | final JobManagerTestBase.ObjectReference injectedJobReference = new JobManagerTestBase.ObjectReference();
26 | final AtomicInteger injectionCallCount = new AtomicInteger(0);
27 | DependencyInjector dependencyInjector = new DependencyInjector() {
28 | @Override
29 | public void inject(Job job) {
30 | injectedJobReference.setObject(job);
31 | injectionCallCount.incrementAndGet();
32 | }
33 | };
34 | builder.injector(dependencyInjector);
35 | builder.timer(mockTimer);
36 | JobManager jobManager = createJobManager(builder);
37 | jobManager.stop();
38 | jobManager.addJob(new DummyJob(new Params(4)));
39 | MatcherAssert.assertThat("injection should be called after adding a non-persistent job", injectionCallCount.get(), equalTo(1));
40 | jobManager.addJob(new DummyJob(new Params(1).persist()));
41 | MatcherAssert.assertThat("injection should be called after adding a persistent job", injectionCallCount.get(), equalTo(2));
42 | JobHolder holder = nextJob(jobManager);
43 | MatcherAssert.assertThat("injection should NOT be called for non persistent job", holder.getJob(), not(injectedJobReference.getObject()));
44 | MatcherAssert.assertThat("injection should be called once for non persistent job", injectionCallCount.get(), equalTo(2));
45 | holder = nextJob(jobManager);
46 | MatcherAssert.assertThat("injection should be called for persistent job", holder.getJob(), equalTo(injectedJobReference.getObject()));
47 | MatcherAssert.assertThat("injection should be called two times for persistent job", injectionCallCount.get(), equalTo(3));
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/NetworkJobWithConnectivityListenerTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.Job;
4 | import com.birbit.android.jobqueue.JobManager;
5 | import com.birbit.android.jobqueue.Params;
6 | import com.birbit.android.jobqueue.config.Configuration;
7 | import com.birbit.android.jobqueue.network.NetworkUtil;
8 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
9 |
10 | import org.hamcrest.CoreMatchers;
11 | import org.hamcrest.MatcherAssert;
12 | import org.junit.Test;
13 | import org.junit.runner.RunWith;
14 | import org.robolectric.*;
15 | import org.robolectric.annotation.Config;
16 |
17 | import static org.hamcrest.CoreMatchers.equalTo;
18 |
19 | @RunWith(RobolectricTestRunner.class)
20 |
21 | public class NetworkJobWithConnectivityListenerTest extends JobManagerTestBase {
22 | @Test
23 | public void testNetworkJobWithConnectivityListener() throws Exception {
24 | final DummyNetworkUtilWithConnectivityEventSupport dummyNetworkUtil = new DummyNetworkUtilWithConnectivityEventSupport();
25 | final JobManager jobManager = createJobManager(
26 | new Configuration.Builder(RuntimeEnvironment.application)
27 | .networkUtil(dummyNetworkUtil)
28 | .timer(mockTimer));
29 | dummyNetworkUtil.setNetworkStatus(NetworkUtil.DISCONNECTED, true);
30 | final DummyJob dummyJob = new DummyJob(new Params(0).requireNetwork());
31 | jobManager.addJob(dummyJob);
32 | // no job to run so consumers should finish
33 | jobManager.waitUntilConsumersAreFinished();
34 | MatcherAssert.assertThat("count should be 1 as no jobs should be consumed w/o network", jobManager.count(), equalTo(1));
35 | // JobManager may wake up as idle right here and see the new network value. sleep to avoid it
36 | // count will trigger the queue and will result in another IDLE call. We need to wait until
37 | // it is handled.
38 | //noinspection SLEEP_IN_CODE
39 | Thread.sleep(2000);
40 |
41 | dummyNetworkUtil.setNetworkStatus(NetworkUtil.METERED, false);
42 | //noinspection SLEEP_IN_CODE
43 | Thread.sleep(5000); //wait a little bit more to let consumer run
44 | MatcherAssert.assertThat("even though network is recovered, job manager should not consume any job because it " +
45 | "does not know (we did not inform)", jobManager.count(), equalTo(1));
46 |
47 | waitUntilAJobIsDone(jobManager, new WaitUntilCallback() {
48 | @Override
49 | public void run() {
50 | dummyNetworkUtil.setNetworkStatus(NetworkUtil.METERED, true);
51 | }
52 |
53 | @Override
54 | public void assertJob(Job job) {
55 | MatcherAssert.assertThat("should be the added job", job, CoreMatchers.is((Job) dummyJob));
56 | }
57 | });
58 | MatcherAssert.assertThat("job manager should consume network job after it is informed that network is recovered"
59 | , jobManager.count(), equalTo(0));
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/NetworkNextJobTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobHolder;
4 | import com.birbit.android.jobqueue.JobManager;
5 | import com.birbit.android.jobqueue.Params;
6 | import com.birbit.android.jobqueue.config.Configuration;
7 | import com.birbit.android.jobqueue.network.NetworkUtil;
8 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
9 |
10 | import org.hamcrest.MatcherAssert;
11 | import org.junit.Test;
12 | import org.junit.runner.RunWith;
13 | import org.robolectric.RobolectricTestRunner;
14 | import org.robolectric.RuntimeEnvironment;
15 | import org.robolectric.annotation.Config;
16 |
17 | import static org.hamcrest.CoreMatchers.equalTo;
18 | import static org.hamcrest.CoreMatchers.notNullValue;
19 | import static org.hamcrest.CoreMatchers.nullValue;
20 |
21 | @RunWith(RobolectricTestRunner.class)
22 |
23 | public class NetworkNextJobTest extends JobManagerTestBase {
24 |
25 | @Test
26 | public void testNetworkNextJob() throws Throwable {
27 | DummyNetworkUtil dummyNetworkUtil = new DummyNetworkUtil();
28 | JobManager jobManager = createJobManager(
29 | new Configuration.Builder(RuntimeEnvironment.application)
30 | .networkUtil(dummyNetworkUtil)
31 | .timer(mockTimer));
32 | jobManager.stop();
33 | DummyJob dummyJob = new DummyJob(new Params(0).requireNetwork());
34 | jobManager.addJob(dummyJob);
35 | dummyNetworkUtil.setNetworkStatus(NetworkUtil.DISCONNECTED);
36 | MatcherAssert.assertThat("when there isn't any network, next job should return null",
37 | nextJob(jobManager), nullValue());
38 | MatcherAssert
39 | .assertThat("even if there is network, job manager should return correct count",
40 | jobManager.count(), equalTo(1));
41 | dummyNetworkUtil.setNetworkStatus(NetworkUtil.METERED);
42 | JobHolder retrieved = nextJob(jobManager);
43 | MatcherAssert
44 | .assertThat("when network is recovered, next job should be retrieved", retrieved,
45 | notNullValue());
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/NonSerializableJobTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.Params;
5 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
6 |
7 | import org.hamcrest.CoreMatchers;
8 | import org.hamcrest.MatcherAssert;
9 | import org.junit.Test;
10 | import org.junit.runner.RunWith;
11 | import org.robolectric.RobolectricTestRunner;
12 | import org.robolectric.annotation.Config;
13 |
14 | import java.io.IOException;
15 | import java.util.concurrent.CountDownLatch;
16 | import java.util.concurrent.TimeUnit;
17 |
18 | @RunWith(RobolectricTestRunner.class)
19 |
20 | public class NonSerializableJobTest extends JobManagerTestBase {
21 | @Test
22 | public void test() throws InterruptedException {
23 | final Throwable[] throwable = new Throwable[1];
24 | JobManager jobManager = createJobManager();
25 | final CountDownLatch latch = new CountDownLatch(1);
26 | jobManager.getJobManagerExecutionThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
27 | @Override
28 | public void uncaughtException(Thread thread, Throwable ex) {
29 | throwable[0] = ex;
30 | latch.countDown();
31 | }
32 | });
33 | jobManager.addJobInBackground(new DummyJob(new Params(0).persist()) {
34 | ICannotBeSerialized iCannotBeSerialized = new ICannotBeSerialized();
35 |
36 | });
37 | MatcherAssert.assertThat(latch.await(30, TimeUnit.SECONDS), CoreMatchers.is(true));
38 | MatcherAssert.assertThat(throwable[0] instanceof RuntimeException, CoreMatchers.is(true));
39 | MatcherAssert.assertThat(throwable[0].getCause() instanceof IOException, CoreMatchers.is(true));
40 | }
41 |
42 | static class ICannotBeSerialized {
43 |
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/PersistentJobTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.Params;
5 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
6 | import static org.hamcrest.CoreMatchers.*;
7 | import org.hamcrest.*;
8 | import org.junit.Test;
9 | import org.junit.runner.RunWith;
10 | import org.robolectric.*;
11 | import org.robolectric.annotation.Config;
12 |
13 | import java.util.concurrent.CountDownLatch;
14 | import java.util.concurrent.TimeUnit;
15 |
16 | @RunWith(RobolectricTestRunner.class)
17 |
18 | public class PersistentJobTest extends JobManagerTestBase {
19 | //TEST parallel running
20 | public static CountDownLatch persistentRunLatch = new CountDownLatch(1);
21 |
22 | @Test
23 | public void testPersistentJob() throws Exception {
24 | JobManager jobManager = createJobManager();
25 | jobManager.addJob(new DummyPersistentLatchJob());
26 | persistentRunLatch.await(5, TimeUnit.SECONDS);
27 | MatcherAssert.assertThat((int) persistentRunLatch.getCount(), equalTo(0));
28 | }
29 |
30 | protected static class DummyPersistentLatchJob extends DummyJob {
31 |
32 | public DummyPersistentLatchJob() {
33 | super(new Params(0).persist());
34 | }
35 |
36 | @Override
37 | public void onRun() throws Throwable {
38 | PersistentJobTest.persistentRunLatch.countDown();
39 | }
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/PriorityTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import android.annotation.TargetApi;
4 | import android.os.Build;
5 | import androidx.annotation.NonNull;
6 | import androidx.annotation.Nullable;
7 |
8 | import com.birbit.android.jobqueue.CancelReason;
9 | import com.birbit.android.jobqueue.Job;
10 | import com.birbit.android.jobqueue.JobManager;
11 | import com.birbit.android.jobqueue.Params;
12 | import com.birbit.android.jobqueue.RetryConstraint;
13 | import com.birbit.android.jobqueue.config.Configuration;
14 |
15 | import org.hamcrest.MatcherAssert;
16 | import org.junit.Test;
17 | import org.junit.runner.RunWith;
18 | import org.robolectric.RobolectricTestRunner;
19 | import org.robolectric.RuntimeEnvironment;
20 | import org.robolectric.annotation.Config;
21 |
22 | import java.util.concurrent.CountDownLatch;
23 | import java.util.concurrent.TimeUnit;
24 | import java.util.concurrent.atomic.AtomicInteger;
25 |
26 | import static org.hamcrest.CoreMatchers.equalTo;
27 | import static org.hamcrest.CoreMatchers.is;
28 |
29 | @RunWith(RobolectricTestRunner.class)
30 |
31 | public class PriorityTest extends JobManagerTestBase {
32 | private static CountDownLatch priorityRunLatch;
33 |
34 | @Test
35 | public void testPriority() throws Exception {
36 | JobManager jobManager = createJobManager(
37 | new Configuration.Builder(RuntimeEnvironment.application)
38 | .maxConsumerCount(1)
39 | .timer(mockTimer));
40 | testPriority(jobManager, false);
41 | }
42 |
43 | @TargetApi(Build.VERSION_CODES.GINGERBREAD)
44 | public void testPriority(JobManager jobManager, boolean persist) throws Exception {
45 | priorityRunLatch = new CountDownLatch(2);
46 | DummyJobWithRunOrderAssert.globalRunCount = new AtomicInteger(0);
47 | Job job1 = new DummyJobWithRunOrderAssert(2, new Params(1).setPersistent(persist));
48 | Job job2 = new DummyJobWithRunOrderAssert(1, new Params(2).setPersistent(persist));
49 | jobManager.stop();
50 | jobManager.addJob(job1);
51 | jobManager.addJob(job2);
52 | jobManager.start();
53 | MatcherAssert.assertThat(priorityRunLatch.await(1, TimeUnit.MINUTES), is(true));
54 | //ensure both jobs did run
55 | MatcherAssert.assertThat((int) priorityRunLatch.getCount(), equalTo(0));
56 | }
57 |
58 | public static class DummyJobWithRunOrderAssert extends Job {
59 | transient public static AtomicInteger globalRunCount;
60 | private int expectedRunOrder;
61 |
62 | public DummyJobWithRunOrderAssert(int expectedRunOrder, Params params) {
63 | super(params.requireNetwork());
64 | this.expectedRunOrder = expectedRunOrder;
65 | }
66 |
67 | @Override
68 | public void onAdded() {
69 | }
70 |
71 | @Override
72 | public void onRun() throws Throwable {
73 | final int cnt = globalRunCount.incrementAndGet();
74 | MatcherAssert.assertThat(expectedRunOrder, equalTo(cnt));
75 | priorityRunLatch.countDown();
76 | }
77 |
78 | @Override
79 | protected RetryConstraint shouldReRunOnThrowable(@NonNull Throwable throwable, int runCount, int maxRunCount) {
80 | return RetryConstraint.CANCEL;
81 | }
82 |
83 | @Override
84 | protected void onCancel(@CancelReason int cancelReason, @Nullable Throwable throwable) {
85 |
86 | }
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/ReRunWithLimitTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.Job;
4 | import com.birbit.android.jobqueue.JobManager;
5 |
6 | import org.hamcrest.MatcherAssert;
7 | import org.junit.Test;
8 | import org.junit.runner.RunWith;
9 | import org.robolectric.RobolectricTestRunner;
10 | import org.robolectric.annotation.Config;
11 |
12 | import static org.hamcrest.CoreMatchers.equalTo;
13 |
14 | @RunWith(RobolectricTestRunner.class)
15 |
16 | public class ReRunWithLimitTest extends JobManagerTestBase {
17 | @Test
18 | public void testReRunWithLimit() throws Exception {
19 | JobManager jobManager = createJobManager();
20 | testReRun(jobManager, false);
21 | }
22 |
23 | @Test
24 | public void testReRunWithLimitPersist() throws Exception {
25 | JobManager jobManager = createJobManager();
26 | testReRun(jobManager, true);
27 | }
28 |
29 | private void testReRun(final JobManager jobManager, boolean persist) throws InterruptedException {
30 | DummyJobWithRunCount.runCount = 0;//reset
31 | final DummyJobWithRunCount job = new DummyJobWithRunCount(persist);
32 | waitUntilAJobIsDone(jobManager, new WaitUntilCallback() {
33 | @Override
34 | public void run() {
35 | jobManager.addJob(job);
36 | }
37 |
38 | @Override
39 | public void assertJob(Job job) {
40 |
41 | }
42 | });
43 |
44 |
45 | MatcherAssert.assertThat(DummyJobWithRunCount.runCount, equalTo(job.getRetryLimit()));
46 | MatcherAssert.assertThat((int) jobManager.count(), equalTo(0));
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/RunFailingJobTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import androidx.annotation.NonNull;
4 | import androidx.annotation.Nullable;
5 |
6 | import com.birbit.android.jobqueue.CancelReason;
7 | import com.birbit.android.jobqueue.Job;
8 | import com.birbit.android.jobqueue.JobManager;
9 | import com.birbit.android.jobqueue.Params;
10 | import com.birbit.android.jobqueue.RetryConstraint;
11 |
12 | import org.hamcrest.MatcherAssert;
13 | import org.junit.Test;
14 | import org.junit.runner.RunWith;
15 | import org.robolectric.RobolectricTestRunner;
16 | import org.robolectric.annotation.Config;
17 |
18 | import java.util.concurrent.CountDownLatch;
19 | import java.util.concurrent.TimeUnit;
20 |
21 | import static org.hamcrest.CoreMatchers.equalTo;
22 |
23 | @RunWith(RobolectricTestRunner.class)
24 |
25 | public class RunFailingJobTest extends JobManagerTestBase {
26 | @Test
27 | public void runFailingJob() throws Exception {
28 | final CountDownLatch latch = new CountDownLatch(1);
29 | JobManager jobManager = createJobManager();
30 | jobManager.addJob(new Job(new Params(0).requireNetwork()) {
31 | @Override
32 | public void onAdded() {
33 |
34 | }
35 |
36 | @Override
37 | public void onRun() throws Throwable {
38 | throw new RuntimeException();
39 | }
40 |
41 | @Override
42 | protected void onCancel(@CancelReason int cancelReason, @Nullable Throwable throwable) {
43 | latch.countDown();
44 | }
45 |
46 | @Override
47 | protected RetryConstraint shouldReRunOnThrowable(@NonNull Throwable throwable, int runCount, int maxRunCount) {
48 | return RetryConstraint.CANCEL;
49 | }
50 | });
51 | latch.await(10, TimeUnit.SECONDS);
52 | MatcherAssert.assertThat((int) latch.getCount(), equalTo(0));
53 | }
54 |
55 | }
56 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/RunManyNonPersistentTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.Params;
5 | import static org.hamcrest.CoreMatchers.*;
6 | import org.hamcrest.*;
7 | import org.junit.Test;
8 | import org.junit.runner.RunWith;
9 | import org.robolectric.*;
10 | import org.robolectric.annotation.Config;
11 |
12 | import java.util.concurrent.CountDownLatch;
13 | import java.util.concurrent.TimeUnit;
14 |
15 | @RunWith(RobolectricTestRunner.class)
16 |
17 | public class RunManyNonPersistentTest extends JobManagerTestBase {
18 | @Test
19 | public void runManyNonPersistentJobs() throws Exception {
20 | JobManager jobManager = createJobManager();
21 | jobManager.stop();
22 | int limit = 2;
23 | final CountDownLatch latch = new CountDownLatch(limit);
24 | for (int i = 0; i < limit; i++) {
25 | jobManager.addJob(new DummyLatchJob(new Params(i), latch));
26 | }
27 | jobManager.start();
28 | latch.await(10, TimeUnit.SECONDS);
29 | MatcherAssert.assertThat((int) latch.getCount(), equalTo(0));
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/SessionIdTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 |
4 | import com.birbit.android.jobqueue.Job;
5 | import com.birbit.android.jobqueue.JobHolder;
6 | import com.birbit.android.jobqueue.JobManager;
7 | import com.birbit.android.jobqueue.Params;
8 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
9 |
10 | import static org.hamcrest.CoreMatchers.*;
11 | import org.hamcrest.*;
12 | import org.junit.Test;
13 | import org.junit.runner.RunWith;
14 | import org.robolectric.*;
15 | import org.robolectric.annotation.Config;
16 |
17 | @RunWith(RobolectricTestRunner.class)
18 |
19 | public class SessionIdTest extends JobManagerTestBase {
20 | @Test
21 | public void testSessionId() throws Throwable {
22 | JobManager jobManager = createJobManager();
23 | Long sessionId = mockTimer.nanoTime(); //we know job manager uses this value :/
24 | jobManager.stop();
25 | Job[] jobs = new Job[]{new DummyJob(new Params(0)), new DummyJob(new Params(0).persist())};
26 | for (Job job : jobs) {
27 | jobManager.addJob(job);
28 | }
29 |
30 | for (int i = 0; i < jobs.length; i++) {
31 | JobHolder jobHolder = nextJob(jobManager);
32 | MatcherAssert.assertThat("session id should be correct for job " + i, jobHolder.getRunningSessionId(), equalTo(sessionId));
33 | }
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobmanager/ThreadFactoryTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobmanager;
2 |
3 | import androidx.annotation.NonNull;
4 | import androidx.annotation.Nullable;
5 |
6 | import com.birbit.android.jobqueue.CancelReason;
7 | import com.birbit.android.jobqueue.Job;
8 | import com.birbit.android.jobqueue.JobManager;
9 | import com.birbit.android.jobqueue.Params;
10 | import com.birbit.android.jobqueue.RetryConstraint;
11 | import com.birbit.android.jobqueue.config.Configuration;
12 |
13 | import org.hamcrest.MatcherAssert;
14 | import org.junit.Test;
15 | import org.junit.runner.RunWith;
16 | import org.robolectric.RobolectricTestRunner;
17 | import org.robolectric.RuntimeEnvironment;
18 | import org.robolectric.annotation.Config;
19 |
20 | import java.util.UUID;
21 | import java.util.concurrent.ThreadFactory;
22 |
23 | @RunWith(RobolectricTestRunner.class)
24 |
25 | public class ThreadFactoryTest extends JobManagerTestBase {
26 |
27 | private Throwable error;
28 |
29 | @Test
30 | public void testThreadFactory() throws Throwable {
31 | final JobManager jobManager = createJobManager(
32 | new Configuration.Builder(RuntimeEnvironment.application)
33 | .timer(mockTimer)
34 | .threadFactory(new ThreadFactory() {
35 | @Override
36 | public Thread newThread(@NonNull Runnable r) {
37 | return new DummyThread(r);
38 | }
39 | })
40 | );
41 | final Job job = new CheckWorkerJob();
42 | waitUntilAJobIsDone(jobManager, new WaitUntilCallback() {
43 | @Override
44 | public void run() {
45 | jobManager.addJob(job);
46 | }
47 |
48 | @Override
49 | public void assertJob(Job job) {}
50 | });
51 | if (error != null) {
52 | throw error;
53 | }
54 | }
55 |
56 | static class DummyThread extends Thread {
57 |
58 | public DummyThread(Runnable runnable) {
59 | super(runnable, "dummy-worker-" + UUID.randomUUID().toString());
60 | }
61 |
62 | }
63 |
64 | class CheckWorkerJob extends Job {
65 |
66 | protected CheckWorkerJob() {
67 | super(new Params(1));
68 | }
69 |
70 | @Override
71 | public void onAdded() {}
72 |
73 | @Override
74 | public void onRun() throws Throwable {
75 | try {
76 | MatcherAssert.assertThat("Worker thread should be an instance of DummyThread",
77 | Thread.currentThread() instanceof DummyThread);
78 | } catch (Throwable e) {
79 | error = e;
80 | }
81 | }
82 |
83 | @Override
84 | protected void onCancel(@CancelReason int cancelReason, @Nullable Throwable throwable) {}
85 |
86 | @Override
87 | protected RetryConstraint shouldReRunOnThrowable(@NonNull Throwable throwable, int runCount, int maxRunCount) {
88 | return RetryConstraint.CANCEL;
89 | }
90 | }
91 |
92 | }
93 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobqueue/CachedPersistentJobQueueTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobqueue;
2 |
3 | import com.birbit.android.jobqueue.JobQueue;
4 | import com.birbit.android.jobqueue.config.Configuration;
5 | import com.birbit.android.jobqueue.persistentQueue.sqlite.SqliteJobQueue;
6 | import com.birbit.android.jobqueue.test.util.JobQueueFactory;
7 | import com.birbit.android.jobqueue.timer.Timer;
8 |
9 | import org.junit.runner.RunWith;
10 | import org.robolectric.*;
11 | import org.robolectric.annotation.Config;
12 |
13 | @RunWith(RobolectricTestRunner.class)
14 |
15 | public class CachedPersistentJobQueueTest extends JobQueueTestBase {
16 | public CachedPersistentJobQueueTest() {
17 | super(new JobQueueFactory() {
18 | @Override
19 | public JobQueue createNew(long sessionId, String id, Timer timer) {
20 | SqliteJobQueue.JavaSerializer jobSerializer = new SqliteJobQueue.JavaSerializer();
21 | return new SqliteJobQueue(
22 | new Configuration.Builder(RuntimeEnvironment.application)
23 | .id(id).jobSerializer(jobSerializer).inTestMode()
24 | .timer(timer).build(), sessionId, jobSerializer);
25 | }
26 | });
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobqueue/JobParamsTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobqueue;
2 |
3 | import com.birbit.android.jobqueue.JobHolder;
4 | import com.birbit.android.jobqueue.Params;
5 | import com.birbit.android.jobqueue.network.NetworkUtil;
6 | import com.birbit.android.jobqueue.test.TestBase;
7 | import com.birbit.android.jobqueue.test.jobs.DummyJob;
8 | import com.birbit.android.jobqueue.test.timer.MockTimer;
9 |
10 | import static org.hamcrest.CoreMatchers.*;
11 | import static org.hamcrest.MatcherAssert.*;
12 | import org.junit.Test;
13 | import org.junit.runner.RunWith;
14 | import org.robolectric.*;
15 | import org.robolectric.annotation.Config;
16 |
17 | @RunWith(RobolectricTestRunner.class)
18 |
19 | public class JobParamsTest extends TestBase {
20 | @Test
21 | public void assertParamsUnderstood() {
22 | MockTimer mockTimer = new MockTimer();
23 | JobHolder j1 = JobQueueTestBase.createNewJobHolder(new Params(1).requireNetwork(), mockTimer);
24 | assertThat("require network param should be understood properly", j1.getRequiredNetworkType(), equalTo(NetworkUtil.METERED));
25 |
26 | JobHolder j2 = JobQueueTestBase.createNewJobHolder(new Params(1).groupBy("blah"), mockTimer);
27 | assertThat("group param should be understood properly", j2.getGroupId(), equalTo("blah"));
28 | assertThat("require network param should be understood properly",
29 | j2.getRequiredNetworkType(), equalTo(NetworkUtil.DISCONNECTED));
30 |
31 | JobHolder j3 = JobQueueTestBase.createNewJobHolder(new Params(1).persist(), mockTimer);
32 | assertThat("persist param should be understood properly", j3.persistent, equalTo(true));
33 |
34 | JobHolder j4 = JobQueueTestBase.createNewJobHolder(new Params(1).setPersistent(false)
35 | .setRequiresNetwork(false).setGroupId(null).setSingleId(null), mockTimer);
36 | assertThat("persist param should be understood properly", j4.persistent, equalTo(false));
37 | assertThat("require network param should be understood properly", j4.getRequiredNetworkType(), equalTo(NetworkUtil.DISCONNECTED));
38 |
39 | assertThat("group param should be understood properly", j4.groupId, nullValue());
40 | assertThat("single param should be understood properly", j4.getSingleInstanceId(), nullValue());
41 | mockTimer.incrementMs(2);
42 |
43 | DummyJob j15 = new DummyJob(new Params(1).singleInstanceBy("bloop"));
44 | assertThat("single param should be understood properly", j15.getSingleInstanceId(), endsWith("bloop"));
45 | assertThat("group param should be automatically set if single instance", j15.getRunGroupId(), notNullValue());
46 |
47 | mockTimer.setNow(150);
48 |
49 | JobHolder j6 = JobQueueTestBase.createNewJobHolder(new Params(1), mockTimer);
50 | assertThat("no deadline", j6.getDeadlineNs(), is(Params.FOREVER));
51 |
52 | JobHolder j7 = JobQueueTestBase.createNewJobHolder(new Params(1).overrideDeadlineToCancelInMs(100), mockTimer);
53 | assertThat("100 ms deadline", j7.getDeadlineNs(), is(100000150L));
54 | assertThat("100 ms deadline", j7.shouldCancelOnDeadline(), is(true));
55 |
56 | JobHolder j13 = JobQueueTestBase.createNewJobHolder(new Params(1).overrideDeadlineToCancelInMs(200), mockTimer);
57 | assertThat("100 ms deadline", j13.getDeadlineNs(), is(200000150L));
58 | assertThat("100 ms deadline", j7.shouldCancelOnDeadline(), is(true));
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobqueue/SimpleInMemoryJobQueueTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobqueue;
2 |
3 | import com.birbit.android.jobqueue.inMemoryQueue.SimpleInMemoryPriorityQueue;
4 | import com.birbit.android.jobqueue.JobQueue;
5 | import com.birbit.android.jobqueue.test.util.JobQueueFactory;
6 | import com.birbit.android.jobqueue.timer.Timer;
7 |
8 | import org.junit.runner.RunWith;
9 | import org.robolectric.RobolectricTestRunner;
10 | import org.robolectric.annotation.Config;
11 |
12 | @RunWith(RobolectricTestRunner.class)
13 |
14 | public class SimpleInMemoryJobQueueTest extends JobQueueTestBase {
15 | public SimpleInMemoryJobQueueTest() {
16 | super(new JobQueueFactory() {
17 | @Override
18 | public JobQueue createNew(long sessionId, String id, Timer timer) {
19 | return new SimpleInMemoryPriorityQueue(null, sessionId);
20 | }
21 | });
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/jobs/DummyJob.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.jobs;
2 |
3 | import androidx.annotation.NonNull;
4 | import androidx.annotation.Nullable;
5 |
6 | import com.birbit.android.jobqueue.CancelReason;
7 | import com.birbit.android.jobqueue.Job;
8 | import com.birbit.android.jobqueue.Params;
9 | import com.birbit.android.jobqueue.RetryConstraint;
10 |
11 | public class DummyJob extends Job {
12 | int onAddedCnt = 0;
13 | int onRunCnt = 0;
14 | int onCancelCnt = 0;
15 | int shouldReRunOnThrowableCnt = 0;
16 |
17 | public DummyJob(Params params) {
18 | super(params);
19 | }
20 |
21 | @Override
22 | public void onAdded() {
23 | onAddedCnt++;
24 | }
25 |
26 | @Override
27 | public void onRun() throws Throwable {
28 | onRunCnt++;
29 | }
30 |
31 | @Override
32 | protected void onCancel(@CancelReason int cancelReason, @Nullable Throwable throwable) {
33 | onCancelCnt++;
34 | }
35 |
36 | @Override
37 | protected RetryConstraint shouldReRunOnThrowable(@NonNull Throwable throwable, int runCount, int maxRunCount) {
38 | shouldReRunOnThrowableCnt++;
39 | return RetryConstraint.CANCEL;
40 | }
41 |
42 | public int getOnAddedCnt() {
43 | return onAddedCnt;
44 | }
45 |
46 | public int getOnRunCnt() {
47 | return onRunCnt;
48 | }
49 |
50 | public int getOnCancelCnt() {
51 | return onCancelCnt;
52 | }
53 |
54 | public int getShouldReRunOnThrowableCnt() {
55 | return shouldReRunOnThrowableCnt;
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/util/JobQueueFactory.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.util;
2 |
3 | import com.birbit.android.jobqueue.JobQueue;
4 | import com.birbit.android.jobqueue.timer.Timer;
5 |
6 | public interface JobQueueFactory {
7 | public JobQueue createNew(long sessionId, String id, Timer timer);
8 | }
9 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/test/util/RunningJobSetTest.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.test.util;
2 |
3 | import com.birbit.android.jobqueue.RunningJobSet;
4 | import com.birbit.android.jobqueue.test.timer.MockTimer;
5 | import com.birbit.android.jobqueue.timer.SystemTimer;
6 | import com.birbit.android.jobqueue.timer.Timer;
7 |
8 | import static org.hamcrest.MatcherAssert.*;
9 | import static org.hamcrest.CoreMatchers.*;
10 |
11 | import org.junit.Before;
12 | import org.junit.Test;
13 | import org.junit.runner.RunWith;
14 | import org.robolectric.RobolectricTestRunner;
15 | import org.robolectric.annotation.Config;
16 |
17 | import java.util.Arrays;
18 | import java.util.Iterator;
19 | import java.util.concurrent.atomic.AtomicLong;
20 |
21 | @RunWith(RobolectricTestRunner.class)
22 |
23 | public class RunningJobSetTest {
24 | RunningJobSet set;
25 | @Before
26 | public void setUp() {
27 | set = new RunningJobSet(new SystemTimer());
28 | }
29 |
30 | @Test
31 | public void testEmpty() {
32 | assertThat(set.getSafe().size(), is(0));
33 | }
34 |
35 | @Test
36 | public void testAdd() {
37 | set.add("g1");
38 | assertThat(set.getSafe().iterator().next(), is("g1"));
39 | }
40 |
41 | @Test
42 | public void testAddTheSame() {
43 | set.add("g1");
44 | set.add("g1");
45 | assertThat(set.getSafe().iterator().next(), is("g1"));
46 | assertThat(set.getSafe().size(), is(1));
47 | }
48 |
49 | @Test
50 | public void testRemove() {
51 | set.add("g1");
52 | set.remove("g1");
53 | assertThat(set.getSafe().iterator().hasNext(), is(false));
54 | }
55 |
56 | @Test
57 | public void testOrder() {
58 | set.add("a");
59 | set.add("z");
60 | set.add("b");
61 | assertList("a", "b", "z");
62 | }
63 |
64 | private void assertList(String... items) {
65 | assertThat(set.getSafe().size(), is(items.length));
66 | Iterator iterator = set.getSafe().iterator();
67 | for (int i = 0; i < items.length; i++) {
68 | assertThat(iterator.next(), is(items[i]));
69 | }
70 | }
71 |
72 | @Test
73 | public void testAddWithTimeout() {
74 | MockTimer timer = new MockTimer();
75 | set = new RunningJobSet(timer);
76 | set.addGroupUntil("g1", 10L);
77 | timer.setNow(5);
78 | assertList("g1");
79 | timer.setNow(11);
80 | assertList();
81 | timer.setNow(3);
82 | assertList(); // should've pruned the list
83 | }
84 |
85 | @Test
86 | public void testAddSameGroupTwiceWithTimeout() {
87 | MockTimer timer = new MockTimer();
88 | set = new RunningJobSet(timer);
89 | set.addGroupUntil("g1", 10L);
90 | set.addGroupUntil("g1", 12L);
91 | timer.setNow(5);
92 | assertList("g1");
93 | timer.setNow(11);
94 | assertList("g1");
95 | timer.setNow(13);
96 | assertList();
97 | }
98 |
99 | @Test
100 | public void testAddMultipleGroupTimeouts() {
101 | MockTimer timer = new MockTimer();
102 | set = new RunningJobSet(timer);
103 | set.addGroupUntil("g1", 10L);
104 | set.addGroupUntil("g2", 20L);
105 | timer.setNow(5);
106 | assertList("g1", "g2");
107 | timer.setNow(11);
108 | assertList("g2");
109 | timer.setNow(21);
110 | assertList();
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/testing/CleanupRule.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.testing;
2 |
3 | import com.birbit.android.jobqueue.JobManager;
4 | import com.birbit.android.jobqueue.test.jobmanager.JobManagerTestBase;
5 |
6 | import org.junit.runner.Description;
7 |
8 | public class CleanupRule extends ThreadDumpRule {
9 | final JobManagerTestBase test;
10 |
11 | public CleanupRule(JobManagerTestBase test) {
12 | this.test = test;
13 | }
14 |
15 | @Override
16 | protected void starting(Description description) {
17 | super.starting(description);
18 | System.out.println("started test " + getId(description));
19 | }
20 |
21 | @Override
22 | protected void finished(Description description) {
23 | String id = getId(description);
24 | System.out.println("tear down " + id);
25 | for (JobManager jobManager : test.getCreatedJobManagers()) {
26 | JobManagerTestBase.NeverEndingDummyJob.unlockAll();
27 | jobManager.destroy();
28 | }
29 | System.out.println("finished tear down of " + id);
30 | }
31 |
32 | private String getId(Description description) {
33 | return description.getMethodName() + "/" + description.getClassName();
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/testing/CollectLogsRule.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.testing;
2 |
3 |
4 | import com.birbit.android.jobqueue.log.CustomLogger;
5 | import com.birbit.android.jobqueue.log.JqLog;
6 |
7 | import org.junit.rules.TestWatcher;
8 | import org.junit.runner.Description;
9 |
10 | public class CollectLogsRule extends TestWatcher {
11 | public final CollectingLogger logger = new CollectingLogger();
12 |
13 | public CollectLogsRule() {
14 | super();
15 | }
16 |
17 | @Override
18 | protected void starting(Description description) {
19 | super.starting(description);
20 | JqLog.setCustomLogger(logger);
21 | }
22 |
23 | @Override
24 | public void failed(Throwable e, Description description) {
25 | throw new AssertionError(logger.logs.toString());
26 | }
27 |
28 | static class CollectingLogger implements CustomLogger {
29 | private StringBuffer logs = new StringBuffer();
30 | @Override
31 | public boolean isDebugEnabled() {
32 | return true;
33 | }
34 |
35 | @Override
36 | public void d(String text, Object... args) {
37 | logs.append(Thread.currentThread().getName()).append("[d]:");
38 | logs.append(String.format(text, args)).append("\n");
39 | }
40 |
41 | @Override
42 | public void e(Throwable t, String text, Object... args) {
43 | logs.append(Thread.currentThread().getName()).append("[e]:");
44 | logs.append(String.format(text, args)).append("\n");
45 | }
46 |
47 | @Override
48 | public void e(String text, Object... args) {
49 | logs.append(Thread.currentThread().getName()).append("[e]:");
50 | logs.append(String.format(text, args)).append("\n");
51 | }
52 |
53 | @Override
54 | public void v(String text, Object... args) {
55 | logs.append(Thread.currentThread().getName()).append("[v]:");
56 | logs.append(String.format(text, args)).append("\n");
57 | }
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/testing/StackTraceRule.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.testing;
2 |
3 | import org.junit.Rule;
4 | import org.junit.rules.TestRule;
5 | import org.junit.rules.TestWatcher;
6 | import org.junit.runner.Description;
7 | import org.junit.runners.model.Statement;
8 |
9 | import java.lang.annotation.Annotation;
10 | import java.util.Map;
11 |
12 | public class StackTraceRule extends TestWatcher {
13 |
14 | @Override
15 | protected void failed(Throwable e, Description description) {
16 | System.out.println("stack trace detected failed test");
17 | super.failed(e, description);
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/jobqueue/src/test/java/com/birbit/android/jobqueue/testing/ThreadDumpRule.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.testing;
2 |
3 | import org.junit.rules.TestWatcher;
4 | import org.junit.runner.Description;
5 |
6 | import java.util.Map;
7 |
8 | /**
9 | * Throws a new assertion with thread dump
10 | */
11 | public class ThreadDumpRule extends TestWatcher {
12 | @Override
13 | public void failed(Throwable e, Description description) {
14 | Map stackTraces = Thread.getAllStackTraces();
15 | // add stack traces to the errors
16 | StringBuilder sb = new StringBuilder("Thread dump:");
17 | for (Map.Entry entry : stackTraces.entrySet()) {
18 | sb.append(entry.getKey().getName()).append("\n");
19 | for (StackTraceElement element : entry.getValue()) {
20 | sb.append(" ").append(element.getClassName())
21 | .append("#").append(element.getMethodName())
22 | .append("#").append(element.getLineNumber())
23 | .append("\n");
24 | }
25 | sb.append("\n----------\n");
26 | }
27 | throw new AssertionError(sb.toString());
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/jobqueue/src/test/resources/robolectric.properties:
--------------------------------------------------------------------------------
1 | sdk=21
--------------------------------------------------------------------------------
/lint/build.gradle:
--------------------------------------------------------------------------------
1 | group 'com.birbit.android.jobqueue'
2 | version '1.0'
3 |
4 | apply plugin: 'java'
5 |
6 | sourceCompatibility = 1.6
7 |
8 | repositories {
9 | jcenter()
10 | }
11 |
12 | dependencies {
13 | compile 'com.android.tools.lint:lint-api:24.5.0'
14 | compile 'com.android.tools.lint:lint-checks:24.5.0'
15 | testCompile group: 'junit', name: 'junit', version: '4.11'
16 | }
17 |
18 | jar {
19 | manifest {
20 | attributes("Lint-Registry": "com.birbit.android.jobqueue.lint.JobQueueDevelopmentLintRegistery")
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/lint/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yigit/android-priority-jobqueue/360c090857eb0f6efbdde04a7c8bb5cc31582eb9/lint/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/lint/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Fri Jan 01 00:50:43 PST 2016
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | distributionUrl=https\://services.gradle.org/distributions/gradle-2.5-all.zip
7 |
--------------------------------------------------------------------------------
/lint/gradlew.bat:
--------------------------------------------------------------------------------
1 | @if "%DEBUG%" == "" @echo off
2 | @rem ##########################################################################
3 | @rem
4 | @rem Gradle startup script for Windows
5 | @rem
6 | @rem ##########################################################################
7 |
8 | @rem Set local scope for the variables with windows NT shell
9 | if "%OS%"=="Windows_NT" setlocal
10 |
11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
12 | set DEFAULT_JVM_OPTS=
13 |
14 | set DIRNAME=%~dp0
15 | if "%DIRNAME%" == "" set DIRNAME=.
16 | set APP_BASE_NAME=%~n0
17 | set APP_HOME=%DIRNAME%
18 |
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 |
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 |
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 |
32 | goto fail
33 |
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 |
38 | if exist "%JAVA_EXE%" goto init
39 |
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 |
46 | goto fail
47 |
48 | :init
49 | @rem Get command-line arguments, handling Windowz variants
50 |
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | if "%@eval[2+2]" == "4" goto 4NT_args
53 |
54 | :win9xME_args
55 | @rem Slurp the command line arguments.
56 | set CMD_LINE_ARGS=
57 | set _SKIP=2
58 |
59 | :win9xME_args_slurp
60 | if "x%~1" == "x" goto execute
61 |
62 | set CMD_LINE_ARGS=%*
63 | goto execute
64 |
65 | :4NT_args
66 | @rem Get arguments from the 4NT Shell from JP Software
67 | set CMD_LINE_ARGS=%$
68 |
69 | :execute
70 | @rem Setup the command line
71 |
72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
73 |
74 | @rem Execute Gradle
75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
76 |
77 | :end
78 | @rem End local scope for the variables with windows NT shell
79 | if "%ERRORLEVEL%"=="0" goto mainEnd
80 |
81 | :fail
82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
83 | rem the _cmd.exe /c_ return code!
84 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
85 | exit /b 1
86 |
87 | :mainEnd
88 | if "%OS%"=="Windows_NT" endlocal
89 |
90 | :omega
91 |
--------------------------------------------------------------------------------
/lint/settings.gradle:
--------------------------------------------------------------------------------
1 | rootProject.name = 'lint'
2 |
3 |
--------------------------------------------------------------------------------
/lint/src/main/java/com/birbit/android/jobqueue/lint/JobQueueDevelopmentLintRegistery.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.lint;
2 |
3 | import com.android.tools.lint.client.api.IssueRegistry;
4 | import com.android.tools.lint.detector.api.Issue;
5 |
6 | import java.util.Arrays;
7 | import java.util.List;
8 |
9 | public class JobQueueDevelopmentLintRegistery extends IssueRegistry {
10 | @Override
11 | public List getIssues() {
12 | return Arrays.asList(SystemTimeDetector.ISSUE, SleepDetector.ISSUE, WaitOnObjectWithTimeDetector.ISSUE,
13 | NotifyOnObjectDetector.ISSUE);
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/lint/src/main/java/com/birbit/android/jobqueue/lint/NotifyOnObjectDetector.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.lint;
2 |
3 | import com.android.annotations.NonNull;
4 | import com.android.tools.lint.detector.api.*;
5 | import lombok.ast.AstVisitor;
6 | import lombok.ast.Expression;
7 | import lombok.ast.ForwardingAstVisitor;
8 | import lombok.ast.MethodInvocation;
9 |
10 | import java.util.EnumSet;
11 | import java.util.HashSet;
12 | import java.util.Set;
13 |
14 | public class NotifyOnObjectDetector extends Detector implements Detector.JavaScanner {
15 | public static final Issue ISSUE = Issue.create(
16 | "NOTIFY_ON_OBJECT",
17 | "Code should not notify on objects directly",
18 | "Use Timer instead so that mock notifications can work as expected",
19 | Category.CORRECTNESS,
20 | 6,
21 | Severity.ERROR,
22 | new Implementation(NotifyOnObjectDetector.class, EnumSet.of(Scope.JAVA_FILE))
23 | );
24 |
25 | private static final Set BAD_METHODS = new HashSet();
26 | static {
27 | BAD_METHODS.add("notify");
28 | BAD_METHODS.add("notifyAll");
29 | }
30 |
31 | @Override
32 | public AstVisitor createJavaVisitor(@NonNull final JavaContext context) {
33 | return new ForwardingAstVisitor() {
34 |
35 | @Override
36 | public boolean visitMethodInvocation(MethodInvocation node) {
37 | Expression operand = node.astOperand();
38 | String methodName = node.astName().toString();
39 | if (BAD_METHODS.contains(methodName) && !context.isSuppressedWithComment(node, ISSUE)) {
40 | context.report(ISSUE, context.getLocation(node), "Don't call " + methodName + " directly. Use" +
41 | " Timer instead.");
42 | }
43 | return super.visitMethodInvocation(node);
44 | }
45 | };
46 | }
47 | }
48 |
49 |
--------------------------------------------------------------------------------
/lint/src/main/java/com/birbit/android/jobqueue/lint/SleepDetector.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.lint;
2 |
3 | import com.android.annotations.NonNull;
4 | import com.android.tools.lint.detector.api.*;
5 | import lombok.ast.*;
6 |
7 | import java.util.EnumSet;
8 |
9 | /**
10 | * Detects sleep calls in tests.
11 | */
12 | public class SleepDetector extends Detector implements Detector.JavaScanner {
13 | public static final Issue ISSUE = Issue.create(
14 | "SLEEP_IN_CODE",
15 | "Tests should not use sleep.",
16 | "Tests should not use sleep. Instead, use mock timer",
17 | Category.CORRECTNESS,
18 | 6,
19 | Severity.ERROR,
20 | new Implementation(SleepDetector.class, EnumSet.of(Scope.JAVA_FILE, Scope.TEST_SOURCES))
21 | );
22 |
23 | @Override
24 | public AstVisitor createJavaVisitor(@NonNull final JavaContext context) {
25 | return new ForwardingAstVisitor() {
26 | @Override
27 | public boolean visitMethodInvocation(MethodInvocation node) {
28 | Expression operand = node.astOperand();
29 | if (node.astName().toString().equals("sleep") && operand.toString().equals("Thread") && !context.isSuppressedWithComment(node, ISSUE)) {
30 | context.report(ISSUE, node, context.getLocation(node), "Don't call sleep. Use MockTimer instead.");
31 | }
32 | return super.visitMethodInvocation(node);
33 | }
34 | };
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/lint/src/main/java/com/birbit/android/jobqueue/lint/SystemTimeDetector.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.lint;
2 |
3 | import com.android.annotations.NonNull;
4 | import com.android.tools.lint.detector.api.*;
5 | import lombok.ast.AstVisitor;
6 | import lombok.ast.Expression;
7 | import lombok.ast.ForwardingAstVisitor;
8 | import lombok.ast.MethodInvocation;
9 |
10 | import java.util.EnumSet;
11 | import java.util.HashSet;
12 | import java.util.Set;
13 |
14 | public class SystemTimeDetector extends Detector implements Detector.JavaScanner {
15 | public static final Issue ISSUE = Issue.create(
16 | "DIRECT_TIME_ACCESS",
17 | "Code should not access time directly",
18 | "Code should not access System time. Use Timer instead.",
19 | Category.CORRECTNESS,
20 | 6,
21 | Severity.ERROR,
22 | new Implementation(SystemTimeDetector.class, EnumSet.of(Scope.JAVA_FILE))
23 | );
24 |
25 | private static final Set BAD_METHODS = new HashSet();
26 | static {
27 | BAD_METHODS.add("nanoTime");
28 | BAD_METHODS.add("currentTimeMillis");
29 | }
30 |
31 | @Override
32 | public AstVisitor createJavaVisitor(@NonNull final JavaContext context) {
33 | return new ForwardingAstVisitor() {
34 |
35 | @Override
36 | public boolean visitMethodInvocation(MethodInvocation node) {
37 | Expression operand = node.astOperand();
38 | String methodName = node.astName().toString();
39 | if (BAD_METHODS.contains(methodName) && operand.toString().equals("System") && !context.isSuppressedWithComment(node, ISSUE)) {
40 | context.report(ISSUE, context.getLocation(node), "Don't call " + methodName + " on system. Use" +
41 | " Timer instead.");
42 | }
43 | return super.visitMethodInvocation(node);
44 | }
45 | };
46 | }
47 | }
48 |
49 |
--------------------------------------------------------------------------------
/lint/src/main/java/com/birbit/android/jobqueue/lint/WaitOnObjectWithTimeDetector.java:
--------------------------------------------------------------------------------
1 | package com.birbit.android.jobqueue.lint;
2 |
3 | import com.android.annotations.NonNull;
4 | import com.android.tools.lint.detector.api.*;
5 | import lombok.ast.AstVisitor;
6 | import lombok.ast.Expression;
7 | import lombok.ast.ForwardingAstVisitor;
8 | import lombok.ast.MethodInvocation;
9 |
10 | import java.util.EnumSet;
11 |
12 | /**
13 | * Detects sleep calls in tests.
14 | */
15 | public class WaitOnObjectWithTimeDetector extends Detector implements Detector.JavaScanner {
16 | public static final Issue ISSUE = Issue.create(
17 | "TIMED_WAIT",
18 | "Code should not use object locked waits.",
19 | "Code should not use timed waits directly. Instead, used the timer's utility method.",
20 | Category.CORRECTNESS,
21 | 6,
22 | Severity.ERROR,
23 | new Implementation(WaitOnObjectWithTimeDetector.class, EnumSet.of(Scope.JAVA_FILE))
24 | );
25 |
26 | @Override
27 | public AstVisitor createJavaVisitor(@NonNull final JavaContext context) {
28 | return new ForwardingAstVisitor() {
29 | @Override
30 | public boolean visitMethodInvocation(MethodInvocation node) {
31 | Expression operand = node.astOperand();
32 | if (node.astName().toString().equals("wait")
33 | && !context.isSuppressedWithComment(node, ISSUE)) {
34 | context.report(ISSUE, context.getLocation(node), "Don't wait on object. Use Timer's wait instead.");
35 | }
36 | return super.visitMethodInvocation(node);
37 | }
38 | };
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | rootProject.name = "android-priority-jobqueue"
2 | include ":jobqueue"
3 | include ":examples:twitter:TwitterClient"
--------------------------------------------------------------------------------