当前位置: 首页 > 编程笔记 >

Android IPC机制利用Messenger实现跨进程通信

樊胜
2023-03-14
本文向大家介绍Android IPC机制利用Messenger实现跨进程通信,包括了Android IPC机制利用Messenger实现跨进程通信的使用技巧和注意事项,需要的朋友参考一下

写作原因:跨进程通信的实现和理解是Android进阶中重要的一环。下面博主分享IPC一些相关知识、操作及自己在学习IPC过程中的一些理解。这一章使用Messenger实现跨进程通信,其中bindService基础部分参见Android IPC机制绑定Service实现本地通信。

跨进程简介

在介绍使用Messenger跨进程通信之前先要了解以下问题:为什么需要跨进程通信?只有有了需求才有学习的价值。我个人将不同进程简单的理解为不同的应用程序(当然也有例外,比如可以在同一个应用程序中开启两个或多个进程)。由于进程之间不能像线程一样共享内存,所以数据通信不能像线程一般进行。在Android中可以使用bundle,广播,Messenger,AIDL和Socket进行跨进程通信。本章利用Messenger分别进行单应用程序多进程单向通信和多应用程序多进程双向通信的实现。

Messenger介绍

Messenger是通过使用Message来实现跨进程通信,一次实现一个请求的方式,这是它的优点也是缺点。其底层实现为AIDL(下章我将阐述)。Messenger的优点是:基于Message,方便使用;支持回调的方式,也就是服务端处理完成长任务可以和客户端交互;不需要编写aidl文件。

Messenger使用流程如下(转载):

单应用程序多进程单向通信

先介绍一下Android中单应用程序开启多进程的方法,实际上只要在mainfests中的你想开启新进程的组件的XML中添加<android:progress = ":remote(可以自定义)">或者<android:progress = "包.remote(可以自定义)">就行。如:

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

这样就把Service放在新的线程中运行了。

Service实现

 下面是服务端的代码实现,具体思路是:创建一个Handler对象用来处理客户端发送来的消息,再创建一个Messenger对象将上面的Handler对象作为参数传入,这样我们就获得了一个信使。下面就是通过getBinder()把这个信使创建的Binder对象返回给客户端(一旦客户端拿到这个Binder,又可以将它还原为Messenger)。Handler中处理信息为:当得到的Message的what值为MSG_SAY_HELLO时输出Toast。

public class CustomService extends Service{
  static final int MSG_SAY_HELLO = 1;
  //实现一个能够处理接收信息的Handler
  class IncomingHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
      super.handleMessage(msg);
      switch(msg.what){
        case MSG_SAY_HELLO:
          Toast.makeText(getApplicationContext(),"hello!",Toast.LENGTH_SHORT).show();
          break;
        default:
          super.handleMessage(msg);
      }
    }
  }
  //被客户端接收的Messenger对象
  final Messenger messenger = new Messenger(new IncomingHandler());
  @Override
  public IBinder onBind(Intent intent) {
    Toast.makeText(getApplicationContext(),"binding!",Toast.LENGTH_SHORT).show();
    return messenger.getBinder();
  }
}

 Activity实现

 在客户端中我们应该做的是:拿到服务端传来的Messenger对象(在ServiceConnection中取得,具体参见上一篇文章),然后创建一个Message对象,为Message写入数据,注意Message中的what要与服务端中Handler对象中的what一致。使用该Messenger通过send()将Message发送给服务端,这样就可以实现客户端与服务端的单向通信了。

具体代码如下:

 

public class MainActivity extends AppCompatActivity {
  private Button mBtStart;
  private Messenger messenger = null;
  private boolean mBound;
  private TextView mTvMsg;
  private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
      messenger = new Messenger(service);
      mBound = true;
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      messenger = null;
      mBound = false;
    }
  };
  public void sayHello(View v){
    if(!mBound) return;
    Message msg = Message.obtain(null,CustomService.MSG_SAY_HELLO,0,0);
    try{
      messenger.send(msg);
    }catch (RemoteException e){
      e.printStackTrace();
    }
  }
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    mBtStart = (Button) findViewById(R.id.bt_start);
    mTvMsg = (TextView) findViewById(R.id.tv_msg);
    mBtStart.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        Intent intent = new Intent(MainActivity.this,CustomService.class);
        bindService(new Intent(MainActivity.this,CustomService.class),serviceConnection, Context.BIND_AUTO_CREATE);
      }
    });
  }
  @Override
  protected void onStop() {
    super.onStop();
    // Unbind from the service
    if (mBound) {
      unbindService(serviceConnection);
      mBound = false;
    }
  }
}

 以上过程一开始理解可能会有些抽象,多动手才能加深理解。

 多应用程序多进程双向通信

