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

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

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

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

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

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

  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. start_device_log();
  17. D("Handling main()\n");
  18. return adb_main(0, DEFAULT_ADB_PORT);
  19. #endif
  20. }

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

  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()的源代码如下:

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

(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):

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

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

----------

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

android adb源码分析(1)的更多相关文章

  1. android adb源码分析(5)【转】

    本文转载自:http://blog.csdn.net/xgbing/article/details/52096880 本篇以“adb devices"命令为例,跟踪代码的执行流程. (1) ...

  2. Appium Android Bootstrap源码分析之启动运行

    通过前面的两篇文章<Appium Android Bootstrap源码分析之控件AndroidElement>和<Appium Android Bootstrap源码分析之命令解析 ...

  3. ADB 源码分析(一) ——ADB模块简述【转】

    ADB源码分析(一)——ADB模块简述 1.Adb 源码路径(system/core/adb). 2.要想很快的了解一个模块的基本情况,最直接的就是查看该模块的Android.mk文件,下面就来看看a ...

  4. Appium Android Bootstrap源码分析之命令解析执行

    通过上一篇文章<Appium Android Bootstrap源码分析之控件AndroidElement>我们知道了Appium从pc端发送过来的命令如果是控件相关的话,最终目标控件在b ...

  5. Appium Android Bootstrap源码分析之控件AndroidElement

    通过上一篇文章<Appium Android Bootstrap源码分析之简介>我们对bootstrap的定义以及其在appium和uiautomator处于一个什么样的位置有了一个初步的 ...

  6. Android HandlerThread 源码分析

    HandlerThread 简介: 我们知道Thread线程是一次性消费品,当Thread线程执行完一个耗时的任务之后,线程就会被自动销毁了.如果此时我又有一 个耗时任务需要执行,我们不得不重新创建线 ...

  7. Android Choreographer 源码分析

    Choreographer 的作用主要是配合 Vsync ,给上层 App 的渲染提供一个稳定的 Message 处理的时机,也就是 Vsync 到来的时候 ,系统通过对 Vsync 信号周期的调整, ...

  8. Appium Android Bootstrap源码分析之简介

    在上一个系列中我们分析了UiAutomator的核心源码,对UiAutomator是怎么运行的原理有了根本的了解.今天我们会开始另外一个在安卓平台上基于UiAutomator的新起之秀--Appium ...

  9. Android base-adapter-helper 源码分析与扩展

    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/44014941,本文出自:[张鸿洋的博客] 本篇博客是我加入Android 开源项 ...

随机推荐

  1. 浅谈2-SAT(待续)

    2-SAT问题,其实是一个逻辑互斥问题.做了两道裸题之后仔细想来,和小时候做过的“有两个女生,如果A是女生,那么B一定不是女生.A和C性别相同,求A.B.C三人的性别.”几乎是一样的. 对于这道题我们 ...

  2. 最牛逼的任务调度工具 | Quartz

    Quartz 是一个完全由 Java 编写的开源作业调度框架,不要让作业调度这个术语吓着你,其实不难.尽管 Quartz 框架整合了许多额外功能,但就我们使用来说,你会发现它易用得简直让人受不了! 简 ...

  3. git使用姿势

    IDEA 整合Git 可以在IDEA中Terminal中进行git操作 下面所说的快捷键操作都只是对于IDEA中 拉取提交代码 git pull 从远程仓库更新代码 (ctrl+t) git comm ...

  4. 网页图表Highcharts实践教程标之添加题副标题版权信息

    网页图表Highcharts实践教程标之添加题副标题版权信息 Highcharts辅助元素 辅助元素图表的非必要元素,如标题.版权信息.标签.载入动态.它们不和图表数据发生关联,只是额外说明一些基本信 ...

  5. Atcoder Contest069F:Flag

    题目:https://arc069.contest.atcoder.jp/tasks/arc069_d 题意就是让你在n对数字每一对都选一个数使得任意两个数做差的绝对值最小值最大. 关系显然是一个2- ...

  6. [BZOJ3757]苹果树(树上莫队)

    树上莫队共有三种写法: 1.按DFS序列分块,和普通莫队类似.常数大,不会被卡. 2.按块状树的方式分块.常数小,会被菊花图卡到O(n). 3.按[BZOJ1086]王室联邦的方式分块.常数小,不会被 ...

  7. BZOJ.3265.志愿者招募加强版(费用流SPFA)

    题目链接 见上题. 每类志愿者可能是若干段,不满足那个...全幺模矩阵(全单位模矩阵)的条件,所以线性规划可能存在非整数解. 于是就可以用费用流水过去顺便拿个rank2 233. //20704kb ...

  8. python3 开发面试题(面向对象)6.6

    """ 封装.继承.多态 1. 谈谈你对面向对象的理解? 2. Python面向对象中的继承有什么特点? 3. 面向对象深度优先和广度优先是什么? 4. 面向对象中sup ...

  9. SNOI 滚粗记

    连睡觉都只能睡一半就吓醒 真的蠢 CE了四道 没有cstring 踏马本机怎么能过??!! 还有几次夏令营什么的 可能水水就结束了 最单纯的拿点优惠的想法也没实现 都说以后会有用的 大概是吧 也大概是 ...

  10. Ural 2036. Intersect Until You're Sick of It 计算几何

    2036. Intersect Until You're Sick of It 题目连接: http://acm.timus.ru/problem.aspx?space=1&num=2036 ...