android usb adb流程

android adb 概述

android adb的代码分为两部分:
kernel层的代码在如下路径:
drivers/usb/gadget/f_adb.c
drivers/usb/gadget/android.c
他吐给上层应用的是如下的设备节点:/dev/android_adb
应用层的代码在如下路径:
system/core/adb目录
针对device,该目录编译的输出是adbd


控制台上手动启动平板adb的功能的方法如下:

step1:在init.rc中申明adbd服务
  1. <span style="font-size:18px;">service adbd /sbin/adbd  
  2.     class core  
  3. #    socket adbd stream 660 system system  
  4.     disabled  
  5. #    seclabel u:r:adbd:s0</span>  
step2:init.rc中通过属性变量来触发usb adb功能
  1. on property:sys.usb.config=adb  
  2.     write /sys/class/android_usb/android0/enable 0  
  3.     write /sys/class/android_usb/android0/idVendor 18d1  
  4.     write /sys/class/android_usb/android0/idProduct D002  
  5.     write /sys/class/android_usb/android0/functions ${sys.usb.config}  
  6.     write /sys/class/android_usb/android0/enable 1  
  7.     start adbd  
  8.     setprop sys.usb.state ${sys.usb.config}  

step3: init.rc中disable adb
  1. <span style="font-size:18px;">on property:sys.usb.config=none  
  2.     stop adbd  
  3.     write /sys/class/android_usb/android0/enable 0  
  4.     write /sys/class/android_usb/android0/bDeviceClass 0  
  5.     setprop sys.usb.state ${sys.usb.config}</span>  

step4:在控制台上执行命令setprop sys.usb.config adb 将使能adb功能
         在控制台上执行命令setprop sys.usb.confignone关闭adb功能    

以上默认是通过usb来实现adb的功能,其实也可以通过网络来实现adb的功能; 方法如下:
device端:
step1:  setprop service.adb.tcp.port 5555
step2:  setprop sys.usb.confignone
    setprop sys.usb.config adb
step3: 通过执行netstat -tna命令确认5555端口被监听。#以上操作如下图

pc端:
step1:  adb kill-server
step2: adb connect 10.1.32.4  #这里的地址就是平板的地址
step3: adb devices
step3: adb shell  #以上操作如下图

adb 出问题时的调试方法:
方法一:通过bus hound工具来抓pc跟device之间的usb 包的通讯。前提是需要对usb adb的命令包格式很熟悉。
方法二: 由属性变量:persist.adb.trace_mask来控制adb的log输出级别。其输出的log信息将被重定向到/data/adb/目录下的文件中。
具体源代码,请查看:/system/core/adb/adb.c(start_device_log函数), system/core/adb/adb.h(adb_trace_mask,AdbTrace)
方法三:由于方法二有一定的局限性,他是将printf的输出重定向到/data/adb/xxxx.txt文件中,这样很多的后台服务的打印信息是打印不出来的。
因为他的输入,输出被重定向到pty/pts或是pipe或是socket pair上了。 所以我们的方法就是修改/system/core/adb/adb.h文件中的#  define  D(...) 宏,使其的打印输出到logcat中。方法如下:
  1. /* you must define TRACE_TAG before using this macro */  
  2.  define  D(...)                                      \  
  3.       do {                                           \  
  4.           if (ADB_TRACING) {                         \  
  5.               int save_errno = errno;                \  
  6.               adb_mutex_lock(&D_lock);               \  
  7.               __android_log_print(3,"adb""%s::%s():",           \  
  8.                       __FILE__, __FUNCTION__);       \  
  9.               errno = save_errno;                    \  
  10.               __android_log_print(3,"adb", __VA_ARGS__ );         \  
  11.               fflush(stderr);                        \  
  12.               adb_mutex_unlock(&D_lock);             \  
  13.               errno = save_errno;                    \  
  14.          }                                           \  
  15.       } while (0)  
上面的__android_log_print函数需要依赖头文件#include <android/log.h>和动态库:liblog ,动态库的链接方法:
LOCAL_STATIC_LIBRARIES +=  liblog    #交叉编译时使用
LOCAL_LDLIBS += -llog  #编译主机端的adb时使用
为了查看更多地log,可以将persist.adb.trace_mask设置为0x3ff。

一下将从几个专题来研究devices端的adbd后台的工作内容:

