IPC机制

1、IPC简介

IPC是Inter-Process Communication的缩写，进程间通信或者跨进程通信，是指两进程之间进行数据交换的过程。在Android中，UI是主线程，其可以操作界面元素，但耗时操作放在UI线程处理会导致ANR错误。

2、多进程模式

2.1、开启多进程

通过四大组件制定android:process属性，可以开启多进程模式，例如：

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:roundIcon="@mipmap/ic_launcher_round"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity android:name=".MainActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <activity android:name=".SecondActivity"
        android:process=":test"/>
    <activity android:name=".ThirdActivity"
        android:process="com.fomin.ipc.test"/>
</application>

上面分别为SecondActivity和ThirdActivity增加了process属性，可以看出，他们的命名是不一样的，首先，“:”的含义是指要在当前的进程名前面附加上当前的包名，简写的写法；其次，“:”开头的进程属于当前应用的私有名称，其它应用的组件不可以和它跑在同一个进程中，而进程名不以":"开头的进程属于全局进程，可以通过ShareUID和它跑在同一个进程中（要求签名相同既可以）。

2.2、运行机制

Android为每个应用都分配了独立的虚拟机，也可以说为每个进程分配独立虚拟机，不同的虚拟机在内存中分配上有不同的地址空间，导致不同的虚拟机中访问一个类的对象会产生多个副本。

一般来说，使用多进程是产生下面的问题：

• 静态成员和单列模式完全失效
• 线程同步机制完全失效
• SharedPreferences的可靠性下降
• Application会多次创建

3、Binder

Binder是Android中的一个类，实现了IBinder接口，从IPC角度来说，它是Android的一种跨进程通信方式。主要在Service中，包括AIDL和Messenger，其中普通Service中的Binder不涉及进程间通信的。

public interface IBookManager extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.fomin.ipc.IBookManager {
        private static final java.lang.String DESCRIPTOR = "com.fomin.ipc.IBookManager";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.fomin.ipc.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.fomin.ipc.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.fomin.ipc.IBookManager))) {
                return ((com.fomin.ipc.IBookManager) iin);
            }
            return new com.fomin.ipc.IBookManager.Stub.Proxy(obj);
        }

        @Override
        public android.os.IBinder asBinder() {
            return this;
        }

        @Override
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(DESCRIPTOR);
                    return true;
                }
                case TRANSACTION_getBookList: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.fomin.ipc.Book> _result = this.getBookList();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.fomin.ipc.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.fomin.ipc.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.fomin.ipc.IBookManager {
            private android.os.IBinder mRemote;

            Proxy(android.os.IBinder remote) {
                mRemote = remote;
            }

            @Override
            public android.os.IBinder asBinder() {
                return mRemote;
            }

            public java.lang.String getInterfaceDescriptor() {
                return DESCRIPTOR;
            }

            @Override
            public java.util.List<com.fomin.ipc.Book> getBookList() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.fomin.ipc.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.fomin.ipc.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            @Override
            public void addBook(com.fomin.ipc.Book book) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    if ((book != null)) {
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

        static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
    }

    public java.util.List<com.fomin.ipc.Book> getBookList() throws android.os.RemoteException;

    public void addBook(com.fomin.ipc.Book book) throws android.os.RemoteException;
}

上面的类是通过AIDL自动生成的，介绍下相关的方法含义。

• DESCRIPTOR：Binder的唯一标识，一般用在当前Binder的类名表示。
• asInterface(android.os.IBinder obj)：用于将服务端的Binder对象转换成客户端的AIDL接口类型对象，转换过程是区分进程的，如果客户端和服务端位于同一进程，那么此方法返回的就是服务端的Stub对象本身，否则返回的系统封装后的Stub.proxy对象。
• asBinder：返回当前的Binder对象
• onTransact：方法运行在服务端中的Binder线程池中，当客户端发起跨进程请求时，远程请求会通过系统底层封装后交由此方法来处理。
• Proxy#getBookList：自定义的API
• Proxy#addBook：自定义的API

4、Android中的IPC方式

4.1、使用文件共享

