AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Android aidl Binder框架浅析

2017-11-16 956
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

1、概述

Binder能干什么？Binder可以提供系统中任何程序都可以访问的全局服务。这个功能当然是任何系统都应该提供的，下面我们简单看一下Android的Binder的框架

Android Binder框架分为服务器接口、Binder驱动、以及客户端接口；简单想一下，需要提供一个全局服务，那么全局服务那端即是服务器接口，任何程序即客户端接口，它们之间通过一个Binder驱动访问。

服务器端接口：实际上是Binder类的对象，该对象一旦创建，内部则会启动一个隐藏线程，会接收Binder驱动发送的消息，收到消息后，会执行Binder对象中的onTransact()函数，并按照该函数的参数执行不同的服务器端代码。

Binder驱动：该对象也为Binder类的实例，客户端通过该对象访问远程服务。

客户端接口：获得Binder驱动，调用其transact()发送消息至服务器

如果大家对上述不了解，没关系，下面会通过例子来更好的说明，实践是检验真理的唯一标准嘛

2、AIDL的使用

如果对Android比较熟悉，那么一定使用过AIDL，如果你还不了解，那么也没关系，下面会使用一个例子展示AIDL的用法。

我们使用AIDL实现一个跨进程的加减法调用

1、服务端

新建一个项目，创建一个包名：com.zhy.calc.aidl，在包内创建一个ICalcAIDL文件：

[java]  view plain  copy
  1. package com.zhy.calc.aidl;  
  2. interface ICalcAIDL  
  3. {  
  4.     int add(int x , int y);  
  5.     int min(int x , int y );  
  6. }  


注意，文件名为ICalcAIDL.aidl

然后在项目的gen目录下会生成一个ICalcAIDL.Java文件，暂时不贴这个文件的代码了，后面会详细说明

然后我们在项目中新建一个Service，代码如下：

[java]  view plain  copy
  1. package com.example.zhy_binder;  
  2.   
  3. import com.zhy.calc.aidl.ICalcAIDL;  
  4.   
  5. import android.app.Service;  
  6. import android.content.Intent;  
  7. import android.os.IBinder;  
  8. import android.os.RemoteException;  
  9. import android.util.Log;  
  10.   
  11. public class CalcService extends Service  
  12. {  
  13.     private static final String TAG = "server";  
  14.   
  15.     public void onCreate()  
  16.     {  
  17.         Log.e(TAG, "onCreate");  
  18.     }  
  19.   
  20.     public IBinder onBind(Intent t)  
  21.     {  
  22.         Log.e(TAG, "onBind");  
  23.         return mBinder;  
  24.     }  
  25.   
  26.     public void onDestroy()  
  27.     {  
  28.         Log.e(TAG, "onDestroy");  
  29.         super.onDestroy();  
  30.     }  
  31.   
  32.     public boolean onUnbind(Intent intent)  
  33.     {  
  34.         Log.e(TAG, "onUnbind");  
  35.         return super.onUnbind(intent);  
  36.     }  
  37.   
  38.     public void onRebind(Intent intent)  
  39.     {  
  40.         Log.e(TAG, "onRebind");  
  41.         super.onRebind(intent);  
  42.     }  
  43.   
  44.     private final ICalcAIDL.Stub mBinder = new ICalcAIDL.Stub()  
  45.     {  
  46.   
  47.         @Override  
  48.         public int add(int x, int y) throws RemoteException  
  49.         {  
  50.             return x + y;  
  51.         }  
  52.   
  53.         @Override  
  54.         public int min(int x, int y) throws RemoteException  
  55.         {  
  56.             return x - y;  
  57.         }  
  58.   
  59.     };  
  60.   
  61. }  

在此Service中，使用生成的ICalcAIDL创建了一个mBinder的对象，并在Service的onBind方法中返回

最后记得在AndroidManifest中注册

[html]  view plain  copy
  1. <service android:name="com.example.zhy_binder.CalcService" >  
  2.            <intent-filter>  
  3.                <action android:name="com.zhy.aidl.calc" />  
  4.   
  5.                <category android:name="android.intent.category.DEFAULT" />  
  6.            </intent-filter>  
  7.        </service>  


