`
hunankeda110
  • 浏览: 746524 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

android进程间通信：AIDL

androidAIDL进程通信 
阅读更多

  欢迎阅读本文，你能关注本文，你知道你需要进程间通信、需要AIDL（以及Binder），那么可以默认你对这些概念已经有了一些了解，你（大致）知道它们是什么，它们有什么用，所以为了节约大家的眼力和时间，在此我不复制粘贴网上泛滥的博客或者翻译冗长的android文档。

      关于AIDL的介绍在文档：docs/guide/developing/tools/aidl.html

      关于IBinder的介绍在文档：docs/reference/android/os/IBinder.html

      以及Binder：docs/reference/android/os/Binder.html

      在后文中，我将以我自己的理解向你介绍相关的概念。以我目前粗浅的经验，应用程序使用AIDL的地方，几乎都和Service有关，所以你也需要知道一些关于Service的知识。日后得闲我也会继续写一些关于Service的贴。

      本文将以一个例子来和你分享使用AIDL的基础技能，这个例子里有：

1、一个类mAIDLActivity，继承Activity。里面有三个按钮，text分别为StartService，StopService，CallbackTest。

2、一个类mAIDLService，继承Service。为了充分展示ADIL的功能，它做以下工作：当用户点击CallbackTest按钮时，从mAIDLActivity调用mAIDLService中的Stub 对象的一个方法invokCallBack()，而这个方法又会调用mAIDLActivity中Stub 对象的一个方法performAction()，这个方法在屏幕上显示一个toast。没什么意义，只是展示一下AIDL如何使用。

3、两个AIDL文件：forService.aidl和forActivity.aidl。对应名字，在Service和Activity中分别有对象需要用到它们定义的接口。

4、相关XML文件，略过。关于manifest中Service的语法，见docs/guide/topics/manifest/service-element.html。你也可以简单地在<application></application>中加入

     <service android:name=".mAIDLService" android:process=":remote"> </service>

开发环境为Eclipse。

拣重要的先说，来看看aidl文件的内容：

文件：forActivity.aidl

[java] view plaincopyprint?
  1. package com.styleflying.AIDL;  
  2. interface forActivity {  
  3.     void performAction();  
  4.     }  

 

 

文件：forService.aidl

[java] view plaincopyprint?
  1. package com.styleflying.AIDL;  
  2. import com.styleflying.AIDL.forActivity;  
  3. interface forService {  
  4.     void registerTestCall(forActivity cb);  
  5.     void invokCallBack();  
  6. }  

 

 

这两个文件和Java文件放置的地方一样，看包名。

在Eclipse中它们将被自动编译为forActivity.java和forService.java，它们存放在gen目录下。为了方便手头无法演练的读者，代码贴上，不用细看。

文件forActivity.java：

[java] view plaincopyprint?
  1. /* 
  2.  * This file is auto-generated.  DO NOT MODIFY. 
  3.  * Original file: D://workspace//AIDLTest//src//com//styleflying//AIDL//forActivity.aidl 
  4.  */  
  5. package com.styleflying.AIDL;  
  6. import java.lang.String;  
  7. import android.os.RemoteException;  
  8. import android.os.IBinder;  
  9. import android.os.IInterface;  
  10. import android.os.Binder;  
  11. import android.os.Parcel;  
  12. public interface forActivity extends android.os.IInterface  
  13. {  
  14. /** Local-side IPC implementation stub class. */  
  15. public static abstract class Stub extends android.os.Binder implements com.styleflying.AIDL.forActivity  
  16. {  
  17. private static final java.lang.String DESCRIPTOR = "com.styleflying.AIDL.forActivity";  
  18. /** Construct the stub at attach it to the interface. */  
  19. public Stub()  
  20. {  
  21. this.attachInterface(this, DESCRIPTOR);  
  22. }  
  23. /** 
  24.  * Cast an IBinder object into an forActivity interface, 
  25.  * generating a proxy if needed. 
  26.  */  
  27. public static com.styleflying.AIDL.forActivity asInterface(android.os.IBinder obj)  
  28. {  
  29. if ((obj==null)) {  
  30. return null;  
  31. }  
  32. android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
  33. if (((iin!=null)&&(iin instanceof com.styleflying.AIDL.forActivity))) {  
  34. return ((com.styleflying.AIDL.forActivity)iin);  
  35. }  
  36. return new com.styleflying.AIDL.forActivity.Stub.Proxy(obj);  
  37. }  
  38. public android.os.IBinder asBinder()  
  39. {  
  40. return this;  
  41. }  
  42. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  43. {  
  44. switch (code)  
  45. {  
  46. case INTERFACE_TRANSACTION:  
  47. {  
  48. reply.writeString(DESCRIPTOR);  
  49. return true;  
  50. }  
  51. case TRANSACTION_performAction:  
  52. {  
  53. data.enforceInterface(DESCRIPTOR);  
  54. this.performAction();  
  55. reply.writeNoException();  
  56. return true;  
  57. }  
  58. }  
  59. return super.onTransact(code, data, reply, flags);  
  60. }  
  61. private static class Proxy implements com.styleflying.AIDL.forActivity  
  62. {  
  63. private android.os.IBinder mRemote;  
  64. Proxy(android.os.IBinder remote)  
  65. {  
  66. mRemote = remote;  
  67. }  
  68. public android.os.IBinder asBinder()  
  69. {  
  70. return mRemote;  
  71. }  
  72. public java.lang.String getInterfaceDescriptor()  
  73. {  
  74. return DESCRIPTOR;  
  75. }  
  76. public void performAction() throws android.os.RemoteException  
  77. {  
  78. android.os.Parcel _data = android.os.Parcel.obtain();  
  79. android.os.Parcel _reply = android.os.Parcel.obtain();  
  80. try {  
  81. _data.writeInterfaceToken(DESCRIPTOR);  
  82. mRemote.transact(Stub.TRANSACTION_performAction, _data, _reply, 0);  
  83. _reply.readException();  
  84. }  
  85. finally {  
  86. _reply.recycle();  
  87. _data.recycle();  
  88. }  
  89. }  
  90. }  
  91. static final int TRANSACTION_performAction = (IBinder.FIRST_CALL_TRANSACTION + 0);  
  92. }  
  93. public void performAction() throws android.os.RemoteException;  
  94. }  

 

文件forService.java：

[java] view plaincopyprint?
  1. /* 
  2.  * This file is auto-generated.  DO NOT MODIFY. 
  3.  * Original file: D://workspace//AIDLTest//src//com//styleflying//AIDL//forService.aidl 
  4.  */  
  5. package com.styleflying.AIDL;  
  6. import java.lang.String;  
  7. import android.os.RemoteException;  
  8. import android.os.IBinder;  
  9. import android.os.IInterface;  
  10. import android.os.Binder;  
  11. import android.os.Parcel;  
  12. public interface forService extends android.os.IInterface  
  13. {  
  14. /** Local-side IPC implementation stub class. */  
  15. public static abstract class Stub extends android.os.Binder implements com.styleflying.AIDL.forService  
  16. {  
  17. private static final java.lang.String DESCRIPTOR = "com.styleflying.AIDL.forService";  
  18. /** Construct the stub at attach it to the interface. */  
  19. public Stub()  
  20. {  
  21. this.attachInterface(this, DESCRIPTOR);  
  22. }  
  23. /** 
  24.  * Cast an IBinder object into an forService interface, 
  25.  * generating a proxy if needed. 
  26.  */  
  27. public static com.styleflying.AIDL.forService asInterface(android.os.IBinder obj)  
  28. {  
  29. if ((obj==null)) {  
  30. return null;  
  31. }  
  32. android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
  33. if (((iin!=null)&&(iin instanceof com.styleflying.AIDL.forService))) {  
  34. return ((com.styleflying.AIDL.forService)iin);  
  35. }  
  36. return new com.styleflying.AIDL.forService.Stub.Proxy(obj);  
  37. }  
  38. public android.os.IBinder asBinder()  
  39. {  
  40. return this;  
  41. }  
  42. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  43. {  
  44. switch (code)  
  45. {  
  46. case INTERFACE_TRANSACTION:  
  47. {  
  48. reply.writeString(DESCRIPTOR);  
  49. return true;  
  50. }  
  51. case TRANSACTION_registerTestCall:  
  52. {  
  53. data.enforceInterface(DESCRIPTOR);  
  54. com.styleflying.AIDL.forActivity _arg0;  
  55. _arg0 = com.styleflying.AIDL.forActivity.Stub.asInterface(data.readStrongBinder());  
  56. this.registerTestCall(_arg0);  
  57. reply.writeNoException();  
  58. return true;  
  59. }  
  60. case TRANSACTION_invokCallBack:  
  61. {  
  62. data.enforceInterface(DESCRIPTOR);  
  63. this.invokCallBack();  
  64. reply.writeNoException();  
  65. return true;  
  66. }  
  67. }  
  68. return super.onTransact(code, data, reply, flags);  
  69. }  
  70. private static class Proxy implements com.styleflying.AIDL.forService  
  71. {  
  72. private android.os.IBinder mRemote;  
  73. Proxy(android.os.IBinder remote)  
  74. {  
  75. mRemote = remote;  
  76. }  
  77. public android.os.IBinder asBinder()  
  78. {  
  79. return mRemote;  
  80. }  
  81. public java.lang.String getInterfaceDescriptor()  
  82. {  
  83. return DESCRIPTOR;  
  84. }  
  85. public void registerTestCall(com.styleflying.AIDL.forActivity cb) throws android.os.RemoteException  
  86. {  
  87. android.os.Parcel _data = android.os.Parcel.obtain();  
  88. android.os.Parcel _reply = android.os.Parcel.obtain();  
  89. try {  
  90. _data.writeInterfaceToken(DESCRIPTOR);  
  91. _data.writeStrongBinder((((cb!=null))?(cb.asBinder()):(null)));  
  92. mRemote.transact(Stub.TRANSACTION_registerTestCall, _data, _reply, 0);  
  93. _reply.readException();  
  94. }  
  95. finally {  
  96. _reply.recycle();  
  97. _data.recycle();  
  98. }  
  99. }  
  100. public void invokCallBack() throws android.os.RemoteException  
  101. {  
  102. android.os.Parcel _data = android.os.Parcel.obtain();  
  103. android.os.Parcel _reply = android.os.Parcel.obtain();  
  104. try {  
  105. _data.writeInterfaceToken(DESCRIPTOR);  
  106. mRemote.transact(Stub.TRANSACTION_invokCallBack, _data, _reply, 0);  
  107. _reply.readException();  
  108. }  
  109. finally {  
  110. _reply.recycle();  
  111. _data.recycle();  
  112. }  
  113. }  
  114. }  
  115. static final int TRANSACTION_registerTestCall = (IBinder.FIRST_CALL_TRANSACTION + 0);  
  116. static final int TRANSACTION_invokCallBack = (IBinder.FIRST_CALL_TRANSACTION + 1);  
  117. }  
  118. public void registerTestCall(com.styleflying.AIDL.forActivity cb) throws android.os.RemoteException;  
  119. public void invokCallBack() throws android.os.RemoteException;  
  120. }  

 

两段代码差不多，前面基本一样，从后面看，最后跟着我们在AIDL中自定义的方法，没有实现。两个文件各定义一个了接口，这两个接口分别会在Activity和Service中使用，在那里我们将实现自定义的方法。两个接口中都定义了一个抽象类Stub，实现所在的接口。Stub中又有一个类Proxy。Stub中有一个static的asInterface()方法，里面有很多return语句，在mAIDLActivity中调用它时，它返回一个新创建的内部类Proxy对象。

这个Stub对我们来说很有用，它继承了Binder。Binder有什么用呢？一个类，继承了Binder，那么它的对象就可以被远程的进程使用了(前提是远程进程获取了这个类的对象【对象的引用】，至于如如何获得看下文)，在本例中就是说，如果一个Service中有一个继承了Stub的类的对象，那么这个对象中的方法就可以在Activity中使用，对Activity也是这样。至于Binder的细节，网上有很多贴介绍，看不明白也不影响我们完成这个例子。

再看mAIDLActivity.java:

[java] view plaincopyprint?
  1. package com.styleflying.AIDL;  
  2. import android.app.Activity;  
  3. import android.content.ComponentName;  
  4. import android.content.Context;  
  5. import android.content.Intent;  
  6. import android.content.ServiceConnection;  
  7. import android.os.Bundle;  
  8. import android.os.IBinder;  
  9. import android.os.RemoteException;  
  10. import android.util.Log;  
  11. import android.view.View;  
  12. import android.view.View.OnClickListener;  
  13. import android.widget.Button;  
  14. import android.widget.Toast;  
  15. public class mAIDLActivity extends Activity {  
  16.     private static final String TAG = "AIDLActivity";  
  17.     private Button btnOk;  
  18.     private Button btnCancel;  
  19.     private Button btnCallBack;  
  20.       
  21.     private void Log(String str) {  
  22.         Log.d(TAG, "------ " + str + "------");  
  23.         }  
  24.       
  25.     private forActivity mCallback = new forActivity.Stub() {  
  26.         public void performAction() throws RemoteException  
  27.         {  
  28.             Toast.makeText(mAIDLActivity.this, "this toast is called from service", 1).show();  
  29.         }  
  30.         };  
  31.           
  32.     forService mService;  
  33.     private ServiceConnection mConnection = new ServiceConnection() {  
  34.         public void onServiceConnected(ComponentName className,  
  35.                 IBinder service) {  
  36.             mService = forService.Stub.asInterface(service);  
  37.             try {  
  38.                 mService.registerTestCall(mCallback);}  
  39.             catch (RemoteException e) {  
  40.                   
  41.             }  
  42.             }  
  43.         public void onServiceDisconnected(ComponentName className) {  
  44.             Log("disconnect service");  
  45.             mService = null;  
  46.             }  
  47.         };  
  48.     @Override  
  49.     public void onCreate(Bundle icicle) {  
  50.         super.onCreate(icicle);  
  51.         setContentView(R.layout.main);  
  52.         btnOk = (Button)findViewById(R.id.btn_ok);  
  53.         btnCancel = (Button)findViewById(R.id.btn_cancel);  
  54.         btnCallBack = (Button)findViewById(R.id.btn_callback);  
  55.         btnOk.setOnClickListener(new OnClickListener() {  
  56.             public void onClick(View v) {  
  57.                 Bundle args = new Bundle();  
  58.                 Intent intent = new Intent(mAIDLActivity.this, mAIDLService.class);  
  59.                 intent.putExtras(args);  
  60.                 bindService(intent, mConnection, Context.BIND_AUTO_CREATE);  
  61.                 startService(intent);  
  62.                 }  
  63.             });  
  64.         btnCancel.setOnClickListener(new OnClickListener() {  
  65.             public void onClick(View v) {  
  66.                 unbindService(mConnection);  
  67.                 //stopService(intent);   
  68.                 }  
  69.             });  
  70.         btnCallBack.setOnClickListener(new OnClickListener() {  
  71.               
  72.             @Override  
  73.             public void onClick(View v)  
  74.             {  
  75.                 try  
  76.                 {  
  77.                     mService.invokCallBack();  
  78.                 } catch (RemoteException e)  
  79.                 {  
  80.                     // TODO Auto-generated catch block   
  81.                     e.printStackTrace();  
  82.                 }  
  83.             }  
  84.         });  
  85.         }  
  86. }  

 

 

很短，相信大家很容易看明白。注意mConnection，它的onServiceConnected()中有一句mService = forService.Stub.asInterface(service);给mService赋值了，这个mService是一个forService，而service是onServiceConnected()传进来的参数，onServiceConnected()会在连接Service的时候被系统调用，这个service参数的值来自哪里呢？看mAIDLService.java:

[java] view plaincopyprint?
  1. package com.styleflying.AIDL;  
  2. import android.app.Service;  
  3. import android.content.Intent;  
  4. import android.os.IBinder;  
  5. import android.os.RemoteCallbackList;  
  6. import android.os.RemoteException;  
  7. import android.util.Log;  
  8. public class mAIDLService extends Service {  
  9.     private static final String TAG = "AIDLService";    
  10.     private forActivity callback;  
  11.     private void Log(String str) {  
  12.         Log.d(TAG, "------ " + str + "------");  
  13.     }  
  14.     @Override  
  15.     public void onCreate() {  
  16.         Log("service create");  
  17.     }  
  18.     @Override  
  19.     public void onStart(Intent intent, int startId) {  
  20.         Log("service start id=" + startId);  
  21.     }  
  22.       
  23.     @Override  
  24.     public IBinder onBind(Intent t) {  
  25.         Log("service on bind");  
  26.         return mBinder;  
  27.     }  
  28.     @Override  
  29.     public void onDestroy() {  
  30.         Log("service on destroy");  
  31.         super.onDestroy();  
  32.     }  
  33.     @Override  
  34.     public boolean onUnbind(Intent intent) {  
  35.         Log("service on unbind");  
  36.         return super.onUnbind(intent);  
  37.     }  
  38.     public void onRebind(Intent intent) {  
  39.         Log("service on rebind");  
  40.         super.onRebind(intent);  
  41.     }  
  42.     private final forService.Stub mBinder = new forService.Stub() {  
  43.         @Override  
  44.         public void invokCallBack() throws RemoteException  
  45.         {  
  46.             callback.performAction();  
  47.               
  48.         }  
  49.         @Override  
  50.         public void registerTestCall(forActivity cb) throws RemoteException  
  51.         {  
  52.             callback = cb;  
  53.               
  54.         }  
  55.           
  56.     };  
  57. }  

 

注意onBind()，它的返回类型为IBinder，返回了一个mBinder，看看mBinder的定义：

    private final forService.Stub mBinder = new forService.Stub() {

        @Override
        public void invokCallBack() throws RemoteException
        {
            callback.performAction();
         }

        @Override
        public void registerTestCall(forActivity cb) throws RemoteException
        {
            callback = cb;

        }

       };

它是实现了我们在AIDL中定义的方法，这个mBinder最终返回给了mAIDLActivity中的mService，于是在mAIDLActivity中可以使用mBinder中的方法了。在mAIDLActivity中也有一个类似mBinder的对象，看看定义：   

        private forActivity mCallback = new forActivity.Stub()

    {
        public void performAction() throws RemoteException
        {
            Toast.makeText(mAIDLActivity.this, "this toast is called from service", 1).show();
        }
      };

我们要在界面上显示一个toast，就是在这里实现的。这个对象，在mConnection的onServiceConnected()被调用时，通过调用mService（也就是远程的mAIDLService中的mBinder）的registerTestCall()，传递给了mAIDLService，于是在mAIDLService中可以调用performAction()了。

很啰嗦，只为了能把这个细节说清楚。请大家认真看，我尽量避免错别字、混乱的大小写和逻辑不清的语法，相信你会看明白。是不是很简单？再啰嗦一下，做一个大致总结，我们使用AIDL是要做什么呢：

让Acticity（或者说一个进程/一个类？）和Service（或者说远端进程/远端类/对象？）获取对方的一个Stub对象，这个对象在定义时实现了我们在AIDL中定义的方法，于是这些远程对象中的方法可以在本地使用了。如果这种使用（通信）是单向的，比如只是Activity需要通知Service做什么，那么只要Service中有一个Stub对象，并且传给Acticity就够了。

至于如何获得远程的Stub，参看上面的代码，看mConnection、registerTestCall、onRebind，它们展示了一种方法。

另外，有时候我们可能在一个类中有多个Stub对象，它们都要给远程交互的类的实例，这个时候可以考虑使用RemoteCallbackList<>（docs/reference/android/os/RemoteCallbackList.html）。

欢迎阅读、收藏本文。例子随手写的，功能只在演示AIDL的使用。您可以转载本文，但请勿盲目乱贴。不是我小气，我不权威，我怕它被贴到泛滥，以讹传讹，害了人。

0
顶
0
踩
分享到：
| Activity堆栈管理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    android进程间通信：使用AIDL

    你知道你需要进程间通信、需要AIDL（以及Binder），那么可以默认你对这些概念已经有了一些了解，你（大致）知道它们是什么，它们有什么用，所以为了节约大家的眼力和时间，在此我不复制粘贴网上泛滥的博客或者翻译...

    android进程间通信之AIDL

    android进程间通信之AIDL的简单的示例代码

    Android-Android进程间通信之AIDL

    **Android进程间通信之AIDL详解** Android系统作为一个多任务操作系统，多个应用程序之间可能存在需要相互交互的需求，这就涉及到了进程间通信（IPC, Inter-Process Communication）。在Android中，AIDL（Android ...

    进程间通信(aidl的使用)

    AIDL是Android提供的一个接口定义语言，它类似于Java，但专门用于描述进程间通信的接口。通过AIDL，开发者可以定义方法签名，指定参数类型和返回值，从而创建可以在进程间传递的对象。AIDL文件会被编译成Java代码，...

    Android进程间的通信AIDL实例

    AIDL（Android Interface Definition Language）是Android提供的一种强大的工具，专门用于实现进程间通信。本篇将详细介绍AIDL的使用方法，并通过一个简单的实例来帮助初学者理解其工作流程。 AIDL是一种接口定义...

    android aidl 不同进程间通信

    下面将详细介绍Aidl在不同进程间通信中的应用及其工作原理。 **1. Android进程通信的重要性** Android系统设计时，每个应用运行在自己的进程中，为了保护应用间的隔离性和安全性。但有时我们需要让一个应用调用另一...

    Android 进程间通信AIDL Demo

    在Android系统中，进程间通信（IPC，Inter-Process Communication）是实现不同应用程序之间数据交换的关键技术。AIDL（Android Interface Definition Language）是Android提供的一种强大的工具，它使得跨进程调用...

    Android进程间通信AIDLDemo

    本教程将深入讲解AIDL的使用和其在Android进程间通信中的应用。 首先，我们要理解什么是AIDL。AIDL实际上是一种接口定义语言，类似于Java中的接口，但它的目的是让不同的Android进程之间能够调用彼此的方法。当一个...

    AIDL----Android进程间通信（IPC）代码

    **Android进程间通信（IPC）：AIDL详解** 在Android系统中，进程间通信（IPC，Inter-Process Communication）是应用程序之间数据交换的关键技术。AIDL（Android Interface Definition Language）是Android提供的一...

    android根据不同任务创建不同进程，并通过AIDL进行进程间通信

    本文将深入探讨如何在Android中创建多个进程以及如何通过Android Interface Definition Language (AIDL) 实现进程间通信（IPC, Inter-Process Communication）。 首先，创建不同进程主要基于以下两个原因：一是提高...

    Android多进程间采用AIDL方式进行通信

    Android 多进程间采用 AIDL 方式进行通信是一种常用的进程间通信方式。在 Android 中，多进程间通信是指不同的应用程序之间或同一应用程序中的不同组件之间的通信。AIDL（Android Interface Definition Language）是...

    使用 AIDL实现进程间通信

    AIDL（Android Interface Definition Language）是Android提供的一种工具，用于方便开发者实现进程间通信。这篇博客“使用AIDL实现进程间通信”将深入探讨如何利用AIDL进行跨进程的交互。 首先，我们要理解AIDL的...

    Android使用AIDL实现进程间通信

    本篇文章将深入探讨如何在Android中使用AIDL来实现进程间通信。 首先，理解AIDL的基本概念。AIDL是一种接口定义语言，类似于Java中的接口，但它的目的是跨越进程边界。通过AIDL，我们可以定义一个接口，该接口会被...

    Android多进程通讯AIDL传递Parcelable对象

    AIDL（Android Interface Definition Language）是Android提供的一种接口定义语言，用于支持跨进程调用方法，从而实现多进程间的通信。 AIDL的基本原理是将接口定义为一个.aidl文件，系统会自动生成对应的Java代码...

    android 进程间通信demo

    本示例"android 进程间通信demo"专注于讲解如何利用Android Interface Definition Language (AIDL) 实现这一功能。 AIDL是Android提供的一个接口定义工具，它允许我们定义服务间的接口，这样不同的进程可以通过 ...

    android进程间通信

    本篇文章将深入探讨如何利用AIDL来实现在Android中的进程间通信。 首先，我们要了解Android进程的概念。在Android中，每个应用都运行在自己的进程中，默认情况下，只有同一应用内的组件才能互相通信。但有时，我们...

    Android AIDL进程间通信

    综上所述，AIDL是Android平台中实现进程间通信的重要手段，通过合理的使用，可以构建出高效、稳定、可扩展的应用程序。通过阅读和理解给定的`MyTestAIDL`代码资源，开发者可以更好地掌握AIDL的工作方式，为今后的...

    Android 进程间通信机制(六) 手写AIDL文件

     进程间通信涉及到客户端和服务端, 肯定有绑定服务的过程, 所以要阅读一下Android Service相关的知识, 跨进程通信的媒介aidl文件,我们也必须要了解怎么创建的,有什么规则,所以请先阅读一下Android AIDL使用这篇...

    Android IPC进程间通信AIDL方式Demo

    这是一个IPC进程间AIDL方式通信的简单Demo。包括服务端和客户端。目的在于协助该博客讲解binder与service之间跨进程通信机制。所有大家读源码时务必同时读该博客。 ...

    Android AIDL 进程间通信

    Android进程间通信 AIDL Service 一、服务端结构 服务端需要处理的有： 1.处理对象，对象内方法，注意：AIDL 只能对函数起作用； 2.处理服务； 3.配置文件； 二、客户端 配置 1.对象，切记，与服务端的对象完全一致...

Magicbox
Global site tag (gtag.js) - Google Analytics