Android蓝牙源码分析——Gatt连接（一）

本文将重点描述Android蓝牙GATT连接的大致流程，不会过多地纠缠代码细节，只为了从架构上梳理清楚，为接下来深入研究底层机制奠定一个宏观认识。

首先建立GATT连接前，我们通常要扫描蓝牙设备，获得设备的BluetoothDevice对象，然后调用connectGatt去建立GATT连接并等待连接状态回调，接下来我们就开始分析这一过程，首先看看connectGatt的实现：

public BluetoothGatt connectGatt(Context context, boolean autoConnect, BluetoothGattCallback callback, int transport) {    BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();    IBluetoothManager managerService = adapter.getBluetoothManager();    try {        IBluetoothGatt iGatt = managerService.getBluetoothGatt();        if (iGatt == null) {            // BLE is not supported            return null;        }        BluetoothGatt gatt = new BluetoothGatt(context, iGatt, this, transport);        gatt.connect(autoConnect, callback);        return gatt;    } catch (RemoteException e) {Log.e(TAG, "", e);}    return null;}

这里主要是获取IBluetoothGatt，Gatt相关操作是单独抽出来的，没有都塞到IBluetoothManager中，否则会让IBluetoothManager显得很臃肿，作为蓝牙总管IBluetoothManager还是简洁一些为好。这个IBluetoothGatt的真正实现在GattService中，不过在进入GattService之前，我们先看看这个BluetoothGatt的connect函数，这里为了突出重点略去了一些代码。

boolean connect(Boolean autoConnect, BluetoothGattCallback callback) {    if (!registerApp(callback)) {        return false;    }    return true;}

这里只调用了registerApp，从字面意思上理解貌似与连接无关，只是注册一个调用方，我们看看其实现：

private boolean registerApp(BluetoothGattCallback callback) {    mCallback = callback;    UUID uuid = UUID.randomUUID();    try {        mService.registerClient(new ParcelUuid(uuid), mBluetoothGattCallback);    } catch (RemoteException e) {        return false;    }    return true;}

这里给用户传进来的callback保存起来，生成了一个UUID作为调用方的标识，然后调用IBluetoothGatt的registerClient去注册，奇怪的是这里传入的是另外一个BluetoothGattCallback，这是个典型的静态代理，想必回调后还要做一些额外处理才会走到我们自己的callback。

private final IBluetoothGattCallback mBluetoothGattCallback = new BluetoothGattCallbackWrapper() {    public void onClientRegistered(int status, int clientIf) {        mClientIf = clientIf;        if (status != GATT_SUCCESS) {            mCallback.onConnectionStateChange(BluetoothGatt.this, GATT_FAILURE, BluetoothProfile.STATE_DISCONNECTED);            return;        }        try {            mService.clientConnect(mClientIf, mDevice.getAddress(), !mAutoConnect, mTransport);        } catch (RemoteException e) {            Log.e(TAG,"",e);        }    }    ......}

这个Callback是一个BluetoothGattCallbackWrapper对象，相当于在我们自己的callback基础上增加了一些别的接口，这些接口只是用于系统内部调用。这里的onClientRegistered就是新增的接口之一，也是我们上面调用registerClient之后的回调。这个回调会返回一个clientIf和status，如果status不是成功则直接返回失败，否则继续调用IBluetoothGatt的clientConnect去真正建立连接。

好了，到此为止我们清楚了Gatt连接是分为两步的，首先要获取一个ClientIf，然后再去连接。这两个操作的实现都是在GattService中，我们先看registerClient，如下：

void registerClient(UUID uuid, IBluetoothGattCallback callback) {    mClientMap.add(uuid, callback, this);    gattClientRegisterAppNative(uuid.getLeastSignificantBits(), uuid.getMostSignificantBits());}

这里给uuid和callback建立映射，等到需要回调的时候通过uuid就可以找到callback了。再来看看gattClientRegisterAppNative的实现，是在com_android_bluetooth_gatt.cpp中，如下：

static void gattClientRegisterAppNative(JNIEnv* env, jobject object, jlong app_uuid_lsb, jlong app_uuid_msb ){    bt_uuid_t uuid;    if (!sGattIf) return;    set_uuid(uuid.uu, app_uuid_msb, app_uuid_lsb);    sGattIf->client->register_client(&uuid);}

这里sGattIf是在GattService启动的时候初始化的，对应的是一组Gatt操作的接口，包括初始化、清理、gatt client和server相关的接口。这里gatt连接作为client端调到了register_client，传入的是调用方的uuid。其实现是btif_gattc_register_app函数，如下：

static bt_status_t btif_gattc_register_app(bt_uuid_t *uuid) {    btif_gattc_cb_t btif_cb;    memcpy(&btif_cb.uuid, uuid, sizeof(bt_uuid_t));    return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_REGISTER_APP, (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);}

这里调到了btif_transfer_context，从字面上理解是改变上下文，其实际意义是切换运行线程到btif task。这里有两个问题，为什么要切换线程？如何切换线程？

首先看第一个问题，为什么要切换线程，因为调用方是跨进程调到GattService中的，所以会运行在GattService的Binder线程池中，这样就要考虑多线程同步的问题了，因为Gatt Native层实现中有大量的全局变量，多线程环境下肯定会出问题。这里有两种做法，要么到处上锁，要么切换运行线程。类似的在Java中，我们要么加synchronized，要么干脆给所有操作都post到统一的工作线程中。而这两种方案中显然后者更省心，都切到统一的线程内就不用操心多线程的事了。

再来看第二个问题，在Android Java中，我们要切换运行线程只要将逻辑封装到Runnable中然后Post到目标线程的消息队列即可。而这里是Native层该怎么做呢？其实核心思想大致相同，线程中有一个消息队列，我们将消息和操作封装成一个msg，丢到该消息队列中，再将线程唤醒去取消息执行即可。虽然说起来简单，做起来可比Java复杂得多，只是Java中很多底层细节都封装得很好了，我们上层不用再考虑而已。

在蓝牙模块初始化的时候，native层会启动两个线程，一个是btif task，另一个是btu task。上层下来的所有调用都要先丢到btif task中，然后再看情况继续丢到btu task中处理。

我们回到btif_gattc_register_app这个函数，这里虽然切换了上下文，但是要做的事还是不变的，只是改头换面了一下，变成了一个BTIF_GATTC_REGISTER_APP消息和btgattc_handle_event函数。这个函数从字面意思上理解是处理各类事件的，想必里面就是switch case了，我们只关心BTIF_GATTC_REGISTER_APP事件，其处理函数为BTA_GATTC_AppRegister，如下：

void BTA_GATTC_AppRegister(tBT_UUID *p_app_uuid, tBTA_GATTC_CBACK *p_client_cb) {    ......    if ((p_buf = (tBTA_GATTC_API_REG *) GKI_getbuf(sizeof(tBTA_GATTC_API_REG))) != NULL)    {        p_buf->hdr.event    = BTA_GATTC_API_REG_EVT;        if (p_app_uuid != NULL) {            memcpy(&p_buf->app_uuid, p_app_uuid, sizeof(tBT_UUID));        }        p_buf->p_cback      = p_client_cb;        bta_sys_sendmsg(p_buf);    }    return;}

到这里真让人无语了，简单的一个注册就像踢皮球一样被丢来丢去，又被封装成消息发射出去了，这回是被丢到了另一个线程中，就是传说中的btu task。怎么丢的我们暂时不管，还是先搞清楚怎么注册才最要紧，经过了千辛万苦终于到了真正的注册环节，就是bta_gattc_register函数了，如下：

void bta_gattc_register(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_data) {    tBTA_GATTC               cb_data;    memset(&cb_data, 0, sizeof(cb_data));    cb_data.reg_oper.status = BTA_GATT_NO_RESOURCES;    for (i = 0; i < BTA_GATTC_CL_MAX; i ++) {        if (!p_cb->cl_rcb[i].in_use) {            if ((p_cb->cl_rcb[i].client_if = GATT_Register(p_app_uuid, &bta_gattc_cl_cback)) == 0) {                status = BTA_GATT_ERROR;            } else {                p_cb->cl_rcb[i].in_use = TRUE;                p_cb->cl_rcb[i].p_cback = p_data->api_reg.p_cback;                memcpy(&p_cb->cl_rcb[i].app_uuid, p_app_uuid, sizeof(tBT_UUID));                /* BTA use the same client interface as BTE GATT statck */                cb_data.reg_oper.client_if = p_cb->cl_rcb[i].client_if;                if ((p_buf = (tBTA_GATTC_INT_START_IF *) GKI_getbuf(sizeof(tBTA_GATTC_INT_START_IF))) != NULL) {                    p_buf->hdr.event    = BTA_GATTC_INT_START_IF_EVT;                    p_buf->client_if    = p_cb->cl_rcb[i].client_if;                    bta_sys_sendmsg(p_buf);                    status = BTA_GATT_OK;                } else {                    GATT_Deregister(p_cb->cl_rcb[i].client_if);                    status = BTA_GATT_NO_RESOURCES;                    memset( &p_cb->cl_rcb[i], 0 , sizeof(tBTA_GATTC_RCB));                }                break;            }        }    }    if (p_data->api_reg.p_cback) {        if (p_app_uuid != NULL) {            memcpy(&(cb_data.reg_oper.app_uuid), p_app_uuid,sizeof(tBT_UUID));        }        cb_data.reg_oper.status = status;        (*p_data->api_reg.p_cback)(BTA_GATTC_REG_EVT,  (tBTA_GATTC *)&cb_data);    }}

这个函数稍微有点长，不过逻辑很简单，就是在一个for循环中遍历看是否有可用的clientif，如果没有就返回BTA_GATT_NO_RESOURCES，值为128。遍历的时候发现某个槽没有人用就会去调用GATT_Register注册，注册成功就会返回一个clientIf，然后就要开始往java层回调了。在往回走之前，我们先看看GATT_Register的实现：

tGATT_IF GATT_Register (tBT_UUID *p_app_uuid128, tGATT_CBACK *p_cb_info){    tGATT_REG    *p_reg;    UINT8        i_gatt_if=0;    tGATT_IF     gatt_if=0;    for (i_gatt_if = 0, p_reg = gatt_cb.cl_rcb; i_gatt_if < GATT_MAX_APPS; i_gatt_if++, p_reg++)    {        if (!p_reg->in_use)        {            memset(p_reg, 0 , sizeof(tGATT_REG));            i_gatt_if++;              /* one based number */            p_reg->app_uuid128 =  *p_app_uuid128;            gatt_if            =            p_reg->gatt_if     = (tGATT_IF)i_gatt_if;            p_reg->app_cb      = *p_cb_info;            p_reg->in_use      = TRUE;            break;        }    }    return gatt_if;}

这里逻辑很简单，就是看哪个槽没有被人占用，不过注意的是这个槽和上面的槽是不同的，上面的槽是bta_gattc_cb中的cl_rcb，这的槽是gatt_cb的cl_rcb。不过两个槽大小都一样，都是32。这样我们了解到clientIf是有数量限制的，而且是系统全局的，而不是单个APP进程内的限制。每次用完之后要及时释放，否则别的人就没法再用了。

好了接下来我们踏上归途了，看看拿到这个clientIf之后是怎么回调回上层的。回到bta_gattc_register函数中，回调是从这一句开始的

(*p_data->api_reg.p_cback)(BTA_GATTC_REG_EVT,  (tBTA_GATTC *)&cb_data);

这个p_cback是什么呢，注册的时候被封装成消息转手了无数次，但还是给揪出来了，这个指针指向的是bta_gattc_cback，如下：

static void bta_gattc_cback(tBTA_GATTC_EVT event, tBTA_GATTC *p_data) {    bt_status_t status = btif_transfer_context(btif_gattc_upstreams_evt,                    (uint16_t) event, (void*) p_data, sizeof(tBTA_GATTC), btapp_gattc_req_data);}

这里可以理解，毕竟来的路上是怎么切过来的，回去的时候就得怎么切回去。之前是先切到btif task，再切到btu task，现在要从btu task切回到btif task了，回调是btif_gattc_upstreams_evt，事件是BTA_GATTC_REG_EVT，如下：

static void btif_gattc_upstreams_evt(uint16_t event, char* p_param){    tBTA_GATTC *p_data = (tBTA_GATTC*) p_param;    switch (event)    {        case BTA_GATTC_REG_EVT:        {            bt_uuid_t app_uuid;            bta_to_btif_uuid(&app_uuid, &p_data->reg_oper.app_uuid);            bt_gatt_callbacks->client->register_client_cb(p_data->reg_oper.status, p_data->reg_oper.client_if, &app_uuid);            break;        }        ......    }}

这里的register_client_cb最终指向的是btgattc_register_app_cb函数，这已经回到了gatt service的native中了，如下：

void btgattc_register_app_cb(int status, int clientIf, bt_uuid_t *app_uuid){    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientRegistered, status,        clientIf, UUID_PARAMS(app_uuid));}

这里调用到了Java层的onClientRegistered函数，返回的正是clientIf和uuid。至此，整个clientIf的注册流程终于走通了，虽然中间有很多代码细节我们没有深究，不过那都不重要了，有了对总体的把握，以后遇到具体问题再细看也不迟。而且代码细节很可能在以后Android升级时有重大改动，但总体思想和大致流程基本不会变的。

总结一下调用流程，App发起的Gatt连接请求被丢到GattService中，分解为两步走，第一步是注册ClientIf，注册成功后再拿着ClientIf建立真正的连接。先看ClientIf的注册，会往下走到GattService的native层中，再往下走到BlueDroid层，注册ClientIf完之后，会回到GattService的native层，再回调到GattService java层，这时如果ClientIf是注册成功的，则继续走Gatt连接流程，否则直接回调失败给用户。

下文我们将继续分析蓝牙真正的Gatt连接流程。