什么是IPC

Inter-Process Comminication 进程间通信

各平台进程间如何通信

• Windows
  剪切板、管道和油槽
• Linux
  命名管道、共享内容和信号量
• Android
  基于Linux，常用Binder和Socket

Android应用如何开启多进程

• 通过给四大组件指定android:process
• 通过JNI在native层fork一个新的进程 不推荐

指定android:processs

• 系统将为每个进程名生成一个进程，进程名相同将运行在同一进程中

同程序多进程的危害

对象序列化

• Serializable : 常用于存储和网络通信
• Parcelable ： 常用于内存通信，由于在内存中序列化，效率更高
• Bundle

ipc方式的优缺点和适用场景

Binder各角度理解

• IPC 是一种跨进程通信方式，也可理解为虚拟的物理设备/dev/binder
• Android Framework 是ServiceManager连接各种Mangager的桥梁
• 应用层 是客户端和服务端进行通信的媒介AIDL

AIDL使用解析

文件共享

• 适合在数据同步要求不高的进程之间进行通信
• SharedPreference也是文件共享，但由于Android对他有一层内存缓存，所以多进程操作很容易丢失数据。

使用Messenger

• 是轻量级IPC方案，顶层使用AIDL实现
• 串行(Handler)处理请求，大量并发请求状况不适用

public class MessengerService extends Service {
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            //  回数据
            switch (msg.what) {
                case 0:
                    System.out.println(msg.getData().getString("request"));
                    Messenger client = msg.replyTo;
                    Message replyMsg = Message.obtain(null, 1);
                    Bundle data = new Bundle();
                    data.putString("result", "i've received you request");
                    replyMsg.setData(data);
                    try {
                        client.send(replyMsg);
                        break;
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                default:
                    super.handleMessage(msg);
            }
        }
    }

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

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

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

public class MainActivity extends AppCompatActivity {
    private Messenger mMessenger;

    private Messenger mGetReplyMessenger = new Messenger(new ClientMsgHandler());

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //  发数据
            mMessenger = new Messenger(service);
            Message msg = Message.obtain(null, 0);
            Bundle data = new Bundle();
            data.putString("request", "i'm client, send a msg");
            msg.setData(data);
            msg.replyTo = mGetReplyMessenger;
            try {
                mMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };

    static class ClientMsgHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    Bundle data = msg.getData();
                    System.out.println(data.getString("result"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

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

        Intent intent = new Intent(MainActivity.this, MessengerService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
    }

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

AIDL跨进程回调

• 封装一个集合存储回调

• 由于跨进程对象会经过序列化和反序列化（普通集合移除时传入对象和集合中对象不同），所以需要使用RemoteCallbackList来避免回调对象移除失败

• RemoteCallbackList : 内部有个ArrayMap结构专门用来保存AIDL回调，这个Map的key是Ibinder类型，value是CallBack类型。其中CallBack中封装了真正的Listener远程对象

• 服务端

// IOnChangeListener.aidl  回调接口
package com.rtfsc.passwordinputview;
interface IOnChangeListener {
    void onChange(String aString);
}

// IMyAidlInterface.aidl 远程服务接口
package com.rtfsc.passwordinputview;
import com.rtfsc.passwordinputview.IOnChangeListener;
interface IMyAidlInterface {
    void doSomething(String str);
    void registerListener(IOnChangeListener listener);
    void unregisterListener(IOnChangeListener listener);
}

// AidlService.java 远程服务Service
public class AidlService extends Service {
    private RemoteCallbackList<IOnChangeListener> mCallbackList = new RemoteCallbackList<>();

    private Binder mBinder = new IMyAidlInterface.Stub() {

        @Override
        public void doSomething(String str) throws RemoteException {
            System.out.println("AidlService.doSomething@" + str);
        }

        @Override
        public void registerListener(IOnChangeListener listener) throws RemoteException {
            listener.onChange("call back register");
            System.out.println("AidlService.registerListener@" + mCallbackList.register(listener));

        }

        @Override
        public void unregisterListener(IOnChangeListener listener) throws RemoteException {
            listener.onChange("call back unregister");
            System.out.println("AidlService.unregisterListener@" + mCallbackList.unregister(listener));
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }
}

// AndroidManifest.xml
<service    
  android:name=".AidlService"    
  android:process=":remote"/>

• 客户端

public class MainActivity extends AppCompatActivity {
    IMyAidlInterface iMyAidlInterface;
    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            iMyAidlInterface = IMyAidlInterface.Stub.asInterface(service);
            try {
                iMyAidlInterface.registerListener(mListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    private IOnChangeListener mListener = new IOnChangeListener.Stub() {
        @Override
        public void onChange(String aString) throws RemoteException {
            System.out.println(aString);
        }
    };

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

        Intent intent = new Intent(MainActivity.this, AidlService.class);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        try {
            if (iMyAidlInterface != null) {
                iMyAidlInterface.unregisterListener(mListener);
            }
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        unbindService(mServiceConnection);
        super.onDestroy();
    }
}

• Log

07-28 18:04:24.017 6844-6844/com.rtfsc.passwordinputview I/System.out: call back register
07-28 18:04:24.017 6873-6890/com.rtfsc.passwordinputview:remote I/System.out: AidlService.registerListener@true
07-28 18:04:29.027 6844-6844/com.rtfsc.passwordinputview I/System.out: call back unregister
07-28 18:04:29.027 6873-6890/com.rtfsc.passwordinputview:remote I/System.out: AidlService.unregisterListener@true