仍然以Activity和Service通信为例,不过这次我们需要新建两个Module(ClientApp和ServiceApp),ClientApp中就一个Activity,ServiceApp中一个Service(关于没有Activity的App的启动方式自行百度)。这样就是两个应用程序两个进程的情况了。

下面开始分析这种情况下的Messenger的用法:

Service实现

依然是先从Service开始。大致思路与上面的Service的创建类似,但又一点不同的是,这次我们需要新建一个clientMessenger来实现Service向客户端发送Message操作。在Service的Handler中有这样一段代码,

clientMessenger = msg.replyTo;//这个Message是在客户端中创建的
        if(clientMessenger!=null){
          Message msgToClient = Message.obtain();
          msgToClient.what = SEND_MESSAGE_CODE;
          Bundle bundle = new Bundle();
          bundle.putString("msg","客户端,我接收到你的消息了,这是我回应给你的,看到了吗?");
          msgToClient.setData(bundle);
          try {
            clientMessenger.send(msgToClient);
          } catch (RemoteException e) {
            e.printStackTrace();
          }
        }

上面代码用来接收到客户端发送来的数据后向客户端发送数据作出回应。注意这里的clientMessenger = msg.replyTo;,是指从客户端中取出与msg一道捆绑过来的clientMessenger对象。利用clientMessenger就可以实现向Activity中返回数据了。

详细代码如下:

public class MyService extends Service {
  private static final int RECEIVE_MESSAGE_CODE = 0x0001;
  private static final int SEND_MESSAGE_CODE = 0x0002;

  private Messenger clientMessenger = null;
  private Messenger serviceMessenger = new Messenger(new ServiceHandler());
  @Override
  public IBinder onBind(Intent intent) {
    return serviceMessenger.getBinder();
  }

  @Override
  public void onCreate() {
    super.onCreate();
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
    clientMessenger = null;
  }

  private class ServiceHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
      super.handleMessage(msg);
      if(msg.what == RECEIVE_MESSAGE_CODE){
        Bundle data = msg.getData();
        if(data != null){
          String str = data.getString("msg");
          Toast.makeText(getApplicationContext(),"Service:I received the message:"+str,Toast.LENGTH_SHORT).show();
        }
        clientMessenger = msg.replyTo;//这个Message是在客户端中创建的
        if(clientMessenger!=null){
          Message msgToClient = Message.obtain();
          msgToClient.what = SEND_MESSAGE_CODE;
          Bundle bundle = new Bundle();
          bundle.putString("msg","客户端,我接收到你的消息了,这是我回应给你的,看到了吗?");
          msgToClient.setData(bundle);
          try {
            clientMessenger.send(msgToClient);
          } catch (RemoteException e) {
            e.printStackTrace();
          }
        }
      }

    }
  }
}

Activity实现:

Activity中主要是实现绑定发送数据和解除绑定两大块功能。绑定先发送显式Intent(5.0以上不支持隐式启动Service,具体操作见下面的启动过程)绑定Service,当绑定成功后获取Messenger对象并使用该对象发送Message对象msg给Service,具体操作与上面的一样。这里有一点不一样的是,为了能够使得Service能获得clientMessenger,我们必须手动将msg与clientMessenger关联,即:msg.replyTo = clientMessenger;。这样Service在获得Activity发送过来的Message的同时也可以取到clientMessenger。而clientMessenger必须先创建出来,方法与单向获取时一致。

详细代码如下:

public class MainActivity extends AppCompatActivity{
  private Button mBtBind;
  private Button mBtUnBind;
  private TextView mTvMsg;

  private static final int SEND_MESSAGE_CODE = 0x0001;
  private static final int RECEIVE_MESSAGE_CODE = 0x0002;
  private boolean isBound = false;

  private String SERVICE_ACTION = "com.example.serviceapp.MyService";

  private Messenger serviceMessenger = null;

