添加链接
link管理
链接快照平台
  • 输入网页链接,自动生成快照
  • 标签化管理网页链接

Android GATT 连接过程源码分析

低功耗蓝牙(BLE)设备的通信基本协议是 GATT , 要操作 BLE 设备,第一步就是要连接设备,其实就是连接 BLE 设备上的 GATT service。
结合上一篇文章,我这里结合源码,分析一下 GATT 连接的流程,以及各个模块是怎么相互交互的。注意本文依据的是 Android 4.4 的源代码。

应用框架层

首先,一般应用层都是通过调用如下方法,来创建一个 GATT 连接的:

mBluetoothGatt = device.connectGatt(this, false, mGattCallback);

这里调用了方法 connectGatt(),我们来看一下源码,代码在 /frameworks/base/core/java/android/bluetooth/BluetoothDevice.java

 
public BluetoothGatt connectGatt(Context context, boolean autoConnect,
		BluetoothGattCallback callback) {
	BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
	IBluetoothManager managerService = adapter.getBluetoothManager();
	try {
		IBluetoothGatt iGatt = managerService.getBluetoothGatt();
		if (iGatt == null) {
			// BLE is not supported
			return null;
		// 创建一个 BluetoothGatt 对象
		BluetoothGatt gatt = new BluetoothGatt(context, iGatt, this);
		// 发起连接
		gatt.connect(autoConnect, callback);
		return gatt;
	} catch (RemoteException e) {Log.e(TAG, "", e);}
	return null;

这里通过 BluetoothAdapter 获取 managerService ,这是通过 Binder 机制绑定的一个远程蓝牙管理服务,进而获得 iGatt,同样,这也是一个远程的 Binder 对象,这是一个非常关键的对象,后面会详细讲。然后调用了 BluetoothGatt 的 connect() 方法,需要注意这里有一个参数 autoConnect, 如果为 false,则表示直接连接,true 表示自动连接,意思是等到设备可用,则会自动连接上。

接下来看 gatt.connect() 的实现,代码在/frameworks/base/core/java/android/bluetooth/BluetoothGatt.java

 
boolean connect(Boolean autoConnect, BluetoothGattCallback callback) {
	if (DBG) Log.d(TAG, "connect() - device: " + mDevice.getAddress() + ", auto: " + autoConnect);
	synchronized(mStateLock) {
		// 判断当前连接状态
		if (mConnState != CONN_STATE_IDLE) {
			throw new IllegalStateException("Not idle");
		mConnState = CONN_STATE_CONNECTING;
	// 这里向底层注册上层的应用
	if (!registerApp(callback)) {
		synchronized(mStateLock) {
			mConnState = CONN_STATE_IDLE;
		Log.e(TAG, "Failed to register callback");
		return false;
	// the connection will continue after successful callback registration
	mAutoConnect = autoConnect;
	return true;

这里面关键的一句是 registerApp(callback),这是向底层注册 App,底层就知道有 App 在使用蓝牙,有蓝牙消息的时候,就通过回调通知上层的 App。BLE 几乎所有操作都是通过异步回调实现的,就是通过这个你自定义的 BluetoothGattCallback 来通知你的应用的。接下来我们继续看 registerApp()

 
private boolean registerApp(BluetoothGattCallback callback) {
	if (DBG) Log.d(TAG, "registerApp()");
	if (mService == null) return false;
	mCallback = callback;
	UUID uuid = UUID.randomUUID();
	if (DBG) Log.d(TAG, "registerApp() - UUID=" + uuid);
	try {
		mService.registerClient(new ParcelUuid(uuid), mBluetoothGattCallback);
	} catch (RemoteException e) {
		Log.e(TAG,"",e);
		return false;
	return true;

可以看到,这里调用了 mService.registerClient(),这里的 mService 就是第一步创建的 BluetoothGatt对象的时候传入的 IBluetoothGatt 类型的 Binder 对象。对于这个函数的名字为什么叫 registerClient,这是因为,在 Binder 机制中,被绑定的 Service 作为称为服务端,发起绑定的一方是客户端

在继续往下看 registerClient() 这个函数之前,我们回忆一下,我们的目标是连接 BLE 设备,到这一步了,还没有看到连接动作的踪影。这是怎么回事?前面我们说过,蓝牙几乎所有的操作都是依靠回调实现,我们先来看一下这里的 mBluetoothGatt 的实现,看源代码中,这个回调对象非常大,包含所有的 Gatt 回调动作,我们这里主要看 onClientRegistered() 方法:

 
private final IBluetoothGattCallback mBluetoothGattCallback =
new IBluetoothGattCallback.Stub() {
	 * Application interface registered - app is ready to go
	 * @hide
	public void onClientRegistered(int status, int clientIf) {
		if (DBG) Log.d(TAG, "onClientRegistered() - status=" + status
				+ " clientIf=" + clientIf);
		if (VDBG) {
			synchronized(mStateLock) {
				// 这里判断状态是不是 CONN_STATE_CONNECTING,
				// 注意到前面的 `connect()` 方法中已经把 mConnState = CONN_STATE_CONNECTING;
				if (mConnState != CONN_STATE_CONNECTING) {
					Log.e(TAG, "Bad connection state: " + mConnState);
		mClientIf = clientIf;
		// 注册客户端失败,通知到应用的 callback
		if (status != GATT_SUCCESS) {
			mCallback.onConnectionStateChange(BluetoothGatt.this, GATT_FAILURE,
					BluetoothProfile.STATE_DISCONNECTED);
			synchronized(mStateLock) {
				mConnState = CONN_STATE_IDLE;
			return;
		try {
			// 这里开始做真正的连接操作了
			mService.clientConnect(mClientIf, mDevice.getAddress(),
					!mAutoConnect); // autoConnect is inverse of "isDirect"
		} catch (RemoteException e) {
			Log.e(TAG,"",e);

这个回调方法有两个参数 status 和 clientIf,前者很好理解,就是表示注册客户端是否成功。clientIf 表示从底层返回的一个 id,用来唯一标示这个客户端,接下来的所有客户端的操作请求,都需要带上这个 id。
这个回调方法中做的事情比较清晰,特别注意到 mService.clientConnect(...),这里开始调用 Service 接口开始发起连接了。

从代码中可以看到,mService 是一个很关键的对象,但是这个对象是从哪里来的呢?

应用框架和蓝牙服务的衔接: Binder

在第一段代码的分析中就提到了 iGatt 对象,从 BluetoothGatt 的构造函数可以看出,其实 mService = iGattiGatt 是 IBluetoothGatt 接口的 Binder。

我们看一下 BluetoothAdapter 是怎么获得的,BluetoothAdapter.getDefaultAdapter():

 
public static synchronized BluetoothAdapter getDefaultAdapter() {
	if (sAdapter == null) {
		IBinder b = ServiceManager.getService(BLUETOOTH_MANAGER_SERVICE);
		if (b != null) {
			IBluetoothManager managerService = IBluetoothManager.Stub.asInterface(b);
			sAdapter = new BluetoothAdapter(managerService);
		} else {
			Log.e(TAG, "Bluetooth binder is null");
	return sAdapter;

这里是一个单例模式,通过系统API ServiceManager.getService() 获得的,这里大致逻辑就是,在系统那个启动的时候,Android 会启动一些系统服务并通过 ServiceManager 管理,具体我就不往下深究了,可以具体看一下老罗的这篇文章。这里直接给出结论,这里 Binder 对象对应的服务是 BluetoothManagerService,代码在 /frameworks/base/services/java/com/android/server/BluetoothManagerService.java

我们看一下怎么从 BluetoothManagerService 中获取到 IBluetoothGatt 的 Binder 的。注意到 BluetoothManagerService 中有一个方法 bluetoothStateChangeHandler(),冲方法名就大概可以知道这个方法是在蓝牙状态变化的时候,做一些处理的。跟踪以下这个函数的调用的地方,就能验证我们的猜想是对的。这一块和本文的关系不大,我们现在来看一下 bluetoothStateChangeHandler() 的具体实现:

 
private void bluetoothStateChangeHandler(int prevState, int newState) {
	if (prevState != newState) {
		//Notify all proxy objects first of adapter state change
		if (newState == BluetoothAdapter.STATE_ON || newState == BluetoothAdapter.STATE_OFF) {
			boolean isUp = (newState==BluetoothAdapter.STATE_ON);
			sendBluetoothStateCallback(isUp);
			if (isUp) {
				// connect to GattService
				if (mContext.getPackageManager().hasSystemFeature(
							PackageManager.FEATURE_BLUETOOTH_LE)) {
					Intent i = new Intent(IBluetoothGatt.class.getName());
					doBind(i, mConnection, Context.BIND_AUTO_CREATE, UserHandle.CURRENT);
					Intent iqc = new Intent(IQBluetooth.class.getName());
					doBind(iqc, mConnection, Context.BIND_AUTO_CREATE, UserHandle.CURRENT);
			} else {
				//If Bluetooth is off, send service down event to proxy objects, and unbind
				if (!isUp && canUnbindBluetoothService()) {
					sendBluetoothServiceDownCallback();
					sendQBluetoothServiceDownCallback();
					unbindAndFinish();
		//Send broadcast message to everyone else
		Intent intent = new Intent(BluetoothAdapter.ACTION_STATE_CHANGED);
		intent.putExtra(BluetoothAdapter.EXTRA_PREVIOUS_STATE, prevState);
		intent.putExtra(BluetoothAdapter.EXTRA_STATE, newState);
		intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
		intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
		if (DBG) Log.d(TAG,"Bluetooth State Change Intent: " + prevState + " -> " + newState);
		mContext.sendBroadcastAsUser(intent, UserHandle.ALL,
				BLUETOOTH_PERM);

看到 if (isUp) 这个分支中,会绑定到以 IBluetoothGatt 的类名为 Action Name 的服务,也就是 action="android.bluetooth.IBluetoothGatt"。我们在 /packages/apps/Bluetooth 这个 App 的 AndroidManifest.xml 中找到如下的声明:

 
<service
	android:process="@string/process"
	android:name = ".gatt.GattService"
	android:enabled="@bool/profile_supported_gatt">
	<intent-filter>
		<action android:name="android.bluetooth.IBluetoothGatt" />
	</intent-filter>
</service>

我们找到了,原来是绑定到了 com.android.bluetooth.gatt.GattService 上了。如果绑定成功,会回调 mConnection 的 onServiceConnected(),其实现如下:

 
public void onServiceConnected(ComponentName className, IBinder service) {
	Message msg = mHandler.obtainMessage(MESSAGE_BLUETOOTH_SERVICE_CONNECTED);
	} else if (className.getClassName().equals("com.android.bluetooth.gatt.GattService")) {
		msg.arg1 = SERVICE_IBLUETOOTHGATT;
	msg.obj = service;
	mHandler.sendMessage(msg);

如果绑定的类名是 GattService,就会发送MESSAGE_BLUETOOTH_SERVICE_CONNECTED 消息给 mHandler,消息的第一个参数为 SERVICE_IBLUETOOTHGATT,我们接下来看 mHandler 怎么处理的:

 
@Override
public void handleMessage(Message msg) {
	if (DBG) Log.d (TAG, "Message: " + msg.what);
	switch (msg.what) {
		case MESSAGE_BLUETOOTH_SERVICE_CONNECTED:
			IBinder service = (IBinder) msg.obj;
			synchronized(mConnection) {
				if (msg.arg1 == SERVICE_IBLUETOOTHGATT) {
					mBluetoothGatt = IBluetoothGatt.Stub.asInterface(service);
					break;

最终获得 IBluetoothGatt 的 Binder,并赋值给 mBluetoothGatt,最后通过如下接口,返回给前面的 BluetoothGatt

至此,通过 Binder 机制,完成了应用框架 API 到 Service 的绑定。别忘了我们的目标:分析BLE连接的流程。通过前面的代码分析我们知道,连接的时候,先调用了 ‘mService.registerClient()’,然后在注册成功后,调用了 mService.clientConnect() 真正发起连接。我们知道了,这个 mService 实际上就是 com.android.bluetooth.gatt.GattService。我们接下来分析这个 Service,也就到了蓝牙服务层了。

蓝牙服务的代码在 packages/app/Bluetooth,编译以后成 Bluetooth.apk,安装在 /system/app/ 目录下面,GattService 运行在 com.android.bluetooth 进程中。我们接着来看 Binder 的 registerClient()接口,这个 Binder 是 GattService 的一个内部类:

 
private static class BluetoothGattBinder extends IBluetoothGatt.Stub implements IProfileServiceBinder {
	public void registerClient(ParcelUuid uuid, IBluetoothGattCallback callback) {
		GattService service = getService();
		if (service == null) return;
		service.registerClient(uuid.getUuid(), callback);

可以看到,实际上这里还是调用了 GattService 的 registerClient 方法:

 
void registerClient(UUID uuid, IBluetoothGattCallback callback) {
	enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");
	if (DBG) Log.d(TAG, "registerClient() - UUID=" + uuid);
	mClientMap.add(uuid, callback);
	// 调用 native 接口
	gattClientRegisterAppNative(uuid.getLeastSignificantBits(),
			uuid.getMostSignificantBits());

这里首先是把 uuid 以及对应的 callback 保存到一个 mClientMap 中去,这里从名字上我们就能大概清楚这里的作用,这里的 uuid 是客户端的唯一标示, uuid 对应了客户端的回调函数 callback。接下来,调用了 gattClientRegisterAppNative() 接口向底层协议栈注册客户端,看一下函数定义:

 
private native void gattClientRegisterAppNative(long app_uuid_lsb, long app_uuid_msb);

这里可以看出,实际上是客户端的标示 – UUID 注册到底层去,UUID 是 128 bit, 正好用两个 long 型的参数表示。这个函数是 JNI 的申明,具体的实现就在对应的 C/C++ 代码中。

蓝牙服务和 HAL 的调用:JNI

上面的 gattClientRegisterAppNative() 对应的 JNI 的代码在哪里呢?通过查看 AndroidManifest.xml,我们知道 Bluetooth 的自定义 Application 是 AdapterApp,里面有这样的代码:

 
static {
	if (DBG) Log.d(TAG,"Loading JNI Library");
	System.loadLibrary("bluetooth_jni");

这里是加载了 libbluetooth_jni.so 动态库。我们再看 jni 目录的 Android.mk,这里正好是生成 libbluetooth_jni 的编译脚本。这样我们就知道了对应的 C/C++ 代码在 com_android_bluetooth_gatt.cpp:

 
static JNINativeMethod sMethods[] = {
	{"gattClientRegisterAppNative", "(JJ)V", (void *) gattClientRegisterAppNative},

这是注册 JNI 函数的标准方法,关于 JNI 的详细语法,可以参考这里。可以找到对应的函数实现如下:

 
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 的 client 的 register_client() 方法,这里还是把客户端的标示 UUID 传递下去。这里的  sGattIf 是什么呢?

 
static const btgatt_interface_t *sGattIf = NULL;

它是一个 btgatt_interface_t 类型的变量,sGattIf 的初始化在 initializeNative() 中,这个函数在 GattService.start() 方法中被调用了,这个函数定义如下:

 
static void initializeNative(JNIEnv *env, jobject object) {
	if(btIf)
      return;
  if ( (btIf = getBluetoothInterface()) == NULL) {
      error("Bluetooth module is not loaded");
      return;
  if ( (sGattIf = (btgatt_interface_t *)
        btIf->get_profile_interface(BT_PROFILE_GATT_ID)) == NULL) {
      error("Failed to get Bluetooth GATT Interface");
      return;

注意这里首先通过 getBluetoothInterface() 获得整个底层的蓝牙接口。我们重点来关注以下 sGattIf 是怎么来的?
看到这里调用了 btIf->get_profile_interface(BT_PROFILE_GATT_ID)) 来获取 sGattIf 实例。

现在来看 btgatt_interface_t 是在哪里定义的,我们看一下这个文件 include 的头文件中,最有可能就是在 #include "hardware/bt_gatt.h",这就是 HAL 接口定义的地方。

硬件抽象层 HAL

HAL 头文件都放在 hardware/libhardware/include/hardware/,我们在这里找到了 bt_gatt.h,并找到了 btgatt_interface_t 的定义如下:

 
/** Represents the standard Bluetooth GATT interface. */
typedef struct {
	/** Set to sizeof(btgatt_interface_t) */
	size_t          size;
	 * Initializes the interface and provides callback routines
	bt_status_t (*init)( const btgatt_callbacks_t* callbacks );
	/** Closes the interface */
	void (*cleanup)( void );
	/** Pointer to the GATT client interface methods.*/
	const btgatt_client_interface_t* client;
	/** Pointer to the GATT server interface methods.*/
	const btgatt_server_interface_t* server;
} btgatt_interface_t;

可以看到 btgatt_interface_t 有一个成员 client,类型是 btgatt_client_interface_t
我们再来看 btgatt_client_interface_t 的定义,在 bt_gatt_client.h 中:

 
/** Represents the standard BT-GATT client interface. */
typedef struct {
    /** Registers a GATT client application with the stack */
    bt_status_t (*register_client)( bt_uuid_t *uuid );
    /** Unregister a client application from the stack */
    bt_status_t (*unregister_client)(int client_if );
    /** Create a connection to a remote LE or dual-mode device */
    bt_status_t (*connect)( int client_if, const bt_bdaddr_t *bd_addr,
                         bool is_direct, int transport );
    /** Disconnect a remote device or cancel a pending connection */
    bt_status_t (*disconnect)( int client_if, const bt_bdaddr_t *bd_addr,
                    int conn_id);
} btgatt_client_interface_t;

在这里我们看到了 register_client 这个函数指针。这个结构体的定义很长,我这里只截取了本文相关的内容。这里定义了所有 GATT 客户端操作相关的接口,例如连接、扫描、获取 Gatt Service、读写 Gatt characteristic/descriptor 等等。
但是这个结构体的具体实现在什么地方呢?我们的直觉应该就在 HAL 的实现 BlueDroid 模块了。

蓝牙协议栈:BlueDroid

BlueDroid 的代码在 external/bluetooth/bluedroid。我们在这个目录下 grep 一下:

 
$ cd external/bluetooth/bluedroid
$ grep -nr 'btgatt_interface_t' .

我们很容易找到 btgatt_interface_t 的实现:

 
// btif/src/btif_gatt.c
static const btgatt_interface_t btgattInterface = {
    sizeof(btgattInterface),
    btif_gatt_init,
    btif_gatt_cleanup,
    &btgattClientInterface,
    &btgattServerInterface,

然后在 btif/src/btif_gatt_client.c,找到 btgattClientInterface 具体的实现如下:

 
const btgatt_client_interface_t btgattClientInterface = {
	btif_gattc_register_app,
	btif_gattc_unregister_app,
	btif_gattc_open,
	btif_gattc_close,

看到这里定义了一个 btgatt_client_interface_t 的实例 btgattClientInterface,内部都是函数指针,所有的函数的实现都这这个文件中能找到。其实这个变量就是前面的代码中提到的 sGattIf->client,我们下面来看看这是是怎么关联上的。
在 btif/src/btif_gatt.c 中又如下定义:

 

extern btgatt_client_interface_t btgattClientInterface;
static const btgatt_interface_t btgattInterface = {
	sizeof(btgattInterface),
	btif_gatt_init,
	btif_gatt_cleanup,
	&btgattClientInterface,
	&btgattServerInterface,
const btgatt_interface_t *btif_gatt_get_interface()
	return &btgattInterface;

从代码中可以看出,btgattClientInterface 赋值给了 btgattInterface 的 client 成员(还记得前面的 btgatt_interface_t 的定义吧)。难道这里的 btgattInterface 就是 JNI 中的 sGattIf 吗?
确实是这样的,还记的前面的说的 sGattIf 的初始化,调用了如下接口:

 
sGattIf = (btgatt_interface_t *)btIf->get_profile_interface(BT_PROFILE_GATT_ID)

我们来看一下 get_profile_interface() 的定义,在 btif/src/bluetooth.c 中:

 
static const void* get_profile_interface (const char *profile_id)
	if (is_profile(profile_id, BT_PROFILE_GATT_ID))
		return btif_gatt_get_interface();

看到这里调用了 btif_gatt_get_interface(),实际上就是把 btgattInterface 返回赋值给了 sGattIf

到这里,变量之间的相互关系和初始化就都完全清楚了。还是不要忘记我们的目标:连接 BLE 设备。前面我们分析到了,发起 BLE 设备连接,首先是向底层协议栈注册客户端,也就是调用了 sGattIf->client->register_client(&uuid);
现在我们知道了 register_client() 的实现就在 btif/src/btif_gatt_client.c,对应的实现如下:

 
static bt_status_t btif_gattc_register_app(bt_uuid_t *uuid)
    CHECK_BTGATT_INIT();
    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/src/btif_core.c
bt_status_t btif_transfer_context (tBTIF_CBACK *p_cback, UINT16 event, char* p_params, int param_len, tBTIF_COPY_CBACK *p_copy_cback)
    tBTIF_CONTEXT_SWITCH_CBACK *p_msg;
    BTIF_TRACE_VERBOSE2("btif_transfer_context event %d, len %d", event, param_len);
    /* allocate and send message that will be executed in btif context */
    if ((p_msg = (tBTIF_CONTEXT_SWITCH_CBACK *) GKI_getbuf(sizeof(tBTIF_CONTEXT_SWITCH_CBACK) + param_len)) != NULL)
        // 给 p_msg 赋值
				// 注意这里
        btif_sendmsg(p_msg);
        return BT_STATUS_SUCCESS;
        /* let caller deal with a failed allocation */
        return BT_STATUS_NOMEM;

这里面调用了一个很重要的方法 btif_sendmsg(...),实际上是调用了 GKI_send_msg(...),接着往下看代码就会发现,实际上就是发送一个 Event,让对应的 handler 函数去处理。
据我的理解,其实就是一个类似于 Android framework 中的 Handler,你可以提交你的 Task 到指定的线程中去运行。
这里 btif_transfer_context(...) 的作用就是把代码运行的上下文(context)转为蓝牙协议栈,这部分的代码和本文关系不大,这里就不深入讨论了。
这里的 btgattc_handle_event 相当于我们要运行的 Task, 后面就是这个 Task 运行需要的一些参数。我们接下来看 btgattc_handle_event 的实现:

 
// btif/src/btif_gatt_client.c
static void btgattc_handle_event(uint16_t event, char* p_param)
    tBTA_GATT_STATUS           status;
    tBT_UUID                   uuid;
    btif_gattc_cb_t* p_cb = (btif_gattc_cb_t*)p_param;
    if (!p_cb) return;
    ALOGD("%s: Event %d", __FUNCTION__, event);
    switch (event)
        case BTIF_GATTC_REGISTER_APP:
						// UUID 的格式转换
            btif_to_bta_uuid(&uuid, &p_cb->uuid);
            BTA_GATTC_AppRegister(&uuid, bta_gattc_cback);
            break;

可以看到,这个函数的参数,都是我们上面那个 btif_transfer_context(...) 传递进来的,这里 event = BTIF_GATTC_REGISTER_APP,看一下对应的 switch 分支代码。
btif_to_bta_uuid() 非常简单,这是把 UUID 的转换为 BTA 层 UUID 格式。然后真正做事的是 BTA_GATTC_AppRegister(...)

 
// bta/gatt/bta_gattc_api.c
void BTA_GATTC_AppRegister(tBT_UUID *p_app_uuid, tBTA_GATTC_CBACK *p_client_cb)
    tBTA_GATTC_API_REG  *p_buf;
		if (bta_sys_is_register(BTA_ID_GATTC) == FALSE)
        GKI_sched_lock();
				// 注册事件处理函数
        bta_sys_register(BTA_ID_GATTC, &bta_gattc_reg);
        GKI_sched_unlock();
    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;

这里首先判断 BTA_ID_GATTC 事件处理器是否注册了,如果没有注册就注册一个 bta_gattc_reg。这里表示 bta_gattc_reg 所有的 GATT 客户端事件的处理器。
可见,这个 bta_gattc_reg 是非常重要的,我们来看它的定义:

 
// bta/sys/bta_sys.h
/* registration structure */
typedef struct
		// 事件处理函数
    tBTA_SYS_EVT_HDLR   *evt_hdlr;
		// 关闭事件处理
    tBTA_SYS_DISABLE    *disable;
} tBTA_SYS_REG;  
// bta/gatt/bta_gattc_api.c
static const tBTA_SYS_REG bta_gattc_reg =
    bta_gattc_hdl_event,
    BTA_GATTC_Disable

这是一个结构体,其定义我也贴在上面了,成员类型都是函数指针,其函数的定义我在后面会讲。
我们先往下看,这里的代码是不是看起来有些面熟,其实和 btif_transfer_context() 的逻辑非常类似,这里也是发送一个 event 给 handler 去处理。
虽然这里调用的是 bta_sys_sendmsg(...),实际上它的实现就是调用 GKI_send_msg(...)
分析方法类似,我们这里的 event 是 BTA_GATTC_API_REG_EVT,这个事件的处理函数就是上面的 bta_gattc_reg 的 bta_gattc_hdl_event

 
// bta/gatt/bta_gattc_main.c
BOOLEAN bta_gattc_hdl_event(BT_HDR *p_msg)
    tBTA_GATTC_CB *p_cb = &bta_gattc_cb;
    switch (p_msg->event)
        case BTA_GATTC_API_REG_EVT:
            bta_gattc_register(p_cb, (tBTA_GATTC_DATA *) p_msg);
            break;

到这里,我们终于看到了最终的真正执行注册客户端的函数 bta_gattc_register(...) 了:

 
// bta/gatt/bta_gattc_act.c
void bta_gattc_register(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_data)
    tBTA_GATTC               cb_data;
    UINT8                    i;
    tBT_UUID                 *p_app_uuid = &p_data->api_reg.app_uuid;
    tBTA_GATTC_INT_START_IF  *p_buf;
    tBTA_GATT_STATUS         status = BTA_GATT_NO_RESOURCES;
    APPL_TRACE_DEBUG1("bta_gattc_register state %d",p_cb->state);
    memset(&cb_data, 0, sizeof(cb_data));
    cb_data.reg_oper.status = BTA_GATT_NO_RESOURCES;
     // 检查 GATTC 模块是否开启;如果没有,就开启
     if (p_cb->state == BTA_GATTC_STATE_DISABLED)
         bta_gattc_enable (p_cb);
		// 这里遍历客户端列表
    for (i = 0; i < BTA_GATTC_CL_MAX; i ++)
				// 检查是否被占用
        if (!p_cb->cl_rcb[i].in_use)
						// 如果没有被占用,就向 GATT 协议栈注册,并获得新的 client_if
            if ((p_app_uuid == NULL) || (p_cb->cl_rcb[i].client_if = GATT_Register(p_app_uuid, &bta_gattc_cl_cback)) == 0)
                APPL_TRACE_ERROR0("Register with GATT stack failed.");
                status = BTA_GATT_ERROR;
								// GATT协议栈注册成功,就在 BTA 层也中保存下来,完成注册
                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_GATTC_INT_START_IF_EVT 事件
                    bta_sys_sendmsg(p_buf);
                    status = BTA_GATT_OK;
                    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;
		/* callback with register event */
    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;
				// 通过发送 BTA_GATTC_REG_EVT 事件,把注册结果回调给上层
        (*p_data->api_reg.p_cback)(BTA_GATTC_REG_EVT,  (tBTA_GATTC *)&cb_data);

主要流程都在代码的注释中解释了,遍历客户端列表,向 GATT statck 注册客户端,注册成功后发送 BTA_GATTC_INT_START_IF_EVT 事件。
因为这里和前面一样,同样是调用了 bta_sys_sendmsg(...),所以处理函数是 bta_gattc_hdl_event(...),我们再来看这个分支:

 
// bta/gatt/bta_gattc_main.c
BOOLEAN bta_gattc_hdl_event(BT_HDR *p_msg)
    tBTA_GATTC_CB *p_cb = &bta_gattc_cb;
    switch (p_msg->event)
        case BTA_GATTC_INT_START_IF_EVT:
            bta_gattc_start_if(p_cb, (tBTA_GATTC_DATA *) p_msg);
            break;

这里调用了 bta_gattc_start_if(...)

 
// bta/gatt/bta_gattc_act.c
void bta_gattc_start_if(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_msg)
    if (bta_gattc_cl_get_regcb(p_msg->int_start_if.client_if) !=NULL )
        GATT_StartIf(p_msg->int_start_if.client_if);
        APPL_TRACE_ERROR1("Unable to start app.: Unknown interface =%d",p_msg->int_start_if.client_if );

最终调用了 GATT_StartIf(...)

 
// stack/gatt/gatt_api.c
void GATT_StartIf (tGATT_IF gatt_if)
    tGATT_REG   *p_reg;
    tGATT_TCB   *p_tcb;
    BD_ADDR     bda;
    UINT8       start_idx, found_idx;
    UINT16      conn_id;
    GATT_TRACE_API1 ("GATT_StartIf gatt_if=%d", gatt_if);
    if ((p_reg = gatt_get_regcb(gatt_if)) != NULL)
        p_reg = &gatt_cb.cl_rcb[gatt_if - 1];
        start_idx = 0;
        while (gatt_find_the_connected_bda(start_idx, bda, &found_idx))
            p_tcb = gatt_find_tcb_by_addr(bda);
            if (p_reg->app_cb.p_conn_cb && p_tcb)
                conn_id = GATT_CREATE_CONN_ID(p_tcb->tcb_idx, gatt_if);
                (*p_reg->app_cb.p_conn_cb)(gatt_if, bda, conn_id, TRUE, 0);
            start_idx = ++found_idx;

这个函数的主要作用是,调用刚注册的客户端 gatt_if 的连接回调函数,上报所有的设备的连接状态。

我们接着分析 bta_gattc_register(...) 函数,重点是这一行:

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

这里是看起来调用了一个回调函数,这里的 (*p_data->api_reg.p_cback) 是谁,我们这里回溯以下。
回到 bta_gattc_hdl_event(...),这个 p_data 是这里传进来的 tBTA_GATTC_DATA 类型的数据,它是一个联合体(union):

 
// bta/gatt/bta_gattc_int.h
typedef union
    BT_HDR                      hdr;
    tBTA_GATTC_API_REG          api_reg;
} tBTA_GATTC_DATA;

其中 (p_data->api_reg) 成员是一个 tBTA_GATTC_API_REG,这个类型我们在 BTA_GATTC_AppRegister(...) 函数中见过。
其实这个值就是我们在这里创建的,我们看一下 p_cback 是谁,我们在往回找到 btgattc_handle_event(...)函数,发现就是 bta_gattc_cback:其定义如下:

 
// btif/src/btif_gatt_client.c
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);
    ASSERTC(status == BT_STATUS_SUCCESS, "Context transfer failed!", status);

这里又是一个通过 “handler” 机制实现运行上下文的切换,这里来看一下事件处理函数 btif_gattc_upstreams_evt

 
static void btif_gattc_upstreams_evt(uint16_t event, char* p_param)
    ALOGD("%s: Event %d", __FUNCTION__, event);
    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);
            HAL_CBACK(bt_gatt_callbacks, client->register_client_cb
                , p_data->reg_oper.status
                , p_data->reg_oper.client_if
                , &app_uuid
            break;
		btapp_gattc_free_req_data(event, p_data);

因为上面传递进来的 event 是 BTA_GATTC_REG_EVT,我们就来看这个 event 的处理代码。
bta_to_btif_uuid() 和上面的 btif_to_bta_uuid() 相反,把 BTA 的 UUID 转换为 BTIF 的格式。
然后,一个宏 HAL_CBACK,其定义如下:

 
#define HAL_CBACK(P_CB, P_CBACK, ...)\
    if (P_CB && P_CB->P_CBACK) {            \
        BTIF_TRACE_API2("HAL %s->%s", #P_CB, #P_CBACK); \
        P_CB->P_CBACK(__VA_ARGS__);         \
    }                                       \
    else {                                  \
        ASSERTC(0, "Callback is NULL", 0);  \

这里展开一下,并替换其中实际的变量:

 
bt_gatt_callbacks->client->register_client_cb(p_data->reg_oper.status, p_data->reg_oper.client_if, &app_uuid);

可以看到这里其实就是一个执行回调函数的宏。

现在问题是 bt_gatt_callbacks 是从谁?我们可以看到是在这里初始化的: