[关闭]
@Tyhj 2020-03-18T15:19:20.000000Z 字数 13625 阅读 703

Android跨进程通信

Android


Android跨进程通信的方式也是比较多的,项目中用的比较多的应该是Messenger和AIDL,主要讲一下两者的实现

跨进程通信的方式

1、四大组件间传递Bundle;
2、文件共享,多进程读写一个相同的文件,获取文件内容进行交互;
3、Messenger,利用Handler实现。(适用于多进程、单线程,不需要考虑线程安全),其底层基于AIDL。
4、AIDL(Android Interface Definition Language,Android接口定义语言),大部分应用程序不应该使用AIDL去创建一个绑定服务,因为它需要多线程能力,并可能导致一个更复杂的实现。
5、ContentProvider,常用于多进程共享数据,比如系统的相册,音乐等,我们也可以通过ContentProvider访问到;
6、Socket传输数据。

Messenger

Messenger的实现比较简单,底层基于AIDL,适用于多进程、单线程,不需要考虑线程安全;

实现思路

Messenger就是信使的意思;在服务端创建一个信使,在客户端创建一个信使,当客户端绑定服务的时候,服务端将信使传递给客户端,客户端就可以通过服务端的信使发送消息给服务端;客户端也可以将自己的信使作为消息发送给服务端,服务端拿到客户端的信使就可以发送消息给客户端了,就实现了双方的通信。

具体实现

服务端在onBind方法返回自己的信使给客户端,等客户端发送客户端的信使过来后进行保存,然后就可以使用客户端的信使给客户端发消息了;

  1. public class MessengerService extends Service {
  2. /**
  3. *客户端的信使
  4. */
  5. private Messenger clientMessenger;
  6. @Nullable
  7. @Override
  8. public IBinder onBind(Intent intent) {
  9. //返回自己的信使
  10. return messenger.getBinder();
  11. }
  12. private Handler handler = new Handler() {
  13. @Override
  14. public void handleMessage(@NonNull Message msg) {
  15. switch (msg.what) {
  16. //接受客户端的信使
  17. case 1:
  18. clientMessenger = msg.replyTo;
  19. break;
  20. //使用客户端的信使发送消息
  21. case 2:
  22. if (clientMessenger != null) {
  23. try {
  24. String name=msg.getData().getString("name");
  25. Bundle bundle = new Bundle();
  26. bundle.putString("name", "messenger is "+name);
  27. Message message = new Message();
  28. message.what=2;
  29. message.setData(bundle);
  30. //发送消息
  31. clientMessenger.send(message);
  32. } catch (RemoteException e) {
  33. e.printStackTrace();
  34. }
  35. }
  36. break;
  37. default:
  38. break;
  39. }
  40. }
  41. };
  42. /**
  43. * 服务本地信使
  44. */
  45. private Messenger messenger = new Messenger(handler);
  46. }

当然服务需要在AndroidManifest文件中申明为单独进程运行

  1. <service android:name=".service.MessengerService"
  2. android:enabled="true"
  3. android:exported="true"
  4. android:process="com.yorhp.messenger.name">
  5. <intent-filter>
  6. <action android:name="com.yorhp.messenger.name"/>
  7. </intent-filter>
  8. </service>

客户端,在服务连接后获取到服务端的信使,将自己的信使发送到服务端

  1. @SuppressLint("HandlerLeak")
  2. private Handler handler = new Handler() {
  3. @Override
  4. public void handleMessage(@NonNull Message msg) {
  5. switch (msg.what) {
  6. case 2:
  7. String name = msg.getData().getString("name");
  8. Toast.makeText(MainActivity.this, name, Toast.LENGTH_SHORT).show();
  9. break;
  10. default:
  11. break;
  12. }
  13. }
  14. };
  15. /**
  16. * messenger服务连接监听
  17. */
  18. private ServiceConnection mMessengerServiceConnection = new ServiceConnection() {
  19. @Override
  20. public void onServiceConnected(ComponentName name, IBinder service) {
  21. try {
  22. //获取到服务端信使
  23. serviceMessenger = new Messenger(service);
  24. Message message = new Message();
  25. //将客户端信使传递到服务端
  26. message.replyTo = new Messenger(handler);;
  27. message.what = 1;
  28. //使用服务端信使发送
  29. serviceMessenger.send(message);
  30. } catch (RemoteException e) {
  31. e.printStackTrace();
  32. }
  33. }
  34. @Override
  35. public void onServiceDisconnected(ComponentName name) {
  36. }
  37. };

