Android Service. Lecture 19

Transcription

1 Android Service Lecture 19

2 Services Service: A background task used by an app. Example: Google Play Music plays the music using a service Example: Web browser runs a downloader service to retrieve a file Example: Chat app listens for new messages to come in and alerts the user, even if the user is not actively using the chat app Useful for long-running tasks, and/or providing functionality that can be used by other applications Android has two kinds of services: intent services: For shorter jobs; app launches them via intents. standard services: For longer jobs; remains running after app closes. When/if the service is done doing work, it can broadcast this information to any receivers who are listening.

3 Services Services, like other application objects, run in the main thread of their hosting process. This means that, if your service is going to do any CPU intensive (such as MP3 playback) or blocking (such as networking) operations, it should spawn its own thread in which to do that work. Each service class must have a corresponding <service> declaration in its package's AndroidManifest.xml. Services can be started with Context.startService() and Context.bindService().

4 Services Multiple calls to Context.startService() do not nest (though they do result in multiple corresponding calls to the onstart() method of the Service class), so no matter how many times it is started a service will be stopped once Context.stopService() or stopself() is called. A service can be started and allowed to run until someone stops it or it stops itself. Only one stopservice() call is needed to stop the service, no matter how many times startservice() was called.

5 Services A service is started by an app's activity using an intent. Service operation modes: start: The service keeps running until it is manually stopped we'll use this one bind: The service keeps running until no "bound" apps are left Service has similar methods to activities for lifecycle events - oncreate, ondestroy

6

7 Service Life Cycle Like an activity, a service has lifecycle methods that you can implement to monitor changes in its state. But they are fewer than the activity methods only three and they are public, not protected: void oncreate () void onstart (Intent intent) void ondestroy ()

8 Service Life Cycle The entire lifetime of a service happens between the time oncreate() is called and the time ondestroy() returns. Like an activity, a service does its initial setup in oncreate(), and releases all remaining resources in ondestroy(). For example, a music playback service could create the thread where the music will be played in oncreate(), and then stop the thread in ondestroy().

9 Adding a service in Android Studio right-click your project's Java package click New Service Service

