IntentServicepublic abstract class IntentService extends Service | IntentService is a base class for {@link Service}s that handle asynchronous
requests (expressed as {@link Intent}s) on demand. Clients send requests
through {@link android.content.Context#startService(Intent)} calls; the
service is started as needed, handles each Intent in turn using a worker
thread, and stops itself when it runs out of work.
This "work queue processor" pattern is commonly used to offload tasks
from an application's main thread. The IntentService class exists to
simplify this pattern and take care of the mechanics. To use it, extend
IntentService and implement {@link #onHandleIntent(Intent)}. IntentService
will receive the Intents, launch a worker thread, and stop the service as
appropriate.
All requests are handled on a single worker thread -- they may take as
long as necessary (and will not block the application's main loop), but
only one request will be processed at a time.
Developer Guides
For a detailed discussion about how to create services, read the
Services developer guide.
|
| Fields Summary |
|---|
| private volatile android.os.Looper | mServiceLooper | | private volatile ServiceHandler | mServiceHandler | | private String | mName | | private boolean | mRedelivery |
| Constructors Summary |
|---|
public IntentService(String name)Creates an IntentService. Invoked by your subclass's constructor.
super();
mName = name;
|
| Methods Summary |
|---|
| public android.os.IBinder | onBind(android.content.Intent intent)Unless you provide binding for your service, you don't need to implement this
method, because the default implementation returns null.
return null;
| | public void | onCreate()
// TODO: It would be nice to have an option to hold a partial wakelock
// during processing, and to have a static startService(Context, Intent)
// method that would launch the service & hand off a wakelock.
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
| | public void | onDestroy()
mServiceLooper.quit();
| | protected abstract void | onHandleIntent(android.content.Intent intent)This method is invoked on the worker thread with a request to process.
Only one Intent is processed at a time, but the processing happens on a
worker thread that runs independently from other application logic.
So, if this code takes a long time, it will hold up other requests to
the same IntentService, but it will not hold up anything else.
When all requests have been handled, the IntentService stops itself,
so you should not call {@link #stopSelf}.
| | public void | onStart(android.content.Intent intent, int startId)
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
| | public int | onStartCommand(android.content.Intent intent, int flags, int startId)You should not override this method for your IntentService. Instead,
override {@link #onHandleIntent}, which the system calls when the IntentService
receives a start request.
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
| | public void | setIntentRedelivery(boolean enabled)Sets intent redelivery preferences. Usually called from the constructor
with your preferred semantics.
If enabled is true,
{@link #onStartCommand(Intent, int, int)} will return
{@link Service#START_REDELIVER_INTENT}, so if this process dies before
{@link #onHandleIntent(Intent)} returns, the process will be restarted
and the intent redelivered. If multiple Intents have been sent, only
the most recent one is guaranteed to be redelivered.
If enabled is false (the default),
{@link #onStartCommand(Intent, int, int)} will return
{@link Service#START_NOT_STICKY}, and if the process dies, the Intent
dies along with it.
mRedelivery = enabled;
|
|
