大部分编程人员进行程序代码分析时往往喜欢从main函数入手，因为它是程序入口，从main开始能够更快更好的把握程序的整体结构。

       因此我们先来看adb.c的main函数的实现：

C++代码
  1. int main(int argc, char **argv)   
  2. {   
  3.     adb_trace_init();   
  4. #if ADB_HOST   
  5.     adb_sysdeps_init();   
  6.     return adb_commandline(argc - 1, argv + 1);   
  7. #else   
  8.     if((argc > 1) && (!strcmp(argv[1],"recovery"))) {   
  9.         adb_device_banner = "recovery";   
  10.         recovery_mode = 1;   
  11.     }   
  12.   
  13.     start_device_log();   
  14.     return adb_main(0);   
  15. #endif   
  16. }  

       宏ADB_HOST用来区别编译adb和adbd，参见上一篇文章：Android开发工具ADB教程之一：ADB概论。

       现在用一个常用命令“adb devices”用来捋顺代码流程，adb_trace_init用于log tag初始化，在host端，输入命令"adb devices"之后，进入adb_commandline函数。

       adb_commandline首先解析参数，判断有没有指定transport type，即指定与哪个设备通信，emulator或者device，指定设备的方法是

       -d 
       -e 
       -s <serial number>

       然后调用adb_set_transport将type,serial赋值给全局变量。

C++代码
  1. void adb_set_transport(transport_type type, const char* serial)   
  2. {   
  3.        __adb_transport = type;   
  4.        __adb_serial = serial;   
  5. }  

       这两个全局变量由client保存，将用来告诉server，与何种设备通信，用何种方式传输通信。

       接下来，adb_commandline用来判断server守护进程是否已经启动。

C++代码
  1. if ((argc > 0) && (!strcmp(argv[0],"server"))) {   
  2.     if (no_daemon || is_daemon) {   
  3.         r = adb_main(is_daemon);   
  4.     } else {   
  5.         r = launch_server();   
  6.     }   
  7.     if(r) {   
  8.         fprintf(stderr,"* could not start server *\n");   
  9.     }   
  10.     return r;   
  11. }  

       no_daemon和is_daemon初始化为0，当读到nodaemon参数时，no_daemon为1，这种情况用户显式的不用server进行通信；读到fork-server时is_daemon为1，这是标识当前进程已经是server进程。adb_main函数的is_daemon参数是用来决定是否回送一个应答“OK”给client的。

       在这里我们的client第一次执行“adb device”，因此会去启动server，在launch_server中，执行fork()操作，生成一对管道用于父子进程的通信。子进程调用execl，执行adb fork-server server，父进程等待来自子进程的OK应答。

C++代码
  1. // child side of the fork   
  2.   
  3.  // redirect stderr to the pipe   
  4.  // we use stderr instead of stdout due to stdout's buffering behavior.   
  5.  adb_close(fd[0]);   
  6.  dup2(fd[1], STDERR_FILENO);   
  7.  adb_close(fd[1]);   
  8.   
  9.  // child process   
  10.  int result = execl(path, "adb", "fork-server", "server", NULL);   
  11.  // this should not return   
  12.  fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno);  

       这里子进程将STDERR_FILENO重定向到管道的写端fd[1];然后讲管道关闭，这样所有对stderr的操作都将写入父进程，fprintf语句只有在execl执行失败时执行。

C++代码
  1. // parent side of the fork   
  2.   
  3. char  temp[3];   
  4.   
  5. temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C';   
  6. // wait for the "OK\n" message   
  7. adb_close(fd[1]);   
  8. int ret = adb_read(fd[0], temp, 3);   
  9. adb_close(fd[0]);   
  10. if (ret < 0) {   
  11.     fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", errno);   
  12.     return -1;   
  13. }   
  14. if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') {   
  15.     fprintf(stderr, "ADB server didn't ACK\n" );   
  16.     return -1;   
  17. }   
  18.   
  19. setsid();  

       父进程从管道的读端读取子进程发过来的应答，如果非“OK”，代表创建server失败，返回，setsid用于避免父进程退出时子进程也退出，即server真正成为一个守护进程。

       花开两朵各表一只，先看fork出来的子进程，即守护进程server，前面说到，它的启动command是adb fork-server server,我们在回到adb的main函数，它用走到了adb_commandline里面来，这时候它解析参数以后，is_daemon就变成1了，因此执行adb_daemon（is_daemon）。