绑定服务后就可以使用服务端的信使发送消息给服务端了,因为实现借助Handler实现,所以需要制定相应的协议,这里代码发message.what=1为传输客户端的信使,message.what = 2为请求数据;

  1. //绑定服务
  2. bindService(new Intent(MainActivity.this, MessengerService.class), mMessengerServiceConnection, BIND_AUTO_CREATE);
  3. //Messenger进行通信
  4. findViewById(R.id.btnMessenger).setOnClickListener(v -> {
  5. try {
  6. Message message = new Message();
  7. message.what = 2;
  8. Bundle bundle=new Bundle();
  9. bundle.putString("name","Tony");
  10. message.setData(bundle);
  11. //使用
  12. serviceMessenger.send(message);
  13. } catch (RemoteException e) {
  14. e.printStackTrace();
  15. }
  16. });

实现还是比较简单的,两个APP间的通信也是一样的实现,只是需要对service进行配置,设置可以被其他APP启动

  1. <service android:name=".service.MessengerService"
  2. android:enabled="true"
  3. android:exported="true"
  4. android:process="com.yorhp.messenger.name">
  5. <intent-filter>
  6. <action android:name="com.yorhp.messenger.name"/>
  7. </intent-filter>
  8. </service>

启动方式也有所不同,改为隐式启动,其他都一样

  1. Intent intentMessenger = new Intent();
  2. intentMessenger.setAction("com.yorhp.messenger.name");
  3. intentMessenger.setPackage("com.yorhp.interprocesscommunication");
  4. bindService(intentMessenger, mMessengerServiceConnection, BIND_AUTO_CREATE);

AIDL

实现思路

服务端要创建一个Service用来监听客户端的连接请求,然后创建一个AIDL文件,将暴露给客户端的接口在这个AIDL文件中申明,最后在Service中实现接口即可;

客户端需要绑定这个服务,然后将服务器返回的Binder对象转成AIDL接口所属的类型,然后就可以调用AIDL中的接口了;AIDL的接口方法是在服务端的Binder线程池中执行的,因此当多个客户端同时连接的时候,会存在多个线程同时访问的情形,所以看实现的功能可能需要考虑多线程问题。

具体实现

创建AIDL,先在main文件夹下面创建一个aidl的文件夹,然后新建一个AIDL文件,里面会有一个默认的接口,在里面新建接口;系统会在/app/build/generated/aidl_source_output_dir/debug/out/com/yorhp/interprocesscommunication/下面生成Java文件,如果没有可以rebuild一下

  1. // IMyAidlInterface.aidl
  2. package com.yorhp.interprocesscommunication;
  3. // Declare any non-default types here with import statements
  4. interface IMyAidlInterface {
  5. /**
  6. * Demonstrates some basic types that you can use as parameters
  7. * and return values in AIDL.
  8. */
  9. void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
  10. double aDouble, String aString);
  11. /**
  12. *
  13. *获取姓名
  14. */
  15. String getName(String nickName);
  16. }

