JobRequest.Builder (library API)

java.lang.Object
- com.evernote.android.job.JobRequest.Builder

Enclosing class:: JobRequest

public static final class JobRequest.Builder
extends java.lang.Object

Builder class for constructing JobRequests.

Constructor Summary

Constructors
Constructor and Description

Builder(java.lang.String tag)
Creates a new instance to build a JobRequest.

Constructors
Constructor and Description
`Builder(java.lang.String tag)` Creates a new instance to build a `JobRequest`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`JobRequest`	`build()`
`boolean`	`equals(java.lang.Object o)`
`int`	`hashCode()`
`JobRequest.Builder`	`setBackoffCriteria(long backoffMs, JobRequest.BackoffPolicy backoffPolicy)` Change the back-off policy for a non periodic job.
`JobRequest.Builder`	`setExact(long exactMs)` Specify that the job should run at an exact time.
`JobRequest.Builder`	`setExecutionWindow(long startMs, long endMs)` Set the time window when the job will be run.
`JobRequest.Builder`	`setExtras(PersistableBundleCompat extras)` Set optional extras.
`JobRequest.Builder`	`setPeriodic(long intervalMs)` Specify that this job should recur with the provided interval, not more than once per period.
`JobRequest.Builder`	`setPeriodic(long intervalMs, long flexMs)` Specify that this job should recur with the provided interval and flex, not more than once per period.
`JobRequest.Builder`	`setPersisted(boolean persisted)` Set whether the job should be persisted across reboots.
`JobRequest.Builder`	`setRequiredNetworkType(JobRequest.NetworkType networkType)` Set some description of the kind of network type your job needs to have.
`JobRequest.Builder`	`setRequirementsEnforced(boolean enforced)` It's possible to set several requirements for a job, however, not all of them need to be considered by the underlying `JobApi`.
`JobRequest.Builder`	`setRequiresCharging(boolean requiresCharging)` Specify that to run this job, the device needs to be plugged in.
`JobRequest.Builder`	`setRequiresDeviceIdle(boolean requiresDeviceIdle)` Specify that to run, the job needs the device to be in idle mode.
`JobRequest.Builder`	`setUpdateCurrent(boolean updateCurrent)` Sets whether this request should overwrite any preexisting jobs with the same tag.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Builder
```
public Builder(java.lang.String tag)
```
    Creates a new instance to build a JobRequest. Note that the tag doesn't need to be unique. Each created request has an unique ID to differentiate between jobs with the same tag.
    
    When your job is about to start you receive a callback in your JobCreator to create a Job for this tag.
    
    Parameters:
    
    tag - The tag is used to identify your Job in JobCreator.create(String).
- Method Detail
  - setExecutionWindow
```
public JobRequest.Builder setExecutionWindow(long startMs,
                                             long endMs)
```
    Set the time window when the job will be run. Note that it's mandatory to set a time for one-off tasks, but it's not allowed to call this method together with setPeriodic(long) or setExact(long). For those types jobs it doesn't make sense to have a time window.
    
    The window specified is treated as offset from now, e.g. the job will run between System.currentTimeMillis() + startMs and System.currentTimeMillis() + endMs.
    
    The maximum value for each argument is Long.MAX_VALUE / 3 * 2 (about 53_375_995_583 days). Otherwise some APIs schedule the job immediately. No exception is thrown if an argument is greater than the maximum value, the arguments are silently being clamped.
    
    NOTE: It's not recommended to have such big execution windows. The AlarmManager used as fallback API doesn't allow setting a start date. Although being inexact, the execution time is the arithmetic average of startMs and endMs. The result could be that your job never runs on pre Android 5.0 devices, if one argument is too large.
    
    Parameters:
    
    startMs - Earliest point from which your task is eligible to run.
    
    endMs - Latest point at which your task must be run.
  - setExtras
```
public JobRequest.Builder setExtras(PersistableBundleCompat extras)
```
    Set optional extras. This is persisted, so only primitive types are allowed.
    
    Parameters:
    
    extras - Bundle containing extras which you can retrieve with Job.Params.getExtras().
  - setRequirementsEnforced
```
public JobRequest.Builder setRequirementsEnforced(boolean enforced)
```
    It's possible to set several requirements for a job, however, not all of them need to be considered by the underlying JobApi. If the requirements are enforced, then the device state is checked before your job runs. If at least one requirement isn't met, then the job is rescheduled and not run.
    
    It's possible to check single requirements in your job, if you keep this field set to false. The Job class provides several methods, e.g. Job.isRequirementChargingMet().
    
    Note that it's not allowed to set requirements for exact jobs. That wouldn't make sense, because the job needs to run at a specific time no matter of the device's state.
    
    The default value is set to false.
    
    Parameters:
    
    enforced - If true, then all set requirements are manually checked.
  - setRequiredNetworkType
```
public JobRequest.Builder setRequiredNetworkType(JobRequest.NetworkType networkType)
```
    Set some description of the kind of network type your job needs to have. Not calling this function means the network is not necessary, as the default is JobRequest.NetworkType.ANY.
    
    Note that if the deadline is met and the requirements aren't enforced, then your job will run and ignore this requirement.
    
    Parameters:
    
    networkType - The required network type.
    
    See Also:
    
    setRequirementsEnforced(boolean), setExecutionWindow(long, long)
  - setRequiresCharging
