I am seeking an example of something that can be done with an IntentService
that cannot be done with a Service
(and vice-versa)?
I also believe that an IntentService
runs in a different thread and a Service
does not. So, as far as I can see, starting a service within its own thread is like starting an IntentService
. Is that correct?
This question is related to
android
multithreading
android-service
android-intentservice
The Major Difference between a Service
and an IntentService
is described as follows:
Service :
1.A Service
by default, runs on the application's main thread.(here no default worker thread is available).So the user needs to create a separate thread and do the required work in that thread.
2.Allows Multiple requests at a time.(Multi Threading)
IntentService :
1.Now, coming to IntentService
, here a default worker thread is available to perform any operation. Note that - You need to implement onHandleIntent()
method ,which receives the intent for each start request, where you can do the background work.
2.But it allows only one request at a time.
Adding points to the accepted answer:
See the usage of IntentService within Android API. eg:
public class SimpleWakefulService extends IntentService {
public SimpleWakefulService() {
super("SimpleWakefulService");
}
@Override
protected void onHandleIntent(Intent intent) { ...}
To create an IntentService component for your app, define a class that extends IntentService, and within it, define a method that overrides onHandleIntent().
Also, see the source code of the IntentService, it's constructor and life cycle methods like onStartCommand...
@Override
public int More ...onStartCommand(Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
Service together an AsyncTask is one of best approaches for many use cases where the payload is not huge. or just create a class extending IntentSerivce. From Android version 4.0 all network operations should be in background process otherwise the application compile/build fails. separate thread from the UI. The AsyncTask class provides one of the simplest ways to fire off a new task from the UI thread. For more discussion of this topic, see the blog post
from Android developers guide:
IntentService is a base class for Services that handle asynchronous requests (expressed as Intents) on demand. Clients send requests through 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.
Design pattern used in IntentService
: 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 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.
The IntentService class provides a straightforward structure for running an operation on a single background thread. This allows it to handle long-running operations without affecting your user interface's responsiveness. Also, an IntentService isn't affected by most user interface lifecycle events, so it continues to run in circumstances that would shut down an AsyncTask.
An IntentService has a few limitations:
It can't interact directly with your user interface. To put its results in the UI, you have to send them to an Activity. Work requests run sequentially. If an operation is running in an IntentService, and you send it another request, the request waits until the first operation is finished. An operation running on an IntentService can't be interrupted. However, in most cases
IntentService is the preferred way to simple background operations
**
Volley Library
There is the library called volley-library for developing android networking applications The source code is available for the public in GitHub.
The android official documentation for Best practices for Background jobs: helps better understand on intent service, thread, handler, service. and also Performing Network Operations
I'm sure you can find an extensive list of differences by simply googling something such as 'Android IntentService vs Service'
One of the more important differences per example is that IntentService ends itself once it's done.
Some examples (quickly made up) could be;
IntentService: If you want to download a bunch of images at the start of opening your app. It's a one-time process and can clean itself up once everything is downloaded.
Service: A Service which will constantly be used to communicate between your app and back-end with web API calls. Even if it is finished with its current task, you still want it to be around a few minutes later, for more communication.
If someone can show me an example of something that you can be done with an
IntentService
and can not be done with aservice
and the other way around.
IntentService
can not be used for Long Time Listening, Like for XMPP Listeners, its a single time operator, do the job and wave goodbye.
Also it has just one threadworker, but with a trick, you can use it as unlimited.
IntentService extends Service class which clearly means that IntentService
is intentionally made for same purpose.
So what is the purpose ?
`IntentService's purpose is to make our job easier to run background tasks without even worrying about
Creation of worker thread
Queuing the processing multiple-request one by one (Threading
)
Service
So NO, Service
can do any task which an IntentService
would do. If your requirements fall under the above-mentioned criteria, then you don't have to write those logics in the Service
class.
So don't reinvent the wheel because IntentService
is the invented wheel.
The Service runs on the UI thread while an IntentService runs on a separate thread
When you want to perform multiple background tasks one by one which exists beyond the scope of an Activity then the IntentService
is perfect.
IntentService
is made from Service
A normal service runs on the UI Thread(Any Android Component type runs on UI thread by default eg Activity
, BroadcastReceiver
, ContentProvider
and Service
). If you have to do some work that may take a while to complete then you have to create a thread. In the case of multiple requests, you will have to deal with synchronization
.
IntentService
is given some default implementation which does those tasks for you.
According to developer page
IntentService
creates a Worker Thread
IntentService
creates a Work Queue which sends request to onHandleIntent()
method one by one
IntentService
calls stopSelf()
methodonBind()
method which is nullonStartCommand()
which sends Intent
request to WorkQueue and eventually to onHandleIntent()
If someone can show me an example of something that can be done with an
IntentService
and can not be done with aService
and the other way around.
By definition, that is impossible. IntentService
is a subclass of Service
, written in Java. Hence, anything an IntentService
does, a Service
could do, by including the relevant bits of code that IntentService
uses.
Starting a service with its own thread is like starting an IntentService. Is it not?
The three primary features of an IntentService
are:
the background thread
the automatic queuing of Intent
s delivered to onStartCommand()
, so if one Intent
is being processed by onHandleIntent()
on the background thread, other commands queue up waiting their turn
the automatic shutdown of the IntentService
, via a call to stopSelf()
, once the queue is empty
Any and all of that could be implemented by a Service
without extending IntentService
.
IntentService
runs on its own thread.
It will stop itself when it's done. More like fire and forget.
Subsequent calls will be queued. Good for queuing calls.
You can also spin multiple threads within IntentService
if you need to- You can achieve this using ThreadPoolExecutor
.
I say this because many people asked me "why use IntentService
since it doesn't support parallel execution".
IntentService
is just a thread. You can do whatever you need inside it- Even spinning multiple threads. The only caveat is that IntentService
finishes as soon as you spin those multiple threads. It doesn't wait for those threads to come back. You need to take care of this. So I recommend using ThreadPoolExecutor
in those scenarios.
By Default Service
runs on the main thread. You need to spin a worker thread to do your job.
You need to stop service
explicitly.
I used it for a situation when you need to run stuff in the background even when you move away from your app and come back more for a Headless service
.
You can always communicate back to your activity using BroadcastReceivers
if you need to.
Service
startService()
Thread
Main Thread
stopSelf()
or stopService()
IntentService
Handler
or BroadcastReceiver
Intent
Main Thread
Android IntentService vs Service
1.Service
2. IntentService
Refer from Here
An IntentService is an extension of a Service that is made to ease the execution of a task that needs to be executed in background and in a seperated thread.
IntentService starts, create a thread and runs its task in the thread. once done, it cleans everything. Only one instance of a IntentService can run at the same time, several calls are enqueued.
It is very simple to use and very convenient for a lot of uses, for instance downloading stuff. But it has limitations that can make you want to use instead the more basic (not simple) Service.
For example, a service connected to a xmpp server and bound by activities cannot be simply done using an IntentService. You'll end up ignoring or overriding IntentService stuffs.
Source: Stackoverflow.com