然后新建Service,实现这个AIDL接口

  1. public class AIDLService extends Service {
  2. IMyAidlInterface.Stub stub=new IMyAidlInterface.Stub() {
  3. @Override
  4. public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {
  5. }
  6. @Override
  7. public String getName(String nickName) throws RemoteException {
  8. return "aidl is "+nickName;
  9. }
  10. };
  11. @Nullable
  12. @Override
  13. public IBinder onBind(Intent intent) {
  14. return stub;
  15. }
  16. }

同样,Service申明为单独进程运行

  1. <service android:name=".service.AIDLService"
  2. android:enabled="true"
  3. android:exported="true"
  4. android:process="com.yorhp.aidl.test.service">
  5. <intent-filter>
  6. <action android:name="com.yorhp.aild.name"/>
  7. </intent-filter>
  8. </service>

客户端在服务绑定的时候获取到AIDL接口对应的对象,调用接口即可

  1. /**
  2. * AIDL服务连接监听
  3. */
  4. private ServiceConnection mAIDLServiceConnection = new ServiceConnection() {
  5. @Override
  6. public void onServiceConnected(ComponentName name, IBinder service) {
  7. myAidlInterface = IMyAidlInterface.Stub.asInterface(service);
  8. //Log.i("MainActivity","service connected");
  9. Toast.makeText(MainActivity.this, "service connected", Toast.LENGTH_SHORT).show();
  10. }
  11. @Override
  12. public void onServiceDisconnected(ComponentName name) {
  13. }
  14. };
  15. //绑定服务
  16. bindService(new Intent(MainActivity.this, AIDLService.class), mAIDLServiceConnection, BIND_AUTO_CREATE);
  17. //AIDL进行通信
  18. findViewById(R.id.btnAIDL).setOnClickListener(v -> {
  19. try {
  20. String name = null;
  21. name = myAidlInterface.getName("Nick");
  22. Toast.makeText(MainActivity.this, name, Toast.LENGTH_SHORT).show();
  23. } catch (RemoteException e) {
  24. e.printStackTrace();
  25. }
  26. });

如果另一个APP访问这个进程需要将这个aidl文件都复制到另一个APP中,并且包名要一样,然后隐式调用服务就好了

  1. Intent intent = new Intent();
  2. intent.setAction("com.yorhp.aild.name");
  3. intent.setPackage("com.yorhp.interprocesscommunication");
  4. bindService(intent, bindService, BIND_AUTO_CREATE);

AIDL文件支持:

Parcelable对象

自定义的对象需要实现Parcelable接口,举个例子,新建一个User对象,实现Parcelable接口

  1. public class User implements Parcelable {
  2. /**
  3. * 姓名
  4. */
  5. private String name;
  6. /**
  7. * 年龄
  8. */
  9. private int age;
  10. public User(String name, int age) {
  11. this.name = name;
  12. this.age = age;
  13. }
  14. protected User(Parcel in) {
  15. name = in.readString();
  16. age = in.readInt();
  17. }
  18. public static final Creator<User> CREATOR = new Creator<User>() {
  19. @Override
  20. public User createFromParcel(Parcel in) {
  21. return new User(in);
  22. }
  23. @Override
  24. public User[] newArray(int size) {
  25. return new User[size];
  26. }
  27. };
  28. @Override
  29. public int describeContents() {
  30. return 0;
  31. }
  32. @Override
  33. public void writeToParcel(Parcel dest, int flags) {
  34. dest.writeString(name);
  35. dest.writeInt(age);
  36. }
  37. }

在AIDL文件中新增接口,在AIDL中引用Parcelable对象和AIDL对象的时候必须要显式的import进来,而且Parcelable对象也需要新建一个同名的AIDL文件,并在其中申明它为parcelable对象;

感觉这里关于包名的设定还是有点坑,如果写写demo把文件都放在一个文件夹下面没什么问题,但是稍微修改一下目录就会出问题,这里还是有一定的规则的,我把文件目录展示出来;
截屏2020-03-17下午11.54.54.png-45.8kB

