JobInfo.Builder

JobInfo.Builder(int jobId, ComponentName jobService)
Initialize a new Builder to construct a JobInfo.

JobInfo.Builder接收兩個參數(shù)

• jobId ： 要運行的任務(wù)的標(biāo)識符
• jobService ： Service組件的類名。

下面簡要的介紹部分builder中的方法：（截止Android API 25）

• addTriggerContentUri(JobInfo.TriggerContentUri uri)：添加一個TriggerContentUri，該Uri將利用ContentObserver來監(jiān)控一個Content Uri，當(dāng)且僅當(dāng)其發(fā)生變化時將觸發(fā)任務(wù)的執(zhí)行。為了持續(xù)監(jiān)控content的變化，你需要在最近的任務(wù)觸發(fā)后再調(diào)度一個新的任務(wù)（需要注意的是觸發(fā)器URI不能與setPeriodic(long)或setPersisted(boolean)組合使用。要持續(xù)監(jiān)控內(nèi)容更改，需要在完成JobService處理最近的更改之前，調(diào)度新的JobInfo，觀察相同的URI。因為設(shè)置此屬性與定期或持久化Job不兼容，這樣做會在調(diào)用build()時拋出IllegalArgumentException異常。)

• setBackoffCriteria(long initialBackoffMillis, int backoffPolicy)：特殊：設(shè)置回退/重試的策略，詳細(xì)的可以參閱Google API。
  類似網(wǎng)絡(luò)原理中的沖突退避，當(dāng)一個任務(wù)的調(diào)度失敗時需要重試，所采取的策略。第一個參數(shù)時第一次嘗試重試的等待間隔，單位為毫秒，預(yù)設(shè)的參數(shù)有：DEFAULT_INITIAL_BACKOFF_MILLIS 30000 、MAX_BACKOFF_DELAY_MILLIS 18000000。第二個參數(shù)是對應(yīng)的退避策略，預(yù)設(shè)的參數(shù)有：BACKOFF_POLICY_EXPONENTIAL 二進(jìn)制退避。等待間隔呈指數(shù)增長 BACKOFF_POLICY_LINEAR。

• setExtras(PersistableBundle extras)：設(shè)置可選附件。這是持久的，所以只允許原始類型。

• setMinimumLatency(long minLatencyMillis)： 這個函數(shù)能用以設(shè)置任務(wù)的延遲執(zhí)行時間(毫秒），相當(dāng)于post delay。

• setOverrideDeadline(long maxExecutionDelayMillis)： 這個方法讓用以設(shè)置任務(wù)最晚的延遲時間
  。如果到了規(guī)定的時間時其他條件還未滿足，任務(wù)也會被啟動。

• setPeriodic(long time)：設(shè)置任務(wù)運行的周期（每X毫秒，運行一次）。衍生在運行一些權(quán)限檢查的時候如果可以使用job scheduler的話，可以這樣來循環(huán)檢查權(quán)限的開啟，但是目前的觸發(fā)條件沒有權(quán)限部分的觸發(fā)。

• setPeriodic(long intervalMillis, long flexMillis)：設(shè)置在Job周期末的一個flex長度的窗口，任務(wù)都有可能被執(zhí)行 require API LEVEL 24

• setPersisted(boolean isPersisted): 這個方法告訴系統(tǒng)當(dāng)設(shè)備重啟之后任務(wù)是否還要繼續(xù)執(zhí)行。

• setRequiredNetworkType(int networkType)： 這個方法讓這個任務(wù)只有在滿足指定的網(wǎng)絡(luò)條件時才會被執(zhí)行。默認(rèn)條件是JobInfo.NETWORK_TYPE_NONE，這意味著不管是否有網(wǎng)絡(luò)這個任務(wù)都會被執(zhí)行。另外兩個可選類型，一種是JobInfo.NETWORK_TYPE_ANY，它表明需要任意一種網(wǎng)絡(luò)才使得任務(wù)可以執(zhí)行。另一種是JobInfo.NETWORK_TYPE_UNMETERED，它表示設(shè)備不是蜂窩網(wǎng)絡(luò)( 比如在WIFI連接時 )時任務(wù)才會被執(zhí)行。

• setRequiresCharging(boolean requiresCharging): 只有當(dāng)設(shè)備在充電時這個任務(wù)才會被執(zhí)行。這個也并非只是插入充電器，而且還要在電池處于健康狀態(tài)的情況下才會觸發(fā)，一般來說是手機(jī)電量>15%

• setRequiresDeviceIdle(boolean requiresDeviceIdle)：指定Job在空閑狀態(tài)才能運行。設(shè)備處于屏幕關(guān)閉或dreaming狀態(tài)（類似window的休眠動畫狀態(tài)）71分鐘后，執(zhí)行工作

• setTransientExtras(Bundle extras)：設(shè)置可選的臨時附加功能。（Android O Developer Preview）這里指定了需要Android O 系統(tǒng)，可以看出，Google還是在繼續(xù)完善job scheduler的，期待能夠代替?zhèn)鹘y(tǒng)的service組件成為主流。