  private Messenger clientMessenger = new Messenger(new ClientHandler());
  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    mBtBind = (Button) findViewById(R.id.bt_bind);
    mBtUnBind = (Button) findViewById(R.id.bt_unbind);
    mTvMsg = (TextView) findViewById(R.id.tv_msg);
    mBtUnBind.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        if(isBound){
          unbindService(serviceConnection);
        }
      }
    });
    mBtBind.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        if(!isBound){
          Intent intent = new Intent();
          intent.setAction(SERVICE_ACTION);
          intent.addCategory(Intent.CATEGORY_DEFAULT);
          PackageManager pm = getPackageManager();
          ResolveInfo info = pm.resolveService(intent,0);
          if(info != null){
            String packageName = info.serviceInfo.packageName;
            String serviceName = info.serviceInfo.name;
            ComponentName componentName = new ComponentName(packageName,serviceName);
            intent.setComponent(componentName);
            bindService(intent,serviceConnection,BIND_AUTO_CREATE);
          }
        }
      }
    });
  }
  private ServiceConnection serviceConnection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
      serviceMessenger = new Messenger(service);
      isBound = true;
      Message msg = Message.obtain();
      msg.what = SEND_MESSAGE_CODE;
      Bundle data = new Bundle();
      data.putString("msg","你好,MyService,我是客户端");
      msg.setData(data);
      msg.replyTo = clientMessenger;
      try {
        serviceMessenger.send(msg);
      } catch (RemoteException e) {
        e.printStackTrace();
      }
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      serviceMessenger = null;
      isBound = false;
    }
  };
  private class ClientHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
      super.handleMessage(msg);
      if(msg.what == RECEIVE_MESSAGE_CODE){
        Bundle data = msg.getData();
        if(data != null){
          String str = data.getString("msg");
          mTvMsg.setText(str);
        }
      }
    }
  }
}

总结:

这一块理解起来可能比较吃力,所以希望读者多加尝试,为后面的AIDL跨通信方式学习做准备。

 类似资料:
  • 本文向大家介绍WinForm实现跨进程通信的方法,包括了WinForm实现跨进程通信的方法的使用技巧和注意事项,需要的朋友参考一下 本文实例展示了WinForm实现跨进程通信的方法,分享给大家供大家参考之用。具体方法如下: 主要功能代码如下: 希望本文所述实例对大家C#程序设计有所帮助。

  • 概览 Chromium有一个多进程架构,这意味着我们有许多需要互相交流的进程。我们的主要跨进程交流元素是命名管道。在Linux和OS X上,我们使用socketpair()。每个渲染器进程可以分配到一个命名管道来跟浏览器进程交流。这些管道是用异步方式使用的,确保没有哪个端会等待另一个端。 想要得到如何编写安全的IPC端点的知识,请查看IPC安全要点. 浏览器中IPC 在浏览器中,与渲染器的交流是通

  • 本文向大家介绍Android  AIDL——进程通信机制详解,包括了Android  AIDL——进程通信机制详解的使用技巧和注意事项,需要的朋友参考一下 Android  AIDL, Android进程机制通信机制,这里就整理下AIDL 的知识,帮助大家学习理解此部分知识! 什么是 AIDL AIDL 全称 Android Interface Definition Language,即 安卓接口

  • 本文向大家介绍php利用反射实现插件机制的方法,包括了php利用反射实现插件机制的方法的使用技巧和注意事项,需要的朋友参考一下 本文实例讲述了php利用反射实现插件机制的方法。分享给大家供大家参考。具体实现方法如下: 希望本文所述对大家的php程序设计有所帮助。

  • 进程之间互相通讯并和核心通讯,协调它们的行为。 Linux 支持一些进程间通讯( IPC )的机制。信号和管道是其中的两种, Linux 还支持系统 V IPC (用首次出现的 Unix 的版本命名)的机制。 5.1 Signals (信号) 信号是 Unix 系统中使用的最古老的进程间通讯的方法之一。用于向一个或多个进程发送异步事件的信号。信号可以用键盘终端产生,或者通过一个错误条件产生,比如进

  • 我正试图为著名的Dijkstra餐厅哲学家问题实现我自己的解决方案。我得到的只是状态机,一个哲学家应该同时抓住这两个叉子。 这是我的代码: 除了尝试运行在Erlang shell中,我看到的不是进程通信,而是: 苏格拉底是思考吗?孔子是思考吗 我不明白为什么会发生这种情况,因为在我开始编码之前,为了避免迷路,我手工设计了一切。任何帮助赞赏。 这个实现应该是为了防止死锁,因为四个哲学家首先抓住左边的