Android ADB实现解析【转】

本文转载自：http://blog.csdn.net/u010223349/article/details/41120255

  ADB是Android系统提供的调试工具，整个ADB工具由三部分组成：adb client、adb service、adb daemon。

 1、ADB client

       提供HOST端运行的命令

 2、ADB service

       HOST端上的一个后台进程

 3、ADB daemom

       DEVICE端（真实的机器或者模拟器）的守护进程

       ADB代码位于/system/core/adb目录下，通过查看Android.mk，可以知道，该目录下的代码生成了两个MODULE，分别是adb和adbd,  adb client和adb service都是由adb这个可执行文件实现， adb daemon由adbd实现。adb和adbd的一些源代码文件是用同一个的，编译时通过LOCAL_CFLAGS的参数ADB_HOST来区分，这种你中有我我中有你的关系，对于初次接触的朋友们，多少增加了些困扰。理清了ADB几部分的关系，以及源代码的结构，对ADB的认识已经有一个飞越了。

 

        一、main函数

 

        adb.c的main函数是adb client、adb service、adb daemon的共同入口，

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. }

 

        根据Android.mk中传入的ADB_HOST确定编译的是adb client\adb service, 或者是adb daemon, ADB_HOST为1时编译adb client\adb service的代码， ADB_HOST为0时编译adb daemon的代码。

 

        以上代码中，adb client\adb service端代码如下,

1. adb_sysdeps_init();
2. adb_trace_init();
3. D("Handling commandline()\n");
4. return adb_commandline(argc - 1, argv + 1);

1、adb_sysdeps_init():  adb client\adb service适用于linux和windows版本，所以代码中有平台相关的部分。

2、adb_trace_init():   初始化log输出配置，初始化后在HOST上设置ADB_TRACE这个环境变量，可以控制client\service端的log输出等级，

配置为1或者all的话，将输出所有 的log。