C++代码
  1. init_transport_registration();   
  2.   
  3.   
  4. ADB_HOST   
  5. HOST = 1;   
  6. usb_vendors_init();   
  7. usb_init();   
  8. local_init(ADB_LOCAL_TRANSPORT_PORT);   
  9.   
  10. if(install_listener("tcp:5037", "*smartsocket*", NULL)) {   
  11.     exit(1);   
  12. }   
  13. e  

       adb_daemon首先初始化transport registrantion，等待注册transport时间的到来，transport是用来与远端设备进行通信的，对HOST来说远端设备就是device/emulator，反之亦然。注册信息本身，是用通过一个socket对transport_registration_send,transport_registration_recv来传递的，这属于线程之间的通信。

       首先初始化本地USB，监听本地usb的情况，如果有用于ADB的USB设备，则注册一个type为kTransportUsb的transport。

       具体调用流程：usb_init->client_socket_thread出一个device_poll_thread线程，在device_poll_thread中：

C++代码
  1. for (;;) {    
  2.     sleep(5);   
  3.     kick_disconnected();   
  4.     scan_usb_devices();   
  5. }  

       通过scan_usb_devices查找用于adb的usb设备：

       scan_usb_devices->check_device->register_device->register_usb_transport->init_usb_transport->register_transport。

       在init_usb_transport中：

C++代码
  1. void init_usb_transport(atransport *t, usb_handle *h, int state)   
  2. {      
  3.     D("transport: usb\n");   
  4.     t->close = remote_close;   
  5.     t->kick = remote_kick;   
  6.     t->read_from_remote = remote_read;   
  7.     t->write_to_remote = remote_write;   
  8.     t->sync_token = 1;   
  9.     t->connection_state = state;   
  10.     t->type = kTransportUsb;   
  11.     t->usb = h;   
  12.   
  13. #if ADB_HOST   
  14.     HOST = 1;   
  15. #else   
  16.     HOST = 0;   
  17. #endif     
  18. }            

       可以看到，不管在host端，还是在device端，都会去注册usb的transport。

       接着然后试图连接5555-55585之间的端口，这个时候如果已经有emulator在运行，即调用socket_network_client成功，则注册一个type为kTransportLocal的transport，调用流程：local_init->adb_thread_create出一个client_socket_thread线程，在client_socket_thread中，尝试连接5555-55585的本地端口：client_socket_thread->socket_loopback_client。

       如果socket_loopback_client返回值大于0，说明已连接上emulator，则调用：register_socket_transport->init_socket_transport->register_transport。

       在init_socket_transport中：

C++代码
  1. int init_socket_transport(atransport *t, int s, int port, int local)   
  2. {          
  3.     int  fail = 0;   
  4.   
  5.     t->kick = remote_kick;   
  6.     t->close = remote_close;   
  7.     t->read_from_remote = remote_read;   
  8.     t->write_to_remote = remote_write;   
  9.     t->sfd = s;   
  10.     t->sync_token = 1;   
  11.     t->connection_state = CS_OFFLINE;   
  12.     t->type = kTransportLocal;   
  13.            
  14. #if ADB_HOST   
  15.     if (HOST && local) {   
  16.         adb_mutex_lock( &local_transports_lock );   
  17.         {    
  18.             int  index = (port - ADB_LOCAL_TRANSPORT_PORT)/2;   
  19.        
  20.             if (!(port & 1) || index < 0 || index >= ADB_LOCAL_TRANSPORT_MAX) {   
  21.                 D("bad local transport port number: %d\n", port);   
  22.                 fail = -1;   
  23.             }   
  24.             else if (local_transports[index] != NULL) {   
  25.                 D("local transport for port %d already registered (%p)?\n",   
  26.                 port, local_transports[index]);   
  27.                 fail = -1;   
  28.             }   
  29.             else  
  30.                 local_transports[index] = t;   
  31.         }   
  32.         adb_mutex_unlock( &local_transports_lock );   
  33.     }   
  34. #endif   
  35.     return fail;   
  36. }  

       注意看ADB_HOST里面的东西，如果是在HOST端，则将transport添加到列表里面，因为adb device就是从这个列表里面读信息的。

       再看register_transport，它将transport信息，一个tmsp的结构体，写入transport_registration_send。

