1、概念

IPC（一）跨进程通讯的几种方式、作用

2、Messenger

IPC（二）Messenger实现跨进程双向通信

3、AIDL

IPC（三）AIDL实现跨进程通信

4、两个APP间进行IPC通信

两个App间进行IPC通信

5、学习资料

课程地址：https://ke.qq.com/course/3853967

LocalSocket是什么？
在弄清LocalSocket是什么之前，有必要先了解下Socket是什么。Socket通常翻译为套接字，它是为了方便让两台机器能互相通信的一套技术，该套技术封装好了繁琐的TCP/IP协议，向外提供出简单的API简化了通信实现的过程，其可以实现不同层面，不同应用，跨进程跨网络的通信。依据Socket提供的数据传输特性可分为如下几个大类：

• Stream socket: 提供双向、有序、可靠、非重复的数据通信。大致可以认为它封装的TCP通信协议。
• Datagram socket: 提供双向数据通信，数据不一定按顺序到达。大致可以认为它封装的是UDP通信协议。
• Sequential socket: 提供双向、有序、可靠数据通信，数据包有最大限制，并且必须把这个包完整的接受才能进行读取。
• Raw socket: 提供相对TCP/UDP而言较下层的通信协议访问，如果使用非TCP/UDP的通信协议可以使用该类型的socket。

socket通信过程如下图
Android系统可以通过命令

adb shell netstat -apn

LocalSocket通信实例
一般两个不同的应用之间如果要相互通信，首先想到的解决方案都是利用AIDL，这里我们用LocalSocket来实现。通过该例子来实践下LocalSocket
一、服务端实现
1、服务端代码如下所示

public class ServerActivity extends AppCompatActivity {

    private LocalServerSocket mServerSocket = null;
    private LocalSocket mSocket = null;
    private TextView mShowMsg = null;
    private InputStream mInputStream = null;
    private static final String SOCKET_NAME = "com.wq.serverdemo.testsocket";
    private static final String TAG = "wq892373445-Socket";

    private final Handler mHandler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            String dispMesg = (String) msg.obj;
            mShowMsg.setText(dispMesg);
        };
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_server);
        Button button = (Button) findViewById(R.id.replay_btn);
        mShowMsg = (TextView) findViewById(R.id.display_msg);
        createServerSocket();// 创建LocalServerSocket
        new Thread(new Runnable() {
            @Override
            public void run() {
                acceptMsg();//必须要在子线程里接收消息
            }
        }).start();
    }

    private void createServerSocket() {
        if (mServerSocket == null) {
            try {
                /**注意这里new出LocalServerSocket的同时，系统层已经同步做了bind和listen。
                 * 我们看看new的过程：
                 * public LocalServerSocket(String name) throws IOException {
                 *       impl = new LocalSocketImpl();
                 *       impl.create(LocalSocket.SOCKET_STREAM);
                 *       localAddress = new LocalSocketAddress(name);
                 *       impl.bind(localAddress);
                 *       impl.listen(LISTEN_BACKLOG);
                 * }
                 */
                mServerSocket = new LocalServerSocket(SOCKET_NAME);
            } catch (IOException ex) {
                throw new RuntimeException(
                        "Error binding to local socket " + ex);
            }
        }
    }

    private void acceptMsg() {
        try {
            mSocket = mServerSocket.accept();//accept是个阻塞方法，这就是必须要在子线程接收消息的原因。
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        while (true) {
            try {
                byte[] buffer = new byte[1024];
                mInputStream = mSocket.getInputStream();
                int count = mInputStream.read(buffer);
                String key = new String(Arrays.copyOfRange(buffer, 0, count));
                Log.e(TAG, "ServerActivity mSocketOutStream==" + key);
                if ("stop".equals(key)) {
                    closeSocketResource();
                    break;
                }
                Message msg = mHandler.obtainMessage();
                msg.obj = key;
                msg.sendToTarget();
            } catch (IOException e) {
                Log.e(TAG, "exception==" + e.fillInStackTrace().getMessage());
                e.printStackTrace();
            }
        }
    }

    private void closeSocketResource() {
        closeSlient(mInputStream);
        closeSlient(mSocket);
        try {
            if (mServerSocket != null) {
                mServerSocket.close();
                mServerSocket = null;
            }
        } catch (IOException ex) {
            Log.e(TAG, "Failed closing ServerSocket" + ex.fillInStackTrace());
        }
    }

    private void closeSlient(Closeable closeable){
        try {
            if (closeable != null) {
                closeable.close();
                closeable = null;
            }
        } catch (IOException ex) {
            Log.e(TAG, "Failed closing : " + closeable);
        }
    }
}

2、布局文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".ServerActivity">

   <Button
       android:id="@+id/replay_btn"
       android:text="这是服务端"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"/>
    <TextView
        android:id="@+id/display_msg"
        android:textColor="#f0f0f0"
        android:layout_width="match_parent"
        android:layout_height="60dp"/>

</LinearLayout>