• setTriggerContentMaxDelay(long durationMs)：設(shè)置從第一次檢測到內(nèi)容更改到Job之前允許的最大總延遲（以毫秒為單位）。說人話就是設(shè)置從content變化到任務(wù)被執(zhí)行，中間的最大延遲。 同樣的require API 24

• setTriggerContentUpdateDelay(long durationMs)：設(shè)置從content變化到任務(wù)被執(zhí)行中間的延遲。如果在延遲期間content發(fā)生了變化，延遲會重新計算

• setExtras(PersistableBundle extra)：Bundle

要注意的是：
1、設(shè)置延遲時間 setMinimumLatency(long minLatencyMillis)和設(shè)置最終期限時間 setOverrideDeadline(long maxExecutionDelayMillis)的兩個方法不能同時與setPeriodic(long time)同時設(shè)置，也就是說，在設(shè)置延遲和最終期限時間時是不能設(shè)置重復(fù)周期時間的。還有在具體開發(fā)過程中需要注意各個方法的API兼容情況。

2、setRequiredNetworkType(int networkType), setRequiresCharging(boolean requireCharging) 和 setRequiresDeviceIdle(boolean requireIdle)這幾個方法可能會使得任務(wù)無法執(zhí)行，除非調(diào)用setOverrideDeadline(long time)設(shè)置了最大延遲時間，使得任務(wù)在為滿足條件的情況下也會被執(zhí)行。

構(gòu)建一個JobInfo對象設(shè)置預(yù)置的條件，然后通過如下所示的代碼將它發(fā)送到的JobScheduler中。

開啟一個JobScheduler任務(wù)：

mJobScheduler.schedule(JobInfo job)

在schedule時，會返回一個int類型的值來標(biāo)記這次任務(wù)是否執(zhí)行成功，如果返回小于0的錯誤碼，這表示該次任務(wù)執(zhí)行失敗，反之則成功(成功會返回該任務(wù)的id，這里可以使用這個id來判斷哪些任務(wù)成功了)。所以在返回值小于0的時候就需要我們手動去處理一些事情了。

if(mJobScheduler.schedule(JobInfo job) < 0){
    // do something when schedule goes wrong
}

最后如果需要停止一個任務(wù)，就通過JobScheduler中，cancel(int jobId)來實現(xiàn)(所以之前在Builer中的指定id又有了重要作用)；如果想取消所有的任務(wù)，可以調(diào)用JobScheduler對象的cancelAll()來實現(xiàn)。

四、Jobscheduler使用

在上邊初略的講解了job scheduler的一些使用方法，下邊通過一個用例來加深一下理解。

創(chuàng)建我們Job依附的Activity:

public class SchedulerAcitvity extends Activity {  

    private static final String TAG = "SchedulerAcitvity";  

