Mobile Programming Practice Background processing AsynTask Service Broadcast receiver Lab #5

Size: px

Start display at page:

Download "Mobile Programming Practice Background processing AsynTask Service Broadcast receiver Lab #5"

Julianna Price
5 years ago
Views:

1 1 Mobile Programming Practice Background processing AsynTask Service Broadcast receiver Lab #5 Prof. Hwansoo Han T.A. Sung-in Hong T.A. Minseop Jeong

2 2 Background processing Every Android app has a main thread handling UI, coordinating user interactions, and receiving lifecycle events. If there is too much work happening on this thread, the app appears to hang or slow down, leading to an undesirable user experience. Any long-running computations and operations such as decoding a bitmap, accessing the disk, or performing network requests should be done on a separate background thread. In general, anything that takes more than a few milliseconds should be delegated to a background thread. Some of these tasks may be required to be performed while the user is actively interacting with the app.

3 3 AsyncTask This class allows to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers Should ideally be used for short operations (a few seconds) If you need to keep threads running for long periods of time, it is highly recommended you use Executor, ThreadPoolExecutor, and FutureTask provided by java.util.concurrent

4 4 AsyncTask A task can be cancelled at any time by invoking cancel(boolean) Does not be cancelled when an activity is destroyed Executed AsyncTask is an object Cannot be reuse Executed only once Only one AsyncTask can be run at a time

5 AsyncTask workflow https://academy.realm.

5 5 AsyncTask workflow

6 6 The 4 steps onpreexecute() invoked on the UI thread before the task is executed This step is normally used to setup the task, for instance by showing a progress bar in the user interface doinbackground(params...) invoked on the background thread immediately after onpreexecute() finishes executing This step is used to perform background computation that can take a long time. The parameters of the asynchronous task are passed to this step

7 7 The 4 steps onprogressupdate(progress...) invoked on the UI thread after a call to publishprogress(progress...) The timing of the execution is undefined This method is used to display any form of progress in the user interface while the background computation is still executing onpostexecute(result) invoked on the UI thread after the background computation finishes The result of the background computation is passed to this step as a parameter

8 8 AsyncTask s generic types Params the type of the parameters sent to the task upon execution Progress the type of the progress units published during the background computation Result the type of the result of the background computation

