android adb源码分析

Posted 专注it

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了android adb源码分析相关的知识，希望对你有一定的参考价值。

ADB是android debug bridge的缩写，它使用PC机可以通过USB或网络与android设备通讯。

adb的源码位于system/core/adb目录下，先来看下编译脚本Android.mk：

[plain] view plain copy
  1. # Copyright 2005 The Android Open Source Project  
  2. #  
  3. # Android.mk for adb  
  4. #  
  5.   
  6. LOCAL_PATH:= $(call my-dir)  
  7.   
  8. # adb host tool  
  9. # =========================================================  
  10. include $(CLEAR_VARS)  
  11.   
  12. # Default to a virtual (sockets) usb interface  
  13. USB_SRCS :=  
  14. EXTRA_SRCS :=  
  15.   
  16. ifeq ($(HOST_OS),linux)  
  17.   USB_SRCS := usb_linux.c  
  18.   EXTRA_SRCS := get_my_path_linux.c  
  19.   LOCAL_LDLIBS += -lrt -ldl -lpthread  
  20.   LOCAL_CFLAGS += -DWORKAROUND_BUG6558362  
  21. endif  
  22.   
  23. ifeq ($(HOST_OS),darwin)  
  24.   USB_SRCS := usb_osx.c  
  25.   EXTRA_SRCS := get_my_path_darwin.c  
  26.   LOCAL_LDLIBS += -lpthread -framework CoreFoundation -framework IOKit -framework Carbon  
  27. endif  
  28.   
  29. ifeq ($(HOST_OS),freebsd)  
  30.   USB_SRCS := usb_libusb.c  
  31.   EXTRA_SRCS := get_my_path_freebsd.c  
  32.   LOCAL_LDLIBS += -lpthread -lusb  
  33. endif  
  34.   
  35. ifeq ($(HOST_OS),windows)  
  36.   USB_SRCS := usb_windows.c  
  37.   EXTRA_SRCS := get_my_path_windows.c ../libcutils/list.c  
  38.   EXTRA_STATIC_LIBS := AdbWinApi  
  39.   ifneq ($(strip $(USE_CYGWIN)),)  
  40.     # Pure cygwin case  
  41.     LOCAL_LDLIBS += -lpthread -lgdi32  
  42.     LOCAL_C_INCLUDES += /usr/include/w32api/ddk  
  43.   endif  
  44.   ifneq ($(strip $(USE_MINGW)),)  
  45.     # MinGW under Linux case  
  46.     LOCAL_LDLIBS += -lws2_32 -lgdi32  
  47.     USE_SYSDEPS_WIN32 := 1  
  48.     LOCAL_C_INCLUDES += /usr/i586-mingw32msvc/include/ddk  
  49.   endif  
  50.   LOCAL_C_INCLUDES += development/host/windows/usb/api/  
  51. endif  
  52.   
  53. LOCAL_SRC_FILES := \  
  54.     adb.c \  
  55.     console.c \  
  56.     transport.c \  
  57.     transport_local.c \  
  58.     transport_usb.c \  
  59.     commandline.c \  
  60.     adb_client.c \  
  61.     adb_auth_host.c \  
  62.     sockets.c \  
  63.     services.c \  
  64.     file_sync_client.c \  
  65.     $(EXTRA_SRCS) \  
  66.     $(USB_SRCS) \  
  67.     usb_vendors.c  
  68.   
  69. LOCAL_C_INCLUDES += external/openssl/include  
  70.   
  71. ifneq ($(USE_SYSDEPS_WIN32),)  
  72.   LOCAL_SRC_FILES += sysdeps_win32.c  
  73. else  
  74.   LOCAL_SRC_FILES += fdevent.c  
  75. endif  
  76.   
  77. LOCAL_CFLAGS += -O2 -g -DADB_HOST=1  -Wall -Wno-unused-parameter  
  78. LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE  
  79. LOCAL_MODULE := adb  
  80. LOCAL_MODULE_TAGS := debug  
  81.   
  82. LOCAL_STATIC_LIBRARIES := libzipfile libunz libcrypto_static $(EXTRA_STATIC_LIBS)  
  83. ifeq ($(USE_SYSDEPS_WIN32),)  
  84.     LOCAL_STATIC_LIBRARIES += libcutils  
  85. endif  
  86.   
  87. include $(BUILD_HOST_EXECUTABLE)  
  88.   
  89. $(call dist-for-goals,dist_files sdk,$(LOCAL_BUILT_MODULE))  
  90.   
  91. ifeq ($(HOST_OS),windows)  
  92. $(LOCAL_INSTALLED_MODULE): \  
  93.     $(HOST_OUT_EXECUTABLES)/AdbWinApi.dll \  
  94.     $(HOST_OUT_EXECUTABLES)/AdbWinUsbApi.dll  
  95. endif  
  96.   
  97.   
  98. # adbd device daemon  
  99. # =========================================================  
  100.   
  101. include $(CLEAR_VARS)  
  102.   
  103. LOCAL_SRC_FILES := \  
  104.     adb.c \  
  105.     backup_service.c \  
  106.     fdevent.c \  
  107.     transport.c \  
  108.     transport_local.c \  
  109.     transport_usb.c \  
  110.     adb_auth_client.c \  
  111.     sockets.c \  
  112.     services.c \  
  113.     file_sync_service.c \  
  114.     jdwp_service.c \  
  115.     framebuffer_service.c \  
  116.     remount_service.c \  
  117.     usb_linux_client.c \  
  118.     log_service.c  
  119.   
  120. LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter  
  121. LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE  
  122.   
  123. ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT)))  
  124. LOCAL_CFLAGS += -DALLOW_ADBD_ROOT=1  
  125. endif  
  126.   
  127. LOCAL_MODULE := adbd  
  128.   
  129. LOCAL_FORCE_STATIC_EXECUTABLE := true  
  130. LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT_SBIN)  
  131. LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_SBIN_UNSTRIPPED)  
  132.   
  133. LOCAL_STATIC_LIBRARIES := liblog libcutils libc libmincrypt  
  134. include $(BUILD_EXECUTABLE)  
  135.   
  136.   
  137. # adb host tool for device-as-host  
  138. # =========================================================  
  139. ifneq ($(SDK_ONLY),true)  
  140. include $(CLEAR_VARS)  
  141.   
  142. LOCAL_LDLIBS := -lrt -ldl -lpthread  
  143.   
  144. LOCAL_SRC_FILES := \  
  145.     adb.c \  
  146.     console.c \  
  147.     transport.c \  
  148.     transport_local.c \  
  149.     transport_usb.c \  
  150.     commandline.c \  
  151.     adb_client.c \  
  152.     adb_auth_host.c \  
  153.     sockets.c \  
  154.     services.c \  
  155.     file_sync_client.c \  
  156.     get_my_path_linux.c \  
  157.     usb_linux.c \  
  158.     usb_vendors.c \  
  159.     fdevent.c  
  160.   
  161. LOCAL_CFLAGS := \  
  162.     -O2 \  
  163.     -g \  
  164.     -DADB_HOST=1 \  
  165.     -DADB_HOST_ON_TARGET=1 \  
  166.     -Wall \  
  167.     -Wno-unused-parameter \  
  168.     -D_XOPEN_SOURCE \  
  169.     -D_GNU_SOURCE  
  170.   
  171. LOCAL_C_INCLUDES += external/openssl/include  
  172.   
  173. LOCAL_MODULE := adb  
  174.   
  175. LOCAL_STATIC_LIBRARIES := libzipfile libunz libcutils  
  176.   
  177. LOCAL_SHARED_LIBRARIES := libcrypto  
  178.   
  179. include $(BUILD_EXECUTABLE)  
  180. endif  