10 Service Class Template public class ServiceClassName extends Service { /* this method handles a single incoming request public int onstartcommand(intent intent, int flags, int id) { // unpack any parameters that were passed to us String value1 = intent.getstringextra("key1"); String value2 = intent.getstringextra("key2"); // do the work that the service needs to do... return START_STICKY; // stay running (stay live), always this public IBinder onbind(intent intent) { // if you need to bound service return null; // disable binding

11 AndroidManifest.xml To allow your app to use the service, add the following to your app's AndroidManifest.xml configuration: (Android Studio does this for you if you use the New Service option) The exported attribute signifies whether other apps are also allowed to use the service (true=yes, false=no)

12 AndroidManifest.xml <application...> <service android:name=".serviceclassname" android:enabled="true" android:exported="false" />

13 Starting a Service In your Activity class: Intent intent = new Intent(this, ServiceClassName.class); intent.putextra("key1", "value1"); intent.putextra("key2", "value2"); startservice(intent); // not startactivity! or if the same code is launched from a fragment: Intent intent = new Intent(getActivity(), ServiceClassName.class);...

14 Intent actions Often a service has several "actions" or commands it can perform Example: A chat service can send, receive,... Example: A music player service can play, stop, pause,... Android implements this with set/getaction methods in Intent In your Activity class: Intent intent = new Intent(this, ServiceClassName.class); intent.setaction("some constant string"); intent.putextra("key1", "value1"); startservice(intent); In your Service class: String action = intent.getaction(); if (action == "some constant string ) {... else {...

15 Broadcasting a result When a service has completed a task, it can notify the app by "sending a broadcast" which the app can listen for: As before, set an action in the intent to distinguish different kinds of results public class ServiceClassName extends Service public int onstartcommand(intent tent, int flags, int id) { // do the work that the service needs to do // broadcast that the work is done Intent done = new Intent(); done.setaction("action"); done.putextra("key1", value1);... sendbroadcast(done); return START_STICKY; // stay running

16 Broadcast Receiver Lifecycle A Broadcast Receiver is an application class that listens for Intents that are broadcast, rather than being sent to a single target application/activity. The system delivers a broadcast Intent to all interested broadcast receivers, which handle the Intent sequentially.

17 Broadcast Receiver

18 Registering a Broadcast Receiver You can either dynamically register an instance of this class with Context.registerReceiver() or statically publish an implementation through the <receiver> tag in your AndroidManifest.xml.

19 Listening for Broadcasts Set up your activity to be notified when certain broadcast actions occur. You must pass an intentfilter specifying the action(s)of interest public class ActivityClassName extends protected void oncreate(bundle savedinstancestate) {... IntentFilter filter = new IntentFilter(); filter.addaction("action"); registerreceiver(new ReceiverClassName(), filter); Note: the action need to match the broadcast s action.

20 Broadcast Receiver Lifecycle A broadcast receiver has a single callback method: void onreceive (Context curcontext, Intent broadcastmsg) When a broadcast message arrives for the receiver, Android calls its onreceive() method and passes it the Intent object containing the message The broadcast receiver is considered to be active only while it is executing this method. When onreceive() returns, it is inactive.

21 Receiving a broadcast Your activity can hear broadcasts using a BroadcastReceiver Any extra parameters in the message come from the service's intent Extend BroadcastReceiver with the code to handle the message public class ActivityClassName extends Activity {... private class ReceiverClassName extends BroadcastReceiver public void onreceive(context context, Intent intent) { // handle the received broadcast message...

22 AndroidManifest The manifest of applications using Android Services must include: A <service> entry for each service used in the application. If the application defines a BroadcastReceiver as an independent class, it must include a <receiver> clause identifying the component. In addition an <intent-filter> entry is needed to declare the actual filter the service and the receiver use.

23 <manifest...> <application <activity android:name=".myservicedriver2 > <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> </activity> <service android:name=.myservice2" /> <receiver android:name=.mybroadcastreceiver"> <intent-filter> <action android:name = "maozheng.action.goservice2" /> </intent-filter> </receiver> </application> </manifest>

24 Type of Broadcasts There are two major classes of broadcasts that can be received: Normal broadcasts (sent with Context.sendBroadcast) are completely asynchronous. All receivers of the broadcast are run in an undefined order, often at the same time. Ordered broadcasts (sent with Context.sendOrderedBroadcast) are delivered to one receiver at a time. As each receiver executes in turn, it can propagate a result to the next receiver, or it can completely abort the broadcast so that it won't be passed to other receivers. The order receivers run in can be controlled with the android:priority attribute of the matching intent-filter; receivers with the same priority will be run in an arbitrary order.

25 Summary Assume main activity wants to interact with a service called MyService3. The main activity is responsible for the following tasks: 1. Start the service called MyService3 Intent intentmyservice = new Intent(this, MyService3.class); Service myservice = startservice(intentmyservice); 2. Define corresponding receiver s filter and register local receiver IntentFilter mainfilter = new IntentFilter( maozheng.action.goservice3"); BroadcastReceiver receiver = new MyMainLocalReceiver(); registerreceiver(receiver, mainfilter); 3. Implement local receiver and override its main method public void onreceive(context localcontext, Intent callerintent)

26 Service methods Assume main activity wants to interact with a service called MyService3. The Service uses its onstart method to do the following: 1. Create an Intent with the appropriate broadcast filter (any number of receivers could match it) Intent myfilteredresponse = new Intent( maozheng.action.goservice3"); 2. Prepare the extra data ( myservicedata ) to be sent with the intent to the receiver(s) Object msg = some user data goes here; myfilteredresponse.putextra("myservicedata", msg); 3. Release the intent to all receivers matching the filter sendbroadcast(myfilteredresponse);

27 Cleaning up Assume main activity wants to interact with a service called MyService3. The main activity is responsible for cleanly terminating the service. Do the following 1. Assume intentmyservice is the original Intent used to start the service. Calling the termination of the service is accomplished by the method stopservice(new Intent(intentMyService) ); 2. Use the service s ondestroy method to assure that all of its running threads are terminated and the receiver is unregistered. unregisterreceiver(receiver);

28 Example 1 A very simple service ServiceExample1: The main application starts a service. The service prints lines on the LogCat until the main activity stops the service.

29 ServiceExample1 public class MainActivity extends AppCompatActivity { TextView txtmsg; Button btnstopservice; ComponentName service; Intent intentmyservice; txtmsg = (TextView) findviewbyid(r.id.txtmsg); intentmyservice = new Intent(this, MyService1.class); service = startservice(intentmyservice); btnstopservice = (Button) findviewbyid(r.id.btnstopservice); btnstopservice.setonclicklistener(new View.OnClickListener() { public void onclick(view v) { try { stopservice((intentmyservice)); txtmsg.settext("after stopping Service: \n" + service.getclassname()); catch (Exception e) { Toast.makeText(getApplicationContext(), e.getmessage(), Toast.LENGTH_LONG).show(); protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); Toolbar toolbar = (Toolbar) findviewbyid(r.id.toolbar); setsupportactionbar(toolbar);

30 public class MyService1 extends Service { public MyService1() public IBinder onbind(intent intent) { // TODO: Return the communication channel to the service. //throw new UnsupportedOperationException("Not yet implemented"); return public void oncreate() { super.oncreate(); Log.i( <MyService1-onCreate>", "I am public void onstart(intent intent, int startid) { super.onstart(intent, startid); Log.i ( <MyService1-onStart>", "I did something very public void ondestroy() { super.ondestroy(); Log.i ("<MyService1-onDestroy>", "I am dead-1");

31 <manifest > <application > <activity android:name=".mainactivity" <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> </activity> <service android:name=".myservice1" android:enabled="true" android:exported="true"> </service> </application> </manifest> AndroidManifest.xml

32 LogCat <MyService1-onCreate>: I am alive-1! <MyService1-onStart>: I did something very quickly <MyService1-onDestroy>: I am dead-1

33 Another Example ServiceExample2 The main activity starts the service and registers a receiver. The service is slow, therefore it runs in a parallel thread its time consuming task. When done with a computing cycle, the service adds a message to an intent. The intent is broadcasted using the filter: maozheng.action.goservice3. A BroadcastReceiver (defined inside the main Activity) uses the previous filter and catches the message (displays the contents on the main UI ). At some point the main activity stops the service and finishes executing.

34 Layout <LinearLayout > <EditText android:layout_width="fill_parent" android:layout_height="wrap_content" android:textsize="12sp"> </EditText> <Button android:layout_width="151dp" android:layout_height="wrap_content" android:text="stop Service"> </Button> </LinearLayout>

35 </manifest> AndroidManifest.xml <manifest xmlns:android=" package="com.example.maozheng.serviceexample2"> <application android:allowbackup="true" android:supportsrtl="true" <activity android:name=".mainactivity" <intent-filter> <action android:name="android.intent.action.main" /> <category android:name="android.intent.category.launcher" /> </intent-filter> </activity> <service android:name=".myservice3" android:enabled="true" android:exported="true"></service> </application>

36 MainActivity.java public class MainActivity extends AppCompatActivity { TextView txtmsg; Button btnstopservice; ComponentName service; Intent intentmyservice; BroadcastReceiver receiver;

37 protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); Toolbar toolbar = (Toolbar) findviewbyid(r.id.toolbar); setsupportactionbar(toolbar); txtmsg = (TextView) findviewbyid(r.id.txtmsg); intentmyservice = new Intent(this, MyService3.class); service = startservice(intentmyservice); txtmsg.settext("myservice3 started - (see DDMS Log)"); btnstopservice = (Button) findviewbyid(r.id.btnstopservice); btnstopservice.setonclicklistener(new View.OnClickListener() { public void onclick(view v) { try { stopservice(new Intent(intentMyService)); txtmsg.settext("after stopping Service: \n" + service.getclassname()); catch (Exception e) { e.printstacktrace(); );

38 oncreate // register & define filter for local listener IntentFilter mainfilter = new IntentFilter("maozheng.action.GOSERVICE3"); receiver = new MyMainLocalReceiver(); registerreceiver(receiver, mainfilter);

39 unregister in protected void ondestroy() { super.ondestroy(); try { stopservice(intentmyservice); unregisterreceiver(receiver); catch (Exception e) { Log.e("MAIN3-DESTROY>>>", e.getmessage()); Log.e ("MAIN3-DESTROY>>>", "Adios" ); //ondestroy

40 Local Receiver Class inside the MainActivity // local (embedded) RECEIVER public class MyMainLocalReceiver extends BroadcastReceiver public void onreceive(context localcontext, Intent callerintent) { String servicedata = callerintent.getstringextra("servicedata"); Log.e ("MAIN>>>", servicedata + " -receiving data " + SystemClock.elapsedRealtime() ); String now = "\n" + servicedata + " --- " + new Date().toLocaleString(); txtmsg.append(now); //MyMainLocalReceiver

41 public void onstart(intent intent, int startid) { super.onstart(intent, startid); Log.e("<<MyService3-onStart>>", "I am alive-3!"); // we place the slow work of the service in its own thread // so the caller is not hung up waiting for us Thread triggerservice = new Thread (new Runnable(){ long startingtime = System.currentTimeMillis(); long tics = 0; public void run() { for(int i=0; (i< 120) & isrunning; i++) { //at most 10 minutes try { //fake that you are very busy here tics = System.currentTimeMillis() - startingtime; Intent myfilteredresponse = new Intent("maozheng.action.GOSERVICE3"); String msg = i + " value: " + tics; myfilteredresponse.putextra("servicedata", msg); sendbroadcast(myfilteredresponse); Thread.sleep(1000); //five seconds catch (Exception e){ e.printstacktrace(); //for //run ); triggerservice.start(); //onstart

42 public void ondestroy() { super.ondestroy(); Log.e ("<MyService3-onDestroy>", "I am dead-3"); isrunning = false; //Stop thread //ondestroy

43 Log.e ("MAIN>>>", servicedata + receiving data " + SystemClock.elapsedRealtime () ); E/MAIN>>>: 22 value: receiving data E/MAIN>>>: 23 value: receiving data E/MAIN>>>: 24 value: receiving data E/MAIN>>>: 25 value: receiving data E/MAIN>>>: 26 value: receiving data Screenshots

44 Service Example -- 3 DownLoad App Has an EditText and a Button, you can type things in the EditText area any time. The UI is available always When click the button, the app goes to a website to download a file and show it in the UI Uses an intent to start a background service so as not to disturb the UI FileService is a service After downloading file, send a broadcast The MainActivity has a broadcast receiver, will put the downloaded file content to the UI

45 MainActivity.java public class MainActivity extends AppCompatActivity { EditText protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); downloadededittext = (EditText) findviewbyid(r.id.downloadededittext); // Allows user to track when an intent with the id TRANSACTION_DONE is executed // We can call for an intent to execute something and then tell user when it finishes IntentFilter intentfilter = new IntentFilter(); intentfilter.addaction(fileservice.transaction_done); // Prepare the main thread to receive a broadcast and act on it registerreceiver(downloadreceiver, intentfilter); // oncreate

46 BroadcastReceiver // BroadcastReceiver : Acts when a specific broadcast is made // Is alerted when the IntentService broadcasts TRANSACTION_DONE private BroadcastReceiver downloadreceiver = new BroadcastReceiver() { // Called when the broadcast is public void onreceive(context context, Intent intent) { Log.e("FileService", "Service Received"); showfilecontents(); ;

47 // Will read our local file and put the text in the EditText public void showfilecontents(){ // Will build the String from the local file StringBuilder sb; try { // Opens a stream so we can read from our local file FileInputStream fis = this.openfileinput("myfile"); // Gets an input stream for reading data InputStreamReader isr = new InputStreamReader(fis, "UTF-8"); // Used to read the data in small bytes to minimize system load BufferedReader bufferedreader = new BufferedReader(isr); // Read the data in bytes until nothing is left to read sb = new StringBuilder(); String line; while ((line = bufferedreader.readline())!= null) { sb.append(line).append("\n"); // Put downloaded text into the EditText downloadededittext.settext(sb.tostring()); catch (FileNotFoundException e) { e.printstacktrace(); catch (UnsupportedEncodingException e) { e.printstacktrace(); catch (IOException e) { e.printstacktrace();

48 public void startfileservice(view view) { // Create an intent to run the IntentService in the background Intent intent = new Intent(this, FileService.class); // Pass the URL that the IntentService will download from intent.putextra("url", CS518Spring18/madlib1.txt ); // Start the intent service protected void onstop() { super.onstop(); unregisterreceiver(downloadreceiver);

49 layout <RelativeLayout > <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="download File" android:layout_alignparenttop="true" android:layout_alignparentleft="true" android:layout_alignparentstart="true" android:onclick="startfileservice"/> <EditText android:layout_width="match_parent" android:layout_height="350dp" android:inputtype="textmultiline" android:ems="10" android:layout_alignparentleft="true" android:layout_alignparentstart="true" android:layout_margintop="41dp" /> </RelativeLayout>

50 FileService.java // We use an IntentService to handle long running processes off the UI thread // Any new requests will wait for the 1st to end and it can't be interrupted public class FileService extends IntentService { // Used to identify when the IntentService finishes public static final String TRANSACTION_DONE = protected void onhandleintent(intent intent) { Log.e("FileService", "Service Started"); // Get the URL for the file to download String passedurl = intent.getstringextra("url"); downloadfile(passedurl); Log.e("FileService", "Service Stopped"); // Broadcast an intent back to MainActivity when file is downloaded Intent i = new Intent(TRANSACTION_DONE); FileService.this.sendBroadcast(i);

51 protected void downloadfile(string theurl) { // The name for the file we will save data to String filename = "myfile"; try{ // Create an output stream to write data to a file (private to everyone except our app) FileOutputStream outputstream = openfileoutput(filename, Context.MODE_PRIVATE); // Get File URL fileurl = new URL(theURL); // Create a connection we can use to read data from a url HttpURLConnection urlconnection = (HttpURLConnection) fileurl.openconnection(); // We are using the GET method urlconnection.setrequestmethod("get"); // Set that we want to allow output for this connection urlconnection.setdooutput(true); // Connect to the url urlconnection.connect(); // Gets an input stream for reading data InputStream inputstream = urlconnection.getinputstream(); // Define the size of the buffer byte[] buffer = new byte[1024]; int bufferlength = 0; // read reads a byte of data from the stream until there is nothing more while ( (bufferlength = inputstream.read(buffer)) > 0 ){ // Write the data received to our file outputstream.write(buffer, 0, bufferlength); // Close our connection to our file outputstream.close(); catch (FileNotFoundException e) { e.printstacktrace(); catch (IOException e) { e.printstacktrace();

52 Services and threading By default, a service lives in the same process and thread as the app that created it. This is not ideal for long-running tasks. If the service is busy, the app's UI will freeze up. To make the service and app more independent and responsive, the service should handle tasks in threads.

53 Android thread helper classes job (or message) queue: Common pattern in Android services. New jobs come in to the service via the app's intents. Jobs are "queued up in some kind of structure to be processed. The thread(s) process jobs in the order they came in. As jobs finish, results are broadcast back to the app

54 Android thread helper classes Android provides several classes to help implement multi-threaded job/message queues: Looper, Handler, HandlerThread, AsyncTask, Loader, CursorLoader,... advantages: easier to submit/finish jobs; easier synchronization; able to be canceled; support for thread pooling; better handling of Android lifecycle issues;...

55 HandlerThread HandlerThread : just a thread that has some internal data representing a queue of jobs to perform. Looper : Lives inside a handler thread and performs a long-running while loop that waits for jobs and processes them You can give new jobs to the handler thread to process via its looper HandlerThread hthread = new HandlerThread("name"); hthread.start(); Looper looper = hthread.getlooper();...

56 Handler Handler : Represents a single piece of code to handle one job in the job queue. When you construct a handler, pass the Looper of the handler thread in which the job should be executed. Submit a job to the handler by calling its post method, passing a Runnable object indicating the code to run Handler handler = new Handler(looper); handler.post(new Runnable() { public void run() { // the code to process the job... );

57 IntentService Android provides a class called IntentService (subclass of Service) that runs all of its tasks in a single extra thread. Great for a queue of long-running tasks to do one-ata-time Instead of overriding onstartcommand, use onhandleintent Creating an IntentService public class Name extends IntentService protected void onhandleintent(intent intent) {