3、adb_commandline():  关键函数，代码如下。

 

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 || server_port > 65535) {
31. fprintf(stderr,
32. "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. 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 if (!strcmp(argv[0],"-a")) {
78. gListenAll = 1;
79. } else if(!strncmp(argv[0], "-H", 2)) {
80. const char *hostname = NULL;
81. if (argv[0][2] == '\0') {
82. if (argc < 2) return usage();
83. hostname = argv[1];
84. argc--;
85. argv++;
86. } else {
87. hostname = argv[0] + 2;
88. }
89. adb_set_tcp_name(hostname);
90. } else if(!strncmp(argv[0], "-P", 2)) {
91. if (argv[0][2] == '\0') {
92. if (argc < 2) return usage();
93. server_port_str = argv[1];
94. argc--;
95. argv++;
96. } else {
97. server_port_str = argv[0] + 2;
98. }
99. if (strlen(server_port_str) > 0) {
100. server_port = (int) strtol(server_port_str, NULL, 0);
101. if (server_port <= 0 || server_port > 65535) {
102. fprintf(stderr,
103. "adb: port number must be a positive number less than 65536. Got \"%s\"\n",
104. server_port_str);
105. return usage();
106. }
107. } else {
108. fprintf(stderr,
109. "adb: port number must be a positive number less than 65536. Got empty string.\n");
110. return usage();
111. }
112. } else {
113. /* out of recognized modifiers and flags */
114. break;
115. }
116. argc--;
117. argv++;
118. }
119. adb_set_transport(ttype, serial);
120. adb_set_tcp_specifics(server_port);
121. if (is_server) {
122. if (no_daemon || is_daemon) {
123. r = adb_main(is_daemon, server_port);
124. } else {
125. r = launch_server(server_port);
126. }
127. if(r) {
128. fprintf(stderr,"* could not start server *\n");
129. }
130. return r;
131. }
132. top:
133. if(argc == 0) {
134. return usage();
135. }
136. /* adb_connect() commands */
137. if(!strcmp(argv[0], "devices")) {
138. char *tmp;
139. char *listopt;
140. if (argc < 2)
141. listopt = "";
142. else if (argc == 2 && !strcmp(argv[1], "-l"))
143. listopt = argv[1];
144. else {
145. fprintf(stderr, "Usage: adb devices [-l]\n");
146. return 1;
147. }
148. snprintf(buf, sizeof buf, "host:%s%s", argv[0], listopt);
149. tmp = adb_query(buf);
150. if(tmp) {
151. printf("List of devices attached \n");
152. printf("%s\n", tmp);
153. return 0;
154. } else {
155. return 1;
156. }
157. }
158. if(!strcmp(argv[0], "connect")) {
159. char *tmp;
160. if (argc != 2) {
161. fprintf(stderr, "Usage: adb connect <host>[:<port>]\n");
162. return 1;
163. }
164. snprintf(buf, sizeof buf, "host:connect:%s", argv[1]);
165. tmp = adb_query(buf);
166. if(tmp) {
167. printf("%s\n", tmp);
168. return 0;
169. } else {
170. return 1;
171. }
172. }
173. if(!strcmp(argv[0], "disconnect")) {
174. char *tmp;
175. if (argc > 2) {
176. fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]]\n");
177. return 1;
178. }
179. if (argc == 2) {
180. snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]);
181. } else {
182. snprintf(buf, sizeof buf, "host:disconnect:");
183. }
184. tmp = adb_query(buf);
185. if(tmp) {
186. printf("%s\n", tmp);
187. return 0;
188. } else {
189. return 1;
190. }
191. }
192. if (!strcmp(argv[0], "emu")) {
193. return adb_send_emulator_command(argc, argv);
194. }
195. if(!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) {
196. int r;
197. int fd;
198. char h = (argv[0][0] == 'h');
199. if (h) {
200. printf("\x1b[41;33m");
201. fflush(stdout);
202. }
203. if(argc < 2) {
204. D("starting interactive shell\n");
205. r = interactive_shell();
206. if (h) {
207. printf("\x1b[0m");
208. fflush(stdout);
209. }
210. return r;
211. }
212. snprintf(buf, sizeof buf, "shell:%s", argv[1]);
213. argc -= 2;
214. argv += 2;
215. while(argc-- > 0) {
216. strcat(buf, " ");
217. /* quote empty strings and strings with spaces */
218. quote = (**argv == 0 || strchr(*argv, ' '));
219. if (quote)
220. strcat(buf, "\"");
221. strcat(buf, *argv++);
222. if (quote)
223. strcat(buf, "\"");
224. }
225. for(;;) {
226. D("interactive shell loop. buff=%s\n", buf);
227. fd = adb_connect(buf);
228. if(fd >= 0) {
229. D("about to read_and_dump(fd=%d)\n", fd);
230. read_and_dump(fd);
231. D("read_and_dump() done.\n");
232. adb_close(fd);
233. r = 0;
234. } else {
235. fprintf(stderr,"error: %s\n", adb_error());
236. r = -1;
237. }
238. if(persist) {
239. fprintf(stderr,"\n- waiting for device -\n");
240. adb_sleep_ms(1000);
241. do_cmd(ttype, serial, "wait-for-device", 0);
242. } else {
243. if (h) {
244. printf("\x1b[0m");
245. fflush(stdout);
246. }
247. D("interactive shell loop. return r=%d\n", r);
248. return r;
249. }
250. }
251. }
252. if(!strcmp(argv[0], "kill-server")) {
253. int fd;
254. fd = _adb_connect("host:kill");
255. if(fd == -1) {
256. fprintf(stderr,"* server not running *\n");
257. return 1;
258. }
259. return 0;
260. }
261. if(!strcmp(argv[0], "sideload")) {
262. if(argc != 2) return usage();
263. if(adb_download("sideload", argv[1], 1)) {
264. return 1;
265. } else {
266. return 0;
267. }
268. }
269. if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot")
270. || !strcmp(argv[0], "reboot-bootloader")
271. || !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb")
272. || !strcmp(argv[0], "root")) {
273. char command[100];
274. if (!strcmp(argv[0], "reboot-bootloader"))
275. snprintf(command, sizeof(command), "reboot:bootloader");
276. else if (argc > 1)
277. snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]);
278. else
279. snprintf(command, sizeof(command), "%s:", argv[0]);
280. int fd = adb_connect(command);
281. if(fd >= 0) {
282. read_and_dump(fd);
283. adb_close(fd);
284. return 0;
285. }
286. fprintf(stderr,"error: %s\n", adb_error());
287. return 1;
288. }
289. if(!strcmp(argv[0], "bugreport")) {
290. if (argc != 1) return usage();
291. do_cmd(ttype, serial, "shell", "bugreport", 0);
292. return 0;
293. }
294. /* adb_command() wrapper commands */
295. if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) {
296. char* service = argv[0];
297. if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) {
298. if (ttype == kTransportUsb) {
299. service = "wait-for-usb";
300. } else if (ttype == kTransportLocal) {
301. service = "wait-for-local";
302. } else {
303. service = "wait-for-any";
304. }
305. }
306. format_host_command(buf, sizeof buf, service, ttype, serial);
307. if (adb_command(buf)) {
308. D("failure: %s *\n",adb_error());
309. fprintf(stderr,"error: %s\n", adb_error());
310. return 1;
311. }
312. /* Allow a command to be run after wait-for-device,
313. * e.g. 'adb wait-for-device shell'.
314. */
315. if(argc > 1) {
316. argc--;
317. argv++;
318. goto top;
319. }
320. return 0;
321. }
322. if(!strcmp(argv[0], "forward")) {
323. char host_prefix[64];
324. char remove = 0;
325. char remove_all = 0;
326. char list = 0;
327. char no_rebind = 0;
328. // Parse options here.
329. while (argc > 1 && argv[1][0] == '-') {
330. if (!strcmp(argv[1], "--list"))
331. list = 1;
332. else if (!strcmp(argv[1], "--remove"))
333. remove = 1;
334. else if (!strcmp(argv[1], "--remove-all"))
335. remove_all = 1;
336. else if (!strcmp(argv[1], "--no-rebind"))
337. no_rebind = 1;
338. else {
339. return usage();
340. }
341. argc--;
342. argv++;
343. }
344. // Ensure we can only use one option at a time.
345. if (list + remove + remove_all + no_rebind > 1) {
346. return usage();
347. }
348. // Determine the <host-prefix> for this command.
349. if (serial) {
350. snprintf(host_prefix, sizeof host_prefix, "host-serial:%s",
351. serial);
352. } else if (ttype == kTransportUsb) {
353. snprintf(host_prefix, sizeof host_prefix, "host-usb");
354. } else if (ttype == kTransportLocal) {
355. snprintf(host_prefix, sizeof host_prefix, "host-local");
356. } else {
357. snprintf(host_prefix, sizeof host_prefix, "host");
358. }
359. // Implement forward --list
360. if (list) {
361. if (argc != 1)
362. return usage();
363. snprintf(buf, sizeof buf, "%s:list-forward", host_prefix);
364. char* forwards = adb_query(buf);
365. if (forwards == NULL) {
366. fprintf(stderr, "error: %s\n", adb_error());
367. return 1;
368. }
369. printf("%s", forwards);
370. free(forwards);
371. return 0;
372. }
373. // Implement forward --remove-all
374. else if (remove_all) {
375. if (argc != 1)
376. return usage();
377. snprintf(buf, sizeof buf, "%s:killforward-all", host_prefix);
378. }
379. // Implement forward --remove <local>
380. else if (remove) {
381. if (argc != 2)
382. return usage();
383. snprintf(buf, sizeof buf, "%s:killforward:%s", host_prefix, argv[1]);
384. }
385. // Or implement one of:
386. //    forward <local> <remote>
387. //    forward --no-rebind <local> <remote>
388. else
389. {
390. if (argc != 3)
391. return usage();
392. const char* command = no_rebind ? "forward:norebind:" : "forward";
393. snprintf(buf, sizeof buf, "%s:%s:%s;%s", host_prefix, command, argv[1], argv[2]);
394. }
395. if(adb_command(buf)) {
396. fprintf(stderr,"error: %s\n", adb_error());
397. return 1;
398. }
399. return 0;
400. }
401. /* do_sync_*() commands */
402. if(!strcmp(argv[0], "ls")) {
403. if(argc != 2) return usage();
404. return do_sync_ls(argv[1]);
405. }
406. if(!strcmp(argv[0], "push")) {
407. if(argc != 3) return usage();
408. return do_sync_push(argv[1], argv[2], 0 /* no verify APK */);
409. }
410. if(!strcmp(argv[0], "pull")) {
411. if (argc == 2) {
412. return do_sync_pull(argv[1], ".");
413. } else if (argc == 3) {
414. return do_sync_pull(argv[1], argv[2]);
415. } else {
416. return usage();
417. }
418. }
419. if(!strcmp(argv[0], "install")) {
420. if (argc < 2) return usage();
421. return install_app(ttype, serial, argc, argv);
422. }
423. if(!strcmp(argv[0], "uninstall")) {
424. if (argc < 2) return usage();
425. return uninstall_app(ttype, serial, argc, argv);
426. }
427. if(!strcmp(argv[0], "sync")) {
428. char *srcarg, *android_srcpath, *data_srcpath;
429. int listonly = 0;
430. int ret;
431. if(argc < 2) {
432. /* No local path was specified. */
433. srcarg = NULL;
434. } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {
435. listonly = 1;
436. if (argc == 3) {
437. srcarg = argv[2];
438. } else {
439. srcarg = NULL;
440. }
441. } else if(argc == 2) {
442. /* A local path or "android"/"data" arg was specified. */
443. srcarg = argv[1];
444. } else {
445. return usage();
446. }
447. ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath);
448. if(ret != 0) return usage();
449. if(android_srcpath != NULL)
450. ret = do_sync_sync(android_srcpath, "/system", listonly);
451. if(ret == 0 && data_srcpath != NULL)
452. ret = do_sync_sync(data_srcpath, "/data", listonly);
453. free(android_srcpath);
454. free(data_srcpath);
455. return ret;
456. }
457. /* passthrough commands */
458. if(!strcmp(argv[0],"get-state") ||
459. !strcmp(argv[0],"get-serialno") ||
460. !strcmp(argv[0],"get-devpath"))
461. {
462. char *tmp;
463. format_host_command(buf, sizeof buf, argv[0], ttype, serial);
464. tmp = adb_query(buf);
465. if(tmp) {
466. printf("%s\n", tmp);
467. return 0;
468. } else {
469. return 1;
470. }
471. }
472. /* other commands */
473. if(!strcmp(argv[0],"status-window")) {
474. status_window(ttype, serial);
475. return 0;
476. }
477. if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) {
478. return logcat(ttype, serial, argc, argv);
479. }
480. if(!strcmp(argv[0],"ppp")) {
481. return ppp(argc, argv);
482. }
483. if (!strcmp(argv[0], "start-server")) {
484. return adb_connect("host:start-server");
485. }
486. if (!strcmp(argv[0], "backup")) {
487. return backup(argc, argv);
488. }
489. if (!strcmp(argv[0], "restore")) {
490. return restore(argc, argv);
491. }
492. if (!strcmp(argv[0], "jdwp")) {
493. int  fd = adb_connect("jdwp");
494. if (fd >= 0) {
495. read_and_dump(fd);
496. adb_close(fd);
497. return 0;
498. } else {
499. fprintf(stderr, "error: %s\n", adb_error());
500. return -1;
501. }
502. }
503. /* "adb /?" is a common idiom under Windows */
504. if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {
505. help();
506. return 0;
507. }
508. if(!strcmp(argv[0], "version")) {
509. version(stdout);
510. return 0;
511. }
512. usage();
513. return 1;
514. }

   adb_commandline解析adb命令，如adb devices,  关于某个命令具体执行过程，后面专门针对某个命令进行解析。

 

   main()中， adbd端代码如下，

