android 蓝牙 bluetooth.apk

首先我们先熟悉一下蓝牙协议的基本规范

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
————————————————
版权声明:本文为CSDN博主「飞_哥」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/pashanhu6402/java/article/details/80061154

你可能感兴趣的:(android,蓝牙系列)