Android IPC (跨线程调用)

任神的书确实不错， 以IPC的角度把以前零碎的东西做一次复习，加深了理解。以下是读书笔记。

1.进程与线程
进程：android一般一个程序占有一个进程，但可以通过给四大组件指定android:process属性 开启单独，一个进程会运行在
线程： 在一个应用 中耗时操作一般要开启子线程去操作，也就是说一个进程可以有多个线程，它们之间是包含关系。

1. 能够进行IPC的数据库型： 基本数据类型、Serializable 、 Parcelable

   3.实现IPC的方式
   1. 使用Bundle, 四大组线传通过intent传递bundle对象是可以实现跨线程传输的。

   2.使用文件共享， 把对象序列化到文件中，在其它线程中反序列化。比较重量级
   
   3. 使用Messenger(信使)
   
   4. 使用AIDL
   
   5. ContentProvider,  内容提供者是android提供不同应用 之前数据访问的方式。天生就是跨进程的通信。
   
    6 使用Socket, socket在android中的使用与java中完全一样，可用于不同终端之前的通信， 跨进程更不在话下了。
   

这里主要介绍Messenger与AIDL的使用，两者一般都是用在service中
Messenger的底层实现也是aidl,它是android为我们提供的更加简化的方式。Messenger只能进行数据的传递，而不能进行方法的调用。

1.服务端程序如下， 通过OnBind方法把我们的Messager内部的Binder返回给客户端

public class MessengerService extends Service {

private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
if (msg.what == 1) {
// System.out.println(msg.obj.toString());
Bundle data = msg.getData();
                System.out.println(data.getString("msg"));
super.handleMessage(msg);
        }
    }

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

@Nullable
    @Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
    }
}
2.下面是客户端程序 

public class MessengerActivity extends Activity{


private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
messenger = new Messenger(service);
            Message message = Message.obtain();
            message.what = 1;
// message.obj = "试试";
            //message.obj传递对象装失效，但可以能过setDate传递Bundle
Bundle data = new Bundle();
            data.putString("msg", "helloworld");
            message.setData(data);

try {
messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

@Override
public void onServiceDisconnected(ComponentName name) {

        }
    };
private Messenger messenger;

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


    }

public void bind(View v) {
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }
@Override
protected void onDestroy() {
        unbindService(mConnection);
super.onDestroy();
    }
}

程序很简单，在service绑定成功后，通过new 一个Messenger并传递 binder对象，这样服务端与客户端随便是两个Messenger对象，但共有一个binder.最后调用messenger.sendDate方法传递数据给服务端。

下面让服务端接到消息后能再返回数据给客户端。改动代码如下
首先是客户端部分，要准备一个Messenger对象传递 给服务端

private Messenger replyMessenger = new Messenger(new MessengerHandler());

private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
if (msg.what == 1) {
            System.out.println(msg.getData().getString("msg"));
        }
super.handleMessage(msg);
    }
}
然后把Messenger对象放入Bundle.replyTo中
Bundle data = new Bundle();
data.putString("msg", "helloworld");
message.setData(data);

//把messenger传递过去
message.replyTo = replyMessenger;
try {
messenger.send(message);
} catch (RemoteException e) {
    e.printStackTrace();
}

下面是服务端，拿到Messenger,并以同样的方式发送消息给客户端
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
if (msg.what == 1) {
// System.out.println(msg.obj.toString());
Bundle data = msg.getData();
            System.out.println(data.getString("msg"));

            Messenger client = msg.replyTo;
            Message replayMessage = Message.obtain();
            replayMessage.what = 1;
            Bundle replyData = new Bundle();
            replyData.putString("msg", "哈哈，，我已收到");
            replayMessage.setData(replyData);
try {
                client.send(replayMessage);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
super.handleMessage(msg);
    }
}

这样完整的交互就完成了。