Android Interface Definition Language(AIDL)

duohuoteng

浏览: 205105 次
性别:
来自: 南京

最近访客更多访客>>

djsmallpig

topyin78

mfcai

inclick

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

android 其他
android 基础

使用AIDL 设计远程接口 ( Designing a Remote Interface Using AIDL )

由于每个应用程序都运行在自己的进程空间，并且可以从应用程序UI 运行另一个服务进程，而且经常会在不同的进程间传递对象。在 Android 平台，一个进程通常不能访问另一个进程的内存空间，所以要想对话，需要将对象分解成操作系统可以理解的基本单元，并且有序的通过进程边界。

通过代码来实现这个数据传输过程是冗长乏味的，Android 提供了 AIDL 工具来处理这项工作。

AIDL (Android Interface Definition Language)是一种 IDL 语言，用于生成可以在 Android 设备上两个进程之间进行进程间通信 (IPC) 的代码。如果在一个进程中（例如 Activity ）要调用另一个进程中（例如 Service ）对象的操作，就可以使用 AIDL 生成可序列化的参数。

AIDL IPC机制是面向接口的，像 COM 或 Corba 一样，但是更加轻量级。它是使用代理类在客户端和实现端传递数据。

使用AIDL 实现 IPC( Implementing IPC Using AIDL )

使用AIDL 实现 IPC 服务的步骤是：

1. 创建.aidl 文件 - 该文件（ YourInterface.aidl ）定义了客户端可用的方法和数据的接口。

2. 在makefile 文件中加入 .aidl 文件 - （ Eclipse 中的 ADT 插件提供管理功能） Android 包括名为 AIDL 的编译器，位于 tools/ 文件夹。

3. 实现接口-AIDL 编译器从 AIDL 接口文件中利用 Java 语言创建接口，该接口有一个继承的命名为 Stub 的内部抽象类（并且实现了一些 IPC 调用的附加方法），要做的就是创建一个继承于 YourInterface.Stub 的类并且实现在 .aidl 文件中声明的方法。

4. 向客户端公开接口- 如果是编写服务，应该继承 Service 并且重载 Service.onBind(Intent) 以返回实现了接口的对象实例

创建.aidl 文件 ( Create an .aidl File )

AIDL使用简单的语法来声明接口，描述其方法以及方法的参数和返回值。这些参数和返回值可以是任何类型，甚至是其他 AIDL 生成的接口。重要的是必须导入所有非内置类型，哪怕是这些类型是在与接口相同的包中。下面是 AIDL 能支持的数据类型：

l Java编程语言的主要类型 (int, boolean 等 ) — 不需要 import 语句。

l 以下的类 ( 不需要 import 语句 ):

n String

n List - 列表中的所有元素必须是在此列出的类型，包括其他AIDL 生成的接口和可打包类型。 List 可以像一般的类（例如 List<String> ）那样使用，另一边接收的具体类一般是一个 ArrayList ，这些方法会使用 List 接口。

n Map - Map中的所有元素必须是在此列出的类型，包括其他 AIDL 生成的接口和可打包类型。一般的 maps （例如 Map<String,Integer> ）不被支持，另一边接收的具体类一般是一个 HashMap ，这些方法会使用 Map 接口。

n CharSequence - 该类是被TextView 和其他控件对象使用的字符序列。

l 通常引引用方式传递的其他AIDL 生成的接口，必须要 import 语句声明

l 实现了Parcelable protocol 以及按值传递的自定义类，必须要 import 语句声明。

以下是基本的AIDL 语法：

实现接口( Implementing the Interface )

AIDL生成了与 .aidl 文件同名的接口，如果使用 Eclipse 插件， AIDL 会做为编译过程的一部分自动运行（不需要先运行 AIDL 再编译项目），如果没有插件，就要先运行 AIDL 。

生成的接口包含一个名为Stub 的抽象的内部类，该类声明了所有 .aidl 中描述的方法， Stub 还定义了少量的辅助方法，尤其是 asInterface() ，通过它或以获得 IBinder （当 applicationContext.bindService() 成功调用时传递到客户端的 onServiceConnected() ）并且返回用于调用 IPC 方法的接口实例，更多细节参见 Calling an IPC Method 。

