Android Framework——进程间通讯学习，从Binder使用看起_activitymanager binder transaction

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

    private fun readObjectNoData() {}
}

}

这些方法都在`ObjectStreamClass` 中进行维护和处理，实现版本维护和序列化自定义。 **比较重要**的是`serialVersionUID`字段，该字段标记了实体类的版本号，当反序列化的时候，通过比对版本号判断是否结构没有发生大的改变，完成反序列过程。 \*\*提供该字段会让反序列化变得更加可靠可控。\*\*一般在即时的数据传输过程中不需要提供该字段，系统也会自动生成该类的hash值并将它赋值给`serialVersionUID`。但是在一些持久化操作的时候，提供该字段就是一个比较重要的工作。因为如果没有提供，一旦有属性改动，类的`hash`结果也会改变，直接将导致之前的数据无法反序列化成功，抛出异常。这对于体验的影响是严重的。 **所以在需要持久化数据的场景下，需要提供**`**serialVersionUID**` **字段。** Serializable 的序列化和反序列化代码很简单，下面举个简单的例子。

val file = File(“aaaa”)
file.createNewFile()
///序列化过程
ObjectOutputStream(FileOutputStream(file))
.use {
it.writeObject(User(“张三”))
}
///反序列化
val user: User? =
ObjectInputStream(FileInputStream(file)).use {
it.readObject() as User?
}
println(“序列化结果”)
println(user?.name)

上述代码完成了`Serializable` 方式序列化的整个过程。很简单，直接使用`ObjectOutputStream` 和 `ObjectInputStream` 就可以了。


## Parcelable


介绍完Serializable，再来看看Parcelable 。Parcelable也是一个接口，只要实现这个接口，就可以实现序列化并通过intent和binder进行传递。看看一个经典的用法：

class User(val name: String? = “小王”) : Parcelable {
constructor(parcel: Parcel) : this(parcel.readString()) {
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeString(name)
}
override fun describeContents(): Int {
return 0
}
companion object CREATOR : Parcelable.Creator {
override fun createFromParcel(parcel: Parcel): User {
return User(parcel)
}
override fun newArray(size: Int): Array<User?> {
return arrayOfNulls(size)
}
}
}

可以看到有这么四个自定义的方法，说明如下：


1. writeToParcel 实现序列化功能，写入到parcel
2. describeContents 提供内容描述，几乎都是返回0，只有在存在文件描述符的时候才返回1
3. createFromParcel 实现反序列功能，从序列化后的对象中创建原始对象
4. newArray 提供数组容器


`Parcelale`和`Serializable` 都能实现序列化，怎么选呢？我们可以根据两种方案的区别来选择。`Serializable`使用简单，但是开销比较大，在序列化和反序列化的过程中需要大量的I/O操作。而`Parcelable` 的使用稍微复杂一些，但是性能比较好是Android 推荐的序列化方式。所以在进行内存传递的时候，可以使用`Parcelable`进行序列化，但是在涉及到持久化和网络传输的时候，`Parcelable`也能实现，但是使用会比较复杂，所以在这两种情况下建议使用`Serializable`。上面就是两种序列化方案的区别。


## Binder


Binder是Android专有的一种通信方式，Binder底层有kernel驱动的支持，设备驱动文件是/dev/binder，通过该驱动，android 在native层有一整套C/S架构，在java层也封装了一层相应实现。直观来说，Binder是Android中的一个类，它继承了IBinder接口。 Binder 可以进行跨进程通讯，也可以进行本地进程通讯。我们在写一个无须跨进程的本地服务 LocalService 时，可以直接获取Binder类来进行通讯。 基于binder,Android实现了多个ManagerService。因为android 系统有各种系统组件硬件需要暴露给其他进程，并且要集中管理，所以安卓在实现管理方案之后，再通过binder来暴露对应的接口服务，比如pms，ams，wms。 Android开发中，开发者对于Binder最直接的应用就是使用AIDL，相关使用流程大概有以下几步：


1. 创建aidl文件，声明方法
2. 继承生成的Stub类(Binder的抽象子类)，实现服务端操作的相关接口方法
3. 创建另一个进程中运行的service，在其onBind方法中返回该Binder实例
4. 使用该Service，通过`ServiceConnection#onServiceConnected`回调中得到的参数IBinder 获取定义接口的Binder实例。如`IHelloManager.Stub.asInterface(service)`。
5. 通过Binder实例进行远程方法调用。


### AIDL ( Android 接口定义语言 )


先看[谷歌官方开发者文档]( )的介绍 我们可以利用AIDL定义客户端与服务均认可的编程接口，以便二者使用进程间通信 (IPC) 进行相互通信。在安卓中，编写进程间通信的代码较为繁琐，Android 会使用AIDL 帮我们处理这类问题。 我们先从一个典型的AIDL实例入手来探究。