这里我们指定了一个name，因为我们一会会在别的应用程序中通过Intent来查找此Service；这个不需要Activity，所以我也就没写Activity，安装完成也看不到安装图标，悄悄在后台运行着。

到此，服务端编写完毕。下面开始编写客户端

2、客户端

客户端的代码比较简单，创建一个布局，里面包含4个按钮，分别为绑定服务，解除绑定，调用加法，调用减法

布局文件：

[html]  view plain  copy
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     xmlns:tools="http://schemas.android.com/tools"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical" >  
  6.   
  7.     <Button  
  8.         android:layout_width="fill_parent"  
  9.         android:layout_height="wrap_content"  
  10.         android:onClick="bindService"  
  11.         android:text="BindService" />  
  12.   
  13.     <Button  
  14.         android:layout_width="fill_parent"  
  15.         android:layout_height="wrap_content"  
  16.         android:onClick="unbindService"  
  17.         android:text="UnbindService" />  
  18.   
  19.     <Button  
  20.         android:layout_width="fill_parent"  
  21.         android:layout_height="wrap_content"  
  22.         android:onClick="addInvoked"  
  23.         android:text="12+12" />  
  24.   
  25.     <Button  
  26.         android:layout_width="fill_parent"  
  27.         android:layout_height="wrap_content"  
  28.         android:onClick="minInvoked"  
  29.         android:text="50-12" />  
  30.   
  31. </LinearLayout>  


主Activity

[java]  view plain  copy
  1. package com.example.zhy_binder_client;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.os.Bundle;  
  9. import android.os.IBinder;  
  10. import android.util.Log;  
  11. import android.view.View;  
  12. import android.widget.Toast;  
  13.   
  14. import com.zhy.calc.aidl.ICalcAIDL;  
  15.   
  16. public class MainActivity extends Activity  
  17. {  
  18.     private ICalcAIDL mCalcAidl;  
  19.   
  20.     private ServiceConnection mServiceConn = new ServiceConnection()  
  21.     {  
  22.         @Override  
  23.         public void onServiceDisconnected(ComponentName name)  
  24.         {  
  25.             Log.e("client", "onServiceDisconnected");  
  26.             mCalcAidl = null;  
  27.         }  
  28.   
  29.         @Override  
  30.         public void onServiceConnected(ComponentName name, IBinder service)  
  31.         {  
  32.             Log.e("client", "onServiceConnected");  
  33.             mCalcAidl = ICalcAIDL.Stub.asInterface(service);  
  34.         }  
  35.     };  
  36.   
  37.     @Override  
  38.     protected void onCreate(Bundle savedInstanceState)  
  39.     {  
  40.         super.onCreate(savedInstanceState);  
  41.         setContentView(R.layout.activity_main);  
  42.   
  43.     }  
  44.       
  45.     /** 
  46.      * 点击BindService按钮时调用 
  47.      * @param view 
  48.      */  
  49.     public void bindService(View view)  
  50.     {  
  51.         Intent intent = new Intent();  
  52.         intent.setAction("com.zhy.aidl.calc");  
  53.         bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE);  
  54.     }  
  55.     /** 
  56.      * 点击unBindService按钮时调用 
  57.      * @param view 
  58.      */  
  59.     public void unbindService(View view)  
  60.     {  
  61.         unbindService(mServiceConn);  
  62.     }  
  63.     /** 
  64.      * 点击12+12按钮时调用 
  65.      * @param view 
  66.      */  
  67.     public void addInvoked(View view) throws Exception  
  68.     {  
  69.   
  70.         if (mCalcAidl != null)  
  71.         {  
  72.             int addRes = mCalcAidl.add(12, 12);  
  73.             Toast.makeText(this, addRes + "", Toast.LENGTH_SHORT).show();  
  74.         } else  
  75.         {  
  76.             Toast.makeText(this, "服务器被异常杀死，请重新绑定服务端", Toast.LENGTH_SHORT)  
  77.                     .show();  
  78.   
  79.         }  
  80.   
  81.     }  
  82.     /** 
  83.      * 点击50-12按钮时调用 
  84.      * @param view 
  85.      */  
  86.     public void minInvoked(View view) throws Exception  
  87.     {  
  88.   
  89.         if (mCalcAidl != null)  
  90.         {  
  91.             int addRes = mCalcAidl.min(58, 12);  
  92.             Toast.makeText(this, addRes + "", Toast.LENGTH_SHORT).show();  
  93.         } else  
  94.         {  
  95.             Toast.makeText(this, "服务端未绑定或被异常杀死，请重新绑定服务端", Toast.LENGTH_SHORT)  
  96.                     .show();  
  97.   
  98.         }  
  99.   
  100.     }  
  101.   
  102. }  

