本文将重点描述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连接流程。
