Utilizzo dell'API di JobScheduler su Android Lollipop

In questo tutorial imparerai come usare il JobScheduler API disponibile in Android Lollipop. Il JobScheduler L'API consente agli sviluppatori di creare lavori che vengono eseguiti in background quando vengono soddisfatte determinate condizioni.

introduzione

Quando si lavora con Android, ci saranno occasioni in cui si vorrà eseguire un'attività in un momento successivo o in determinate condizioni, ad esempio quando un dispositivo viene collegato a una fonte di alimentazione o connesso a una rete Wi-Fi. Fortunatamente con l'API 21, conosciuta dalla maggior parte delle persone come Android Lollipop, Google ha fornito un nuovo componente noto come JobScheduler API per gestire questo stesso scenario.

Il JobScheduler L'API esegue un'operazione per l'applicazione quando viene soddisfatta una serie di condizioni predefinite. non mi piace il AlarmManager classe, i tempi non sono esatti. Inoltre, il JobScheduler API è in grado di raggruppare vari lavori da eseguire insieme. Ciò consente alla tua app di eseguire l'attività assegnata pur rispettando la batteria del dispositivo al costo del controllo dei tempi.

In questo articolo, imparerai di più su JobScheduler API e il JobService class usandoli per eseguire una semplice attività in background in un'applicazione Android. Il codice per questo tutorial è disponibile su GitHub.

1. Creazione del servizio di lavoro

Per iniziare, vorrai creare un nuovo progetto Android con un'API minima di 21, perché il JobScheduler L'API è stata aggiunta nella versione più recente di Android e, al momento della scrittura, non è retrocompatibile tramite una libreria di supporto.

Supponendo che tu stia utilizzando Android Studio, dopo aver premuto il pulsante finito per il nuovo progetto, dovresti avere un'applicazione "Hello World" essenziale. Il primo passo che farai con questo progetto è creare una nuova classe Java. Per mantenere le cose semplici, chiamiamolo JobSchedulerService ed estendere il JobService classe, che richiede la creazione di due metodi onStartJob (parametri di JobParameters) e onStopJob (parametri di JobParameters).

public class JobSchedulerService estende JobService @Override public boolean onStartJob (Param parametri JobParameters) return false;  @Override public booleano onStopJob (Param parametri JobParameters) return false; 

onStartJob (parametri di JobParameters) è il metodo che è necessario utilizzare quando si inizia l'attività, poiché è ciò che il sistema utilizza per attivare i processi che sono già stati pianificati. Come puoi vedere, il metodo restituisce un valore booleano. Se il valore di ritorno è falso, il sistema presuppone che qualsiasi attività sia stata eseguita non ha richiesto molto tempo e viene eseguita al momento della restituzione del metodo. Se il valore di ritorno è vero, quindi il sistema presume che l'attività richiederà un po 'di tempo e l'onere ricade su di te, lo sviluppatore, per dire al sistema quando l'attività data è completa chiamando jobFinished (parametri di JobParameters, esigenze booleane programmate).

onStopJob (parametri di JobParameters) viene utilizzato dal sistema per annullare le attività in sospeso quando viene ricevuta una richiesta di annullamento. È importante notare che se onStartJob (parametri di JobParameters) ritorna falso, il sistema presuppone che non ci siano lavori attualmente in esecuzione quando viene ricevuta una richiesta di annullamento. In altre parole, semplicemente non chiamerà onStopJob (parametri di JobParameters).

Una cosa da notare è che il servizio di lavoro viene eseguito sul thread principale dell'applicazione. Questo significa che tu dovere utilizzare un altro thread, un gestore o un'attività asincrona per eseguire attività più lunghe per non bloccare il thread principale. Poiché le tecniche di multithreading vanno oltre lo scopo di questo tutorial, manteniamolo semplice e implementiamo un gestore per eseguire il nostro task nel JobSchedulerService classe.