C++代码
  1. struct tmsg    
  2. {   
  3.     atransport *transport;   
  4.     int         action;   
  5. };    

       action为0表示移除该transport，1表示添加。

       则接收端的描述符transport_registration_recv会收到对应的信息，它的处理回调函数是transport_registration_func，在transport_registration_func中，首先读取出待注册的transport的地址，在这里创建套接字对，一个是fd，负责从远端读入，或者写入远端。transport_socket负责跟本地(emulator或者device)交互，同时启动两个线程output_thread，调用read_from_remote从远端读入，还有input_thread，调用write_to_remote写入远端。

       以output_thread为例：

C++代码
  1. p = get_apacket();   
  2. p->msg.command = A_SYNC;                                                     
  3. p->msg.arg0 = 1;   
  4. p->msg.arg1 = ++(t->sync_token);   
  5. p->msg.magic = A_SYNC ^ 0xffffffff;                                          
  6. if(write_packet(t->fd, &p)) {                                                
  7.     put_apacket(p);   
  8.     D("from_remote: failed to write SYNC apacket to transport %p", t);       
  9.     goto oops;                                                               
  10. }      

      首先向fd写入一个包含A_SYNC命令的信息包,用于同步，transport_socket的处理回调函数transport_socket_events会执行，继而调用handle_packet处理信息包。

C++代码
  1. case A_SYNC:                                                                 
  2.     if(p->msg.arg0){                                                         
  3.         send_packet(p, t);                                                   
  4.         if(HOST) send_connect(t);                                            
  5.     } else {                                                                 
  6.         t->connection_state = CS_OFFLINE;                                    
  7.         handle_offline(t);                                                   
  8.         send_packet(p, t);                                                   
  9.     }                                                                        
  10.     return;      

       handle_packet判断是A_SYNC同步命令，则同时将信息包发送给远端，并发送一个连接请求给远端，里面包含adb版本，最大载荷等信息。send_package讲信息包写回给transport_socket。

       回过头来output_thread线程回收到这些信息包，并将这些包写入远端。

       写的太深入了，回到adb_main函数，初始化完可能USB和emulator的transport之后，执行下面这段代码：

C++代码
  1. if(install_listener("tcp:5037", "*smartsocket*", NULL)) {   
  2.     exit(1);   
  3. }  

       listener是一个很重要的概念，它绑定到一个本地端口，即local socket，负责与client通信(稍候将看到)，并且创建一个连接到远端的remote socket，smartsocket是一个特殊的socket，它其实类似一个接线员的角色，它分析后看你要连接到哪个remote socket，然后帮你连上。注意这里的第三个参数NULL，因为接线员还来不及分析你的adb命令参数，不知道你要往哪个remote上连，所以这里为NULL，等分析好了，确定要连接那个remote socket，smartsocket的任务也完成了。

C++代码
  1. struct alistener   
  2. {   
  3.     alistener *next;   
  4.     alistener *prev;   
  5.   
  6.     fdevent fde;   
  7.     int fd;   
  8.   
  9.     const char *local_name;   
  10.     const char *connect_to;   
  11.     atransport *transport;   
  12.     adisconnect  disconnect;   
  13. };  

       在install_listener里面：

C++代码
  1. l->fd = local_name_to_fd(local_name);   
  2. close_on_exec(l->fd);   
  3. if(!strcmp(l->connect_to, "*smartsocket*")) {   
  4.     fdevent_install(&l->fde, l->fd, ss_listener_event_func, l);   
  5. }   

       这样，client来消息的时候，就可以调用ss_listener_event_func进行处理了。

       接下来，adb_main执行下面代码：

C++代码
  1. if (is_daemon)   
  2. {   
  3.     // inform our parent that we are up and running.   
  4. f defined(HAVE_FORKEXEC)   
  5.     fprintf(stderr, "OK\n");   
  6. if  
  7.     start_logging();   
  8. }  

       这段代码，告诉父进程adb server已经跑起来了，因此，往stderr里面写一个OK，还记得刚刚server已经将stderr重定向到fd[1]了，所以父进程能接收到这个OK消息。

       接下来，server调用fdevent_loop进入事件循环。

