Android5.0.2蓝牙源码分析

本文只是简单地分析了一下代码的调用流程，大家可以先把流程走通了，代码分析和修改定制，也就相对简单了。

本人使用的是友善之臂tiny4412系统版本是Android5.0.2 分析蓝牙部分代码，其中使用到状态机，还有就是JNI里边的一些东西。

BluetoothAdapter mAdapter= BluetoothAdapter.getDefaultAdapter();

 mAdapter.enable();

1、路径：frameworks/base/core/java/android/buletooth/BluetoothAdapter.java 

public final class BluetoothAdapter {
 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;
    }


    /**
     * Use {@link #getDefaultAdapter} to get the BluetoothAdapter instance.
     */
    BluetoothAdapter(IBluetoothManager managerService) {
        if (managerService == null) {
            throw new IllegalArgumentException("bluetooth manager service is null");
        }
        try {
            mService = managerService.registerAdapter(mManagerCallback);
        } catch (RemoteException e) {Log.e(TAG, "", e);}
        mManagerService = managerService;
        mLeScanClients = new HashMap<LeScanCallback, ScanCallback>();
    }
    public boolean enable() {
        if (isEnabled() == true){
            if (DBG) Log.d(TAG, "enable(): BT is already enabled..!");
            return true;
        }
        try {
            return mManagerService.enable();
        } catch (RemoteException e) {Log.e(TAG, "", e);}
        return false;
    }
}
实现硬件访问服务
2、路径：frameworks/base/services/core/java/com/android/server/BluetoothManagerService.java
class BluetoothManagerService extends IBluetoothManager.Stub {
 public boolean enable(){
  sendEnableMsg(false);
}
private void sendEnableMsg(boolean quietMode) {
        mHandler.sendMessage(mHandler.obtainMessage(MESSAGE_ENABLE,
                             quietMode ? 1 : 0, 0));
    }
  case MESSAGE_ENABLE:
                    if (DBG) {
                        Log.d(TAG, "MESSAGE_ENABLE: mBluetooth = " + mBluetooth);
                    }
                    mHandler.removeMessages(MESSAGE_RESTART_BLUETOOTH_SERVICE);
                    mEnable = true;
                    handleEnable(msg.arg1 == 1);
                    break;
private void handleEnable(boolean quietMode) {
if (!mQuietEnable) {
                        if(!mBluetooth.enable()) {
                            Log.e(TAG,"IBluetooth.enable() returned false");
                        }
                    }

}

3、路径：frameworks/base/core/java/android/bluetooth/IBluetooth.aidl

interface IBluetooth
{
   boolean isEnabled();
    int getState();
    boolean enable();
    boolean enableNoAutoConnect();
    boolean disable();
}

4、路径：packages/app/Bluetooth/src/com/android/bluetooth/btservice/AdapterService.java
private static class AdapterServiceBinder extends IBluetooth.Stub {
        private AdapterService mService;
        public AdapterServiceBinder(AdapterService svc) {
            mService = svc;
        }
        public boolean enable() {
            if ((Binder.getCallingUid() != Process.SYSTEM_UID) &&
                (!Utils.checkCaller())) {
                Log.w(TAG, "enable() - Not allowed for non-active user and non system user");
                return false;
            }
            AdapterService service = getService();
            if (service == null) return false;
            return service.enable();
        }
}
     boolean enable() {
        return enable (false);
    }
     public synchronized boolean enable(boolean quietMode) {
         enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
                                        "Need BLUETOOTH ADMIN permission");
         debugLog("enable() - Enable called with quiet mode status =  " + mQuietmode);
         mQuietmode  = quietMode;
         Message m =
                 mAdapterStateMachine.obtainMessage(AdapterState.USER_TURN_ON);
                 mAdapterStateMachine.sendMessage(m);
         return true;
     }