    public static final String MESSENGER_INTENT_KEY = TAG + ".MESSENGER_INTENT_KEY";
    public static final String WORK_DURATION_KEY = TAG + ".WORK_DURATION_KEY";
    public static final int MSG_JOB_START = 0;
    public static final int MSG_JOB_STOP = 1;
    public static final int MSG_ONJOB_START = 2;
    public static final int MSG_ONJOB_STOP = 3;

    private int mJobId = 0;// 執(zhí)行的JobId

    ComponentName mServieComponent;// 這就是我們的jobservice組件了
    private IncomingMessageHandler mHandler;// 用于來自服務(wù)的傳入消息的處理程序。
    
    // UI
    private EditText mEt_Delay;// 設(shè)置delay時間
    private EditText mEt_Deadline;// 設(shè)置最長的截止時間
    private EditText mEt_DurationTime;// setPeriodic周期
    private RadioButton mRb_WiFiConnectivity;// 設(shè)置builder中的是否有WiFi連接
    private RadioButton mRb_AnyConnectivity;// 設(shè)置builder中的是否有網(wǎng)絡(luò)即可
    private CheckBox mCb_RequiresCharging;// 設(shè)置builder中的是否需要充電
    private CheckBox mCb_RequiresIdle;// 設(shè)置builder中的是否設(shè)備空閑
    private Button mBtn_StartJob;// 點擊開始任務(wù)的按鈕
    private Button mBtn_StopAllJob;// 點擊結(jié)束所有任務(wù)的按鈕
    
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.durian_main);

        mHandler = new IncomingMessageHandler(this);
        mServieComponent = new ComponentName(this, MyJobService.class);// 獲取到我們自己的jobservice，同時啟動該service

        // 設(shè)置UI
        mEt_Delay = (EditText) findViewById(R.id.delay_time);
        mEt_DurationTime = (EditText) findViewById(R.id.duration_time);
        mEt_Deadline = (EditText) findViewById(R.id.deadline_time);
        mRb_WiFiConnectivity = (RadioButton) findViewById(R.id.checkbox_unmetered);
        mRb_AnyConnectivity = (RadioButton) findViewById(R.id.checkbox_any);
        mCb_RequiresCharging = (CheckBox) findViewById(R.id.checkbox_charging);
        mCb_RequiresIdle = (CheckBox) findViewById(R.id.checkbox_idle);
        mBtn_StartJob = (Button)findViewById(R.id.button_start_job);
        mBtn_StopAllJob = (Button)findViewById(R.id.button_start_job);

        mBtn_StartJob.setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                scheduleJob();
                }  
        }); 

        mBtn_StopAllJob.setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                cancelAllJobs();
                }  
        });
    }
    
    @Override
    protected void onStart() {
        super.onStart();
        // 啟動服務(wù)并提供一種與此類通信的方法。
        Intent startServiceIntent = new Intent(this, MyJobService.class);
        Messenger messengerIncoming = new Messenger(mHandler);
        startServiceIntent.putExtra(MESSENGER_INTENT_KEY, messengerIncoming);
        startService(startServiceIntent);
    }
    
    @Override
    protected void onStop() {
        // 服務(wù)可以是“開始”和/或“綁定”。 在這種情況下，它由此Activity“啟動”
        // 和“綁定”到JobScheduler（也被JobScheduler稱為“Scheduled”）。
        // 對stopService（）的調(diào)用不會阻止處理預(yù)定作業(yè)。
        // 然而，調(diào)用stopService（）失敗將使它一直存活。
        stopService(new Intent(this, MyJobService.class));
        super.onStop();
    }
    
    // 當(dāng)用戶單擊SCHEDULE JOB時執(zhí)行。
    public void scheduleJob() {
        //開始配置JobInfo
        JobInfo.Builder builder = new JobInfo.Builder(mJobId++, mServiceComponent);

        //設(shè)置任務(wù)的延遲執(zhí)行時間(單位是毫秒)
        String delay = mEt_Delay.getText().toString();
        if (!TextUtils.isEmpty(delay)) {
            builder.setMinimumLatency(Long.valueOf(delay) * 1000);
        }
        //設(shè)置任務(wù)最晚的延遲時間。如果到了規(guī)定的時間時其他條件還未滿足，你的任務(wù)也會被啟動。
        String deadline = mEt_Deadline.getText().toString();
        if (!TextUtils.isEmpty(deadline)) {
            builder.setOverrideDeadline(Long.valueOf(deadline) * 1000);
        }
        boolean requiresUnmetered = mRb_WiFiConnectivity.isChecked();
        boolean requiresAnyConnectivity = mRb_AnyConnectivity.isChecked();

        //讓你這個任務(wù)只有在滿足指定的網(wǎng)絡(luò)條件時才會被執(zhí)行
        if (requiresUnmetered) {
            builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED);
        } else if (requiresAnyConnectivity) {
            builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
        }

        //你的任務(wù)只有當(dāng)用戶沒有在使用該設(shè)備且有一段時間沒有使用時才會啟動該任務(wù)。
        builder.setRequiresDeviceIdle(mCb_RequiresIdle.isChecked());
        //告訴你的應(yīng)用，只有當(dāng)設(shè)備在充電時這個任務(wù)才會被執(zhí)行。
        builder.setRequiresCharging(mCb_RequiresCharging.isChecked());

        // Extras, work duration.
        PersistableBundle extras = new PersistableBundle();
        String workDuration = mEt_DurationTime.getText().toString();
        if (TextUtils.isEmpty(workDuration)) {
            workDuration = "1";
        }
        extras.putLong(WORK_DURATION_KEY, Long.valueOf(workDuration) * 1000);

        builder.setExtras(extras);

        // Schedule job
        Log.d(TAG, "Scheduling job");
        JobScheduler mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        // 這里就將開始在service里邊處理我們配置好的job
        mJobScheduler.schedule(builder.build());

        //mJobScheduler.schedule(builder.build())會返回一個int類型的數(shù)據(jù)
        //如果schedule方法失敗了，它會返回一個小于0的錯誤碼。否則它會返回我們在JobInfo.Builder中定義的標(biāo)識id。
    }

    // 當(dāng)用戶點擊取消所有時執(zhí)行
    public void cancelAllJobs() {
        JobScheduler mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        mJobScheduler.cancelAll();
        Toast.makeText(MainActivity.this, R.string.all_jobs_cancelled, Toast.LENGTH_SHORT).show();
    }

    /**
    * {@link Handler}允許您發(fā)送與線程相關(guān)聯(lián)的消息。
    * {@link Messenger}使用此處理程序從{@link MyJobService}進(jìn)行通信。
    * 它也用于使開始和停止視圖在短時間內(nèi)閃爍。
    */
    private static class IncomingMessageHandler extends Handler {

        // 使用弱引用防止內(nèi)存泄露
        private WeakReference<SchedulerAcitvity> mActivity;

        IncomingMessageHandler(SchedulerAcitvity activity) {
            super(/* default looper */);
            this.mActivity = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            SchedulerAcitvity mSchedulerAcitvity = mActivity.get();
            if (mSchedulerAcitvity == null) {
                // 活動不再可用，退出。
                return;
            }
            
            // 獲取到兩個View，用于之后根據(jù)Job運行狀態(tài)顯示不同的運行狀態(tài)（顏色變化）
            View showStartView = mSchedulerAcitvity.findViewById(R.id.onstart_textview);
            View showStopView = mSchedulerAcitvity.findViewById(R.id.onstop_textview);

            Message m;
            switch (msg.what) {
                 // 當(dāng)作業(yè)登錄到應(yīng)用程序時，從服務(wù)接收回調(diào)。 打開指示燈（上方View閃爍）并發(fā)送一條消息，在一秒鐘后將其關(guān)閉。
                 case MSG_JOB_START:
                    // Start received, turn on the indicator and show text.
                    // 開始接收，打開指示燈（上方View閃爍）并顯示文字。
                    showStartView.setBackgroundColor(getColor(R.color.start_received));
                    updateParamsTextView(msg.obj, "started");

                    // Send message to turn it off after a second.
                    // 發(fā)送消息，一秒鐘后關(guān)閉它。
                    m = Message.obtain(this, MSG_ONJOB_START);
                    sendMessageDelayed(m, 1000L);
                    break;

                // 當(dāng)先前執(zhí)行在應(yīng)用程序中的作業(yè)必須停止執(zhí)行時，
                // 從服務(wù)接收回調(diào)。 打開指示燈并發(fā)送一條消息，
                // 在兩秒鐘后將其關(guān)閉。
                case MSG_JOB_STOP:
                    // Stop received, turn on the indicator and show text.
                    // 停止接收，打開指示燈并顯示文本。
                    showStopView.setBackgroundColor(getColor(R.color.stop_received));
                    updateParamsTextView(msg.obj, "stopped");

                    // Send message to turn it off after a second.
                    // 發(fā)送消息，一秒鐘后關(guān)閉它。
                    m = obtainMessage(MSG_ONJOB_STOP);
                    sendMessageDelayed(m, 2000L);
                    break;
                case MSG_ONJOB_START:
                    showStartView.setBackgroundColor(getColor(R.color.none_received));
                    updateParamsTextView(null, "job had started");
                    break;
                case MSG_ONJOB_STOP:
                    showStopView.setBackgroundColor(getColor(R.color.none_received));
                    updateParamsTextView(null, "job had stoped");
                    break;
            }
        } 

        // 更新UI顯示
        // @param jobId jobId
        // @param action 消息
        private void updateParamsTextView(@Nullable Object jobId, String action) {
            TextView paramsTextView = (TextView) mActivity.get().findViewById(R.id.task_params);
            if (jobId == null) {
                paramsTextView.setText("");
                return;
            }
            String jobIdText = String.valueOf(jobId);
            paramsTextView.setText(String.format("Job ID %s %s", jobIdText, action));
        }

        private int getColor(@ColorRes int color) {
            return mActivity.get().getResources().getColor(color);
        }
    }
}  

