官方 DEMO

路徑如下

sdk\sources\android-22\com\android\demo\jobSchedulerApp\

Demo 需求

JobShedule的出發點是提供省電場景給使用者進行任務完成，目前主要場景如下
1.網路資料場景
2.充電場景
3.idle待機場景
4.固定週期場景

接下來我們已
充電下且網路為連線時的場景為例進行JobShedule的使用說明。

Demo中的原始碼都是Google SDK自帶的

核心設定引數程式碼如下

        // 設定最小的延遲時間
        builder.setMinimumLatency(1
 
*1000);

        // 設定最大的延遲時間，一旦設定了這個屬性，不管其他條件怎麼樣，jobinfo到了時間就一定會執行。
        builder.setOverrideDeadline(5*1000);

        // 設定在什麼樣的網路下啟動jobinfo
        builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED);

        // 設定裝置需要在空閒的時候，是否啟動job
        builder.setRequiresDeviceIdle(false);

        // 設定是否充電情況下排程
 

        builder.setRequiresCharging(true);

備註：上述的關係是與的關係，不是或的關係

場景條件達成回撥介面如下

public class MyJobSchedulerService extends JobService{

    /**
     * 滿足Job預設定條件下回調 
     */
    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        Log.d(Constant.TAG, "onStartJob: " + jobParameters.getJobId());
    }

    /**
     * 1.被CancleAll的時候回撥
     * 2.不滿足預設定條件的情況下回調
     */
 

    @Override
    public boolean onStopJob(JobParameters jobParameters) {
    }

}

重要許可權

    <service android:name=".service.MyJobSchedulerService"
        android:permission="android.permission.BIND_JOB_SERVICE"/>

    /**
     * Job services must be protected with this permission:
     *
     * <pre class="prettyprint">
     *     &#60;service android:name="MyJobService"
     *              android:permission="android.permission.BIND_JOB_SERVICE" &#62;
     *         ...
     *     &#60;/service&#62;
     * </pre>
     *
     * <p>If a job service is declared in the manifest but not protected with this
     * permission, that service will be ignored by the OS.
     */
    public static final String PERMISSION_BIND =
            "android.permission.BIND_JOB_SERVICE";

JobScheduler引數設定指令

public void scheduleJob(View v) {
        if (!ensureJobSchedulerService()) {
            return;
        }

        JobInfo.Builder builder = new JobInfo.Builder(kJobId++, mServiceComponent);
        /**
         * Specify that this job should be delayed by the provided amount of time.
         * Because it doesn't make sense setting this property on a periodic job, doing so will
         * throw an {@link java.lang.IllegalArgumentException} when
         * {@link android.app.job.JobInfo.Builder#build()} is called.
         * @param minLatencyMillis Milliseconds before which this job will not be considered for
         *                         execution.
         */
        // 設定最小的延遲時間
        // builder.setMinimumLatency(1*1000);
        /**
         * Set deadline which is the maximum scheduling latency. The job will be run by this
         * deadline even if other requirements are not met. Because it doesn't make sense setting
         * this property on a periodic job, doing so will throw an
         * {@link java.lang.IllegalArgumentException} when
         * {@link android.app.job.JobInfo.Builder#build()} is called.
         */
        // 設定最大的延遲時間，一旦設定了這個屬性，不管其他條件怎麼樣，jobinfo到了時間就一定會執行。
        // builder.setOverrideDeadline(5*1000);
        /** Default. 任意網路都可以*/
        // public static final int NETWORK_TYPE_NONE = 0;
        /** This job requires network connectivity. 任意網路都可以*/
        // public static final int NETWORK_TYPE_ANY = 1;
        /** This job requires network connectivity that is unmetered. 無線網路接入*/
        // public static final int NETWORK_TYPE_UNMETERED = 2;
        /** This job requires network connectivity that is not roaming. 非漫遊*/
        // public static final int NETWORK_TYPE_NOT_ROAMING = 3;
        /** This job requires metered connectivity such as most cellular data networks. 移動資料網路 */
        // public static final int NETWORK_TYPE_METERED = 4;
        // 設定在什麼樣的網路下啟動jobinfo
        builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED);

        /**
         * Specify that to run, the job needs the device to be in idle mode. This defaults to
         * false.
         * <p>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. Bear in mind that battery usage will still be attributed
         * to your application, and surfaced to the user in battery stats.</p>
         * @param requiresDeviceIdle Whether or not the device need be within an idle maintenance
         *                           window.
         */
        // 設定裝置需要在空閒的時候，是否啟動job
        builder.setRequiresDeviceIdle(false);

        /**
         * Specify that to run this job, the device needs to be plugged in. This defaults to
         * false.
         * @param requiresCharging Whether or not the device is plugged in.
         */
        // 設定是否充電情況下排程
        builder.setRequiresCharging(true);
        /**
         * Set whether or not to persist this job across device reboots.
         *
         * @param isPersisted True to indicate that the job will be written to
         *            disk and loaded at boot.
         */
        // 設定是否重啟後繼續排程，注意設定true是需要新增重啟許可權
        builder.setPersisted(false);

        /**
         * 我設定了充電下且網路連線時才觸發onJobStart()的條件
         * 注意：上述的條件是與的關係，不是或
         */
        Log.d(Constant.TAG, "設定充電下且網路連線的條件");
        tv_info.setText("設定充電下且網路連線的條件");
        myJobSchedulerService.schedulejob(builder.build());
    }