要实现自己的接口，就从YourInterface.Stub 类继承，然后实现相关的方法（可以创建 .aidl 文件然后实现 stub 方法而不用在中间编译， Android 编译过程会在 .java 文件之前处理 .aidl 文件）。

这个例子实现了对IRemoteService 接口的调用，这里使用了匿名对象并且只有一个 getPid() 接口。

这里是实现接口的几条说明：

l 不会有返回给调用方的异常

l 默认IPC 调用是同步的。如果已知 IPC 服务端会花费很多毫秒才能完成，那就不要在 Activity 或 View 线程中调用，否则会引起应用程序挂起（ Android 可能会显示“应用程序未响应”对话框），可以试着在独立的线程中调用。

l AIDL接口中只支持方法，不能声明静态成员。

向客户端暴露接口( Exposing Your Interface to Clients )

在完成了接口的实现后需要向客户端暴露接口了，也就是发布服务，实现的方法是继承 Service ，然后实现以 Service.onBind(Intent) 返回一个实现了接口的类对象。下面的代码片断表示了暴露 IRemoteService 接口给客户端的方式。

public class RemoteService extends Service {

...

@Override

public IBinder onBind ( Intent intent ) {

// Select the interface to return. If your service only implements

// a single interface, you can just return it here without checking

// the Intent.

if ( IRemoteService . class . getName (). equals ( intent . getAction ())) {

return mBinder ;

}

if ( ISecondary . class . getName (). equals ( intent . getAction ())) {

return mSecondaryBinder ;

}

return null ;

}

/**

* The IRemoteInterface is defined through IDL

private final IRemoteService . Stub mBinder = new IRemoteService . Stub () {

public void registerCallback ( IRemoteServiceCallback cb ) {

if ( cb != null ) mCallbacks . register ( cb );

}

public void unregisterCallback ( IRemoteServiceCallback cb ) {

if ( cb != null ) mCallbacks . unregister ( cb );

}

};

/**

* A secondary interface to the service.

private final ISecondary . Stub mSecondaryBinder = new ISecondary . Stub () {

public int getPid () {

return Process . myPid ();

}

public void basicTypes ( int anInt , long aLong , boolean aBoolean ,

float aFloat , double aDouble , String aString ) {

}

};

}

使用可打包接口传递参数 Pass by value Parameters using Parcelables

如果有类想要能过AIDL 在进程之间传递，这一想法是可以实现的，必须确保这个类在 IPC 的两端的有效性，通常的情形是与一个启动的服务通信。

这里列出了使类能够支持Parcelable 的 4 个步骤：【译者注：原文为 5 ，但列表为 4 项，疑为作者笔误】

1. 使该类实现Parcelabel 接口。

2. 实现public void writeToParcel(Parcel out) 方法，以便可以将对象的当前状态写入包装对象中。

3. 增加名为CREATOR 的构造器到类中，并实现 Parcelable.Creator 接口。

4. 最后，但同样重要的是，创建AIDL 文件声明这个可打包的类（见下文），如果使用的是自定义的编译过程，那么不要编译此 AIDL 文件，它像 C 语言的头文件一样不需要编译。

AIDL会使用这些方法的成员序列化和反序列化对象。

这个例子演示了如何让Rect 类实现 Parcelable 接口。

import android . os . Parcel ;

import android . os . Parcelable ;

public final class Rect implements Parcelable {

public int left ;

public int top ;

public int right ;

public int bottom ;

public static final Parcelable . Creator < Rect > CREATOR = new Parcelable . Creator < Rect >() {

public Rect createFromParcel ( Parcel in ) {

return new Rect ( in );

}

public Rect [] newArray ( int size ) {

return new Rect [ size ];

}

};

public Rect () {

}

private Rect ( Parcel in ) {

readFromParcel ( in );

}

public void writeToParcel ( Parcel out ) {

out . writeInt ( left );

out . writeInt ( top );

out . writeInt ( right );

out . writeInt ( bottom );

}

public void readFromParcel ( Parcel in ) {

left = in . readInt ();

top = in . readInt ();

right = in . readInt ();

bottom = in . readInt ();

}

这个是Rect.aidl 文件。

序列化Rect 类的工作相当简单，对可打包的其他类型的数据可以参见 Parcel 类。

警告：不要忘了对从其他进程接收到的数据进行安全检查。在上面的例子中，rect 要从数据包中读取 4 个数值，需要确认无论调用方想要做什么，这些数值都是在可接受的范围之内。想要了解更多的关于保持应用程序安全的内容，可参见 Security and Permissions 。

调用IPC 方法 (Calling an IPC Method)

这里给出了调用远端接口的步骤：

1. 声明.aidl 文件中定义的接口类型的变量。

2. 实现ServiceConnection

3. 调用Context.bindService() ，传递 ServiceConnection 的实现

4. 在ServiceConnection.onServiceConnected() 方法中会接收到 IBinder 对象，调用 YourInterfaceName.Stub.asInterface((IBinder)service) 将返回值转换为 YourInterface 类型

5. 调用接口中定义的方法。应该总是捕获连接被打断时抛出的DeadObjectException 异常，这是远端方法唯一的异常。

6. 调用Context.unbindService() 断开连接

这里是几个调用IPC 服务的提示：

l 对象是在进程间进行引用计数

l 可以发送匿名对象作为方法参数

以下是演示调用AIDL 创建的服务，可以在 ApiDemos 项目中获取远程服务的示例。

public static class Binding extends Activity {

/** The primary interface we will be calling on the service. */

IRemoteService mService = null ;

/** Another interface we use on the service. */

ISecondary mSecondaryService = null ;

Button mKillButton ;

TextView mCallbackText ;

private boolean mIsBound ;

/**

* Standard initialization of this activity. Set up the UI, then wait

* for the user to poke it before doing anything.

@Override

protected void onCreate ( Bundle savedInstanceState ) {

super . onCreate ( savedInstanceState );

setContentView ( R . layout . remote_service_binding );

// Watch for button clicks.

Button button = ( Button ) findViewById ( R . id . bind );

button . setOnClickListener ( mBindListener );

button = ( Button ) findViewById ( R . id . unbind );

button . setOnClickListener ( mUnbindListener );

mKillButton = ( Button ) findViewById ( R . id . kill );

mKillButton . setOnClickListener ( mKillListener );

mKillButton . setEnabled ( false );

mCallbackText = ( TextView ) findViewById ( R . id . callback );

mCallbackText . setText ( "Not attached." );

}

/**

* Class for interacting with the main interface of the service.

private ServiceConnection mConnection = new ServiceConnection () {

public void onServiceConnected ( ComponentName className , IBinder service ) {

// This is called when the connection with the service has been

// established, giving us the service object we can use to

// interact with the service. We are communicating with our

// service through an IDL interface, so get a client-side

// representation of that from the raw service object.

mService = IRemoteService . Stub . asInterface ( service );

mKillButton . setEnabled ( true );

mCallbackText . setText ( "Attached." );

// We want to monitor the service for as long as we are

// connected to it.

try {

mService . registerCallback ( mCallback );

} catch ( RemoteException e ) {

// In this case the service has crashed before we could even

// do anything with it; we can count on soon being

// disconnected (and then reconnected if it can be restarted)

// so there is no need to do anything here.

}

// As part of the sample, tell the user what happened.

Toast . makeText ( Binding . this , R . string . remote_service_connected ,

Toast . LENGTH_SHORT ). show ();

}

public void onServiceDisconnected ( ComponentName className ) {

// This is called when the connection with the service has been

// unexpectedly disconnected -- that is, its process crashed.

mService = null ;

mKillButton . setEnabled ( false );

mCallbackText . setText ( "Disconnected." );

// As part of the sample, tell the user what happened.

Toast . makeText ( Binding . this , R . string . remote_service_disconnected ,

Toast . LENGTH_SHORT ). show ();

}

};

/**

* Class for interacting with the secondary interface of the service.

private ServiceConnection mSecondaryConnection = new ServiceConnection () {

public void onServiceConnected ( ComponentName className , IBinder service ) {

// Connecting to a secondary interface is the same as any

// other interface.

mSecondaryService = ISecondary . Stub . asInterface ( service );

mKillButton . setEnabled ( true );

}

public void onServiceDisconnected ( ComponentName className ) {

mSecondaryService = null ;

mKillButton . setEnabled ( false );

}

};

private OnClickListener mBindListener = new OnClickListener () {

public void onClick ( View v ) {

// Establish a couple connections with the service, binding

// by interface names. This allows other applications to be

// installed that replace the remote service by implementing

// the same interface.

bindService ( new Intent ( IRemoteService . class . getName ()),

mConnection , Context . BIND_AUTO_CREATE );

bindService ( new Intent ( ISecondary . class . getName ()),

mSecondaryConnection , Context . BIND_AUTO_CREATE );

mIsBound = true ;

mCallbackText . setText ( "Binding." );

}

};

private OnClickListener mUnbindListener = new OnClickListener () {

public void onClick ( View v ) {

if ( mIsBound ) {

// If we have received the service, and hence registered with

// it, then now is the time to unregister.

if ( mService != null ) {

try {

mService . unregisterCallback ( mCallback );

} catch ( RemoteException e ) {

// There is nothing special we need to do if the service

// has crashed.

}

// Detach our existing connection.

unbindService ( mConnection );

unbindService ( mSecondaryConnection );

mKillButton . setEnabled ( false );

mIsBound = false ;

mCallbackText . setText ( "Unbinding." );

}

};

private OnClickListener mKillListener = new OnClickListener () {

public void onClick ( View v ) {

// To kill the process hosting our service, we need to know its

// PID. Conveniently our service has a call that will return

// to us that information.

if ( mSecondaryService != null ) {

try {

int pid = mSecondaryService . getPid ();

// Note that, though this API allows us to request to

// kill any process based on its PID, the kernel will

// still impose standard restrictions on which PIDs you

// are actually able to kill. Typically this means only

// the process running your application and any additional

// processes created by that app as shown here; packages

// sharing a common UID will also be able to kill each

// other's processes.

Process . killProcess ( pid );
mCallbackText . setText ( "Killed service process." );

} catch ( RemoteException ex ) {

// Recover gracefully from the process hosting the

// server dying.

// Just for purposes of the sample, put up a notification.

Toast . makeText ( Binding . this ,

R . string . remote_call_failed ,

Toast . LENGTH_SHORT ). show ();

}

};

// ----------------------------------------------------------------------

// Code showing how to deal with callbacks.

// ----------------------------------------------------------------------

/**

* This implementation is used to receive callbacks from the remote

* service.

private IRemoteServiceCallback mCallback = new IRemoteServiceCallback . Stub () {

/**

* This is called by the remote service regularly to tell us about

* new values. Note that IPC calls are dispatched through a thread

* pool running in each process, so the code executing here will

* NOT be running in our main thread like most other things -- so,

* to update the UI, we need to use a Handler to hop over there.

public void valueChanged ( int value ) {

mHandler . sendMessage ( mHandler . obtainMessage ( BUMP_MSG , value , 0 ));

}

};

private static final int BUMP_MSG = 1 ;

private Handler mHandler = new Handler () {

@Override public void handleMessage ( Message msg ) {

switch ( msg . what ) {

case BUMP_MSG :

mCallbackText . setText ( "Received from service: " + msg . arg1 );

break ;

default :

super . handleMessage ( msg );

}

};

}

原文

http://developer.android.com/guide/developing/tools/a idl .html ( 注意：3.0 r1 以后移到 Appendix 下 )

分享到：

android 录音 | measure

2012-06-10 15:47
浏览 781
评论(0)
分类:移动开发
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论