CHAPTER 6 Threads, Handlers, and Programmatic Movement

Chapter objectives: Understand the benefits of multithreading on Android Understand multi-threading fundamentals. Know the Thread class and the Runnable interface Understand an AsyncTask Learn to implement canvas movement using surface views Learn to communicate between threads.

6.1 Multithreading and Multi-core Processing Android uses processes and thread management models to manage running applications, services, and the other elements of the system When an application does several things at once it is called multithreading Other terms are used for multithreading, such as parallelism and concurrency A multithreaded Android application contains two or more threads

Multithreading enables programmers to write very efficient applications because it allows the utilization idle time that may accrue while other segments of code are being processed Each thread runs as a separate path of execution that is managed by its own stack, the call stack The call stack is used to manage method calling, parameter passing, and storage for a called method’s local variables

Multitasking can be subdivided into two categories: process-based multitasking and thread-based multitasking Process-based multitasking is the feature that allows a device to execute two or more programs concurrently. In process-based multitasking, an app is the smallest unit of code that can be dispatched by the scheduler.

In a thread-based multitasking environment, the thread is the smallest unit of dispatchable code This means that a single program can perform two or more tasks at once This single thread is responsible for handling all the UI events Even a simple single-threaded application can benefit from parallel processing on different cores

Categories of operations that can be carried out on separate background threads are as follows: Heavy calculations An Object’s long initialization Networking Database operations

6.2 Main Thread and Background Thread Android UI threads are distinct from background threads When an activity is created, it runs by default in the UI thread of the application All the commands issued by the Android operating system, such as onClick, onCreate, etc., are sent to and processed by this UI thread.

When a substantial amount of processing is performed on the UI thread, the application may be too busy to respond to messages sent by the Android operating system If an application frequently computes an elaborate game move on the UI thread, the I/O operations of the system, such as processing incoming user input events, may perform sluggishly or can be blocked.

When writing multithreaded applications in Android, it is a good idea to keep several things in mind about the UI thread: The UI thread should not perform tasks that take longer than a few seconds The user interface cannot be updated from a background thread. An Android application can be entered from an Activity, Service or a Broadcast Receiver, all of which run on the UI thread.

6.3 Thread Approaches From the main UI thread, programmers can create other threads This is done by instantiating an object of type Thread The Thread class encapsulates an object that is runnable. There are two ways in which a runnable object can be created: 1) Implement the Runnable interface 2) Extend the Thread class

The Runnable interface abstracts a unit of executable code You can construct a thread on any object that implements the Runnable interface Runnable defines only one method called run(). An application that creates an instance of Thread must provide the code that will run in that thread

A Thread class can also be constructed that implements the Runnable interface The Thread class itself implements Runnable, through its run() method

6.4 UI Modification and the Handler Class A Handler is part of the Android system’s framework for managing threads and is designed for inter-thread communication It combines features from a BlockingQueue and a message listener. Interaction between an Android thread and the UI thread is accomplished using a UI thread Handler object and posting Messages and Runnable objects to a message queue A Handler object created on the UI thread exposes a thread-safe message queue on which background threads can asynchronously add either messages or requests for foreground runnables to act on their behalf

When a Handler is created for a new thread, it is bound to the message queue of the thread in which it is created The Handler will deliver messages and runnables to this message queue and execute them as they are retrieved off the queue.

6.5 Loopers Looper is a class within the Android user interface that can be used in tandem with the Handler class to provide a framework for implementing a concurrency pattern

Background threads can push new units of work onto the MessageQueue at any time The UI thread processes the queued units of work one after another If there are no work units on the MessageQueue it waits until one appears in the queue Processing the MessageQueue can be quit at any time and units of work can be removed from the queue

A Looper is the mechanism that allows these units of work to be executed or processed sequentially on a single thread A Handler is used to schedule those units of work for execution by pushing them onto a MessageQueue.

6.6 Canvas Movement and Views Programatic animation can be achieved through the use of a canvas A canvas is provided by View.onDraw() The most convenient aspect of this feature is the provision of the pre-defined Canvas, which is automatically supplied by the Android framework

6.7 SurfaceViews Android provides a SurfaceView class to construct objects with a dedicated drawing surface that can be updated on a background thread SurfaceViews contain a rendering mechanism that allows threads to update the surface’s content without the use of a Handler

SurfaceView is derived from the View class. It provides more resources than Views and was created with the objective of delivering a drawing surface for a background thread

6.8 Efficient Threading There are obvious advantages of multithreading, such as the provision of greater responsiveness by using idle time to perform background tasks The employment too many threads can lead to a sluggish application.

The impact of having too many threads in an application can result in the following two conditions First, partitioning a fixed amount of work among too many threads gives each thread too little work Second, having too many threads running incurs overhead in the way they share finite processing resources

When designing applications that require multiple threads, it is advisable to strategize the detection of possible deadlocks Deadlocks will occur when a given thread is waiting for another thread to finish, while that thread is waiting for the previous one to complete These deadlocks must be avoided, or resolved when they occur

The most common thread communication between threads occurs between the UI thread and background threads The UI thread offloads long tasks by sending data messages to be processed on background threads Multithreaded applications should follow an efficient message passing mechanism

6.9 Materials and Functionality With the release of Lollipop new visual enhancement features were added to the platform and given the name Material Design A specific feature that stood out was fluid animations Surfaces and edges of material provide visual cues The use of familiar tactile attributes helps users quickly comprehend how to maneuver

Applying material design to an application requires the android:Theme attribute in AndroidManifest.xml to be set to Material This specification provides a collection of default animations for touch feedback and activity transitions

6.10 Async Tasks In general, when performing parallel tasks running longer than a few seconds, it is best to use Java threads rather than the UI thread As an alternate solution, Android provides an AsyncTask class as a convenient way to execute work units in parallel. The AsyncTask class is similar to a thread in that it allows background work to execute outside the UI thread

AsyncTask is designed to be a helper class for Thread and Handler and does not constitute a generic threading mechanism AsyncTask operations should not be used for long running work

AsyncTask is an abstract class that is designed to work with the UI An asynchronous process is defined by the following four steps, each implemented as a callback method: onPreExecute(): doInBackground(): onProgressUpdate(): onPostExecute():