可以看到，最终会有3个执行文件被生成，adbd和两个adb程序。adbd是手机终的守护进程；adb一个是windows、linux、darwin或freebsd运行的程序，另一个是目标机上运行的程序。

    宏ADB_HOST用于区分是PC端程序还是目标机端的程序。宏ADB_HOST_ON_TARGET用于区分adb程序是否是在目标机上运行。这3个程序使用的是同一份源码，在内部，使用这些宏来区别不同的程序。

    程序的入口在adb.c的main()函数：

[cpp] view plain copy
  1. int main(int argc, char **argv)  
  2. {  
  3. #if ADB_HOST  
  4.     adb_sysdeps_init();  
  5.     adb_trace_init();  
  6.     D("Handling commandline()\n");  
  7.     return adb_commandline(argc - 1, argv + 1);  
  8. #else  
  9.     /* If adbd runs inside the emulator this will enable adb tracing via 
  10.      * adb-debug qemud service in the emulator. */  
  11.     adb_qemu_trace_init();  
  12.     if((argc > 1) && (!strcmp(argv[1],"recovery"))) {  
  13.         adb_device_banner = "recovery";  
  14.         recovery_mode = 1;  
  15.     }  
  16.   
  17.     start_device_log();  
  18.     D("Handling main()\n");  
  19.     return adb_main(0, DEFAULT_ADB_PORT);  
  20. #endif  
  21. }  