1. /* If adbd runs inside the emulator this will enable adb tracing via
2. * adb-debug qemud service in the emulator. */
3. adb_qemu_trace_init();
4. if((argc > 1) && (!strcmp(argv[1],"recovery"))) {
5. adb_device_banner = "recovery";
6. recovery_mode = 1;
7. }
8. start_device_log();
9. D("Handling main()\n");
10. return adb_main(0, DEFAULT_ADB_PORT);

  1、adb_qemu_trace_init()：  建立和模拟器中的adb-debug qemud service的连接。

  2、if((argc > 1) && (!strcmp(argv[1],"recovery"))) {

            adb_device_banner = "recovery";
            recovery_mode = 1;
        }

     启动adbd的时候，可以加参数， 例如，在recovery模式中init.rc文件中的adbd service是带recovery参数的，如果带

     recovery参数就设置这两个标志，但目前没有看到哪里用到了这两个标志。

  3、start_device_log()： 配置adb daemon的log输出， 前面说了adb client和service端的log输出可以通过ADB_TRACE这个环境

     变量来控制，adb daemon端的log可以通过persist.adb.trace_mask控制， start_device_log()中判persist.adb.trace_mask

     的值，如果有值，就会将log输出到/data/adb/目录下。

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

        二、adb_main()函数

 

        上一节中已经附上adb_main()函数代码， 其中，adb service端的代码如下,

