前言
本故事纯属虚构,如有不通顺的逻辑请轻喷。❤️
《犬夜叉2021》
第一章:我还能找到你吗,阿篱
犬夜叉和奈落大决战之后,四魂之玉、食骨之井消失,谁也不知道去了哪,而犬夜叉和阿篱再次被分割到两个世界。
于是犬夜叉拜托一位研究世界宇宙的法师——积木,来帮助他找到阿篱。
时间转眼来到了2021年,积木终于发现了这个世界的秘密。。
其实我们所在的整个宇宙叫做Android宇宙,犬夜叉和阿篱所处的两个世界其实是两个进程,两个世界可以通过食骨之井相连接。
所以想让犬夜叉重新联系到阿篱,必须再找到当年的食骨之井。
第二章:食骨之井改名Binder井?
“犬夜叉,我终于找到了”
“找到什么了?是阿篱吗?阿篱找到了????”
“没有,不过我找到了关键的东西——食骨之井”
“在哪,快带我去”
于是,积木法师带着犬夜叉来到一间屋子里:
这间屋子门面上写着《内核屋》
三个大字,犬夜叉一个箭步飞了进去,在里面果然找到了当年那个食骨之井
,但是又有点不一样,因为它被改了名,旁边一个破碎的板子上写着——Binder井
。板子上还同时刻有使用说明:
Binder井
这口井联系这两个世界,你看到的也许不是真实的,请慎用!
如需使用,请找到当年遗落的四魂之玉,现在它叫SM之玉(ServiceManager)
。
找到SM之玉,心里默念你想联系的那个世界那个人,如果她在那个世界的SM之玉碎片中留下了地址,那么你就能找到她。
“积木法师,你知道SM之玉吗,哪里可以找到它”,犬夜叉问到。
第三章:四魂之玉——ServiceManager
“说到SM之玉,还要从宇宙的起源说起,Android宇宙创建初期,诞生了第一个有人的世界(用户进程),叫做Init世界
,而SM之玉就是由这个世界创建的。
SM之玉创建后,启动了Binder井
,成为了他的守护神。
但是它的真身存在于单独的世界中,无法获得。为了让人们能够使用到它,它特意在每个世界都留下了自己的碎片(代理)。”
“在哪在哪,快告诉我”。
“第0街道(句柄值固定为0)”,积木法师指了一个方向说到。
第四章:阿篱,我想你了
犬夜叉急忙去第0街道找到了SM之玉的碎片,然后回到Binder井
旁边,心里默念道:
“
SM之玉,
求求你帮我找到阿篱吧。
”
忽然,Binder
井刮出一阵狂风,一个虚影出现在了犬夜叉的面前。
是阿篱~
“阿篱,你能听到我说话吗?”
“犬夜叉,我能听到,没想到还能看到你”,阿篱的虚影说到。
“我想你了,阿篱...”
故事End
故事结束了。
再帮大家理一下故事梗概,其实也就是Binder
的工作流程:
- 阿篱(服务端) 为了让犬夜叉(客户端) 找到她,在四魂之玉(ServiceManager) 上留下了他们世界(进程) 的地址。
- 犬夜叉在第0街道(句柄为0) 找到了四魂之玉碎片(ServiceManager代理)。
- 通过四魂之玉碎片,犬夜叉看到了阿篱的虚影(服务端代理),并通过虚影告诉了阿篱,想她了(通信)。
当然,故事毕竟是故事,并不能完全说清楚。
所以下面就完整看看Binder
的工作流程和原理~
代码实现犬夜叉的需求
首先,我们使用AIDL
来实现刚才故事中的场景——让犬夜叉和阿篱两个不同进程的人说上话:
//IMsgManager.aidl
interface IMsgManager {
String getMsg();
void tell(in String msg);
}
//阿篱
public class AliWorldService extends Service {
private static final String TAG = "lz1";
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
private Binder mBinder = new IMsgManager.Stub() {
@Override
public String getMsg() throws RemoteException {
String tellMsg="犬夜叉...是我";
Log.e(TAG, "阿篱:" + tellMsg);
return tellMsg;
}
@Override
public void tell(String msg) throws RemoteException {
Log.e(TAG, "我是阿篱,我收到了你说的:" + msg);
}
};
}
<service
android:name=".binder.AliWorldService"
android:process=":aliworld">
</service>
//犬夜叉
public class QycWorldActivity extends Activity {
private static final String TAG = "lz1";
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_qyc);
Intent i = new Intent(this, AliWorldService.class);
bindService(i, mConnection, Context.BIND_AUTO_CREATE);
}
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
IMsgManager msgManager = IMsgManager.Stub.asInterface(service);
try {
String tellMsg="阿篱,是你吗";
Log.e(TAG, "犬夜叉:" + tellMsg);
msgManager.tell(tellMsg);
String msg = msgManager.getMsg();
Log.e(TAG, "我是犬夜叉,我收到了你说的:" + msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onDestroy() {
super.onDestroy();
unbindService(mConnection);
}
}
运行,打印结果:
E/lz1: 犬夜叉:阿篱,是你吗
E/lz1: 我是阿篱,我收到了你说的:阿篱,是你吗
E/lz1: 阿篱:犬夜叉...是我
E/lz1: 我是犬夜叉,我收到了你说的:犬夜叉...是我
AIDL原理
代码比较简单,服务器端新建一个Binder
对象并传到onBind
方法中,客户端bindservice
之后,获取到服务端的代理接口,就可以进行方法的调用了。
AIDL
其实只是一个帮助我们实现进程间通信的工具,它会根据我们写的AIDL
文件代码,生成相应的java
接口代码,其内部也是通过Binder
实现的。
我们可以通过build——generated——aidl_source_output_dir——debug——out
文件路径找到AIDL为我们生成的接口类。代码如下:
public interface IMsgManager extends android.os.IInterface {
public static abstract class Stub extends android.os.Binder implements com.example.studynote.binder.IMsgManager {
//1
private static final java.lang.String DESCRIPTOR = "com.example.studynote.binder.IMsgManager";
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
//2
public static com.example.studynote.binder.IMsgManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.example.studynote.binder.IMsgManager))) {
return ((com.example.studynote.binder.IMsgManager) iin);
}
return new com.example.studynote.binder.IMsgManager.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
//4
@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_getMsg: {
data.enforceInterface(descriptor);
java.lang.String _result = this.getMsg();
reply.writeNoException();
reply.writeString(_result);
return true;
}
case TRANSACTION_tell: {
data.enforceInterface(descriptor);
java.lang.String _arg0;
_arg0 = data.readString();
this.tell(_arg0);
reply.writeNoException();
return true;
}
default: {
return super.onTransact(code, data, reply, flags);
}
}
}
private static class Proxy implements com.example.studynote.binder.IMsgManager {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
//3
@Override
public java.lang.String getMsg() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.lang.String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getMsg, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void tell(java.lang.String msg) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(msg);
mRemote.transact(Stub.TRANSACTION_tell, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_getMsg = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_tell = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public java.lang.String getMsg() throws android.os.RemoteException;
public void tell(java.lang.String msg) throws android.os.RemoteException;
}
代码比较长,我们依次来分析下:
DESCRIPTOR
。Binder的唯一标示。
在Stub类的构造方法中,就是通过attachInterface
方法将当前的Binder和这个唯一标示进行了绑定。
asInterface()
。将服务端的Binder对象转换成客户端所需的接口类型对象。
这个方法是客户端调用的,在这个方法中,会通过queryLocalInterface(DESCRIPTOR)
方法,传入唯一标示,来获取对应的Binder。
如果是服务端和客户端在同一个进程,那么就会返回服务端的Binder对象,也就是Stub对象本身,然后就直接调用对象的方法了。
如果在不同进程,也就是我们一般的跨进程情况,就会返回封装后的Stub.Proxy这个代理对象。
Proxy.getMsg/tell
接着就看看代理类里面的方法,也就是我们在客户端(Activity)中实际调用的方法。
这其中有两个比较重要的对象 :_data对象
和 _reply
对象,都是Parcel
类型的,这里会对数据进行一个序列化操作,这样才能进行跨进程传输。
如果方法传有参数,就会把参数写到_data对象
,然后调用transact方法
发起远程调用请求(RPC),同时当前线程挂起,等待服务端执行完请求。
mRemote.transact(Stub.TRANSACTION_getMsg, _data, _reply, 0);
可以看到,传入了一个int类型的code——TRANSACTION_getMsg
,这个code其实就是为了要确定调用的是哪个方法。
等请求结束后,当前线程继续,会从_reply
对象中取出返回结果。
整个IPC流程就结束了。那服务器到底是在哪里进行任务执行的呢?继续看onTransact方法。
onTransact
onTransact
方法就是服务端要做的事了,运行在服务端的Binder线程池
中。
当客户端发起远程调用请求后,会通过系统底层封装,其实也就是内核层的Binder
驱动,然后交给服务端的onTransact
方法。
在该方法中,首先通过code
知晓是哪个方法,然后就执行目标方法,并将序列化结果写到reply
中,RPC过程结束,交给客户端处理。
case TRANSACTION_getMsg: {
data.enforceInterface(descriptor);
java.lang.String _result = this.getMsg();
reply.writeNoException();
reply.writeString(_result);
return true;
}
最后画张图总结下AIDL整个流程:
Binder
经过了上述AIDL的例子,大家是不是对Binder又进一步了解了呢?
在java层面,其实Binder
就是一个实现了IBinder
接口的类。
真正跨进程的部分还是在客户端发起远程调用请求之后,系统底层封装好,交给服务端的时候。而这个系统底层封装,其实就是发生在Linux内核
中。
而在内核中完成这个通信关键功能的还是Binder
,这次不是Binder
类了,而是Binder驱动
。
驱动你可以理解为一种硬件接口,可以帮助操作系统来控制硬件设备。
Binder驱动
被添加运行到Linux内核空间
,这样,两个不同进程就可以通过访问内核空间来完成数据交换:把数据传给Binder驱动
,然后处理好再交给对方进程,完成跨进程通信。
而刚才通过AIDL
的例子我们可以知道,客户端在请求服务端通信的时候,并不是直接和服务端的某个对象联系,而是用到了服务端的一个代理对象,通过对这个代理对象操作,然后代理类会把方法对应的code、传输的序列化数据、需要返回的序列化数据
交给底层,也就是Binder驱动。(这也解释了为什么犬夜叉看到的是阿篱的虚影,而不是真身
文章来源: 博客园
- 还没有人评论,欢迎说说您的想法!