Android bluetooth介绍—连接

最新推荐文章于 2024-05-10 20:20:55 发布
最新推荐文章于 2024-05-10 20:20:55 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： Android-OS 文章标签： 蓝牙 源码 蓝牙连接分析

一、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;  
    }

idh.code\external\bluetooth\hcidump\parser\avdtp.c 

    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;  
}

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;  
}





（二）、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关联起来，于是就实现了文件描述符传递。


nullZgy
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android蓝牙a2dp协议流程分析(四)--avdtp简介
手机-手表蓝牙开发工程师的博客
02-02 278
上面整个的avdtp协议就是我们avdtp代码流程的全部过程，也是为我们后面阅读代码大侠基础，下期我们来说说avdtp交互流程。AVDTP：音视频分发协议，定义了基础的音视频分发，音视频的参数协商，但是没有音视频的编解码，是A2DP的基础协议。A2DP：高级音视频分发协议，协商使用哪种编解码器，使用哪种比特率传输音视频。AVDTP在协议栈上的结构：向上层提供了三个接口，向下层提供了2个接口。值得注意的是，我们avdtp整个代码，都是按照下面的交互流程来执行的。AVRCP：音视频控制协议，定义了播放暂停等。
Android 蓝牙开发（十）A2DP源码分析
奋斗的菜鸟ing
05-18 1万+
上一篇说了下A2DP的一些基本操作，这篇分析下系统应用、系统源码是如何操作A2DP的。尤其是其连接过程，基于Android4.3源码
Android bluetooth介绍（四）： a2dp connect流程分析
热门推荐
CLK
08-17 3万+
关键词：蓝牙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作者：xubi
Android蓝牙连接a2dp蓝牙耳机
fanfan
12-06 4377
开发环境： 开发工具：Androidstudio 适配机型：honor8(Android6.0)， 坚果R1(Android8.0) 开发功能：Android中蓝牙连接A2DP设备，蓝牙耳机设备 功能实现： 本应用提供以下功能： 第一：开启蓝牙 第二：查找过滤掉A2DP设备 第三：连接A2DP设备 第四：断开连接A2DP设备 第五：保存通过本应用连接的A2DP设备 第六：当重新启动应用时加载已连接...
ADK2.0 A2DP个链接过程解析
10-16
详细阐述ADK2.0中关于a2dp初始化、建立信号连接、暂停流控制等操作流程。
Android Bluetooth OPP Bugreport
10-09
在Android系统中，Bluetooth OPP（Object Push Profile）是一种用于设备间传输小文件的协议，它允许用户方便地发送图片、联系人、日历事件等数据。这篇博客文章的附件是针对一个特定的Android设备（可能是Xiaomi设备...
android bluetooth搜索连接实例
01-30
一个很简单的bluetooth搜索和连接的例子，没有后续的数据通讯，适合数学者参考，本实例借鉴了部分网上的代码，工程使用android studio创建
android bluetooth framework,application 层分析
12-18
AndroidBluetooth Framework 是 Android 操作系统中的蓝牙协议栈，负责管理蓝牙设备的连接、数据传输和蓝牙 Profile 的管理。整个蓝牙系统可以分为四个层次：蓝牙嵌入式系统（BTE）、蓝牙应用（BTA）、蓝牙系统服务...
Unity Bluetooth LE for iOS tvOS and Android
11-15
亲测~ Android可以正常扫描连接接收和发送指令给蓝牙 有demo~
Android_BlueTooth.rar
11-21
在Android平台上，蓝牙（BlueTooth）是一种广泛用于设备间短距离无线通信的技术，它允许智能手机、平板电脑、智能手表和其他支持蓝牙的设备之间交换数据或建立连接。本教程将深入探讨Android Bluetooth API的使用，...
Android7.0 IBluetoothA2dp.aidl
08-22
可用于android应用通过A2dp协议进行蓝牙耳机连接，详情可参见博客 https://blog.csdn.net/csdn_xiaozhe/article/details/81937511
基于Android的蓝牙A2DP功能的实现
10-11
蓝牙（Bluetooth）技术是一种低成本的无线数据与数字通信的开放性全球规范。 Android 是Google 于2007 年11 月5 日宣布的基于Linux 平台开源手机操作系统名称，该平 台由操作系统、中间件、用户界面和应用软件组成，号称是首个为移动终端打造的真正开放 和完整的移动软件。本文通过研究蓝牙无线通信协议栈，在Android 手机平台上设计并实现 了蓝牙立体声耳机收听高保真音乐的功能（即A2DP 应用框架的实现）。
Android 蓝牙 A2DP协议连接流程图（协议栈），非常详细的从btif-bta-btm-hci 数据流程走向，以及从con
04-30
Android 蓝牙 A2DP协议连接流程图（协议栈），非常详细的从btif-bta-btm-hci 数据流程走向，以及从controller收到数据到btm层，将Android 源码使用流程图的形式画了出来，使Android 蓝牙开发者更清楚数据收发走向，代码流程更加形象生动，能够很快的熟悉Android 蓝牙源码，利于后面问题处理和BUG解决。
Android 蓝牙L2cap协议源码分析大全，非常详细的从btif-bta-btm-hci 数据流程走向，以及从control
04-14
Android 蓝牙L2cap协议源码分析大全，非常详细的从btif-bta-btm-hci 数据流程走向，以及从controller收到数据到btm层，将Android 源码每个函数都摘录出来，进行分析，使Android 蓝牙开发者更清楚数据收发走向，代码流程更加形象生动，能够很快的熟悉Android 蓝牙源码，利于后面问题处理和BUG解决。
A2dp连接流程源码分析
weixin_33809981的博客
08-07 1368
在上一篇文章中，我们已经分析了：a2dp初始化流程 这篇文章主要分析a2dp的连接流程，其中还是涉及到一些底层的profile以及protocol，SDP、AVDTP以及L2CAP等。 当蓝牙设备与主机配对完成之后，作为一个BREDR设备，会走SDP的流程进行服务搜索，当服务搜索完成之后，上层应用得到了该设备的相关的服务，将启动相关的profile 的连接流程，如果对方是一个音箱设备，那么就会...
android-BluetoothA2dp
燃烧那滴泪的专栏
07-17 3719
BluetoothA2dp public final class BluetoothA2dp  extends Object implements BluetoothProfile java.lang.Object    ↳ android.bluetooth.BluetoothA2dp This class provides the
Android Bluetooth A2DP
我有一壶酒
10-11 2929
结合日志分析Android Bluetooth A2DP
Android BluetoothA2dp
最新发布
liuning1985622的博客
05-10 1322
高级音频分发规范 (A2DP) 定义了实现以单声道（mono）、立体声（stereo）或多声道（multi-channel）模式分发高质量音频内容的协议和程序。因此，术语“高级音频（advanced audio）”应与“蓝牙音频（Bluetooth audio）”区分开来，后者表示在蓝牙核心规范第 2 卷 B 部分第 9 节中定义的 SCO 通道上的窄带语音分布。一个典型的用例是将音乐内容从立体声音乐播放器流式传输到耳机或扬声器。音频数据以适当的格式压缩，以有效利用有限的带宽。
android bluetooth a2dp 连接
05-08
Android Bluetooth A2DP 连接是指安卓设备通过蓝牙无线技术，连接到支持A2DP（Advanced Audio Distribution Profile）协议的耳机、音箱或汽车音响等设备，实现高质量音频传输。 在连接前，先确保设备支持A2DP并开启...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值