#### 定义AIDL接口


我们来定义一个 aidl 接口文件

//IHelloManager.aidl
package top.guuguo.wanandroid.tv;
import top.guuguo.wanandroid.tv.User;
interface IHelloManager {
User getFriend();
void setFriend(in User friend);
}
//User.aidl
package top.guuguo.wanandroid.tv;
parcelable User;

其中用到了User对象，所以上文还定义了该`User.aidl`，该对象实现Parcelable接口。 我们找到`generated/aidl_source_output_dir`观察对应生成的java 类:`IHelloManager.java`。

public interface IHelloManager extends android.os.IInterface {
/**
* Default implementation for IHelloManager.
/
public static class Default implements top.guuguo.wanandroid.tv.IHelloManager {
//
}
/
* Local-side IPC implementation stub class.
/
public static abstract class Stub extends android.os.Binder implements top.guuguo.wanandroid.tv.IHelloManager {
//
private static class Proxy implements top.guuguo.wanandroid.tv.IHelloManager {
/*/
}
}
public top.guuguo.wanandroid.tv.User getFriend() throws android.os.RemoteException;
public void setFriend(top.guuguo.wanandroid.tv.User friend) throws android.os.RemoteException;
}

可以看到生成了`IHelloManager` 接口，实现`IInterface`。可以看到默认生成了三个该接口的实现类。`Default`，`Stub` 和`Stub.Proxy`。 `Stub` 是一个`Binder`类,是一个实例是服务端对象。`Stub.Proxy` 是`Proxy`的服务端代理类，其中执行方法的时候，调用了服务端的transact方法进行进程间数据交互转换，这两个实现类就是`IHelloManager`的核心类。 看看Stub类的代码：

public static abstract class Stub extends android.os.Binder implements top.guuguo.wanandroid.tv.IHelloManager {
private static final java.lang.String DESCRIPTOR = “top.guuguo.wanandroid.tv.IHelloManager”;
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
public static top.guuguo.wanandroid.tv.IHelloManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof top.guuguo.wanandroid.tv.IHelloManager))) {
return ((top.guuguo.wanandroid.tv.IHelloManager) iin);
}
return new top.guuguo.wanandroid.tv.IHelloManager.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {}
@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
java.lang.String descriptor = DESCRIPTOR;
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(descriptor);
return true;
}
case TRANSACTION_getFriend: {
data.enforceInterface(descriptor);
top.guuguo.wanandroid.tv.User _result = this.getFriend();
reply.writeNoException();
if ((_result != null)) {
reply.writeInt(1);
_result.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
reply.writeInt(0);
}
return true;
}
case TRANSACTION_setFriend: {
data.enforceInterface(descriptor);
top.guuguo.wanandroid.tv.User _arg0;
if ((0 != data.readInt())) {
_arg0 = top.guuguo.wanandroid.tv.User.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.setFriend(_arg0);
reply.writeNoException();
return true;
}
default: {
return super.onTransact(code, data, reply, flags);
}
}
}
static final int TRANSACTION_getFriend = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_setFriend = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
public static boolean setDefaultImpl(top.guuguo.wanandroid.tv.IHelloManager impl) {
if (Stub.Proxy.sDefaultImpl != null) {
throw new IllegalStateException(“setDefaultImpl() called twice”);
}
if (impl != null) {
Stub.Proxy.sDefaultImpl = impl;
return true;
}
return false;
}
public static top.guuguo.wanandroid.tv.IHelloManager getDefaultImpl() {
return Stub.Proxy.sDefaultImpl;
}
}

下面介绍一下`Stub`类中成员的含义：


* #### DESCRIPTOR

Binder的唯一标识，一般是当前Binder的类名。本例是"top.guuguo.wanandroid.tv.IHelloManager"

* #### asInterface(android.os.IBinder obj)


将服务端的Binder对象转换成对应AIDL接口对象。通过`queryLocalInterface`区分进程，如果双端是在同一进程中，返回的对象就是Stub对象，如果是在不同的进程中，则返回其Proxy代理对象。


* #### asBinder


返回当前Binder实例


* #### onTransact


该方法对传输的数据进行序列化和反序列化操作。完整的方法是`public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)`。该方法中，通过code定位客户端所请求的方法是什么，接着从data中取出方法所需的参数，然后执行目标方法，如果目标方法有返回值，向`reply`写入返回结果。 该方法如果返回false，那么客户端的请求就会失败。我们可以在该方法做一些调用限制，避开一些不期望的进程调用该方法。


* #### `Proxy#getFriend` 和`Proxy#setFriend`