从这里开始就进入状态机了，状态机的过程不了解的话，可以直接看它最终执行的函数第 7 步。
5、路径：packages/app/Bluetooth/src/com/android/bluetooth/btservice/AdapterState.java
 private class OffState extends State {
        @Override
        public void enter() {
            infoLog("Entering OffState");
        }
        @Override
        public boolean processMessage(Message msg) {
            AdapterService adapterService = mAdapterService;
            if (adapterService == null) {
                Log.e(TAG,"receive message at OffState after cleanup:" +
                          msg.what);
                return false;
            }
            switch(msg.what) {
               case USER_TURN_ON:
                   if (DBG) Log.d(TAG,"CURRENT_STATE=OFF, MESSAGE = USER_TURN_ON");
                   notifyAdapterStateChange(BluetoothAdapter.STATE_TURNING_ON);
                   mPendingCommandState.setTurningOn(true);
                   transitionTo(mPendingCommandState);
                   sendMessageDelayed(START_TIMEOUT, START_TIMEOUT_DELAY);
                    adapterService.processStart();
                   break;
}
}
}
 这是一个操作类，里边有好多  native 操作函数，也就是说，所有的操作最终都会进到这里边来，通过 JNI native 去操作下一层C代码。 
6、路径：packages/app/Bluetooth/src/com/android/bluetooth/btservice/AdapterService.java

