Android使用Messenger实现进程间双向通信

Posted 2022-12-03 阿蛮家

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Android使用Messenger实现进程间双向通信相关的知识，希望对你有一定的参考价值。

在了解本文即将学到的技能外，有些知识还是有必要提前知道的，这样才会更容易理解本文即将讲到的知识点。需要提前预热的知识点：

1、android四大组件之一Service，要知道怎样去写一个Service，Service有哪两种启动方式；

2、Android Service启动方式之Bound Service；

3、Android基础知识之Messenger；

掌握了这三个知识点，就可以快速入手使用Messenger进行进程间通信了。

一、知识点回顾之Service

我们来看看官方文档关于对Service最权威的解释：

Service是一个应用程序组件，它能够在后台执行一些耗时较长的操作，并且不提供用户界面。服务能被其它应用程序的组件启动，即使用户切换到另外的应用时还能保持后台运行。此外，应用程序组件还能与服务绑定，并与服务进行交互，甚至能进行进程间通信（IPC）。比如，服务可以处理网络传输、音乐播放、执行文件I/O、或者与content provider进行交互，所有这些都是后台进行的。

服务有以下两种基本类型：

Started

如果一个应用程序组件（比如一个activity）通过调用startService()来启动服务，则该服务就是被“started”了。一旦被启动，服务就能在后台一直运行下去，即使启动它的组件已经被销毁了。通常，started的服务执行单一的操作并且不会向调用者返回结果。比如，它可以通过网络下载或上传文件。当操作完成后，服务应该自行终止。

Bound

如果一个应用程序组件通过调用bindService()绑定到服务上，则该服务就是被“bound”了。bound服务提供了一个客户端/服务器接口，允许组件与服务进行交互、发送请求、获取结果，甚至可以利用进程间通信（IPC）跨进程执行这些操作。绑定服务的生存期和被绑定的应用程序组件一致。多个组件可以同时与一个服务绑定，不过所有的组件解除绑定后，服务也就会被销毁。

虽然本文对这两种类型的服务是分别进行简要描述的，但是你的服务仍可以同时用两种方式工作——可以是started（一直运行下去），同时也能被绑定。只会存在一点麻烦，是否两个回调方法都要实现：实现onStartCommand()以允许组件启动服务、实现onBind()以允许绑定。

无论你的应用程序是started、bound、还是两者都支持，任何应用程序组件都可以使用此服务（即使是从另一个独立的应用程序中），同样，任何组件都可以用这种方式使用一个activity——通过一个Intent启动。不过，也可以在manifest文件中把服务声明为私有private的，以便阻止其它应用程序的访问。

注意：服务运行于宿主进程的主线程中——不创建自己的线程并且不是运行在单独的进程中（除非你明确指定）。这意味着，如果你的服务要执行一些很耗CPU的工作或者阻塞的操作（比如播放MP3或网络操作），你应该在服务中创建一个新的线程来执行这些工作。利用单独的线程，将减少你的activity发生应用程序停止响应（ANR）错误的风险。

Service的两种启动模式

在创建一个Service之前，需要继承Service类，重写一些回调方法。Service最重要的两个回调方法就是onStartCommand()和onBind()，基于这两个方法的重写也就决定了Service的启动模式。如果onBind()方法中返回null，说明Service需要通过startService()启动，如果onBind()返回一个IBinder，说明Service可以通过bindService()进行服务绑定，从而启用Service；

onStartCommand()

当其它组件，比如一个activity，通过调用startService()请求started方式的服务时，系统将会调用本方法。一旦本方法执行，服务就被启动，并在后台一直运行下去。如果你的代码实现了本方法，你就有责任在完成工作后通过调用stopSelf()或stopService()终止服务。（如果你只想提供bind方式，那就不需要实现本方法。）

onBind()

当其它组件需要通过bindService()绑定服务时（比如执行RPC），系统会调用本方法。在本方法的实现代码中，你必须返回IBinder来提供一个接口，客户端用它来和服务进行通信。你必须确保实现本方法，不过假如你不需要提供绑定，那就返回null即可。

Service其他几个重写方法：

onCreate()

当服务第一次被创建时，系统会调用本方法，用于执行一次性的配置工作（之前已调用过onStartCommand()或onBind()) 了。如果服务已经运行，则本方法就不会被调用。

onDestroy()

当服务用不上了并要被销毁时，系统会调用本方法。你的服务应该实现本方法来进行资源的清理工作，诸如线程、已注册的侦听器listener和接收器receiver等等。这将是服务收到的最后一个调用。

