jobmanager - GitLite

KO | EN

gitlite — search

#javascript #llm #go #golang #android #machine-learning #rust #deep-learning #awesome #kubernetes #vue #pytorch #openai #open-source

jobmanager

(★ 101)

Android library for executing tasks.

파일 탐색기

최종 버전 다운로드 (.zip)

- - gradle-wrapper.jar
  - gradle-wrapper.properties
- - AndroidManifest.xml
.gitignore
build.gradle
gradlew
gradlew.bat
README.md

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/signalapp/jobmanager

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd jobmanager

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Gradle (Java/Kotlin)

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
JDK (Java) Java/Kotlin 프로젝트를 빌드/실행하려면 필요합니다.
Gradle 레포에 포함된 gradlew(Gradle Wrapper)를 쓰면 Gradle을 따로 설치할 필요가 없습니다.

./gradlew build

Gradle로 빌드를 진행합니다.

✅ BUILD SUCCESSFUL 메시지가 뜨면 성공입니다. build/ 폴더에 결과물이 생성됩니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# JobManager

An Android library that facilitates scheduling persistent jobs which are executed when their
prerequisites have been met.  Similar to Path's android-priority-queue.

Add as a gradle dependency, replacing `${latest_version}` with the version currently available:

```
dependencies {
  compile 'org.whispersystems:jobmanager:${latest_version}'
}
```

## The JobManager Way

Android apps often need to perform blocking operations.  A messaging app might need to make REST
API calls over a network, send SMS messages, download attachments, and interact with a database.

The standard Android way to do these things are with Services, AsyncTasks, or a dedicated Thread.
However, some of an app's operations might need to wait until certain dependencies are available
(such as a network connection), and some of the operations might need to be durable (complete even if the
app restarts before they have a chance to run).  The standard Android way can result in
a lot of retry logic, timers for monitoring dependencies, and one-off code for making operations
durable.

By contrast, the JobManager way allows operations to be broken up into Jobs.  A Job represents a
unit of work to be done, the prerequisites that need to be met (such as network access) before the
work can execute, and the characteristics of the job (such as durable persistence).

Applications construct a `JobManager` at initialization time:

```
public class ApplicationContext extends Application {

private JobManager jobManager;

@Override
  public void onCreate() {
    initializeJobManager();
  }

private void initializeJobManager() {
    this.jobManager = JobManager.newBuilder(this)
                                .withName("SampleJobManager")
                                .withConsumerThreads(5)
                                .build();
  }

...

}
```

This constructs a new `JobManager` with 5 consumer threads dedicated to executing Jobs.  A
Job looks like this:

```
public class SampleJob extends Job {

public SampleJob() {
    super(JobParameters.newBuilder().create());
  }

@Override
  public onAdded() {
    // Called after the Job has been added to the queue.
  }

@Override
  public void onRun() {
    // Here's where we execute our work.
    Log.w("SampleJob", "Hello, world!");
  }

@Override
  public void onCanceled() {
    // This would be called if the job had failed.
  }

@Override
  public boolean onShouldRetry(Exception exception) {
   // Called if onRun() had thrown an exception to determine whether
   // onRun() should be called again.
   return false;
  }
}
```

A Job is scheduled simply by adding it to the JobManager:

```
  this.jobManager.add(new SampleJob());
```

## Persistence

To create durable Jobs, the JobManager needs to be given an interface responsible for serializing
and deserializing Job objects.  A `JavaJobSerializer` is included with JobManager that uses Java
Serialization, but you can specify your own serializer if you wish:

```
public class ApplicationContext extends Application {

private JobManager jobManager;

@Override
  public void onCreate() {
    initializeJobManager();
  }

private void initializeJobManager() {
    this.jobManager = JobManager.newBuilder(this)
                                .withName("SampleJobManager")
                                .withConsumerThreads(5)
                                .withJobSerializer(new JavaJobSerializer())
                                .build();
  }

...

}

```

The Job simply needs to declare itself as durable when constructed:

```
public class SampleJob extends Job {

public SampleJob() {
    super(JobParameters.newBuilder()
                       .withPersistence()
                       .create());
  }

...

```

Persistent jobs that are enqueued will be serialized to disk to ensure that they run even if
the App restarts first.  A Job's onAdded() method is called after the commit to disk is complete.

## Requirements

A Job might have certain requirements that need to be met before it can run.  A requirement is
represented by the `Requirement` interface.  Each `Requirement` must also have a corresponding
`RequirementProvider` that is registered with the JobManager.

A `Requirement` tells you whether it is present when queried, while a `RequirementProvider`
broadcasts to a listener when a Requirement's status might have changed.  `Requirement` is attached
to Job, while `RequirementProvider` is attached to JobManager.

One common `Requirement` a `Job` might depend on is the presence of network connectivity.
A `NetworkRequirement` is bundled with JobManager:

```
public class ApplicationContext extends Application {

private JobManager jobManager;

@Override
  public void onCreate() {
    initializeJobManager();
  }

private void initializeJobManager() {
    this.jobManager = JobManager.newBuilder(this)
                                .withName("SampleJobManager")
                                .withConsumerThreads(5)
                                .withJobSerializer(new JavaJobSerializer())
                                .withRequirementProviders(new NetworkRequirementProvider(this))
                                .build();
  }

...

}
```

The Job declares itself as having a `Requirement` when constructed:

```
public class SampleJob extends Job {

public SampleJob(Context context) {
    super(JobParameters.newBuilder()
                       .withPersistence()
                       .withRequirement(new NetworkRequirement(context))
                       .create());
  }

...

```

## Dependency Injection

It is possible that Jobs (and Requirements) might require dependency injection.  A simple example
is `Context`, which many Jobs might require, but can't be persisted to disk for durable Jobs.  Or
maybe Jobs require more complex DI through libraries such as Dagger.

JobManager has an extremely primitive DI mechanism strictly for injecting `Context` objects into
Jobs and Requirements after they're deserialized, and includes support for plugging in more complex
DI systems such as Dagger.

The JobManager `Context` injection works by having your `Job` and/or `Requirement` implement the
`ContextDependent` interface.  `Job`s and `Requirement`s implementing that interface will get a
`setContext(Context context)` call immediately after the persistent `Job` or `Requirement` is
deserialized.

To plugin a more complex DI mechanism, simply pass an instance of the `DependencyInjector` interface
 to the `JobManager`:

```
public class ApplicationContext extends Application implements DependencyInjector {

private JobManager jobManager;

@Override
  public void onCreate() {
    initializeJobManager();
  }

private void initializeJobManager() {
    this.jobManager = JobManager.newBuilder(this)
                                .withName("SampleJobManager")
                                .withConsumerThreads(5)
                                .withJobSerializer(new JavaJobSerializer())
                                .withRequirementProviders(new NetworkRequirementProvider(this))
                                .withDependencyInjector(this)
                                .build();
  }

@Override
  public void injectDependencies(Object object) {
    // And here we do our DI magic.
  }

...

}
```

`injectDependencies(Object object)` will be called for a `Job` before the job's `onAdded()` method
is called, or after a persistent job is deserialized.

## License

Copyright 2014 Open Whisper Systems

Licensed under the GPLv3: http://www.gnu.org/licenses/gpl-3.0.html