首先新建一个User.aidl文件,里面的package是可以不和真实路径一致的,但是必须和User.java文件的包名一致,不然会报错

  1. // User.aidl
  2. //这个包名必须和java文件的包名一致,路径和真实路径不一样也可以
  3. package com.yorhp.interprocesscommunication.bean;
  4. // Declare any non-default types here with import statements
  5. parcelable User;

然后修改AIDL接口,需要显式引用User对象,这个对象必须是User.aidl的文件路径,不然会报错,其实引用就是这个AIDL对象,不然申明了干什么

  1. // IMyAidlInterface.aidl
  2. package com.yorhp.interprocesscommunication;
  3. //这个包名必须是User.aidl文件的路径
  4. import com.yorhp.interprocesscommunication.bean.User;
  5. // Declare any non-default types here with import statements
  6. interface IMyAidlInterface {
  7. /**
  8. * Demonstrates some basic types that you can use as parameters
  9. * and return values in AIDL.
  10. */
  11. void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
  12. double aDouble, String aString);
  13. /**
  14. *
  15. *获取姓名
  16. */
  17. String getName(String nickName);
  18. /**
  19. *获取用户
  20. */
  21. User getUserById(int id);
  22. }

同样Service实现新的接口

  1. public class AIDLService extends Service {
  2. IMyAidlInterface.Stub stub=new IMyAidlInterface.Stub() {
  3. @Override
  4. public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {
  5. }
  6. @Override
  7. public String getName(String nickName) throws RemoteException {
  8. return "aidl is "+nickName;
  9. }
  10. @Override
  11. public User getUserById(int id) throws RemoteException {
  12. return new User("Tyhj",1);
  13. }
  14. };
  15. @Nullable
  16. @Override
  17. public IBinder onBind(Intent intent) {
  18. return stub;
  19. }
  20. }

客户端进行接口调用

  1. //绑定服务
  2. bindService(new Intent(MainActivity.this, AIDLService.class), mAIDLServiceConnection, BIND_AUTO_CREATE);
  3. //AIDL进行通信
  4. findViewById(R.id.btnAIDL).setOnClickListener(v -> {
  5. try {
  6. String name = null;
  7. User user=myAidlInterface.getUserById(0);
  8. name = user.getName();
  9. Toast.makeText(MainActivity.this, name, Toast.LENGTH_SHORT).show();
  10. } catch (RemoteException e) {
  11. e.printStackTrace();
  12. }
  13. });

同样的如果要在另一个APP访问服务,需要把AIDL和相关的类都拷贝过去,Parcelable类也需要放在同样的包名下

AIDL对象

在方法中传入一个监听接口是比较常用的方法,但是在AIDL中是不支持普通接口的,只支持AIDL接口;新建一个AIDL接口,用于监听用户的变化,当用户改变时,把最新的用户信息通知到客户端;

  1. import com.yorhp.interprocesscommunication.bean.User;
  2. // Declare any non-default types here with import statements
  3. interface IOnUserChangedListener {
  4. /**
  5. *用户改变监听
  6. */
  7. void onUserChanged(in User user);
  8. }

AIDL中的in、out、inout的区别

其中AIDL中除了基本数据类型和String外,其他参数必须标上方向:in、out或者inout;定向tag是AIDL中语法的一部分,其中in、out、inout是三个定向tag。在官网上关于Android定向tag的定义是这样的:

All non-primitive parameters require a directional tag indicating which way the data goes .
Either in , out , or inout . Primitives are in by default , and connot be otherwise .

意思就是所有非基本类型的参数都需要一个定向tag来表明数据是如何走向的,要不是in,out或者inout。基本数据类型默认是in,而且不能是其他tag。

定向 tag 表示了在跨进程通信中数据的流向,其中 in 表示数据只能由客户端流向服务端, out 表示数据只能由服务端流向客户端,而 inout 则表示数据可以在服务端与客户端之间双向流通。其中的数据流向是针对在客户端中的那个传入方法的对象而言的。