先来看adbd程序，此时宏的设置是ADB_HOST=0。上面代码中start_device_log()是log的初始化操作，可以重定向输出的log信息，接着进入adb_main()函数。先来看下它的参数DEFAULT_ADB_PORT：

[cpp] view plain copy
  1. #if ADB_HOST_ON_TARGET  
  2. /* adb and adbd are coexisting on the target, so use 5038 for adb 
  3.  * to avoid conflicting with adbd‘s usage of 5037 
  4.  */  
  5. #  define DEFAULT_ADB_PORT 5038  
  6. #else  
  7. #  define DEFAULT_ADB_PORT 5037  
  8. #endif  

如果是目标机程序，它的值是5038，否则它的值是5037。这里没有定义ADB_HOST_ON_TARGET， 所以它是5037。

adb_main()的源代码如下：

[cpp] view plain copy
  1. int adb_main(int is_daemon, int server_port)  
  2. {  
  3. #if !ADB_HOST  
  4.     int port;  
  5.     char value[PROPERTY_VALUE_MAX];  
  6.   
  7.     umask(000);  
  8. #endif  
  9.   
  10.     atexit(adb_cleanup);  
  11. #ifdef HAVE_WIN32_PROC  
  12.     SetConsoleCtrlHandler( ctrlc_handler, TRUE );  
  13. #elif defined(HAVE_FORKEXEC)  
  14.     // No SIGCHLD. Let the service subproc handle its children.  
  15.     signal(SIGPIPE, SIG_IGN);  
  16. #endif  
  17.   
  18.     init_transport_registration();  
  19.   
  20. #if ADB_HOST  
  21.     HOST = 1;  
  22.     usb_vendors_init();  
  23.     usb_init();  
  24.     local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);  
  25.     adb_auth_init();  
  26.   
  27.     char local_name[30];  
  28.     build_local_name(local_name, sizeof(local_name), server_port);  
  29.     if(install_listener(local_name, "*smartsocket*", NULL)) {  
  30.         exit(1);  
  31.     }  
  32. #else  
  33.     property_get("ro.adb.secure", value, "0");  
  34.     auth_enabled = !strcmp(value, "1");  
  35.     if (auth_enabled)  
  36.         adb_auth_init();  
  37.   
  38.     // Our external storage path may be different than apps, since  
  39.     // we aren‘t able to bind mount after dropping root.  
  40.     const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");  
  41.     if (NULL != adb_external_storage) {  
  42.         setenv("EXTERNAL_STORAGE", adb_external_storage, 1);  
  43.     } else {  
  44.         D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"  
  45.           " unchanged.\n");  
  46.     }  
  47.   
  48.     /* don‘t listen on a port (default 5037) if running in secure mode */  
  49.     /* don‘t run as root if we are running in secure mode */  
  50.     if (should_drop_privileges()) {  
  51.         struct __user_cap_header_struct header;  
  52.         struct __user_cap_data_struct cap;  
  53.   
  54.         if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) {  
  55.             exit(1);  
  56.         }  
  57.   
  58.         /* add extra groups: 
  59.         ** AID_ADB to access the USB driver 
  60.         ** AID_LOG to read system logs (adb logcat) 
  61.         ** AID_INPUT to diagnose input issues (getevent) 
  62.         ** AID_INET to diagnose network issues (netcfg, ping) 
  63.         ** AID_GRAPHICS to access the frame buffer 
  64.         ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump) 
  65.         ** AID_SDCARD_R to allow reading from the SD card 
  66.         ** AID_SDCARD_RW to allow writing to the SD card 
  67.         ** AID_MOUNT to allow unmounting the SD card before rebooting 
  68.         ** AID_NET_BW_STATS to read out qtaguid statistics 
  69.         */  
  70.         gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,  
  71.                            AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,  
  72.                            AID_MOUNT, AID_NET_BW_STATS };  
  73.         if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {  
  74.             exit(1);  
  75.         }  
  76.   
  77.         /* then switch user and group to "shell" */  
  78.         if (setgid(AID_SHELL) != 0) {  
  79.             exit(1);  
  80.         }  
  81.         if (setuid(AID_SHELL) != 0) {  
  82.             exit(1);  
  83.         }  
  84.   
  85.         /* set CAP_SYS_BOOT capability, so "adb reboot" will succeed */  
  86.         header.version = _LINUX_CAPABILITY_VERSION;  
  87.         header.pid = 0;  
  88.         cap.effective = cap.permitted = (1 << CAP_SYS_BOOT);  
  89.         cap.inheritable = 0;  
  90.         capset(&header, &cap);  
  91.   
  92.         D("Local port disabled\n");  
  93.     } else {  
  94.         char local_name[30];  
  95.         build_local_name(local_name, sizeof(local_name), server_port);  
  96.         if(install_listener(local_name, "*smartsocket*", NULL)) {  
  97.             exit(1);  
  98.         }  
  99.     }  
  100.   
  101.     int usb = 0;  
  102.     if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {  
  103.         // listen on USB  
  104.         usb_init();  
  105.         usb = 1;  
  106.     }  
  107.   
  108.     // If one of these properties is set, also listen on that port  
  109.     // If one of the properties isn‘t set and we couldn‘t listen on usb,  
  110.     // listen on the default port.  
  111.     property_get("service.adb.tcp.port", value, "");  
  112.     if (!value[0]) {  
  113.         property_get("persist.adb.tcp.port", value, "");  
  114.     }  
  115.     if (sscanf(value, "%d", &port) == 1 && port > 0) {  
  116.         printf("using port=%d\n", port);  
  117.         // listen on TCP port specified by service.adb.tcp.port property  
  118.         local_init(port);  
  119.     } else if (!usb) {  
  120.         // listen on default port  
  121.         local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);  
  122.     }  
  123.   
  124.     D("adb_main(): pre init_jdwp()\n");  
  125.     init_jdwp();  
  126.     D("adb_main(): post init_jdwp()\n");  
  127. #endif  
  128.   
  129.     if (is_daemon)  
  130.     {  
  131.         // inform our parent that we are up and running.  
  132. #ifdef HAVE_WIN32_PROC  
  133.         DWORD  count;  
  134.         WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL );  
  135. #elif defined(HAVE_FORKEXEC)  
  136.         fprintf(stderr, "OK\n");  
  137. #endif  
  138.         start_logging();  
  139.     }  
  140.     D("Event loop starting\n");  
  141.   
  142.     fdevent_loop();  
  143.   
  144.     usb_cleanup();  
  145.   
  146.     return 0;  
  147. }  