在activity中我們使用一個按鈕來開啟JobScheduler，同時簡單的配置了相應(yīng)Builder的配置。在點擊button的時候，此項scheduler就開始schedule(我們配置的jobInfo)。那當(dāng)我們的條件匹配我們配置的JobInfo的時候會開始怎樣的處理呢？這里就需要我們在service里邊做作業(yè)了。

滿足配置條件時候啟動任務(wù)的Service：

public class MyJobService extends JobService {

    private static final String TAG = MyJobService.class.getSimpleName();

    private Messenger mActivityMessenger;

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "Service created");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "Service destroyed");
    }

    // 當(dāng)應(yīng)用程序的MainActivity被創(chuàng)建時，它啟動這個服務(wù)。
    // 這是為了使活動和此服務(wù)可以來回通信。 請參見“setUiCallback（）”
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        mActivityMessenger = intent.getParcelableExtra(MESSENGER_INTENT_KEY);
        return START_NOT_STICKY;
    }

    @Override
    public boolean onStartJob(final JobParameters params) {
        // The work that this service "does" is simply wait for a certain duration and finish
        // the job (on another thread).

        // 該服務(wù)做的工作只是等待一定的持續(xù)時間并完成作業(yè)（在另一個線程上）。
        sendMessage(MSG_JOB_START, params.getJobId());
        // 當(dāng)然這里可以處理其他的一些任務(wù)
        // TODO something else
        
        // 獲取在activity里邊設(shè)置的每個任務(wù)的周期，其實可以使用setPeriodic()
        long duration = params.getExtras().getLong(WORK_DURATION_KEY);

        // 使用一個handler處理程序來延遲jobFinished（）的執(zhí)行。
        Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {
                sendMessage(MSG_JOB_STOP, params.getJobId());
                jobFinished(params, false);
            }
        }, duration);
        Log.i(TAG, "on start job: " + params.getJobId());

        // 返回true，很多工作都會執(zhí)行這個地方，我們手動結(jié)束這個任務(wù)
        return true;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        // 停止跟蹤這些作業(yè)參數(shù)，因為我們已經(jīng)完成工作。
        sendMessage(MSG_JOB_STOP, params.getJobId());
        Log.i(TAG, "on stop job: " + params.getJobId());

        // 返回false來銷毀這個工作
        return false;
    }

    private void sendMessage(int messageID, @Nullable Object params) {
        // 如果此服務(wù)由JobScheduler啟動，則沒有回調(diào)Messenger。
        // 它僅在MainActivity在Intent中使用回調(diào)函數(shù)調(diào)用startService()時存在。
        if (mActivityMessenger == null) {
            Log.d(TAG, "Service is bound, not started. There's no callback to send a message to.");
            return;
        }

        Message m = Message.obtain();
        m.what = messageID;
        m.obj = params;
        try {
            mActivityMessenger.send(m);
        } catch (RemoteException e) {
            Log.e(TAG, "Error passing service object back to activity.");
        }
    }
}