C++代码
  1. for(;;) {   
  2.     fdevent_process();   
  3.   
  4.     while((fde = fdevent_plist_dequeue())) {   
  5.         unsigned events = fde->events;   
  6.         fde->events = 0;   
  7.         fde->state &= (~FDE_PENDING);   
  8.         dump_fde(fde, "callback");   
  9.         fde->func(fde->fd, events, fde->arg);   
  10.     }   
  11. }  

       因此adb是事件驱动型，所有的事件调用fdevent_register进行注册，该函数讲事件保存到全局事件数组fd_table里面。

C++代码
  1. struct fdevent   
  2. {   
  3.     fdevent *next;   
  4.     fdevent *prev;   
  5.   
  6.     int fd;   
  7.     unsigned short state;   
  8.     unsigned short events;   
  9.   
  10.     fd_func func;   
  11.     void *arg;   
  12. };  

       如果有相关事件的到达则调用fun进行处理。

       adb_main，即server已经启动完成，再回到client的adb_commandline函数，我们继续adb device命令的解析。

C++代码
  1. if(!strcmp(argv[0], "devices")) {   
  2.     char *tmp;   
  3.     snprintf(buf, sizeof buf, "host:%s", argv[0]);   
  4.     tmp = adb_query(buf);   
  5.     if(tmp) {   
  6.         printf("List of devices attached \n");   
  7.         printf("%s\n", tmp);   
  8.         return 0;   
  9.     } else {   
  10.         return 1;   
  11.     }   
  12. }  

       它调用adb_query函数，参数是"host:devices“，它表示需要发往server的请求，这些请求分两种query型和command型，分别调用adb_query和adb_command。

C++代码
  1. char *adb_query(const char *service)   
  2. {          
  3.     char buf[5];   
  4.     unsigned n;   
  5.     char *tmp;   
  6.   
  7.     D("adb_query: %s\n", service);    
  8.     int fd = adb_connect(service);   
  9.   
  10.     if(readx(fd, buf, 4)) goto oops;   
  11.   
  12.     if(readx(fd, tmp, n) == 0) {   
  13.   
  14.     }   
  15. }  

       可以看到，它连接到server，返回一个描述符，然后直接从该描述符里面读取结果就可以了。看起来很简单，adb_connect把下面很复杂的东西都包装起来了。

       adb_connect包装了_adb_connect函数，包装了一些adb server是否已经成功启动，查询adb server版本信息的工作，在_adb_connect中

       调用socket_loopback_client(ADB_PORT, SOCK_STREAM);尝试连接ADB_PORT，也就是5037，记住刚才adb server已经调用socket_loopback_server(port, SOCK_STREAM);这样，client和service之间就可以开始通信了。请求信息“host:devices”将写入adb server，来看adb server的处理函数ss_listener_event_func。

       ss_listener_event_func创建一个local socket读取该信息：

C++代码
  1. fd = adb_socket_accept(_fd, &addr, &alen);   
  2. if(fd < 0) return;   
  3.   
  4. adb_socket_setbufsize(fd, CHUNK_SIZE);   
  5.   
  6. s = create_local_socket(fd);   
  7. if(s) {   
  8.     connect_to_smartsocket(s);   
  9.     return;   
  10. }  

       先看create_local_socket，这个socket负责与client通信，回调处理函数是local_socket_event_func。

C++代码
  1. asocket *create_local_socket(int fd)   
  2. {          
  3.     asocket *s = calloc(1, sizeof(asocket));   
  4.     if(s == 0) fatal("cannot allocate socket");   
  5.     install_local_socket(s);   
  6.     s->fd = fd;   
  7.     s->enqueue = local_socket_enqueue;   
  8.     s->ready = local_socket_ready;   
  9.     s->close = local_socket_close;   
  10.            
  11.     fdevent_install(&s->fde, fd, local_socket_event_func, s);   
  12.     return s;   
  13. }  

       也就是由local_socket_event_func来读取“host:devices”串，然后调用s->peer->enqueue(s->peer, p);交给对断处理。

       那local socket的对端是谁，看connect_to_smartsocket：

C++代码
  1. void connect_to_smartsocket(asocket *s)   
  2. {   
  3.     D("Connecting to smart socket \n");   
  4.     asocket *ss = create_smart_socket(smart_socket_action);   
  5.     s->peer = ss;   
  6.     ss->peer = s;   
  7.     s->ready(s);   
  8. }  

       这里明白了local socket的对端就是smart socket(remote socket的一种)，与local socket交互。