```
public JobRequest.Builder setRequiresCharging(boolean requiresCharging)
```
    Specify that to run this job, the device needs to be plugged in. The default is set to false.
    
    Note that if the deadline is met and the requirements aren't enforced, then your job will run and ignore this requirement.
    
    Parameters:
    
    requiresCharging - Whether or not the device needs to be plugged in.
    
    See Also:
    
    setRequirementsEnforced(boolean), setExecutionWindow(long, long)
  - setRequiresDeviceIdle
```
public JobRequest.Builder setRequiresDeviceIdle(boolean requiresDeviceIdle)
```
    Specify that to run, the job needs the device to be in idle mode. This defaults to false. Idle mode is a loose definition provided by the system, which means that the device is not in use, and has not been in use for some time. As such, it is a good time to perform resource heavy jobs.
    
    Note that if the deadline is met and the requirements aren't enforced, then your job will run and ignore this requirement.
    
    Parameters:
    
    requiresDeviceIdle - Whether or not the device needs be idle.
    
    See Also:
    
    setRequirementsEnforced(boolean), setExecutionWindow(long, long)
  - setExact
```
public JobRequest.Builder setExact(long exactMs)
```
    Specify that the job should run at an exact time. This type of job must only be used for situations where it is actually required that the alarm go off even while in idle. A reasonable example would be for a calendar notification that should make a sound so the user is aware of it.
    
    Note that an exact job can't be periodic. It's also not allowed to specify any requirement, the exact timing is the most important requirement for such a job. This method overrides any specified time window.
    
    The default value is set to false. Internally an exact job is always using the AlarmManager.
    
    The milliseconds specified are treated as offset from now, e.g. the job will run at System.currentTimeMillis() + exactMs.
    
    The maximum value of the argument is Long.MAX_VALUE / 3 * 2 (about 53_375_995_583 days). No exception is thrown if the argument is greater than the maximum value, the argument is silently being clamped.
    
    Parameters:
    
    exactMs - The exact offset when the job should run from when the job was scheduled.
    
    See Also:
    
    AlarmManager.setExact(int, long, android.app.PendingIntent), AlarmManager.setExactAndAllowWhileIdle(int, long, android.app.PendingIntent)
  - setPeriodic
```
public JobRequest.Builder setPeriodic(long intervalMs)
```
    Specify that this job should recur with the provided interval, not more than once per period. As default a job isn't periodic.
    
    It isn't allowed to specify a time window for a periodic job. Instead you set an interval with this function. Since Job.Result.RESCHEDULE is ignored for periodic jobs, setting a back-off criteria is illegal as well.
    
    Parameters:
    
    intervalMs - The job should run at most once every intervalMs. The minimum value is 15min.
  - setPeriodic
```
public JobRequest.Builder setPeriodic(long intervalMs,
                                      long flexMs)
```
    Specify that this job should recur with the provided interval and flex, not more than once per period. The flex controls how close to the end of a period the job can run. For example, specifying an interval of 60 seconds and a flex of 15 seconds will allow the scheduler to determine the best moment between the 45th and 60th second at which to execute your job.
    
    As default a job isn't periodic. It isn't allowed to specify a time window for a periodic job. Instead you set an interval with this function. Since Job.Result.RESCHEDULE is ignored for periodic jobs, setting a back-off criteria is illegal as well.
    
    Parameters:
    
    intervalMs - The job should run at most once every intervalMs. The minimum value is 15min.
    
    flexMs - How close to the end of the period the job should run. The minimum value is 5min.
    
    See Also:
    
    JobRequest.MIN_INTERVAL, JobRequest.MIN_FLEX
  - setBackoffCriteria
```
public JobRequest.Builder setBackoffCriteria(long backoffMs,
                                             JobRequest.BackoffPolicy backoffPolicy)
```
    Change the back-off policy for a non periodic job. The default value is set to 30 seconds and JobRequest.BackoffPolicy.EXPONENTIAL. The time is increasing each time a job fails and returns Job.Result.RESCHEDULE, but capped at 5 hours.
    
    Note that it's not allowed to change the back-off criteria for a periodic job.
    
    Parameters:
    
    backoffMs - The initial interval to wait when the job has been rescheduled.
    
    backoffPolicy - Is either JobRequest.BackoffPolicy.LINEAR or JobRequest.BackoffPolicy.EXPONENTIAL.
    
    See Also:
    
    Job.Result.RESCHEDULE, Job.onReschedule(int)
  - setPersisted
```
public JobRequest.Builder setPersisted(boolean persisted)
```
    Set whether the job should be persisted across reboots. This will only have an effect if your application holds the permission Manifest.permission.RECEIVE_BOOT_COMPLETED. Otherwise an exception will be thrown. The default is set to false.
    
    Parameters:
    
    persisted - If true the job is scheduled after a reboot.
  - setUpdateCurrent
```
public JobRequest.Builder setUpdateCurrent(boolean updateCurrent)
```
    Sets whether this request should overwrite any preexisting jobs with the same tag. If true, then this request calls JobManager.cancelAllForTag(String) with the given tag before being scheduled.
    
    Parameters:
    
    updateCurrent - If {code true} this request will cancel any preexisting job with the same tag while being scheduled.
  - build
```
public JobRequest build()
```
    Returns:
    
    The JobRequest with this parameters to hand to the JobManager.
  - equals
```
public boolean equals(java.lang.Object o)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object

Class JobRequest.Builder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Builder

Method Detail

setExecutionWindow

setExtras

setRequirementsEnforced

setRequiredNetworkType

setRequiresCharging

setRequiresDeviceIdle

setExact

setPeriodic

setPeriodic

setBackoffCriteria

setPersisted

setUpdateCurrent

build

equals

hashCode