devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android 使用AIDL进行两个APP之间通讯以及相互消息回调(一)_android aidl 互相收发数据

作者：从前慢现在也慢 | 2024-02-21 09:43:21

赞

踩

android aidl 互相收发数据

前言：

AIDL：Android Interface Definition Language，翻译过来就是Android接口定义语言。是用于定义服务器和客户端通信接口的一种描述语言，可以拿来生成用于IPC的代码。所以使用AIDL需要一个服务端和客户端
作用：可以在一个进程中获取另一个进程的数据和调用其暴露出来的方法，从而满足进程间通信的需求。

1.AIDL支持的基本数据类型

  1. 八种基本数据类型：byte、char、short、int、long、float、double、boolean
  2. String，CharSequence
  3. 实现了Parcelable接口的数据类型
  4. List 类型。List承载的数据必须是AIDL支持的类型，或者是其它声明的AIDL对象
  5. Map类型。Map承载的数据必须是AIDL支持的类型，或者是其它声明的AIDL对象

2.服务端的实现

   创建工程，以及所需aidl文件

  • 使用Android Studio新建一个工程,命名为TestAidlDemo1
  • 右键New一个AIDL文件，取名为IAidlInterface，AS会自动在工程目录生成一个路径完全一样的aidl文件夹
  • 既然是要回调消息，那就还需要一个回调接口，同样的方法，创建IAidlCallBack.aidl文件，那么接下来就进行代码编写

