Android App Development - 08 Services
Download as ODP, PDF•2 likes•709 views
A service is a component that performs long-running operations in the background independently of any activity. There are two types of services: started services, which run indefinitely until stopped, and bound services, which are attached to components and stop when all components detach. Services must be declared in the manifest and have lifecycle methods like onStartCommand(), onBind(), onCreate(), and onDestroy().
Android App Development - 08 Services
- 1. Services
- 2. Services A service is a component of an application without a GUI that performs long running operations in the background. Its life cycle is independent from that of Activity for which a Service survives the closure of all the Activity of the application. All other components can connect to a service and interact. There are 2 types of Service based on its lifecycle: ● Started: when a component invokes startService() the service is initialized and runs in the background indefinitely even if the component that started it is destroyed ● Bound: when a component invokes bindService() the Service is attached to that component. More components can be attached to the Service, and when all the components attached are destroyed the Service is destroyed. Service
- 3. Services This separation is not clear because a component may engage to an existing Started Service and this can survive over the destruction of the component the Service is bound to. A service by default runs on the same process and then on the same Main Thread of Activity, so in otrder to avoid UI blocks, long running operations should be executed in a Background Thread. Pattern: use a Service only if you need to perform any operations not related to user interaction. For user operations use simple AsyncTask and Background Thread. Es. To handle an MP3 player within the application is not necessary to instantiate a service, unless this has to survive beyond the closing of the Activity. Service
- 5. Services ● onStartCommand(): invoked when another component invokes StartService(). The instance of the service is unique, so each new call to StartService () does not create a new instance of the Service, but is rerun the onStartCommand(). It is not necessary to override it if you want to create a Bound Service. ● onBind(): abstract method that must return a IBinder to retrieve the instance of the Service. If you do not want to create a BoundService this method must return null. ● onCreate(): first creation callback method. ● onDestroy(): last lifecycle method used to free resources. Service – LifeCycle Callbacks
- 6. Services Like all main components the service must be declared in the Manifest file. <manifest> <application> <service android:name=".ExampleService" /> </application> </manifest> A Service may contain an IntentFilter to be started with an implicit Intent, but this is not recommended because it may be initiated by other applications unknowingly. Pattern: if you enter an IntentFilter in the declaration of the Service for creating implicit Intent through, add the attribute: android:exported="false" Manifest declaration
- 7. Services A StartedService starts with the call to StartService (). To close a StartedService call StopService() from the outside or Service.stopSelf () internally when the operation is finished. There are 2classes to create a Started Service: ● Service: it is the class that all the Services extend. You need to create a WorkerThread because all the service is performed in the Main Thread and this could block the GUI of any Activity in the foreground on the same process. It can handle multiple simultaneous requests. ● IntentService: specialization of Service that handles each request in a WorkerThread. It is the best choice to handle requests in series. Started Service
- 8. Services public class ExampleService extends Service{ @Override public void onCreate() { super.onCreate(); } @Override public int onStartCommand(Intent intent, int flags, int startId) { return super.onStartCommand(intent, flags, startId); } @Override public IBinder onBind(Intent arg0) { return null; } @Override public void onDestroy() { super.onDestroy(); } } Started Service - Service
- 9. Services The Service.onStartCommand() method must return an integer value. This tells the system how the Service will be managed and destroyed. ● START_NOT_STICKY: Service is not rebuilt unless there are pending Intent-to-manage. ● START_STICKY: Service is always recreated by switching to Service.onStartCommand() as a parameter to a null Intent. ● START_REDELIVER_INTENT: Service is always recreated by switching to Service.onStartCommand() the last Intent received. Started Service - Service
- 10. Services An IntentService does the following: ● It creates a WorkerThread to perform all tasks in series ● It creates a queue of Intent to pass the implementation of the IntentService.onHandleIntent() method ● It destroys itself when the queue is empty ● It provides an implementation of Service.onBind() that returns null by default ● It provides a default implementation of Service.onStartCommand() to manage the queue of requests that then have to be sent to IntentService.onHandleIntent() Started Service - IntentService
- 11. Services public class ExampleService extends IntentService { public ExampleService() { super("ExampleService"); } @Override protected void onHandleIntent(Intent intent) { } } Started Service - IntentService
- 12. Services To communicate outside the feed, or manage the operations to another component running in the same process you can create a Bound Service. A Bound Service is the server part of a client-server interface. Communications between components of different processes (and different applications) are possible using the interprocess communications (IPC) through a special language called Android Interface Definition Language (AIDL). Bound Service
- 13. Services To attach a Service the Service.onBind() method must return a IBinder that provides the communications interface between the Service and the other component. There are 3 ways to bind the service: ● Binder: used in the case where the service is private to the application and is executed on the same process. ● Messenger: used in the case of communication between different processes. In this case a Handler manages the Message be sent to the Service ● AIDL: used in a multiprocess environment and/or multi- application. AIDL decomposes objects into primitive types so that the system can send them in different processes. To use it you need to create a file .aidl which is defined in the interface. Bound Service
- 14. Services ● Create an instance of the Binder in the Service ● Return this instance in the Service.onBind() method ● Retrieve the Service in the client-side using the callback ServiceConnection.onServiceConnected(). public class BoundService extends Service { private final IBinder mBinder = new LocalBinder(); public class LocalBinder extends Binder { BoundService getService() { return BoundService.this; } } @Override public IBinder onBind(Intent intent) { return mBinder; } } Bound Service - Binder
- 15. Services public class BindingActivity extends Activity { BoundService mService; boolean mBound = false; @Override protected void onStart() { super.onStart(); Intent intent = new Intent(this, BoundService.class); bindService(intent, mConnection, Context.BIND_AUTO_CREATE); } @Override protected void onStop() { super.onStop(); if (mBound) unbindService(mConnection); } public void onButtonClick(View v) { if (mBound) mService.doSomething(); } Bound Service - Binder
- 16. Services private ServiceConnection mConnection = new ServiceConnection() { @Override public void onServiceConnected(ComponentName className, IBinder service) { LocalBinder binder = (LocalBinder) service; mService = binder.getService(); mBound = true; } @Override public void onServiceDisconnected(ComponentName arg0) { mBound = false; } }; } Bound Service - Binder
- 17. Services Bound Service - LifeCycle