对于in,服务端将会收到客户端对象的完整数据,但是客户端对象不会因为服务端对传参的修改而发生变动。类似的行为在Java中的表现是,在Java方法中,对传进来的参数进行了深复制,传进来的参数不会受到深复制后的对象的影响。这和in的行为有点类似。

对于out,服务端将会收到客户端对象,该对象不为空,但是它里面的字段为空,但是在服务端对该对象作任何修改之后客户端的传参对象都会同步改动。类似的行为在Java中的表现是,在Java方法中,对传进来的参数进行忽略,并new一个新对象,所有的操作都是围绕着这个新对象进行的,最后将该新对象赋值给传参对象。

对于inout ,服务端将会接收到客户端传来对象的完整信息,并且客户端将会同步服务端对该对象的任何变动。类似的行为在Java中的表现是,在Java方法中,对传进来的参数进行修改并返回。

参考文章 AIDL中的in、out、inout的区别

然后继续修改IMyAidlInterfaceAIDL文件,新增两个方法,注册和取消注册

  1. //这个包名必须是User.aidl文件的路径
  2. import com.yorhp.interprocesscommunication.bean.User;
  3. import com.yorhp.interprocesscommunication.IOnUserChangedListener;
  4. // Declare any non-default types here with import statements
  5. interface IMyAidlInterface {
  6. /**
  7. *
  8. *获取姓名
  9. */
  10. String getName(String nickName);
  11. /**
  12. *获取用户
  13. */
  14. User getUserById(int id);
  15. /**
  16. *
  17. *注册监听
  18. */
  19. void registerListener(IOnUserChangedListener listener);
  20. /**
  21. *
  22. *取消监听
  23. */
  24. void unRegisterListener(IOnUserChangedListener listener);
  25. }

然后修改AIDLService文件,实现新的接口,模拟了数据改变

  1. public class AIDLService extends Service {
  2. /**
  3. * 监听集合,自动进行线程同步,线程安全
  4. */
  5. private CopyOnWriteArrayList<IOnUserChangedListener> listeners = new CopyOnWriteArrayList<>();
  6. @Override
  7. public void onCreate() {
  8. super.onCreate();
  9. //开启线程模拟用户数据改变,回调
  10. new Thread(()->{
  11. while (true){
  12. for (IOnUserChangedListener listener:listeners){
  13. try {
  14. //返回用户数据
  15. listener.onUserChanged(new User("Tyhj"+System.currentTimeMillis(),10));
  16. } catch (RemoteException e) {
  17. e.printStackTrace();
  18. }
  19. }
  20. SystemClock.sleep(2000);
  21. }
  22. }).start();
  23. }
  24. IMyAidlInterface.Stub stub = new IMyAidlInterface.Stub() {
  25. @Override
  26. public String getName(String nickName) throws RemoteException {
  27. return "aidl is " + nickName;
  28. }
  29. @Override
  30. public User getUserById(int id) throws RemoteException {
  31. return new User("Tyhj", 1);
  32. }
  33. @Override
  34. public void registerListener(IOnUserChangedListener listener) throws RemoteException {
  35. if (!listeners.contains(listener)) {
  36. listeners.add(listener);
  37. }
  38. }
  39. @Override
  40. public void unRegisterListener(IOnUserChangedListener listener) throws RemoteException {
  41. listeners.remove(listener);
  42. }
  43. };
  44. @Nullable
  45. @Override
  46. public IBinder onBind(Intent intent) {
  47. return stub;
  48. }
  49. }