实现代码逻辑

  • 编写IAidlInterface.aldi代码，因为我们需要回调消息，那么我们需要注册回调以及注销回调接口，一个发送消息的接口，一个获取历史消息的接口，代码如下(AIDL文件不会自动导包,一些不是基本支持数据类型需要我们自己手动import，) 
    1. import com.pgc.testaidldemo1.IAidlCallBack;
    2. interface IAidlInterface {
    3.     /**
    4.      * Demonstrates some basic types that you can use as parameters
    5.      * and return values in AIDL.
    6.      */
    7.     void registerCallBack(IAidlCallBack iAidlCallBack);
    8.     void unregisterCallBack(IAidlCallBack iAidlCallBack);
    9.     void sendMessage(String message);
    10.     List<String> getMessages();
    11. }

     

  • 编写IAidlCallBack.aidl代码：既然是回调接口，那么我们只需要一个消息发送成功的回调接口就行，代码如下

    1. interface IAidlCallBack {
    2.     /**
    3.      * Demonstrates some basic types that you can use as parameters
    4.      * and return values in AIDL.
    5.      */
    6.     void onMessageSuccess(String message);
    7. }

     

  • 既然是服务端，我们需要实现接收消息已经处理消息的逻辑代码，所以我们创建一个AidlService，继承Service,因为Service不能直接接收Callback,但是提供了RemoteCallbackList来注册回调

    private RemoteCallbackList<IAidlCallBack> callbackList= new RemoteCallbackList<>();

    同时RemoteCallbackList提供了beginBroadcast来获取当前注册的回调数，因此我们可以通过这个方法进行回调处理(再使用了beginBroadcast之后必须调用finishBroadcast不然会报beginBroadcast() called while already in a broadcast错误)

    1. final int num=callbackList.beginBroadcast();
    2. for (int i=0;i<num;i++){
    3.      IAidlCallBack iAidlCallBack=callbackList.getBroadcastItem(i);
    4.      iAidlCallBack.onMessageSuccess(message);
    5.     }
    6. callbackList.finishBroadcast();

     接下来实例化binder对象并返回给客户端，

    1. @Override
    2.     public IBinder onBind(Intent intent) {
    3.         return binder;
    4.     }
    5.  
    6.     private final IAidlInterface.Stub binder=new IAidlInterface.Stub() {
    7.         @Override
    8.         public void registerCallBack(IAidlCallBack iAidlCallBack) throws RemoteException {
    9.             callbackList.register(iAidlCallBack);
    10.         }
    11.  
    12.         @Override
    13.         public void unregisterCallBack(IAidlCallBack iAidlCallBack) throws RemoteException {
    14.             callbackList.unregister(iAidlCallBack);
    15.         }
    16.  
    17.         @Override
    18.         public void sendMessage(String message) throws RemoteException {
    19.             messages.add(message);
    20.             final int num=callbackList.beginBroadcast();
    21.             for (int i=0;i<num;i++){
    22.                 IAidlCallBack iAidlCallBack=callbackList.getBroadcastItem(i);
    23.                 iAidlCallBack.onMessageSuccess(message);
    24.             }
    25.             callbackList.finishBroadcast();
    26.         }
    27.  
    28.         @Override
    29.         public List<String> getMessages() throws RemoteException {
    30.             return messages;
    31.         }
    32.     };

      

  • 在AndroidManifest.xml注册Service

    1. <service android:name=".AidlService"
    2.          android:enabled="true"
    3.          android:exported="true"
    4.             >
    5.     <intent-filter android:priority="1000">
    6.             <action android:name="AIDL.service"></action>
    7.    </intent-filter>
    8. </service>

     

  • AidlService全部代码

    1. package com.pgc.testaidldemo1;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.app.Service;
    5. import android.content.Intent;
    6. import android.os.IBinder;
    7. import android.os.RemoteCallbackList;
    8. import android.os.RemoteException;
    9.  
    10. import androidx.annotation.Nullable;
    11.  
    12. import java.util.ArrayList;
    13. import java.util.List;
    14.  
    15.  
    16. /**
    17.  * Created by PengGuiChu on 2020/4/11.
    18.  */
    19. @SuppressLint("Registered")
    20. public class AidlService extends Service {
    21.     private RemoteCallbackList<IAidlCallBack> callbackList= new RemoteCallbackList<>();
    22.     private List<String> messages=new ArrayList<>();
    23.     @Nullable
    24.     @Override
    25.     public IBinder onBind(Intent intent) {
    26.         return binder;
    27.     }
    28.  
    29.     private final IAidlInterface.Stub binder=new IAidlInterface.Stub() {
    30.         @Override
    31.         public void registerCallBack(IAidlCallBack iAidlCallBack) throws RemoteException {
    32.             callbackList.register(iAidlCallBack);
    33.         }
    34.  
    35.         @Override
    36.         public void unregisterCallBack(IAidlCallBack iAidlCallBack) throws RemoteException {
    37.             callbackList.unregister(iAidlCallBack);
    38.         }
    39.  
    40.         @Override
    41.         public void sendMessage(String message) throws RemoteException {
    42.             messages.add(message);
    43.             final int num=callbackList.beginBroadcast();
    44.             for (int i=0;i<num;i++){
    45.                 IAidlCallBack iAidlCallBack=callbackList.getBroadcastItem(i);
    46.                 iAidlCallBack.onMessageSuccess(message);
    47.             }
    48.             callbackList.finishBroadcast();
    49.         }
    50.  
    51.         @Override
    52.         public List<String> getMessages() throws RemoteException {
    53.             return messages;
    54.         }
    55.     };
    56.  
    57.     @Override
    58.     public void onCreate() {
    59.         super.onCreate();
    60.     }
    61. }

     

  • 因为是服务端和客户端实现相互消息回调，因此在服务端也需要通过binderService来获取binder，相对客户端，因为服务端和AidlService是在同一线程，我们可以直接binderService

    1. Intent intent=new Intent(getApplicationContext(),AidlService.class);
    2. bindService(intent,serviceConnection,BIND_AUTO_CREATE);

    然后实例化ServiceConnection

    1. private ServiceConnection serviceConnection=new ServiceConnection() {
    2.         @Override
    3.         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
    4.             
    5.         }
    6.  
    7.         @Override
    8.         public void onServiceDisconnected(ComponentName componentName) {
    9.  
    10.         }
    11. };

    然后在onServiceConnected中获取binder

    1. iAidlInterface=IAidlInterface.Stub.asInterface(iBinder);
    2. try {
    3.       iAidlInterface.asBinder().linkToDeath(mDeathRecipient, 0);//监听进程是否消失
    4.       iAidlInterface.registerCallBack(iAidlCallBack);//注册消息回调
    5.       messages.addAll(iAidlInterface.getMessages());//获取历史消息
    6.       listView.setAdapter(arrayAdapter=new ArrayAdapter<> 
    7.       (getApplicationContext(),android.R.layout.simple_list_item_1,messages));
    8. } catch (RemoteException e) {
    9.        e.printStackTrace();
    10. }

    DeathRecipient实例

    1.     private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
    2.         //当承载IBinder的进程消失时接收回调的接口
    3.         @Override
    4.         public void binderDied() {
    5.             if (null == iAidlInterface) {
    6.                 return;
    7.             }
    8.             try {
    9.                 iAidlInterface.unregisterCallBack(iAidlCallBack);//注销
    10.             } catch (RemoteException e) {
    11.                 e.printStackTrace();
    12.             }
    13.             iAidlInterface.asBinder().unlinkToDeath(mDeathRecipient, 0);
    14.             iAidlInterface = null;
    15.         }
    16.     };

    iAidlCallBack实例

    1.     private IAidlCallBack iAidlCallBack=new IAidlCallBack.Stub() {
    2.         @Override
    3.         public void onMessageSuccess(String message) {
    4.             if (messages!=null&&arrayAdapter!=null){
    5.                 messages.add(message);
    6.                 handler.sendEmptyMessage(1);
    7.             }
    8.         }
    9.     };

     MainActivity全部代码

    1. package com.pgc.testaidldemo1;
    2.  
    3.  
    4.  
    5. import android.annotation.SuppressLint;
    6. import android.content.ComponentName;
    7. import android.content.Intent;
    8. import android.content.ServiceConnection;
    9. import android.os.Bundle;
    10. import android.os.Handler;
    11. import android.os.IBinder;
    12. import android.os.Message;
    13. import android.os.RemoteException;
    14. import android.view.View;
    15. import android.widget.ArrayAdapter;
    16. import android.widget.ListView;
    17.  
    18. import androidx.annotation.NonNull;
    19. import androidx.appcompat.app.AppCompatActivity;
    20. import java.util.ArrayList;
    21. import java.util.List;
    22.  
    23. import butterknife.BindView;
    24. import butterknife.ButterKnife;
    25. import butterknife.OnClick;
    26.  
    27. public class MainActivity extends AppCompatActivity {
    28.     @BindView(R.id.list_view)
    29.     ListView listView;
    30.     private IAidlInterface iAidlInterface;
    31.     private int num;
    32.     private List<String> messages=new ArrayList<>();
    33.     private ArrayAdapter arrayAdapter;
    34.     @Override
    35.     protected void onCreate(Bundle savedInstanceState) {
    36.         super.onCreate(savedInstanceState);
    37.         setContentView(R.layout.activity_main);
    38.         ButterKnife.bind(this);
    39.         Intent intent=new Intent(getApplicationContext(),AidlService.class);
    40.         bindService(intent,serviceConnection,BIND_AUTO_CREATE);
    41.     }
    42.  
    43.  
    44.     @OnClick(R.id.send_message)
    45.     public void onViewClicked(View view) {
    46.         if (iAidlInterface!=null){
    47.             try {
    48.                 iAidlInterface.sendMessage("消息"+num);
    49.                 num++;
    50.             } catch (RemoteException e) {
    51.                 e.printStackTrace();
    52.             }
    53.         }
    54.     }
    55.  
    56.     private ServiceConnection serviceConnection=new ServiceConnection() {
    57.         @Override
    58.         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
    59.             iAidlInterface=IAidlInterface.Stub.asInterface(iBinder);
    60.             try {
    61.                 iAidlInterface.asBinder().linkToDeath(mDeathRecipient, 0);//监听进程是否消失
    62.                 iAidlInterface.registerCallBack(iAidlCallBack);//注册消息回调
    63.                 messages.addAll(iAidlInterface.getMessages());//获取历史消息
    64.                 listView.setAdapter(arrayAdapter=new ArrayAdapter<>(getApplicationContext(),android.R.layout.simple_list_item_1,messages));
    65.             } catch (RemoteException e) {
    66.                 e.printStackTrace();
    67.             }
    68.         }
    69.  
    70.         @Override
    71.         public void onServiceDisconnected(ComponentName componentName) {
    72.  
    73.         }
    74.     };
    75.  
    76.     private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
    77.         //当承载IBinder的进程消失时接收回调的接口
    78.         @Override
    79.         public void binderDied() {
    80.             if (null == iAidlInterface) {
    81.                 return;
    82.             }
    83.             try {
    84.                 iAidlInterface.unregisterCallBack(iAidlCallBack);//注销
    85.             } catch (RemoteException e) {
    86.                 e.printStackTrace();
    87.             }
    88.             iAidlInterface.asBinder().unlinkToDeath(mDeathRecipient, 0);
    89.             iAidlInterface = null;
    90.         }
    91.     };
    92.  
    93.     private IAidlCallBack iAidlCallBack=new IAidlCallBack.Stub() {
    94.         @Override
    95.         public void onMessageSuccess(String message) {
    96.             if (messages!=null&&arrayAdapter!=null){
    97.                 messages.add(message);
    98.                 handler.sendEmptyMessage(1);
    99.             }
    100.         }
    101.     };
    102.  
    103.     @SuppressLint("HandlerLeak")
    104.     private Handler handler=new Handler(){
    105.         @Override
    106.         public void handleMessage(@NonNull Message msg) {
    107.             arrayAdapter.notifyDataSetChanged();
    108.         }
    109.     };
    110.  
    111.     @Override
    112.     protected void onDestroy() {
    113.         //解除注册
    114.         if (null != iAidlInterface && iAidlInterface.asBinder().isBinderAlive()) {
    115.             try {
    116.                 iAidlInterface.unregisterCallBack(iAidlCallBack);
    117.             } catch (RemoteException e) {
    118.                 e.printStackTrace();
    119.             }
    120.         }
    121.         //解除绑定服务
    122.         unbindService(serviceConnection);
    123.         super.onDestroy();
    124.     }
    125. }

    到此我们的服务端就编码完成，实现效果

