Ricerca…


Sintassi

  1. <servizio android: name = ". UploadS3IntentService" android: exported = "false" />

Osservazioni

Un IntentService fornisce un modo semplice per scaricare il lavoro su un thread in background. Gestisce tutto ciò che riguarda la ricezione delle richieste, la loro messa in coda, l'arresto di se stesso, ecc. È anche facile da implementare, rendendolo la cosa perfetta da usare quando si eseguono operazioni che richiedono tempo e che non appartengono al thread Main (UI).

Creare un IntentService

Per creare un IntentService, creare una classe che estenda IntentService e al suo interno un metodo che sovrascrive onHandleIntent :

package com.example.myapp;
public class MyIntentService extends IntentService {
    @Override
     protected void onHandleIntent (Intent workIntent) {
         //Do something in the background, based on the contents of workIntent.
     }
}

Servizio di esempio di esempio

Ecco un esempio di IntentService che finge di caricare le immagini in background. Tutto ciò che devi fare per implementare un IntentService è quello di fornire un costruttore che chiama il costruttore super(String) e devi implementare il onHandleIntent(Intent) .

public class ImageLoaderIntentService extends IntentService {

    public static final String IMAGE_URL = "url";

    /**
     * Define a constructor and call the super(String) constructor, in order to name the worker
     * thread - this is important if you want to debug and know the name of the thread upon 
     * which this Service is operating its jobs.
     */
    public ImageLoaderIntentService() {
        super("Example");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        // This is where you do all your logic - this code is executed on a background thread

        String imageUrl = intent.getStringExtra(IMAGE_URL);

        if (!TextUtils.isEmpty(imageUrl)) {
            Drawable image = HttpUtils.loadImage(imageUrl); // HttpUtils is made-up for the example
        }

        // Send your drawable back to the UI now, so that you can use it - there are many ways
        // to achieve this, but they are out of reach for this example
    }
}

Per avviare un IntentService , devi inviare un Intent ad esso. Puoi farlo da Activity , per un esempio. Certo, non sei limitato a questo. Ecco un esempio di come invocare il nuovo Service da una classe di Activity .

Intent serviceIntent = new Intent(this, ImageLoaderIntentService.class); // you can use 'this' as the first parameter if your class is a Context (i.e. an Activity, another Service, etc.), otherwise, supply the context differently
serviceIntent.putExtra(IMAGE_URL, "http://www.example-site.org/some/path/to/an/image");
startService(serviceIntent); // if you are not using 'this' in the first line, you also have to put the call to the Context object before startService(Intent) here

IntentService elabora IntentService i dati dai propri Intent , in modo da poter inviare più Intent senza preoccuparsi che si scontrino tra loro. Solo un Intent alla volta viene elaborato, il resto va in coda. Quando tutti i lavori sono completi, IntentService si spegnerà automaticamente.

Esempio di Basic IntentService

La classe astratta IntentService è una classe base per servizi, che vengono eseguiti in background senza alcuna interfaccia utente. Pertanto, al fine di aggiornare l'interfaccia utente, dobbiamo utilizzare un ricevitore, che può essere un BroadcastReceiver o un ResultReceiver :

  • Un BroadcastReceiver deve essere utilizzato se il servizio deve comunicare con più componenti che desiderano ascoltare la comunicazione.
  • A ResultReceiver : deve essere utilizzato se il servizio deve comunicare solo con l'applicazione padre (ovvero l'applicazione).

All'interno di IntentService , abbiamo un metodo chiave, onHandleIntent() , in cui faremo tutte le azioni, ad esempio preparando notifiche, creando allarmi, ecc.

Se si desidera utilizzare il proprio IntentService , è necessario estenderlo come segue:

public class YourIntentService extends IntentService {
    public YourIntentService () {
        super("YourIntentService ");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        // TODO: Write your own code here.
    }
}    

La chiamata / avvio dell'attività può essere eseguita come segue:

Intent i = new Intent(this, YourIntentService.class);
startService(i);  // For the service.
startActivity(i); // For the activity; ignore this for now.

Simile a qualsiasi attività, è possibile passare informazioni aggiuntive come dati bundle ad esso come segue:

Intent passDataIntent = new Intent(this, YourIntentService.class);
msgIntent.putExtra("foo","bar");
startService(passDataIntent);

Supponiamo ora di aver passato alcuni dati alla classe YourIntentService . Sulla base di questi dati, un'azione può essere eseguita come segue:

public class YourIntentService extends IntentService {
    private String actvityValue="bar";
    String retrivedValue=intent.getStringExtra("foo");

    public YourIntentService () {
        super("YourIntentService ");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        if(retrivedValue.equals(actvityValue)){
            // Send the notification to foo.
        } else {
            // Retrieving data failed.
        }    
    }
}

Il codice sopra mostra anche come gestire i vincoli nel metodo OnHandleIntent() .



Modified text is an extract of the original Stack Overflow Documentation
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow