Android进程间通信方式Messenger的简单记录

广告也精彩

前言

简单记录一下Messenger的使用,方便自己查阅。

正文

什么是Messenger

Messenger是基于消息Message的传递的一种轻量级IPC进程间通信方式,本质上是对Binder的封装。

通过Messenger可以让我们可以简单地在进程间直接使用Handler进行Message传递,跨进程是通过Binder(AIDL实现),而消息发送是通过Handler#sendMessage方法,而处理则是Handler#handleMessage处理的;当然除了Handler之外还可以是自定义的相关的某些IBinder接口,简而言之,Messenger的跨进程能力是由构造时关联的对象提供的。

Messenger是以串行的方式来处理消息,如果有大量消息发送到服务端,也只能一个一个的处理,那么如果高并发的请求用AIDL更合适一些。

Messenger的使用

Server端进程:

我们需要在服务端进程中创建一个Service来监听客户端的连接请求,同时创建Handler并通过Handler创建Messenger对象。最后在Service的onBind中返回Messenger中的Binder。

public class MessengerService extends Service {

    private Messenger mMessenger;
    private final int MSG_ONE = 0x1001;
    private final int MSG_TWO = 0x1002;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        // 返回iBinder
        return mMessenger.getBinder();
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //创建Messenger
        mMessenger = new Messenger(mServerHandler);
    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        //移除消息,这个忽略
        mServerHandler.removeCallbacksAndMessages(null);
    }

    @SuppressWarnings("HandlerLeak")
    private final Handler mServerHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            if (msg.what == MSG_ONE) {
                // 可以处理Client传过来的Message
                //...
                // Client通信,
                try {
                    //双向通行,获取ClientMessenger
                    Messenger clientMessenger = msg.replyTo;
                    if (null != clientMessenger) {
                        Message message = Message.obtain();
                        message.what = MSG_TWO;
                        message.obj = "Hello 125la.com : "; //内容
                        clientMessenger.send(message);
                    }
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    };
}

AndroidManifest.xml的配置

<service
    android:name=".service.MessengerService"
    android:enabled="true"
    android:exported="true">
    <intent-filter>
        <action android:name="com.biumall.messenger.service.MessengerService" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</service>
Client端进程:

客户端只需要创建用于绑定服务端的Service,并通过服务端返回的Ibinder创建Messenger,此时就可以通过这个Messenger向服务端发送消息了。

public class MainActivity extends AppCompatActivity {

    private final String TAG = MessengerApp.TAG + MainActivity.class.getSimpleName();
    private final int MSG_ONE = 0x1001;
    // ClientServerMessenger
    private Messenger mServiceMessenger = null, mClientMessenger = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "onCreate: ");
        initData();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mClientHandler.removeCallbacksAndMessages(null);
        unbindService(serviceConnection);
        Log.d(TAG, "onDestroy: ");
    }

    @SuppressWarnings("HandlerLeak")
    private final Handler mClientHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            // 可以处理Server传过来的Message
        }
    };


    private void initData() {
        // 创建ClientMessenger
        mClientMessenger = new Messenger(mClientHandler);
        bindService();
    }

    /**
     * 绑定Server
     */
    private void bindService() {
        Intent intent = new Intent();
        intent.setClassName("com.biumall.messenger", "com.biumall.messenger.service.MessengerService");
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
    }

    private final ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            // 获取ServerMessenger
            mServiceMessenger = new Messenger(iBinder);
            // 死亡监听,如果死了重新绑定
            try {
                mServiceMessenger.getBinder().linkToDeath(new IBinder.DeathRecipient() {
                    @Override
                    public void binderDied() {
                        mServiceMessenger = null;
                        bindService();
                    }
                }, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

            //向服务端通信,并把mClientMessenger传给服务端
            try {
                Message message = Message.obtain();
                message.obj = "Hi 125la.com : ";
                message.replyTo = mClientMessenger; // 把服务端的Messenger附上,方便双向通信
                message.what = MSG_ONE;
                mServiceMessenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mServiceMessenger = null;
        }
    };
}

如果要双向通信,需要把Client的Messenger通过message.replyTo 传给Server端,这样就可以双向通信了。

上面代码都有实现。

参考文章

  1. Android Messenger进程间双向通信详解
  2. Android中Messenger的简单使用
  3. Android进程间通信之Messenger的使用和理解
  4. 【Android学习笔记】Android进程间通信方式Messenger
  5. Android IPC之Messenger

广告也精彩
版权声明:125la.com站长 发表于 2022年7月25日 下午6:47。
转载请注明:Android进程间通信方式Messenger的简单记录 | 125啦读书导航

相关文章

广告也精彩

暂无评论

暂无评论...