如果组件通过调用startService()（这会导致onStartCommand()的调用）启动了服务，那么服务将一直保持运行，直至自行用stopSelf()终止或由其它组件调用stopService()来终止它。

如果组件调用bindService()来创建服务（那onStartCommand()就不会被调用），则服务的生存期就与被绑定的组件一致。一旦所有客户端都对服务解除了绑定，系统就会销毁该服务。

创建一个started服务

started服务是指其它组件通过调用startService()来启动的服务，这会引发对该服务onStartCommand()方法的调用。

一旦服务被启动started，它就拥有了自己的生命周期，这是独立于启动它的组件的。并且它能够在后台一直运行下去，即使启动它的组件已被销毁也是如此。因此，服务应该能够在完成工作后自行终止，通过调用stopSelf()即可，或者由其它组件通过调用stopService()也可以。

诸如activity之类的应用程序组件，可以通过调用startService()启动服务,并传入一个给出了服务和服务所需数据的Intent对象。服务将在onStartCommand()方法中接收到该Intent对象。

Service

这是所有服务的基类。如果你要扩展该类，则很重要的一点是：请在其中创建一个新的线程来完成所有的服务工作。因为服务默认是使用应用程序的主线程的，这会降低应用程序中activity的运行性能。

扩展Service类

package com.lc.proctice.androidstudioproctice.myservice;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.support.annotation.Nullable;

/**
 * Created by licheng on 24/7/16.
 */
public class HelloService extends Service 

    private ServiceHandler serviceHandler;
    private Looper looper;



    /** 处理从线程获取到的消息 **/
    private final class ServiceHandler extends Handler

        public ServiceHandler(Looper looper) 
            super(looper);
        

        @Override
        public void handleMessage(Message msg) 
            /** 线程等待5秒 **/
            long endTime = System.currentTimeMillis() + 5*1000;
            while (System.currentTimeMillis() < endTime) 
                synchronized (this) 
                    try 
                        wait(endTime - System.currentTimeMillis());
                     catch (Exception e) 
                    
                
            
            /** 根据startId停止当前服务,这样我们就不必要在处理其他工作的过程中来终止这个服务 **/
            stopSelf(msg.arg1);
        
    

    @Override
    public void onCreate() 
        super.onCreate();
        /** Service运行在主线程,为了不阻塞线程,我们需要另起线程,还可以赋予线程优先级 **/
        HandlerThread handlerThread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);
        handlerThread.start();

        /** 获取线程的Looper队列用于Handler **/
        looper = handlerThread.getLooper();
        serviceHandler = new ServiceHandler(looper);
    

    @Override
    public void onDestroy() 
        super.onDestroy();
    

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) 
        /** 发送消息,传入当前服务startId **/
        Message msg = serviceHandler.obtainMessage();
        msg.arg1 = startId;
        serviceHandler.sendMessage(msg);
        /** 如果服务被杀死,从这里返回后服务将被重启 **/
        return START_STICKY;
    

    @Nullable
    @Override
    public IBinder onBind(Intent intent) 
        /** 如果不支持绑定,就返回Null **/
        return null;

关于HandlerThread，可以参考这篇博文Android HandlerThread完全解析

启动服务

从activity或其它应用程序组件中可以启动一个服务，调用startService()并传入一个Intent（指定所需启动的服务）即可。Android系统将调用服务的onStartCommand()方法，并传入该Intent（你永远都不应该直接去调用onStartCommand()。）

例如，一个activity可以用一个显式的intent通过startService()启动上一节的示例服务（HelloSevice）：

Intent intent = new Intent(this, HelloService.class);
startService(intent);

startService()方法会立即返回，Android系统会去调用服务的onStartCommand() 方法。如果服务还未运行，系统会首先调用onCreate()，然后再去调用onStartCommand() 。

如果服务不同时支持绑定，那么通过startService()传入的intent将是应用程序组件与服务进行交互的唯一途径。当然，如果你期望服务能返回结果，那启动服务的客户端可以创建一个PendingIntent来获得一个广播broadcast（利用getBroadcast()），并把它放入启动服务的Intent并传到服务中去。然后服务就会用这个broadcast来传递结果。

多个启动服务的请求将会引发服务onStartCommand()方法的多次调用。不过，只有一个终止服务的请求（用stopSelf()或stopService()）会被接受并执行。

终止服务

一个started服务必须自行管理生命周期。也就是说，系统不会终止或销毁这类服务，除非必须恢复系统内存并且服务返回后一直维持运行。因此，服务必须通过调用stopSelf()自行终止，或者其它组件可通过调用stopService()来终止它。