很标准的绑定服务的代码。

直接看运行结果：

我们首先点击BindService按钮，查看log

[html]  view plain  copy
  1. 08-09 22:56:38.959: E/server(29692): onCreate  
  2. 08-09 22:56:38.959: E/server(29692): onBind  
  3. 08-09 22:56:38.959: E/client(29477): onServiceConnected  

可以看到，点击BindService之后，服务端执行了onCreate和onBind的方法，并且客户端执行了onServiceConnected方法，标明服务器与客户端已经联通

然后点击12+12，50-12可以成功的调用服务端的代码并返回正确的结果

下面我们再点击unBindService

[html]  view plain  copy
  1. 08-09 22:59:25.567: E/server(29692): onUnbind  
  2. 08-09 22:59:25.567: E/server(29692): onDestroy  

由于我们当前只有一个客户端绑定了此Service，所以Service调用了onUnbind和onDestory

然后我们继续点击12+12，50-12，通过上图可以看到，依然可以正确执行，也就是说即使onUnbind被调用，连接也是不会断开的，那么什么时候会端口呢？

即当服务端被异常终止的时候，比如我们现在在手机的正在执行的程序中找到该服务：

点击停止，此时查看log

[html]  view plain  copy
  1. 08-09 23:04:21.433: E/client(30146): onServiceDisconnected  

可以看到调用了onServiceDisconnected方法，此时连接被断开，现在点击12+12，50-12的按钮，则会弹出Toast服务端断开的提示。

说了这么多，似乎和Binder框架没什么关系，下面我们来具体看一看AIDL为什么做了些什么。

3、分析AIDL生成的代码

 

1、服务端

先看服务端的代码，可以看到我们服务端提供的服务是由

[java]  view plain  copy
  1. private final ICalcAIDL.Stub mBinder = new ICalcAIDL.Stub()  
  2.     {  
  3.   
  4.         @Override  
  5.         public int add(int x, int y) throws RemoteException  
  6.         {  
  7.             return x + y;  
  8.         }  
  9.   
  10.         @Override  
  11.         public int min(int x, int y) throws RemoteException  
  12.         {  
  13.             return x - y;  
  14.         }  
  15.   
  16.     };  


ICalcAILD.Stub来执行的，让我们来看看Stub这个类的声明：

[java]  view plain  copy
  1. public static abstract class Stub extends android.os.Binder implements com.zhy.calc.aidl.ICalcAIDL  


清楚的看到这个类是Binder的子类，是不是符合我们文章开通所说的服务端其实是一个Binder类的实例

接下来看它的onTransact()方法：

[java]  view plain  copy
  1. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  2. {  
  3. switch (code)  
  4. {  
  5. case INTERFACE_TRANSACTION:  
  6. {  
  7. reply.writeString(DESCRIPTOR);  
  8. return true;  
  9. }  
  10. case TRANSACTION_add:  
  11. {  
  12. data.enforceInterface(DESCRIPTOR);  
  13. int _arg0;  
  14. _arg0 = data.readInt();  
  15. int _arg1;  
  16. _arg1 = data.readInt();  
  17. int _result = this.add(_arg0, _arg1);  
  18. reply.writeNoException();  
  19. reply.writeInt(_result);  
  20. return true;  
  21. }  
  22. case TRANSACTION_min:  
  23. {  
  24. data.enforceInterface(DESCRIPTOR);  
  25. int _arg0;  
  26. _arg0 = data.readInt();  
  27. int _arg1;  
  28. _arg1 = data.readInt();  
  29. int _result = this.min(_arg0, _arg1);  
  30. reply.writeNoException();  
  31. reply.writeInt(_result);  
  32. return true;  
  33. }  
  34. }  
  35. return super.onTransact(code, data, reply, flags);  
  36. }  


