Android中的进程之间的通信

Android中的进程通信主要有以下种

1.广播

广播是比较常用的进程间通信的方式，而且实现起来也比较简单

缺点：某些手机对于静态注册的广播的发送和接收延迟非常严重，例如一些配置很低的手机，华硕，联想的部分低配手机就对静态注册的广播有较长的延迟，我曾经遇到过的有延迟1到2分钟的；广播的数据传输是有限的，如果传输的数据量太大会报错

2.AIDL

AIDL是用在Service和外部进程之间的通信，如果是Service单独进程和App主进程进行通信的话可以考虑采用AIDL来实现；

第一步：定义AIDL接口

package com.xtc.sync;

import com.xtc.sync.ICloseCallback;
// Declare any non-default types here with import statements

interface IConnectionService {

/**
* 连接IM服务器
*/
int connect(String hostname, int port);

/**
* 发送数据
*/
int send(in byte[] data);

/**
* 心跳包
*/
void heartbeat();

/**
* 关闭TCP连接并停止服务
*/
void close();

void closeForBack(ICloseCallback icloseCallback);

/**
*连接是否关闭
*/
boolean isClose();

/**
*把服务器ip和端口信息传进来
*/
void initServerInfo(in String[] serverInfo);

/**
*切换连接主机
*/
void switchHost();

}

有些方法参数前面有“in”修饰，例如send(in byte[] data)，这便是是外部调用send（）接口，然后传入data的字节数组，加入是想从AIDL绑定的Service中回调获取数据的话，例如onReceive(in byte[] data)

，也要加一个“in”修饰，而如果参数类型是简单数据类型：String，int等就不需要，在用Androidstudio建aidl文件的时候会有默认提示：

interface IMyAidlInterface {
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
double aDouble, String aString);
}

表示int,long,boolean,float,double,String就可以直接传递，不需要加修饰符，当然double部数据简单数据类型

缺点：AIDL接口不够灵活，如果要传复杂的数据对象很麻烦，要定义对应的AIDL接口，而且在两个进程之中都要定义才行，更重要的是AIDL接口不稳定，因为Service有可能被系统杀死，这时候Service就是停止状态，然而要是这时候程序调用AIDL接口就会报DeadObjectException异常；会报空指针错误：

/**
* 发送数据
*/
@Override public int send(byte[] data) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeByteArray(data);
mRemote.transact(Stub.TRANSACTION_send, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}

这段代码是前面定义的send（）的AIDL接口编译后自动生成的一个类，有时候就会报__reply.readException()是NullPointerExeception，解决方案：

@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
try {
return super.onTransact(code, data, reply, flags);
} catch(RuntimeException e) {
SyncLogUtil.e("AIDL接口异常,终于捕获到了");
SyncLogUtil.e(e);
throw e;
}
}
}

捕获aidl异常，然后查看log分析到底是那一句报错，aidl接口定义好了之后就在service里面建一个内部累，集成aidl的Sub：

private class ConnectionBinder extends IConnectionService.Stub {

@Override
public int connect(String hostname, int port) throws RemoteException {
return ConnectionService.this.connect(hostname, port, true);
}

@Override
public int send(byte[] data) throws RemoteException {
return ConnectionService.this.send(data);
}

@Override
public void heartbeat() throws RemoteException {
ConnectionService.this.heartbeat();
}

@Override
public void close() throws RemoteException {
ConnectionService.this.close();
}

@Override
public void closeForBack(ICloseCallback icloseCallback) throws RemoteException {
ConnectionService.this.close(icloseCallback);
}

@Override
public boolean isClose() throws RemoteException {
return ConnectionService.this.isClose();
}

@Override
public void initServerInfo(String[] serverInfo) throws RemoteException {
ConnectionService.this.initServerInfo(serverInfo);
}

@Override
public void switchHost() throws RemoteException {
ConnectionService.this.switchHost();
}

@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
try {
return super.onTransact(code, data, reply, flags);
} catch(RuntimeException e) {
SyncLogUtil.e("AIDL接口异常,终于捕获到了");
SyncLogUtil.e(e);
throw e;
}
}
}

这个就是提供给ingyige进程调用的远程接口了，而且在onBind()方法里面要反悔这个Binder：

@Override
public IBinder onBind(Intent intent) {
SyncLogUtil.d("TCPConnection Service has binded.");
bind = true;
return new ConnectionBinder();
}