用stopSelf()或stopService()的终止请求一旦发出，系统就会尽快销毁服务。

不过，如果你的服务要同时处理多个onStartCommand()请求，那在处理启动请求的过程中，你就不应该去终止服务，因为你可能接收到了一个新的启动请求（在第一个请求处理完毕后终止服务将停止第二个请求的处理。为了避免这个问题，你可以用stopSelf(int)来确保终止服务的请求总是根据最近一次的启动请求来完成。也就是说，当你调用stopSelf(int) 时，你把启动请求ID（发送给onStartCommand()的startId）传给了对应的终止请求。这样，如果服务在你可以调用stopSelf(int)时接收到了新的启动请求，则ID将会不一样，服务将不会被终止。

注意：

当服务完成工作后，你的应用程序应该及时终止它，这点非常重要。这样可以避免系统资源的浪费，并能节省电池的电力。必要时，其它组件可以通过调用stopService()来终止服务。即使你的服务允许绑定，你也必须保证它在收到对onStartCommand()的调用时能够自行终止。

启动服务前还需要在manifest.xml文件声明Service，这样才能保证服务正常工作。

要声明你的服务，把<service>元素作为子元素加入到<application>元素中去即可。例如：

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

在<service>元素中可以包含很多其它属性，比如定义启动服务所需权限、服务运行的进程之类的属性。

创建一个Bound服务

bound服务是指允许被应用程序组件绑定的服务，通过调用bindService()可以完成绑定，用于创建一个长期存在的连接（并且一般不再允许组件通过调用startService()来start服务。

当应用程序中的activity或其它组件需要与服务进行交互，或者应用程序的某些功能需要暴露给其它应用程序时，你应该创建一个bound服务，并通过进程间通信（IPC）来完成。

要创建一个bound服务，你必须实现onBind()回调方法，并返回一个IBinder对象，此对象定义了与服务进行通信的接口。然后，其它应用程序组件可以调用bindService()来获得接口并调用服务中的方法。服务只在为绑定的应用程序组件工作时才会存活，因此，只要没有组件绑定到服务，系统就会自动销毁服务（你不需要像started服务中那样通过onStartCommand()来终止一个bound服务）。

要创建一个bound服务，首先必须定义好接口，用于指明客户端如何与服务进行通信。这个客户端与服务之间的接口必须是一个IBinder对象的实现，并且你的服务必须在onBind()回调方法中返回这个对象。一旦客户端接收到这个IBinder，它就可以通过这个接口来与服务进行交互。

同一个服务可以被多个客户端绑定。当客户端完成交互时，会调用unbindService()来解除绑定。一旦不存在客户端与服务绑定时，系统就会销毁该服务。

扩展Service类

package com.lc.proctice.androidstudioproctice.myservice;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

/**
 * Created by licheng on 18/8/15.
 */
public class BindService extends Service 
    private static final String TAG = "BindService";
    private int count=0;
    private boolean quit=false;
    private Thread thread;
    private MyBinder binder=new MyBinder();

    /** 创建和和客户端通信的Binder,公开它的方法,便于客户端调用 **/
    public class MyBinder extends Binder
        public int getCount()
            return count;
        
    

    @Override
    public void onCreate() 
        super.onCreate();
        Log.v(TAG, "service is onCreate");
        /** 另起线程 **/
        thread = new Thread(new Runnable() 
            @Override
            public void run() 
                while (!quit) 
                    try 
                        thread.sleep(1000);
                     catch (InterruptedException e) 
                        e.printStackTrace();
                    
                    count++;
                
            
        );
        thread.start();
    

    @Override
    public IBinder onBind(Intent intent) 
        Log.v(TAG, "Service is Binded");
        return binder;
    

    @Override
    public void onStart(Intent intent, int startId) 
        super.onStart(intent, startId);
    

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) 
        Log.v(TAG, "Service is started");
        return super.onStartCommand(intent, flags, startId);
    

    @Override
    public boolean onUnbind(Intent intent) 
        Log.v(TAG, "Service is Unbinded");
        return true;
    

    @Override
    public void onDestroy() 
        Log.v(TAG,"service is destroyed");
        this.quit = true;

绑定服务

应用程序组件（客户端）可以通过调用 bindService() 来绑定服务。然后Android系统会调用服务的 onBind() 方法，返回一个用于和服务进行交互的 IBinder。

绑定是异步进行的。 bindService() 将立即返回，并不会向客户端返回 IBinder 。为了接收 IBinder ，客户端必须创建一个 ServiceConnection 的实例，并把它传给 bindService()。 ServiceConnection 包含了一个回调方法，系统将会调用该方法来传递客户端所需的那个 IBinder。