3.客户端实现

   创建client工程

  •      选中TestAidlDemo1工程右键NEW一个model，命名为client
  • 要想client项目能够连接上Service，我们直接复制上面工程的aidl文件到client工程的main文件里，这样是为了保证两个项目的aidl文件路径一致

       

  • 而调用逻辑基本和上面MainActivity一样，需要注意一点的是，因为是两个不同进程，在这里我们不能直接bindService来调起服务端，而是通过以下代码实现 
    1. Intent intent=new Intent();
    2. String ACTION = "AIDL.service";//对应服务端AndroidManifest.xml配置service action:name
    3. intent.setAction(ACTION);
    4. intent.setPackage("com.pgc.testaidldemo1");//对应服务端AndroidManifest.xml package
    5. bindService(intent,serviceConnection,BIND_AUTO_CREATE);

     

  • client的MainActivity全部代码

    1. package com.pgc.client;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.content.ComponentName;
    5. import android.content.Intent;
    6. import android.content.ServiceConnection;
    7. import android.os.Bundle;
    8. import android.os.Handler;
    9. import android.os.IBinder;
    10. import android.os.Message;
    11. import android.os.RemoteException;
    12. import android.view.View;
    13. import android.widget.ArrayAdapter;
    14. import android.widget.ListView;
    15.  
    16. import androidx.annotation.NonNull;
    17. import androidx.appcompat.app.AppCompatActivity;
    18.  
    19. import com.pgc.testaidldemo1.IAidlCallBack;
    20. import com.pgc.testaidldemo1.IAidlInterface;
    21.  
    22. import java.util.ArrayList;
    23. import java.util.List;
    24.  
    25. import butterknife.BindView;
    26. import butterknife.ButterKnife;
    27. import butterknife.OnClick;
    28.  
    29. public class MainActivity extends AppCompatActivity {
    30.     @BindView(R.id.list_view)
    31.     ListView listView;
    32.     private IAidlInterface iAidlInterface;
    33.     private int num;
    34.     private List<String> messages=new ArrayList<>();
    35.     private ArrayAdapter arrayAdapter;
    36.     @Override
    37.     protected void onCreate(Bundle savedInstanceState) {
    38.         super.onCreate(savedInstanceState);
    39.         setContentView(R.layout.activity_main);
    40.         ButterKnife.bind(this);
    41.         Intent intent=new Intent();
    42.         String ACTION = "AIDL.service";
    43.         intent.setAction(ACTION);
    44.         intent.setPackage("com.pgc.testaidldemo1");
    45.         bindService(intent,serviceConnection,BIND_AUTO_CREATE);
    46.     }
    47.  
    48.  
    49.     @OnClick(R.id.send_message)
    50.     public void onViewClicked(View view) {
    51.         if (iAidlInterface!=null){
    52.             try {
    53.                 iAidlInterface.sendMessage("消息"+num);
    54.                 num++;
    55.             } catch (RemoteException e) {
    56.                 e.printStackTrace();
    57.             }
    58.         }
    59.     }
    60.  
    61.     private ServiceConnection serviceConnection=new ServiceConnection() {
    62.         @Override
    63.         public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
    64.             iAidlInterface=IAidlInterface.Stub.asInterface(iBinder);
    65.             try {
    66.                 iAidlInterface.asBinder().linkToDeath(mDeathRecipient, 0);
    67.                 iAidlInterface.registerCallBack(iAidlCallBack);
    68.                 messages.addAll(iAidlInterface.getMessages());
    69.                 listView.setAdapter(arrayAdapter=new ArrayAdapter<>(getApplicationContext(),android.R.layout.simple_list_item_1,messages));
    70.             } catch (RemoteException e) {
    71.                 e.printStackTrace();
    72.             }
    73.         }
    74.  
    75.         @Override
    76.         public void onServiceDisconnected(ComponentName componentName) {
    77.  
    78.         }
    79.     };
    80.  
    81.     private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
    82.         //当承载IBinder的进程消失时接收回调的接口
    83.         @Override
    84.         public void binderDied() {
    85.             if (null == iAidlInterface) {
    86.                 return;
    87.             }
    88.             iAidlInterface.asBinder().unlinkToDeath(mDeathRecipient, 0);
    89.             iAidlInterface = null;
    90.             //断线重来逻辑
    91.         }
    92.     };
    93.  
    94.     private IAidlCallBack iAidlCallBack=new IAidlCallBack.Stub() {
    95.         @Override
    96.         public void onMessageSuccess(String message) {
    97.             if (messages!=null&&arrayAdapter!=null){
    98.                 messages.add(message);
    99.                 handler.sendEmptyMessage(1);
    100.             }
    101.         }
    102.     };
    103.  
    104.     @SuppressLint("HandlerLeak")
    105.     private Handler handler=new Handler(){
    106.         @Override
    107.         public void handleMessage(@NonNull Message msg) {
    108.             arrayAdapter.notifyDataSetChanged();
    109.         }
    110.     };
    111.  
    112.     @Override
    113.     protected void onDestroy() {
    114.         //解除注册
    115.         if (null != iAidlInterface && iAidlInterface.asBinder().isBinderAlive()) {
    116.             try {
    117.                 iAidlInterface.unregisterCallBack(iAidlCallBack);
    118.             } catch (RemoteException e) {
    119.                 e.printStackTrace();
    120.             }
    121.         }
    122.         //解除绑定服务
    123.         unbindService(serviceConnection);
    124.         super.onDestroy();
    125.     }
    126. }

     

  • 运行效果

源码下载地址

https://github.com/pengkongkong/TestAidlDemo1

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/122659
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号