“Le basi
Per creare un servizio, devi creare una sottoclasse di Service o utilizzare una delle sue sottoclassi esistenti. Nella tua implementazione, devi sovrascrivere alcuni metodi di callback che gestiscono aspetti chiave del ciclo di vita del servizio e fornire un meccanismo che consenta ai componenti di associarsi al servizio, se appropriato. Questi sono i metodi di callback più importanti che dovresti sovrascrivere:
onStartCommand()
Il sistema richiama questo metodo chiamando startService() quando un altro componente (come un’attività) richiede l’avvio del servizio. Quando questo metodo viene eseguito, il servizio viene avviato e può essere eseguito in background a tempo indeterminato. Se lo implementi, è tua responsabilità interrompere il servizio quando il suo lavoro è completo chiamando stopSelf() o stopService(). Se si desidera fornire solo l’associazione, non è necessario implementare questo metodo.
onBind()
Il sistema richiama questo metodo chiamando bindService() quando un altro componente desidera eseguire il binding con il servizio (ad esempio per eseguire RPC). Nell’implementazione di questo metodo, devi fornire un’interfaccia che i client utilizzano per comunicare con il servizio restituendo un IBinder. Devi sempre implementare questo metodo; tuttavia, se non si desidera consentire l’associazione, è necessario restituire null.
onCreate()
Il sistema richiama questo metodo per eseguire procedure di installazione una tantum quando il servizio viene creato inizialmente (prima di chiamare onStartCommand() o onBind()). Se il servizio è già in esecuzione, questo metodo non viene chiamato.
onDestroy()
Il sistema richiama questo metodo quando il servizio non viene più utilizzato e viene distrutto. Il tuo servizio dovrebbe implementarlo per ripulire tutte le risorse come thread, listener registrati o ricevitori. Questa è l’ultima chiamata ricevuta dal servizio.”
Esempio di servizio in Android :
public class HelloService extends Service {
private Looper serviceLooper;
private ServiceHandler serviceHandler;
// Handler that receives messages from the thread
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// Restore interrupt status.
Thread.currentThread().interrupt();
}
// Stop the service using the startId, so that we don't stop
// the service in the middle of handling another job
stopSelf(msg.arg1);
}
}
@Override
public void onCreate() {
// Start up the thread running the service. Note that we create a
// separate thread because the service normally runs in the process's
// main thread, which we don't want to block. We also make it
// background priority so CPU-intensive work doesn't disrupt our UI.
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
// Get the HandlerThread's Looper and use it for our Handler
serviceLooper = thread.getLooper();
serviceHandler = new ServiceHandler(serviceLooper);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
// For each start request, send a message to start a job and deliver the
// start ID so we know which request we're stopping when we finish the job
Message msg = serviceHandler.obtainMessage();
msg.arg1 = startId;
serviceHandler.sendMessage(msg);
// If we get killed, after returning from here, restart
return START_STICKY;
}
@Override
public IBinder onBind(Intent intent) {
// We don't provide binding, so return null
return null;
}
@Override
public void onDestroy() {
Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
}
}Articolo completo :
https://developer.android.com/guide/components/services#java
