Android-vold源码分析之startListener(6)

短命女 2022-05-14 01:15 222阅读 0赞

**作者：gzshun. 原创作品，转载请标明出处！**  
  
vold处理完磁盘事件，就要开始接受framework的操作命令，在main函数里面，开启了一个线程来监听framework的信息，当收到操作命令，vold进行解析，分析出命令，然后调用相应的磁盘操作函数，待操作完成后，再将操作结果的状态值反馈给framework，中间均使用了广播机制，使用了UDP协议。

在main函数中，有以下函数的调用：

if (cl->startListener()) \{ SLOGE("Unable to start CommandListener (%s)", strerror(errno)); exit(1); \}cl是CommandListener类实例化的一个对象，该对象专门负责与framework的通信，首先说明与CommandListener类相关的一些继承关系。  
CommandListener --> FrameworkListener --> SocketListener(父类)  
在CommandListener类中，声明了6个类，这6个类继承了VoldCommand类，VoldCommand类继承了FrameworkCommand，关系如下：  
VoldCommand --> FrameworkCommand(父类)  
以下是CommandListener类的声明：

class CommandListener : public FrameworkListener \{ public: CommandListener(); virtual ~CommandListener() \{\} private: static void dumpArgs(int argc, char \*\*argv, int argObscure); class DumpCmd : public VoldCommand \{ public: DumpCmd(); virtual ~DumpCmd() \{\} int runCommand(SocketClient \*c, int argc, char \*\* argv); \}; class VolumeCmd : public VoldCommand \{ public: VolumeCmd(); virtual ~VolumeCmd() \{\} int runCommand(SocketClient \*c, int argc, char \*\* argv); \}; class ShareCmd : public VoldCommand \{ public: ShareCmd(); virtual ~ShareCmd() \{\} int runCommand(SocketClient \*c, int argc, char \*\* argv); \}; class AsecCmd : public VoldCommand \{ public: AsecCmd(); virtual ~AsecCmd() \{\} int runCommand(SocketClient \*c, int argc, char \*\* argv); \}; class StorageCmd : public VoldCommand \{ public: StorageCmd(); virtual ~StorageCmd() \{\} int runCommand(SocketClient \*c, int argc, char \*\* argv); \}; class XwarpCmd : public VoldCommand \{ public: XwarpCmd(); virtual ~XwarpCmd() \{\} int runCommand(SocketClient \*c, int argc, char \*\* argv); \}; \};在这个类中，VoldCommand主要写了一个纯虚函数runCommand，声明如下：  
virtual int runCommand(SocketClient \*c, int argc, char \*\*argv) = 0;  
为了就是在CommandListener类中的实现，这里总共实现了6个版本的runCommand函数，下一篇文章只讨论其中一个比较重要的VolumeCmd类的实现，其余的跟这个类的实现差不多。  
开始深入startListener线程：  
进入startListener函数，创建了以下线程：

if (pthread\_create(&mThread, NULL, SocketListener::threadStart, this)) \{ SLOGE("pthread\_create (%s)", strerror(errno)); return -1; \}这里跟前几章线程的创建几乎一样，

void \*SocketListener::threadStart(void \*obj) \{ SocketListener \*me = reinterpret\_cast<SocketListener \*>(obj); me->runListener(); pthread\_exit(NULL); return NULL; \}线程真正实现的函数在这里：

void SocketListener::runListener() \{ while(1) \{ SocketClientCollection::iterator it; fd\_set read\_fds; int rc = 0; int max = 0; FD\_ZERO(&read\_fds); if (mListen) \{ max = mSock; FD\_SET(mSock, &read\_fds); \} FD\_SET(mCtrlPipe\[0\], &read\_fds); if (mCtrlPipe\[0\] > max) max = mCtrlPipe\[0\]; pthread\_mutex\_lock(&mClientsLock); for (it = mClients->begin(); it != mClients->end(); ++it) \{ FD\_SET((\*it)->getSocket(), &read\_fds); if ((\*it)->getSocket() > max) max = (\*it)->getSocket(); \} pthread\_mutex\_unlock(&mClientsLock); if ((rc = select(max + 1, &read\_fds, NULL, NULL, NULL)) < 0) \{ SLOGE("select failed (%s)", strerror(errno)); sleep(1); continue; \} else if (!rc) continue; if (FD\_ISSET(mCtrlPipe\[0\], &read\_fds)) break; if (mListen && FD\_ISSET(mSock, &read\_fds)) \{ struct sockaddr addr; socklen\_t alen = sizeof(addr); int c; if ((c = accept(mSock, &addr, &alen)) < 0) \{ SLOGE("accept failed (%s)", strerror(errno)); sleep(1); continue; \} pthread\_mutex\_lock(&mClientsLock); mClients->push\_back(new SocketClient(c)); pthread\_mutex\_unlock(&mClientsLock); \} do \{ pthread\_mutex\_lock(&mClientsLock); for (it = mClients->begin(); it != mClients->end(); ++it) \{ int fd = (\*it)->getSocket(); if (FD\_ISSET(fd, &read\_fds)) \{ pthread\_mutex\_unlock(&mClientsLock); /\*当收到framework的操作命令，执行该函数\*/ if (!onDataAvailable(\*it)) \{ close(fd); pthread\_mutex\_lock(&mClientsLock); delete \*it; it = mClients->erase(it); pthread\_mutex\_unlock(&mClientsLock); \} FD\_CLR(fd, &read\_fds); continue; \} \} pthread\_mutex\_unlock(&mClientsLock); \} while (0); \} \}将收到的命令交给onDataAvailable函数来处理，onDataAvailable函数是类的纯虚函数，在FrameworkListener类实现了该函数：