专题一:#######adb 从pc端发送命令到device端的流程:#############
output_thread(system/core/adb/transport.c)
get_apacket(分配一个apacket包所需的内存)
t->read_from_remote(p, t)
write_packet(t->fd, t->serial, &p) //注意该函数,真正只是发送包的开始地址,并不是发送整个包的内容数据
|
|t->fd对应的pipe另一端为: t->transport_socket ,而该句柄的接收处理函数为: transport_socket_events
|
\|/
transport_socket_events
read_packet(fd, t->serial, &p)) //fd即为t->transport_socket
handle_packet(p, (atransport *) _t); //该函数根据从pc端发送过来的命令,做相应的处理的。

注意:
read_from_remote/write_to_remote  对应从/dev/android_adb读取和写入数据


专题二:###############adb 从device端发送响应到pc端的流程:#########
send_packet(apacket *p, atransport *t)//函数用来向pc端发送数据(通过usb或以太网)
write_packet(t->transport_socket, t->serial, &p)
 |
 |t->fd对应的pipe另一端为: t->transport_socket ,该socket对是在 transport_registration_func 函数中申明  |的。
\|/
input_thread
read_packet(t->fd, t->serial, &p)
t->write_to_remote(p, t);
 |
 |
 |对应于usb而言
\|/
remote_write //发送命令和数据到pc端
usb_write(t->usb, &p->msg, sizeof(amessage)) // 发送命令
usb_write(t->usb, &p->data, size) //发送数据

专题三:pc跟device之间传输adb数据包的格式
他们之间的数据传输单元称为:struct apacket,具体结构如下:
  1. <span style="font-size:18px;">      struct apacket  
  2.         {  
  3.             apacket *next;   //adb package队列,可以对还未来得及处理的adb数据包进行入队列  
  4.   
  5.             unsigned len;  
  6.             unsigned char *ptr;  
  7.   
  8.             amessage msg;     //adb数据包对应的命令头,对应一个IN或OUT传输  
  9.             unsigned char data[MAX_PAYLOAD]; //命令包对应的数据部分,对应一个IN或OUT传输  
  10.         };</span>  
一个 apacket 包传输分为两个阶段:
第一个阶段是:命令传输阶段(required),存储在 apacket.msg 中
第二个阶段是:数据传输阶段(optional),存储在 apacket.data 中
adb支持的命令如下:
  1. <span style="font-size:18px;">          #define A_SYNC 0x434e5953   //该命令用于adb push/pull命令  
  2.             #define A_CNXN 0x4e584e43   //该命令用于pc和device进行adb连接时使用,该命令带有数据阶段  
  3.             #define A_OPEN 0x4e45504f   //用于在devices端开启一个服务,譬如adb shell,adb logcat,adb remount等shell命令  
  4.             #define A_OKAY 0x59414b4f   //表示接收ok,该命令没有数据阶段  
  5.             #define A_CLSE 0x45534c43   //关闭对应的连接,关闭和打开都是双向的。  
  6.             #define A_WRTE 0x45545257   //该命令用来向pc端或是device端发送数据,该命令一般都有数据阶段  
  7.             #define A_AUTH 0x48545541</span>  