共享文件是一种不错的进程间通信方式，两个进程通过读/写一个文件来交换数据。在Android中，SharedPreferences是轻量级的存储方案，由于系统对它的读/写有一定的缓存策略，即在内存中会有一份SharedPreferences的文件缓存，因此在多线程下，系统对读/写变得不可靠，面对高并发的读/写数据，有很大的几率会丢失数据，不建议进程间通信使用SharedPreferences。

进程一写数据：
fun saveDataToFile() {
    Thread(Runnable {
        var book: Book = Book(1, "Android")
        val dir = File(path)
        if (!dir.exists()) {
            dir.mkdirs()
        }
        val cachedFile = File(cachePath)
        var stream: ObjectOutputStream? = null
        try {
            stream = ObjectOutputStream(FileOutputStream(cachedFile))
            stream.writeObject(book)
        } catch (e: IOException) {
            e.printStackTrace();
        } finally {
            stream?.close();
        }
    }).start()
}
进程二读取数据：
fun readFromFile() {
    Thread(Runnable {
        var book: Book? = null
        val cachedFile = File(cachePath)
        if (cachedFile.exists()) {
            var stream: ObjectInputStream? = null
            try {
                stream = ObjectInputStream(FileInputStream(cachedFile))
                book = stream.readObject() as Book
            } catch (e: IOException) {
                e.printStackTrace();
            } finally {
                stream?.close();
            }
        }
    }).start()
}

4.2、使用Messager

Messager中进行的数据传递必须将数据传入Message中，而Messager和Message都实现了Parcelable接口。在Message中有what、arg1、arg2、Bundle和replyTo，而另外一个object字段只能使用系统提供的Parcelable对象才能传输，自定义的Parcelable对象是无法通过传输的。下面通过例子来看看它是怎样使用的。

class MessageService : Service() {

    private val TAG = "MessageService"

    private val mMessenger = Messenger(MessageHandler())

    private inner class MessageHandler : Handler() {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                1001 -> {
                    Log.d(TAG, msg.data.getString("key"))
                    val client = msg.replyTo
                    val reply = Message.obtain(null, 1002)
                    val bundle = Bundle()
                    bundle.putString("key", "消息收到")
                    reply.data = bundle
                    try {
                        client.send(reply)
                    } catch (e: RemoteException) {
                        e.printStackTrace()
                    }
                }
                else -> super.handleMessage(msg)
            }
        }
    }

override fun onBind(intent: Intent): IBinder? {
        return mMessenger.binder
    }
}

注册service

<service android:name=".MessageService"
    android:process=":process1"/>

客户端使用

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val intent = Intent(this, MessageService::class.java)
    bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
}
private val TAG = "MainActivity"
private var mService: Messenger? = null
private val mMessenger = Messenger(MessengerHandler())

private val mConnection = object : ServiceConnection {
    override fun onServiceConnected(name: ComponentName, service: IBinder) {
        mService = Messenger(service)
        val msg = Message.obtain(null, 1001)
        val data = Bundle()
        data.putString("msg", "客户端发送消息")
        msg.data = data
        msg.replyTo = mMessenger
        try {
            mService?.send(msg)
        } catch (e: RemoteException) {
            e.printStackTrace()
        }
    }

    override fun onServiceDisconnected(name: ComponentName) {

    }
}

private inner class MessengerHandler : Handler() {
    override fun handleMessage(msg: Message) {
        when (msg.what) {
            1002 -> Log.i(TAG, msg.data.getString("key"))
            else -> super.handleMessage(msg)
        }
    }
}

4.3、使用AIDL

AIDL首先需要创建一个Service监听客户端的连接请求；再次需要创建客户端绑定Service。下面来看看AIDL接口创建(IBookManager.aidl和Book.aidl)

//IBookManager.aidl
import com.fomin.ipc.Book;
// Declare any non-default types here with import statements

interface IBookManager {
    List<Book> getBookList();
    void addBook(in Book book);
}

// IBook.aidl
packag// IBook.aidl
package com.fomin.ipc;

// Declare any non-default types here with import statements

parcelable Book;

支持以下数据类型：

• 基本数据类型（int、long、char、boolean、double等）
• String和CharSequence
• List：只支持ArraryList
• Map：只支持HashMap
• Parcelable：所有实现Parcelable的对象
• AIDL：所有AIDL本身也可以使用

创建Service：

class BookManagerService : Service() {

