ipc 使用Messenger进行跨进程通信

Messenger

Messenger翻译为信使,即它可以在不同进程中传递Message对象。在Message中放入我们需要传递的数据,就可以轻松地实现地实现数据的数据间传递了。它的底层实现是AIDL。从构造函数可以明显看到AILD的痕迹,不管是IMessenger还是Stub.asInterface这种使用方法都是表面它的底层的AIDL。

    public Messenger(Handler target) {
        mTarget = target.getIMessenger();
    }

    public Messenger(IBinder target) {
        mTarget = IMessenger.Stub.asInterface(target);
    }

使用Messenger进行跨进程通信

  • 服务端进程
    需要在服务端创建一个Service来处理客户端的连接请求,同时创建一个Handler并通过它来创建一个Messenger对象,然后在Service的onBind中返回这个Messenger对象底层的Binder即可。
  • 客户端进程中,首先要绑定服务端的Service,绑定成功后用服务端返回的IBinder对象创建一个Messenger,通过这个Messenger就可以向服务端发送消息了。发送消息类型是Messeage对象。如果需要服务端能够回应客户端,就和服务端一样,我们还需要创建一个Handler并创建一个新的Messenger,并把这个Messenger对象通过Message的replyTo参数传递给服务器,服务器通过这个replyTo参数就可以回应客户端。

服务端的代码

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MyConstants.MSG_FROM_CLIENT:
                Log.i(TAG, "来自客户端的消息" + msg.getData().getString("msg"));
                Messenger client = msg.replyTo;
                Message relpyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);
                Bundle bundle = new Bundle();
                bundle.putString("reply", "嗯,你的消息我已经收到,稍后会回复你。");
                relpyMessage.setData(bundle);
                try {
                    client.send(relpyMessage);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }

    private final Messenger mMessenger = new Messenger(new MessengerHandler());

    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }

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

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    
}


解析:可以看到MessengerHandler 是用来处理客户端发送过来的消息,mMessenger 是一个Messenger对象,它和MessengerHandler相关联,并在onBind方法中返回它里面的Binder对象,可以看出,这里的Messenger的作用是将客户端发送的消息传递给MessengerHandler处理。注意,注册service,让其运行在单独的进程中:

        <service
            android:name=".Messenger.MessengerService"
            android:process=":remote"
            android:exported="true">
            <intent-filter>
                <action android:name="com.lu.ipc.remote" />
            </intent-filter>
        </service>


客户端的代码

在onCreate()中绑定远程进程的MessengerService。

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent("com.lu.ipc.remote");
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
         intent=createExplicitFromImplicitIntent(this,intent);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);

    }

绑定成功后根据服务端返回的binder对象创建Messenger对象并使用此对象向服务端发送消息,代码中创建的Bundle包括了文本消息和客户端的Messenger对象,此对象可以是接收来自服务端的消息。

    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            mService = new Messenger(service);
            Log.d(TAG, "bind service");
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "从服务端发送消息");
            msg.setData(data);
            msg.replyTo = mGetReplyMessenger;
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        public void onServiceDisconnected(ComponentName className) {
        }
    };

接收来自服务端的消息


    private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
    
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case MyConstants.MSG_FROM_SERVICE:
                Log.i(TAG, "接收到来自服务端的消息:" + msg.getData().getString("reply"));
                break;
            default:
                super.handleMessage(msg);
            }
        }
    }



总结

上面的例子是个很经典的使用Messenger进行跨进程通信的例子,所以是在同一个应用中,但是服务端是在不同的进程的,这个和分别在两个不同的应用道理是一样的,有兴趣可以自己试试。在Messenger中进行数据传递必须将数据放入Message中,而Messenger和Message都实现了Parcelable接口,因此可以进行跨进程的通信。

项目地址

MessengerDemo

    原文作者:nullStr
    原文地址: https://www.jianshu.com/p/db8327fdc6af
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