主题四:device端对收到的pc端来的命令或数据的处理函数:handle_packet
  1. <span style="font-size:18px;">void handle_packet(apacket *p, atransport *t)//system/core/adb/adb.c  
  2. {  
  3.     asocket *s;  
  4.   
  5.     D("handle_packet() %c%c%c%c\n", ((char*) (&(p->msg.command)))[0],  
  6.             ((char*) (&(p->msg.command)))[1],  
  7.             ((char*) (&(p->msg.command)))[2],  
  8.             ((char*) (&(p->msg.command)))[3]);  
  9.     print_packet("recv", p);  
  10.   
  11.     switch(p->msg.command){  
  12.     case A_SYNC:           //在adb push和pull命令时使用。  
  13.         if(p->msg.arg0){  
  14.             send_packet(p, t);  
  15.             if(HOST) send_connect(t);  
  16.         } else {  
  17.             t->connection_state = CS_OFFLINE;  
  18.             handle_offline(t);  
  19.             send_packet(p, t);  
  20.         }  
  21.         return;  
  22.   
  23.     case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */ //在adb连接过程时使用。  
  24.             /* XXX verify version, etc */       //首先由pc发送一个A_CNXN命令和对应的数据,然后device收到后,会回复一个  
  25.                                                 //A_CNXN命令并带上数据阶段。  
  26.         if(t->connection_state != CS_OFFLINE) {  
  27.             t->connection_state = CS_OFFLINE;  
  28.             handle_offline(t);  
  29.         }  
  30.   
  31.         parse_banner((char*) p->data, t);  
  32.   
  33.         if (HOST || !auth_enabled) {  
  34.             handle_online(t);  
  35.             if(!HOST) send_connect(t);  
  36.         } else {  
  37.             send_auth_request(t);  
  38.         }  
  39.         break;  
  40.   
  41.     case A_AUTH:  
  42.         if (p->msg.arg0 == ADB_AUTH_TOKEN) {  
  43.             t->connection_state = CS_UNAUTHORIZED;  
  44.             t->key = adb_auth_nextkey(t->key);  
  45.             if (t->key) {  
  46.                 send_auth_response(p->data, p->msg.data_length, t);  
  47.             } else {  
  48.                 /* No more private keys to try, send the public key */  
  49.                 send_auth_publickey(t);  
  50.             }  
  51.         } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) {  
  52.             if (adb_auth_verify(t->token, p->data, p->msg.data_length)) {  
  53.                 adb_auth_verified(t);  
  54.                 t->failed_auth_attempts = 0;  
  55.             } else {  
  56.                 if (t->failed_auth_attempts++ > 10)  
  57.                     adb_sleep_ms(1000);  
  58.                 send_auth_request(t);  
  59.             }  
  60.         } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) {  
  61.             adb_auth_confirm_key(p->data, p->msg.data_length, t);  
  62.         }  
  63.         break;  
  64.   
  65.     case A_OPEN: /* OPEN(local-id, 0, "destination") */  执行一个adb命令时,首先是发送的这个命令  
  66.         if (t->online) {  
  67.             char *name = (char*) p->data;  //命令对应的数据,该数据字段一般包含所要执行的shell命令  
  68.             name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0;  
  69.          D("open usb\n");  
  70.             s = create_local_service_socket(name); // 根据命令的名字执行相应的后台服务线程,通过socket对或是pty/pts来实现本地socket跟  
  71.             if(s == 0) {                         //后台服务线程之间的通讯,本地socket用于跟对应命令的后台服务线程通讯  
  72.                 send_close(0, p->msg.arg0, t);  
  73.             } else {  
  74.                 s->peer = create_remote_socket(p->msg.arg0, t); //对端socket即用于实现跟pc端的交互,主要是向pc发送数据  
  75.                 s->peer->peer = s;  
  76.                 send_ready(s->id, s->peer->id, t);  
  77.                 s->ready(s);  
  78.             }  
  79.         }  
  80.         break;  
  81.   
  82.     case A_OKAY: /* READY(local-id, remote-id, "") */  
  83.         if (t->online) {  
  84.             if((s = find_local_socket(p->msg.arg1))) {  
  85.                 if(s->peer == 0) {  
  86.                     s->peer = create_remote_socket(p->msg.arg0, t);  
  87.                     s->peer->peer = s;  
  88.                 }  
  89.                 s->ready(s);  
  90.             }  
  91.         }  
  92.         break;  
  93.   
  94.     case A_CLSE: /* CLOSE(local-id, remote-id, "") */  
  95.         if (t->online) {  
  96.             if((s = find_local_socket(p->msg.arg1))) {  
  97.                 s->close(s);  //关闭时双向的,现实pc端发送关闭命令,然后是device端回复关闭命令,close 对应 local_socket_close  
  98.             }  
  99.         }  
  100.         break;  
  101.   
  102.     case A_WRTE:    // 对应pc端给device发送数据,分为两个阶段:一个阶段是命令:WRTE(包含在 apacket.msg中);另一个阶段是数据(包含在 apacket.data中)  
  103.         if (t->online) {  
  104.             if((s = find_local_socket(p->msg.arg1))) {  
  105.                 unsigned rid = p->msg.arg0;  
  106.                 p->len = p->msg.data_length;  
  107.   
  108.                 if(s->enqueue(s, p) == 0) {  //enqueue 对应的函数是 local_socket_enqueue  
  109.                     D("Enqueue the socket\n");  
  110.                     send_ready(s->id, rid, t);  
  111.                 }  
  112.                 return;  
  113.             }  
  114.         }  
  115.         break;  
  116.   
  117.     default:  
  118.         printf("handle_packet: what is %08x?!\n", p->msg.command);  
  119.     }  
  120.   
  121.     put_apacket(p);  
  122. }</span>  
