1. 首页
  2. 文章中心
  3. Android

Android 通过Messager与Service实现进程间双向通信案例详解

186 阅读 0 评论
我是靠谱客的博主 不安蚂蚁，最近开发中收集的这篇文章主要介绍Android 通过Messager与Service实现进程间双向通信案例详解，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

Android中的Service和其调用者既可以在同一个App中，也可以在不同的App。如果Service在App1中，而调用Service的客户端在App2中，那么我们就可以用Service实现进程间的相互通信。本文将介绍如何通过bindService和Messenger实现进程间通信（IPC），如果对bindService绑定服务和Binder不熟悉，可参见《Android中bindService的使用及Service生命周期》，理解该博文是本文的基础。

让Service实现与其他进程通信的关键是Messenger，以及与其相关的IBinder和Hanlder。如果对Handler不熟悉，可参见《Android中Handler的使用》。

Messenger使用步骤

以下是如何使用Messenger的步骤:
1. Service需要实现一个Hanlder，用以处理从客户端收到的消息
2. 用该Handler创建一个Messenger对象，Messenger对象内部会引用该Handler对象
3. 用创建好的Messenger对象获得一个IBinder实例，并且将该IBinder通过Service的onBind方法返回给各个客户端
4. 客户端通过收到的IBinder对象实例化一个Messenger对象，该Messenger内部指向指向Service中的Handler。客户端通过该Messenger对象就可以向Service中的Hanlder发送消息。
5. Service中的Hanlder收到消息后，在Handler中的handleMessage方法中处理消息。
6. 通过上面的第4步与第5步，就完成了客户端向Service发送消息并且Service接收到消息的单向通信过程，即客户端 -> Service。如果要实现Service向客户端回消息的通信过程，即Service -> 客户端，那么前提是在客户端中也需要像Service一样内部维护有一个指向Handler的Messenger。当在第四步中客户端向Service发送信息时，将Message的replyTo属性设置为客户端自己的Messenger。这样在第5步Service在Handler的handleMessage中处理收到的消息时，可以通过Message的Messenger再向客户端发送Message，这样客户端内维护的Handler对象就会收到来自于Service的Message，从而完成Service向客户端发送消息且客户端接收到消息的通信过程。

综上六步就能完成客户端与Service的跨进程双向通信过程:
客户端 -> Service -> 客户端

为了演示客户端与Service的跨进程通信，我建立了两个应用ClientApp和ServiceApp，两个应用的名称也是见名知意:
1. ClientApp, 该App是客户端，用于调用服务
2. ServiceApp，该App是Service端，用于供客户端ClientApp调用

Service代码

ServiceApp中只有一个MyService类，没有其他Activity，也就是说ServiceApp没有任何UI界面。ServiceApp的manifest.xml文件如下所示:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.ispring2.serviceapp" >

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="ServiceApp">

        <service
            android:name=".MyService"
            android:enabled="true"
            android:exported="true" >
            <intent-filter>
                <action android:name="com.ispring2.action.MYSERVICE" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </service>
    </application>

</manifest>

我们在ServiceApp的manifest.xml文件中注册了MyService，并通过exported=”true”将其声明为可被其他App调用的。需要注意的是，我们将其action设置为自定义的action（com.ispring2.action.MYSERVICE），这是为了方便客户端通过其action启动MyService。并且我们将其设置了值为android.intent.category.DEFAULT的category。

ServiceApp中MyService的代码如下所示:

package com.ispring2.serviceapp;

import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

public class MyService extends Service {

    private static final int RECEIVE_MESSAGE_CODE = 0x0001;

    private static final int SEND_MESSAGE_CODE = 0x0002;

    //clientMessenger表示的是客户端的Messenger，可以通过来自于客户端的Message的replyTo属性获得，
    //其内部指向了客户端的ClientHandler实例，可以用clientMessenger向客户端发送消息
    private Messenger clientMessenger = null;

    //serviceMessenger是Service自身的Messenger，其内部指向了ServiceHandler的实例
    //客户端可以通过IBinder构建Service端的Messenger，从而向Service发送消息，
    //并由ServiceHandler接收并处理来自于客户端的消息
    private Messenger serviceMessenger = new Messenger(new ServiceHandler());

