正文
Android 12(S) 图像显示系统 - 基础知识之 BitTube
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
必读：
Android 12(S) 图像显示系统 - 开篇
一、基本概念
在Android显示子系统中，我们会看到有使用BitTube来进行跨进程数据传递。BitTube的实现很简洁，就是一对“parcel-able”模式的socket，用Linux/Unix中的专业术语就是socketpair。socketpair是Linux/Unix系统中用于进程间通信的一种机制，和pipe十分类似。
socketpair利用socket为双方建立了全双工的通信管道(communication pipe)。通过文件描述符的复用(dup/dup2)，可以传递socket handle到另一个进程，复用它并开启通信。
BitTube使用了Linux/Unix socket中的顺序数据包(sequenced packets，SOCK_SEQPACKET)，像SOCK_DGRAM，它只传送整包数据；又像SOCK_STREAM，面向连接且提供有序的数据报传送。
尽管socketpair是一个全双工的管道，但BitTube是按照单向方式使用它的：一端写入数据，另一端读出数据。收、发缓存默认限制为4KB大小。在BitTube中，提供了收发序列化对象的方法(sendObjects, recvObjects)。
二、源码解读
BitTube代码量很少,在(frameworks\native\libs\gui\BitTube.cpp)中,我们直接看它的几个重要的接口。
2.1 构造函数
[/frameworks/native/libs/gui/include/private/gui/BitTube.h]
BitTube() = default; // 默认构造函数，未初始化
explicit BitTube(size_t bufsize); // 创建指定发送、接收缓存大小的BitTube对象，creates a BitTube with a a specified send and receive buffer size
explicit BitTube(DefaultSizeType); // 默认缓存大小4KB，creates a BitTube with a default (4KB) send buffer
explicit BitTube(const Parcel& data); // 从Parcel中解析创建对象，用于跨进程传递该对象
BitTube提供了四个构造函数，用于不同的场景
[/frameworks/native/libs/gui/BitTube.cpp]
BitTube::BitTube(size_t bufsize) {
init(bufsize, bufsize); // 根据指定的buffer size,进行初始化
}BitTube::BitTube(DefaultSizeType) : BitTube(DEFAULT_SOCKET_BUFFER_SIZE) {}BitTube::BitTube(const Parcel& data) {
readFromParcel(&data);
}
构造函数中最主要的还是调用了init方法进行初始化。
2.2 init初始化
init方法中就是去创建/配置sockect pair
[/frameworks/native/libs/gui/BitTube.cpp]
void BitTube::init(size_t rcvbuf, size_t sndbuf) {
int sockets[2];
if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, sockets) == 0) { // 创建socket pair
size_t size = DEFAULT_SOCKET_BUFFER_SIZE;
setsockopt(sockets[0], SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)); // //对socketfd进行配置
setsockopt(sockets[1], SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf));
// since we don't use the "return channel", we keep it small...
setsockopt(sockets[0], SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
setsockopt(sockets[1], SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
fcntl(sockets[0], F_SETFL, O_NONBLOCK); //设置为非阻塞
fcntl(sockets[1], F_SETFL, O_NONBLOCK); //设置为非阻塞
mReceiveFd.reset(sockets[0]); //用于数据接收的socket handle
mSendFd.reset(sockets[1]); //用于数据发送的socket handle
} else {
mReceiveFd.reset();
ALOGE("BitTube: pipe creation failed (%s)", strerror(errno));
}
}
成员变量mReceiveFd,看起来是一个接收端,实际上这个fd也可以用来发送，同样mSendFd也可以用来接收，只是BitTube是按照单向方式使用它的：一端写入数据，另一端读出数据。
2.3 sendObjects 发送数据
先看其定义，sendObject实现为一个模板函数,sendObjects里调用的是write成员函数,write中调用send接口将数据写入mSendFd中。
[/frameworks/native/libs/gui/include/private/gui/BitTube.h]
// send objects (sized blobs). All objects are guaranteed to be written or the call fails.
template <typename T>
static ssize_t sendObjects(BitTube* tube, T const* events, size_t count) {
return sendObjects(tube, events, count, sizeof(T));
}
发送成功则返回：发送的对象的个数
发送失败则返回：负数
[ /frameworks/native/libs/gui/BitTube.cpp]
ssize_t BitTube::sendObjects(BitTube* tube, void const* events, size_t count, size_t objSize) {
const char* vaddr = reinterpret_cast<const char*>(events);
ssize_t size = tube->write(vaddr, count * objSize);
...
return size < 0 ? size : size / static_cast<ssize_t>(objSize);
}ssize_t BitTube::write(void const* vaddr, size_t size) {
ssize_t err, len;
do {
len = ::send(mSendFd, vaddr, size, MSG_DONTWAIT | MSG_NOSIGNAL); // 通过mSendFd，发送数据
// cannot return less than size, since we're using SOCK_SEQPACKET
err = len < 0 ? errno : 0;
} while (err == EINTR);
return err == 0 ? len : -err;
}
2.4 recvObjects 接收数据
先看其定义，recvObject实现为一个模板函数,recvObjects里调用的是read成员函数,read中调用rev接口将数据从mReceiveFd中读出。
接收成功则返回：接收的对象的个数
接收失败则返回：负数
[ /frameworks/native/libs/gui/include/private/gui/BitTube.h]
template <typename T>
static ssize_t recvObjects(BitTube* tube, T* events, size_t count) {
return recvObjects(tube, events, count, sizeof(T));
}
[/frameworks/native/libs/gui/BitTube.cpp]
ssize_t BitTube::recvObjects(BitTube* tube, void* events, size_t count, size_t objSize) {
char* vaddr = reinterpret_cast<char*>(events);
ssize_t size = tube->read(vaddr, count * objSize);
...
return size < 0 ? size : size / static_cast<ssize_t>(objSize);
}ssize_t BitTube::read(void* vaddr, size_t size) {
ssize_t err, len;
do {
len = ::recv(mReceiveFd, vaddr, size, MSG_DONTWAIT);
err = len < 0 ? errno : 0;
} while (err == EINTR);
if (err == EAGAIN || err == EWOULDBLOCK) {
// EAGAIN means that we have non-blocking I/O but there was no data to be read. Nothing the
// client should care about.
return 0;
}
return err == 0 ? len : -err;
}
2.5 writeToParcel & readFromParcel
writeToParcel & readFromParcel用于跨进程传递BitTube对象，进行序列化和反序列化，主要是传递mReceivedFd 和 mSendFd。
status_t BitTube::writeToParcel(Parcel* reply) const {
if (mReceiveFd < 0) return -EINVAL; status_t result = reply->writeDupFileDescriptor(mReceiveFd); // mReceiveFd写入Parcel
mReceiveFd.reset();
if (result != NO_ERROR) {
return result;
}
result = reply->writeDupFileDescriptor(mSendFd);// mSendFd写入Parcel
mSendFd.reset();
return result;
}status_t BitTube::readFromParcel(const Parcel* parcel) {
mReceiveFd.reset(dup(parcel->readFileDescriptor())); // 获取 mReceiveFd
if (mReceiveFd < 0) {
mReceiveFd.reset();
int error = errno;
ALOGE("BitTube::readFromParcel: can't dup file descriptor (%s)", strerror(error));
return -error;
}
mSendFd.reset(dup(parcel->readFileDescriptor())); // 获取 mSendFd
if (mSendFd < 0) {
mSendFd.reset();
int error = errno;
ALOGE("BitTube::readFromParcel: can't dup file descriptor (%s)", strerror(error));
return -error;
}
return NO_ERROR;
}
三、使用
关于如何使用BitTube实现跨进程的数据通信，提供一个简单的测试Demo:
https://github.com/yrzroger/BitTubeTest
在测试demo中，创建了一个BitTube对象，这样就建立了通信的 socketpair。
然后使用fork系统调用创建新的进程，来模拟跨进的通信中的不同进程(一个父进程，一个子进程)
父进程和子进程就可以使用BitTube对象的sendObjects方法发送数据，或使用recvObjects方法接收数据
Demo的主要代码如下：
struct Event {
int id;
int message;
};int main()
{
gui::BitTube* dataChannel = new gui::BitTube(gui::BitTube::DefaultSize); printf("\033[0mBitTube info: mReceiveFd=%d, mSendFd=%d\n", dataChannel->getFd(), dataChannel->getSendFd()); if(fork()) {
// 父进程发送数据
Event events[] = { {0, 888}, {1, 999} };
ssize_t size = gui::BitTube::sendObjects(dataChannel, events, 2);
if(size < 0)
printf("\033[32mprocess(%d) send failed, in parent process", getpid());
else
printf("\033[32mprocess(%d) send success, object size = %d\n", getpid(), size);
sleep(1);
// 父进程接收数据
size = gui::BitTube::recvObjects(dataChannel, events, 2);
if(size < 0) {
printf("\033[32mprocess(%d) receive failed, in child process", getpid());
}
else {
printf("\033[32mprocess(%d) receive success, object size = %d\n", getpid(), size);
for(int i = 0; i < size; ++i) {
printf("\033[32mprocess(%d): id=%d, message=%d\n", getpid(), events[i].id, events[i].message);
}
}
sleep(1); } else {
// 子进程接收数据
Event events[2];
ssize_t size = gui::BitTube::recvObjects(dataChannel, events, 2);
if(size < 0) {
printf("\033[31mprocess(%d) receive failed, in child process", getpid());
}
else {
printf("\033[31mprocess(%d) receive success, object size = %d\n", getpid(), size);
for(int i = 0; i < size; ++i) {
printf("\033[31mprocess(%d): id=%d, message=%d\n", getpid(), events[i].id, events[i].message);
}
}
// 子进程发送数据
events[0].message+=1; events[1].message+=1;
size = gui::BitTube::sendObjects(dataChannel, events, 2);
if(size < 0)
printf("\033[31mprocess(%d) send failed, in parent process", getpid());
else
printf("\033[31mprocess(%d) send success, object size = %d\n", getpid(), size);
sleep(2);
}
delete dataChannel; return 0;
}
放到Android源码下，执行mm，编译得到可执行档BitTubeTest，push到测试板/system/bin/目录下 执行BitTubeTest可以查看打印的结果：
绿色字体是父进程的打印(PID=12374)，红色字体是子进程的答应(PID=12375)
在Android图像显示子系统中， /frameworks/native/libs/gui/DisplayEventReceiver.cpp 及 /frameworks/native/services/surfaceflinger/Scheduler/EventThread.cpp 中可以看到使用BitTube的身影。
BitTube用于建立跨进程传递数据的通道，主要是display evnets， 比如hotplug events , vsync events等等
至于具体的使用过程，在接下来的文章中我们会再详细介绍，，本篇就仅先讲解必要的基础知识。