注意：

只有activity、服务和content provider才可以绑定到服务上——你不能从广播接收器（broadcast receiver）中绑定服务。

因此，要把客户端绑定到服务上，你必须：

实现ServiceConnection。

你的实现代码必须重写两个回调方法：

onServiceConnected()

系统调用该方法来传递服务的 onBind()方法所返回的 IBinder。

onServiceDisconnected()

当与服务的联接发生意外中断时，比如服务崩溃或者被杀死时，Android系统将会调用该方法。客户端解除绑定时，不会调用该方法。
调用bindService()，传入已实现的ServiceConnection。
当系统调用你的onServiceConnected()回调方法时，你可以利用接口中定义的方法开始对服务的调用。
要断开与服务的联接，请调用unbindService()。

当客户端被销毁时，与服务的绑定也将解除。但与服务交互完毕后，或者你的activity进入pause状态时，你都应该确保解除绑定，以便服务能够在用完后及时关闭。（绑定和解除绑定的合适时机将在后续章节中继续讨论。）

为了启动上面的BindService，我们需要在客户端写一个ServiceConnection

private ServiceConnection connection = new ServiceConnection() 
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) 
            Log.i(TAG, "--Service Connected--");
            // 取得Service对象中的Binder对象
            binder = (BindService.MyBinder) service;
        

        @Override
        public void onServiceDisconnected(ComponentName name) 
            Log.i(TAG, "--Service Disconnected--");
        
    ;

启动服务

 Intent intent = new Intent(ServiceActivity.this, BindService.class);
 bindService(intent, connection, Service.BIND_AUTO_CREATE);

注意：BindService需要在manifest.xml文件中声明。

以上关于Service的两种启动模式就讲到这里啦，关于Android Service 的Bound服务，这里也很有必要将清楚，因为在介绍了这么多准备知识后，我们还没有进入到这篇文章的主题，使用Messenger进行进程间通信。

Android Bound服务

bound服务是客户端-服务器模式的服务。bound服务允许组件（比如activity）对其进行绑定、发送请求、接收响应、甚至进行进程间通信（IPC）。 bound服务一般只在为其它应用程序组件服务期间才是存活的，而不会一直在后台保持运行。

bound服务是 Service 类的一种实现，它允许其它应用程序与其绑定并交互。为了让服务支持绑定，你必须实现onBind() 回调方法。这个方法返回一个 IBinder 对象，此对象定义了客户端与服务进行交互时所需的编程接口。

客户端可以通过调用 bindService() 方法来绑定服务。在调用时，必须提供一个 ServiceConnection 的实现代码，用于监控与服务的联接。 bindService() 将会立即返回，没有返回值。但是Android系统在创建客户端与服务之间的联接时，会调用 ServiceConnection 中的onServiceConnected() 方法，传递一个 IBinder ，客户端将用它与服务进行通信。

多个客户端可以同时联接到一个服务上。不过，只有在第一个客户端绑定时，系统才会调用服务的 onBind()方法来获取 IBinder 。然后，系统会向后续请求绑定的客户端传送这同一个 IBinder ，而不再调用 onBind() 。

当最后一个客户端解除绑定后，系统会销毁服务（除非服务同时是通过 startService() 启动的）。

当你实现自己的bound服务时，最重要的工作就是定义onBind() 回调方法所返回的接口。定义服务 IBinder 接口的方式有好几种，后续章节将会对每种技术进行论述。

定义IBinder的三种方式

创建一个支持绑定的服务时，你必须提供一个 IBinder，用作客户端和服务间进行通信的编程接口。定义这类接口的方式有三种：

扩展Binder类

如果服务是你的应用程序所私有的，并且与客户端运行于同一个进程中（通常都是如此），你应该通过扩展 Binder类来创建你的接口,并从 onBind()返回一个它的实例。客户端接收该 Binder对象并用它来直接访问 Binder甚至 Service中可用的公共（public）方法。

如果你的服务只是为你自己的应用程序执行一些后台工作，那这就是首选的技术方案。不用这种方式来创建接口的理由只有一个，就是服务要被其它应用程序使用或者要跨多个进程使用。

使用Messenger

如果你需要

以上是关于Android使用Messenger实现进程间双向通信的主要内容，如果未能解决你的问题，请参考以下文章

Android中AIDL实现进程通信（附源码下载）

Android17.5 利用Messenger实现进程间通信（IPC）

Android 进程间通信之Messenger

android 进程间通信使用aidl和Messenger类

Messenger 进程间通信