9 9 Usage AsyncTask<Params, Progress, Result> private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> { protected Long doinbackground(url... urls) { int count = urls.length; long totalsize = 0; for (int i = 0; i < count; i++) { totalsize += Downloader.downloadFile(urls[i]); publishprogress((int) ((i / (float) count) * 100)); // Escape early if cancel() is called if (iscancelled()) break; return totalsize; protected void onprogressupdate(integer... progress) { setprogresspercent(progress[0]); protected void onpostexecute(long result) { showdialog("downloaded " + result + " bytes");

10 10 Example of AsyncTask import android.os.asynctask; import android.os.bundle; import android.support.v7.app.appcompatactivity; import android.widget.textview; import android.widget.toast; import java.lang.ref.weakreference; public class MainActivity extends AppCompatActivity protected void oncreate(bundle savedinstancestate) { super.oncreate(savedinstancestate); setcontentview(r.layout.activity_main); AsyncTask<Integer,Double,String> cnttask = new CntTask(this); cnttask.execute(10); private static class CntTask extends AsyncTask<Integer,Double,String> { private final WeakReference<MainActivity> weakactivity; private CntTask(MainActivity mcontext) { this.weakactivity = new protected void onpreexecute() { super.onpreexecute(); Toast.makeText(weakActivity.get(), "Start AsyncTask", Toast.LENGTH_SHORT).show();

11 11 Example of AsyncTask(cont protected String doinbackground(integer... params) { for (int i=1; i<=params[0]; i++) { try { Thread.sleep(1000); publishprogress((double) (i)); // Escape early if cancel() is called if(iscancelled()) break; catch(interruptedexception e){ e.printstacktrace(); return protected void onprogressupdate(double... values) { super.onprogressupdate(values); TextView tv = weakactivity.get().findviewbyid(r.id.cnt); protected void onpostexecute(string s) { super.onpostexecute(s); Toast.makeText(weakActivity.get(),"End AsyncTask", Toast.LENGTH_SHORT).show();

12 12 Service An application component that can perform longrunning operations in the background, and it doesn't provide a user interface. Another application component can start a service, and it continues to run in the background even if the user switches to another application. Additionally, a component can bind to a service to interact with it and even perform inter-process communication (IPC). For example, a service can handle network transactions, play music, perform file I/O, or interact with a content provider, all from the background.

13 13 Three types of services Foreground performs some operation that is noticeable to the user. For example, an audio app would use a foreground service to play an audio track. must display a Notification. continues running even when the user isn't interacting with the app. Background performs an operation that isn't directly noticed by the user. For example, if an app used a service to compact its storage, that would usually be a background service.

14 14 Three types of services 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, receive results, and even do so across processes with inter-process communication (IPC). 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.

15 15 Choosing between a service and a thread A service is simply a component that can run in the background, even when the user is not interacting with your application, so you should create a service only if that is what you need If you must perform work outside of your main thread, but only while the user is interacting with your application, you should instead create a new thread Remember that if you do use a service, it still runs in your application's main thread by default, so you should still create a new thread within the service if it performs intensive or blocking operations.

16 Service workflow * 16

17 17 Service classes Service Base class for all services Use application s main thread by default IntentService Subclass of service Create a worker thread to handle all of the start request, one at a time

18 18 Callback methods of service onstartcommand() The system invokes this method by calling startservice() when another component (such as an activity) requests that the service be started When this method executes, the service is started and can run in the background indefinitely If you implement this, it is your responsibility to stop the service when its work is complete by calling stopself() or stopservice() If you only want to provide binding, you don't need to implement this method. onbind() The system invokes this method by calling bindservice() when another component wants to bind with the service (such as to perform RPC) In your implementation of this method, you must provide an interface that clients use to communicate with the service by returning an IBinder You must always implement this method; however, if you don't want to allow binding, you should return null

19 19 Callback methods of service oncreate() The system invokes this method to perform one-time setup procedures when the service is initially created (before it calls either onstartcommand() or onbind() ) If the service is already running, this method is not called. ondestroy() The system invokes this method when the service is no longer used and is being destroyed Your service should implement this to clean up any resources such as threads, registered listeners, or receivers This is the last call that the service receives.

20 20 Declaring a service in the manifest You must declare all services in your application's manifest file, just as you do for activities and other components To declare your service, add a <service> element as a child of the <application> element <manifest... >... <application... > <service android:name=".exampleservice" />... </application> </manifest>

21 21 Example of IntentService public class HelloIntentService extends IntentService { /** A constructor is required, and must call the super * constructor with a name for the worker thread. */ public HelloIntentService() { super("hellointentservice"); /** The IntentService calls this method from the default worker thread with * the intent that started the service. When this method returns, IntentService * stops the service, as protected void onhandleintent(intent intent) { // Normally we would do some work here, like download a file. // For our sample, we just sleep for 5 seconds. try { Thread.sleep(5000); catch (InterruptedException e) { // Restore interrupt status. Thread.currentThread().interrupt();

22 22 Example of service public class HelloService extends Service { private Looper servicelooper; private ServiceHandler servicehandler; private final class ServiceHandler extends Handler { public ServiceHandler(Looper looper) { public void handlemessage(message msg) { try { Thread.sleep(5000); catch (InterruptedException e) { Thread.currentThread().interrupt(); public void oncreate() { HandlerThread thread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND); thread.start();

23 23 Example of service (cont d) // Get the HandlerThread's Looper and use it for our Handler servicelooper = thread.getlooper(); servicehandler = new public int onstartcommand(intent intent, int flags, int startid) { Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show(); Message msg = servicehandler.obtainmessage(); msg.arg1 = startid; servicehandler.sendmessage(msg); return public IBinder onbind(intent intent) { // We don't provide binding, so return null return public void ondestroy() { Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();

24 Broadcast receivers simply respond to broadcast messages from other applications or from the system itself These messages are sometime called events or intents * 24

25 25 Creating the broadcast receiver A broadcast receiver is implemented as a subclass of BroadcastReceiver class and overriding the onreceive() method where each message is received as a Intent object parameter public class MyReceiver extends BroadcastReceiver public void onreceive(context context, Intent intent) { Toast.makeText(context, "Intent Detected.", Toast.LENGTH_LONG).show();

26 26 Registering broadcast receiver An application listens for specific broadcast intents by registering a broadcast receiver in AndroidManifest.xml file <application android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/apptheme" > <receiver android:name="myreceiver"> <intent-filter> <action android:name="android.intent.action.boot_completed"> </action> </intent-filter> </receiver> </application>

27 27 Sending and receiving a broadcast message To broadcast public void broadcastintent(view view){ Intent intent = new Intent(); intent.setaction( ACTION"); sendbroadcast(intent); To receive public class MyReceiver extends public void onreceive(context context, Intent intent) { Toast.makeText(context, "Intent Detected.", Toast.LENGTH_LONG).show();

28 28 Summary Background processing AsyncTask Service Broadcast receiver

29 29 Lab #5 Implement an example of AsyncTask Please upload zipped project Make a brainstorming with your team for the proposal

30 30 APPENDIX A Methods of AsyncTask

31 31 Methods of AsyncTask Public methods AsyncTask#public-methods Protected methods AsyncTask#protected-methods

32 32 APPENDIX B Event Constants of Intent

33 33 Event constant android.intent.action.battery_changed Sticky broadcast containing the charging state, level, and other information about the battery. android.intent.action.battery_low Indicates low battery condition on the device. android.intent.action.battery_okay Indicates the battery is now okay after being low. android.intent.action.boot_completed This is broadcast once, after the system has finished booting. android.intent.action.bug_report Show activity for reporting a bug. android.intent.action.call Perform a call to someone specified by the data. android.intent.action.call_button The user pressed the "call" button to go to the dialer or other appropriate UI for placing a call. android.intent.action.date_changed The date has changed. android.intent.action.reboot Have the device reboot.

34 34 APPENDIX C Choosing the right background solution for your work

35 35 Selection guide for background processing guide/background

Software Practice 3 Today s lecture Today s Task

1 Software Practice 3 Today s lecture Today s Task Prof. Hwansoo Han T.A. Jeonghwan Park 43 2 MULTITHREAD IN ANDROID 3 Activity and Service before midterm after midterm 4 Java Thread Thread is an execution