MOBILE APPLICATION DEVELOPMENT LECTURE 10 SERVICES IMRAN IHSAN ASSISTANT PROFESSOR

Transcription

1 MOBILE APPLICATION DEVELOPMENT LECTURE 10 SERVICES IMRAN IHSAN ASSISTANT PROFESSOR Android Component A Service is an application component that runs in the background, not interacting with the user, for an indefinite period of time. Higher priority than inactive Activities, so less likely to be killed o If killed, they can be configured to re-run automatically (when resources available) Each service class must have a corresponding <service> declaration in its package's AndroidManifest.xml 1

2 Android Component can be started with Context.startService(Intent intent) and Context.bindService() Execute in the main thread of the application s process. CPU intensive tasks must be offloaded to background threads using Thread or AsyncTask Alarms can be used to fire Intents at set times. These can start services, open Activities, or broadcast Intents Android Component Started A service is "started" when an application component (such as an activity) starts it by calling startservice(). Once started, a service can run in the background indefinitely, even if the component that started it is destroyed. Usually, a started service performs a single operation and does not return a result to the caller. For example, it might download or upload a file over the network. When the operation is done, the service should stop itself. Bound A service is "bound" when an application component binds to it by calling bindservice(). A bound service offers a client-server interface that allows components to interact with the service, send requests, get results. A bound service runs only as long as another application component is bound to it. Multiple components can bind to the service at once, but when all of them unbind, the service is destroyed. 2

3 Android Component Client components can bind to a Service when they want to interact with it Context.bindService (Intent service, ServiceConnection conn, int flags) Service will be started if necessary Service remains active as long as at least one client is bound to it Lifecycle Android Component A Service has three lifecycle methods 1. void oncreate() 2. void onstartcommand() 3. void ondestroy() 3

4 Creating a Service Android Component onstartcommand Service Events Called whenever the Service is started with startservicecall So beware: may be executed several times in Service s lifetime! Controls how system will respond if Service restarted (START_STICKY) Run from main GUI thread, so standard pattern is to create a new Thread from onstartcommand to perform processing and stop Service when complete 4

5 onstartcommand Service Events START_STICKY is basically the same as the previous behavior, where the service is left "started" and will later be restarted by the system. The only difference from previous versions of the platform is that it if it gets restarted because its process is killed, onstartcommand() will be called on the next instance of the service with a null Intent instead of not being called at all. that use this mode should always check for this case and deal with it appropriately. START_NOT_STICKY says that, after returning from onstartcreated(), if the process is killed with no remaining start commands to deliver, then the service will be stopped instead of restarted. This makes a lot more sense for services that are intended to only run while executing commands sent to them. For example, a service may be started every 15 minutes from an alarm to poll some network state. If it gets killed while doing that work, it would be best to just let it be stopped and get started the next time the alarm fires. START_REDELIVER_INTENT is like START_NOT_STICKY, except if the service's process is killed before it calls stopself() for a given intent, that intent will be redelivered to it until it completes (unless after some number of more tries it still can't complete, at which point the system gives up). This is useful for services that are receiving commands of work to do, and want to make sure they do eventually complete the work for each command sent. Starting a Service Service Events Call startservice() (To use this example, would need to include a ORDER_PIZZA constant in MyServiceclass and use an Intent Filter to register the Service as a provider of ORDER_PIZZA) 5

6 Stopping a Service Service Events Call stopservice() Example Logging service Client Activity sends log messages to service Service writes messages to a log console Music player Client Activity tells service to play a music file plays music in the background (even if Client Activity pauses or terminates) ID service Client Activity requests system-wide unique ID Service returns ID to Client 6

7 Logging Service requests represented as Intents Uses a Service subclass called IntentService IntentService requests handled sequentially in a single worker thread IntentService started and stopped as needed Logging (Cont.) public class BGLoggingDemo extends Activity { public void oncreate(bundle savedinstancestate) { buttonstart.setonclicklistener(new OnClickListener() { public void onclick(view v) { Intent intent = new Intent(BGLoggingDemo.this, BGLoggingService.class); intent.putextra("course.examples..logging", "Log this message"); startservice(intent); ); 7

8 Logging (Cont.) public class BGLoggingService extends IntentService { public int onstartcommand(intent intent, int flags, int startid) { super.onstartcommand(intent, flags, startid); return START_NOT_STICKY; protected void onhandleintent(intent intent) { // create and start new Thread to handle request... Log.i(TAG,arg.getCharSequenceExtra("course.examples..Logging").toString()); Logging (Cont.) <application android:icon="@drawable/icon" android:label="@string/app_name"> <activity android:name=".bgloggingdemo" android:label="@string/app_name"> <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> </activity> <service android:enabled="true" android:name=".bgloggingservice" /> </application> 8

9 Notes on The LoggingService is a simplified example It doesn t need to be implemented as a Service In practice you would simply start a new Thread to do the logging Use when you want to run a component even when a user is not interacting with the Service s hosting application Music Player Service Client Activity can start/stop playing music via a Service If music is playing when client leaves the foreground, music service will continue playing 9

10 Music Player Service (cont.) public class MusicService extends Service { MediaPlayer player; public void oncreate() { player = MediaPlayer.create(this, R.raw.braincandy); player.setlooping(false); public int onstartcommand (Intent intent, int flags, int startid) { player.start(); return START_NOT_STICKY; Music Player Service (cont.) public class MusicServiceDemo extends Activity { public void oncreate(bundle savedinstancestate) { button.setonclicklistener(new OnClickListener() { public void onclick(view src) { startservice( new Intent(MusicServiceDemo.this,MusicService.class)); ); 10

11 Binding Activities to Activity maintains reference to a Service Activity can make calls on the Service just as any other instantiated class To support this, implement onbind for the Service Binding Activities to Service Binding A Service has three lifecycle methods Once Service is bound, all public methods and properties are available through the servicebinderobject obtained from the onserviceconnectedhandler 11

12 Questions? 12