    //MyService用ServiceHandler接收并处理来自于客户端的消息
    private class ServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Log.i("DemoLog", "ServiceHandler -> handleMessage");
            if(msg.what == RECEIVE_MESSAGE_CODE){
                Bundle data = msg.getData();
                if(data != null){
                    String str = data.getString("msg");
                    Log.i("DemoLog", "MyService收到客户端如下信息: " + str);
                }
                //通过Message的replyTo获取到客户端自身的Messenger，
                //Service可以通过它向客户端发送消息
                clientMessenger = msg.replyTo;
                if(clientMessenger != null){
                    Log.i("DemoLog", "MyService向客户端回信");
                    Message msgToClient = Message.obtain();
                    msgToClient.what = SEND_MESSAGE_CODE;
                    //可以通过Bundle发送跨进程的信息
                    Bundle bundle = new Bundle();
                    bundle.putString("msg", "你好，客户端，我是MyService");
                    msgToClient.setData(bundle);
                    try{
                        clientMessenger.send(msgToClient);
                    }catch (RemoteException e){
                        e.printStackTrace();
                        Log.e("DemoLog", "MyService向客户端发送信息失败: " + e.getMessage());
                    }
                }
            }
        }
    }

    @Override
    public void onCreate() {
        Log.i("DemoLog", "MyService -> onCreate");
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.i("DemoLog", "MyServivce -> onBind");
        //获取Service自身Messenger所对应的IBinder，并将其发送共享给所有客户端
        return serviceMessenger.getBinder();
    }

    @Override
    public void onDestroy() {
        Log.i("DemoLog", "MyService -> onDestroy");
        clientMessenger = null;
        super.onDestroy();
    }
}
  1. MyService中有一个内部类ServiceHandler，继承自Hanlder并重写了handleMessage方法，MyService用ServiceHandler接收并处理来自于客户端的消息。
  2. MyService中，我们用ServiceHandler的实例初始化了serviceMessenger。serviceMessenger是Service自身的Messenger，其内部指向了ServiceHandler的实例，客户端可以通过IBinder构建Service端的Messenger，从而向Service发送消息，并由ServiceHandler接收并处理来自于客户端的消息。

客户端代码

客户端应用ClientApp就一个MainActivity，其界面上就只有两个按钮:bindService和unbindService, 界面如下:

这里写图片描述

代码如下所示：

package com.ispring.clientapp;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.widget.Button;


public class MainActivity extends Activity implements Button.OnClickListener {

    private static final int SEND_MESSAGE_CODE = 0x0001;

    private static final int RECEIVE_MESSAGE_CODE = 0x0002;

    private boolean isBound = false;

    //用于启动MyService的Intent对应的action
    private final String SERVICE_ACTION = "com.ispring2.action.MYSERVICE";

    //serviceMessenger表示的是Service端的Messenger，其内部指向了MyService的ServiceHandler实例
    //可以用serviceMessenger向MyService发送消息
    private Messenger serviceMessenger = null;

    //clientMessenger是客户端自身的Messenger，内部指向了ClientHandler的实例
    //MyService可以通过Message的replyTo得到clientMessenger，从而MyService可以向客户端发送消息，
    //并由ClientHandler接收并处理来自于Service的消息
    private Messenger clientMessenger = new Messenger(new ClientHandler());

