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

最新推荐文章于 2024-05-13 14:25:33 发布

2401_84544363

最新推荐文章于 2024-05-13 14:25:33 发布

阅读量710

点赞数 5

分类专栏：程序员文章标签： android 学习 binder

本文链接：https://blog.csdn.net/2401_84544363/article/details/138273396

版权

程序员专栏收录该内容

174 篇文章 0 订阅

订阅专栏

 * 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)
reply?.writeNoException()
reply?.writeString(startActivity(data.readInt()))
return true
}
}
return super.onTransact(code, data, reply, flags)
}
}


3. 客户端代理类(完成数据的序列化反序列化工作，具体交给代理的对象完成)

class Proxy(val remote: IBinder) : ActivityManager() {
    override fun startActivity(code: Int): String? {
        val params = Parcel.obtain()
        val reply = Parcel.obtain()
        params.writeInterfaceToken(DESCRIPTOR)
        params.writeInt(code)
        remote.transact(CODE_START_ACTIVITY, params, reply, 0)
        reply.readException()
        val str = reply.readString()
        params.recycle()
        reply.recycle()
        return str
    }
    override fun getInterfaceDescriptor(): String? {
       return DESCRIPTOR
    }
    override fun asBinder(): IBinder {
        return remote
    }
}


通过`InterfaceToken`标记,完成服务端和客户端相关工作。 在具体使用的时候，实现ActivityManager，完成服务端的任务自定义实现如下:

inner class HelloManagerImpl : ActivityManager() {
override fun startActivity(code: Int): String? {
return “progress:” + getProcessName(baseContext)
}
}


完成了编写，同样地通过`bindService` 就可以绑定服务获取Binder进行进程间通讯了。 调用例子中的 `binder?.startActivity(1)` 便可以获取到对应的字符串结果。


## 完结


Binder的使用方式大概学习了一遍，也手写了模拟`ActivityManagerService`的Binder实现。大概了解了如何通过Binder来进行进程间通讯。 同样的，安卓系统中利用Binder对外提供服务的例子比比皆是，安卓通过`ServiceManager` 提供了比如`PackageManagerService` `WindowsManagerService`等服务。如果了解了这些框架层的实现，对于我们的开发之路将会很有帮助。 了解Binder使用是个起步，接下来朝着进阶出发。


**如果你还没有掌握Framework，现在想要在最短的时间里吃透它，可以参考一下[《Android Framework核心知识点》]( )，里面内容包含了：Init、Zygote、SystemServer、Binder、Handler、AMS、PMS、Launcher……等知识点记录。**


#### **《Framework 核心知识点汇总手册》**:[`https://qr18.cn/AQpN4J`]( )


**Handler 机制实现原理部分：**  
 1.宏观理论分析与Message源码分析  
 2.MessageQueue的源码分析  
 3.Looper的源码分析  
 4.handler的源码分析  
 5.总结


![](https://img-blog.csdnimg.cn/img_convert/c8b3e9c3184f053650c41a01ba82f25a.webp?x-oss-process=image/format,png)


**Binder 原理：**  
 1.学习Binder前必须要了解的知识点  
 2.ServiceManager中的Binder机制  
 3.系统服务的注册过程  
 4.ServiceManager的启动过程  
 5.系统服务的获取过程  
 6.Java Binder的初始化  
 7.Java Binder中系统服务的注册过程


![](https://img-blog.csdnimg.cn/img_convert/96a959886ed5b54fc4eb705ca6d898bf.webp?x-oss-process=image/format,png)


**Zygote ：**


1. Android系统的启动过程及Zygote的启动过程
2. 应用进程的启动过程


![](https://img-blog.csdnimg.cn/img_convert/3affffe3aa14dff42acb6f6da5b6066a.webp?x-oss-process=image/format,png)


**AMS源码分析 ：**


1. Activity生命周期管理
2. onActivityResult执行过程
3. AMS中Activity栈管理详解


![](https://img-blog.csdnimg.cn/img_convert/f27fc62fea875e1f994e74b29991b4cb.webp?x-oss-process=image/format,png)


**深入PMS源码：**


1.PMS的启动过程和执行流程  
 2.APK的安装和卸载源码分析  
 3.PMS中intent-filter的匹配架构



## 最后

Android学习是一条漫长的道路，我们要学习的东西不仅仅只有表面的 技术，还要深入底层，弄明白下面的 原理，只有这样，我们才能够提高自己的竞争力，在当今这个竞争激烈的世界里立足。

**人生不可能一帆风顺，有高峰自然有低谷，要相信，那些打不倒我们的，终将使我们更强大，要做自己的摆渡人。**

资源持续更新中，欢迎大家一起学习和探讨。



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

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618156601)**

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

2401_84544363

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Android Framework——进程间通讯学习，从Binder使用看起_activitymanager binder transaction(1)

【代码】Android Framework——进程间通讯学习，从Binder使用看起_activitymanager binder transaction(1)
复制链接

扫一扫