結束Job任務指令

結束所有JOB

    /**
     * 殺死在這個包裡註冊的所有的jobinfo
     * @param v
     */
    public void cancelAllJobs(View v) {
        JobScheduler tm = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);

        /**
         * Cancel all jobs that have been registered with the JobScheduler by this package.
         *
         * 備註：這裡會回撥onStopJob();
         */
        tm.cancelAll();

        tv_info.setText("殺死在這個包裡註冊的所有的jobinfo");
    }

結束指定JOB

    public void callJobFinished() {

        if (mJobParametersMap.size() == 0) {
            return ;
        }

        JobParameters params = mJobParametersMap.valueAt(0);
        if (params == null) {
            return; 
        } else {
            /**
             * Call this to inform the JobManager you've finished executing. This can be called from any
             * thread, as it will ultimately be run on your application's main thread. When the system
             * receives this message it will release the wakelock being held.
             * <p>
             *     You can specify post-execution behaviour to the scheduler here with
             *     <code>needsReschedule </code>. This will apply a back-off timer to your job based on
             *     the default, or what was set with
             *     {@link android.app.job.JobInfo.Builder#setBackoffCriteria(long, int)}. The original
             *     requirements are always honoured even for a backed-off job. Note that a job running in
             *     idle mode will not be backed-off. Instead what will happen is the job will be re-added
             *     to the queue and re-executed within a future idle maintenance window.
             * </p>
             *
             * @param params Parameters specifying system-provided info about this job, this was given to
             *               your application in {@link #onStartJob(JobParameters)}.
             * @param needsReschedule True if this job should be rescheduled according to the back-off
             *                        criteria specified at schedule-time. False otherwise.
             */

            /**
             * 告訴JobManager 已經完成了工作，如果第二個引數為false，就是不需要重試這個jobinfo，
             *   第二個引數為true,相當於告訴系統任務失敗，需要重試，而且與要遵守之前的jobinfo.
             *   
             * 備註：這裡不會回撥onStopJob();
            */
            jobFinished(params, false);

            String result = "callJobFinished getJobId = " + params.getJobId();
            Log.d(Constant.TAG, result);
            if (null != mainActivity) {
                mainActivity.onReceivedJobFinished(result);
            }

            mJobParametersMap.removeAt(0);
        }
    }

Job回撥事件

預設定條件滿足事件回撥

    /**
     *  滿足Job預設定條件下回調 
     */
    @Override
    public boolean onStartJob(JobParameters jobParameters) {
        Log.d(Constant.TAG, "當前滿足預設定條件，故觸發 onStartJob: " + jobParameters.getJobId());

        mCurrentId ++;
        mJobParametersMap.put(mCurrentId, jobParameters);

        if (null != mainActivity) {
            mainActivity.onReceivedStartJob(jobParameters);
        }
        return true;
    }

預設定條件不滿足事件回撥

    /**
     * 1.被CancleAll的時候回撥
     * 2.不滿足預設定條件的情況下回調
     */
    @Override
    public boolean onStopJob(JobParameters jobParameters) {
        Log.d(Constant.TAG, "不滿足預設定條件， onStopJob : " + jobParameters.getJobId());

        int id = mJobParametersMap.indexOfValue(jobParameters);
        mJobParametersMap.remove(id);

        if (null != mainActivity) {
            mainActivity.onReceivedStopJob(jobParameters);
        }
        return false;
    }

結語

個人任務Job本質提供合適的省電場景，讓應用執行一些費時且優先順序不是很高的事情，比如備份，資料上傳等等，當然不建議利用這個特性進行保活，即利用該機制完成應用的頻繁啟動，這樣就違背Google的初衷了

Demo下載