void processStart() {
      ......
        setAdapterService(this);
        //Start profile services
        if (!mProfilesStarted && supportedProfileServices.length >0) {
            //Startup all profile services
            setProfileServiceState(supportedProfileServices,BluetoothAdapter.STATE_ON);
        }else {
            debugLog("processStart() - Profile Services alreay started");
            mAdapterStateMachine.sendMessage(mAdapterStateMachine.obtainMessage(AdapterState.STARTED));
        }
7、路径：packages/app/Bluetooth/src/com/android/bluetooth/btservice/AdapterState.java
    private class PendingCommandState extends State {
  public boolean processMessage(Message msg) {
      switch (msg.what) {
 case STARTED:   {
                    if (DBG) Log.d(TAG,"CURRENT_STATE=PENDING, MESSAGE = STARTED, isTurningOn=" +  isTurningOn +                         ", isTurningOff=" + isTurningOff);
                    //Remove start timeout
                    removeMessages(START_TIMEOUT);
                    //Enable
                    boolean ret = adapterService.enableNative();
                    if (!ret) {
                        Log.e(TAG, "Error while turning Bluetooth On");
                        notifyAdapterStateChange(BluetoothAdapter.STATE_OFF);
                        transitionTo(mOffState);
                    } else {
                        sendMessageDelayed(ENABLE_TIMEOUT, ENABLE_TIMEOUT_DELAY);
                    }
                }
                    break;
}
}
这个时候从状态机跳出来了，又回到了这个操作类。
8、路径：packages/apps/Bluetooth/src/com/android/bluetooth/btservice/AdapterService.java

    private native static void classInitNative();
    private native boolean initNative();
    private native void cleanupNative();
    /*package*/ native boolean enableNative();
    /*package*/ native boolean disableNative();
    /*package*/ native boolean setAdapterPropertyNative(int type, byte[] val);
    /*package*/ native boolean getAdapterPropertiesNative();

开始调用JNI，这个可以有专门讲JNI的 https://www.jianshu.com/p/ac00d59993aa。

9、路径：packages/apps/Bluetooth/jni/com_android_bluetooth_btservice_AdapterService.cpp

static jboolean enableNative(JNIEnv* env, jobject obj) {
    ALOGV("%s:",__FUNCTION__);
    jboolean result = JNI_FALSE;
    if (!sBluetoothInterface) return result;

    int ret = sBluetoothInterface->enable();
    result = (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;
    return result;
}
10、路径：external/bluetooth/bluedroid/btif/src/bluetooth.c

static int enable( void )
{
    ALOGI("enable");
    /* sanity check */
    if (interface_ready() == FALSE)
        return BT_STATUS_NOT_READY;
    return btif_enable_bluetooth();
}

11、路径：external/bluetooth/bluedroid/btif/src/btif_core.c

bt_status_t btif_enable_bluetooth(void)
{
    BTIF_TRACE_DEBUG("BTIF ENABLE BLUETOOTH");

    if (btif_core_state != BTIF_CORE_STATE_DISABLED)
    {
        ALOGD("not disabled\n");
        return BT_STATUS_DONE;
    }
    btif_core_state = BTIF_CORE_STATE_ENABLING;

    /* Create the GKI tasks and run them */
    bte_main_enable();
    return BT_STATUS_SUCCESS;
}
12、路径：external/bluetooth/bluedroid/main/bte_main.c
void bte_main_enable()
{
    APPL_TRACE_DEBUG("%s", __FUNCTION__);
    /* Initialize BTE control block */
    BTE_Init();
    lpm_enabled = FALSE;
    GKI_create_task((TASKPTR)btu_task, BTU_TASK, BTE_BTU_TASK_STR,
                    (UINT16 *) ((UINT8 *)bte_btu_stack + BTE_BTU_STACK_SIZE),
                    sizeof(bte_btu_stack));
    bte_hci_enable();
    GKI_run();
}
static void bte_hci_enable(void)
{
    APPL_TRACE_DEBUG("%s", __FUNCTION__);
    preload_start_wait_timer();
    if (bt_hc_if)
    {
        int result = bt_hc_if->init(&hc_callbacks, btif_local_bd_addr.address);
        APPL_TRACE_EVENT("libbt-hci init returns %d", result);
        assert(result == BT_HC_STATUS_SUCCESS);
        if (hci_logging_enabled == TRUE || hci_logging_config == TRUE)
            bt_hc_if->logging(BT_HC_LOGGING_ON, hci_logfile, hci_save_log);
#if (defined (BT_CLEAN_TURN_ON_DISABLED) && BT_CLEAN_TURN_ON_DISABLED == TRUE)
        APPL_TRACE_DEBUG("%s  Not Turninig Off the BT before Turninig ON", __FUNCTION__);

#else
        /* toggle chip power to ensure we will reset chip in case
           a previous stack shutdown wasn't completed gracefully */
        bt_hc_if->set_power(BT_HC_CHIP_PWR_OFF);
#endif

        bt_hc_if->set_power(BT_HC_CHIP_PWR_ON);

        bt_hc_if->preload(NULL);
    }
}
13、路径：external/bluetooth/bluedroid/hci/src/bt_hci_bdroid.c
static void set_power(bt_hc_chip_power_state_t state)
{
    int pwr_state;
    BTHCDBG("set_power %d", state);
    /* Calling vendor-specific part */
    pwr_state = (state == BT_HC_CHIP_PWR_ON) ? BT_VND_PWR_ON : BT_VND_PWR_OFF;
    vendor_send_command(BT_VND_OP_POWER_CTRL, &pwr_state);

}

14、路径：external/bluetooth/bluedroid/hci/src/vendor.c

int vendor_send_command(bt_vendor_opcode_t opcode, void *param) {
  assert(vendor_interface != NULL);
  return vendor_interface->op(opcode, param);
}
15、路径：hardware\broadcom\libbt\src\Bt_vendor_brcm.c
static int init(const bt_vendor_callbacks_t* p_cb, unsigned char *local_bdaddr){}
static int op(bt_vendor_opcode_t opcode, void *param)
{  switch(opcode)
    {
        case BT_VND_OP_POWER_CTRL:
            {
                int *state = (int *) param;
                if (*state == BT_VND_PWR_OFF)
                    upio_set_bluetooth_power(UPIO_BT_POWER_OFF);
                else if (*state == BT_VND_PWR_ON)
                    upio_set_bluetooth_power(UPIO_BT_POWER_ON);
            }
            break;
}
}


16、路径：hardware\broadcom\libbt\src\upio.c
int upio_set_bluetooth_power(int on)
{
    int sz;
    int fd = -1;
    int ret = -1;
    char buffer = '0';
    switch(on)
    {
        case UPIO_BT_POWER_OFF:
            buffer = '0';
            break;
        case UPIO_BT_POWER_ON:
            buffer = '1';
            break;
    }
    if (is_emulator_context())
    {
        /* if new value is same as current, return -1 */
        if (bt_emul_enable == on)
            return ret;
        UPIODBG("set_bluetooth_power [emul] %d", on);
        bt_emul_enable = on;
        return 0;
    }
    /* check if we have rfkill interface */
    if (is_rfkill_disabled())
        return 0;
    if (rfkill_id == -1)
    {
        if (init_rfkill())
            return ret;
    }
    fd = open(rfkill_state_path, O_WRONLY);
    if (fd < 0)
    {
        ALOGE("set_bluetooth_power : open(%s) for write failed: %s (%d)",
            rfkill_state_path, strerror(errno), errno);
        return ret;
    }
    sz = write(fd, &buffer, 1);
    if (sz < 0) {
        ALOGE("set_bluetooth_power : write(%s) failed: %s (%d)",
            rfkill_state_path, strerror(errno),errno);
    }
    else
        ret = 0;
    if (fd >= 0)
        close(fd);
    return ret;
}
看到open(), 这部分算是结束了，下边就是Linux内核中的驱动了，这部分还没有开始看。