bool FrameworkListener::onDataAvailable(SocketClient \*c) \{ char buffer\[255\]; int len; if ((len = read(c->getSocket(), buffer, sizeof(buffer) -1)) < 0) \{ SLOGE("read() failed (%s)", strerror(errno)); return errno; \} else if (!len) return false; int offset = 0; int i; for (i = 0; i < len; i++) \{ if (buffer\[i\] == '\\0') \{ /\*命令的处理函数\*/ dispatchCommand(c, buffer + offset); offset = i + 1; \} \} return true; \}dispatchCommand函数用来选择不同的分支函数，因为在类有6个分支的实现版本，包括DumpCmd，VolumeCmd，ShareCmd，AsecCmd，StorageCmd和XwarpCmd。以下是dispatchCommand函数的源码：

void FrameworkListener::dispatchCommand(SocketClient \*cli, char \*data) \{ FrameworkCommandCollection::iterator i; int argc = 0; /\*static const int CMD\_ARGS\_MAX = 16; 说明framework发送的命令最多只能容纳16个子串\*/ char \*argv\[FrameworkListener::CMD\_ARGS\_MAX\]; /\*中间省略了字符串的处理部分,将每个子串保存到了argv数组中， 所以在out标记的位置，对argv\[i\]的数组进行释放， 因为使用了strdup函数复制字符串\*/ /\*下面这个循环用来循环选择不同的分支实现函数， mCommands容器保存着6个新声明的类对象\*/ for (i = mCommands->begin(); i != mCommands->end(); ++i) \{ FrameworkCommand \*c = \*i; /\*当第一个参数与FrameworkCommand类中的mCommand参数相等时， 才去调用该对象新实现的runCommand函数\*/ if (!strcmp(argv\[0\], c->getCommand())) \{ if (c->runCommand(cli, argc, argv)) \{ SLOGW("Handler '%s' error (%s)", c->getCommand(), strerror(errno)); \} goto out; \} \} cli->sendMsg(500, "Command not recognized", false); out: int j; for (j = 0; j < argc; j++) free(argv\[j\]); return; \}这里从代码可能有点疑问，这个循环为什么可以选择不同的分支新实现的函数呢？  
仔细看下代码会发现，在FrameworkListener中有一个注册函数，将新的派生类的名字注册到mCommands容器中，每个类的mCommand参数各代表一个派生类的名字。

void FrameworkListener::registerCmd(FrameworkCommand \*cmd) \{ mCommands->push\_back(cmd); \}在CommandListener类的构造函数中，分别对6个分支的派生类进行了注册，每次注册都实例化了一个新的对象存放到mCommands容器中。

CommandListener::CommandListener() : FrameworkListener("vold") \{ registerCmd(new DumpCmd()); registerCmd(new VolumeCmd()); registerCmd(new AsecCmd()); registerCmd(new ShareCmd()); registerCmd(new StorageCmd()); registerCmd(new XwarpCmd()); \}那这6个派生类的名称保存在FrameworkCommand类的一个私有变量mCommand中，该类的构造函数就是给mCommand赋值，源码：

FrameworkCommand::FrameworkCommand(const char \*cmd) \{ mCommand = cmd; \}在刚才的FrameworkListener::dispatchCommand函数里，有这么一个比较：

if (!strcmp(argv\[0\], c->getCommand()))\{\}getCommand函数的源码：

const char \*getCommand() \{ return mCommand; \}

这里来看mCommand的赋值，我们知道以下关系：  
DumpCmd --> VoldCommand --> FrameworkCommand  
VolumeCmd --> VoldCommand --> FrameworkCommand  
ShareCmd --> VoldCommand --> FrameworkCommand  
AsecCmd --> VoldCommand --> FrameworkCommand  
StorageCmd --> VoldCommand --> FrameworkCommand  
XwarpCmd --> VoldCommand --> FrameworkCommand  
所以在CommandListener类中的6个派生类中的构造函数中，必须初始化const char \*cmd这个参数，以下是初始化代码：

CommandListener::DumpCmd::DumpCmd() : VoldCommand("dump") \{ \} CommandListener::VolumeCmd::VolumeCmd() : VoldCommand("volume") \{ \} CommandListener::ShareCmd::ShareCmd() : VoldCommand("share") \{ \} CommandListener::StorageCmd::StorageCmd() : VoldCommand("storage") \{ \} CommandListener::AsecCmd::AsecCmd() : VoldCommand("asec") \{ \} CommandListener::XwarpCmd::XwarpCmd() : VoldCommand("xwarp") \{ \}  
6个构造函数均初始化不同的cmd参数，分别为dump,volume,share,storage,asec,xwarp。  
在VoldCommand类的构造函数中，将cmd的值初始化FrameworkCommand类的构造函数。

VoldCommand::VoldCommand(const char \*cmd) : FrameworkCommand(cmd) \{ \}

所以这个比较，就是将framework发下来的命令的第一个参数与mCommands容器中的6个对象的mCommand参数进行了比较，从而选择正确的处理分支函数。

以上的内容涉及到好几个类，谷歌真是花了很大的力气啊。。  
现在流程就走到了runCommand函数，该函数就声明在最上面那个CommandListener类里面，下一篇文章将介绍runCommand函数的实现。