    //客户端用ClientHandler接收并处理来自于Service的消息
    private class ClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            Log.i("DemoLog", "ClientHandler -> handleMessage");
            if(msg.what == RECEIVE_MESSAGE_CODE){
                Bundle data = msg.getData();
                if(data != null){
                    String str = data.getString("msg");
                    Log.i("DemoLog", "客户端收到Service的消息: " + str);
                }
            }
        }
    }

    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder binder) {
            //客户端与Service建立连接
            Log.i("DemoLog", "客户端 onServiceConnected");

            //我们可以通过从Service的onBind方法中返回的IBinder初始化一个指向Service端的Messenger
            serviceMessenger = new Messenger(binder);
            isBound = true;

            Message msg = Message.obtain();
            msg.what = SEND_MESSAGE_CODE;

            //此处跨进程Message通信不能将msg.obj设置为non-Parcelable的对象，应该使用Bundle
            //msg.obj = "你好，MyService，我是客户端";
            Bundle data = new Bundle();
            data.putString("msg", "你好，MyService，我是客户端");
            msg.setData(data);

            //需要将Message的replyTo设置为客户端的clientMessenger，
            //以便Service可以通过它向客户端发送消息
            msg.replyTo = clientMessenger;
            try {
                Log.i("DemoLog", "客户端向service发送信息");
                serviceMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
                Log.i("DemoLog", "客户端向service发送消息失败: " + e.getMessage());
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            //客户端与Service失去连接
            serviceMessenger = null;
            isBound = false;
            Log.i("DemoLog", "客户端 onServiceDisconnected");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    public void onClick(View v) {
        if(v.getId() == R.id.btnBindService){
            //单击了bindService按钮
            if(!isBound){
                Intent intent = new Intent();
                intent.setAction(SERVICE_ACTION);
                intent.addCategory(Intent.CATEGORY_DEFAULT);

                PackageManager pm = getPackageManager();
                //我们先通过一个隐式的Intent获取可能会被启动的Service的信息
                ResolveInfo info = pm.resolveService(intent, 0);

                if(info != null){
                    //如果ResolveInfo不为空，说明我们能通过上面隐式的Intent找到对应的Service
                    //我们可以获取将要启动的Service的package信息以及类型
                    String packageName = info.serviceInfo.packageName;
                    String serviceNmae = info.serviceInfo.name;
                    //然后我们需要将根据得到的Service的包名和类名，构建一个ComponentName
                    //从而设置intent要启动的具体的组件信息，这样intent就从隐式变成了一个显式的intent
                    //之所以大费周折将其从隐式转换为显式intent，是因为从Android 5.0 Lollipop开始，
                    //Android不再支持通过通过隐式的intent启动Service，只能通过显式intent的方式启动Service
                    //在Android 5.0 Lollipop之前的版本倒是可以通过隐式intent启动Service
                    ComponentName componentName = new ComponentName(packageName, serviceNmae);
                    intent.setComponent(componentName);
                    try{
                        Log.i("DemoLog", "客户端调用bindService方法");
                        bindService(intent, conn, BIND_AUTO_CREATE);
                    }catch(Exception e){
                        e.printStackTrace();
                        Log.e("DemoLog", e.getMessage());
                    }
                }
            }
        }else if(v.getId() == R.id.btnUnbindService){
            //单击了unbindService按钮
            if(isBound){
                Log.i("DemoLog", "客户端调用unbindService方法");
                unbindService(conn);
            }
        }
    }
}
  1. ClientHandler继承自Hanlder，并重写了handleMessage方法，客户端用ClientHandler接收并处理来自于Service的消息。
  2. 我们用ClientHandler的实例初始化了clientMessenger。clientMessenger是客户端自身的Messenger，内部指向了ClientHandler的实例，MyService可以通过Message的replyTo得到clientMessenger，从而MyService可以向客户端发送消息，并由ClientHandler接收并处理来自于Service的消息。

分析结果

我们在上述代码的各个关键节点都添加了代码输出语句，我们通过DDMS观察输出结果。

首先打开ClientApp，单击上面的bindService按钮，我们看到DDMS里面的输出结果如下所示:

这里写图片描述

我们通过上面的图片可以看出，客户端ClientApp和服务ServiceApp的所属进程PID分别为2524和2542，二者运行在不同的进程中。

我们通过输出结果分析一下代码的执行过程:
1. 首先我们要明白一点，Messenger是和Handler以及IBinder绑定在一起的。因此Messenger的构造函数有两种：
a. 一种是传入一个Hanlder，根据传入的Handler创建Messenger，且该Messenger指向该Handler，当我们向Messenger发送信息的时候，Handler会受到信息并处理消息，该构造函数往往是在某个类中构建该类自身的Messenger，比如在MyService中用ServiceHandler的实例初始化了自身的serviceMessenger以及在客户端中用ClientHandler的实例初始化了其自身的clientMessenger。这种Messenger可以看做是本地的Messenger。创建完的Messenger可以通过getBinder()方法得到对应的IBinder类型的实例。
b. 另一种是传入一个IBinder，根据传入的IBinder实例创建一个远程的Messenger。这种构造函数往往是在客户端中，通过得到Service的onBind方法返回的IBinder，然后基于此IBinder初始化一个远程的Messenger。该Messenger指向的是Service，而不是客户端，所以该Messenger就是一种远程的Messenger。比如客户端中的serviceMessenger就是一种远程的Messenger，指向的是MyService。

2.当单击了客户端中的bindService按钮后，我们通过intent启动了MyService，MyService开始执行其生命周期，先执行onCreate回调方法，然后执行onBind回调方法，在执行onBind方法的时候，该方法返回了MyService中本地serviceMessenger所对应的binder，将其返回给客户端。

3.MyService的onBind方法返回之后，会将IBinder传入客户端的ServiceConnection对象的onServiceConnected回调方法中，该方法的执行表明客户端与MyService建立了连接。此时，我们会根据来自于MyService的IBinder初始化一个指向MyService的serviceMessenger，serviceMessenger是一个远程Messenger。

4.在得到指向MyService的serviceMessenger之后，我们就可以通过它向MyService发送下消息了。我们构建了一个Message，并通过Bundle为其设置了数据，而且需要注意的是，我们还将Message的replyTo设置为客户端的clientMessenger，以便Service可以通过它向客户端发送消息。然后通过代码serviceMessenger.send(msg)将Message发送给MyService。

5.客户端通过serviceMessenger向MyService发送消息后，MyService的ServiceHandler收到消息，并在handleMessage中处理该消息。我们首先读取了该Message的Bundle数据，并打印出来。然后我们通过通过Message的replyTo获取到指向客户端自身的Messenger，并且我们将其保存在了MyService的clientMessenger中，clientMessenger相对于MyService来说是一个远程的Messenger。然后我们又构造了一条Message，并且也通过Bundle设置数据，通过执行代码clientMessenger.send(msgToClient)向客户端回信发送消息。由于我们保存了clientMessenger，所以我们可以在后续的过程中随时向客户端主动发送消息。

6.MyService通过clientMessenger向客户端发信信息后，客户端的ClientHandler收到信息，并在其handleMessage方法中处理消息: 读取来自于MyService的Message的Bundle数据，并将其打印出来。

通过以上的几步我们就能实现客户单与Service的跨进程的双向通信:
1. 客户端发信息到Service，Service读取信息，即客户端 -> Service
2. Service给客户端回信，客户端读取信息，即Service -> 客户端

以上就是当我们单击客户端上的bindService按钮所发生的代码执行过程，当我们单击unbindService按钮时，DDMS输出结果如下所示:

这里写图片描述

当执行unbindService的时候，客户端与MyService就断开了连接，此时没有其他的客户端连接到MyService上，所以MyService就执行了onUnbind回调方法，然后执行onDestroy回调方法，MyService销毁。

注意事项

在客户端代码中，有两点需要注意:
1.当通过执行bindService(intent, conn, BIND_AUTO_CREATE)代码的时候，如果intent只设置了action和category，没有明确指明要启动的组件，那么该intent就是是隐式的。在Android 5.0及以上的版本中，必须使用显式的intent去执行启动服务，如果使用隐式的intent，则会报如下错误:

这里写图片描述

3072-3072/com.ispring.clientapp E/DemoLog﹕ Service Intent must be explicit: Intent { act=com.ispring2.action.MYSERVICE cat=[android.intent.category.DEFAULT] }

解决办法是我们先构建一个隐式的Intent，然后通过PackageManager的resolveService获取可能会被启动的Service的信息。如果ResolveInfo不为空，说明我们能通过上面隐式的Intent找到对应的Service，并且我们还可以获取将要启动的Service的package信息以及类型。然后我们需要将根据得到的Service的包名和类名，构建一个ComponentName，从而设置intent要启动的具体的组件信息，这样intent就从隐式变成了一个显式的intent。然后我们可以将该显式的intent传递给bindService方法去启动服务。
具体可参见连接：http://stackoverflow.com/questions/24480069/google-in-app-billing-illegalargumentexception-service-intent-must-be-explicit/26318757#26318757。

2.当用Messenger在两个进程之间传递Message时，Message的obj不能设置为设置为non-Parcelable的对象，比如在跨进程的情形下，Message的obj设置为了一个String对象，那么在Messenger执行send(Message)方法时就会报如下错误:

这里写图片描述

java.lang.RuntimeException: Can't marshal non-Parcelable objects across processes.

解决该问题最简单的办法是，在跨进程的时候不使用Message的obj，用Bundle传递数据，setData设置Bundle数据，getData获取Bundle数据。

希望本文对大家使用Messenger以及与Service的跨进程双向通信有所帮助。

到此这篇关于Android 通过Messager与Service实现进程间双向通信案例详解的文章就介绍到这了,更多相关Android 通过Messager与Service实现进程间双向通信内容请搜索靠谱客以前的文章或继续浏览下面的相关文章希望大家以后多多支持靠谱客！

最后

以上就是不安蚂蚁为你收集整理的Android 通过Messager与Service实现进程间双向通信案例详解的全部内容，希望文章能够帮你解决Android 通过Messager与Service实现进程间双向通信案例详解所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(123)

相关文章

Android Service生命周期详解
Android Service生命周期详解
Android bindService的使用与Service生命周期案例详解
Android bindService的使用与Service生命周期案例详解
Android startService的使用与Service生命周期案例详解
Android startService的使用与Service生命周期案例详解
Android开发中amera2 Preview使用详解
Android开发中amera2 Preview使用详解
Android 通过Messager与Service实现进程间双向通信案例详解
Android 通过Messager与Service实现进程间双向通信案例详解
Android开发中关于组件导出的风险及防范
Android开发中关于组件导出的风险及防范
Android Handler的使用详解
Android Handler的使用详解
Android中初始化Codec2的具体流程
Android中初始化Codec2的具体流程

评论列表共有 0 条评论

立即
投稿
返回
顶部