雖然在service里邊只是簡單地進(jìn)行了一個我們設(shè)置的耗時操作，但是通過以上的例子應(yīng)該很容易理解JobScheduler的使用了。在某些條件下（充電，網(wǎng)絡(luò)連接【可以指定特定的狀態(tài)】，設(shè)備空閑）JobScheduler可以更優(yōu)秀的完成我們的觸發(fā)型任務(wù)，雖然目前來講匹配的條件很是很少，但使用JobScheduler可以更優(yōu)雅的處理這些觸發(fā)事件，也是值得使用的。同時隨著Android的發(fā)展，我相信JobScheduler的應(yīng)用場景會越來越多。

五、衍生：

似乎都很熱衷于應(yīng)用的?；?，很多地方都是將jobScheduler應(yīng)用于Service殺不死，進(jìn)一步拉應(yīng)用的狀態(tài)
使用JobScheduler進(jìn)行開機(jī)自啟動
Android服務(wù)?；?JobScheduler拉活
Android進(jìn)程?；畹囊话闾茁?/a>

JobScheduler省電：
Android L 的 JobScheduler API 是怎么讓設(shè)備省電的

除了JobScheduler ,還有其他一些類似的APIs去幫助安排你的工作計劃，它們包括：
AlarmManager
Firebase JobDispatcher
GCM NETwork Manager
SyncAdapter
Additional Facilities