上面函数中的remote_socket_enqueue函数,用于向pc端发送命令和数据
  1. <span style="font-size:18px;">static int remote_socket_enqueue(asocket *s, apacket *p)  
  2. {  
  3.     D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d\n",  
  4.       s->id, s->fd, s->peer->fd);  
  5.     p->msg.command = A_WRTE;      //apackge包对应的命令  
  6.     p->msg.arg0 = s->peer->id;  
  7.     p->msg.arg1 = s->id;  
  8.     p->msg.data_length = p->len;  
  9.     send_packet(p, s->transport);  
  10.     return 1;  
  11. }</span>  
上面函数create_local_service_socket的实现如下:
  1. <span style="font-size:18px;">asocket *create_local_service_socket(const char *name)  
  2. {  
  3.     asocket *s;  
  4.     int fd;  
  5.   
  6. #if !ADB_HOST  
  7.     if (!strcmp(name,"jdwp")) {  
  8.         return create_jdwp_service_socket();  
  9.     }  
  10.     if (!strcmp(name,"track-jdwp")) {  
  11.         return create_jdwp_tracker_service_socket();  
  12.     }  
  13. #endif  
  14.     D("begin service_to_fd:%s\n",name);  
  15.     fd = service_to_fd(name);//该函数的功能就是根据name来创建相应的后台服务,并创建一个socket pair或是pty/pts管道对,返回的fd对应该管道的一端;  
  16.     if(fd < 0) return 0;     //该管道的另一端,将dup重定向到该后台服务的输入输出句柄。  
  17.   
  18.     s = create_local_socket(fd);//安装本地句柄,即上面返回的fd句柄的输入和输出处理函数:local_socket_event_func  
  19.     D("LS(%d): bound to '%s' via %d\n", s->id, name, fd);  
  20.   
  21. #if !ADB_HOST  
  22.     if ((!strncmp(name, "root:", 5) && getuid() != 0)  
  23.         || !strncmp(name, "usb:", 4)  
  24.         || !strncmp(name, "tcpip:", 6)) {  
  25.         D("LS(%d): enabling exit_on_close\n", s->id);  
  26.         s->exit_on_close = 1;  
  27.     }  
  28. #endif  
  29.   
  30.     return s;  
  31. }</span>  
