android开发艺术探索（二补充）

IPC方式

1.使用Bundle

我们知道四大组件中的三大组件（Activity、Service、Receiver）都是支持在Intent中传递Bundle数据的，由于Bundle实现了Parcelable接口，所以他可以很方便的在不同进程中传输。

Bundle传递的数据类型有哪些？
（1）基本类型数据
（2）实现了序列化接口的对象（Parcellable以及Serializable接口）

如下代码：我们在Bundle存储数据，并通过intent发送出去。

Intent intent = new Intent();
        intent.setClass(this, ActivityA.class);
        Bundle bundle = new Bundle();
        bundle.putCharSequence("name", "花花");
        intent.putExtras(bundle);
        startActivity(intent);

获取Binder对象以及其中的数据。

        Bundle b=getIntent().getExtras();
        String name= b.getString("name");

使用文件共享
共享文件是通过两个进程通过读/写同一个文件来交换数据，比如A进程把数据写入文件，B进程通过读取这个文件来获取数据。

新建项目，首先我们再MainActivity中，再文件中存储一串数据。

Context 类中提供了一个 openFileOutput ()方法，可以用于将数据存储到指定的文件中。这个方法接收两个参数，第一个参数是文件名，在文件创建的时候使用的就是这个名称，注意这里指定的文件名不可以包含路径，因为所有的文件都是默认存储到/data/data/packagename/files/ 目 录 下 的 。

 private void writeInFile() {
        String data = "this is my book";
        FileOutputStream out = null;
        BufferedWriter writer = null;

        try {
            out = openFileOutput("data", Context.MODE_PRIVATE);
            writer = new BufferedWriter(new OutputStreamWriter(out));
            writer.write(data);

            handler.sendEmptyMessage(0);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

然后新建ActivityA,在此界面中去读取数据：在弹出的Toast中读取到了我们写入的字符串数据。

  private void readFile() {
        FileInputStream in=null;
        BufferedReader reader=null;
        StringBuilder content=new StringBuilder();

        try {
            in=openFileInput("data");
            reader=new BufferedReader(new InputStreamReader(in));
            String line="";
            while ((line=reader.readLine())!=null){
                content.append(line);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        Toast.makeText(this,content.toString(),Toast.LENGTH_LONG).show();
    }

SharedPreference是个特例，它是Android中提供的轻量级存储方案，他通过键值对的方式来存储数据，在底层实现上采用了XML文件来存储键值对。从本质上说SharedPreference也属于文件的一种，但是系统对它的读写有一定的缓存策略，记载内存中会有一份SharedPreference的文件缓存，因此在多进程情况下，系统对它的读/写就变得不可靠。

使用Messenger

Messenger可以翻译为信史，顾名思义，通过它可以再不同进程中传递Message对象，在Message中放入我们需要传递的数据，就可以轻松的实现数据的进程间传递。Messenger是一种轻量级的IPC方案，底层实现为AIDL。Messenger对AIDL做了封装，我们可以更简便的进行进程间通讯。由于它每次只处理一个请求，因此我们再服务端不用考虑线程同步的问题，这是因为在服务端中不存在并发执行的情况。

    Messenger的构造方法，一个传入Handler对象，另外一个传入Ibinder对象。
    public Messenger(Handler target) {
        throw new RuntimeException("Stub!");
    }

    public Messenger(IBinder target) {
        throw new RuntimeException("Stub!");
    }
    /**次方法用于返回Binder对象*/
     public IBinder getBinder() {
        throw new RuntimeException("Stub!");
    }
    /**次方法用于发送一条Message消息*/
    public void send(Message message) throws RemoteException {
        throw new RuntimeException("Stub!");
    }

Messenger的使用方法以及实现步骤
1、服务端进程

首先，我们需要在服务端创建按一个Service用来处理客户端的链接请求，同时创建一个Handler并通过它来创建爱你一个Messenger对象，然后再Service的OnBind中返回这个Messenger对象底层的Binder即可。

2.客户端进程

在客户端进程中，我们首先要绑定到服务端的Service，绑定成功后用服务端返回的IBinder对象创建一个Messenger，通过这个Messenger就可以向服务端发送消息了，发送消息类型为Message对象。

step1:创建服务端项目，并新建MessengerService.java文件

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 0:
                    Log.e(TAG, "receive msg from Client:" + msg.getData().getString("msg"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
    private final Messenger messenger=new Messenger(new MessengerHandler());

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

step2:在Mainfest文件中注册

 <!--让服务运行在单独的进程中-->
        <service android:name=".service.MessengerService"
            android:process=":romote"
            >
            <intent-filter>
                <action android:name="com.example.ipc.service.MessengerService"></action>
            </intent-filter>

        </service>

step3:创建客户端项目，Client

public class MainActivity extends AppCompatActivity {

    private static final String TAG="MainActivity";
    private Messenger messengerService;

    ServiceConnection conn=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            /**创建Messenger对象*/
            messengerService=new Messenger(iBinder);
            Message msg=Message.obtain(null,Sign.MSG_FROM_CLIENT);
            Bundle data=new Bundle();
            data.putString("msg","hello ,this is client.");
            msg.setData(data);
            try {
                /**通过Messenger对象发送Message消息*/
                messengerService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
                messengerService=null;
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /**Step1：绑定服务端service*/
        Intent intent=new Intent("com.example.ipc.service.MessengerService");
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }

    /**解绑Service*/
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}

然后运行项目，首先运行服务端，然后运行客户端。可以看到收到了客户端发送的消息。

通过以上例子，我们可以看到Messenger传递数据，必须将Message消息放入Messenger中。Messenger和Message都实现了Parcelable接口，因此可以进行跨进程传输。然而这个只是客户端发消息给服务端，这时候我们需要服务端能给客户端发送消息。首先修改服务端代码：

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 Sign.MSG_FROM_CLIENT:
                    Log.e(TAG, "receive msg from Client:" + msg.getData().getString("msg"));

                    /**获取到Messenger对象*/
                    Messenger client=msg.replyTo;
                    /**创建Message*/
                    Message reply=Message.obtain(null, Sign.MSG_FROM_SERVICE);
                    Bundle bundle=new Bundle();
                    bundle.putString("reply","I am receive msg");
                    reply.setData(bundle);
                    try {
                        /**通过Messenger向客户端发送消息*/
                        client.send(reply);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
    private final Messenger messenger=new Messenger(new MessengerHandler());

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

然后是客户端，既然要接收到服务端返回的消息，我们也定义一个接收消息的Messenger和Handler。如下：

public class MainActivity extends AppCompatActivity {

    private static final String TAG="MessengerService";
    private Messenger messengerService;


    private Messenger mGetReplyMessenger=new Messenger(new MessengerHandler());
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case Sign.MSG_FROM_SERVICE:
                    Log.e(TAG,"receive msg from Service:"+msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }


    ServiceConnection conn=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            /**创建Messenger对象*/
            messengerService=new Messenger(iBinder);
            Message msg=Message.obtain(null,Sign.MSG_FROM_CLIENT);
            Bundle data=new Bundle();
            data.putString("msg","hello ,this is client.");
            msg.setData(data);
            //注意：
            msg.replyTo=mGetReplyMessenger;

            try {
                /**通过Messenger对象发送Message消息*/
                messengerService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName componentName) {
                messengerService=null;
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /**Step1：绑定服务端service*/
        Intent intent=new Intent("com.example.ipc.service.MessengerService");
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
    }

    /**解绑Service*/
    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(conn);
    }
}

结果：我们可以看到，手下服务端接收到了客户端发送的消息，然后服务端作出响应返回给客户端。

AIDL方式
这里就不做具体的例子了，上一篇文章介绍过了。
1、aidl文件支持的数据类型？

(1)基本数据类型（int,long,char,boolean,double）
(2)String 和CharSequence
(3)List，只支持ArrayList，里面每个元素都能被AIDL支持。
(4)Map,只支持HashMap,里面的每个元素都必须被AIDL支持，包括key和value。
(5)Parcelable：所有实现了Parcelable接口的对象。
(6)所有的AIDL接口本身也可以在AIDL文件中使用。

2、服务端可以使用CopyOnWriteArrayList和ConcurrentHashMap来进行自动线程同步，客户端拿到的依然是ArrayList和HashMap；

3、服务端和客户端之间做监听器，服务端需要使用RemoteCallbackList，否则客户端的监听器无法收到通知（因为服务端实质还是一份新的序列化后的监听器实例，并不是客户端那份）；

4、客户端通过IBinder.DeathRecipient来监听Binder死亡，也可以在onServiceDisconnected中监听并重连服务端。区别在于前者是在binder线程池中，访问UI需要用Handler，后者则是UI线程。

5、可通过自定义权限在onBind或者onTransact中进行权限验证。

ContentProvider
Android中专门用作不同应用间数据共享的方式，底层实现也是Binder。
Socket
Socket 一般用于网络通信，AIDL用这种方式会过于繁琐，不建议。它在网络通讯中被称为“套接字”，分为流式套接字和用户数据报套接字两种，分别对应网络传输控制层中的TCP和UDP协议。

TCP

面向链接的协议、双向通讯稳定，建立链接需要三次握手，数据传输功能稳定。

UDP

无连接，提供不稳定单项通讯，也可实现双向通讯，效率较高，但传输数据的正确率低。

使用事项

(1)声明权限：

<uses-permission android:name="android.permission.INTERNET"></uses-permission>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>

Binder连接池

Binder连接池，通过BinderPool的方式将Binder的控制与Service本身解耦，同时只需要维护一份Service即可。这里用到了CountDownLatch，大概解释下用意：线程在await后等待，直到CountDownLatch的计数为0，BinderPool里使用它的目的是为了保证Activity获取BinderPool的时候Service已确定bind完成。

选择合适的IPC方式