文章开头也说到服务端的Binder实例会根据客户端依靠Binder驱动发来的消息，执行onTransact方法，然后由其参数决定执行服务端的代码。

可以看到onTransact有四个参数

code ， data ，replay ， flags

code 是一个整形的唯一标识，用于区分执行哪个方法，客户端会传递此参数，告诉服务端执行哪个方法

data客户端传递过来的参数

replay服务器返回回去的值

flags标明是否有返回值，0为有（双向），1为没有（单向）

我们仔细看case TRANSACTION_min中的代码

data.enforceInterface(DESCRIPTOR);与客户端的writeInterfaceToken对用，标识远程服务的名称

int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();

接下来分别读取了客户端传入的两个参数

int _result = this.min(_arg0, _arg1);
reply.writeNoException();
reply.writeInt(_result);

然后执行this.min，即我们实现的min方法；返回result由reply写回。

add同理，可以看到服务端通过AIDL生成Stub的类，封装了服务端本来需要写的代码。

2、客户端

客户端主要通过ServiceConnected与服务端连接

[java]  view plain  copy
  1. private ServiceConnection mServiceConn = new ServiceConnection()  
  2.     {  
  3.         @Override  
  4.         public void onServiceDisconnected(ComponentName name)  
  5.         {  
  6.             Log.e("client", "onServiceDisconnected");  
  7.             mCalcAidl = null;  
  8.         }  
  9.   
  10.         @Override  
  11.         public void onServiceConnected(ComponentName name, IBinder service)  
  12.         {  
  13.             Log.e("client", "onServiceConnected");  
  14.             mCalcAidl = ICalcAIDL.Stub.asInterface(service);  
  15.         }  
  16.     };  


如果你比较敏锐，应该会猜到这个onServiceConnected中的IBinder实例，其实就是我们文章开通所说的Binder驱动，也是一个Binder实例

在ICalcAIDL.Stub.asInterface中最终调用了：

[java]  view plain  copy
  1. return new com.zhy.calc.aidl.ICalcAIDL.Stub.Proxy(obj);  


这个Proxy实例传入了我们的Binder驱动，并且封装了我们调用服务端的代码，文章开头说，客户端会通过Binder驱动的transact()方法调用服务端代码

直接看Proxy中的add方法

[java]  view plain  copy
  1. @Override public int add(int x, int y) throws android.os.RemoteException  
  2. {  
  3. android.os.Parcel _data = android.os.Parcel.obtain();  
  4. android.os.Parcel _reply = android.os.Parcel.obtain();  
  5. int _result;  
  6. try {  
  7. _data.writeInterfaceToken(DESCRIPTOR);  
  8. _data.writeInt(x);  
  9. _data.writeInt(y);  
  10. mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);  
  11. _reply.readException();  
  12. _result = _reply.readInt();  
  13. }  
  14. finally {  
  15. _reply.recycle();  
  16. _data.recycle();  
  17. }  
  18. return _result;  
  19. }  


首先声明两个Parcel对象，一个用于传递数据，一个用户接收返回的数据

_data.writeInterfaceToken(DESCRIPTOR);与服务器端的enforceInterfac对应

_data.writeInt(x);
_data.writeInt(y);写入需要传递的参数

mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);

终于看到了我们的transact方法，第一个对应服务端的code,_data,_repay分别对应服务端的data，reply，0表示是双向的

_reply.readException();
_result = _reply.readInt();

最后读出我们服务端返回的数据，然后return。可以看到和服务端的onTransact基本是一行一行对应的。

到此，我们已经通过AIDL生成的代码解释了Android Binder框架的工作原理。Service的作用其实就是为我们创建Binder驱动，即服务端与客户端连接的桥梁。

AIDL其实通过我们写的aidl文件，帮助我们生成了一个接口，一个Stub类用于服务端，一个Proxy类用于客户端调用。那么我们是否可以不通过写AIDL来实现远程的通信呢？下面向大家展示如何完全不依赖AIDL来实现客户端与服务端的通信。

4、不依赖AIDL实现程序间通讯

 

1、服务端代码

我们新建一个CalcPlusService.java用于实现两个数的乘和除