1. usb_vendors_init();
2. usb_init();
3. local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
4. adb_auth_init();
5. char local_name[30];
6. build_local_name(local_name, sizeof(local_name), server_port);
7. if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
8. exit(1);
9. }
10. .........
11. start_logging();
12. }
13. D("Event loop starting\n");
14. fdevent_loop();
15. usb_cleanup();

    1、usb_vendors_init()： 每个设备产家都会定义一个vender id来标识自己的usb 设备，ADB service端只会连接已知的vender

     id，这个函数的作用就是初始化一个vender id的数组，初始化后这个数组中将包含adb代码中内建的一些产家的id以及HOST

     端的android配置文件中定义的id。

  2、usb_init(): 创建一个线程，线程处理函数device_poll_thread, 进入一个循环，每隔1s执行一次find_usb_device和 

     kick_disconnected_devices,find_usb_device搜索所有的usb设备，判断vender id是否在上面初始化的列表中，如果是，则

     将该usb设备注册到一个handle_list中。调用register_usb_transport基于这个fd 构造一个atransport类型的对象，再基于

     这个atransport对象调用register_transport构造一个tmsg类型的对象。

     最后，将这个tmsg对象写到transport_registration_send这个fd,  将触发相应的socket监控。kick_disconnected_devices

     判断adb设备是否还正常，不正常的话从handle_list中支掉。

  3、local_init(): 创建一个线程，尝试连接HOST端5555-5585端口，如果连接成功，则返回一个fd, register_socket_transport

     基于这个fd 构造一个atransport类型的对象，再基于这个atransport对象调用register_transport构造一个tmsg类型的

     对象。最后，将这个tmsg对象写 transport_registration_send这个fd,  将触发相应的socket监控。

  4、install_listener():  监听"tcp:5037" ,  adb client与adb service之间通讯用这个端口。

  5、start_logging():  将stdin重写向到/dev/null, 将stdout、stderr重定向/tmp/adb.log, 然后输出"adb starting"到

     stderr。

  6、fdevent_loop():  前面通过fdinstall()注册了几个fde, 这里就通过一个无限循环epoll相应的fd,  有相应的事件则调用

     fdinstall时注册的处理函数。

  7、usb_cleanup()： usb相关的清理工作，对应linux平台的实现目前为空。

     其中，adb daemon端代码如下， 

