本文正在参与「金石方案」

前言

说起Android进行间通讯，咱们榜首时间会想到AIDL，可是因为Binder机制的约束，AIDL无法传输超大数据。

那么咱们怎么在进程间传输大数据呢？

Android中给咱们提供了别的一个机制：LocalSocket

它会在本地创立一个socket通道来进行数据传输。

那么它怎样使用？

首要咱们需求两个使用：客户端和服务端

服务端初始化

override fun run() {
    server = LocalServerSocket("xxxx")
    remoteSocket = server?.accept()
    ...
}

先创立一个LocalServerSocket服务，参数是服务名，留意这个服务名需求仅有，这是两头衔接的依据。

然后调用accept函数进行等候客户端衔接，这个函数是block线程的，所以比如中另起线程。

当客户端发起衔接后，accept就会回来LocalSocket目标，然后就能够进行传输数据了。

客户端初始化

var localSocket = LocalSocket()
localSocket.connect(LocalSocketAddress("xxxx"))

首要创立一个LocalSocket目标

然后创立一个LocalSocketAddress目标，参数是服务名

然后调用connect函数衔接到该服务即可。就能够使用这个socket传输数据了。

数据传输

两头的socket目标是一个类，所以两头的发送和承受代码逻辑共同。

经过localSocket.inputStream和localSocket.outputStream能够获取到输入输出流，经过对流的读写进行数据传输。

留意，读写流的时分一定要新开线程处理。

因为socket是双向的，所以两头都能够进行收发，即读写

发送数据

var pool = Executors.newSingleThreadExecutor()
var runnable = Runnable {
 try {
 var out = xxxxSocket.outputStream
 out.write(data)
 out.flush()
    } catch (e: Throwable) {
        Log.e("xxx", "xxx", e)
    }
}
pool.execute(runnable)

发送数据是自动动作，每次发送都需求另开线程，所以假如是屡次，咱们需求使用一个线程池来进行管理

假如需求屡次发送数据，能够将其进行封装成一个函数

接纳数据

接纳数据实际上是进行while循环，循环进行读取数据，这个最好在衔接成功后就开端，比如客户端

localSocket.connect(LocalSocketAddress("xxx"))
var runnable = Runnable {
    while (localSocket.isConnected){
var input = localSocket.inputStream
input.read(data)
        ...
    }
}
Thread(runnable).start()

接纳数据实际上是一个while循环不停的进行读取，未读到数据就持续循环，读到数据就进行处理再循环，所以这里只另开一个线程即可，不需求线程池。

传输杂乱数据

上面只是简略事例，无法传输杂乱数据，假如要传输杂乱数据，就需求使用DataInputStream和DataOutputStream。

首要需求界说一套协议。

比如界说一个简略的协议：传输的数据分两部分，榜首部分是一个int值，表示后边byte数据的长度；第二部分便是byte数据。这样就知道怎么进行读写

写数据

var pool = Executors.newSingleThreadExecutor()
var out = DataOutputStream(xxxSocket.outputStream)
var runnable = Runnable {
 try {
 out.writeInt(data.size)
 out.write(data)
 out.flush()
    } catch (e: Throwable) {
        Log.e("xxx", "xxx", e)
    }
}
pool.execute(runnable)

读数据

var runnable = Runnable {
 var input = DataInputStream(xxxSocket.inputStream)
 var outArray = ByteArrayOutputStream()
    while (true) {
        outArray.reset()
 var length = input.readInt()
 if(length > 0) {
 var buffer = ByteArray(length)
 input.read(buffer)
            ...
        }
    }
}
Thread(runnable).start()

这样就能够传输杂乱数据，不会导致数据紊乱。

传输超大数据

上面虽然能够传输杂乱数据，可是当咱们的数据过大的时分，也会出现问题。

比如传输图片或视频，假设byte数据长度到达1228800，这时咱们经过

var buffer = ByteArray(1228800)
input.read(buffer)

无法读取到一切数据，只能读到一部分。而且会形成后边数据的紊乱，因为读取方位错位了。

读取的长度大约是65535个字节，这是因为TCP被IP包包着，也会有包大小约束65535。

可是留意！写数据的时分假如数据过大就会自动进行分包，可是读数据的时分假如一次读取形似无法跨包，这样就导致了上面的结果，只能读一个包，后边的就紊乱了。

那么这种超大数据该怎么传输呢，咱们用循环将其一点点写入，也一点点读出，并根据结果不断的修正偏移。代码：

写入

var pool = Executors.newSingleThreadExecutor()
var out = DataOutputStream(xxxSocket.outputStream)
var runnable = Runnable {
 try {
 out.writeInt(data.size)
 var offset = 0
 while ((offset + 1024) <= data.size) {
 out.write(data, offset, 1024)
            offset += 1024
        }
 out.write(data, offset, data.size - offset)
 out.flush()
    } catch (e: Throwable) {
        Log.e("xxxx", "xxxx", e)
    }
}
pool.execute(runnable)

读取

var input = DataInputStream(xxxSocket.inputStream)
var runnable = Runnable {
 var outArray = ByteArrayOutputStream()
    while (true) {
        outArray.reset()
 var length = input.readInt()
 if(length > 0) {
 var buffer = ByteArray(1024)
 var total = 0
            while (total + 1024 <= length) {
 var count = input.read(buffer)
                outArray.write(buffer, 0, count)
                total += count
            }
 var buffer2 = ByteArray(length - total)
 input.read(buffer2)
            outArray.write(buffer2)
 var result = outArray.toByteArray()
            ...
        }
    }
}
Thread(runnable).start()

这样能够避免因为分包而导致读取的长度不匹配的问题