继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

Android GATT 连接过程源码分析

白板的微信
关注TA
已关注
手记 341
粉丝 70
获赞 385

低功耗蓝牙(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 怎么处理的:

@Overridepublic 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.cstatic 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.cbt_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;
    }
    else
    {
        /* 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.cstatic 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.cvoid 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.cstatic 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.cBOOLEAN 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.cvoid 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;
            }
            else
            {
                                // 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;
                }
                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;
            }
        }
    }

        /* 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.cBOOLEAN 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.cvoid 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);
    }
    else
    {
        APPL_TRACE_ERROR1("Unable to start app.: Unknown interface =%d",p_msg->int_start_if.client_if );
    }}

最终调用了 GATT_StartIf(...)

// stack/gatt/gatt_api.cvoid 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.htypedef 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.cstatic 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 是从谁?我们可以看到是在这里初始化的:

static bt_status_t btif_gatt_init( const btgatt_callbacks_t* callbacks )  {
    bt_gatt_callbacks = callbacks;

    return BT_STATUS_SUCCESS;}

也就是初始化的时候,通过传递进来的。在分析 BlueDroid 的最开始我们已经看到了 btgattInterface 的初始化了,这里的 btif_gatt_init 函数就赋值给了它的 init 成员。 通过我们前面的分析,btgattInterface 实际上就是 JNI 层的 sGattIf 对象。我们回到 JNI 层的代码:

// /packages/apps/Bluetooth/jni/com_android_bluetooth_gatt.cppstatic void initializeNative(JNIEnv *env, jobject object) {  
        ...
    // 这里我们前面分析过    if ( (sGattIf = (btgatt_interface_t *)
          btIf->get_profile_interface(BT_PROFILE_GATT_ID)) == NULL) {
        error("Failed to get Bluetooth GATT Interface");
        return;
    }

        // 注意这里调用初始化方法 init(...)    bt_status_t status;
    if ( (status = sGattIf->init(&sGattCallbacks)) != BT_STATUS_SUCCESS) {
        error("Failed to initialize Bluetooth GATT, status: %d", status);
        sGattIf = NULL;
        return;
    }

    mCallbacksObj = env->NewGlobalRef(object);}

这里调用了 sGattIf->init(...) 方法,实际上就是前面的 btif_gatt_init(...) 函数。看到这里传入的 sGattCallbacks 就是我们在 BlueDroid 层寻找的 bt_gatt_callbacks。 我们来看 sGattCallbacks 的定义:

// /packages/apps/Bluetooth/jni/com_android_bluetooth_gatt.cppstatic const btgatt_callbacks_t sGattCallbacks = {  
    sizeof(btgatt_callbacks_t),
    &sGattClientCallbacks,
    &sGattServerCallbacks};

通过前面的分析,我们应该能很快知道 btgatt_callbacks_t 应该在 HAL 中定义的,然后 sGattClientCallbacks 就是对应的 client 成员。 在来看 sGattClientCallbacks 的定义:

// /packages/apps/Bluetooth/jni/com_android_bluetooth_gatt.cppstatic const btgatt_client_callbacks_t sGattClientCallbacks = {  
    btgattc_register_app_cb,
        ...};

这里的 btgattc_register_app_cb 对应的就是 btgatt_client_callbacks_t 的 register_client_cb 成员。所以我们再来看一下那个展开的宏,这里再贴一下:

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

实际上就是调用了 JNI 中定义的 btgattc_register_app_cb 函数:

// /packages/apps/Bluetooth/jni/com_android_bluetooth_gatt.cppvoid btgattc_register_app_cb(int status, int clientIf, bt_uuid_t *app_uuid)  {
    CHECK_CALLBACK_ENV
    sCallbackEnv->CallVoidMethod(mCallbacksObj, method_onClientRegistered, status,
        clientIf, UUID_PARAMS(app_uuid));
    checkAndClearExceptionFromCallback(sCallbackEnv, __FUNCTION__);}

这里通过 JNI 调用了函数 id 为 method_onClientRegistered 函数,

// /packages/apps/Bluetooth/jni/com_android_bluetooth_gatt.cppstatic void classInitNative(JNIEnv* env, jclass clazz) {  
    // Client callbacks    method_onClientRegistered = env->GetMethodID(clazz, "onClientRegistered", "(IIJJ)V");
        ...}

这里就对应了 Java class 中的 onClientRegistered(...) 方法,这里 clazz 是谁呢?

// /packages/apps/Bluetooth/jni/com_android_bluetooth_gatt.cppstatic JNINativeMethod sMethods[] = {  
    {"classInitNative", "()V", (void *) classInitNative},
        ...}

我们在 GattService.java 中看到:

// /packages/apps/Bluetooth/src/com/android/bluetooth/gatt/GattService.javapublic class GattService extends ProfileService {  
    static {
        classInitNative();
  }}

可见,上面的 clazz 就是 GattServiceonClientRegistered 就是 GattService 的成员方法。我们在 GattService 类中找到其实现如下:

// /packages/apps/Bluetooth/src/com/android/bluetooth/gatt/GattService.javavoid onClientRegistered(int status, int clientIf, long uuidLsb, long uuidMsb)  
        throws RemoteException {
    UUID uuid = new UUID(uuidMsb, uuidLsb);
    if (DBG) Log.d(TAG, "onClientRegistered() - UUID=" + uuid + ", clientIf=" + clientIf);
    ClientMap.App app = mClientMap.getByUuid(uuid);
    if (app != null) {
        app.id = clientIf;
        app.linkToDeath(new ClientDeathRecipient(clientIf));
        app.callback.onClientRegistered(status, clientIf);
    }}

哈哈,终于回到我们熟悉的 Java 层代码。还记得我们前面的在分析调用 registerClient(...) 的时候,把上层客户端与 uuid 对应起来,保存在 mClientMap 中。 这里通过 uuid 找到对应的客户端App,然后调用对应的回调函数 app.callback.onClientRegistered(status, clientIf);。 如果你还记得前面的分析的话,应该知道这个 callback 就是 BluetoothGatt 在调用 registerApp(...) 的时候传递的 mBluetoothGattCallback,所以这里就调用了 mBluetoothGattCallback.onClientRegistered(...) 方法。 这个 onClientRegistered() 回调我们在之前就提到过,如果注册客户端完成,就会回调这里。如果成功,就会发起真正的连接请求(见第 1 节)。到这里,其实就回调了 Android framework 层了。

如果这里注册客户端成功了,回调的 status 就是 GATT_SUCCESS,在 BluetoothGatt 中就会发起连接请求 mService.clientConnect(mClientIf, mDevice.getAddress(), !mAutoConnect);。具体的流程和上面整个分析类似。 有了上面的整个分析经验,这次应该就驾轻就熟了。所以我这里也不再往下继续说了。

总结

结合文章开始的那个图,回顾一下代码整个调用过程,非常清楚印证流程:framework-> Bluetooth service -> JNI -> HAL -> BlueDroid。 整个分析下来,几乎贯穿了整个 Android 系统,尽管还有很多细节没有展开去了解,但是脉络还是很清晰的。 第一次写分析源代码的文章,不知不觉就写了这么长(其实大部分是代码),花费了很多精力,也不知道说清楚了没有。对我自己来说,还是收获不少。

原文链接:http://www.apkbus.com/blog-705730-61291.html

打开App,阅读手记
0人推荐
发表评论
随时随地看视频慕课网APP