Android组件——进程间的Service（随笔3）

三、不同进程之间的service交互

此次记录一下不同进程之间的service使用Messenger进行交互，未使用AIDL。

    1、在AndroidManifest.xml文件中注册service

<service android:name=".RemoteMessageService.MessageService"
            android:enabled="true"//表示可以将service实例化
            android:exported="true"//表示可以在不同的进程中连接service
            //":remote"表示在新建一个属于当前应用的进程，名为“remote”,这样可以实现不同进程的通信
            android:process=":remote">

            <intent-filter>
                <action android:name="msg"/>
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
        </service>

    2、继承Service

public class MessageService extends Service{
    private ArrayList<Messenger> messengers=new ArrayList<Messenger>();//存储客户端的Messenger
    private String value;
    private final int REGISTER =1;
    private final int UNREGISTER =2;
    private final int VALUE = 3;

    private Messenger messenger=new Messenger(new IncomingHandler());

    class IncomingHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch ( msg.what){
                case REGISTER:
                    messengers.add(msg.replyTo);
                    break;
                case UNREGISTER:
                    messengers.remove(msg.replyTo);
                    break;
                case VALUE:
                    for(int i=0;i<=messengers.size()-1;i++){
                        try {
                            Log.i("LZH","get value");
                            //处理完数据后，将结果返回给客户端，此时要注意send方法中的Object参数，这个参数在此时不

能是基本类型（int，String等），需要是实现Parcelable的实例，或是Bundle实例

                            messengers.get(i).send(Message.obtain(null,VALUE,msg.obj));//实际上给了客户端的

Handler去处理

                        } catch (RemoteException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
            }
        }
    }

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

    @Override
    public void onDestroy() {
        Log.i("LZH","messsege service destroy");
        super.onDestroy();
    }
}

        3、实现Activity

public class RemoteActivity extends Activity{

    private Messenger messenger;
    private Messenger remessg;
    private final int REGISTER =1;
    private final int UNREGISTER =2;
    private final int VALUE = 3;
    private String str;
    private MyServiceConnection connection;
    private Intent intent;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.remote_layout);
        connection=new MyServiceConnection();

        intent=new Intent("msg");
        intent.setPackage("com.example.administrator.myservice.RemoteMessageService");
    }

    public void remote_bind(View view){
        bindService(intent,connection,BIND_AUTO_CREATE);

    }

    public void remote_unbind(View view){
       if(connection!=null&&status==true){
            status=false;
            Message message=Message.obtain(null,UNREGISTER,null);
            message.replyTo=remessg;
            try {
                messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            unbindService(connection);
        }
    }
    class MyHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch(msg.what){
                case VALUE:
                    Bundle bundle= (Bundle) msg.obj;
                    str=bundle.getString("key");
                    Log.i("LZH","str is "+str);
                    break;
            }
        }
    }
    class MyServiceConnection implements ServiceConnection{

        private MessageService.IncomingHandler mincomingHandler;


        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            messenger=new Messenger(service);
            remessg=new Messenger(new MyHandler());

            Message message=Message.obtain(null,REGISTER,null);

            message.replyTo=remessg;

            try {

                //先在服务端注册，即将客户端的Messenger传送到服务端的list中
                messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
                 //向服务端发送信息
            try {
                Bundle bundle=new Bundle();

                bundle.putString("key","hi");
                message=Message.obtain(null,VALUE,bundle);
                messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    }

    @Override
    protected void onDestroy() {
        if(connection!=null&&status==true){
            status=false;
            Message message=Message.obtain(null,UNREGISTER,null);
            message.replyTo=remessg;
            try {
                messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            unbindService(connection);
        }
        super.onDestroy();
    }

总结：

    1、首先给Messenger传入一个handler用于处理传来的数据

    2、在客户端拿到一个可以连接到服务端的Messenger实例，在服务端拿到一个客户端的Messenger实例

    3、在服务连接成功时， 利用Messenger的send方法将数据发送到服务端，然后服务daunt在用相同的方法将结果返回到客户端

处理流程为：

Messenger处理过程：