zoukankan      html  css  js  c++  java

  • 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的共同入口，
    [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() ");  
    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() ");  
    19.     return adb_main(0, DEFAULT_ADB_PORT);  
    20. #endif  
    21. }  
     
            根据Android.mk中传入的ADB_HOST确定编译的是adb clientadb service, 或者是adb daemon, ADB_HOST为1时编译adb clientadb service的代码， ADB_HOST为0时编译adb daemon的代码。
     
            以上代码中，adb clientadb service端代码如下,
    [cpp] view plain copy
     
    1. adb_sysdeps_init();  
    2. adb_trace_init();  
    3. D("Handling commandline() ");  
    4. return adb_commandline(argc - 1, argv + 1);  

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

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

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

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

     
    [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] == '') {  
    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 || server_port > 65535) {  
    34.             fprintf(stderr,  
    35.                     "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65535. Got "%s" ",  
    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] == '') {  
    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" ",  
    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] != '') 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 if (!strcmp(argv[0],"-a")) {  
    82.             gListenAll = 1;  
    83.         } else if(!strncmp(argv[0], "-H", 2)) {  
    84.             const char *hostname = NULL;  
    85.             if (argv[0][2] == '') {  
    86.                 if (argc < 2) return usage();  
    87.                 hostname = argv[1];  
    88.                 argc--;  
    89.                 argv++;  
    90.             } else {  
    91.                 hostname = argv[0] + 2;  
    92.             }  
    93.             adb_set_tcp_name(hostname);  
    94.   
    95.         } else if(!strncmp(argv[0], "-P", 2)) {  
    96.             if (argv[0][2] == '') {  
    97.                 if (argc < 2) return usage();  
    98.                 server_port_str = argv[1];  
    99.                 argc--;  
    100.                 argv++;  
    101.             } else {  
    102.                 server_port_str = argv[0] + 2;  
    103.             }  
    104.             if (strlen(server_port_str) > 0) {  
    105.                 server_port = (int) strtol(server_port_str, NULL, 0);  
    106.                 if (server_port <= 0 || server_port > 65535) {  
    107.                     fprintf(stderr,  
    108.                             "adb: port number must be a positive number less than 65536. Got "%s" ",  
    109.                             server_port_str);  
    110.                     return usage();  
    111.                 }  
    112.             } else {  
    113.                 fprintf(stderr,  
    114.                 "adb: port number must be a positive number less than 65536. Got empty string. ");  
    115.                 return usage();  
    116.             }  
    117.         } else {  
    118.                 /* out of recognized modifiers and flags */  
    119.             break;  
    120.         }  
    121.         argc--;  
    122.         argv++;  
    123.     }  
    124.   
    125.     adb_set_transport(ttype, serial);  
    126.     adb_set_tcp_specifics(server_port);  
    127.   
    128.     if (is_server) {  
    129.         if (no_daemon || is_daemon) {  
    130.             r = adb_main(is_daemon, server_port);  
    131.         } else {  
    132.             r = launch_server(server_port);  
    133.         }  
    134.         if(r) {  
    135.             fprintf(stderr,"* could not start server * ");  
    136.         }  
    137.         return r;  
    138.     }  
    139.   
    140. top:  
    141.     if(argc == 0) {  
    142.         return usage();  
    143.     }  
    144.   
    145.     /* adb_connect() commands */  
    146.   
    147.     if(!strcmp(argv[0], "devices")) {  
    148.         char *tmp;  
    149.         char *listopt;  
    150.         if (argc < 2)  
    151.             listopt = "";  
    152.         else if (argc == 2 && !strcmp(argv[1], "-l"))  
    153.             listopt = argv[1];  
    154.         else {  
    155.             fprintf(stderr, "Usage: adb devices [-l] ");  
    156.             return 1;  
    157.         }  
    158.         snprintf(buf, sizeof buf, "host:%s%s", argv[0], listopt);  
    159.         tmp = adb_query(buf);  
    160.         if(tmp) {  
    161.             printf("List of devices attached  ");  
    162.             printf("%s ", tmp);  
    163.             return 0;  
    164.         } else {  
    165.             return 1;  
    166.         }  
    167.     }  
    168.   
    169.     if(!strcmp(argv[0], "connect")) {  
    170.         char *tmp;  
    171.         if (argc != 2) {  
    172.             fprintf(stderr, "Usage: adb connect <host>[:<port>] ");  
    173.             return 1;  
    174.         }  
    175.         snprintf(buf, sizeof buf, "host:connect:%s", argv[1]);  
    176.         tmp = adb_query(buf);  
    177.         if(tmp) {  
    178.             printf("%s ", tmp);  
    179.             return 0;  
    180.         } else {  
    181.             return 1;  
    182.         }  
    183.     }  
    184.   
    185.     if(!strcmp(argv[0], "disconnect")) {  
    186.         char *tmp;  
    187.         if (argc > 2) {  
    188.             fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]] ");  
    189.             return 1;  
    190.         }  
    191.         if (argc == 2) {  
    192.             snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]);  
    193.         } else {  
    194.             snprintf(buf, sizeof buf, "host:disconnect:");  
    195.         }  
    196.         tmp = adb_query(buf);  
    197.         if(tmp) {  
    198.             printf("%s ", tmp);  
    199.             return 0;  
    200.         } else {  
    201.             return 1;  
    202.         }  
    203.     }  
    204.   
    205.     if (!strcmp(argv[0], "emu")) {  
    206.         return adb_send_emulator_command(argc, argv);  
    207.     }  
    208.   
    209.     if(!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) {  
    210.         int r;  
    211.         int fd;  
    212.   
    213.         char h = (argv[0][0] == 'h');  
    214.   
    215.         if (h) {  
    216.             printf("x1b[41;33m");  
    217.             fflush(stdout);  
    218.         }  
    219.   
    220.         if(argc < 2) {  
    221.             D("starting interactive shell ");  
    222.             r = interactive_shell();  
    223.             if (h) {  
    224.                 printf("x1b[0m");  
    225.                 fflush(stdout);  
    226.             }  
    227.             return r;  
    228.         }  
    229.   
    230.         snprintf(buf, sizeof buf, "shell:%s", argv[1]);  
    231.         argc -= 2;  
    232.         argv += 2;  
    233.         while(argc-- > 0) {  
    234.             strcat(buf, " ");  
    235.   
    236.             /* quote empty strings and strings with spaces */  
    237.             quote = (**argv == 0 || strchr(*argv, ' '));  
    238.             if (quote)  
    239.                 strcat(buf, """);  
    240.             strcat(buf, *argv++);  
    241.             if (quote)  
    242.                 strcat(buf, """);  
    243.         }  
    244.   
    245.         for(;;) {  
    246.             D("interactive shell loop. buff=%s ", buf);  
    247.             fd = adb_connect(buf);  
    248.             if(fd >= 0) {  
    249.                 D("about to read_and_dump(fd=%d) ", fd);  
    250.                 read_and_dump(fd);  
    251.                 D("read_and_dump() done. ");  
    252.                 adb_close(fd);  
    253.                 r = 0;  
    254.             } else {  
    255.                 fprintf(stderr,"error: %s ", adb_error());  
    256.                 r = -1;  
    257.             }  
    258.   
    259.             if(persist) {  
    260.                 fprintf(stderr," - waiting for device - ");  
    261.                 adb_sleep_ms(1000);  
    262.                 do_cmd(ttype, serial, "wait-for-device", 0);  
    263.             } else {  
    264.                 if (h) {  
    265.                     printf("x1b[0m");  
    266.                     fflush(stdout);  
    267.                 }  
    268.                 D("interactive shell loop. return r=%d ", r);  
    269.                 return r;  
    270.             }  
    271.         }  
    272.     }  
    273.   
    274.     if(!strcmp(argv[0], "kill-server")) {  
    275.         int fd;  
    276.         fd = _adb_connect("host:kill");  
    277.         if(fd == -1) {  
    278.             fprintf(stderr,"* server not running * ");  
    279.             return 1;  
    280.         }  
    281.         return 0;  
    282.     }  
    283.   
    284.     if(!strcmp(argv[0], "sideload")) {  
    285.         if(argc != 2) return usage();  
    286.         if(adb_download("sideload", argv[1], 1)) {  
    287.             return 1;  
    288.         } else {  
    289.             return 0;  
    290.         }  
    291.     }  
    292.   
    293.     if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot")  
    294.             || !strcmp(argv[0], "reboot-bootloader")  
    295.             || !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb")  
    296.             || !strcmp(argv[0], "root")) {  
    297.         char command[100];  
    298.         if (!strcmp(argv[0], "reboot-bootloader"))  
    299.             snprintf(command, sizeof(command), "reboot:bootloader");  
    300.         else if (argc > 1)  
    301.             snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]);  
    302.         else  
    303.             snprintf(command, sizeof(command), "%s:", argv[0]);  
    304.         int fd = adb_connect(command);  
    305.         if(fd >= 0) {  
    306.             read_and_dump(fd);  
    307.             adb_close(fd);  
    308.             return 0;  
    309.         }  
    310.         fprintf(stderr,"error: %s ", adb_error());  
    311.         return 1;  
    312.     }  
    313.   
    314.     if(!strcmp(argv[0], "bugreport")) {  
    315.         if (argc != 1) return usage();  
    316.         do_cmd(ttype, serial, "shell", "bugreport", 0);  
    317.         return 0;  
    318.     }  
    319.   
    320.     /* adb_command() wrapper commands */  
    321.   
    322.     if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) {  
    323.         char* service = argv[0];  
    324.         if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) {  
    325.             if (ttype == kTransportUsb) {  
    326.                 service = "wait-for-usb";  
    327.             } else if (ttype == kTransportLocal) {  
    328.                 service = "wait-for-local";  
    329.             } else {  
    330.                 service = "wait-for-any";  
    331.             }  
    332.         }  
    333.   
    334.         format_host_command(buf, sizeof buf, service, ttype, serial);  
    335.   
    336.         if (adb_command(buf)) {  
    337.             D("failure: %s * ",adb_error());  
    338.             fprintf(stderr,"error: %s ", adb_error());  
    339.             return 1;  
    340.         }  
    341.   
    342.         /* Allow a command to be run after wait-for-device, 
    343.             * e.g. 'adb wait-for-device shell'. 
    344.             */  
    345.         if(argc > 1) {  
    346.             argc--;  
    347.             argv++;  
    348.             goto top;  
    349.         }  
    350.         return 0;  
    351.     }  
    352.   
    353.     if(!strcmp(argv[0], "forward")) {  
    354.         char host_prefix[64];  
    355.         char remove = 0;  
    356.         char remove_all = 0;  
    357.         char list = 0;  
    358.         char no_rebind = 0;  
    359.   
    360.         // Parse options here.  
    361.         while (argc > 1 && argv[1][0] == '-') {  
    362.             if (!strcmp(argv[1], "--list"))  
    363.                 list = 1;  
    364.             else if (!strcmp(argv[1], "--remove"))  
    365.                 remove = 1;  
    366.             else if (!strcmp(argv[1], "--remove-all"))  
    367.                 remove_all = 1;  
    368.             else if (!strcmp(argv[1], "--no-rebind"))  
    369.                 no_rebind = 1;  
    370.             else {  
    371.                 return usage();  
    372.             }  
    373.             argc--;  
    374.             argv++;  
    375.         }  
    376.   
    377.         // Ensure we can only use one option at a time.  
    378.         if (list + remove + remove_all + no_rebind > 1) {  
    379.             return usage();  
    380.         }  
    381.   
    382.         // Determine the <host-prefix> for this command.  
    383.         if (serial) {  
    384.             snprintf(host_prefix, sizeof host_prefix, "host-serial:%s",  
    385.                     serial);  
    386.         } else if (ttype == kTransportUsb) {  
    387.             snprintf(host_prefix, sizeof host_prefix, "host-usb");  
    388.         } else if (ttype == kTransportLocal) {  
    389.             snprintf(host_prefix, sizeof host_prefix, "host-local");  
    390.         } else {  
    391.             snprintf(host_prefix, sizeof host_prefix, "host");  
    392.         }  
    393.   
    394.         // Implement forward --list  
    395.         if (list) {  
    396.             if (argc != 1)  
    397.                 return usage();  
    398.             snprintf(buf, sizeof buf, "%s:list-forward", host_prefix);  
    399.             char* forwards = adb_query(buf);  
    400.             if (forwards == NULL) {  
    401.                 fprintf(stderr, "error: %s ", adb_error());  
    402.                 return 1;  
    403.             }  
    404.             printf("%s", forwards);  
    405.             free(forwards);  
    406.             return 0;  
    407.         }  
    408.   
    409.         // Implement forward --remove-all  
    410.         else if (remove_all) {  
    411.             if (argc != 1)  
    412.                 return usage();  
    413.             snprintf(buf, sizeof buf, "%s:killforward-all", host_prefix);  
    414.         }  
    415.   
    416.         // Implement forward --remove <local>  
    417.         else if (remove) {  
    418.             if (argc != 2)  
    419.                 return usage();  
    420.             snprintf(buf, sizeof buf, "%s:killforward:%s", host_prefix, argv[1]);  
    421.         }  
    422.         // Or implement one of:  
    423.         //    forward <local> <remote>  
    424.         //    forward --no-rebind <local> <remote>  
    425.         else  
    426.         {  
    427.           if (argc != 3)  
    428.             return usage();  
    429.           const char* command = no_rebind ? "forward:norebind:" : "forward";  
    430.           snprintf(buf, sizeof buf, "%s:%s:%s;%s", host_prefix, command, argv[1], argv[2]);  
    431.         }  
    432.   
    433.         if(adb_command(buf)) {  
    434.             fprintf(stderr,"error: %s ", adb_error());  
    435.             return 1;  
    436.         }  
    437.         return 0;  
    438.     }  
    439.   
    440.     /* do_sync_*() commands */  
    441.   
    442.     if(!strcmp(argv[0], "ls")) {  
    443.         if(argc != 2) return usage();  
    444.         return do_sync_ls(argv[1]);  
    445.     }  
    446.   
    447.     if(!strcmp(argv[0], "push")) {  
    448.         if(argc != 3) return usage();  
    449.         return do_sync_push(argv[1], argv[2], 0 /* no verify APK */);  
    450.     }  
    451.   
    452.     if(!strcmp(argv[0], "pull")) {  
    453.         if (argc == 2) {  
    454.             return do_sync_pull(argv[1], ".");  
    455.         } else if (argc == 3) {  
    456.             return do_sync_pull(argv[1], argv[2]);  
    457.         } else {  
    458.             return usage();  
    459.         }  
    460.     }  
    461.   
    462.     if(!strcmp(argv[0], "install")) {  
    463.         if (argc < 2) return usage();  
    464.         return install_app(ttype, serial, argc, argv);  
    465.     }  
    466.   
    467.     if(!strcmp(argv[0], "uninstall")) {  
    468.         if (argc < 2) return usage();  
    469.         return uninstall_app(ttype, serial, argc, argv);  
    470.     }  
    471.   
    472.     if(!strcmp(argv[0], "sync")) {  
    473.         char *srcarg, *android_srcpath, *data_srcpath;  
    474.         int listonly = 0;  
    475.   
    476.         int ret;  
    477.         if(argc < 2) {  
    478.             /* No local path was specified. */  
    479.             srcarg = NULL;  
    480.         } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) {  
    481.             listonly = 1;  
    482.             if (argc == 3) {  
    483.                 srcarg = argv[2];  
    484.             } else {  
    485.                 srcarg = NULL;  
    486.             }  
    487.         } else if(argc == 2) {  
    488.             /* A local path or "android"/"data" arg was specified. */  
    489.             srcarg = argv[1];  
    490.         } else {  
    491.             return usage();  
    492.         }  
    493.         ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath);  
    494.         if(ret != 0) return usage();  
    495.   
    496.         if(android_srcpath != NULL)  
    497.             ret = do_sync_sync(android_srcpath, "/system", listonly);  
    498.         if(ret == 0 && data_srcpath != NULL)  
    499.             ret = do_sync_sync(data_srcpath, "/data", listonly);  
    500.   
    501.         free(android_srcpath);  
    502.         free(data_srcpath);  
    503.         return ret;  
    504.     }  
    505.   
    506.     /* passthrough commands */  
    507.   
    508.     if(!strcmp(argv[0],"get-state") ||  
    509.         !strcmp(argv[0],"get-serialno") ||  
    510.         !strcmp(argv[0],"get-devpath"))  
    511.     {  
    512.         char *tmp;  
    513.   
    514.         format_host_command(buf, sizeof buf, argv[0], ttype, serial);  
    515.         tmp = adb_query(buf);  
    516.         if(tmp) {  
    517.             printf("%s ", tmp);  
    518.             return 0;  
    519.         } else {  
    520.             return 1;  
    521.         }  
    522.     }  
    523.   
    524.     /* other commands */  
    525.   
    526.     if(!strcmp(argv[0],"status-window")) {  
    527.         status_window(ttype, serial);  
    528.         return 0;  
    529.     }  
    530.   
    531.     if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) {  
    532.         return logcat(ttype, serial, argc, argv);  
    533.     }  
    534.   
    535.     if(!strcmp(argv[0],"ppp")) {  
    536.         return ppp(argc, argv);  
    537.     }  
    538.   
    539.     if (!strcmp(argv[0], "start-server")) {  
    540.         return adb_connect("host:start-server");  
    541.     }  
    542.   
    543.     if (!strcmp(argv[0], "backup")) {  
    544.         return backup(argc, argv);  
    545.     }  
    546.   
    547.     if (!strcmp(argv[0], "restore")) {  
    548.         return restore(argc, argv);  
    549.     }  
    550.   
    551.     if (!strcmp(argv[0], "jdwp")) {  
    552.         int  fd = adb_connect("jdwp");  
    553.         if (fd >= 0) {  
    554.             read_and_dump(fd);  
    555.             adb_close(fd);  
    556.             return 0;  
    557.         } else {  
    558.             fprintf(stderr, "error: %s ", adb_error());  
    559.             return -1;  
    560.         }  
    561.     }  
    562.   
    563.     /* "adb /?" is a common idiom under Windows */  
    564.     if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {  
    565.         help();  
    566.         return 0;  
    567.     }  
    568.   
    569.     if(!strcmp(argv[0], "version")) {  
    570.         version(stdout);  
    571.         return 0;  
    572.     }  
    573.   
    574.     usage();  
    575.     return 1;  
    576. }  
       adb_commandline解析adb命令，如adb devices,  关于某个命令具体执行过程，后面专门针对某个命令进行解析。
     
       main()中， adbd端代码如下，
    [cpp] view plain copy
     
    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.   
    9.  start_device_log();  
    10.  D("Handling main() ");  
    11.  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()：如下
     
    [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.   
    23. #ifdef WORKAROUND_BUG6558362  
    24.     if(is_daemon) adb_set_affinity();  
    25. #endif  
    26.     usb_vendors_init();  
    27.     usb_init();  
    28.     local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);  
    29.     adb_auth_init();  
    30.   
    31.     char local_name[30];  
    32.     build_local_name(local_name, sizeof(local_name), server_port);  
    33.     if(install_listener(local_name, "*smartsocket*", NULL, 0)) {  
    34.         exit(1);  
    35.     }  
    36. #else  
    37.     property_get("ro.adb.secure", value, "0");  
    38.     auth_enabled = !strcmp(value, "1");  
    39.     if (auth_enabled)  
    40.         adb_auth_init();  
    41.   
    42.     // Our external storage path may be different than apps, since  
    43.     // we aren't able to bind mount after dropping root.  
    44.     const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE");  
    45.     if (NULL != adb_external_storage) {  
    46.         setenv("EXTERNAL_STORAGE", adb_external_storage, 1);  
    47.     } else {  
    48.         D("Warning: ADB_EXTERNAL_STORAGE is not set.  Leaving EXTERNAL_STORAGE"  
    49.           " unchanged. ");  
    50.     }  
    51.   
    52.     /* don't listen on a port (default 5037) if running in secure mode */  
    53.     /* don't run as root if we are running in secure mode */  
    54.     if (should_drop_privileges()) {  
    55.         drop_capabilities_bounding_set_if_needed();  
    56.   
    57.         /* add extra groups: 
    58.         ** AID_ADB to access the USB driver 
    59.         ** AID_LOG to read system logs (adb logcat) 
    60.         ** AID_INPUT to diagnose input issues (getevent) 
    61.         ** AID_INET to diagnose network issues (netcfg, ping) 
    62.         ** AID_GRAPHICS to access the frame buffer 
    63.         ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump) 
    64.         ** AID_SDCARD_R to allow reading from the SD card 
    65.         ** AID_SDCARD_RW to allow writing to the SD card 
    66.         ** AID_MOUNT to allow unmounting the SD card before rebooting 
    67.         ** AID_NET_BW_STATS to read out qtaguid statistics 
    68.         */  
    69.         gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,  
    70.                            AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,  
    71.                            AID_MOUNT, AID_NET_BW_STATS };  
    72.         if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {  
    73.             exit(1);  
    74.         }  
    75.   
    76.         /* then switch user and group to "shell" */  
    77.         if (setgid(AID_SHELL) != 0) {  
    78.             exit(1);  
    79.         }  
    80.         if (setuid(AID_SHELL) != 0) {  
    81.             exit(1);  
    82.         }  
    83.   
    84.         D("Local port disabled ");  
    85.     } else {  
    86.         char local_name[30];  
    87.         build_local_name(local_name, sizeof(local_name), server_port);  
    88.         if(install_listener(local_name, "*smartsocket*", NULL, 0)) {  
    89.             exit(1);  
    90.         }  
    91.     }  
    92.   
    93.     int usb = 0;  
    94.     if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {  
    95.         // listen on USB  
    96.         usb_init();  
    97.         usb = 1;  
    98.     }  
    99.   
    100.     // If one of these properties is set, also listen on that port  
    101.     // If one of the properties isn't set and we couldn't listen on usb,  
    102.     // listen on the default port.  
    103.     property_get("service.adb.tcp.port", value, "");  
    104.     if (!value[0]) {  
    105.         property_get("persist.adb.tcp.port", value, "");  
    106.     }  
    107.     if (sscanf(value, "%d", &port) == 1 && port > 0) {  
    108.         printf("using port=%d ", port);  
    109.         // listen on TCP port specified by service.adb.tcp.port property  
    110.         local_init(port);  
    111.     } else if (!usb) {  
    112.         // listen on default port  
    113.         local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);  
    114.     }  
    115.   
    116.     D("adb_main(): pre init_jdwp() ");  
    117.     init_jdwp();  
    118.     D("adb_main(): post init_jdwp() ");  
    119. #endif  
    120.   
    121.     if (is_daemon)  
    122.     {  
    123.         // inform our parent that we are up and running.  
    124. #ifdef HAVE_WIN32_PROC  
    125.         DWORD  count;  
    126.         WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK ", 3, &count, NULL );  
    127. #elif defined(HAVE_FORKEXEC)  
    128.         fprintf(stderr, "OK ");  
    129. #endif  
    130.         start_logging();  
    131.     }  
    132.     D("Event loop starting ");  
    133.   
    134.     fdevent_loop();  
    135.   
    136.     usb_cleanup();  
    137.   
    138.     return 0;  
    139. }  

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

       1、local_init():  adb daemon的这个函数与adb service端的有所不同，adb service端的local_init只在adb service初始化
          的时候扫描一下5555-5585端口，而adb daemon端的local_init会在线程中运行一个无限循环，不停尝试连接5555端口或者由
          service.adb.tcp.portpersist.adb.tcp.port设置的端口，因为作为daemon随时要准备为他人服务。  
       2、init_jdwp():  jdwp全称为java debug wire protocol, 每dalvik VM都会创建一个jdwp, 可以建立在adb或者tcp基础上，
          与DDMS或debugger进行通信， 这个函数就是初始化了监听socket描述符"jdwp-control"动作。
       
       adb daemon其它部分的代码与adb service都比较类似，可能参考adb service部分。
  • 相关阅读:
    Echarts 实现中国地图并轮播指定的地区？
    Linux安装Zookeeper
    初遇携程apollo配置中心
    eclipse安装lombok
    依赖layui form模块 复选框tree插件（拓展可根据属性单选还是多选，数据反选）
    centos7环境下mysql5.7的安装与配置
    中文算数验证码（加减乘除）
    获取请求主机IP地址,如果通过代理进来，则透过防火墙获取真实IP地址;
    jdk自带的MD5进行数据的加密与解密
    MyBatis-plus 代码生成器
  • 原文地址：https://www.cnblogs.com/zzb-Dream-90Time/p/8166288.html
Copyright © 2011-2022 走看看