Android™ Application Development - Bahar Ali Khan

Chapter 11: Advanced Android Development
Using AIDL to Support IPC for Services
356
One of the more interesting possibilities of Services is the idea of running independent background
processes to supply processing, data lookup, or other useful functionality to multiple independent
applications.
In Chapter 8, you learned how to create Services for your applications. Here, you’ll learn how to use the
Android Interface Defi nition Language (AIDL) to support interprocess communication (IPC) between
Services and application components. This will give your Services the ability to support multiple applications
across process boundaries.
To pass objects between processes, you need to deconstruct them into OS-level primitives that the
underlying operating system (OS) can then marshal across application boundaries.
AIDL is used to simplify the code that lets your processes exchange objects. It’s similar to interfaces like
COM or Corba in that it lets you create public methods within your Services that can accept and return
object parameters and return values between processes.
Implementing an AIDL Interface
AIDL supports the following data types:
❑ Java language primitives ( int, boolean, float, char, etc.)
❑ String and CharSequence values
❑ List (including generic) objects, where each element is a supported type. The receiving class
will always receive the List object instantiated as an ArrayList.
❑ Map (not including generic) objects in which each key and element is a supported type. The
receiving class will always receive the Map object instantiated as a HashMap.
❑
AIDL-generated interfaces (covered later). An import statement is always needed for these.
❑ Classes that implement the Parcelable interface (covered next). An import statement is always
needed for these.
The following sections demonstrate how to make your application classes AIDL-compatible by implementing
the Parcelable interface, before creating an AIDL interface defi nition and implementing that
interface within your Service.
Passing Custom Class Objects
To pass non-native objects between processes, they must implement the Parcelable interface. This lets
you decompose your objects into primitive types stored within a Parcel that can be marshaled across
process boundaries.
Implement the writeToParcel method to decompose your class object, then implement the public
static Creator fi eld (which implements a new Parcelable.Creator class), which will create a new
object based on an incoming Parcel.