Package io.rong.imlib

## Class RongJobIntentService

- All Implemented Interfaces:

      public abstract class RongJobIntentService

  Helper for processing work that has been enqueued for a job/service. When running on Android O or later, the work will be dispatched as a job via JobScheduler.enqueue. When running on older versions of the platform, it will use Context.startService.

  You must publish your subclass in your manifest for the system to interact with. This should be published as a android.app.job.JobService, as described for that class, since on O and later platforms it will be executed that way.

  Use enqueueWork to enqueue new work to be dispatched to and handled by your service. It will be executed in onHandleWork.

  You do not need to use androidx.legacy.content.WakefulBroadcastReceiver when using this class. When running on Android O, the JobScheduler will take care of wake locks for you (holding a wake lock from the time you enqueue work until the job has been dispatched and while it is running). When running on previous versions of the platform, this wake lock handling is emulated in the class here by directly calling the PowerManager; this means the application must request the WAKE_LOCK permission.

  There are a few important differences in behavior when running on Android O or later as a Job vs. pre-O:

  - When running as a pre-O service, the act of enqueueing work will generally start the service immediately, regardless of whether the device is dozing or in other conditions. When running as a Job, it will be subject to standard JobScheduler policies for a Job with a setOverrideDeadline of 0: the job will not run while the device is dozing, it may get delayed more than a service if the device is under strong memory pressure with lots of demand to run jobs.

  - When running as a pre-O service, the normal service execution semantics apply: the service can run indefinitely, though the longer it runs the more likely the system will be to outright kill its process, and under memory pressure one should expect the process to be killed even of recently started services. When running as a Job, the typical execution time limit will apply, after which the job will be stopped (cleanly, not by killing the process) and rescheduled to continue its execution later. Job are generally not killed when the system is under memory pressure, since the number of concurrent jobs is adjusted based on the memory state of the device.

  Here is an example implementation of this class:

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---

  - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `RongJobIntentService()` | Default empty constructor.

  - ### Enum Constant Summary

    Enum Constants
    Enum Constant | Description
    --- | ---

  - ### Method Summary

    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `onCreate()` |
    `int` | `onStartCommand(Intent intent, int flags, int startId)` | Processes start commands when running as a pre-O service, enqueueing them to be later dispatched in onHandleWork.
    `IBinder` | `onBind(Intent intent)` | Returns the IBinder for the android.app.job.
    `void` | `onDestroy()` |
    `static void` | `enqueueWork(Context context, Class cls, int jobId, Intent work)` | Call this to enqueue work for your subclass of RongJobIntentService.
    `static void` | `enqueueWork(Context context, ComponentName component, int jobId, Intent work)` | Like enqueueWork, but supplies a ComponentName for the service to interact with instead of its class.
    `void` | `setInterruptIfStopped(boolean interruptIfStopped)` | Control whether code executing in onHandleWork will be interrupted if the job is stopped.
    `boolean` | `isStopped()` | Returns true if onStopCurrentWork has been called.
    `boolean` | `onStopCurrentWork()` | This will be called if the JobScheduler has decided to stop this job.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### RongJobIntentService

          RongJobIntentService()

      Default empty constructor.

  - ### Method Detail

    - #### onCreate

           void onCreate()

    - #### onStartCommand

           int onStartCommand(Intent intent, int flags, int startId)

      Processes start commands when running as a pre-O service, enqueueing them to be later dispatched in onHandleWork.

    - #### onBind

           IBinder onBind(Intent intent)

      Returns the IBinder for the android.app.job.JobServiceEngine when running as a JobService on O and later platforms.

    - #### onDestroy

           void onDestroy()

    - #### enqueueWork

           static void enqueueWork(Context context, Class cls, int jobId, Intent work)

      Call this to enqueue work for your subclass of RongJobIntentService. This will either directly start the service (when running on pre-O platforms) or enqueue work for it as a job (when running on O and later). In either case, a wake lock will be held for you to ensure you continue running. The work you enqueue will ultimately appear at onHandleWork.

      Parameters:
        `context` - Context this is being called from.
        `cls` - The concrete class the work should be dispatched to (this is the class that is published in your manifest).
        `jobId` - A unique job ID for scheduling; must be the same value for all work enqueued for the same class.
        `work` - The Intent of work to enqueue.

    - #### enqueueWork

           static void enqueueWork(Context context, ComponentName component, int jobId, Intent work)

      Like enqueueWork, but supplies a ComponentName for the service to interact with instead of its class.

      Parameters:
        `context` - Context this is being called from.
        `component` - The published ComponentName of the class this work should be dispatched to.
        `jobId` - A unique job ID for scheduling; must be the same value for all work enqueued for the same class.
        `work` - The Intent of work to enqueue.

    - #### setInterruptIfStopped

           void setInterruptIfStopped(boolean interruptIfStopped)

      Control whether code executing in onHandleWork will be interrupted if the job is stopped. By default this is false. If called and set to true, any time onStopCurrentWork is called, the class will first call AsyncTask.cancel(true) to interrupt the running task.

      Parameters:
        `interruptIfStopped` - Set to true to allow the system to interrupt actively running work.

    - #### isStopped

           boolean isStopped()

      Returns true if onStopCurrentWork has been called. You can use this, while executing your work, to see if it should be stopped.

    - #### onStopCurrentWork

           boolean onStopCurrentWork()

      This will be called if the JobScheduler has decided to stop this job. The job for this service does not have any constraints specified, so this will only generally happen if the service exceeds the job's maximum execution time.

      Returns:

        True to indicate to the JobManager whether you'd like to reschedule this work, false to drop this and all following work. Regardless of the value returned, your service must stop executing or the system will ultimately kill it. The default implementation returns true, and that is most likely what you want to return as well (so no work gets lost).