转自：https://blog.csdn.net/xubin341719/article/details/38519555
Android bluetooth介绍（一）：基本概念及硬件接口
关键词：蓝牙硬件接口 UART PCM blueZ
版本：基于android4.2之前版本 bluez
内核：linux/linux3.08
系统：android/android4.1.3.4
作者：xubin341719(欢迎转载，请注明作者，请尊重版权谢谢)
欢迎指正错误，共同学习、共同进步！！
Android bluetooth介绍（一）：基本概念及硬件接口
Android bluetooth介绍（二）： android 蓝牙代码架构及其uart 到rfcomm流程
Android bluetooth介绍（三）： 蓝牙扫描(scan)设备分析
Android bluetooth介绍（四）： a2dp connect流程分析
一、基本概念补充
1、AP：ApplicationProcessor应用处理器
采用ARM架构的CPU，通常负责运行OS和一些特定设置和载入开机预设。比如一个没有电话功能的平板电脑，只跑android或者win8的系统，只要AP就可以。如国外性能比较好的AP：三星exynos系列芯片、高通骁龙系列、NVIDIA等；国内近几年芯片做的也不错，如：全志、炬力、瑞芯微、晶晨……不过稳定性、性能都还要提高；支持国产，要不然钱都给老外赚取。
2、BP：BasebandProcessor 基带处理器
架构相对于AP简单，处理电话、信息之类的功能。
基带芯片相对来说，高通一家独大了。然后就是台湾的MTK、大陆的展讯市场占有率逐步上升。
3、CP：coprocessor Processor 协处理器
基带芯片加协处理器（CP，通常是多媒体加速器）。这类产品以MTK方案为典型代表，展讯的市场占有份额也逐年上升，推类似的产品， 用来通过处理主cpu的一些工作负荷来使操作提速的辅助处理器。
4、RF：Radio Frequency射频部分
无线信号的发射部分，如电话、蓝牙、WIFI信号发射、接收；
5、展讯Tshark芯片的集成框图：
我们看到有一个AP，和三个CP：CP0、CP1、CP2。
AP为四核：4个A7。3个CP分别为三个ARM9架构的处理器。
这里所说的CP和一般的意义上的理解不同，理论上的CP不包括BP的，展讯的CP0、CP1其实是两个基带处理芯片，算是公司内部的一种说法。2G支持的制式都一样，3G的一个支持TS-SCDMA、一个支持WCDMA。
其实我们重点说的是CP2，四合一部分的，重点是蓝牙。
二、常见组合（简单框图）
如上图所示，一个AP芯片+外设+android软件，就构成一个简单的平板电脑。
2、以三星、高通等AP设计的手机 AP芯片+BP芯片+RF芯片
如果用单AP芯片，要加基带、射频芯片构成手机硬件架构，如下图所示：
3、以MTK、展讯方案设计的手机（AP+BP+CP）芯片+RF芯片
下面是展讯Tshark芯片的手机简单架构，和传统手机相比，硬件上更集成化，这样有利于厂商的生产、节省成本……MTK现阶段做的比较成熟，由低端向中高端进阶。展讯还在艰苦奋战，希望能再接再厉，成为一流芯片公司，填补大陆在芯片技术上的空白。
BT、WIFI、GPS、FM四合一的集成
前面我们了解BP、CP集成，了解手机整体架构，其实我重点讲解四合一芯片。主要说明四合一芯片独立芯片，和AP集成到同一芯片中两种架构。类型与BP，独立芯片、集成芯片。
（1）、独立芯片：
通过串口接出，如上图的troutII.其他芯片，如BCM、RDA、CSR、Retelk等……如上图troutII 也是独立芯片。
（2）、集成芯片：(WIFI \BT\FM\GPS的集成到主控芯片内，直接输出模拟信号量，通过RF放大后发射出去)
模拟芯片输出、出入到SR2351芯片，展讯比较多的芯片集成四合一（BT/WIFI/GPS/FM），节省客户成本，不过芯片性能跟BCM比还是有点距离，各位同仁继续加油。
三、蓝牙硬件接口概述（以UART接口接出的芯片为例）
蓝牙与主控部分硬件接口比较简单，分三部分，如上图框图所示：
UART部分：串口，主要负责数据传输；有其他USB、SDIO、PC card等通信；
PCM部分：语言接口，用于通话时语音数据传输；
Power部分：也就是BT模块的电源控制部分，VDD2.8V、PDN、RST。
1、UART：通用异步收发传输器（UniversalAsynchronous Receiver/Transmitter)
硬件接口比较简单，只有RX、DX。UART0用于trout芯片的debug：
是传输数据的接口，可以传输音频数据和文件数据。
1）、当通过蓝牙和别人互传文件时，就用UART传输。数据传输如下所示:AP通过uart把数据发送到bt芯片中，通过无线发射出去，对方接收到后传给AP侧处理。
2）、当用蓝牙耳机听音乐时，音频信号也由UART传输。
音乐数据通过uart 传送出去，对方耳机接收到后解码播放。如果是录音数据，则同样传回手机端存储。
2、PCM/IIS
（1）、PCM：脉冲编码调制（pulse codemodulation）
是传输语音信号所使用的调制方式。
用途：传输通话时的语音信号。
硬件接口：
（2）、PCM基本工作原理：
脉冲调制就是把一个时间连续,取值连续的模拟信号变换成时间离散,取值离散的数字信号后在信道中传输.脉冲编码调制就是对模拟信号先抽样,再对样值幅度量化,编码的过程。
一个模拟信号经过抽样量化后,得到已量化的脉冲幅度调制信号,它仅为有限个数值。PCM话音信号先经防混叠低通滤波器,进行脉冲抽样,变成8KHz重复频率的抽样信号(即离散的脉冲调幅PAM信号),然后将幅度连续的PAM信号用"四舍五入"办法量化为有限个幅度取值的信号,再经编码后转换成二进制码.对于电话,CCITT规定抽样率为8KHz,每抽样值编8位码,即共有28=256个量化值,因而每话路PCM编码后的标准数码率是64kb/s。
如下图PCM时序：
（3）、IIS(Inter-IC Sound bus)即集成音频接口
IIS只能传输单声道或双声道立体声的数字音频，数据格式为PCM格式。该接口又派生出三类：左对齐格式、右对齐格式、I2S格式。I2S时差性能要优于SPDIF，适合短距离通讯。
IIS总线一般具有4根信号线，如图1所示，包括串行数据输入(IISDI)、串行数据输出(IISD0)、左／右声道选择(IISLRCK)和串行数据时钟(IISCLK)；产生IISLRCK和IISCLK的是主设备。
如下图IIS时序：
语音通话时数据流：语音数据有3G网络接入，通过PCM传递到蓝牙芯片，蓝牙芯片通过2.4G发射出去，到蓝牙耳机接收，同样mic传回的语言数据做相应处理。
（4）、为什么蓝牙用PCM通道（网络参考）
纠正个说法，一般手机cpu到蓝牙的通话实时音频传输才都使用pcm，MP3之类的音频走的是urat/usb之类的其他接口。
真正原因我也不能确定，不过有几个情况可能是原因之一。
（1）、PCM和IIS的区别在于，PCM一般是固定8k的采样率的单声道音频，最早似乎和固定电话的编码有直接关系，之后所有的话音编码几乎都是在PCM编码基础上再次编码得到的。而IIS则多了一个专门的信号线，采样率也可以配置到较高的频率，如44k；
（2）、手机通话时候的编码一般都会被解码成8k采样率的PCM码，高了也没有用。因为本来手机通话的话音频段就是300~3400Hz而已，编码也是按8k采样的。某些手机平台并没有IIS接口，相对来说基本上都会有PCM接口；
（3）、从蓝牙角度讲，蓝牙在制定协议的时候就特意为通话需求制定了一个协议层，专门定义了一种包结构（SCO）用于通话，有很好的实时性。而通过UART传输的包一般为ALC，用分组传输的方式。两种包的编解使用的软硬件都有些区别。sco包支持的基础码率也是8k的pcm.所以一般蓝牙芯片都会有一个PCM接口；
（4）、还一个原因就是，开始大家这么做了，后来就都这么做了，形成行业规范。
3、POWER 控制部分
程序对应引脚按power on /off 时序来完成on/off操作。同其他硬件一样，通过时序控制。
Android bluetooth介绍（二）： android 蓝牙代码架构及其uart 到rfcomm流程
关键词：蓝牙blueZ UART HCI_UART H4 HCI L2CAP RFCOMM
版本：基于android4.2之前版本 bluez
内核：linux/linux3.08
系统：android/android4.1.3.4
作者：xubin341719(欢迎转载，请注明作者，请尊重版权谢谢)
欢迎指正错误，共同学习、共同进步！！
Android bluetooth介绍（一）：基本概念及硬件接口
Android bluetooth介绍（二）： android 蓝牙代码架构及其uart 到rfcomm流程
Android bluetooth介绍（三）： 蓝牙扫描(scan)设备分析
Android bluetooth介绍（四）： a2dp connect流程分析
一、Android Bluetooth Architecture蓝牙代码架构部分(google 官方蓝牙框架)
Android的蓝牙系统，自下而上包括以下一些内容如上图所示：
1、串口驱动
Linux的内核的蓝牙驱动程、Linux的内核的蓝牙协议的层
2、BlueZ的适配器
BlueZ的（蓝牙在用户空间的函式库）
bluez代码结构
Bluetooth协议栈BlueZ分为两部分：内核代码和用户态程序及工具集。
（1）、内核代码：由BlueZ核心协议和驱动程序组成
Bluetooth协议实现在内核源代码 kernel/net/bluetooth中。包括hci,l2cap,hid，rfcomm,sco,SDP,BNEP等协议的实现。
（2）、驱动程序：kernel/driver/bluetooth中,包含Linuxkernel对各种接口的
Bluetooth device的驱动,如：USB接口，串口等。
（3）、用户态程序及工具集：
包括应用程序接口和BlueZ工具集。BlueZ提供函数库以及应用程序接口，便于程序员开发bluetooth应用程序。BlueZ utils是主要工具集，实现对bluetooth设备的初始化和控制。
3、蓝牙相关的应用程序接口
Android.buletooth包中的各个Class（蓝牙在框架层的内容-----java）
类名 | 作用 |
BluetoothAdapter | 本地蓝牙设备的适配类，所有的蓝牙操作都要通过该类完成 |
BluetoothClass | 用于描述远端设备的类型，特点等信息 |
BluetoothDevice | 蓝牙设备类，代表了蓝牙通讯过程中的远端设备 |
BluetoothServerSocket | 蓝牙设备服务端，类似ServerSocket |
BluetoothSocket | 蓝牙设备客户端，类似Socket |
BluetoothClass.Device | 蓝牙关于设备信息 |
BluetoothClass.Device.Major | 蓝牙设备管理 |
BluetoothClass.Service | 蓝牙相关服务 |
同样下图也是一张比较经典的蓝牙代码架构图（google官方提供）
二、蓝牙通过Hciattach启动串口流程：
1、hciattach总体流程
2、展讯hciattach代码实现流程：
三、具体代码分析
1、initrc中定义
idh.code\device\sprd\sp8830ec_nwcn\init.sc8830.rc
- service hciattach /system/bin/hciattach -n /dev/sttybt0 sprd_shark
- socket bluetooth stream 660 bluetooth bluetooth
- user bluetooth
- group wifi bluetooth net_bt_admin net_bt inet net_raw net_admin system
- disabled
- oneshot
adb 下/dev/ttybt0(不同平台有所不同)
PS 进程中：hicattch
2、/system/bin/hciattach 执行的Main函数
idh.code\external\bluetooth\bluez\tools\hciattach.c
service hciattach /system/bin/hciattach -n /dev/sttybt0 sprd_shark
传进两个参数，/dev/sttybt0 和 sprd_shark
- nt main(int argc, char *argv[])
- {
- ………………
- for (n = 0; optind < argc; n++, optind++) {
- char *opt;
- opt = argv[optind];
- switch(n) {
- case 0://（1）、解析驱动的位置；
- dev[0] = 0;
- if (!strchr(opt, '/'))
- strcpy(dev, "/dev/");
- strcat(dev, opt);
- break;
- case 1://（2）、解析串口的配置相关参数；
- if (strchr(argv[optind], ',')) {
- int m_id, p_id;
- sscanf(argv[optind], "%x,%x", &m_id, &p_id);
- u = get_by_id(m_id, p_id);
- } else {
- u = get_by_type(opt);
- }
- if (!u) {
- fprintf(stderr, "Unknown device type or id\n");
- exit(1);
- }
- break;
- case 2://（3）、通过对前面参数的解析，把uart[i]中的数值初始化；
- u->speed = atoi(argv[optind]);
- break;
- case 3:
- if (!strcmp("flow", argv[optind]))
- u->flags |= FLOW_CTL;
- else
- u->flags &= ~FLOW_CTL;
- break;
- case 4:
- if (!strcmp("sleep", argv[optind]))
- u->pm = ENABLE_PM;
- else
- u->pm = DISABLE_PM;
- break;
- case 5:
- u->bdaddr = argv[optind];
- break;
- }
- }
- ………………
- if (init_speed)//初始化串口速率；
- u->init_speed = init_speed;
- ………………
- n = init_uart(dev, u, send_break, raw);//（4）、初始化串口；
- ………………
- return 0;
- }
（1）、解析驱动的位置；
- if (!strchr(opt, '/'))
- strcpy(dev, "/dev/");
- service hciattach /system/bin/hciattach -n /dev/sttybt0 sprd_shark
- dev = /dev/ttyb0
（2）、解析串口的配置相关参数；获取参数对应的结构体；
- u = get_by_id(m_id, p_id);
- static struct uart_t * get_by_id(int m_id, int p_id)
- {
- int i;
- for (i = 0; uart[i].type; i++) {
- if (uart[i].m_id == m_id && uart[i].p_id == p_id)
- return &uart[i];
- }
- return NULL;
- }
这个函数比较简单，通过循环对比，如传进了的参数sprd_shark和uart结构体中的对比，找到对应的数组。如果是其他蓝牙芯片，如博通、RDA、BEKN等着到其相对应的初始化配置函数。
- struct uart_t uart[] = {
- { "any", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,
- FLOW_CTL, DISABLE_PM, NULL, NULL },
- { "sprd_shark", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,
- FLOW_CTL, DISABLE_PM, NULL, init_sprd_config },
- { "ericsson", 0x0000, 0x0000, HCI_UART_H4, 57600, 115200,
- FLOW_CTL, DISABLE_PM, NULL, ericsson },
- ………………
- { "bk3211", 0x0000, 0x0000, HCI_UART_BCSP, 115200, 921600, 0, DISABLE_PM, NULL, beken_init, NULL},
- { NULL, 0 }
- };
注意：init_sprd_config这个函数在uart_init中用到，这个函数其实对我们具体芯片的初始化配置。
注释：HCI_UART_H4和HCI_UART_BCSP的区别如下图。
（3）、通过对前面参数的解析，把uart[i]中的数值初始化；
- u->speed = atoi(argv[optind]);
- break;
（4）、初始化串口；
- n = init_uart(dev, u, send_break, raw);
- idh.code\external\bluetooth\bluez\tools\hciattach.c
- /* Initialize UART driver */
- int init_uart(char *dev, struct uart_t *u, int send_break)
- {
- struct termios ti;
- int fd, i;
- fd = open(dev, O_RDWR | O_NOCTTY);//打开串口设备，其中标志
- //O_RDWR,可以对此设备进行读写操作；
- //O_NOCTTY：告诉Unix这个程序不想成为“控制终端”控制的程序，不说明这个标志的话，任何输入都会影响你的程序。
- //O_NDELAY：告诉Unix这个程序不关心DCD信号线状态，即其他端口是否运行，不说明这个标志的话，该程序就会在DCD信号线为低电平时停止。
- //但是不要以控制 tty 的模式，因为我们并不希望在发送 Ctrl-C
- 后结束此进程
- if (fd < 0) {
- perror(“Can’t open serial port”);
- return -1;
- }
- //drop fd’s data;
- tcflush(fd, TCIOFLUSH);//清空数据线
- if (tcgetattr(fd, &ti) < 0) {
- perror(“Can’t get port settings”);
- return -1;
- }
- cfmakeraw(&ti);
- cfmakeraw sets the terminal attributes as follows://此函数设置串口终端的以下这些属性，
- termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
- |INLCR|IGNCR|ICRNL|IXON);
- termios_p->c_oflag &= ~OPOST;
- termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
- termios_p->c_cflag &= ~(CSIZE|PARENB) ;
- termios_p->c_cflag |=CS8;
- ti.c_cflag |= CLOCAL;//本地连接，无调制解调器控制
- if (u->flags & FLOW_CTL)
- ti.c_cflag |= CRTSCTS;//输出硬件流控
- else
- ti.c_cflag &= ~CRTSCTS;
- if (tcsetattr(fd, TCSANOW, &ti) < 0) {//启动新的串口设置
- perror(“Can’t set port settings”);
- return -1;
- }
- /* Set initial baudrate */
- if (set_speed(fd, &ti, u->init_speed) < 0) {//设置串口的传输速率bps, 也可以使
- //用 cfsetispeed 和 cfsetospeed 来设置
- perror(“Can’t set initial baud rate”);
- return -1;
- }
- tcflush(fd, TCIOFLUSH);//清空数据线
- if (send_break)
- tcsendbreak(fd, 0);
- //int tcsendbreak ( int fd, int duration );Sends a break for
- //the given time.在串口线上发送0值，至少维持0.25秒。
- //If duration is 0, it transmits zero-valued bits for at least 0.25 seconds, and
- //not more than 0.5seconds.
- //where place register u’s init function;
- if (u->init && u->init(fd, u, &ti) < 0)
- //所有bluez支持的蓝牙串口设备类型构成了一个uart结构数组，通过
- //查找对应的uart类型，这个uart的init成员显示了它的init调用方法；
- struct uart_t uart[] = {
- { "any", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,FLOW_CTL, DISABLE_PM, NULL, NULL },
- { "sprd_shark", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,FLOW_CTL, DISABLE_PM, NULL, init_sprd_config },
- { "ericsson", 0x0000, 0x0000, HCI_UART_H4, 57600, 115200,FLOW_CTL, DISABLE_PM, NULL, ericsson },
- ………………
- { "bk3211", 0x0000, 0x0000, HCI_UART_BCSP, 115200, 921600, 0, DISABLE_PM, NULL, beken_init, NULL},
- { NULL, 0的init函数名为bcsp,定义在本文件中＊＊；
- return -1;
- tcflush(fd, TCIOFLUSH);//清空数据线
- /* Set actual baudrate */
- if (set_speed(fd, &ti, u->speed) < 0) {
- perror(“Can’t set baud rate”);
- return -1;
- }
- /* Set TTY to N_HCI line discipline */
- i = N_HCI;
- if (ioctl(fd, TIOCSETD, &i) < 0) {//
- TIOCSETD int *ldisc//改变到 i 行规，即hci行规
- Change to the new line discipline pointed to by ldisc. The available line disciplines are listed in
- /* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
- /* line disciplines */
- #define N_TTY 0
- ……
- #define N_HCI 15 /* Bluetooth HCI UART */
- perror(“Can’t set line discipline”);
- return -1;
- }
- if (ioctl(fd, HCIUARTSETPROTO, u->proto) < 0) {
- //设置hci设备的proto操作函数集为hci_uart操作集；
- perror(“Can’t set device”);
- return -1;
- }
- return fd;
- }
这里一个重要的部分是：u->init指向init_sprd_config
4、uart具体到芯片的初始化init_sprd_config（这部分根据不同的芯片，对应进入其相应初始化部分）
idh.code\external\bluetooth\bluez\tools\hciattach_sprd.c
- int sprd_config_init(int fd, char *bdaddr, struct termios *ti)
- {
- int i,psk_fd,fd_btaddr,ret = 0,r,size=0,read_btmac=0;
- unsigned char resp[30];
- BT_PSKEY_CONFIG_T bt_para_tmp;
- char bt_mac[30] = {0};
- char bt_mac_tmp[20] = {0};
- uint8 bt_mac_bin[32] = {0};
- fprintf(stderr,"init_sprd_config in \n");
- //（1）、这部分检查bt_mac，如果存在，从文件中读取，如果不存在，随机生成，并写入相应文件；
- if(access(BT_MAC_FILE, F_OK) == 0) {//这部分检查bt_mac
- LOGD("%s: %s exists",__FUNCTION__, BT_MAC_FILE);
- fd_btaddr = open(BT_MAC_FILE, O_RDWR);// #define BT_MAC_FILE "/productinfo/btmac.txt"
- if(fd_btaddr>=0) {
- size = read(fd_btaddr, bt_mac, sizeof(bt_mac));//读取BT_MAC_FILE中的地址；
- LOGD("%s: read %s %s, size=%d",__FUNCTION__, BT_MAC_FILE, bt_mac, size);
- if(size == BT_RAND_MAC_LENGTH){
- LOGD("bt mac already exists, no need to random it");
- fprintf(stderr, "read btmac ok \n");
- read_btmac=1;
- }
- …………
- }else{//如果不存在，就随机生成一个bt_mac地址，写入/productinfo/btmac.txt
- fprintf(stderr, "btmac.txt not exsit!\n");
- read_btmac=0;
- mac_rand(bt_mac);
- LOGD("bt random mac=%s",bt_mac);
- printf("bt_mac=%s\n",bt_mac);
- write_btmac2file(bt_mac);
- fd_btaddr = open(BT_MAC_FILE, O_RDWR);
- if(fd_btaddr>=0) {
- size = read(fd_btaddr, bt_mac, sizeof(bt_mac));
- LOGD("%s: read %s %s, size=%d",__FUNCTION__, BT_MAC_FILE, bt_mac, size);
- if(size == BT_RAND_MAC_LENGTH){
- LOGD("bt mac already exists, no need to random it");
- fprintf(stderr, "read btmac ok \n");
- read_btmac=1;
- }
- close(fd_btaddr);
- …………
- }
- /* Reset the BT Chip */
- memset(resp, 0, sizeof(resp));
- memset(&bt_para_tmp, 0, sizeof(BT_PSKEY_CONFIG_T) );
- ret = getPskeyFromFile( (void *)(&bt_para_tmp) );//ret = get_pskey_from_file(&bt_para_tmp);//（2）、PSKey参数、射频参数的设定；
- if(ret != 0){//参数失败处理
- fprintf(stderr, "get_pskey_from_file faill \n");
- /* Send command from hciattach*/
- if(read_btmac == 1){
- memcpy(bt_para_setting.device_addr, bt_mac_bin, sizeof(bt_para_setting.device_addr));// （3）、读取失败，把bt_para_setting中defaut参数写入；
- }
- if (write(fd, (char *)&bt_para_setting, sizeof(BT_PSKEY_CONFIG_T)) != sizeof(BT_PSKEY_CONFIG_T)) {
- fprintf(stderr, "Failed to write reset command\n");
- return -1;
- }
- }else{//getpskey成功处理
- /* Send command from pskey_bt.txt*/
- if(read_btmac == 1){
- memcpy(bt_para_tmp.device_addr, bt_mac_bin, sizeof(bt_para_tmp.device_addr));
- }
- …………
- return 0;
- }
（1）、这部分检查bt_mac，如果存在，从文件中读取，如果不存在，随机生成，并写入相应文件/productinfo/btmac.txt；
（2）、PSKey参数、射频参数的设定；
get_pskey_from_file(&bt_para_tmp);这个函数后面分析；
（3）、读取失败，把bt_para_setting中defaut参数写入；频率、主从设备设定等……
- // pskey file structure default value
- BT_PSKEY_CONFIG_T bt_para_setting={
- 5,
- 0,
- 0,
- 0,
- 0,
- 0x18cba80,
- 0x001f00,
- 0x1e,
- {0x7a00,0x7600,0x7200,0x5200,0x2300,0x0300},
- …………
- };
5、get_pskey_from_file 解析相关射频参数
idh.code\external\bluetooth\bluez\tools\pskey_get.c
- int getPskeyFromFile(void *pData)
- {
- …………
- char *BOARD_TYPE_PATH = "/dev/board_type";//（1）、判断PCB的版本；
- int fd_board_type;
- char board_type_str[MAX_BOARD_TYPE_LEN] = {0};
- int board_type;
- char *CFG_2351_PATH_2 = "/productinfo/2351_connectivity_configure.ini";//（2）、最终生成ini文件存储的位置；
- char *CFG_2351_PATH[MAX_BOARD_TYPE];
- （3）、针对不同PCB版本，不同的ini配置文件；
- CFG_2351_PATH[0] = "/system/etc/wifi/2351_connectivity_configure_hw100.ini";
- CFG_2351_PATH[1] = "/system/etc/wifi/2351_connectivity_configure_hw102.ini";
- CFG_2351_PATH[2] = "/system/etc/wifi/2351_connectivity_configure_hw104.ini";
（4）、下面函数就不做具体分析，大致意识是，根据/dev/board_type中，读取的PCB类型，设置不同的ini文件。
- ………………
- ret = chmod(CFG_2351_PATH_2, 0644);
- ALOGE("chmod 0664 %s ret:%d\n", CFG_2351_PATH_2, ret);
- if(pBuf == pBuf2)
- free(pBuf1);
- ………………
- }
（1）、判断PCB的版本；
char *BOARD_TYPE_PATH = "/dev/board_type";
（2）、最终生成ini文件存储的位置，就是系统运行时读取ini文件的地方；
char *CFG_2351_PATH_2 ="/productinfo/2351_connectivity_configure.ini";
（3）、针对不同PCB版本，不同的ini配置文件；
- CFG_2351_PATH[0] = "/system/etc/wifi/2351_connectivity_configure_hw100.ini";
- CFG_2351_PATH[1] = "/system/etc/wifi/2351_connectivity_configure_hw102.ini";
- CFG_2351_PATH[2] = "/system/etc/wifi/2351_connectivity_configure_hw104.ini";
（4）、下面函数就不做具体分析，大致意识是，根据/dev/board_type中，读取的PCB类型，设置不同的ini文件。 覆盖到（2）中的文件。
四、HCI_UART_H4和H4层的加入
uart->hci_uart->Uart-H4->hci:从uart开始分析，介绍整个驱动层数据流(涉及tty_uart中断, 线路层ldisc_bcsp、tasklet、work queue、skb_buffer的等)
这是数据的流动过程，最底层的也就是和硬件打交道的是uart层了，它的存在和起作用是通过串口驱动来保证的，这个请参阅附录,但是其它的层我们都不知道什么时候work的，下面来看。
1、idh.code\kernel\drivers\bluetooth\hci_ldisc.c
- static int __init hci_uart_init(void)
- {
- static struct tty_ldisc_ops hci_uart_ldisc;
- int err;
- /* Register the tty discipline */
- memset(&hci_uart_ldisc, 0, sizeof (hci_uart_ldisc));
- hci_uart_ldisc.magic = TTY_LDISC_MAGIC;
- hci_uart_ldisc.name = "n_hci";
- hci_uart_ldisc.open = hci_uart_tty_open;
- hci_uart_ldisc.close = hci_uart_tty_close;
- hci_uart_ldisc.read = hci_uart_tty_read;
- hci_uart_ldisc.write = hci_uart_tty_write;
- hci_uart_ldisc.ioctl = hci_uart_tty_ioctl;
- hci_uart_ldisc.poll = hci_uart_tty_poll;
- hci_uart_ldisc.receive_buf = hci_uart_tty_receive;
- hci_uart_ldisc.write_wakeup = hci_uart_tty_wakeup;
- hci_uart_ldisc.owner = THIS_MODULE;
- if ((err = tty_register_ldisc(N_HCI, &hci_uart_ldisc))) {//（1）、这部分完成ldisc的注册；
- BT_ERR("HCI line discipline registration failed. (%d)", err);
- return err;
- }
- #ifdef CONFIG_BT_HCIUART_H4
- h4_init();//（2）、我们蓝牙芯片用的是H4，这部分完成H4的注册；
- #endif
- #ifdef CONFIG_BT_HCIUART_BCSP
- bcsp_init();
- #endif
- ………………
- return 0;
- }
（1）、这部分完成ldisc的注册；
tty_register_ldisc(N_HCI,&hci_uart_ldisc)
注册了一个ldisc，这是通过把新的ldisc放在一个ldisc的数组里面实现的，tty_ldiscs是一个全局的ldisc数组里面会根据序号对应一个ldisc，这个序号就是上层通过ioctl来指定的，比如我们在前面已经看到的：
i = N_HCI;
ioctl(fd, TIOCSETD, &i) < 0
可以看到这里指定的N_HCI刚好就是这里注册的这个号码15；
（2）、蓝牙芯片用的是H4，这部分完成H4的注册；
h4_init();
hci_uart_proto结构体的初始化：
idh.code\kernel\drivers\bluetooth\hci_h4.c
- static struct hci_uart_proto h4p = {
- .id = HCI_UART_H4,
- .open = h4_open,
- .close = h4_close,
- .recv = h4_recv,
- .enqueue = h4_enqueue,
- .dequeue = h4_dequeue,
- .flush = h4_flush,
- };
H4的注册：
idh.code\kernel\drivers\bluetooth\hci_h4.c
- int __init h4_init(void)
- {
- int err = hci_uart_register_proto(&h4p);
- if (!err)
- BT_INFO("HCI H4 protocol initialized");
- else
- BT_ERR("HCI H4 protocol registration failed");
- return err;
- }
这是通过hci_uart_register_proto(&bcsp)来完成的，这个函数非常简单，本质如下：
hup[p->id]= p;其中static struct hci_uart_proto*hup[HCI_UART_MAX_PROTO];也就是说把对应于协议p的id和协议p连接起来，这样设计的好处是hci uart层本身可以支持不同的协议，包括h4、bcsp等，通过这个数组连接这些协议，等以后有数据的时候调用对应的协议来处理，这里比较关键的是h4里面的这些函数。
五、HCI层的加入
hci的加入是通过hci_register_dev函数来做的，这时候用户通过hciconfig就可以看到有一个接口了，通过这个接口用户可以访问底层的信息了，hci0已经生成；至于它在何时被加入的，我们再看看hciattach在内核里面的处理过程；
1、TIOCSEATD的处理流程
Ioctl的作用是设置一个新的ldisc;
2、HCIUARTSETPROTO的处理流程：
这部分比较重要，注册生成hci0, 初始化3个工作队列，hci_rx_work、hci_tx_work、hci_cmd_work;完成hci部分数据、命令的接收、发送。
六、数据在驱动的传递流程
1、uart数据接收
这部分流程比较简单，其实就是注册一个tty驱动程序和相对应的函数，注册相应的open\close\ioctl等方法，通过应用open /dev/ttyS*操作，注册中断接收函数，接收处理蓝牙模块触发中断的数据。
在这个中断函数里面会接受到来自于蓝牙模块的数据；在中断函数里面会先读取串口的状态寄存器判断是否是data准备好，如果准备好就调用serial_sprd_rx_chars函数来接收数据，下面看看这个函数是如何处理的：
那就是把数据一个个的加入到uart层的缓冲区，直到底层不处于dataready状态，或者读了maxcount个数，当读完后就调用tty层的接口把数据传递给tty层，tty层则把数据交给了ldisc，于是控制权也就交给了hci_uart层；
七、Hci_uart的数据接收
它基本上就是要个二传手，通过：
- spin_lock(&hu->rx_lock);
- hu->proto->recv(hu,(void *) data, count);
- hu->hdev->stat.byte_rx+= count;
- spin_unlock(&hu->rx_lock);
八、H4层处理
这层主要是通过函数h4_recv来处理的，根据协议处理包头、CRC等，然后调用更上层的hci_recv_frame来处理已经剥去h4包头的数据；
如图：
九、HCI以上的处理
这里的hci_rx_work前面已经看到它了，它是一个工作队列用来处理hci层的数据接收的；先看是否有进程打开hci的socket用来监听数据，如果有的话，就把数据的一个copy发送给它，然后根据包的类型调用不同的处理函数，分别对应于event、acl、sco处理；
hci_event_packet是对于事件的处理，里面包含有包括扫描，信号，授权，pin码，总之基本上上层所能收到的事件，基本都是在这里处理的，它的很多信息都是先存起来，等待上层的查询然后才告诉上层；
hci_acldata_packet是一个经常的情况，也就是说上层通常都是使用的是l2cap层的接口，而l2cap就是基于这个的，如下图所示：
到这里如果有基于BTPROTO_L2CAP的socket，那么这个socket就可以收到数据了；再看看BTPROTO_RFCOMM的流程：
十、 数据流程的总结
简单总结一下，数据的流程，
|基本上是：
1， uart口取得蓝牙模块的数据；
2， uart口通过ldisc传给hci_uart；
3， hci_uart传给在其上的h4；
4， h4传给hci层；
5， hci层传给l2cap层
6， l2cap层再传给rfcomm；
Android bluetooth介绍（三）： 蓝牙扫描(scan)设备分析
关键词：蓝牙blueZ A2DP、SINK、sink_connect、sink_disconnect、sink_suspend、sink_resume、sink_is_connected、sink_get_properties、AUDIO、DBUS
版本：基于android4.2之前版本 bluez
内核：linux/linux3.08
系统：android/android4.1.3.4
作者：xubin341719(欢迎转载，请注明作者，请尊重版权谢谢)
欢迎指正错误，共同学习、共同进步！！
参考网站：
http://blog.csdn.net/u011960402/article/details/17216563
http://www.cnblogs.com/fityme/archive/2013/04/13/3019471.html socket相关
http://hi.baidu.com/wwwkljoel/item/a35e5745d14e02e6bcf45170 setsockopt
Android bluetooth介绍（一）：基本概念及硬件接口
Android bluetooth介绍（二）： android 蓝牙代码架构及其uart 到rfcomm流程
Android bluetooth介绍（三）： 蓝牙扫描(scan)设备分析
Android bluetooth介绍（四）： a2dp connect流程分析
一、蓝牙扫描常用的方法：
蓝牙扫描的可以通过两种途径实现：命令行hciitool扫描；Android界面触发，通过JNI、DUBS下发命令。
1、 命令行hciitool扫描（这部分通过Linux命令操作，跟android没有关系）
通过bluez的tool发送扫描命令，如：hcitoool scan
adb shell 下#hcitool scan扫描结果
Hcitool扫描逻辑如下所示：
2、Android界面触发，通过JNI、DUBS下发命令：通过android界面点击搜索设备
应用扫描触发逻辑流程：自上而下三种颜色，分别代表应用部分、JNI部分、linux blueZ部分。
1、hcitool这部分代码比较简单，实现函数
idh.code\external\bluetooth\bluez\tools\hcitool.c代码大致流程如下：
通过所带的参数，找到cmd_scan,进入hci_inquriy。这个函数中创建一个BTPROTO_HCI的socket,通过ioctlHCINQUIRY向内核读取数据，保存返回信息。
2、内核层逻辑：
当然IOCTL只是其中一项。
idh.code\kernel\net\bluetooth\ hci_sock.c
- static const struct proto_ops hci_sock_ops = {
- …………
- .ioctl = hci_sock_ioctl,
- .poll = datagram_poll,
- .listen = sock_no_listen,
- …………
- };
它的流程就是构造查询命令，放入命令队列，调度队列来发送命令，其中hci_send_frame后面会讲解，这里关键是命令的发送和数据的收集是分开的，所以它在里面会放弃2s的调度，以此来等待数据的收集，收集的数据放在hdev->inq_cache里面，我们来看看这个数据是如何取得的，如下图所示：
入口点hci_rx_work前面已经详细分析过了，这里就不说了，它里面会根据不同的事件类型做不同的处理，通常情况下，扫描都是带信号强度的扫描，所以走的hci_inquiry_result_with_rssi_evt路线，还有其它几种扫描方式，比如：HCI_EV_INQUIRY_RESULT，HCI_EV_EXTENDED_INQUIRY_RESULT等，处理逻辑都差不多的，里面会hci_inquiry_cache_update来把结果放到hdev->discovery链表里面去，供后面的查询；比如前面调用的inquiry_cache_dump函数就可以从这个链表里面把数据取出来，然后copy到用户层；
三、Android界面触发，通过JNI、DUBS下发命令
整体流程如下所示：
（一）、应用部分：
1、 idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\DeviceListPreferenceFragment.java
- @Override
- public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
- Preference preference) {
- …………
- mLocalAdapter.startScanning(true);
- return true;
- }
2、 idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\LocalBluetoothAdapter.java
- private final BluetoothAdapter mAdapter;
- void startScanning(boolean force) {
- // Only start if we're not already scanning
- if (!mAdapter.isDiscovering()) {
- if (!force) {
- // Don't scan more than frequently than SCAN_EXPIRATION_MS,
- // unless forced
- if (mLastScan + SCAN_EXPIRATION_MS > System.currentTimeMillis()) {
- return;
- }
- // If we are playing music, don't scan unless forced.
- A2dpProfile a2dp = mProfileManager.getA2dpProfile();
- if (a2dp != null && a2dp.isA2dpPlaying()) {
- return;
- }
- }
- if (mAdapter.startDiscovery()) {
- mLastScan = System.currentTimeMillis();
- }
- }
- }
3、idh.code\frameworks\base\core\java\android\bluetooth\BluetoothAdapter.java
- public boolean startDiscovery() {
- if (getState() != STATE_ON) return false;
- try {
- return mService.startDiscovery();
- } catch (RemoteException e) {Log.e(TAG, "", e);}
- return false;
- }
4、JNI函数的调用idh.code\frameworks\base\core\java\android\server\BluetoothService.java
- private native boolean startDiscoveryNative();//Native函数声明
- public class BluetoothService extends IBluetooth.Stub {
- private static final String TAG = "BluetoothService";
- private static final boolean DBG = true;
- …………
- public synchronized boolean startDiscovery() {
- mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
- "Need BLUETOOTH_ADMIN permission");
- if (!isEnabledInternal()) return false;
- return startDiscoveryNative();
- }
- ………………
- }
（二）、JNI部分：
1、android_server_BluetoothService.cpp中JNI函数的对照表
idh.code\frameworks\base\core\jni\android_server_BluetoothService.cpp
- static JNINativeMethod sMethods[] = {
- /* name, signature, funcPtr */
- ………………
- {"startDiscoveryNative", "()Z", (void*)startDiscoveryNative},
- {"stopDiscoveryNative", "()Z", (void *)stopDiscoveryNative},
- …………
- }
2、对应Native函数的实现
这里面有个知识点DBUS，这个后面我们单独去讲解
idh.code\frameworks\base\core\jni\android_server_BluetoothService.cpp
- #define BLUEZ_DBUS_BASE_IFC "org.bluez"
- #define DBUS_ADAPTER_IFACE BLUEZ_DBUS_BASE_IFC ".Adapter"//其实DBUS_ADAPTER_IFACE 也就是 org.bluez.Adapter
- static jboolean startDiscoveryNative(JNIEnv *env, jobject object) {
- ………………
- /* Compose the command */
- msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC,
- get_adapter_path(env, object),
- DBUS_ADAPTER_IFACE, "StartDiscovery");
- …………
- }
- Native函数startDiscoveryNative和字符串StartDiscovery对应。
（三）、DBUS部分
1、DBUS对应方法的实现，这里跟JNI部分比较类似，也是用了函数结构体对应关系。
idh.code\external\bluetooth\bluez\src\adapter.c
- #define ADAPTER_INTERFACE "org.bluez.Adapter"
- static GDBusMethodTable adapter_methods[] = {
- ………………
- { "ReleaseSession", "", "", release_session },
- { "StartDiscovery", "", "", adapter_start_discovery },
- { "StopDiscovery", "", "", adapter_stop_discovery,
- G_DBUS_METHOD_FLAG_ASYNC},
- ………………
- }
字符StartDiscovery又对应C中的实现函数adapter_start_discovery。
2、adapter_start_discovery的实现
idh.code\external\bluetooth\bluez\src\adapter.c
- static DBusMessage *adapter_start_discovery(DBusConnection *conn,
- DBusMessage *msg, void *data)
- {
- …………
- err = start_discovery(adapter);
- if (err < 0 && err != -EINPROGRESS)
- return btd_error_failed(msg, strerror(-err));
- done:
- req = create_session(adapter, conn, msg, 0,
- session_owner_exit);
- adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
- return dbus_message_new_method_return(msg);
- }
3、 start_discovery调用
idh.code\external\bluetooth\bluez\src\adapter.c
- const struct btd_adapter_ops *adapter_ops = NULL;
- static int start_discovery(struct btd_adapter *adapter)
- {
- …………
- pending_remote_name_cancel(adapter);
- return adapter_ops->start_discovery(adapter->dev_id);
- }
adapter_ops对应结构体btd_adapter_ops中对应函数，如下：上面部分就对应到btd_adapter_ops中的hci_ops结构体。
4、btd_adapter_ops中的hci_ops结构体
idh.code\external\bluetooth\bluez\plugins\hciops.c
- static struct btd_adapter_ops hci_ops = {
- …………
- .set_powered = hciops_set_powered,
- .set_discoverable = hciops_set_discoverable,
- .set_pairable = hciops_set_pairable,
- .set_limited_discoverable = hciops_set_limited_discoverable,
- .start_discovery = hciops_start_discovery,
- .stop_discovery = hciops_stop_discovery,
- ………………
- .create_bonding = hciops_create_bonding,
- .cancel_bonding = hciops_cancel_bonding,
- .read_local_oob_data = hciops_read_local_oob_data,
- .add_remote_oob_data = hciops_add_remote_oob_data,
- .remove_remote_oob_data = hciops_remove_remote_oob_data,
- .set_link_timeout = hciops_set_link_timeout,
- .retry_authentication = hciops_retry_authentication,
- };
5、hciops_start_discovery函数的实现
idh.code\external\bluetooth\bluez\plugins\hciops.c
- static int hciops_start_discovery(int index)
- {
- int adapter_type = get_adapter_type(index);
- switch (adapter_type) {
- case BR_EDR_LE:
- return hciops_start_inquiry(index, LENGTH_BR_LE_INQ);
- case BR_EDR: //蓝牙芯片为2.1+EDR的
- return hciops_start_inquiry(index, LENGTH_BR_INQ);
- case LE_ONLY:
- return hciops_start_scanning(index, TIMEOUT_LE_SCAN);
- default:
- return -EINVAL;
- }
- }
6、hciops_start_inquiry
idh.code\external\bluetooth\bluez\plugins\hciops.c
- static int hciops_start_inquiry(int index, uint8_t length)
- {
- struct dev_info *dev = &devs[index];
- uint8_t lap[3] = { 0x33, 0x8b, 0x9e };
- inquiry_cp inq_cp;
- DBG("hci%d length %u", index, length);
- memset(&inq_cp, 0, sizeof(inq_cp));
- memcpy(&inq_cp.lap, lap, 3);
- inq_cp.length = length;
- inq_cp.num_rsp = 0x00;
- if (hci_send_cmd(dev->sk, OGF_LINK_CTL,
- OCF_INQUIRY, INQUIRY_CP_SIZE, &inq_cp) < 0)
- return -errno;
- return 0;
- }
7、idh.code\external\bluetooth\bluez\lib\hci.c
- /* HCI functions that require open device
- * dd - Device descriptor returned by hci_open_dev. */
- dd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
- int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param)
- {
- ………………
- if (plen) {
- iv[2].iov_base = param;
- iv[2].iov_len = plen;
- ivn = 3;
- }
- while (writev(dd, iv, ivn) < 0) {//writev这里把数据写到socket里面。
- if (errno == EAGAIN || errno == EINTR)
- continue;
- return -1;
- }
- return 0;
- }
（四）、内核部分：
1、HCI FILTER的设置
HCIsocket的类型为BTPROTO_HCI。上层调用setsockopt的时候，触发了内核的hci_sock_setsockopt函数的执行，在这里面设置了socket的filter特性，包括包类型，包括事件类型；
当上层调用setsockopt(sock, SOL_HCI, HCI_FILTER,&flt, sizeof(flt))时，触发相应的内核路径。
idh.code\kernel\net\bluetooth\hci_sock.c
- static const struct proto_ops hci_sock_ops = {
- .family = PF_BLUETOOTH,
- .owner = THIS_MODULE,
- …………
- .shutdown = sock_no_shutdown,
- .setsockopt = hci_sock_setsockopt,
- .getsockopt = hci_sock_getsockopt,
- .connect = sock_no_connect,
- …………
- };
idh.code\kernel\net\bluetooth\hci_sock.c
- static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len)
- {
- ………………
- case HCI_FILTER:
- {
- struct hci_filter *f = &hci_pi(sk)->filter;
- uf.type_mask = f->type_mask;
- uf.opcode = f->opcode;
- uf.event_mask[0] = *((u32 *) f->event_mask + 0);
- uf.event_mask[1] = *((u32 *) f->event_mask + 1);
- }
- ………………
- }<span style="font-weight:bold;">
- </span>
内核这部分就比较统一的数据，通过hci_send_cmd把命令发出去，HCI_FILTER这个地方的处理还没理解，后面补充。
Writev函数通过socket把数据写下去，经过VFS层，调用到内核空间的sendmsg函数。
（五）、EVENT返回状态
Controller收到查询命令后，返回一个命令状态
1、cmd_status
idh.code\external\bluetooth\bluez\plugins\hciops.c
- switch (eh->evt) {
- case EVT_CMD_STATUS:
- cmd_status(index, ptr);
- break;
- static inline void cmd_status(int index, void *ptr)
- {
- evt_cmd_status *evt = ptr;
- uint16_t opcode = btohs(evt->opcode);
- if (opcode == cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY))//如果是inquriy做特殊处理；
- cs_inquiry_evt(index, evt->status);
- }
2、cs_inquiry_evt的实现 idh.code\external\bluetooth\bluez\plugins\hciops.c
- static inline void cs_inquiry_evt(int index, uint8_t status)
- {
- if (status) {//错误信息
- error("Inquiry Failed with status 0x%02x", status);
- return;
- }
- set_state(index, DISCOV_INQ);//设置状态为INQ，向上层回复discoverying的property change
- }
3、设置不同的DISCOV 状态 idh.code\external\bluetooth\bluez\plugins\hciops.c
- static void set_state(int index, int state)
- {
- ………………
- switch (dev->discov_state) {
- case DISCOV_HALTED://停止发现;
- if (adapter_get_state(adapter) == STATE_SUSPENDED)
- return;
- if (is_resolvname_enabled() &&
- adapter_has_discov_sessions(adapter))
- adapter_set_state(adapter, STATE_RESOLVNAME);
- else
- adapter_set_state(adapter, STATE_IDLE);
- break;
- case DISCOV_INQ:
- case DISCOV_SCAN://扫描发现；
- adapter_set_state(adapter, STATE_DISCOV);
- break;
- }
- }
4、设置adapter的状态 idh.code\external\bluetooth\bluez\src\adapter.c
- idh.code\external\bluetooth\bluez\src\adapter.c
- #define ADAPTER_INTERFACE "org.bluez.Adapter"
- void adapter_set_state(struct btd_adapter *adapter, int state)
- {
- …………
- case STATE_DISCOV:
- discov_active = TRUE;
- //向上层回复discovering的property change
- emit_property_changed(connection, path,
- ADAPTER_INTERFACE, "Discovering",
- DBUS_TYPE_BOOLEAN, &discov_active);
- break;
- …………
- }
emit_property_changed发送PropertyChanged的消息，消息内容为Discovering。通知上层BluetoothEventLoop进行Discovering。
5、emit_property_changed发送Discovering消息的实现 idh.code\external\bluetooth\bluez\src\dbus-common.c
这部分涉及到DBUS内容
- dbus_bool_t emit_property_changed(DBusConnection *conn,
- const char *path,
- const char *interface,
- const char *name,
- int type, void *value)
- {
- DBusMessage *signal;
- DBusMessageIter iter;
- signal = dbus_message_new_signal(path, interface, "PropertyChanged"); // 创建消息对象并标识路径
- if (!signal) {
- error("Unable to allocate new %s.PropertyChanged signal",
- interface);
- return FALSE;
- }
- dbus_message_iter_init_append(signal, &iter);//把信号相对应的参数压进去
- dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);//申请一个首地址，把前面压入的参数传入这个首地址
- append_variant(&iter, type, value);//
- return g_dbus_send_message(conn, signal);//启动发送调用，并释放发送相关消息信息
- }
6、DBUS消息接收的实现 idh.code\frameworks\base\core\jni\android_server_BluetoothEventLoop.cpp
- // Called by dbus during WaitForAndDispatchEventNative()
- static DBusHandlerResult event_filter(DBusConnection *conn, DBusMessage *msg,
- void *data) {
- …………
- else if (dbus_message_is_signal(msg, "org.bluez.Adapter", "PropertyChanged")) {
- jobjectArray str_array = parse_adapter_property_change(env, msg);//（1）、对收到消息的解析
- if (str_array != NULL) {
- /* Check if bluetoothd has (re)started, if so update the path. */
- jstring property =(jstring) env->GetObjectArrayElement(str_array, 0);
- const char *c_property = env->GetStringUTFChars(property, NULL);
- if (!strncmp(c_property, "Powered", strlen("Powered"))) {
- jstring value =
- (jstring) env->GetObjectArrayElement(str_array, 1);
- const char *c_value = env->GetStringUTFChars(value, NULL);
- if (!strncmp(c_value, "true", strlen("true")))
- nat->adapter = get_adapter_path(nat->conn);
- env->ReleaseStringUTFChars(value, c_value);
- }
- env->ReleaseStringUTFChars(property, c_property);
- env->CallVoidMethod(nat->me,
- method_onPropertyChanged,//（2）、
- method_onPropertyChanged NATVIE函数的实现
- str_array);
- } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
- goto success;
- }
（1）、对收到消息的解析 idh.code\frameworks\base\core\jni\android_bluetooth_common.cpp
- jobjectArray parse_adapter_property_change(JNIEnv *env, DBusMessage *msg) {
- return parse_property_change(env, msg, (Properties *) &adapter_properties,
- sizeof(adapter_properties) / sizeof(Properties));
- }
针对org.bluez.Adapter不同的消息类型
idh.code\frameworks\base\core\jni\android_bluetooth_common.cpp
- static Properties adapter_properties[] = {
- {"Address", DBUS_TYPE_STRING},
- {"Name", DBUS_TYPE_STRING},
- {"Class", DBUS_TYPE_UINT32},
- {"Powered", DBUS_TYPE_BOOLEAN},
- {"Discoverable", DBUS_TYPE_BOOLEAN},
- {"DiscoverableTimeout", DBUS_TYPE_UINT32},
- {"Pairable", DBUS_TYPE_BOOLEAN},
- {"PairableTimeout", DBUS_TYPE_UINT32},
- {"Discovering", DBUS_TYPE_BOOLEAN},
- {"Devices", DBUS_TYPE_ARRAY},
- {"UUIDs", DBUS_TYPE_ARRAY},
- };
（2）、method_onPropertyChanged NATVIE函数的实现 idh.code\frameworks\base\core\jni\android_server_BluetoothEventLoop.cpp
- static void classInitNative(JNIEnv* env, jclass clazz) {
- ALOGV("%s", __FUNCTION__);
- #ifdef HAVE_BLUETOOTH
- method_onPropertyChanged = env->GetMethodID(clazz, "onPropertyChanged",
- "([Ljava/lang/String;)V");
- method_onDevicePropertyChanged = env->GetMethodID(clazz,
- "onDevicePropertyChanged","(Ljava/lang/String;[Ljava/lang/String;)V");
- …………
- }
7、JNI调用onPropertyChanged对应JAVA的实现，在BluetoothEventLoop.java
idh.code\frameworks\base\core\java\android\server\BluetoothEventLoop.java中
- private static native void classInitNative();
- *package*/ void onPropertyChanged(String[] propValues) {
- ………………
- log("Property Changed: " + propValues[0] + " : " + propValues[1]);
- String name = propValues[0];
- if (name.equals("Name")) {//获取蓝牙名字；
- …………
- } else if (name.equals("Pairable") || name.equals("Discoverable")) {//配对；
- ………………
- } else if (name.equals("Discovering")) {//扫描查询；
- Intent intent;
- adapterProperties.setProperty(name, propValues[1]);
- if (propValues[1].equals("true")) {
- intent = new Intent(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
- } else {
- // Stop the discovery.
- mBluetoothService.cancelDiscovery();
- intent = new Intent(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
- }
- mContext.sendBroadcast(intent, BLUETOOTH_PERM);
- } else if (name.equals("Devices") || name.equals("UUIDs")) {//Devices、UUID的获取；
- ………………
- } else if (name.equals("Powered")) {//蓝牙打开、关闭；
- mBluetoothState.sendMessage(BluetoothAdapterStateMachine.POWER_STATE_CHANGED,
- propValues[1].equals("true") ? new Boolean(true) : new Boolean(false));
- } else if (name.equals("DiscoverableTimeout")) {
- adapterProperties.setProperty(name, propValues[1]);
- }
- }
- D BluetoothEventLoop: Property Changed: Powered : true
- D BluetoothEventLoop: Property Changed: Pairable : true
- D BluetoothEventLoop: Property Changed: Class : 5898764
- D BluetoothEventLoop: Property Changed: Pairable : true
- D BluetoothEventLoop: Property Changed: Discoverable : false
- D BluetoothEventLoop: Property Changed: Discovering : true
- D BluetoothEventLoop: Property Changed: Discovering : false
- D BluetoothEventLoop: Property Changed: Devices : 1
- D BluetoothEventLoop: Device property changed: 94:20:53:01:15:90 property: Connected value: true
- D BluetoothEventLoop: Device property changed: 94:20:53:01:15:90 property: Paired value: true
- D BluetoothEventLoop: Device property changed: 94:20:53:01:15:90 property: UUIDs value: 4
（2）、下面我们重点分析Discovering这部分：
idh.code\frameworks\base\core\java\android\server\BluetoothEventLoop.java
- else if (name.equals("Discovering")) {
- Intent intent;
- adapterProperties.setProperty(name, propValues[1]);
- if (propValues[1].equals("true")) {//开始扫描
- intent = new Intent(BluetoothAdapter.ACTION_DISCOVERY_STARTED);//
- } else {
- // Stop the discovery. //停止扫描
- mBluetoothService.cancelDiscovery();
- intent = new Intent(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
- }
- mContext.sendBroadcast(intent, BLUETOOTH_PERM);
- }
- 这样就可以通过broadcast发送ACTION_DISCOVERY_STARTED广播，注册的receiver来响应了。
8、ACTION_DISCOVERY_STARTED\ACTION_DISCOVERY_FINISHED的receiver分析
从代码中我们可以看到这个action一共有两个receiver，一个是静态注册的BluetoothDiscoveryReceiver,一个是动态注册是ScanningStateChangedHandler。
（1）、BluetoothDiscoveryReceiver：这个receiver是在settings中的Androidmanifest中静态注册的。用途：主要用于获取扫描开始和终止的时间。
idh.code\packages\apps\Settings\AndroidManifest.xml
- <receiver
- android:name=".bluetooth.BluetoothDiscoveryReceiver">
- <intent-filter>
- <action android:name="android.bluetooth.adapter.action.DISCOVERY_STARTED" />
- <action android:name="android.bluetooth.adapter.action.DISCOVERY_FINISHED" />
- <category android:name="android.intent.category.DEFAULT" />
- </intent-filter>
- </receiver>
1）、ACTION_DISCOVERY_STARTED、ACTION_DISCOVERY_FINISHED和AndroidManifest.xml文件的联系
idh.code\frameworks\base\core\java\android\bluetooth\BluetoothAdapter.java
- public final class BluetoothAdapter {
- private static final String TAG = "BluetoothAdapter";
- private static final boolean DBG = false;
- …………
- public static final String ACTION_DISCOVERY_STARTED =
- "android.bluetooth.adapter.action.DISCOVERY_STARTED";
- public static final String ACTION_DISCOVERY_FINISHED =
- "android.bluetooth.adapter.action.DISCOVERY_FINISHED";
- …………
- }
2）、BluetoothAdapter，蓝牙适配器，直到我们建立bluetoothSocket连接之前，都要不断操作它。
BluetoothAdapter中的动作常量
ACTION_DISCOVERY_FINISHED | 已完成蓝牙搜索 |
ACTION_DISCOVERY_STARTED | 已经开始搜索蓝牙设备 |
ACTION_LOCAL_NAME_CHANGED | 更改蓝牙的名字 |
ACTION_REQUEST_DISCOVERABLE | 请求能够被搜索 |
ACTION_REQUEST_ENABLE | 请求启动蓝牙 |
ACTION_SCAN_MODE_CHANGED | 扫描模式已经改变 |
ACTION_STATE_CHANGED | 状态已改变 |
ACTION_CONNECTION_STATE_CHANGED |
|
3）、收到广播后函数实现，开始扫描
Main log中显示的log为DISCOVERY_STARTED
D BluetoothDiscoveryReceiver: Received:android.bluetooth.adapter.action.DISCOVERY_STARTED
HCI log 中：
idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\BluetoothDiscoveryReceiver.java这个文件中就一个函数，还是比简单
- public final class BluetoothDiscoveryReceiver extends BroadcastReceiver {
- private static final String TAG = "BluetoothDiscoveryReceiver";
- private static final boolean DEBUG = Debug.isDebug();
- @Override
- public void onReceive(Context context, Intent intent) {
- String action = intent.getAction();
- if (DEBUG) Log.d(TAG, "Received: " + action);
- if (action.equals(BluetoothAdapter.ACTION_DISCOVERY_STARTED) ||
- action.equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
- //共享时间戳，扫描开始和结束的时间。
- LocalBluetoothPreferences.persistDiscoveringTimestamp(context);
- }
- }
- }
ScanningStateChangedHandler的注册及用途，要用于开始扫描，和扫描显示界面的控制。
这个receiver是在idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\BluetoothEventManager.java动态注册的，如下：
- BluetoothEventManager(LocalBluetoothAdapter adapter,
- CachedBluetoothDeviceManager deviceManager, Context context) {
- mLocalAdapter = adapter;
- …………
- // Bluetooth on/off broadcasts
- addHandler(BluetoothAdapter.ACTION_STATE_CHANGED, new AdapterStateChangedHandler());
- // Discovery broadcastsaddHandler(BluetoothAdapter.ACTION_DISCOVERY_STARTED, new ScanningStateChangedHandler(true));
- addHandler(BluetoothAdapter.ACTION_DISCOVERY_FINISHED, new ScanningStateChangedHandler(false));
- …………
- }
（1）、ScanningStateChangedHandler函数实现如下：idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\BluetoothEventManager.java
- private class ScanningStateChangedHandler implements Handler {
- private final boolean mStarted;
- ScanningStateChangedHandler(boolean started) {
- mStarted = started;
- }
- public void onReceive(Context context, Intent intent,
- BluetoothDevice device) {
- synchronized (mCallbacks) {//1)、调用注册的callback
- 中的onScanningStateChanged函数。
- for (BluetoothCallback callback : mCallbacks) {
- callback.onScanningStateChanged(mStarted);
- }
- }
- //2）、这个函数就是把上次扫描到设备、和之前的设备做相应处理；
- mDeviceManager.onScanningStateChanged(mStarted);
- LocalBluetoothPreferences.persistDiscoveringTimestamp(context);
- }
- }
1）、调用注册的callback中的callback.onScanningStateChanged(mStarted)函数。
idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\DeviceListPreferenceFragment.java
- public void onScanningStateChanged(boolean started) {
- if (started == false) {//《1》、如果扫描结束；
- removeOutOfRangeDevices();
- }
- updateProgressUi(started);// 《2》、UI显示小圆圈扫描；
《1》、如果扫描结束；removeOutOfRangeDevices();
idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\DeviceListPreferenceFragment.java
- private void removeOutOfRangeDevices() {
- Collection<CachedBluetoothDevice> cachedDevices =
- mLocalManager.getCachedDeviceManager().getCachedDevicesCopy();
- for (CachedBluetoothDevice cachedDevice : cachedDevices) {
- if (cachedDevice.getBondState() == BluetoothDevice.BOND_NONE &&
- cachedDevice.isVisible() == false) {
- BluetoothDevicePreference preference = mDevicePreferenceMap.get(cachedDevice);
- if (preference != null) {
- mDeviceListGroup.removePreference(preference);
- }
- mDevicePreferenceMap.remove(cachedDevice);
- }
- }
- }
《2》、UI显示小圆圈扫描，updateProgressUi(started)；如下图所示：
idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\DeviceListPreferenceFragment.java
- private void updateProgressUi(boolean start) {
- if (mDeviceListGroup instanceof ProgressCategory) {
- ((ProgressCategory) mDeviceListGroup).setProgress(start);
- }
- }
2）、这部分的作用，开始扫描，不显示列表中内容，或把之前列表中没扫描到的设备清除
mDeviceManager.onScanningStateChanged(mStarted);
idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\CachedBluetoothDevice.java
- private void updateProgressUi(boolean start) {
- if (mDeviceListGroup instanceof ProgressCategory) {
- ((ProgressCategory) mDeviceListGroup).setProgress(start);
- }
- }
- 2）、这部分的作用，开始扫描，不显示列表中内容，或把之前列表中没扫描到的设备清除
- mDeviceManager.onScanningStateChanged(mStarted);
- idh.code\packages\apps\Settings\src\com\android\settings\bluetooth\ CachedBluetoothDevice.java
- public synchronized void onScanningStateChanged(boolean started) {
- // If starting a new scan, clear old visibility
- // Iterate in reverse order since devices may be removed.
- //如果开始新的扫描，清除旧的能见设备，迭代反序因为有的设备可能被删除
- for (int i = mCachedDevices.size() - 1; i >= 0; i--) {
- CachedBluetoothDevice cachedDevice = mCachedDevices.get(i);
- if (started) {//如果扫描开始就不显示；
- cachedDevice.setVisible(false);
- } else {//对扫描的结果作出判断，如果之前扫描过，这次没有扫描到，就移除列表。
- if (cachedDevice.getBondState() == BluetoothDevice.BOND_NONE &&
- cachedDevice.isVisible() == false) {
- mCachedDevices.remove(cachedDevice);
- }
- }
- }
- }
Android bluetooth介绍（四）： a2dp connect流程分析
关键词：蓝牙blueZ A2DP、SINK、sink_connect、sink_disconnect、sink_suspend、sink_resume、sink_is_connected、sink_get_properties、AUDIO、DBUS
版本：基于android4.2之前版本 bluez
内核：linux/linux3.08
系统：android/android4.1.3.4
作者：xubin341719(欢迎转载，请注明作者，请尊重版权谢谢)
欢迎指正错误，共同学习、共同进步！！
Android bluetooth介绍（一）：基本概念及硬件接口
Android bluetooth介绍（二）： android 蓝牙代码架构及其uart 到rfcomm流程
Android bluetooth介绍（三）： 蓝牙扫描(scan)设备分析
Android bluetooth介绍（四）： a2dp connect流程分析
一、A2DP_CONNECT上层代码流程
二、从HCI log中看AVDTP 创建过程
1、AVDTP l2cap建立过程
2、AVDTP相关信令处理流程在HCI 中的流程
DISCOVER \GET_CAPABILITIES\SET_CONFIGURATION\OPEN\START\SUSPEND
三、audiosink函数注册、及命令处理流程
AVDTP_DISCOVER\AVDTP_GET_CAPABILITIES\AVDTP_SET_CONFIGURATION\AVDTP_OPEN\AVDTP_START:等一系列控制命令
（一）、sink_connect创建流程
整体流程如下所示
1、idh.code\external\bluetooth\bluez\audio\sink.c
- static DBusMessage *sink_connect(DBusConnection *conn,
- DBusMessage *msg, void *data)
- {
- …………
- if (!sink->session)//（1）、如果没有AVDTP会话，获取AVDTP连接状态；
- sink->session = avdtp_get(&dev->src, &dev->dst);
- if (!sink->session)//相关失败操作
- return btd_error_failed(msg, "Unable to get a session");
- if (sink->connect || sink->disconnect)//如果正在连接、断开，发送busy消息；
- return btd_error_busy(msg);
- if (sink->stream_state >= AVDTP_STATE_OPEN)//如果已经打开，发送已经连接消息；
- return btd_error_already_connected(msg);
- if (!sink_setup_stream(sink, NULL))//（2）、创建AVDTP流；
- return btd_error_failed(msg, "Failed to create a stream");
- dev->auto_connect = FALSE;
- pending = sink->connect;
- pending->conn = dbus_connection_ref(conn);//（3）、保存客户端dbus信息；
- pending->msg = dbus_message_ref(msg);
- DBG("stream creation in progress");
- return NULL;
- }
（1）、如果没有AVDTP会话，获取AVDTP连接状态；
- sink->session = avdtp_get(&dev->src, &dev->dst);
- idh.code\external\bluetooth\hcidump\parser\avdtp.c
- struct avdtp *avdtp_get(bdaddr_t *src, bdaddr_t *dst)
- {
- ………………
- session = avdtp_get_internal(src, dst);
- ………………
- }
- avdtp_get_internal 中设置 session->state状态，
- session->state = AVDTP_SESSION_STATE_DISCONNECTED;
（2）、创建AVDTP流；
sink_setup_stream(sink,NULL)
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- gboolean sink_setup_stream(struct sink *sink, struct avdtp *session)
- {
- …………
- avdtp_set_auto_disconnect(sink->session, FALSE);//不能自动断开；
- if (avdtp_discover(sink->session, discovery_complete, sink) < 0)//调用avdtp_discover,
- discovery_complete为回调函数；
- return FALSE;
- sink->connect = g_new0(struct pending_request, 1);
- return TRUE;
- }
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- int avdtp_discover(struct avdtp *session, avdtp_discover_cb_t cb,
- void *user_data)
- {
- int err;
- if (session->discov_cb)
- return -EBUSY;
- if (session->seps) {
- session->discov_cb = cb;
- session->user_data = user_data;
- g_idle_add(process_discover, session);
- return 0;
- }
- err = send_request(session, FALSE, NULL, AVDTP_DISCOVER, NULL, 0);
- //发送AVDTP_DISCOVER命令出去
- if (err == 0) {
- session->discov_cb = cb;
- session->user_data = user_data;
- }
- return err;
- }
- static int send_request(struct avdtp *session, gboolean priority,
- struct avdtp_stream *stream, uint8_t signal_id,
- void *buffer, size_t size)
- {
- struct pending_req *req;
- if (stream && stream->abort_int && signal_id != AVDTP_ABORT) {
- DBG("Unable to send requests while aborting");
- return -EINVAL;
- }
- req = g_new0(struct pending_req, 1);
- req->signal_id = signal_id;
- req->data = g_malloc(size);
- memcpy(req->data, buffer, size);
- req->data_size = size;
- req->stream = stream;
- return send_req(session, priority, req);//这个函数我们后面分析；
- }
（3）、保存客户端dbus信息；
- pending->conn = dbus_connection_ref(conn);
- pending->msg = dbus_message_ref(msg);
2、send_req 创建L2CAP连接
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- static int send_req(struct avdtp *session, gboolean priority,
- struct pending_req *req)
- {
- static int transaction = 0;
- int err;
- if (session->state == AVDTP_SESSION_STATE_DISCONNECTED) {//如果AVDTP没有连接，
- session->io = l2cap_connect(session);//（1）、创建l2cap连接；
- if (!session->io) {
- err = -EIO;
- goto failed;
- }
- avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTING);
- }
- if (session->state < AVDTP_SESSION_STATE_CONNECTED ||
- session->req != NULL) {//如果AVDTP没连接
- queue_request(session, req, priority);//把相关参数放入队列
- return 0;//在这里返回，后面AVDTP sock建立完成后，会再次调用这个函数；
- }
- req->transaction = transaction++;
- transaction %= 16;
- /* FIXME: Should we retry to send if the buffer
- was not totally sent or in case of EINTR? */
- if (!avdtp_send(session, req->transaction, AVDTP_MSG_TYPE_COMMAND,
- req->signal_id, req->data, req->data_size)) {//（2）、发送相关命令
- err = -EIO;
- goto failed;
- }
- …………
- }
（1）、创建l2cap连接
sink connect的过程本质上是建立一个avdtp 连接的过程，avdtp是基于l2cap的，包括控制命令的发送和数据的发送都是l2cap的，所以这个图纸表示了建立一个发送控制命令的l2cap的socket，等这个socket建立起来以后，开始发送AVDPT_DISCOVER的请求；
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- session->io = l2cap_connect(session);
- static GIOChannel *l2cap_connect(struct avdtp *session)
- {
- GError *err = NULL;
- GIOChannel *io;
- io = bt_io_connect(BT_IO_L2CAP, avdtp_connect_cb, session,
- NULL, &err,
- BT_IO_OPT_SOURCE_BDADDR, &session->server->src,
- BT_IO_OPT_DEST_BDADDR, &session->dst,
- BT_IO_OPT_PSM, AVDTP_PSM,
- BT_IO_OPT_INVALID);
- if (!io) {
- error("%s", err->message);
- g_error_free(err);
- return NULL;
- }
- return io;<strong>
- }
- </strong>
这个函数中注意两点，1）、bt_io_connect;2）、avdtp_connect_cb回调函数；
1）、bt_io_connect
idh.code\external\bluetooth\bluez\btio\btio.c
- GIOChannel *bt_io_connect(BtIOType type, BtIOConnect connect,
- gpointer user_data, GDestroyNotify destroy,
- GError **gerr, BtIOOption opt1, ...)
- {
- …………
- io = create_io(type, FALSE, &opts, gerr);
- if (io == NULL)
- return NULL;
- sock = g_io_channel_unix_get_fd(io);
- switch (type) {
- case BT_IO_L2RAW:
- err = l2cap_connect(sock, &opts.dst, 0, opts.cid);
- break;
- //不同协议的连接,如L2CPA、RFCOMM、SCO
- case BT_IO_L2CAP:
- err = l2cap_connect(sock, &opts.dst, opts.psm, opts.cid);
- break;
- case BT_IO_RFCOMM:
- err = rfcomm_connect(sock, &opts.dst, opts.channel);
- break;
- case BT_IO_SCO:
- err = sco_connect(sock, &opts.dst);
- break;
- …………
- connect_add(io, connect, user_data, destroy);
- return io;
- }<strong>
- </strong>
Btio中l2cap_connect的实现:
idh.code\external\bluetooth\bluez\btio\btio.c
- static int l2cap_connect(int sock, const bdaddr_t *dst,
- uint16_t psm, uint16_t cid)
- {
- int err;
- struct sockaddr_l2 addr;
- memset(&addr, 0, sizeof(addr));
- addr.l2_family = AF_BLUETOOTH;
- bacpy(&addr.l2_bdaddr, dst);
- if (cid)
- addr.l2_cid = htobs(cid);
- else
- addr.l2_psm = htobs(psm);
- err = connect(sock, (struct sockaddr *) &addr, sizeof(addr));//建立BTPROTO_L2CAP
- if (err < 0 && !(errno == EAGAIN || errno == EINPROGRESS))
- return err;
- return 0;
- }
2）、avdtp_connect_cb回调函数
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- static void avdtp_connect_cb(GIOChannel *chan, GError *err, gpointer user_data)
- {
- ………………
- if (session->state == AVDTP_SESSION_STATE_CONNECTING) {//如果处于正在连接状态；
- DBG("AVDTP imtu=%u, omtu=%u", session->imtu, session->omtu);
- session->buf = g_malloc0(session->imtu);
- avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTED);//设置AVDTP状态为已经连接状态；
- if (session->io_id)
- g_source_remove(session->io_id);
- /* This watch should be low priority since otherwise the
- * connect callback might be dispatched before the session
- * callback if the kernel wakes us up at the same time for
- * them. This could happen if a headset is very quick in
- * sending the Start command after connecting the stream
- * transport channel.
- */
- session->io_id = g_io_add_watch_full(chan,
- G_PRIORITY_LOW,
- G_IO_IN | G_IO_ERR | G_IO_HUP
- | G_IO_NVAL,
- (GIOFunc) session_cb, session,
- NULL);
- ………………
- process_queue(session);//发送DISCOVER
- return;
- …………
- }
3、process_queue(session)发送DISCOVER命令出去
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- static int process_queue(struct avdtp *session)
- {
- …………
- *queue = g_slist_remove(*queue, req);
- return send_req(session, FALSE, req);
- }<strong>
- </strong>
这个函数调用send_req，这个函数前面已经调用过，可是现在AVDTP的状态不同，第一次调用AVDTP_SESSION_STATE_DISCONNECTED状态，第二次调用为
AVDTP_SESSION_STATE_CONNECTED状态；
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- static int send_req(struct avdtp *session, gboolean priority,
- struct pending_req *req)
- {
- static int transaction = 0;
- int err;
- if (session->state == AVDTP_SESSION_STATE_DISCONNECTED) {//第二次调用时，就不走这段函数
- session->io = l2cap_connect(session);
- if (!session->io) {
- err = -EIO;
- goto failed;
- }
- avdtp_set_state(session, AVDTP_SESSION_STATE_CONNECTING);
- }
- if (session->state < AVDTP_SESSION_STATE_CONNECTED ||//第二次调用也越过这段函数
- session->req != NULL) {
- queue_request(session, req, priority);
- return 0;
- }
- req->transaction = transaction++;
- transaction %= 16;
- /* FIXME: Should we retry to send if the buffer
- was not totally sent or in case of EINTR? */
- if (!avdtp_send(session, req->transaction, AVDTP_MSG_TYPE_COMMAND,
- req->signal_id, req->data, req->data_size)) {//avdtp_send就是主要的操作
- err = -EIO;
- goto failed;
- }
4、avdtp_send的实现
idh.code\external\bluetooth\hcidump\parser\avdtp.c
- static gboolean avdtp_send(struct avdtp *session, uint8_t transaction,
- uint8_t message_type, uint8_t signal_id,
- void *data, size_t len)
- {
- …………
- /* Send the start packet */
- memset(&start, 0, sizeof(start));
- start.transaction = transaction;
- start.packet_type = AVDTP_PKT_TYPE_START;
- start.message_type = message_type;
- start.no_of_packets = cont_fragments + 1;
- start.signal_id = signal_id;
- memcpy(session->buf, &start, sizeof(start));
- memcpy(session->buf + sizeof(start), data,
- session->omtu - sizeof(start));
- if (!try_send(sock, session->buf, session->omtu))
- return FALSE;
- ………………
- cont.message_type = message_type;
- memcpy(session->buf, &cont, sizeof(cont));
- memcpy(session->buf + sizeof(cont), data + sent, to_copy);
- if (!try_send(sock, session->buf, to_copy + sizeof(cont)))
- return FALSE;
- sent += to_copy;
- }
- return TRUE;
- } <strong>
- </strong>
5、Try_sends函数的实现
- static gboolean try_send(int sk, void *data, size_t len)
- {
- int err;
- do {
- err = send(sk, data, len, 0);
- } while (err < 0 && errno == EINTR);
- if (err < 0) {
- error("send: %s (%d)", strerror(errno), errno);
- return FALSE;
- } else if ((size_t) err != len) {
- error("try_send: complete buffer not sent (%d/%zu bytes)",
- err, len);
- return FALSE;
- }
- return TRUE;
- }<strong>
- </strong>
（二）、AVDTP_DISCOVER的命令发送流程如上图所示；
avdtp是基于l2cap的，包括控制命令的发送和数据的发送都是l2cap的，所以建立一个发送控制命令的l2cap的socket，等这个socket建立起来以后，开始发送AVDPT_DISCOVER的请求；|
`AVDTP_DISCOVER\AVDTP_GET_CAPABILITIES\AVDTP_SET_CONFIGURATION\AVDTP_OPEN\AVDTP_START:等一系列控制命令
建立了一个l2cap的连接，等有数据过来的时候，就开始触发逻辑，session_cb是一个非常重要的函数，这里控制了整个连接的流程，我们下面会讲，剩下的就是通过avdtp_send来发送一个AVDTP_DISCOVER的命令，这个命令的作用就是查看远程设备看它支持那些sep（stream end point），也就是说是否支持source，sink等；
四、AVDTP_GET_CAPABILITIES命令发送（其他代码流程比较类似）
如下图所示：
这个图在发送了avdtp discover命令以后，会被先前设立好的回调函数执行，里面会把远程设备的sep都加入到session的seps连边里面去，然后开始发送AVDTP_GET_CAPABILITIES命令了；
当收到远端设备的回复消息后触发调用下面的逻辑：
在系列初始化、状态设定之后，发送哦AVDTP_SET_CONFIGURATION
五、AVDTP_SET_CONFIGURATION命令发送
发送AVDTP_OPEN命令；
六、AVDTP_OPEN的处理流程
到这里就表示已经确立了sep和caps，开始打开AVDTP了，如下：
数stream_setup_complete里面会对先前的dbus消息进行回复；
七、AVDTP_START命令发送
这里发送AVDTP_START的命令，它的触发是由客户端引起的，比如aplay –Dbluetooth 2.wav的时候通过alsa提供的bluetooth的插件，daemonbluetoothd-service-audio通过socket(PF_LOCAL, SOCK_STREAM,0);建立起一个socket来监听客户端的接入，触发server_cb的执行，在这里accept客户端，并设置监听函数client_cb，当收到客户端的启动流播放命令的时候就开始调用avdtp_start函数来发送命令，注意这里设置了一个回调函数a2dp_resume_complete,后面会被调用；当bluetoothd-service-audio收到了这个命令AVDTP_START的响应消息时执行下面的逻辑：
进程间传递文件描述符，内核层里面的实现，通过socket发送这个文件描述符，在内核里面把struct file信息传递给socket的peer端，它再取得一个空的fd把它和struct file关联起来，于是就实现了文件描述符传递。
3565
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