1. property_get("ro.adb.secure", value, "0");
2. auth_enabled = !strcmp(value, "1");
3. if (auth_enabled)
4. adb_auth_init();
5. // Our external storage path may be different than apps, since
6. // we aren't able to bind mount after dropping root.
7. const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");
8. if (NULL != adb_external_storage) {
9. setenv("EXTERNAL_STORAGE", adb_external_storage, 1);
10. } else {
11. D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"
12. " unchanged.\n");
13. }
14. /* don't listen on a port (default 5037) if running in secure mode */
15. /* don't run as root if we are running in secure mode */
16. if (should_drop_privileges()) {
17. drop_capabilities_bounding_set_if_needed();
18. /* add extra groups:
19. ** AID_ADB to access the USB driver
20. ** AID_LOG to read system logs (adb logcat)
21. ** AID_INPUT to diagnose input issues (getevent)
22. ** AID_INET to diagnose network issues (netcfg, ping)
23. ** AID_GRAPHICS to access the frame buffer
24. ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
25. ** AID_SDCARD_R to allow reading from the SD card
26. ** AID_SDCARD_RW to allow writing to the SD card
27. ** AID_MOUNT to allow unmounting the SD card before rebooting
28. ** AID_NET_BW_STATS to read out qtaguid statistics
29. */
30. gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,
31. AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,
32. AID_MOUNT, AID_NET_BW_STATS };
33. if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
34. exit(1);
35. }
36. /* then switch user and group to "shell" */
37. if (setgid(AID_SHELL) != 0) {
38. exit(1);
39. }
40. if (setuid(AID_SHELL) != 0) {
41. exit(1);
42. }
43. D("Local port disabled\n");
44. } else {
45. char local_name[30];
46. build_local_name(local_name, sizeof(local_name), server_port);
47. if(install_listener(local_name, "*smartsocket*", NULL, 0)) {
48. exit(1);
49. }
50. }
51. int usb = 0;
52. if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {
53. // listen on USB
54. usb_init();
55. usb = 1;
56. }
57. // If one of these properties is set, also listen on that port
58. // If one of the properties isn't set and we couldn't listen on usb,
59. // listen on the default port.
60. property_get("service.adb.tcp.port", value, "");
61. if (!value[0]) {
62. property_get("persist.adb.tcp.port", value, "");
63. }
64. if (sscanf(value, "%d", &port) == 1 && port > 0) {
65. printf("using port=%d\n", port);
66. // listen on TCP port specified by service.adb.tcp.port property
67. local_init(port);
68. } else if (!usb) {
69. // listen on default port
70. local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
71. }
72. D("adb_main(): pre init_jdwp()\n");
73. init_jdwp();
74. D("adb_main(): post init_jdwp()\n");

   1、local_init():  adb daemon的这个函数与adb service端的有所不同，adb service端的local_init只在adb service初始化

      的时候扫描一下5555-5585端口，而adb daemon端的local_init会在线程中运行一个无限循环，不停尝试连接5555端口或者由

      service.adb.tcp.port\persist.adb.tcp.port设置的端口，因为作为daemon随时要准备为他人服务。  

   2、init_jdwp():  jdwp全称为java debug wire protocol, 每dalvik VM都会创建一个jdwp, 可以建立在adb或者tcp基础上，

      与DDMS或debugger进行通信， 这个函数就是初始化了监听socket描述符"\0jdwp-control"动作。

   

   adb daemon其它部分的代码与adb service都比较类似，可能参考adb service部分。