Branch | Build Status |
---|---|
Master | |
Dev |
Traditionally "aidl" refers to several related but distinct concepts:
- the AIDL interface definition language;
- .aidl files (which contain AIDL);
- the aidl generator which transforms AIDL into client/server IPC interfaces.
This is a replacement for Google's aidl generator tool. Instead of parsing very limited DSL AIDL2 uses Java annotation processing framework to generate Java implementation, based on Java interface code. This allows you to extend from other interfaces, annotate your interface classes, use generics and other features of Java language.
Unlike Google's code generator, which is implemented as standalone C++ executable, AIDL2 is an annotation processor, that is — a plugin for Java compiler. It works automatically by adding jar file to project dependencies.
Better integration with compiler gives aidl2 complete understanding of involved types. In addition to types, supported by aidl tool, AIDL2 allows use of
- Generic Collections and Maps
- IInterface subtypes (both from AIDL2 and aidl tool)
- Externalizable/Serializable types
- Multi-dimensional arrays
- Void — ignored during (de)serialization, always evaluates to null
All generated code is human-readable and well-formatted.
You can learn more about project features in project wiki.
This project is in alpha stage. It is not nearly as well-tested as original aidl tool, but all features are there. If you decide to use it, make sure to read the generated code, to avoid any unpleasant surprises.
Add the library to project:
dependencies {
compile 'net.sf.aidl2:api:0.4.1'
annotationProcessor 'net.sf.aidl2:compiler:0.4.1'
}
Write an interface with required methods. It must extend android.os.IInterface
. Furthermore,
each method must declare android.os.RemoteException
to be thrown.
Annotate the interface with @AIDL
.
@AIDL
public interface RemoteApi extends IInterface {
String sayHello() throws RemoteException;
}
Retrive generated proxy/stub using InterfaceLoader
.
Service code:
public IBinder onBind(Intent intent) {
RemoteApi serviceApi = new RemoteApi() {
public String sayHello() {
return "Hello world";
}
public IBinder asBinder() {
return InterfaceLoader.asBinder(this, RemoteApi.class);
}
};
return serviceApi.asBinder();
}
Caller code:
public void onServiceConnected(ComponentName name, IBinder serviceBinder) {
try {
final RemoteApi serviceApi = InterfaceLoader.asInterface(serviceBinder, RemoteApi.class);
final String callResult = serviceApi.sayHello();
Toast.makeText(this, "Received message \"" + callResult + '"', Toast.LENGTH_SHORT).show();
} catch (RemoteException e) {
Toast.makeText(this, "Service error: " + e.getMessage(), Toast.LENGTH_SHORT).show();
}
}
You can specify any number of parameters, including varargs. Parameters and
return values must be of types, supported by android.os.Parcel
as well as extra types,
listed above. You can use tricky generic types if you want, but make sure, that those can be
interpreted as one of supported types:
@AIDL
public interface RemoteApi extends IInterface {
<T extends Runnable> void exampleMethod(T runnableParameter) throws RemoteException;
}
will fail to compile with error, because Parcel does not support Runnables.
@AIDL
public interface RemoteApi extends IInterface {
<T extends Runnable & Parcelable> T exampleMethod() throws RemoteException;
}
will compile and generate code, using writeParcelable
and readParcelable
to pass "runnableParameter"
between processes.
@AIDL
public interface RemoteApi extends IInterface {
void exampleMethod(Date[] dateArray) throws RemoteException;
}
will compile and use readSerializable
and writeSerializable
to passs "dateArray" between processes.
Read project wiki for in-depth documentations and some useful links.