local_socket_event_func函数展开如下:该函数是handle_packet与对应的后台服务之间的一个中转函数, 他的任务包括:
任务一:将pc端发送过来的命令和数据报(统称为adb package)通过local_socket_enqueue函数放置在struct 
apacket的next队列上,并触发如下函数的 FDE_WRITE 分支的处理,该分支将从 apacket队列上取package,并将它写到管道另一端的后台服务上,作为后台服务的输入。
任务二:在要读出后台服务的输出结果时,通过调用函数local_socket_ready来触发如下函数的FDE_READ
分支,该分支将通过管道,读取后台服务的输出数据, 并调用 s->peer->enqueue(即remote_socket_enqueue函数)将后台服务的输出发送到远端,即pc端上。
  1. <span style="font-size:18px;">static void local_socket_event_func(int fd, unsigned ev, void *_s)  
  2. {  
  3.     asocket *s = _s;  
  4.   
  5.     D("LS(%d): event_func(fd=%d(==%d), ev=%04x)\n", s->id, s->fd, fd, ev);  
  6.   
  7.     /* put the FDE_WRITE processing before the FDE_READ 
  8.     ** in order to simplify the code. 
  9.     */  
  10.     if(ev & FDE_WRITE){  
  11.         apacket *p;  
  12.   
  13.         while((p = s->pkt_first) != 0) {  
  14.             while(p->len > 0) {  
  15.                 int r = adb_write(fd, p->ptr, p->len);//将pc段发送来的命令和数据写到后台服务  
  16.                 if(r > 0) {  
  17.                     p->ptr += r;  
  18.                     p->len -= r;  
  19.                     continue;  
  20.                 }  
  21.                 if(r < 0) {  
  22.                     /* returning here is ok because FDE_READ will 
  23.                     ** be processed in the next iteration loop 
  24.                     */  
  25.                     if(errno == EAGAIN) return;  
  26.                     if(errno == EINTR) continue;  
  27.                 }  
  28.                 D(" closing after write because r=%d and errno is %d\n", r, errno);  
  29.                 s->close(s);  
  30.                 return;  
  31.             }  
  32.   
  33.             if(p->len == 0) {  
  34.                 s->pkt_first = p->next;//取队列中的下一个apackage包  
  35.                 if(s->pkt_first == 0) s->pkt_last = 0;  
  36.                 put_apacket(p);  
  37.             }  
  38.         }  
  39.   
  40.             /* if we sent the last packet of a closing socket, 
  41.             ** we can now destroy it. 
  42.             */  
  43.         if (s->closing) {  
  44.             D(" closing because 'closing' is set after write\n");  
  45.             s->close(s);  
  46.             return;  
  47.         }  
  48.   
  49.             /* no more packets queued, so we can ignore 
  50.             ** writable events again and tell our peer 
  51.             ** to resume writing 
  52.             */  
  53.         fdevent_del(&s->fde, FDE_WRITE);  
  54.         s->peer->ready(s->peer);  
  55.     }  
  56.   
  57.   
  58.     if(ev & FDE_READ){  
  59.         apacket *p = get_apacket();  
  60.         unsigned char *x = p->data;  
  61.         size_t avail = MAX_PAYLOAD;  
  62.         int r;  
  63.         int is_eof = 0;  
  64.   
  65.         while(avail > 0) {  
  66.             r = adb_read(fd, x, avail);//读取后台服务的输出  
  67.             D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%d\n", s->id, s->fd, r, r<0?errno:0, avail);  
  68.             if(r > 0) {  
  69.                 avail -= r;  
  70.                 x += r;  
  71.                 continue;  
  72.             }  
  73.             if(r < 0) {  
  74.                 if(errno == EAGAIN) break;  
  75.                 if(errno == EINTR) continue;  
  76.             }  
  77.   
  78.                 /* r = 0 or unhandled error */  
  79.             is_eof = 1;  
  80.             break;  
  81.         }  
  82.         D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d\n",  
  83.           s->id, s->fd, r, is_eof, s->fde.force_eof);  
  84.         if((avail == MAX_PAYLOAD) || (s->peer == 0)) {  
  85.             put_apacket(p);  
  86.         } else {  
  87.             p->len = MAX_PAYLOAD - avail;  
  88. <span style="white-space:pre">      </span>//以下将后台服务的输出发送到远端pc上。  
  89.             r = s->peer->enqueue(s->peer, p);//remote_socket_enqueue,该分支在handle_packet函数中的被create_remote_socket初始化  
  90.             D("LS(%d): fd=%d post peer->enqueue(). r=%d\n", s->id, s->fd, r);  
  91.   
  92.             if(r < 0) {  
  93.                     /* error return means they closed us as a side-effect 
  94.                     ** and we must return immediately. 
  95.                     ** 
  96.                     ** note that if we still have buffered packets, the 
  97.                     ** socket will be placed on the closing socket list. 
  98.                     ** this handler function will be called again 
  99.                     ** to process FDE_WRITE events. 
  100.                     */  
  101.                 return;  
  102.             }  
  103.   
  104.             if(r > 0) {  
  105.                     /* if the remote cannot accept further events, 
  106.                     ** we disable notification of READs.  They'll 
  107.                     ** be enabled again when we get a call to ready() 
  108.                     */  
  109.                 fdevent_del(&s->fde, FDE_READ);  
  110.             }  
  111.         }  
  112.         /* Don't allow a forced eof if data is still there */  
  113.         if((s->fde.force_eof && !r) || is_eof) {  
  114.             D(" closing because is_eof=%d r=%d s->fde.force_eof=%d\n", is_eof, r, s->fde.force_eof);  
  115.             s->close(s);  
  116.         }  
  117.     }  
  118.   
  119.     if(ev & FDE_ERROR){  
  120.             /* this should be caught be the next read or write 
  121.             ** catching it here means we may skip the last few 
  122.             ** bytes of readable data. 
  123.             */  
  124. //        s->close(s);  
  125.         D("LS(%d): FDE_ERROR (fd=%d)\n", s->id, s->fd);  
  126.   
  127.         return;  
  128.     }  
  129. }</span>  

