背景

今天完成了 王小二图解Android【010】Binder应用篇的直播，说实话这次我只能给自己打一个59分数。回去我在不断思考，最后觉得这个Binder培训就根本不应该采用1对多的培训模式，其实我在昨晚就给一个毕业半年左右的网友一对一的试讲过，中途我们会不断地交流，给他补了很多知识，最后效果我觉得有85分。
但是今天一整天我一直心有不甘，我觉得还是有必要为自己今天的直播课上一个补课。

一、如何理解抽象的一次Binder通信

一次BinderProxy和Binder之前的Binder通信，可以用如下图更好的抽象表示。

表象来看
BinderProxy的transact方法调用会通过Binder驱动触发调用Binder的onTransact方法。

但是底层的运行逻辑有两次数据流的传递
红色流程
1.BinderProxy创建一个容器data，将要传递给Binder的数据，打包进这个容器
2.BinderProxy将容器data传递给Binder驱动
3.Binder驱动将容器data传递给Binder
4.Binder解包容器data中的数据，进行逻辑处理
蓝色流程
5.Binder创建一个容器reply，将要传递给BinderProxy的数据，打包进这个容器
6.Binder将容器reply传递给Binder驱动
7.Binder驱动将容器reply传递给BinderProxy
8.BinderProxy解包容器reply中的数据，进行逻辑处理。

细心的你发现了，一次BinderProxy和Binder通信其实有两次数据流，而且1-4和5-8本质上没有区别，事实上Binder驱动底层将1-4和5-8称作一次Binder事务，也就说其实一次Binder通信包含两次Binder事务，而且你会发现这个逻辑的能力远远大于RPC的能力。

思考一下，如何实现Binder通信中的Binder远端Exception，最终反馈到BinderProxy这边
答案：Binder将Exception通过reply传递给BinderProxy，BinderProxy解析，然后再throw出来。

每一次Binder事务，其实就包含了一次序列化（writeToParcel）和反序列化（readFromParcel），然后再配合我[084]Binder答疑解惑（二）中对序列化中理解，请把以下这句话读三遍

IBinder对象（Binder或者BinderProxy）在打包到data或者reply之后，另外一端从Binder驱动中获取data或者reply之后，
解包获得是Binder对象或者BinderProxy对象。

二、传送门传递传送门

我今天一直在想用什么例子来解释，Binder通信传递Binder对象，再用Binder对象进行通信，我后来就想到了机器猫中的传送门。

Binder或者BinderProxy就是传递门IBinder
传送门都是成对出现的类似于Binder-BinderProxy
成对的传送门之间可以传递东西，也就是Binder和BinderProxy可以Binder通信
成对的传送门之间还可以传递传送门，也就是Binder通信可以传递Binder或者BinderProxy

接下来我用新的Demo展现，Demo很简单就两个类

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        init();
    }

    private IBinder binder2 = new Binder() {
        @Override
        protected boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
            Log.v("Kobe", "binder2.onTransact");
            return true;
        }
    };

    private void init() {
        Intent intent = new Intent(this, MyService.class);
        this.bindService(intent, new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName name, IBinder service) {
                IBinder binder1 = service;
                Parcel data = Parcel.obtain();
                data.writeStrongBinder(binder2);
                Parcel reply = Parcel.obtain();//暂不使用
                try {
                    Log.v("Kobe", "binder1.transact");
                    binder1.transact(1, data, reply, 0);
                } catch (RemoteException e) {
                    throw new RuntimeException(e);
                }
                IBinder binder3 = reply.readStrongBinder();
                Parcel data3 = Parcel.obtain();
                Parcel reply3 = Parcel.obtain();
                try {
                    Log.v("Kobe", "binder3.transact");
                    binder3.transact(1, data3, reply3, 0);
                } catch (RemoteException e) {
                    throw new RuntimeException(e);
                }
            }

            @Override
            public void onServiceDisconnected(ComponentName name) {

            }
        }, Context.BIND_AUTO_CREATE);
    }
}

    private IBinder binder1 = new Binder() {
        @Override
        protected boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
            Log.v("Kobe", "binder1.onTransact");
            reply.writeStrongBinder(binder3);
            IBinder binder2 = data.readStrongBinder();
            Parcel data2 = Parcel.obtain();
            Parcel reply2 = Parcel.obtain();//暂不使用
            Log.v("Kobe", "binder2.transact");
            binder2.transact(1, data2, reply2, 0);
            return true;
        }
    };

    private IBinder binder3 = new Binder() {
        @Override
        protected boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
            Log.v("Kobe", "binder3.onTransact");
            return super.onTransact(code, data, reply, flags);
        }
    };


    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return binder1;
    }
}

运行的结果如下

11-19 08:44:52.137 14139 14139 V Kobe    : binder1.transact
11-19 08:44:52.138 14163 14179 V Kobe    : binder1.onTransact
11-19 08:44:52.139 14163 14179 V Kobe    : binder2.transact
11-19 08:44:52.140 14139 14139 V Kobe    : binder2.onTransact
11-19 08:44:52.146 14139 14139 V Kobe    : binder3.transact
11-19 08:44:52.149 14163 14178 V Kobe    : binder3.onTransact

希望大家从onServiceConnected这个代码开始按照上图1中表示的一次Binder通信的抽象流程，解读一下我的每一行代码，我这里就不解读了。

我把代码上传了github，大家可以下载一下运行一下，这里每个例子就是经典例子。
https://github.com/kobewang126/Binder2023

总结

我估计接下来不会出图解Binder系列驱动篇或者Framework，因为我今天讲的应用篇其实只占了整个Binder框架知识的10%左右，但是为了给只有应用开发基础的人，讲明白这些知识，我费了很大的精力，关键效果还不好，如果继续往下讲，结果可想而知。
而且我犯了一个很重大的错误，就是之前的所有图解Android系列，都是在运行本质上抽象的理解，但是Binder为了让你用起来像函数调用一样，其实对运行的本质做了很多的封装，我直接讲运行的本质抽象，对于你而言，完全无法和你使用的Binder API的体验对应起来，所以这个东西就很难讲。
Binder更好的教学的方式就是采用1对1，针对你现有对Binder的理解，不断给你深入讲解Binder，然后自己消化，理解，巩固，然后继续深入的学习。

尾巴

人类所有的知识的学习都是建立在现有的知识之上，这个学习过程不能跳跃太大，一旦跳跃过大，就很容易一脸懵逼了。