[java]  view plain  copy
  1. package com.example.zhy_binder;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.Binder;  
  6. import android.os.IBinder;  
  7. import android.os.Parcel;  
  8. import android.os.RemoteException;  
  9. import android.util.Log;  
  10.   
  11. public class CalcPlusService extends Service  
  12. {  
  13.     private static final String DESCRIPTOR = "CalcPlusService";  
  14.     private static final String TAG = "CalcPlusService";  
  15.   
  16.     public void onCreate()  
  17.     {  
  18.         Log.e(TAG, "onCreate");  
  19.     }  
  20.   
  21.     @Override  
  22.     public int onStartCommand(Intent intent, int flags, int startId)  
  23.     {  
  24.         Log.e(TAG, "onStartCommand");  
  25.         return super.onStartCommand(intent, flags, startId);  
  26.     }  
  27.   
  28.     public IBinder onBind(Intent t)  
  29.     {  
  30.         Log.e(TAG, "onBind");  
  31.         return mBinder;  
  32.     }  
  33.   
  34.     public void onDestroy()  
  35.     {  
  36.         Log.e(TAG, "onDestroy");  
  37.         super.onDestroy();  
  38.     }  
  39.   
  40.     public boolean onUnbind(Intent intent)  
  41.     {  
  42.         Log.e(TAG, "onUnbind");  
  43.         return super.onUnbind(intent);  
  44.     }  
  45.   
  46.     public void onRebind(Intent intent)  
  47.     {  
  48.         Log.e(TAG, "onRebind");  
  49.         super.onRebind(intent);  
  50.     }  
  51.   
  52.     private MyBinder mBinder = new MyBinder();  
  53.   
  54.     private class MyBinder extends Binder  
  55.     {  
  56.         @Override  
  57.         protected boolean onTransact(int code, Parcel data, Parcel reply,  
  58.                 int flags) throws RemoteException  
  59.         {  
  60.             switch (code)  
  61.             {  
  62.             case 0x110:  
  63.             {  
  64.                 data.enforceInterface(DESCRIPTOR);  
  65.                 int _arg0;  
  66.                 _arg0 = data.readInt();  
  67.                 int _arg1;  
  68.                 _arg1 = data.readInt();  
  69.                 int _result = _arg0 * _arg1;  
  70.                 reply.writeNoException();  
  71.                 reply.writeInt(_result);  
  72.                 return true;  
  73.             }  
  74.             case 0x111:  
  75.             {  
  76.                 data.enforceInterface(DESCRIPTOR);  
  77.                 int _arg0;  
  78.                 _arg0 = data.readInt();  
  79.                 int _arg1;  
  80.                 _arg1 = data.readInt();  
  81.                 int _result = _arg0 / _arg1;  
  82.                 reply.writeNoException();  
  83.                 reply.writeInt(_result);  
  84.                 return true;  
  85.             }  
  86.             }  
  87.             return super.onTransact(code, data, reply, flags);  
  88.         }  
  89.   
  90.     };  
  91.   
  92. }  


我们自己实现服务端，所以我们自定义了一个Binder子类，然后复写了其onTransact方法，我们指定服务的标识为CalcPlusService，然后0x110为乘，0x111为除；

记得在AndroidMenifest中注册

[html]  view plain  copy
  1. <service android:name="com.example.zhy_binder.CalcPlusService" >  
  2.            <intent-filter>  
  3.                <action android:name="com.zhy.aidl.calcplus" />  
  4.                <category android:name="android.intent.category.DEFAULT" />  
  5.            </intent-filter>  
  6.        </service>  


服务端代码结束。

2、客户端代码

单独新建了一个项目，代码和上例很类似

首先布局文件：

[html]  view plain  copy
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     xmlns:tools="http://schemas.android.com/tools"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical" >  
  6.   
  7.     <Button  
  8.         android:layout_width="fill_parent"  
  9.         android:layout_height="wrap_content"  
  10.         android:onClick="bindService"  
  11.         android:text="BindService" />  
  12.   
  13.     <Button  
  14.         android:layout_width="fill_parent"  
  15.         android:layout_height="wrap_content"  
  16.         android:onClick="unbindService"  
  17.         android:text="UnbindService" />  
  18.   
  19.     <Button  
  20.         android:layout_width="fill_parent"  
  21.         android:layout_height="wrap_content"  
  22.         android:onClick="mulInvoked"  
  23.         android:text="50*12" />  
  24.       
  25.     <Button  
  26.         android:layout_width="fill_parent"  
  27.         android:layout_height="wrap_content"  
  28.         android:onClick="divInvoked"  
  29.         android:text="36/12" />  
  30.   
  31. </LinearLayout>  


