IPC机制第一篇，使用Messenger

IPC机制是为实现进程间的通信，为了避免多进程产生的数据不一致性而产生的。笔者刚好在读《Android开发艺术探索》,由于这个知识点，较偏，但是在高性能实际开发中又不可或缺，所以在此记录一下。

首先，我们建一个工程，命名为Messenger。
修改MainActivity

public class MainActivity extends AppCompatActivity {
   private Messenger mService;
    private static final String TAG = "MainActivity";

    private static class MessenderHandler extends Handler {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_SERVICE:
                    Log.i(TAG, "msg" + msg.getData().getString("reply"));
                    break;
                default:
                    break;
            }
        }
    }
    private Messenger mGetReplyMessenger = new Messenger(new MessenderHandler());

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "Hello World!!!");
            msg.setData(data);
            msg.replyTo = mGetReplyMessenger; //这个设置是为服务器返回数据做了桥梁
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(mConnection);
    }
}

　建一个MessengerService

public class MessengerService extends Service {
    public MessengerService() {
    }

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_CLIENT:
                    System.out.println(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();
    }
}

这里我们通过在清单文件里面配置属性来实现多进程

        <service
            android:process=":remote"
            android:name=".MessengerService"
            android:enabled="true"
            android:exported="true"/>

　还有一个常量类MyConstants

public class MyConstants {
    public static final int MSG_FROM_CLIENT = 1;
    public static final int MSG_FROM_SERVICE = 2;
}

代码链接