这两个代理方法先处理传入参数，将其写入到`Parcel`中，然后调用`mRemote.transact`发起RPC(远程过程调用)请求。同时当前线程挂起，直到RPC过程返回后，再继续执行当前线程，并取出`reply`的返回结果。反序列化后返回数据。


### bindService


通过上面AIDL 及其生成代码的分析，我们知道了AIDL 只是个便于我们快速生成Binder通讯模板代码的方式。我们要在相关组件中使用该Binder进行IPC时，需要通过绑定服务获取`Binder`实例。 下面是绑定服务获取`binder`的相关代码:

val connection = object : ServiceConnection {
override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
“onServiceConnected”.toast()
binder = IHelloManager.Stub.asInterface(service)
}
override fun onServiceDisconnected(name: ComponentName?) {
“onServiceDisconnected”.toast()
}
}
override fun onStart() {
super.onStart()
val intent = Intent(this, HelloService::class.java)
intent.action = “:startHello”
bindService(intent, connection, BIND_AUTO_CREATE)
}
override fun onStop() {
super.onStop()
unbindService(connection)
}

从上面的代码中，我们就可以通过`bindService` 获取`aidl`定义的`Binder`实例。通过该Binder实例，直接就可以对远程进程进行方法调用了。绑定服务具体的流程是什么呢？ 现在看一下整个调用路径


1. 发起绑定服务： `mBase.bindService`
2. 定位到具体的绑定方法：经过查阅`Activity#attach`方法、`ActivityThread#performLaunchActivity`方法和 `createBaseContextForActivity` 方法，得知`mBase`是`ContextImpl`实例。


`mBase.bindService`调用到了`ContextImpl#bindServiceCommon`方法


1. 获取`ActivityManager` Binder代理对象：在`ActivityManager.``*getService*``()` 方法中，从`ServiceManager.getService(Context.ACTIVITY_SERVICE)`获取IBinder实例`(BinderProxy)`
2. 通过 `ActivityManager` 调用`ActivityManagerService`的绑定服务方法，进行绑定服务。


查阅源码和网络搜索中发现，获取`Binder`和`binder`通信原理，涉及到AOSP源码中的`ServiceManager`，`Binder`的 `native C/S`实现等，暂不学习，放到以后针对性得学习aosp中的binder通信机制。对应地，先学习一下[Skytoby]( )大佬的[Binder机制分析文章]( )，了解个大概。 借用作者的Binder机制结构图如下： ![](https://img-blog.csdnimg.cn/img_convert/c276c490aefede66bf631cfa6eb19fb6.webp?x-oss-process=image/format,png)


接下来再看，以及如何手写binder的实现。


### 手写Binder实现类


通过上面的分析，我们大致了解了`Binder`的工作机制。所以我们尝试一下不使用aidl，使用binder进行进程通讯。 基础的实现只需要写三个类就行


1. 定义接口类

interface IActivityManager : IInterface {
fun startActivity(code: Int): String?
}

2. 服务端Binder抽象类，在onTransact 完成远程输送的数据反序列化以及服务端执行任务的工作。

abstract class ActivityManager : Binder(), IActivityManager {
companion object {
val DESCRIPTOR = “top.guuguo.aidltest.IActivityManager”
val CODE_START_ACTIVITY = FIRST_CALL_TRANSACTION + 0
fun asInterface(obj: IBinder?): IActivityManager? {
if (obj == null) return null
return (obj.queryLocalInterface(DESCRIPTOR)
?: Proxy(obj)) as IActivityManager
}
}
override fun asBinder(): IBinder {
return this
}
override fun onTransact(code: Int, data: Parcel, reply: Parcel?, flags: Int): Boolean {
when (code) {
INTERFACE_TRANSACTION -> {
reply?.writeString(DESCRIPTOR);
return true;
}
CODE_START_ACTIVITY -> {
data.enforceInterface(DESCRIPTOR)

尾声

最后，我再重复一次，如果你想成为一个优秀的 Android 开发人员，请集中精力，对基础和重要的事情做深度研究。

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。 整理的这些架构技术希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

最后想要拿高薪实现技术提升薪水得到质的飞跃。最快捷的方式，就是有人可以带着你一起分析，这样学习起来最为高效，所以为了大家能够顺利进阶中高级、架构师，我特地为大家准备了一套高手学习的源码和框架视频等精品Android架构师教程，保证你学了以后保证薪资上升一个台阶。

当你有了学习线路，学习哪些内容，也知道以后的路怎么走了，理论看多了总要实践的。

进阶学习视频

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题 （含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

[外链图片转存中…(img-aLSEtjv2-1713437230003)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-G8J6AjqB-1713437230003)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！