可以看到加入了乘和除

然后是Activity的代码

[java]  view plain  copy
  1. package com.example.zhy_binder_client03;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.os.Bundle;  
  9. import android.os.IBinder;  
  10. import android.os.RemoteException;  
  11. import android.util.Log;  
  12. import android.view.View;  
  13. import android.widget.Toast;  
  14.   
  15. public class MainActivity extends Activity  
  16. {  
  17.   
  18.     private IBinder mPlusBinder;  
  19.     private ServiceConnection mServiceConnPlus = new ServiceConnection()  
  20.     {  
  21.         @Override  
  22.         public void onServiceDisconnected(ComponentName name)  
  23.         {  
  24.             Log.e("client", "mServiceConnPlus onServiceDisconnected");  
  25.         }  
  26.   
  27.         @Override  
  28.         public void onServiceConnected(ComponentName name, IBinder service)  
  29.         {  
  30.   
  31.             Log.e("client", " mServiceConnPlus onServiceConnected");  
  32.             mPlusBinder = service;  
  33.         }  
  34.     };  
  35.   
  36.     @Override  
  37.     protected void onCreate(Bundle savedInstanceState)  
  38.     {  
  39.         super.onCreate(savedInstanceState);  
  40.         setContentView(R.layout.activity_main);  
  41.   
  42.     }  
  43.   
  44.     public void bindService(View view)  
  45.     {  
  46.         Intent intentPlus = new Intent();  
  47.         intentPlus.setAction("com.zhy.aidl.calcplus");  
  48.         boolean plus = bindService(intentPlus, mServiceConnPlus,  
  49.                 Context.BIND_AUTO_CREATE);  
  50.         Log.e("plus", plus + "");  
  51.     }  
  52.   
  53.     public void unbindService(View view)  
  54.     {  
  55.         unbindService(mServiceConnPlus);  
  56.     }  
  57.   
  58.     public void mulInvoked(View view)  
  59.     {  
  60.   
  61.         if (mPlusBinder == null)  
  62.         {  
  63.             Toast.makeText(this, "未连接服务端或服务端被异常杀死", Toast.LENGTH_SHORT).show();  
  64.         } else  
  65.         {  
  66.             android.os.Parcel _data = android.os.Parcel.obtain();  
  67.             android.os.Parcel _reply = android.os.Parcel.obtain();  
  68.             int _result;  
  69.             try  
  70.             {  
  71.                 _data.writeInterfaceToken("CalcPlusService");  
  72.                 _data.writeInt(50);  
  73.                 _data.writeInt(12);  
  74.                 mPlusBinder.transact(0x110, _data, _reply, 0);  
  75.                 _reply.readException();  
  76.                 _result = _reply.readInt();  
  77.                 Toast.makeText(this, _result + "", Toast.LENGTH_SHORT).show();  
  78.   
  79.             } catch (RemoteException e)  
  80.             {  
  81.                 e.printStackTrace();  
  82.             } finally  
  83.             {  
  84.                 _reply.recycle();  
  85.                 _data.recycle();  
  86.             }  
  87.         }  
  88.   
  89.     }  
  90.       
  91.     public void divInvoked(View view)  
  92.     {  
  93.   
  94.         if (mPlusBinder == null)  
  95.         {  
  96.             Toast.makeText(this, "未连接服务端或服务端被异常杀死", Toast.LENGTH_SHORT).show();  
  97.         } else  
  98.         {  
  99.             android.os.Parcel _data = android.os.Parcel.obtain();  
  100.             android.os.Parcel _reply = android.os.Parcel.obtain();  
  101.             int _result;  
  102.             try  
  103.             {  
  104.                 _data.writeInterfaceToken("CalcPlusService");  
  105.                 _data.writeInt(36);  
  106.                 _data.writeInt(12);  
  107.                 mPlusBinder.transact(0x111, _data, _reply, 0);  
  108.                 _reply.readException();  
  109.                 _result = _reply.readInt();  
  110.                 Toast.makeText(this, _result + "", Toast.LENGTH_SHORT).show();  
  111.   
  112.             } catch (RemoteException e)  
  113.             {  
  114.                 e.printStackTrace();  
  115.             } finally  
  116.             {  
  117.                 _reply.recycle();  
  118.                 _data.recycle();  
  119.             }  
  120.         }  
  121.   
  122.     }  
  123. }  