private Handler mJobHandler = new Handler (new Handler.Callback () @ Override public boolean handleMessage (Message msg) Toast.makeText (getApplicationContext (), "JobService task in esecuzione", Toast.LENGTH_SHORT) .show (); jobFinished (( JobParameters) msg.obj, false); return true;);

Nel gestore, si implementa il handleMessage (messaggio msg) metodo di cui fa parte handler istanza e farlo funzionare la logica del tuo compito. In questo caso, manteniamo le cose molto semplici e pubblichiamo un Crostini messaggio dall'applicazione, anche se è qui che si inserisce la logica per cose come la sincronizzazione dei dati.

Quando l'attività è terminata, è necessario chiamare jobFinished (parametri di JobParameters, esigenze booleane programmate) per far sapere al sistema che hai finito con quel compito e che può iniziare l'operazione successiva. Se non lo fai, i tuoi lavori verranno eseguiti una sola volta e alla tua applicazione non sarà permesso di eseguire altri lavori.

I due parametri che jobFinished (parametri di JobParameters, esigenze booleane programmate) prende sono il JobParameters che sono stati passati al JobService classe nel onStartJob (parametri di JobParameters) metodo e un valore booleano che consente al sistema di sapere se è necessario riprogrammare il lavoro in base ai requisiti originali del lavoro. Questo valore booleano è utile per capire perché è il modo in cui gestisci le situazioni in cui l'attività non è in grado di completare a causa di altri problemi, come una chiamata di rete fallita.

Con il handler istanza creata, puoi andare avanti e iniziare a implementare il onStartJob (parametri di JobParameters) e onStopJob (parametri di JobParameters) metodi per controllare i tuoi compiti. Noterai che nel seguente frammento di codice, il onStartJob (parametri di JobParameters) metodo restituisce vero. Questo perché stai per usare a handler istanza per controllare l'operazione, il che significa che potrebbe richiedere più tempo per terminare rispetto al onStartJob (parametri di JobParameters) metodo. Tornando vero, stai facendo sapere all'applicazione che chiamerai manualmente il jobFinished (parametri di JobParameters, esigenze booleane programmate) metodo. Noterai anche che il numero 1 viene passato al handler esempio. Questo è l'identificatore che userete per riferire il lavoro.

@Override public booleano onStartJob (parametri di JobParameters) mJobHandler.sendMessage (Message.obtain (mJobHandler, 1, params)); ritorna vero;  @Override public boolean onStopJob (Param parametri JobParameters) mJobHandler.removeMessages (1); restituisce falso; 

Una volta che hai finito con la parte Java del JobSchedulerServiceclasse, devi entrare AndroidManifest.xml e aggiungere un nodo per il servizio in modo che l'applicazione disponga dell'autorizzazione per associare e utilizzare questa classe come JobService.

2. Creazione del Job Scheduler

Con JobSchedulerServiceFinita la lezione, possiamo iniziare a vedere come la vostra applicazione interagirà con JobScheduler API. La prima cosa che devi fare è creare un JobScheduler oggetto, chiamato mJobScheduler nel codice di esempio e inizializzarlo ottenendo un'istanza del servizio di sistema JOB_SCHEDULER_SERVICE. Nell'applicazione di esempio, questo è fatto nel Attività principaleclasse.

mJobScheduler = (JobScheduler) getSystemService (Context.JOB_SCHEDULER_SERVICE);

Quando si desidera creare l'attività pianificata, è possibile utilizzare il JobInfo.Builder costruire a JobInfo oggetto che viene passato al tuo servizio. Per creare un JobInfo oggetto, JobInfo.Builder accetta due parametri. Il primo è l'identificativo del lavoro che verrà eseguito e il secondo è il nome del componente del servizio che verrà utilizzato con JobScheduler API.

JobInfo.Builder builder = new JobInfo.Builder (1, new ComponentName (getPackageName (), JobSchedulerService.class.getName ()));