    private val TAG = "BookManagerService"
    private val mBookList = CopyOnWriteArrayList<Book>()

    private val mBinder = object : IBookManager.Stub() {
        @Throws(RemoteException::class)
        override fun getBookList(): List<Book>? {
            return mBookList
        }

        @Throws(RemoteException::class)
        override fun addBook(book: Book) {
            mBookList.add(book)
        }
    }
    override fun onBind(intent: Intent?): IBinder {
        return mBinder
    }
}

注册service

<service android:name=".BookManagerService"
    android:process=":process2"/>

创建客户端

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val intent = Intent(this, BookManagerService::class.java)
    bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
}

override fun onDestroy() {
    unbindService(mConnection)
    super.onDestroy()
}

private val mConnection = object : ServiceConnection {
    override fun onServiceConnected(name: ComponentName, service: IBinder) {
        val bookManager = IBookManager.Stub.asInterface(service)
        try {
           val bookList = bookManager.bookList
        } catch (e: RemoteException) {
            e.printStackTrace()
        }
    }

    override fun onServiceDisconnected(name: ComponentName) {

    }
}

在这有个问题，UI线程执行耗时的操作会导致ANR，所以客户端在getBookList的时候需要在非UI线程执行

4.4、使用ContentProvider

ContentProvider底层也是实现Binder，主要以表格形式来组织数据，可以包含多个表，支持文件数据（图片、视频等）。需要注意的是query、update、insert、delete四大方法是存在多线程并发访问的，因此内部需要做好线程同步。

//数据库操作工具
class DbHelper(context: Context) : SQLiteOpenHelper(context, DB_NAME, null, DB_VERSION) {

    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL("")//创建表
    }

    override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {

    }

    companion object {
        private val DB_NAME = "book.db"
        private val DB_VERSION = 1
    }
}
//数据操作
class BookProvider : ContentProvider() {

    private var mDb: SQLiteDatabase? = null

    override fun onCreate(): Boolean {
        mDb = DbHelper(getContext()).writableDatabase
        return true
    }

    override fun insert(uri: Uri?, values: ContentValues?): Uri {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun query(uri: Uri?, projection: Array<out String>?, selection: String?, selectionArgs: Array<out String>?, sortOrder: String?): Cursor {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun update(uri: Uri?, values: ContentValues?, selection: String?, selectionArgs: Array<out String>?): Int {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun delete(uri: Uri?, selection: String?, selectionArgs: Array<out String>?): Int {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

    override fun getType(uri: Uri?): String {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }
}

注册ContentProvider，android:authorities必须是唯一的，外界想使用BookProvider必须声明com.fomin.PROVIDER这权限

<provider
    android:authorities="com.fomin.ipc"
    android:name=".BookProvider"
    android:permission="com.fomin.PROVIDER"
    android:process=":provider"/>

客户端使用：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val bookUri = Uri.parse("content://com.fomin.ipc/book")
    val contentValues = ContentValues()
    contentValues.put("id", 1)
    contentValues.put("name", "Android")
    contentResolver.insert(bookUri, contentValues)
}

4.5、使用socket

使用socket通信，首先需要声明权限：

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

其次不能再主线程中访问网络，网络操作可能是耗时的，影响程序的效率，而且在4.0系统会报错android.os.NetworkOnMainThreadException.

5、选用合适的IPC方式

名称	优点	缺点	适用场景
Bundle	简单	只能传输Bundle支持的数据	四大组件进程间的通信
文件共享	简单	不适合高并发场景，并无法做到进程间的即时通信	无并发访问情形
AIDL	功能强大，支持一对多并发通信，支持实时通信	使用复杂，需要处理好线程间的同步	一对多通信且有RPC需求
Messenger	功能一般，支持一对多串行通信，支持实时通信	不能很好的处理高并发的情形，不支持RPC，数据通过Message进行传输，因此只能传输Bundle支持的数据	低并发的一对多即时通信，无RPC需求，或者不需要返回结果的RPC需求
ContentProvider	数据源访问功能强大，支持一对多并发数据共享	主要提供数据源的CRUD操作	一对多进程间的数据共享
Socket	功能强大，通过网络传输字节流，支持一对多并发实时通信	实现繁琐，不支持直接的RPC	网络数据交换