为了明了，我直接在mulInvoked里面写了代码，和服务端都没有抽象出一个接口。首先绑定服务时，通过onServiceConnected得到Binder驱动即mPlusBinder；

然后准备数据，调用transact方法，通过code指定执行服务端哪个方法，代码和上面的分析一致。

下面看运行结果：

是不是很好的实现了我们两个应用程序间的通讯，并没有使用aidl文件，也从侧面分析了我们上述分析是正确的。

 

好了，就到这里，相信大家看完这篇博文，对aidl和Binder的理解也会更加深刻。

 

测试代码点击下载

代码先安装server端的代码，然后再安装client端的。。。


    本文转自 一点点征服   博客园博客，原文链接：http://www.cnblogs.com/ldq2016/p/7306097.html，如需转载请自行联系原作者



文章标签：
Android开发
Java
关键词：
Android框架
Android Binder
Binder android
Android aidl
Android aidl binder
技术小胖子
目录
相关文章
请看我回答~
|
3月前
|
物联网 区块链 vr&ar
未来已来：探索区块链、物联网与虚拟现实技术的融合与应用安卓与iOS开发中的跨平台框架选择
【8月更文挑战第30天】在科技的巨轮下，新技术不断涌现，引领着社会进步。本文将聚焦于当前最前沿的技术——区块链、物联网和虚拟现实，探讨它们各自的发展趋势及其在未来可能的应用场景。我们将从这些技术的基本定义出发，逐步深入到它们的相互作用和集成应用，最后展望它们如何共同塑造一个全新的数字生态系统。
请看我回答~
60 0
游客zllgslqrsw3f6
|
4月前
|
开发框架 前端开发 Android开发
安卓与iOS开发中的跨平台框架解析
在移动应用开发的广阔舞台上，安卓和iOS一直是两大主角。随着技术的进步，开发者们渴望能有一种方式，让他们的应用能同时在这两大平台上运行，而不必为每一个平台单独编写代码。这就是跨平台框架诞生的背景。本文将探讨几种流行的跨平台框架，包括它们的优势、局限性，以及如何根据项目需求选择合适的框架。我们将从技术的深度和广度两个维度，对这些框架进行比较分析，旨在为开发者提供一个清晰的指南，帮助他们在安卓和iOS的开发旅程中，做出明智的选择。
游客zllgslqrsw3f6
137 2
dufadayang
|
13天前
|
算法 JavaScript Android开发
weiV 框架在 Android 系统中的实际性能表现如何？
【10月更文挑战第30天】
dufadayang
23 1
mzlogin
|
22天前
|
Java 程序员 API
Android｜集成 slf4j + logback 作为日志框架
做个简单改造，统一 Android APP 和 Java 后端项目打印日志的体验。
mzlogin
86 1
1519247591302223
|
1月前
|
存储 Linux Android开发
Android底层：通熟易懂分析binder：1.binder准备工作
本文详细介绍了Android Binder机制的准备工作，包括打开Binder驱动、内存映射（mmap）、启动Binder主线程等内容。通过分析系统调用和进程与驱动层的通信，解释了Binder如何实现进程间通信。文章还探讨了Binder主线程的启动流程及其在进程通信中的作用，最后总结了Binder准备工作的调用时机和重要性。
1519247591302223
56 0
Android底层：通熟易懂分析binder：1.binder准备工作
众所周知
|
2月前
|
前端开发 Java 数据库
💡Android开发者必看！掌握这5大框架，轻松打造爆款应用不是梦！🏆
在Android开发领域，框架犹如指路明灯，助力开发者加速应用开发并提升品质。本文将介绍五大必备框架：Retrofit简化网络请求，Room优化数据库访问，MVVM架构提高代码可维护性，Dagger 2管理依赖注入，Jetpack Compose革新UI开发。掌握这些框架，助你在竞争激烈的市场中脱颖而出，打造爆款应用。
众所周知
345 3
Ant.Dream
|
2月前
|
编译器 Android开发 开发者
带你了解Android Jetpack库中的依赖注入框架：Hilt
本文介绍了Hilt，这是Google为Android开发的依赖注入框架，基于Dagger构建，旨在简化依赖注入过程。Hilt通过自动化的组件和注解减少了DI的样板代码，提高了应用的可测试性和可维护性。文章详细讲解了Hilt的主要概念、基本用法及原理，帮助开发者更好地理解和应用Hilt。
Ant.Dream
77 8
请看我回答~
|
3月前
|
设计模式 Java Android开发
探索安卓应用开发：从新手到专家的旅程探索iOS开发中的SwiftUI框架
【8月更文挑战第29天】本文旨在通过一个易于理解的旅程比喻，带领读者深入探讨安卓应用开发的各个方面。我们将从基础概念入手，逐步过渡到高级技术，最后讨论如何维护和推广你的应用。无论你是编程新手还是有经验的开发者，这篇文章都将为你提供有价值的见解和实用的代码示例。让我们一起开始这段激动人心的旅程吧！
请看我回答~
50 2
阿迷创客
|
3月前
|
Android开发
基于Amlogic 安卓9.0, 驱动简说（三）：使用misc框架，让驱动更简单
如何使用Amlogic T972安卓9.0系统上的misc框架来简化驱动程序开发，通过misc框架自动分配设备号并创建设备文件，从而减少代码量并避免设备号冲突。
阿迷创客
43 0
基于Amlogic 安卓9.0, 驱动简说（三）：使用misc框架，让驱动更简单
招风的黑耳
|
3月前
|
存储 前端开发 Java
Android MVVM框架详解与应用
在Android开发中，随着应用复杂度的增加，如何有效地组织和管理代码成为了一个重要的问题。MVVM（Model-View-ViewModel）架构模式因其清晰的结构和高效的开发效率，逐渐成为Android开发者们青睐的架构模式之一。本文将详细介绍Android MVVM框架的基本概念、优势、实现流程以及一个实际案例。
招风的黑耳
102 0