(1) init_transport_registration()初始化fevent transport_registration_fde；

(2) 判断系统属性ro.adb.secure，目标板没有设置这个宏；

(3) 没有定义环境变量adb_external_storage；

(4) should_drop_privileges()根据android编译环境should_drop_privileges返回不同的值，如果它的值是userdebug或eng，宏ALLOW_ADBD_ROOT的值被定义为1，执行install_listener()，否则不会定义，这种情况下，由于adbd运行在root下，为保证它的安全性，它需要降级运行；

(5) 判断是否存在设备文件USB_ADB_PATH或USB_FFS_ADB_EP0，存在则执行usb_init()；

(6) 读取属性service.adb.tcp.port或persist.adb.tcp.port（目标板均未定义），执行local_init()，它内部会创建adb thread；

(7) 执行init_jdwp()，jdwp是java调试体系中的一种，具体可百度；

(8) 调用fdevent_loop()监听fdevent并处理；

(9) 程序结束。

 

再来看adb程序的执行：

在main()中调用return adb_commandline(argc - 1, argv + 1)：

[cpp] view plain copy
  1. int adb_commandline(int argc, char **argv)  
  2. {  
  3.     char buf[4096];  
  4.     int no_daemon = 0;  
  5.     int is_daemon = 0;  
  6.     int is_server = 0;  
  7.     int persist = 0;  
  8.     int r;  
  9.     int quote;  
  10.     transport_type ttype = kTransportAny;  
  11.     char* serial = NULL;  
  12.     char* server_port_str = NULL;  
  13.   
  14.         /* If defined, this should be an absolute path to 
  15.          * the directory containing all of the various system images 
  16.          * for a particular product.  If not defined, and the adb 
  17.          * command requires this information, then the user must 
  18.          * specify the path using "-p". 
  19.          */  
  20.     gProductOutPath = getenv("ANDROID_PRODUCT_OUT");  
  21.     if (gProductOutPath == NULL || gProductOutPath[0] == ‘\0‘) {  
  22.         gProductOutPath = NULL;  
  23.     }  
  24.     // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint  
  25.   
  26.     serial = getenv("ANDROID_SERIAL");  
  27.   
  28.     /* Validate and assign the server port */  
  29.     server_port_str = getenv("ANDROID_ADB_SERVER_PORT");  
  30.     int server_port = DEFAULT_ADB_PORT;  
  31.     if (server_port_str && strlen(server_port_str) > 0) {  
  32.         server_port = (int) strtol(server_port_str, NULL, 0);  
  33.         if (server_port <= 0) {  
  34.             fprintf(stderr,  
  35.                     "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number. Got \"%s\"\n",  
  36.                     server_port_str);  
  37.             return usage();  
  38.         }  
  39.     }  
  40.   
  41.     /* modifiers and flags */  
  42.     while(argc > 0) {  
  43.         if(!strcmp(argv[0],"server")) {  
  44.             is_server = 1;  
  45.         } else if(!strcmp(argv[0],"nodaemon")) {  
  46.             no_daemon = 1;  
  47.         } else if (!strcmp(argv[0], "fork-server")) {  
  48.             /* this is a special flag used only when the ADB client launches the ADB Server */  
  49.             is_daemon = 1;  
  50.         } else if(!strcmp(argv[0],"persist")) {  
  51.             persist = 1;  
  52.         } else if(!strncmp(argv[0], "-p", 2)) {  
  53.             const char *product = NULL;  
  54.             if (argv[0][2] == ‘\0‘) {  
  55.                 if (argc < 2) return usage();  
  56.                 product = argv[1];  
  57.                 argc--;  
  58.                 argv++;  
  59.             } else {  
  60.                 product = argv[0] + 2;  
  61.             }  
  62.             gProductOutPath = find_product_out_path(product);  
  63.             if (gProductOutPath == NULL) {  
  64.                 fprintf(stderr, "adb: could not resolve \"-p %s\"\n",  
  65.                         product);  
  66.                 return usage();  
  67.             }  
  68.         } else if (argv[0][0]==‘-‘ && argv[0][1]==‘s‘) {  
  69.             if (isdigit(argv[0][2])) {  
  70.                 serial = argv[0] + 2;  
  71.             } else {  
  72.                 if(argc < 2 || argv[0][2] != ‘\0‘) return usage();  
  73.                 serial = argv[1];  
  74.                 argc--;  
  75.                 argv++;  
  76.             }  
  77.         } else if (!strcmp(argv[0],"-d")) {  
  78.             ttype = kTransportUsb;  
  79.         } else if (!strcmp(argv[0],"-e")) {  
  80.             ttype = kTransportLocal;  
  81.         } else {  
  82.                 /* out of recognized modifiers and flags */  
  83.             break;  
  84.         }  
  85.         argc--;  
  86.         argv++;  
  87.     }  
  88.   
  89.     adb_set_transport(ttype, serial);  
  90.     adb_set_tcp_specifics(server_port);  
  91.   
  92.     if (is_server) {  
  93.         if (no_daemon || is_daemon) {  
  94.             r = adb_main(is_daemon, server_port);  
  95.         } else {  
  96.             r = launch_server(server_port);  
  97.         }  
  98.         if(r) {  
  99.             fprintf(stderr,"* could not start server *\n");  
  100.         }  
  101.         return r;  
  102.     }  
  103.   
  104. top:  
  105.     if(argc == 0) {  
  106.         return usage();  
  107.     }  
  108.   
  109.     /* adb_connect() commands */  
  110.   
  111.     if(!strcmp(argv[0], "devices")) {  
  112.         char *tmp;  
  113.         char *listopt;  
  114.         if (argc < 2)  
  115.             listopt = "";  
  116.         else if (argc == 2 && !strcmp(argv[1], "-l"))  
  117.             listopt = argv[1];  
  118.         else {  
  119.             fprintf(stderr, "Usage: adb devices [-l]\n");  
  120.             return 1;  
  121.         }  
  122.         snprintf(buf, sizeof buf, "host:%s%s", argv[0], listopt);  
  123.         tmp = adb_query(buf);  
  124.         if(tmp) {  
  125.             printf("List of devices attached \n");  
  126.             printf("%s\n", tmp);  
  127.             return 0;  
  128.         } else {  
  129.             return 1;  
  130.         }  
  131.     }  
  132.   
  133.     if(!strcmp(argv[0], "connect")) {  
  134.         char *tmp;  
  135.         if (argc != 2) {  
  136.             fprintf(stderr, "Usage: adb connect <host>[:<port>]\n");  
  137.             return 1;  
  138.         }  
  139.         snprintf(buf, sizeof buf, "host:connect:%s", argv[1]);  
  140.         tmp = adb_query(buf);  
  141.         if(tmp) {  
  142.             printf("%s\n", tmp);  
  143.             return 0;  
  144.         } else {  
  145.             return 1;  
  146.         }  
  147.     }  
  148.   
  149.     if(!strcmp(argv[0], "disconnect")) {  
  150.         char *tmp;  
  151.         if (argc > 2) {  
  152.             fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n");  
  153.             return 1;  
  154.         }  
  155.         if (argc == 2) {  
  156.             snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]);  
  157.         } else {  
  158.             snprintf(buf, sizeof buf, "host:disconnect:");  
  159.         }  
  160.         tmp = adb_query(buf);  
  161.         if(tmp) {  
  162.             printf("%s\n", tmp);  
  163.             return 0;  
  164.         } else {  
  165.             return 1;  
  166.         }  
  167.     }  
  168.   
  169.     if (!strcmp(argv[0], "emu")) {  
  170.         return adb_send_emulator_command(argc, argv);  
  171.     }  
  172.   
  173.     if(!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) {  
  174.         int r;  
  175.         int fd;  
  176.   
  177.         char h = (argv[0][0] == ‘h‘);  
  178.   
  179.         if (h) {  
  180.             printf("\x1b[41;33m");  
  181.             fflush(stdout);  
  182.         }  
  183.   
  184.         if(argc < 2) {  
  185.             D("starting interactive shell\n");  
  186.             r = interactive_shell();  
  187.             if (h) {  
  188.                 printf("\x1b[0m");  
  189.                 fflush(stdout);  
  190.             }  
  191.             return r;  
  192.         }  
  193.   
  194.         snprintf(buf, sizeof buf, "shell:%s", argv[1]);  
  195.         argc -= 2;  
  196.         argv += 2;  
  197.         while(argc-- > 0) {  
  198.             strcat(buf, " ");  
  199.   
  200.             /* quote empty strings and strings with spaces */  
  201.             quote = (**argv == 0 || strchr(*argv, ‘ ‘));  
  202.             if (quote)  
  203.                 strcat(buf, "\"");  
  204.             strcat(buf, *argv++);  
  205.             if (quote)  
  206.                 strcat(buf, "\"");  
  207.         }  
  208.   
  209.         for(;;) {  
  210.             D("interactive shell loop. buff=%s\n", buf);  
  211.             fd = adb_connect(buf);  
  212.             if(fd >= 0) {  
  213.                 D("about to read_and_dump(fd=%d)\n", fd);  
  214.                 read_and_dump(fd);  
  215.                 D("read_and_dump() done.\n");  
  216.                 adb_close(fd);  
  217.                 r = 0;  
  218.             } else {  
  219.                 fprintf(stderr,"error: %s\n", adb_error());  
  220.                 r = -1;  
  221.             }  
  222.   
  223.             if(persist) {  
  224.                 fprintf(stderr,"\n- waiting for device -\n");  
  225.                 adb_sleep_ms(1000);  
  226.                 do_cmd(ttype, serial, "wait-for-device", 0);  
  227.             } else {  
  228.                 if (h) {  
  229.                     printf("\x1b[0m");  
  230.                     fflush(stdout);  
  231.                 }  
  232.                 D("interactive shell loop. return r=%d\n", r);  
  233.                 return r;  
  234.             }  
  235.         }  
  236.     }  
  237.   
  238.     if(!strcmp(argv[0], "kill-server")) {  
  239.         int fd;  
  240.         fd = _adb_connect("host:kill");  
  241.         if(fd == -1) {  
  242.             fprintf(stderr,"* server not running *\n");  
  243.             return 1;  
  244.         }  
  245.         return 0;  
  246.     }  
  247.   
  248.     if(!strcmp(argv[0], "sideload")) {  
  249.         if(argc != 2) return usage();  
  250.         if(adb_download("sideload", argv[1], 1)) {  
  251.             return 1;  
  252.         } else {  
  253.             return 0;  
  254.         }  
  255.     }  
  256.   
  257.     if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot")  
  258.             || !strcmp(argv[0], "reboot-bootloader")  
  259.             || !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb")  
  260.             || !strcmp(argv[0], "root")) {  
  261.         char command[100];  
  262.         if (!strcmp(argv[0], "reboot-bootloader"))  
  263.             snprintf(command, sizeof(command), "reboot:bootloader");  
  264.         else if (argc > 1)  
  265.             snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]);  
  266.         else  
  267.             snprintf(command, sizeof(command), "%s:", argv[0]);  
  268.         int fd = adb_connect(command);  
  269.         if(fd >= 0) {  
  270.             read_and_dump(fd);  
  271.             adb_close(fd);  
  272.             return 0;  
  273.         }  
  274.         fprintf(stderr,"error: %s\n", adb_error());  
  275.         return 1;  
  276.     }  
  277.   
  278.     if(!strcmp(argv[0], "bugreport")) {  
  279.         if (argc != 1) return usage();  
  280.         do_cmd(ttype, serial, "shell", "bugreport", 0);  
  281.         return 0;  
  282.     }  
  283.   
  284.     /* adb_command() wrapper commands */  
  285.   
  286.     if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) {  
  287.         char* service = argv[0];  
  288.         if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) {  
  289.             if (ttype == kTransportUsb) {  
  290.                 service = "wait-for-usb";  
  291.             } else if (ttype == kTransportLocal) {  
  292.                 service = "wait-for-local";  
  293.             } else {  
  294.                 service = "wait-for-any";  
  295.             }  
  296.         }  
  297.   
  298.         format_host_command(buf, sizeof buf, service, ttype, serial);  
  299.   
  300.         if (adb_command(buf)) {  
  301.             D("failure: %s *\n",adb_error());  
  302.             fprintf(stderr,"error: %s\n", adb_error());  
  303.             return 1;  
  304.         }  
  305.   
  306.         /* Allow a command to be run after wait-for-device, 
  307.             * e.g. ‘adb wait-for-device shell‘. 
  308.             */  
  309.         if(argc > 1) {  
  310.             argc--;  
  311.             argv++;  
  312.             goto top;  
  313.         }  
  314.         return 0;  
  315.     }  
  316.   
  317.     if(!strcmp(argv[0], "forward")) {  
  318.         if(argc != 3) return usage();  
  319.         if (serial) {  
  320.             snprintf(buf, sizeof buf, "host-serial:%s:forward:%s;%s",serial, argv[1], argv[2]);  
  321.         } else if (ttype == kTransportUsb) {  
  322.             snprintf(buf, sizeof buf, "host-usb:forward:%s;%s", argv[1], argv[2]);  
  323.         } else if (ttype == kTransportLocal) {  
  324.             snprintf(buf, sizeof buf, "host-local:forward:%s;%s", argv[1], argv[2]);  
  325.         } else {  
  326.             snprintf(buf, sizeof buf, "host:forward:%s;%s", argv[1], argv[2]);  
  327.         }  
  328.         if(adb_command(buf)) {  
  329.             fprintf(stderr,"error: %s\n", adb_error());  
  330.             return 1;  
  331.         }  
  332.         return 0;  
  333.     }  
  334.   
  335.     /* do_sync_*() commands */  
  336.   
  337.     if(!strcmp(argv[0], "ls")) {  
  338.         if(argc != 2) return usage();  
  339.         return do_sync_ls(argv[1]);  
  340.     }  
  341.   
  342.     if(!strcmp(argv[0], "push")) {  
  343.         if(argc != 3) return usage();  
  344.         return do_sync_push(argv[1], argv[2], 0 /* no verify APK */);  
  345.     }  
  346.   
  347.     if(!strcmp(argv[0], "pull")) {  
  348.         if (argc == 2) {  
  349.             return do_sync_pull(argv[1], ".");  
  350.         } else if (argc == 3) {  
  351.             return do_sync_pull(argv[1], argv[2]);  
  352.         } else {  
  353.             return usage();  
  354.         }  
  355.     }  
  356.   
  357.     if(!strcmp(argv[0], "install")) {  
  358.         if (argc < 2) return usage();  
  359.         return install_app(ttype, serial, argc, argv);  
  360.     }  
  361.   
  362.     if(!strcmp(argv[0], "uninstall")) {  
  363.         if (argc < 2) return usage();  
  364.         return uninstall_app(ttype, serial, argc, argv);  
  365.     }  
  366.   
  367.     if(!strcmp(argv[0], "sync")) {  
  368.         char *srcarg, *android_srcpath, *data_srcpath;  
  369.         int listonly = 0;  
  370.   
  371.         int ret;  
  372.         if(argc < 2) {  
  373.             /* No local path was specified. */  
  374.             srcarg = NULL;  
  375.         } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {  
  376.             listonly = 1;  
  377.             if (argc == 3) {  
  378.                 srcarg = argv[2];  
  379.             } else {  
  380.                 srcarg = NULL;  
  381.             }  
  382.         } else if(argc == 2) {  
  383.             /* A local path or "android"/"data" arg was specified. */  
  384.             srcarg = argv[1];  
  385.         } else {  
  386.             return usage();  
  387.         }  
  388.         ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath);  
  389.         if(ret != 0) return usage();  
  390.   
  391.         if(android_srcpath != NULL)  
  392.             ret = do_sync_sync(android_srcpath, "/system", listonly);  
  393.         if(ret == 0 && data_srcpath != NULL)  
  394.             ret = do_sync_sync(data_srcpath, "/data", listonly);  
  395.   
  396.         free(android_srcpath);  
  397.         free(data_srcpath);  
  398.         return ret;  
  399.     }  
  400.   
  401.     /* passthrough commands */  
  402.   
  403.     if(!strcmp(argv[0],"get-state") ||  
  404.         !strcmp(argv[0],"get-serialno") ||  
  405.         !strcmp(argv[0],"get-devpath"))  
  406.     {  
  407.         char *tmp;  
  408.   
  409.         format_host_command(buf, sizeof buf, argv[0], ttype, serial);  
  410.         tmp = adb_query(buf);  
  411.         if(tmp) {  
  412.             printf("%s\n", tmp);  
  413.             return 0;  
  414.         } else {  
  415.             return 1;  
  416.         }  
  417.     }  
  418.   
  419.     /* other commands */  
  420.   
  421.     if(!strcmp(argv[0],"status-window")) {  
  422.         status_window(ttype, serial);  
  423.         return 0;  
  424.     }  
  425.   
  426.     if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) {  
  427.         return logcat(ttype, serial, argc, argv);  
  428.     }  
  429.   
  430.     if(!strcmp(argv[0],"ppp")) {  
  431.         return ppp(argc, argv);  
  432.     }  
  433.   
  434.     if (!strcmp(argv[0], "start-server")) {  
  435.         return adb_connect("host:start-server");  
  436.     }  
  437.   
  438.     if (!strcmp(argv[0], "backup")) {  
  439.         return backup(argc, argv);  
  440.     }  
  441.   
  442.     if (!strcmp(argv[0], "restore")) {  
  443.         return restore(argc, argv);  
  444.     }  
  445.   
  446.     if (!strcmp(argv[0], "jdwp")) {  
  447.         int  fd = adb_connect("jdwp");  
  448.         if (fd >= 0) {  
  449.             read_and_dump(fd);  
  450.             adb_close(fd);  
  451.             return 0;  
  452.         } else {  
  453.             fprintf(stderr, "error: %s\n", adb_error());  
  454.             return -1;  
  455.         }  
  456.     }  
  457.   
  458.     /* "adb /?" is a common idiom under Windows */  
  459.     if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {  
  460.         help();  
  461.         return 0;  
  462.     }  
  463.   
  464.     if(!strcmp(argv[0], "version")) {  
  465.         version(stdout);  
  466.         return 0;  
  467.     }  
  468.   
  469.     usage();  
  470.     return 1;  
  471. }  


它的代码有点长，但可以很容易看明白它根据命令的参数执行不同的功能。adb程序可能以服务的方式或命令行客户端的方式运行。

－－－－－－－－－－

以上就是main()函数的执行过程，后续将分析其中的细节内容。





以上是关于android adb源码分析的主要内容，如果未能解决你的问题，请参考以下文章

安卓车机系统adb shell cmd 源码原理分析

安卓车机系统adb shell cmd 源码原理分析

Android 音频源码分析——AudioFlinger

Android 音频源码分析——AudioFlinger

Android 音频源码分析——AudioTrack设备选择

Android 音频源码分析——AudioTrack设备选择