注意:
system/core/adb/services.c对应各种命令的后台服务
system/core/adb/commandline.c包含各种后台服务的具体实现。


主题五:usb adb的bus hound分析
情景1:adb的链接过程

2.1.0  
3.1.0
4.1.0 
5.1.0
以上是通用的枚举过程,即取得描述符的内容。
6.1.0  set_config
7.1.0  取得描述符
至此完成设备的枚举,开始adb的连接过程。
8.1.0 发送adb命令:A_CNXN  为out传输
9.1.0 发送adb命令A_CNXN所带的数据 为out传输
10.1.0 由device端发送adb命令A_CNXN到host pc段。IN传输
11.1.0 为adb命令A_CNXN所带的数据,IN传输
12.1.0为adb命令A_OPEN
13.1.0为adb命令A_OPEN所带的数据
14.1.0为以上命令的响应:A_OKAY
15.1.0为adb命令A_WRTE
16.1.0为adb命令A_WRTE所带的数据
17.1.0为以上命令的响应
21.1.0位adb命令A_CLSE,没有数据阶段 IN传输
22.1.0为adb命令A_CLSE,没有数据阶段,关闭时双向的。OUT传输
以上即为adb连接过程的usb封包的分析


情景2:adb logcat过程



1.1.0对应adb命令A_OPEN
2.1.0对应adb命令A_OPEN所带的数据,这个数据中有如下命令:exec logcat
3.1.0为以上命令的响应,IN传输


4.1.0对应adb命令A_WRTE
5.1.0对应adb命令A_WRTE的数据 IN传输,打开设备节点/dev/log/main
6.1.0为以上命令的响应 OUT传输




7.1.0对应adb命令A_WRTE
8.1.0对应adb命令A_WRTE的数据,即为logcat的输出内容 IN传输
10.1.0为以上命令的响应,OUT传输


再往下,即为上面命令的重复,以不断输出logcat的log信息

情景3:adb pull过程


1.1.0对应adb命令A_OPEN
2.1.0对应adb命令A_OPEN所带的数据,这个数据中有如下命令:sync,
     该sync命令在service_to_fd函数中,被file_sync_service函数所处理
3.1.0为以上命令的响应,IN传输


4.1.0对应adb命令A_WRTE
5.1.0对应adb命令A_WRTE的数据 IN传输,数据内容为:STAT,pc用该命令来查询该文件是否存在,已经是有权限
6.1.0为以上命令的响应 OUT传输


13.1.0 对应adb命令A_WRTE  OUT传输
14.1.0 对应adb命令A_WRTE的数据,该数据包含一个命令:RECV,表示pc从device段接收文件
15.1.0 为以上命令的响应


16.1.0 对应adb命令A_WRTE OUT传输
17.1.0 对应adb命令A_WRTE的数据,表示要pull的是哪个文件
18.1.0 为以上命令的响应


19.1.0 对应adb命令A_WRTE IN传输
20.1.0 对应adb命令A_WRTE的数据:DATA,表示开始数据传输,并且指定下一个命令需要传输的数据大小
21.1.0 为以上命令的响应


22.1.0 对应adb命令A_WRTE IN传输
23.1.0 对应adb命令A_WRTE的数据: 包含文件的具体内容,长度就是上面命令指定的长度
24.1.0 为以上命令的响应

重复19到24这个过程,直到文件被传输完成。


情景4:adb push过程


2.1.0对应adb命令A_OPEN所带的数据,这个数据中有如下命令:shell:
3.1.0为以上命令的响应,IN传输