热门文章

最新文章

  • 1
    Android 11 中的存储机制更新
  • 2
    《Android游戏开发详解》——第1章，第1.1节什么是编程
  • 3
    android处理拍照旋转问题及带来的对内存占用
  • 4
    Android 中ViewPager嵌套RecyclerView出现滑动冲突的解决方案
  • 5
    Android——Fragment介绍
  • 6
    Android Ap 开发 设计模式第五篇：单件模式
  • 7
    android使用Activity
  • 8
    Android Sqlite数据库版本升级管理初探
  • 9
    Android开发1——查找所需要出示权限的内容
  • 10
    实现一个用于显示当前时间的Google Android 窗口小部件（AppWidget）
  • 1
    Android深入Binder拦截问题分析
    59
  • 2
    运维最全linux 命令行操作串口_linux串口命令(2)，2024年最新Linux运维源码的Binder权限是如何控制
    97
  • 3
    2024年校花转学到我们班，于是我用Python把她空间给爬了个遍！(1)，binder机制面试题
    51
  • 4
    binder机制原理面试，安卓app开发教程
    82
  • 5
    Android 浅度解析：AIDL & Binder (1)
    217
  • 6
    Spring-cloud-stream-binder-rocketmq入门与实践
    554
  • 7
    Android中Binder在项目中的具体使用详解
    192
  • 8
    Andorid关于Binder几个面试问题
    136
  • 9
    [RK3568 Android11] Binder通信整体框架
    106
  • 10
    Android中的Binder概述
    174

    • 相关课程

    更多
  • 微服务实战-RocketMQ Binder
  • 开源Android容器化框架Atlas开发者指南

    • 相关电子书

    更多
  • 58同城Android客户端Walle框架演进与实践之路
  • Android组件化实现
  • 蚂蚁聚宝Android秒级编译——Freeline

    • 推荐镜像

    更多
  • android.googlesource.com
    • 下一篇
    阿里云OSS设置跨域访问