C++代码
  1. asocket *create_smart_socket(void (*action_cb)(asocket *s, const char *act))   
  2. {          
  3.     asocket *s = calloc(1, sizeof(asocket));   
  4.     if(s == 0) fatal("cannot allocate socket");   
  5.     s->id = 0;   
  6.     s->enqueue = smart_socket_enqueue;   
  7.     s->ready = smart_socket_ready;   
  8.     s->close = smart_socket_close;   
  9.     s->extra = action_cb;   
  10.   
  11.     return s;    
  12. }     

       这两个socket结对以后，调用local socket的ready回调函数，也就是local_socket_ready。

C++代码
  1. static void local_socket_ready(asocket *s)   
  2. {   
  3.     fdevent_add(&s->fde, FDE_READ);   
  4. }  

       意思是说，我(local socket)已经准备好接收你smart socket发过来的数据了。

       那local socket调用的s->peer->enqueue(s->peer, p);就是smart_socket_enqueue。

       在smart_socket_enqueue中，将刚刚读取到的package插入到package列表中，然后解析service，即发过来的“host:devices”。

C++代码
  1. #if ADB_HOST   
  2.     service = (char *)p->data + 4;   
  3.     if(!strncmp(service, "host-serial:", strlen("host-serial:"))) {   
  4.         char* serial_end;   
  5.         service += strlen("host-serial:");   
  6.   
  7.         // serial number should follow "host:"   
  8.         serial_end = strchr(service, ':');   
  9.         if (serial_end) {   
  10.             *serial_end = 0; // terminate string   
  11.             serial = service;   
  12.             service = serial_end + 1;   
  13.         }   
  14.     } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) {   
  15.         ttype = kTransportUsb;   
  16.         service += strlen("host-usb:");   
  17.     } else if (!strncmp(service, "host-local:", strlen("host-local:"))) {   
  18.         ttype = kTransportLocal;   
  19.         service += strlen("host-local:");   
  20.     } else if (!strncmp(service, "host:", strlen("host:"))) {   
  21.         ttype = kTransportAny;   
  22.         service += strlen("host:");   
  23.     } else {   
  24.         service = NULL;   
  25.     }  

       这里将client发过来的请求，跟去前缀转化为各种transport type，接着解析具体的service名称，接着，调用handle_host_request处理一些可以立即响应的消息，然后直接返回(adb devices请求就是属于这一种),，否则调用create_host_service_socket创建另外一个service socket作为local service的对段，而smart socket就没什么事了，可以关闭了，如下代码。

C++代码
  1. s2 = create_host_service_socket(service, serial);   
  2. if(s2 == 0) {   
  3.     D( "SS(%d): couldn't create host service '%s'\n", s->id, service );   
  4.     sendfailmsg(s->peer->fd, "unknown host service");   
  5.     goto fail;   
  6. }   
  7.   
  8. adb_write(s->peer->fd, "OKAY", 4);   
  9.   
  10. s->peer->ready = local_socket_ready;   
  11. s->peer->close = local_socket_close;   
  12. s->peer->peer = s2;   
  13. s2->peer = s->peer;   
  14. s->peer = 0;   
  15. D( "SS(%d): okay\n", s->id );   
  16. s->close(s);  

       先来看可以用handle_host_request的部分，处理devices部分请求的代码如下：

C++代码
  1. // return a list of all connected devices   
  2. if (!strcmp(service, "devices")) {   
  3.     char buffer[4096];   
  4.     memset(buf, 0, sizeof(buf));   
  5.     memset(buffer, 0, sizeof(buffer));   
  6.     D("Getting device list \n");   
  7.     list_transports(buffer, sizeof(buffer));   
  8.     snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer),buffer);   
  9.     D("Wrote device list \n");   
  10.     writex(reply_fd, buf, strlen(buf));   
  11.     return 0;   
  12. }  

       它讲transport列表里面的信息读取出来，然后写入reply_fd里面，其实这里猜也猜到了，它就是local socket的fd，也就是将信息写入port5037里面，这样我们的client端就能将当前连接的设备信息打印到屏幕上了。

 

       整个过程的如下图：

Android开发工具ADB教程之二：HOST端

本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/environment/215.html
2012年9月23日
发布:鸡啄米 分类:Android开发环境 浏览: 评论:0