4.1.0对应adb命令A_WRTE IN传输
5.1.0对应adb命令A_WRTE的数据 ,数据内容为:#,即为显示在pc上的cmd窗口上的#号。
6.1.0为以上命令的响应 OUT传输
已标记关键词 清除标记
相关推荐
DirectX修复工具(DirectX Repair)是一款系统级工具软件,简便易用。本程序为绿色版,无需安装,可直接运行。 本程序的主要功能是检测当前系统的DirectX状态,如果发现异常则进行修复。程序主要针对0xc000007b问题设计,可以完美修复该问题。本程序中包含了最新版的DirectX redist(Jun2010),并且全部DX文件都有Microsoft的数字签名,安全放心。 本程序为了应对一般电脑用户的使用,采用了易用的一键式设计,只要点击主界面上的“检测并修复”按钮,程序就会自动完成校验、检测、下载、修复以及注册的全部功能,无需用户的介入,大大降低了使用难度。在常规修复过程中,程序还会自动检测DirectX加速状态,在异常时给予用户相应提示。 本程序适用于多个操作系统,如Windows XP(需先安装.NET 2.0,详情请参阅“致Windows XP用户.txt”文件)、Windows Vista、Windows 7、Windows 8、Windows 8.1、Windows 8.1 Update、Windows 10,同时兼容32位操作系统和64位操作系统。本程序会根据系统的不同,自动调整任务模式,无需用户进行设置。 本程序的V4.0版分为标准版、增强版以及在线修复版。所有版本都支持修复DirectX的功能,而增强版则额外支持修复c++的功能。在线修复版功能与标准版相同,但其所需的数据包需要在修复时自动下载。各个版本之间,主程序完全相同,只是其配套使用的数据包不同。因此,标准版和在线修复版可以通过补全扩展包的形式成为增强版。本程序自V3.5版起,自带扩展功能。只要在主界面的“工具”菜单下打开“选项”对话框,找到“扩展”标签,点击其中的“开始扩展”按钮即可。扩展过程需要Internet连接,扩展成功后新的数据包可自动生效。扩展用时根据网络速度不同而不同,最快仅需数秒,最慢需要数分钟,烦请耐心等待。如扩展失败,可点击“扩展”界面左上角小锁图标切换为加密连接,即可很大程度上避免因防火墙或其他原因导致的连接失败。 本程序自V2.0版起采用全新的底层程序架构,使用了异步多线程编程技术,使得检测、下载、修复单独进行,互不干扰,快速如飞。新程序更改了自我校验方式,因此使用新版本的程序时不会再出现自我校验失败的错误;但并非取消自我校验,因此程序安全性与之前版本相同,并未降低。 程序有更新系统c++功能。由于绝大多数软件运行时需要c++的支持,并且c++的异常也会导致0xc000007b错误,因此程序在检测修复的同时,也会根据需要更新系统中的c++组件。自V3.2版本开始使用了全新的c++扩展包,可以大幅提高工业软件修复成功的概率。修复c++的功能仅限于增强版,标准版及在线修复版在系统c++异常时(非丢失时)会提示用户使用增强版进行修复。除常规修复外,新版程序还支持C++强力修复功能。当常规修复无效时,可以到本程序的选项界面内开启强力修复功能,可大幅提高修复成功率。请注意,请仅在常规修复无效时再使用此功能。 程序有两种窗口样式。正常模式即默认样式,适合绝大多数用户使用。另有一种简约模式,此时窗口将只显示最基本的内容,修复会自动进行,修复完成10秒钟后会自动退出。该窗口样式可以使修复工作变得更加简单快速,同时方便其他软件、游戏将本程序内嵌,即可进行无需人工参与的快速修复。开启简约模式的方法是:打开程序所在目录下的“Settings.ini”文件(如果没有可以自己创建),将其中的“FormStyle”一项的值改为“Simple”并保存即可。 新版程序支持命令行运行模式。在命令行中调用本程序,可以在路径后直接添加命令进行相应的设置。常见的命令有7类,分别是设置语言的命令、设置窗口模式的命令,设置安全级别的命令、开启强力修复的命令、设置c++修复模式的命令、控制Direct加速的命令、显示版权信息的命令。具体命令名称可以通过“/help”或“/?”进行查询。 程序有高级筛选功能,开启该功能后用户可以自主选择要修复的文件,避免了其他不必要的修复工作。同时,也支持通过文件进行辅助筛选,只要在程序目录下建立“Filter.dat”文件,其中的每一行写一个需要修复文件的序号即可。该功能仅针对高级用户使用,并且必须在正常窗口模式下才有效(简约模式时无效)。 本程序有自动记录日志功能,可以记录每一次检测修复结果,方便在出现问题时,及时分析和查找原因,以便找到解决办法。 程序的“选项”对话框中包含了7项高级功能。点击"常规”选项卡可以调整程序的基本运行情况,包括日志记录、安全级别控制、调试模式开启等。只有开启调试模式后才能在C
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页