然后在另一个进程实现ServiceConnection中的两个方法：

public final class IConnServiceConnection implements ServiceConnection {

private String[] serverInfo;

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
SyncLogUtil.d(name.getPackageName() + ":connect to service successfully.");
connectionService = IConnectionService.Stub.asInterface(service);

}

@Override
public void onServiceDisconnected(ComponentName name) {

｝

}

connectionService 对象才是真正可以调用刚才定义的哪些aidl接口的对象，它就相当于外部进程和service之际嗯的桥梁，最后在startService，bindService就可以正常调用aidl接口了

3.LocalSocket和LocalServerSocket

这两个可实现和c进程的通信，比较灵活，因为数据传输是流式传输，用法和Socket，ServerSocket比较像，但是内部实现原理和SocketServerSocket就差很多了，虽然是好用，但是貌似调用close()方法的时候并不能像Socket那样直接就抛出异常，例如：

private void startLocalClient() throws IOException {
localSocket = new LocalSocket();
TLVByteBuffer buffer = new TLVByteBuffer();
byte[] receiveBuf = new byte[512];
int readLength = -1;
localSocket.connect(new LocalSocketAddress("com.xtc.watch.local"));
SyncLogUtil.i("LocalPush", "connect to local server success");
inputStream = localSocket.getInputStream();
outputStream = localSocket.getOutputStream();
while ((readLength = inputStream.read(receiveBuf)) != -1) {
buffer.write(receiveBuf, 0, readLength);
SyncLogUtil.i("LocalPush", "local client read [" + readLength + "] bytes,all buffer bytes:" + buffer.size());
while (buffer.hasNextTLVData()) {
byte[] data = buffer.cutNextTLVData();
if (data != null && data.length > 0) {
onRead(data);
} else {
SyncLogUtil.e("LocalPush", "local client data read completely,but cutted tlv bytes is null or length = 0.");
}
}
}
SyncLogUtil.w("LocalPush", "local connect client readLength:" + readLength);
buffer.reset();
}

这里客户端的localSocket如果调用close()方法或者调用localSocket.getInputStream().close()程序并不会抛出IOExeception，而是继续堵在read()方法，这样就会造成线程一直阻塞，线程isAlive()返回的是true，线程资源垡释放，LocalServerSocket也是同样的问题，我尝试在调用close()方法后不断的调用localSocket和localServerSocketwrite数据，这样线程就能正常抛出异常然后结束，而且在LocalServerSocket初始化后会绑定到一个地址，调用close()之后并不会释放这个地址，此时再次绑定这个地址会报address already used，但是在调用了LocalServerSocket的close()方法之后再次连接一个LocalSocket进来，是可以正常连上的，不过此时LocalServerSocket已经把绑定的地址释放了，而且也不能喜剧读取和写入数据了，这时候再次初始化一个LocalServerSocket丙丁岛相同的地址就能绑定成功，但是你要是new一个LocalSocket，写完数据后立即关闭，那这时候客户端的就不会造成阻塞，会正常抛出IO异常，线程结束，关于LocalSocket和LocalServerSocket的正确用法还要继续研究，主要难点就是当读取等待的线程不用了，怎么才能成功close掉，这样才能成功释放线程资源，待补充。。。

直接用本地的TCP：Socket和ServerSocket

socket实际上是用于网络通信的套接字，但是如果你把手机当作服务器，那么实际上进程间的通信也可以采用网络套接字来实现，因为Socket的通信的基于网络的通信，不存在什么进程概念，这里只需要获取手机本地的IP，然后创建ServerSocket，再用Socket连接上即可，跟网络通信的Socket使用方式一模一样，而且这条TCP连接还可实现进程间的互相监听，当有一方进程挂掉的时候，TCP连接久断开了，另一个进程能及时的受到反馈，这个就比LoccalSocket的反馈及时很多，LocalSocket其实现原理和Socket大不一样，后面有时间再做补充。另外，微信目前对于进程间的通信采用的是AIDL来实现，但是据我在一个课程上了解他们认为Socket来实现进程间的通信是非常好的，可值得尝试的做法，他们今后也会在这一个方面做尝试

直接用本地UDP

因为本地UDP数据传输并不用ping到网络上，都是本地发包与收包，因此丢包的概率大大降低了，而且效率也比TCP数据传输高