> Android应用开发入门（五十一）AIDL接口通过绑定Service在进程间传递复杂对象
Android应用开发入门（五十一）AIDL接口通过绑定Service在进程间传递复杂对象
　　Android的AIDL不仅可以在绑定服务中传递一些Android规定的数据类型的数据，还可以传递一些复杂类型的数据。但是与传递系统允许的数据类型相比，复杂类型数据的传递要做更多的工作，本文就讲解一下如何使用AIDL接口通过绑定服务在进程间传递数据。关于AIDL传递规定类型数据的内容，不了解的朋友可以看看：。
　　本文的主要内容：
AIDL传递复杂类型对象的特殊处理
Parcelable与Parcel接口
实现Parcelable接口
AIDL传递复杂类型对象Demo
AIDL传递对象序列化过程详解
AIDL传递复杂类型对象的特殊处理&
　　前面已经介绍了通过AIDL接口在进程间传递系统允许的数据，如果需要传递一个复杂类型的对象，就没那么简单了，需要额外做一些处理。如下：
定义数据接口的AIDL文件中，使用parcelable关键字，例如：parcelable M
在其数据实现类中实现Parcelable接口，并实现对应的方法。
在业务接口的AIDL文件中，使用import引入数据接口AIDL的包名。
　　例如：Message.aidl
parcelable&M&&
　　例如：IGetMsg.aidl
package&com.example.aidlservicedemo. &&&import&com.example.aidlservicedemo.domain.M &import&com.example.aidlservicedemo.domain.U &&interface&IGetMsg{ &&&&&&&&&&List&Message&&getMes(in&User&us); &}&
Parcelable与Parcel接口
　　先来说说Android对象序列化，在Android中序列化对象主要有两种方式，实现Serializable接口或是实现Parcelable接口。Serializable接口是JavaSE原生支持的，而Parcelable接口是Android所特有的，它的序列化和反序列化的效率均比Serializable接口高，而AIDL进行在进程间通信（IPC），就是需要实现这个Parcelable接口。
　　Parcelable接口的作用：实现了Parcelable接口的实例，可以将自身的数据信息写入一个Parcel对象，也可以从parcel中恢复到对象的状态。而Parcel就是完成数据序列化写入的载体。
　　上面提到Parcel，再来聊聊Parcel是什么？Android系统设计之初，定位就是针对内存受限的设备，因此对性能要求更好，所以系统中采用进程间通信（IPC）机制，必然要求性能更优良的序列化方式，所以Parcel就被设计出来了，其定位就是轻量级的高效的对象序列化机制与反序列化机制。如果读一下Android的底层代码，会发现Parcel是使用C++实现的，底层直接通过Parcel指针操作内存实现，所以它的才更高效。
　　Parcel也提供了一系列的方法帮助写入数据与读取数据，这里简单介绍一下：
obtain()：在池中获取一个新的Parcel。
dataSize()：得到当前Parcel对象的实际存储空间。
dataPostion()：获取当前Parcel对象的偏移量。
setDataPosition()：设置当前Parcel对象的偏移量。
recyle()：清空、回收当前Parcel对象的内存。
writeXxx()：向当前Parcel对象写入数据，具有多种重载。
readXxx()：从当前Parcel对象读取数据，具有多种重载。
　　简单来说，Parcelable通过writeToParcel()方法，对复杂对象的数据写入Parcel的方式进行对象序列化，然后在需要的时候，通过其内定义的静态属性CREATOR.createFromParcel()进行反序列化的操作。Parcelable对Parcel进行了包装，其内部就是通过操作Parcel进行序列化与反序列化的。
　　Parcelable与Parcel均定义在android.os包下，而这种机制不仅用于AIDL，还可以用于Intent传递数据等其他地方，这不是本篇博客的主题，以后用到再详细介绍。
本文地址 ：
------分隔线----------------------------9251人阅读
今天我们就来介绍一下Android中的四大组件中的服务Service，说到Service，
它分为本地服务和远程服务：区分这两种服务就是看客户端和服务端是否在同一个进程中，本地服务是在同一进程中的，远程服务是不在同一个进程中的。
开启服务也有两种方式，一种是startService(),他对应的结束服务的方法是stopService()，另一种是bindService()，结束服务的是unBindService()，这两种方式的区别就是：当客户端Client使用startService方法开启服务的时候，这个服务和Client之间就没有联系了，Service的运行和Client是相互独立的，想结束这个服务的话，就在服务本身中调用stopSelf()方法结束服务。而当客户端Client使用bindService方法开始服务的时候，这个服务和Client是一种关联的关系，他们之间使用Binder的代理对象进行交互，这个在后面会详细说到，要是结束服务的话，需要在Client中和服务断开，调用unBindService方法。
在这里我们只做bindService方式的研究，而startService方式比较独立和简单，这里就不做演示了。
首先来说一下本地服务：
本地服务很简单的，就是Client和这个服务在同一个进程中：
先来看一下代码吧：
下面这张图是项目的结构图：
为了方便数据的访问，这里定义一个数据的访问接口：
下面再来看一下StudentService的代码：
StudentService中就是定义一个访问name的方法，在onBind方法中返回Binder对象，这个就是Client和Service之间交互的关键对象
下面看一下Client代码：
在这里，用到了bindService方法，该方法的参数是：第一个参数是服务的intent,第二参数是一个ServiceConnection接口，第三个参数是启动服务的方式常量，这里最主要的就是第二个参数ServiceConnection接口，我们自己定义一个实现该接口的类。
StudentConnection,必须实现两个方法，这两个方法见名思议，一个是连接时调用的方法，一个是断开连接时的方法，在开始连接的方法onServiceConnected中传回来一个IBinder对象，这个时候需要将其转化一下，这个就是为什么要在开始的时候定义一个IStudent接口，在这里访问数据就方便了，同时在Client代码中要做个延迟的操作来访问数据，因为开启服务，连接这个过程是需要时间的，所以在这里就延迟了2s，这里只是为了能够正常显示数据，才这么做的，不然student对象是为null的，当然要根据自己的实际情况操作。最后还要在AndroidMainfest.xml中配置Service：
这里开启服务用的是显示意图，所以没有定义action过滤器了，运行结果很简单这里就不截图了
下面在来说一下远程服务：
在说到远程服务的时候，我们需要先了解一些预备的知识：
首先来了解一下AIDL机制：
AIDL的作用
由于每个应用程序都运行在自己的进程空间，并且可以从应用程序UI运行另一个服务进程，而且经常会在不同的进程间传递对象。在Android平台，一个进程通常不能访问另一个进程的内存空间，所以要想对话，需要将对象分解成操作系统可以理解的基本单元，并且有序的通过进程边界。
通过代码来实现这个数据传输过程是冗长乏味的，Android提供了AIDL工具来处理这项工作。
AIDL (Android Interface Definition Language) 是一种IDL 语言，用于生成可以在Android设备上两个进程之间进行进程间通信(interprocess communication, IPC)的代码。如果在一个进程中（例如Activity）要调用另一个进程中（例如Service）对象的操作，就可以使用AIDL生成可序列化的参数。
AIDL IPC机制是面向接口的，像COM或Corba一样，但是更加轻量级。它是使用代理类在客户端和实现端传递数据。
在Android中, 每个应用程序都有自己的进程，当需要在不同的进程之间传递对象时，该如何实现呢? 显然, Java中是不支持跨进程内存共享的。因此要传递对象, 需要把对象解析成操作系统能够理解的数据格式, 以达到跨界对象访问的目的。在JavaEE中，采用RMI通过序列化传递对象。在Android中, 则采用AIDL(Android Interface Definition Language：接口描述语言)方式实现。
AIDL是一种接口定义语言，用于约束两个进程间的通讯规则，供编译器生成代码，实现Android设备上的两个进程间通信(IPC)。AIDL的IPC机制和EJB所采用的CORBA很类似，进程之间的通信信息，首先会被转换成AIDL协议消息，然后发送给对方，对方收到AIDL协议消息后再转换成相应的对象。由于进程之间的通信信息需要双向转换，所以android采用代理类在背后实现了信息的双向转换，代理类由android编译器生成，对开发人员来说是透明的。
选择AIDL的使用场合
官方文档特别提醒我们何时使用AIDL是必要的：只有你允许客户端从不同的应用程序为了进程间的通信而去访问你的service，以及想在你的service处理多线程。
了解了AIDL之后下面来看一下项目的结构：
我们这个远程服务是想在将服务端和客户端分别放到一个应用中，所以这里要建立两个Android项目一个是remoteService,一个是remoteClient
首先来看一下Service端的项目结构：
在这里我们需要定义一个aidl文件，具体步骤很简单的：
因为AIDL相当于是一个接口，所以它的定义和interface的定义很类似的，使用interface关键字，有一点不同的是，AIDL中不能有修饰符(public,protected,private)，不然报错，这个你们可以自己尝试一下，然后将定义好的AIDL文件的后缀名.java改成.aidl，此时在gen文件夹下面就会多出一个与之对应的java文件，这个是编译器干的事情。这个AIDL接口中定义的一般都是Client和Service交互的接口。
下面来看一下StudentQuery.aidl文件：
代码结构和接口是大同小异的。
再来看一下服务端的代码：
这个服务端的代码和我们之前的本地服务代码差不多，不同的是我们定义的Binder类是继承了StudentQuery.Stub类，其中StudentQuery是我们定义的AIDL文件，编译器帮我们生成的StudentQuery.java（在gen文件夹中）这个类，下面来看一下这个类吧：
感觉好复杂，其实我们没必要看懂的，这个是Android内部实现的，我们在这里可以了解一下，看一下那个Stub抽象类，他实现了Binder接口，所以我们需要继承这个类就可以了，还有一个问题就是我们注意到，就是返回StudentQuery接口对象的问题：
* Copyright (C) 2006 The Android Open Source Project
* Licensed under the Apache License, Version 2.0 (the &License&);
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an &AS IS& BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
package android.
* Base class for Binder interfaces.
When defining a new interface,
* you must derive it from IInterface.
public interface IInterface
* Retrieve the Binder object associated with this interface.
* You must use this instead of a plain cast, so that proxy objects
* can return the correct result.
public IBinder asBinder();
上面的是Interface接口，他只有一个方法asBinder()这个方法就是返回一个IBinder对象，而我们的AIDL接口需要实现这个接口的，所以说这个asBinder()方法的功能就是将AIDL接口转化成IBinder对象，这个是内部实现的，在asInterface()方法中可以看到：
private static class Proxy implements com.demo.aidl.StudentAIDL
private android.os.IBinder mR
Proxy(android.os.IBinder remote)
@Override public android.os.IBinder asBinder()
public java.lang.String getInterfaceDescriptor()
return DESCRIPTOR;
@Override public java.lang.String queryNameByNo(int no) throws android.os.RemoteException
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.lang.String _
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(no);
mRemote.transact(Stub.TRANSACTION_queryNameByNo, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
_reply.recycle();
_data.recycle();
}这个是代理生成类，我们可以看到这个类中是返回的mRemote对象就是IBinder的一个引用，同时也返回了一个StudentQuery实现对象。
在StudentQuery.Stub中有一个asInterface方法，这个方法中我们可以看到，如果这个Service和Client是在同一个进程中，则在Client中的StudentConnection类中返回的是IBinder就是实际的对象，如果不是在同一个进程中的话，返回的是IBinder的代理对象。
其他的问题我们暂时不看了，也不去做深入的了解了，
再来看一下AndroidMainfest.xml文件中配置Service:
这里我们开启服务的话，需要用到隐式意图了，而不能直接用Service类了，因为是在不同的应用中，这样服务端的代码就差不多了，我们现在来看一下客户端的代码结构：
首先来看一下，客户端肯定要有aidl文件，所以我们将服务端的aidl的文件拷到Client中(包括AIDL所在的包也要拷过来，刷新一下，在gen文件夹中出现了StudentQuery.java类)，下面来看一下Client的代码(MainActivity.java):
Client端的代码结构和我们之前的本地服务的代码结构差不多，有几处不同，第一处不同就是那个开启服务的方式，这里使用的是隐式的方式开启服务的，因为是跨应用访问的，还有一处不同的是返回的StudentQuery接口对象不同，本地服务的话是通过强制转化的，而远程服务这里是用asInterface方法进行转化的。
客户端和服务端的代码结构看完了，下面我们来运行一下，首先安装remoteService包，然后运行remoteClient包，在文本框中输入学号，查询到名称了，运行成功。在不同的应用中，一定是跨进程的，不行我们可以查看一下系统的进程：
这里我们使用adb命令查看：
在这篇blog中我说到了怎么使用这条命令
我们可以看到有两个进程Proc #9和Proc #12
到这里我们就介绍了本地服务和远程服务的使用了，下面我们再来看一下额外的知识，就是怎么在一个应用中进行远程服务的访问，我们之前涉及到的是跨应用的访问，这里其实很简单，只需要改动一处就可以：下面是我改过的一个项目，在同一个应用中进行远程服务的访问，代码都是一样的，这里就不做介绍了；
这里需要修改的地方就是要在AndroidManifest.xml中修改一下Service的定义属性：
这里我们添加了一个属性就是android:process=&:remote&,这个属性就是将该服务设置成远程的，就是和Activity不在同一个进程中，具体的Service属性说明请看我的另外的一篇blog:
运行结果是一样的，为了证明服务是远程服务，我们在使用上面的命令打印一下当前系统中的进程信息：
系统中的Proc #9和Proc #10两个进程，这里就介绍了怎么在同一个应用中跨进程访问服务。
下面在来看一下AIDL:
我们上面说到的AIDL是说他怎么用，而且很是简单，我现在来具体看一下AIDL文件的定义：
Aidl默认支持的类型包话java基本类型（int、long、boolean等）和（String、List、Map、CharSequence），如果要传递自定义的类型该如何实现呢？
要传递自定义类型，首先要让自定义类型支持parcelable协议，实现步骤如下：
1&自定义类型必须实现Parcelable接口，并且实现Parcelable接口的publicvoid writeToParcel(Parcel dest, int flags)方法 。
2&自定义类型中必须含有一个名称为CREATOR的静态成员，该成员对象要求实现Parcelable.Creator接口及其方法。
3& 创建一个aidl文件声明你的自定义类型。
Parcelable接口的作用：实现了Parcelable接口的实例可以将自身的状态信息（状态信息通常指的是各成员变量的值）写入Parcel，也可以从Parcel中恢复其状态。Parcel用来完成数据的序列化传递。
下面来看一下例子：
创建自定义类型，并实现接口使其支持协议。如：在包下创建
在自定义类型所在包下创建一个文件对自定义类型进行声明，文件的名称与自定义类型同名。
在接口文件中使用自定义类型需要使用显式导入，本例在包下创建文件，内容如下：
在实现文件生成的接口（本例是），但并非直接实现接口，而是通过继承接口的来实现（抽象类内部实现了接口），并且实现接口方法的代码。内容如下：
创建一个（服务），在服务的方法中返回实现了接口的对象（本例是）。内容如下：
其他应用可以通过隐式意图访问服务意图的动作可以自定义，配置代码如下：
把应用中的文件和所在一起拷贝到客户端应用的目录下，会自动在客户端应用的目录中为文件同步生成接口文件接下来再把自定义类型文件和类型声明文件及所在一起拷贝到客户端应用的目录下。
最后就可以在客户端应用中实现与远程服务的通信，代码如下：
这样就可以访问我们自己定义的类型了。
下面来总结一下定义一个远程服务的步骤：
假设A应用需要与B应用进行通信，调用B应用中的download(String path)方法，B应用以Service方式向A应用提供服务。需要下面四个步骤:
1& 在B应用中创建*.aidl文件，aidl文件的定义和接口的定义很相类，如：在cn.itcast.aidl包下创建IDownloadService.aidl文件，内容如下：
当完成aidl文件创建后，eclipse会自动在项目的gen目录中同步生成IDownloadService.java接口文件。接口文件中生成一个Stub的抽象类，里面包括aidl定义的方法，还包括一些其它辅助方法。值得关注的是asInterface(IBinder iBinder)，它返回接口类型的实例，对于远程服务调用，远程服务返回给客户端的对象为代理对象，客户端在onServiceConnected(ComponentName name, IBinder service)方法引用该对象时不能直接强转成接口类型的实例，而应该使用asInterface(IBinder
iBinder)进行类型转换。
编写Aidl文件时，需要注意下面几点:
& 1.接口名和aidl文件名相同。
& 2.接口和方法前不用加访问权限修饰符public,private,protected等,也不能用final,static。
& 3.Aidl默认支持的类型包话java基本类型（int、long、boolean等）和（String、List、Map、CharSequence），使用这些类型时不需要import声明。对于List和Map中的元素类型必须是Aidl支持的类型。如果使用自定义类型作为参数或返回值，自定义类型必须实现Parcelable接口。
& 4.自定义类型和AIDL生成的其它接口类型在aidl描述文件中，应该显式import，即便在该类和定义的包在同一个包中。
& 5.在aidl文件中所有非Java基本类型参数必须加上in、out、inout标记，以指明参数是输入参数、输出参数还是输入输出参数。
& 6.Java原始类型默认的标记为in,不能为其它标记。
2& 在B应用中实现aidl文件生成的接口（本例是IDownloadService），但并非直接实现接口，而是通过继承接口的Stub来实现（Stub抽象类内部实现了aidl接口），并且实现接口方法的代码。内容如下：
3& 在B应用中创建一个Service（服务），在服务的onBind(Intent intent)方法中返回实现了aidl接口的对象（本例是ServiceBinder）。内容如下：
其他应用可以通过隐式意图访问服务,意图的动作可以自定义，AndroidManifest.xml配置代码如下：
4& 把B应用中aidl文件所在package连同aidl文件一起拷贝到客户端A应用，eclipse会自动在A应用的gen目录中为aidl文件同步生成IDownloadService.java接口文件,接下来就可以在A应用中实现与B应用通信，代码如下：
最后看一下Service的生命周期以及和生命周期相关的方法：
与采用Context.startService()方法启动服务有关的生命周期方法
onCreate()-&onStart()-&onDestroy()
onCreate()该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次startService()或bindService()方法，服务也只被创建一次。
onStart()只有采用Context.startService()方法启动服务时才会回调该方法。该方法在服务开始运行时被调用。多次调用startService()方法尽管不会多次创建服务，但onStart() 方法会被多次调用。
onDestroy()该方法在服务被终止时调用。
l 与采用Context.bindService()方法启动服务有关的生命周期方法
onCreate()-&onBind()-&onUnbind()-&onDestroy()
onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。
onUnbind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用。
如果先采用startService()方法启动服务,然后调用bindService()方法绑定到服务，再调用unbindService()方法解除绑定，最后调用bindService()方法再次绑定到服务，触发的生命周期方法如下：
onCreate()-&onStart()-&onBind()-&onUnbind()[重载后的方法需返回true]-&onRebind()
Android中的服务和windows中的服务是类似的东西，服务一般没有用户操作界面，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。服务的开发比较简单，如下：
第一步：继承Service类
public class SMSService extends Service { }
第二步：在AndroidManifest.xml文件中的&application&节点里对服务进行配置:
&service android:name=&.SMSService& /&
服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。使用startService()方法启用服务，调用者与服务之间没有关连，即使调用者退出了，服务仍然运行。使用bindService()方法启用服务，调用者与服务绑定在了一起，调用者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。
采用Context.startService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onStart()方法。如果调用startService()方法前服务已经被创建，多次调用startService()方法并不会导致多次创建服务，但会导致多次调用onStart()方法。采用startService()方法启动的服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。
下面两张图是Service的生命周期：
关于服务的介绍就到这里了，具体详情可以参考以下两篇blog:
版权声明：本文为博主原创文章，未经博主允许不得转载。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
已经上线了，在各大市场都可以搜索到。希望大家多多支持!!
扫一扫关注
实时推送技术干货的精品文章
访问：945763次
积分：11588
积分：11588
排名：第562名
原创：190篇
评论：666条
文章：35篇
阅读：88304
文章：14篇
阅读：81609
文章：34篇
阅读：92156
文章：93篇
阅读：376702
(1)(2)(4)(1)(1)(1)(30)(9)(4)(7)(12)(3)(12)(13)(17)(21)(9)(33)(35)