Questo builder ti consente di impostare molte opzioni diverse per il controllo quando il tuo lavoro verrà eseguito. Il seguente frammento di codice mostra come è possibile impostare l'attività in modo che venga eseguita periodicamente ogni tre secondi.

builder.setPeriodic (3000);

Altri metodi includono:

• setMinimumLatency (long minLatencyMillis): Questo fa sì che il tuo lavoro non venga avviato fino a quando non è trascorso il numero di millisecondi specificato. Questo è incompatibile con setPeriodic (molto tempo) e volontà causare un'eccezione se vengono utilizzati entrambi.
• setOverrideDeadline (long maxExecutionDelayMillis): Questo stabilirà una scadenza per il tuo lavoro. Anche se non vengono soddisfatti altri requisiti, l'attività verrà avviata all'incirca al termine del periodo indicato. Piace setMinimumLatency (molto tempo), questa funzione si escludono a vicenda setPeriodic (molto tempo) e volontà causare un'eccezione se vengono utilizzati entrambi.
  
• setPersisted (boolean isPersisted): Questa funzione indica al sistema se l'attività deve continuare ad esistere dopo il riavvio del dispositivo.
  
• setRequiredNetworkType (int networkType): Questa funzione indica al tuo lavoro che può essere avviata solo se il dispositivo si trova su un tipo specifico di rete. L'impostazione predefinita è JobInfo.NETWORK_TYPE_NONE, il che significa che l'attività può essere eseguita indipendentemente dalla presenza o meno di connettività di rete. Gli altri due tipi disponibili sono JobInfo.NETWORK_TYPE_ANY, che richiede un certo tipo di connessione di rete disponibile per il lavoro da eseguire, e JobInfo.NETWORK_TYPE_UNMETERED, che richiede che il dispositivo si trovi su una rete non cellulare.
  
• setRequiresCharging (booleano richiedeCaricare): L'uso di questa funzione dirà all'applicazione che il lavoro non dovrebbe iniziare fino a quando il dispositivo non ha iniziato a caricarsi.
  
• setRequiresDeviceIdle (boolean requiresDeviceIdle): Questo indica al tuo lavoro di non avviarsi a meno che l'utente non stia usando il loro dispositivo e non lo abbia usato per un po 'di tempo.

È importante notare questo setRequiredNetworkType (int networkType), setRequiresCharging (booleano requireCharging) e setRequiresDeviceIdle (boolean requireIdle) potrebbe far sì che il tuo lavoro non inizi mai a meno che setOverrideDeadline (molto tempo) è anche impostato, permettendo al tuo lavoro di funzionare anche se le condizioni non sono soddisfatte. Una volta dichiarate le condizioni preferite, puoi costruire il JobInfo oggetto e inviarlo al tuo JobScheduler oggetto come mostrato di seguito.

if (mJobScheduler.schedule (builder.build ()) <= 0 )  //If something goes wrong 

Noterai che il programma operazione restituisce un intero. Se programma fallisce, restituirà un valore pari a zero o inferiore, corrispondente a un codice di errore. Altrimenti restituirà l'identificativo del lavoro che abbiamo definito nel JobInfo.Builder.

Se la tua applicazione richiede di interrompere uno specifico o tutti i lavori, puoi farlo chiamando cancel (int jobId) o cancella tutto() sul JobScheduler oggetto.

mJobScheduler.cancelAll ();

Ora dovresti essere in grado di usare il JobScheduler API con le proprie applicazioni per lavori batch ed eseguire operazioni in background.

Conclusione

In questo articolo, hai imparato come implementare un JobService sottoclasse che utilizza a handler oggetto per eseguire attività in background per l'applicazione. Hai anche imparato a usare il JobInfo.Builder per impostare i requisiti per l'esecuzione del servizio. Usando questi, dovresti essere in grado di migliorare il funzionamento delle tue applicazioni mentre sei attento al consumo di energia.