首先我们先熟悉一下蓝牙协议的基本规范
1）A2DP（Advanced Audio Distribution Profile）
高级音频、立体声规范，包括A2DP Sink和A2DP Source；
2）AVRCP（Audio/Video Remote Control Profile）
音视频远程控制规范，音乐播放、暂停等；
3）HFP（Hands-Free Profile）
免提规范，用于蓝牙通话；
4）HSP（Headset Profile）
耳机规范，用于蓝牙耳机；
5）HID（Human Interface Device Profile）
人体接口设备规范，分为HID Host和HID Device；
6）OPP（Object Push Profile）
对象推送规范，用于传输文件；
7）PAN（Personal Area Networking Profile）
个人局域网规范，蓝牙网络共享；
8）PBAP（Phone Book Access Profile）
电话号码薄访问规范；
9）MAP（Message Access Profile）
信息访问规范；
10）HDP（Health Device Profile）
健康设备规范，和一些健康蓝牙设备进行通信；
11）BLP（Blood Pressure Profile）
血压规范；
12）HRP（Heart Rate Profile）
心率规范；
13）HOGP（HID Over GATT Profile）
基于GATT的HID规范；
14）FMP（Find Me Profile）
找我规范；
15）TIP（Time Profile）
时间规范
1.Bluetooth应用层框架介绍
Bluetooth应用框架
1）Applications：Android蓝牙应用程序，就是使用蓝牙的API的程序；
2）Java FW：提供给应用使用的API，我们平时使用的BluetoothAdapter，BluetoothDevice，BluetoothSocket等；
3）BluetoothAPP：这个本来应该是属于Java FW范畴的，不过由于它比较特殊，所以独立出来，提供所有的上层服务以及与Bluetooth底层记性交互。其中BTAdapter主要提供蓝牙的基本操作，比如enable，disable，discovery，pair，unpair，createRfcomm等，其他的就都是Profile的各自的service了；
4）Bluedroid：蓝牙协议栈，提供所有的实际操作，开关蓝牙，蓝牙的管理，搜索管理，链路管理，各种profile的实现，包括HCI，ACL，SCO，L2CAP，各种profile等；
这里的bluedroid分为三部分：
（1）BITF（Bluetooth interface）：提供所有Bluetooth.apk需要的API（使用HAL）
（2）BTA（Bluetooth Application）：蓝牙应用，一般指蓝牙的Profile的Bluedroid实现
（3）Stack：实现所有蓝牙底层的操作，其中还要分为btm（Bluetooth manager），btu（Bluetooth Upper Layer）等。
2.Bluedroid软件介绍
bluedroid框架图
bt目录结构
1）audio_a2dp_hw：Implements hal for bluedroid a2dp audio device。a2dp再bluedroid中的hal层实现。它通过socket与stack进行通信（通信机制实现参考udv目录下的uipc）；
2）bta：Bluetooth Application layer，实现应用层的一些接口，但都由btif层进行管理和调用。
Ag：audio gateway (AG) subsystem of BTA
Ar：implementation for the audio/video registration module.
Av：implementation of the API for the advanced audio/video(AV)
*subsystem of BTA, Broadcom's Bluetooth application layer for mobile phones*
Dm：API implementation file for the file system call-in functions.//phone
Gattr：the GATT server and client implementation
Hh：host hid
3）btif：all BTIF functions accessed from main bluetooth HAL(与Android的Bluetooth apk的jni层通信的接口，真正的为app提供interface的接口)；
4）conf：是Bluedroid的一些配置文件；
5）embdrv：主要负责sbc编码，SBC是一种用于蓝牙设备标准音频编解码器的高效编码方法。在蓝牙技术的a2dp的音频数据规格中，SBC是用来保持互连能力的一个十分重要的音频数据编码方法，它是MP3和MPEG-AAC的规定选项；
6）gki/osi：general kernel interface/os interface，针对OS的移植层，包括多任务和timer实现，实际就是为Stack代码提供一个抽象的多任务和时间控制环境，达到可移植的目的；
7）hci：host control interface，实现hci的协议，并连接Stack层与底层通信的实现；
8）main：处理配置信息，各个模块的初始化，连接btif与hci，提供btif控制hci的接口；
9）Stack：协议栈代码，各种profile；
10）udrv：代码作用是跟a2dp端进行Socket通信，处理命令和a2dp数据pcm流，media task调用这里的接口，实际就是跟audio_a2dp_hw的audio hal通信；
11）utils：杂项，很简单，目前就是提高a2dp任务优先级的函数；
12）vnd：vendor specific feature for BLE;
其中，还有一个bt vendor没包含在bluedroid中，对于realtek的蓝牙，都是使用相同的bluedroid，但不同的蓝牙模块有不同的bt vendor库，该vendor库的功能是给蓝牙模块上、掉电，打开、关闭、配置串口，download fw（USB接口蓝牙的download fw在驱动内实现）。
数据流传输流程：
（1）uart口取得蓝牙模块的数据；
（2）uart口通过Idisc传给hci_uart;
（3）hci_uart传给在其上的h4;
（4）h4传给hci;
（5）hci层传给l2cap层；
（6）l2cap层再传给rfcomm
2.1 bluedroid对上层接口
bluedroid与上层有多个接口，bluedroid/btif/src/bluetooth.c为一个主要接口，负责蓝牙的开关以及基本控制，bluedroid\audio_a2dp_hw\audio_a2dp_hw.c专门针对a2dp的控制，还有部分profile也提供一些接口，这些接口为不同profile的独立接口。其中bluetooth.c实现一系列接口，由上层调用来控制蓝牙，同事在初始化的时候，上层会传递过来一个毁掉接口，当bluedroid有消息或结果需要通知上层时，就该通过回调接口。但像蓝牙的opp、hid等profile的数据就不是通过接口传递的，都是创建Socket接口来交换数据的。
\bluedroid\btif\src\bluetooth.c
static const bt_interface_t bluetoothInterface = {
sizeof(bluetoothInterface),
init,
enable,
disable,
get_recv_byte,
get_send_byte,
cleanup,
get_adapter_properties,
get_adapter_property,
set_adapter_property,
get_remote_device_properties,
get_remote_device_property,
set_remote_device_property,
get_remote_service_record,
get_remote_services,
start_discovery,
cancel_discovery,
create_bond,
remove_bond,
cancel_bond,
get_connection_state,
pin_reply,
ssp_reply,
get_profile_interface,
dut_mode_configure,
dut_mode_send,
#if BLE_INCLUDED == TRUE
le_test_mode,
#else
NULL,
#endif
config_hci_snoop_log,
set_os_callouts,
read_energy_info,
};
hardware\libhardware\include\hardware\bluetooth.h
typedef struct { /* 蓝牙接口结构体定义 */
/** set to sizeof(bt_interface_t) */
size_t size;
/**
* Opens the interface and provides the callback routines
* to the implemenation of this interface.
*/
int (*init)(bt_callbacks_t* callbacks );
/** Enable Bluetooth. */
int (*enable)(void);
/** Disable Bluetooth. */
int (*disable)(void);
/** Get Bluetooth recv */
int (*get_recv_byte)(void);
…… /* 省略中间代码 */
int (*read_energy_info)();
} bt_interface_t;
\bluedroid\btif\src\bluetooth.c
static int init(bt_callbacks_t* callbacks ) /* 初始化时，上层传递下来的回调接口结构体 */
{
ALOGI(“init”);
/* sanity check */
if (interface_ready() == TRUE)
return BT_STATUS_DONE;
/* store reference to user callbacks */
Bt_hal_cbacks = callbacks;
/* add checks for individual callbacks ? */
bt_utils_init();
/* init btif */
btif_init_bluetooth();
return BT_STATUS_SUCCESS;
}
hardware\libhardware\include\hardware\bluetooth.h
/** Bluetooth DM callback structure. */ /* 回调结构体 */
typedef struct {
/** set to sizeof(bt_callbacks_t) */
size_t size;
adapter_state_changed_callback adapter_state_changed_cb;
adapter_properties_callback adapter_properties_cb;
remote_device_properties_callback remote_device_properties_cb;
device_found_callback device_found_cb;
discovery_state_changed_callback discovery_state_changed_cb;
pin_request_callback pin_request_cb;
ssp_request_callback ssp_request_cb;
bond_state_changed_callback bond_state_changed_cb;
acl_state_changed_callback acl_state_changed_cb;
callback_thread_event thread_evt_cb;
dut_mode_recv_callback dut_mode_recv_cb;
le_test_mode_callback le_test_mode_cb;
energy_info_callback energy_info_cb;
} bt_callbacks_t;
其中在get_profile_interface函数中会返回各种profile提供的接口。
\bluedroid\btif\src\bluetooth.c
static const void* get_profile_interface (const char *profile_id)
{
ALOGI("get_profile_interface %s", profile_id);
/* sanity check */
if (interface_ready() == FALSE)
return NULL;
/* check for supported profile interfaces */
if (is_profile(profile_id, BT_PROFILE_HANDSFREE_ID))
return btif_hf_get_interface();
if (is_profile(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID))
return btif_hf_client_get_interface();
if (is_profile(profile_id, BT_PROFILE_SOCKETS_ID)) /* rfcomm使用 */
return btif_sock_get_interface();
if (is_profile(profile_id, BT_PROFILE_PAN_ID))
return btif_pan_get_interface();
if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_ID))
return btif_av_get_src_interface();
if (is_profile(profile_id, BT_PROFILE_ADVANCED_AUDIO_SINK_ID))
return btif_av_get_sink_interface();
if (is_profile(profile_id, BT_PROFILE_HIDHOST_ID))
return btif_hh_get_interface();
if (is_profile(profile_id, BT_PROFILE_HEALTH_ID))
return btif_hl_get_interface();
if (is_profile(profile_id, BT_PROFILE_MAP_CLIENT_ID))
return btif_mce_get_interface();
#if ( BTA_GATT_INCLUDED == TRUE && BLE_INCLUDED == TRUE)
if (is_profile(profile_id, BT_PROFILE_GATT_ID))
return btif_gatt_get_interface();
#endif
if (is_profile(profile_id, BT_PROFILE_AV_RC_ID))
return btif_rc_get_interface();
if (is_profile(profile_id, BT_PROFILE_AV_RC_CTRL_ID))
return btif_rc_ctrl_get_interface();
return NULL;
}
下面为使用rfcomm通信时的使用的接口：
\bluedroid\btif\src\btif_sock.c
static btsock_interface_t sock_if = {
sizeof(sock_if),
btsock_listen,
btsock_connect
};
btsock_interface_t *btif_sock_get_interface()
{
return &sock_if;
}
audio_a2dp_hw.c的接口就没有看到回调函数，但audio_a2dp_hw.c中创建了2个socket接口，一个用于控制命令，一个用于a2dp数据的传输。
\bluedroid\audio_a2dp_hw\audio_a2dp_hw.c
static int adev_open(const hw_module_t* module, const char* name,
hw_device_t** device)
{
…… /* 省略中间代码 */
adev->device.get_parameters = adev_get_parameters;
adev->device.get_input_buffer_size = adev_get_input_buffer_size;
adev->device.open_output_stream = adev_open_output_stream;
adev->device.close_output_stream = adev_close_output_stream;
adev->device.open_input_stream = adev_open_input_stream;
adev->device.close_input_stream = adev_close_input_stream;
adev->device.dump = adev_dump;
…… /* 省略中间代码 */
static struct hw_module_methods_t hal_module_methods = {
.open = adev_open,
};
struct audio_module HAL_MODULE_INFO_SYM = {
.common = {
.tag = HARDWARE_MODULE_TAG,
.version_major = 1,
.version_minor = 0,
.id = AUDIO_HARDWARE_MODULE_ID,
.name = "A2DP Audio HW HAL",
.author = "The Android Open Source Project",
.methods = &hal_module_methods,
},
};
\bluedroid\audio_a2dp_hw\audio_a2dp_hw.c
static int adev_open_input_stream(struct audio_hw_device *dev,
audio_io_handle_t handle,
audio_devices_t devices,
struct audio_config *config,
struct audio_stream_in **stream_in,
audio_input_flags_t flags __unused,
const char *address __unused,
audio_source_t source __unused)
{
…… /* 省略中间代码 */
in->stream.common.set_parameters = in_set_parameters;
in->stream.common.get_parameters = in_get_parameters;
in->stream.common.add_audio_effect = in_add_audio_effect;
in->stream.common.remove_audio_effect = in_remove_audio_effect;
in->stream.set_gain = in_set_gain;
in->stream.read = in_read; /* 该函数会打开data socket */
in->stream.get_input_frames_lost = in_get_input_frames_lost;
/* initialize a2dp specifics */
a2dp_stream_common_init(&in->common);
*stream_in = &in->stream;
a2dp_dev->input = in;
a2dp_open_ctrl_path(&in->common);
\bluedroid\audio_a2dp_hw\audio_a2dp_hw.c
static void a2dp_open_ctrl_path(struct a2dp_stream_common *common)
{
int i;
/* retry logic to catch any timing variations on control channel */
for (i = 0; i < CTRL_CHAN_RETRY_COUNT; i++)
{
/* connect control channel if not already connected */
if ((common->ctrl_fd = skt_connect(A2DP_CTRL_PATH, common->buffer_sz)) > 0)
{
\bluedroid\audio_a2dp_hw\audio_a2dp_hw.c
static ssize_t in_read(struct audio_stream_in *stream, void* buffer,
size_t bytes)
{
…… /* 省略中间代码 */
/* only allow autostarting if we are in stopped or standby */
if ((in->common.state == AUDIO_A2DP_STATE_STOPPED) ||
(in->common.state == AUDIO_A2DP_STATE_STANDBY))
{
pthread_mutex_lock(&in->common.lock);
if (start_audio_datapath(&in->common) < 0)
\bluedroid\audio_a2dp_hw\audio_a2dp_hw.c
static int start_audio_datapath(struct a2dp_stream_common *common)
{
…… /* 省略中间代码 */
/* connect socket if not yet connected */
if (common->audio_fd == AUDIO_SKT_DISCONNECTED)
{
common->audio_fd = skt_connect(A2DP_DATA_PATH, common->buffer_sz);2.2 Bluedroid中的HCI层接口
Hci层处于bluedroid架构的最下面，向下与bt-vendor、内核交互，向上与bluedroid核心层交互。
2.2.1 Bluedroid中HCI与bt-vendor接口
Bluedroid与下层的交互接口全由hci目录的代码实现，在vendor.c文件中加载bt-vendor库，使用bt-vendor提供的接口，并把一个回调结构体传递给bt-vendor.
\bluedroid\hci\src\vendor.c
static const char *VENDOR_LIBRARY_NAME = "libbt-vendor.so"; /* 固定的bt-vendor库名 */
bool vendor_open(const uint8_t *local_bdaddr) {
assert(lib_handle == NULL);
lib_handle = dlopen(VENDOR_LIBRARY_NAME, RTLD_NOW);
if (!lib_handle) {
ALOGE("%s unable to open %s: %s", __func__, VENDOR_LIBRARY_NAME, dlerror());
goto error;
}
vendor_interface = (bt_vendor_interface_t *)dlsym(lib_handle, VENDOR_LIBRARY_SYMBOL_NAME);
if (!vendor_interface) {
ALOGE("%s unable to find symbol %s in %s: %s", __func__, VENDOR_LIBRARY_SYMBOL_NAME, VENDOR_LIBRARY_NAME, dlerror());
goto error;
}
/* 调用bt-vendor的初始化并传递回调结构体 */
int status = vendor_interface->init(&vendor_callbacks, (unsigned char *)local_bdaddr);
\bluedroid\hci\include\bt_vendor_lib.h
typedef struct { /* bt-vendor提供的3个接口 */
/** Set to sizeof(bt_vndor_interface_t) */
size_t size;
/**
* Caller will open the interface and pass in the callback routines
* to the implemenation of this interface.
*/
int (*init)(const bt_vendor_callbacks_t* p_cb, unsigned char *local_bdaddr);
/** Vendor specific operations */
int (*op)(bt_vendor_opcode_t opcode, void *param);
/** Closes the interface */
void (*cleanup)(void);
} bt_vendor_interface_t;
\bluedroid\hci\src\vendor.c
static const bt_vendor_callbacks_t vendor_callbacks = { /* hci传递给bt-vendor的回调结构体 */
sizeof(vendor_callbacks),
firmware_config_cb,
sco_config_cb,
low_power_mode_cb,
sco_audiostate_cb,
buffer_alloc,
buffer_free,
transmit_cb,
epilog_cb
};
Bt-vendor库中，init和cleanup函数只是做开始时初始化及退出时清理的工作，主要工作都在op函数中实现。
\modules\rtl8723bs\libbt\src\bt_vendor_rtk.c
static int op(bt_vendor_opcode_t opcode, void *param)
{
switch(opcode)
{
case BT_VND_OP_POWER_CTRL:
…… /* 省略中间代码 */ /* 控制蓝牙模块的上掉电 */
break;
case BT_VND_OP_FW_CFG:
/* uart接口蓝牙加载fw */
/* usb接口蓝牙fw在驱动中加载,蓝牙上电时就自动加载，这里直接返回成功 */
…… /* 省略中间代码 */
break;
case BT_VND_OP_SCO_CFG:
…… /* 省略中间代码 */
break;
case BT_VND_OP_USERIAL_OPEN:
/* 打开uart口，把打开的fd传回给hci层。无论是uart接口蓝牙，还是usb接口蓝牙（usb接口蓝牙在驱动层虚拟出一个uart口），对bt-vendor层都是打开一个串口，所以从bluedroid层看，与底层的数据收发就是对uart口的收发 */
…… /* 省略中间代码 */
break;
case BT_VND_OP_USERIAL_CLOSE:
…… /* 省略中间代码 */ /* 关闭uart口 */
break;
case BT_VND_OP_GET_LPM_IDLE_TIMEOUT:
…… /* 省略中间代码 */
break;
case BT_VND_OP_LPM_SET_MODE:
…… /* 省略中间代码 */
break;
case BT_VND_OP_LPM_WAKE_SET_STATE:
…… /* 省略中间代码 */
break;
case BT_VND_OP_EPILOG:
…… /* 省略中间代码 */
break;
}
\bluedroid\hci\src\userial.c
bool userial_open(userial_port_t port) {
/* hci层调用bt-vendor层打开uart口，返回uart口句柄，hci层对数据的收发就使用该句柄 */
…… /* 省略中间代码 */
int num_ports = vendor_send_command(BT_VND_OP_USERIAL_OPEN, &fd_array);
if (num_ports != 1) {
ALOGE("%s opened wrong number of ports: got %d, expected 1.", __func__, num_ports);
goto error;
}
userial_cb.fd = fd_array[0];
2.2.2 Bluedroid中HCI与核心层接口
HCI层与bluedroid的核心层的交互接口，也是通过把接口封装在一个回调的结构体提供给核心层，同时核心层提供一个回调的结构体。
2.3 Bluedroid的核心层
Bluedroid的核心层负责蓝牙的管理，蓝牙协议的处理，状态的管理等，整个核心层的运行都是由事件驱动的，由上层发送的事件，底层处理结果的事件，底层接收数据的事件，加上定时器的超时事件，维护着整个核心层的正常运行。
2.3.1 Bluedroid核心层的启动
Bluedroid的整体功能及运行，都是从enable Bluetooth开始，到disable Bluetooth结束。
\bluedroid\btif\src\bluetooth.c
static int init(bt_callbacks_t* callbacks )
{
…… /* 省略中间代码 */
bt_utils_init();
/* init btif */
btif_init_bluetooth();
return BT_STATUS_SUCCESS;
}
\bluedroid\btif\src\btif_core.c
bt_status_t btif_init_bluetooth()
{
UINT8 status;
btif_config_init(); /* 配置初始化 */
bte_main_boot_entry(); /* Entry point for BTE chip/stack initialization */
/* As part of the init, fetch the local BD ADDR */
memset(&btif_local_bd_addr, 0, sizeof(bt_bdaddr_t));
btif_fetch_local_bdaddr(&btif_local_bd_addr);
/* start btif task */
status = GKI_create_task(btif_task, BTIF_TASK, BTIF_TASK_STR,
(UINT16 *) ((UINT8 *)btif_task_stack + BTIF_TASK_STACK_SIZE),
sizeof(btif_task_stack));
if (status != GKI_SUCCESS)
return BT_STATUS_FAIL;
return BT_STATUS_SUCCESS;
}
\bluedroid\btif\src\bluetooth.c
static int enable( void )
{
ALOGI("enable");
/* sanity check */
if (interface_ready() == FALSE)
return BT_STATUS_NOT_READY;
return btif_enable_bluetooth();
}
\bluedroid\btif\src\btif_core.c
bt_status_t btif_enable_bluetooth(void)
{
…… /* 省略中间代码 */
/* Create the GKI tasks and run them */
bte_main_enable();
return BT_STATUS_SUCCESS;
}
\bluedroid\main\bte_main.c
void bte_main_enable()
{
APPL_TRACE_DEBUG("%s", __FUNCTION__);
/* Initialize BTE control block */
BTE_Init();
lpm_enabled = FALSE;
GKI_create_task((TASKPTR)btu_task, BTU_TASK, BTE_BTU_TASK_STR,
(UINT16 *) ((UINT8 *)bte_btu_stack + BTE_BTU_STACK_SIZE),
sizeof(bte_btu_stack));
bte_hci_enable(); /* 初始化hci层接口，上一节内容 */
GKI_run();
}
\bluedroid\stack\btu\btu_task.c
BTU_API UINT32 btu_task (UINT32 param) /* 初始化工作及进行消息处理 */
{
…… /* 省略中间代码 */
/* Initialize the mandatory core stack control blocks
(BTU, BTM, L2CAP, and SDP)
*/
btu_init_core();
/* Initialize any optional stack components */
BTE_InitStack();
#if (defined(BTU_BTA_INCLUDED) && BTU_BTA_INCLUDED == TRUE)
bta_sys_init();
#endif
/* Initialise platform trace levels at this point as BTE_InitStack() and bta_sys_init()
* reset the control blocks and preset the trace level with XXX_INITIAL_TRACE_LEVEL
*/
#if ( BT_USE_TRACES==TRUE )
BTE_InitTraceLevels();
#endif
/* Send a startup evt message to BTIF_TASK to kickstart the init procedure */
GKI_send_event(BTIF_TASK, BT_EVT_TRIGGER_STACK_INIT);
prctl(PR_SET_NAME, (unsigned long)"BTU TASK", 0, 0, 0);
raise_priority_a2dp(TASK_HIGH_BTU);
/* Wait for, and process, events */
for (;;)
\bluedroid\btif\src\btif_core.c
void btif_enable_bluetooth_evt(tBTA_STATUS status, BD_ADDR local_bd)
{ /* Bluetooth enable完成时收到事件，会调用该函数 */
…… /* 省略中间代码 */
bte_main_postload_cfg();
#if (defined(HCILP_INCLUDED) && HCILP_INCLUDED == TRUE)
bte_main_enable_lpm(TRUE);
#endif
/* add passing up bd address as well ? */
/* callback to HAL */
if (status == BTA_SUCCESS)
{
/* initialize a2dp service */
btif_av_init();
/* init rfcomm & l2cap api */
btif_sock_init();
/* init pan */
btif_pan_init();
/* load did configuration */
bte_load_did_conf(BTE_DID_CONF_FILE);
\bluedroid\btif\src\btif_av.c
bt_status_t btif_av_init()
{
if (btif_av_cb.sm_handle == NULL)
{
if (btif_a2dp_start_media_task() != GKI_SUCCESS)
return BT_STATUS_FAIL;
btif_enable_service(BTA_A2DP_SERVICE_ID);
/* Also initialize the AV state machine */
btif_av_cb.sm_handle = btif_sm_init((const btif_sm_handler_t*)btif_av_state_handlers, BTIF_AV_STATE_IDLE);
btif_a2dp_on_init();
\bluedroid\btif\src\btif_media_task.c
int btif_a2dp_start_media_task(void)
{
…… /* 省略中间代码 */
/* start a2dp media task */
retval = GKI_create_task((TASKPTR)btif_media_task, A2DP_MEDIA_TASK,
A2DP_MEDIA_TASK_TASK_STR,
(UINT16 *) ((UINT8 *)a2dp_media_task_stack + A2DP_MEDIA_TASK_STACK_SIZE),
sizeof(a2dp_media_task_stack));前面说到整个蓝牙核心层由事件驱动，所有事件的处理全部由3个task来完成。
btu_task：处理发送给上层的事件，定时超时事件，部分上层发送下来的事件，同时也会把部分事件转给btif_task处理；
btif_task：主要用于蓝牙协议的处理，处理协议状态的流转，根据不同状态调用不同的处理函数；
btif_media_task：用于a2dp的控制及音频处理；
2.3.2 Bluedroid核心层部分profile的流程
对于a2dp的流程，只给出概要框图，如下图所示。
对于opp文件传输，在bluedroid层就是使用rfcomm协议，rfcomm协议实质就是再两个蓝牙设备之间提供一个逻辑的数据通道，上层只需要使用rfcomm提供的链路就可以在两个设备之间传输数据。Opp文件传输过程中，先是两个设备进行连接，然后建立一条rfcomm通道，同事创建rfcomm与上层传输数据的Socket，后面就可以进行数据传输，设备的连接、rfcomm通道的建立。
对于蓝牙鼠标、蓝牙键盘这些输入设备，使用的是hid（human interface Device）profile，建立连接后，注册一个uhid(dev_path="/dev/uhid")设备，把输入设备发送过来的数据发送给uhid设备，由内核的hid驱动负责进行输入事件的处理，下面给出一个输入数据的流程图。
3.Bluetooth应用程序介绍（Bluetooth.apk）
Bluetooth应用程序的主要功能是负责蓝牙状态的管理，连接Bluedroid，提供各种蓝牙服务。其中btservice提供蓝牙的基本服务，各个profile提供自身独立的服务，除了opp和pabp自成一体外，其它的profile由btservice管理。
3.1 Bluetooth应用程序框图及对外接口
3.2 Bluetooth应用程序与bluedroid的接口
Bluetooth App 与bluedroid通过jni接口交互，bluetooth app 在开始时加载bluedroid库（bluetooth.default.so）,使用bluedroid提供的操作接口，同时在调用bluedroid接口提供的init函数时，传递回调结构体给bluedroid.
packages\apps\bluetooth\jni\com_android_bluetooth_btservice_AdapterService.cpp
jint JNI_OnLoad(JavaVM *jvm, void *reserved)
{
…… /* 省略中间代码 */
if ((status = android::register_com_android_bluetooth_btservice_AdapterService(e)) < 0) {
ALOGE("jni adapter service registration failure, status: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_hfp(e)) < 0) {
ALOGE("jni hfp registration failure, status: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_hfpclient(e)) < 0) {
ALOGE("jni hfp client registration failure, status: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_a2dp(e)) < 0) {
ALOGE("jni a2dp source registration failure: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_a2dp_sink(e)) < 0) {
ALOGE("jni a2dp sink registration failure: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_avrcp(e)) < 0) {
ALOGE("jni avrcp target registration failure: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_avrcp_controller(e)) < 0) {
ALOGE("jni avrcp controller registration failure: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_hid(e)) < 0) {
ALOGE("jni hid registration failure: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_hdp(e)) < 0) {
ALOGE("jni hdp registration failure: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_pan(e)) < 0) {
ALOGE("jni pan registration failure: %d", status);
return JNI_ERR;
}
if ((status = android::register_com_android_bluetooth_gatt(e)) < 0) {
ALOGE("jni gatt registration failure: %d", status);
return JNI_ERR;
}
packages\apps\bluetooth\jni\com_android_bluetooth_btservice_AdapterService.cpp
static JNINativeMethod sMethods[] = { /* 各个Native接口 */
/* name, signature, funcPtr */
{"classInitNative", "()V", (void *) classInitNative},
{"initNative", "()Z", (void *) initNative},
{"cleanupNative", "()V", (void*) cleanupNative},
{"enableNative", "()Z", (void*) enableNative},
{"disableNative", "()Z", (void*) disableNative},
{"getRecvByteNative", "()I", (void*) getRecvByteNative},
{"getSendByteNative", "()I", (void*) getSendByteNative},
{"setAdapterPropertyNative", "(I[B)Z", (void*) setAdapterPropertyNative},
{"getAdapterPropertiesNative", "()Z", (void*) getAdapterPropertiesNative},
{"getAdapterPropertyNative", "(I)Z", (void*) getAdapterPropertyNative},
{"getDevicePropertyNative", "([BI)Z", (void*) getDevicePropertyNative},
{"setDevicePropertyNative", "([BI[B)Z", (void*) setDevicePropertyNative},
{"startDiscoveryNative", "()Z", (void*) startDiscoveryNative},
{"cancelDiscoveryNative", "()Z", (void*) cancelDiscoveryNative},
{"createBondNative", "([BI)Z", (void*) createBondNative},
{"removeBondNative", "([B)Z", (void*) removeBondNative},
{"cancelBondNative", "([B)Z", (void*) cancelBondNative},
{"getConnectionStateNative", "([B)I", (void*) getConnectionStateNative},
{"pinReplyNative", "([BZI[B)Z", (void*) pinReplyNative},
{"sspReplyNative", "([BIZI)Z", (void*) sspReplyNative},
{"getRemoteServicesNative", "([B)Z", (void*) getRemoteServicesNative},
{"getRemoteMasInstancesNative", "([B)Z", (void*) getRemoteMasInstancesNative},
{"connectSocketNative", "([BI[BII)I", (void*) connectSocketNative},
{"createSocketChannelNative", "(ILjava/lang/String;[BII)I",
(void*) createSocketChannelNative},
{"configHciSnoopLogNative", "(Z)Z", (void*) configHciSnoopLogNative},
{"alarmFiredNative", "()V", (void *) alarmFiredNative},
{"readEnergyInfo", "()I", (void*) readEnergyInfo},
};
int register_com_android_bluetooth_btservice_AdapterService(JNIEnv* env)
{
return jniRegisterNativeMethods(env, "com/android/bluetooth/btservice/AdapterService",
sMethods, NELEM(sMethods));
}
packages\apps\bluetooth\jni\com_android_bluetooth_btservice_AdapterService.cpp
static bool initNative(JNIEnv* env, jobject obj) {
ALOGV("%s:",__FUNCTION__);
sJniAdapterServiceObj = env->NewGlobalRef(obj);
sJniCallbacksObj = env->NewGlobalRef(env->GetObjectField(obj, sJniCallbacksField));
if (sBluetoothInterface) {
int ret = sBluetoothInterface->init(&sBluetoothCallbacks); /* 传递给bluedroid的回调接口 */3.3 Bluetooth的状态图
整个bluetooth存在多个状态机，除了有维护蓝牙开关的状态机及设备对状态，还有部分profile使用状态机维护设备的连接状态。
注：1.两台机器配对，配对完成后，处于已配对状态，但还不是连接的状态，当需要传输文件时，才建立连接，文件传输完成后，连接会断开。
2.当机器与蓝牙耳机或蓝牙输入设备（蓝牙鼠标、键盘）配对时，配对完成后，马上会建立连接，这是由于蓝牙耳机或输入设备随时有数据传输。
4.Bluetooth framework层介绍
Bluetooth framework层的作用只要是连接Bluetooth service，为其它应用提供使用蓝牙的接口，起连接上下层的所用。
今天就到这，接下来会对相关知识点进行补充
借鉴自：https://blog.csdn.net/zjli321/article/category/6348822