然后在客户端调用新的方法,返回的数据不在主线程需要做线程切换

  1. /**
  2. * AIDL服务连接监听
  3. */
  4. private ServiceConnection mAIDLServiceConnection = new ServiceConnection() {
  5. @Override
  6. public void onServiceConnected(ComponentName name, IBinder service) {
  7. myAidlInterface = IMyAidlInterface.Stub.asInterface(service);
  8. //Log.i("MainActivity","service connected");
  9. try {
  10. //注册监听
  11. myAidlInterface.registerListener(new IOnUserChangedListener.Stub() {
  12. @Override
  13. public void onUserChanged(User user) throws RemoteException {
  14. handler.post(()->{
  15. Toast.makeText(MainActivity.this, user.getName(), Toast.LENGTH_SHORT).show();
  16. });
  17. }
  18. });
  19. } catch (RemoteException e) {
  20. e.printStackTrace();
  21. }
  22. Toast.makeText(MainActivity.this, "service connected", Toast.LENGTH_SHORT).show();
  23. }
  24. @Override
  25. public void onServiceDisconnected(ComponentName name) {
  26. }
  27. };

但是当取消注册监听的时候失败了,其实仔细看取消注册接口的实现listeners.remove(listener);,在不同的进程里面,这两个listener对象肯定不可能指向一个地址的,传过来的这个对象肯定是会被转换并生成成新对象的,因为跨进程传对象本质就是序列化和反序列化,所以是会失败的;可以使用RemoteCallbackList,是系统专门用于提供删除跨进程listener的接口;它的实现是一个Map,key存了传入listener.asBinder(),就是这个AIDL对象的Binder对象,这个对象对于同一个客户端是不变的,value就是保存了这个AIDL对象的一个封装对象;

  1. IBinder binder = callback.asBinder();
  2. try {
  3. Callback cb = new Callback(callback, cookie);
  4. binder.linkToDeath(cb, 0);
  5. mCallbacks.put(binder, cb);
  6. return true;
  7. } catch (RemoteException e) {
  8. return false;
  9. }

RemoteCallbackList不是一个List对象,所以操作也有些不同,修改服务端代码

  1. public class AIDLService extends Service {
  2. /**
  3. * 监听集合,自动进行线程同步,线程安全
  4. */
  5. private RemoteCallbackList<IOnUserChangedListener> listeners = new RemoteCallbackList<>();
  6. @Override
  7. public void onCreate() {
  8. super.onCreate();
  9. //开启线程模拟用户数据改变,回调
  10. new Thread(()->{
  11. while (true){
  12. final int n=listeners.beginBroadcast();
  13. for (int i=0;i<n;i++){
  14. try {
  15. IOnUserChangedListener listener=listeners.getBroadcastItem(i);
  16. //返回用户数据
  17. listener.onUserChanged(new User("Tyhj"+System.currentTimeMillis(),10));
  18. } catch (RemoteException e) {
  19. e.printStackTrace();
  20. }
  21. }
  22. listeners.finishBroadcast();
  23. SystemClock.sleep(2000);
  24. }
  25. }).start();
  26. }
  27. IMyAidlInterface.Stub stub = new IMyAidlInterface.Stub() {
  28. @Override
  29. public String getName(String nickName) throws RemoteException {
  30. return "aidl is " + nickName;
  31. }
  32. @Override
  33. public User getUserById(int id) throws RemoteException {
  34. return new User("Tyhj", 1);
  35. }
  36. @Override
  37. public void registerListener(IOnUserChangedListener listener) throws RemoteException {
  38. listeners.register(listener);
  39. }
  40. @Override
  41. public void unRegisterListener(IOnUserChangedListener listener) throws RemoteException {
  42. listeners.unregister(listener);
  43. }
  44. };
  45. @Nullable
  46. @Override
  47. public IBinder onBind(Intent intent) {
  48. return stub;
  49. }
  50. }

里面需要注意的是listeners.beginBroadcast();listeners.finishBroadcast();必须配对使用;

总结

讲道理,其实仔细看看还是挺简单的

项目地址

服务端(也包含客户端)地址:https://github.com/tyhjh/AIDL-Service
客户端地址:https://github.com/tyhjh/AIDL-Client

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注