坑:

自啟動問題

按照官方文檔的定義，在原生的Android系統(tǒng)上，當(dāng)設(shè)定了一個Job之后，哪怕該App的進(jìn)程已經(jīng)結(jié)束或者被殺掉，對應(yīng)的JobService也是可以啟動的。
然而Android已經(jīng)被國內(nèi)的各大廠商重新定制過，導(dǎo)致的一個問題就是當(dāng)前App的進(jìn)程被殺掉之后，JobService無法啟動。
例如在MIUI系統(tǒng)中，第三方App如果沒有被用戶設(shè)置到允許自啟動的名單中，在啟動Service的時候會被攔截掉。
這恐怕會導(dǎo)致很多第三方應(yīng)用無法使用這個東西，正如之前的AlarmManager一樣。
還有一個比較坑的地方在于，當(dāng)Job正在執(zhí)行時，如果使用類似MIUI上的一鍵清除所有進(jìn)程，JobService會被強(qiáng)制停止，也不會執(zhí)行對應(yīng)的onStopJob方法。

兼容性問題
JobScheduler支持Android 5.0以上的系統(tǒng)，但對于運行Android 5.0以下系統(tǒng)的手機(jī)是否有辦法呢？

Github上有一個開源的項目也許能幫得上忙：項目地址
這個項目在介紹中也宣稱不在進(jìn)行維護(hù)了，所以，僅供參考吧。

其他一些文章

Android省電的秘密之JobScheduler
Android省電的秘密（2）之a(chǎn)db解讀JobScheduler

本文整合部分網(wǎng)上相關(guān)文章，感謝所有文章的作者。