3、验证服务端是否就绪，输入如下命令

adb shell netstat -apn|grep testsocket

输出结果：
则表明服务端已经就绪，等待客户端socket接入发送消息了
二、客户端的实现
1、客户端代码

public class ClientActivity extends AppCompatActivity implements View.OnClickListener {

    private LocalSocket mSocket;
    private OutputStream mOut;
    private EditText mEditText = null;
    private static final String SOCKET_NAME = "com.wq.serverdemo.testsocket";//这里必须要跟TestLocalSocketServer中定义的一样
    private static final String TAG = "wq892373445-Socket";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_client);
        connect();
        mEditText = (EditText) findViewById(R.id.input_msg);
        findViewById(R.id.replay_btn).setOnClickListener(this);
        findViewById(R.id.stop_btn).setOnClickListener(this);
    }

    private boolean connect() {
        if (mSocket != null) {
            return true;
        }
        try {
            mSocket = new LocalSocket();//创建LocalSocket，模拟客户端
            LocalSocketAddress address = new LocalSocketAddress(SOCKET_NAME,
                    LocalSocketAddress.Namespace.ABSTRACT);
            mSocket.connect(address);//连接TestLocalSocketServer
        } catch (IOException ex) {
            return false;
        }
        return true;
    }

    private boolean writeCommand(String cmdString) {
        final byte[] cmd = cmdString.getBytes();
        final int len = cmd.length;
        try {
            mOut = mSocket.getOutputStream();
            mOut.write(cmd, 0, len);
            Log.e(TAG, "ClientActivity write " + new String(cmd));
        } catch (IOException ex) {
            Log.e(TAG, "ClientActivity write error:" + ex.fillInStackTrace());
            return false;
        }
        return true;
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.replay_btn:
                writeCommand(mEditText.getText().toString());
                break;
            case R.id.stop_btn:
                writeCommand("stop");
                break;
            default:
                break;
        }

    }
}

2、布局文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".ClientActivity">

    <Button
        android:id="@+id/replay_btn"
        android:text="回复"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
    <EditText
        android:id="@+id/input_msg"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"/>
    <Button
        android:id="@+id/stop_btn"
        android:text="关闭Socket"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
    <TextView
        android:id="@+id/display_msg"
        android:textColor="#f0f0f0"
        android:layout_width="match_parent"
        android:layout_height="60dp"/>

</LinearLayout>

3、验证服务端是否就绪，输入如下命令

adb shell netstat -apn|grep testsocket

输出结果：
则表明客户端已经连接上了服务端，可以给服务端发送消息了
三、最后在客户端发送消息给服务端效果如下所示

electron-ipc通信性能分析

electron的主进程和渲染进程间通信方案

• ipc通信
• 借助外部存储通信（通过ipc通知其它进程去读取）

方案描述

ipc通信

使用

主进程 ==> 渲染进程

发送：webContents.send(channel[, arg1][, arg2][, ...])

• channel String
• arg (可选)

通过 channel 发送异步消息给渲染进程，你也可发送任意的参数.参数应该在 JSON 内部序列化，并且此后没有函数或原形链被包括了.

渲染进程可以通过使用 ipcRenderer 监听 channel 来处理消.

接收：ipcMain.on(channel, listener)

• channel String
• listener Function

监听 channel, 当新消息到达，将通过 listener(event, args...) 调用 listener.

渲染进程 ==> 主进程

发送： ipcRenderer.send(channel[, arg1][, arg2][, ...]) 或 ipcRenderer.sendSync(channel[, arg1][, arg2][, ...])

• channel String
• arg (可选)

通过 channel 向主进程发送异步（同步）消息，也可以发送任意参数.参数会被JSON序列化，之后就不会包含函数或原型链.

主进程通过使用 ipcMain 模块来监听 channel，从而处理消息，同步消息通过 event.returnValue 来响应.

注意: 发送同步消息将会阻塞整个渲染进程,除非你知道你在做什么，否则就永远不要用它 .

接收：ipcRenderer.on(channel, listener)

• channel String
• listener Function

监听 channel, 当有新消息到达，使用 listener(event, args...) 调用 listener .

优缺点

优点：

• 可以同步或异步通信
• 使用方式简单
• 传输数据较小的情况下响应速度快

缺点：

• 滥用渲染进程同步通信时会导致进程阻塞，所以要在确保不阻塞的情况下使用
• 数据量大的场景下会导致内存溢出和通信速度变慢

借助外部存储通信

该方案还是基于ipc通信的，将数据存放到磁盘再通过ipc通知监听方去取，所以速度取决于IO读取的速度

优缺点

优点：

• 不占用内存
• 进程关闭后数据还在

缺点

• 读取速度慢，取决于IO读写速度

测试数据

测试没有覆盖多种设备和平台

测试以String为传输类型

结论

数据量较小时建议使用ipc直接通讯，反应速度快。数据量大的时候可以使用外部存储，可以降低内存占用，释放暂时不用的内存，按需读取。