Bluetooth

android -- 蓝牙 bluetooth （一） 入门

目录(?)[+]

        前段时间在 网上看了一些关于android蓝牙的文章，发现大部分是基于老版本（4.1以前含4.1）的源码，虽然无碍了解蓝牙的基本原理和工作流程，但对着4.2.2的代码看起来总是有些遗憾。所以针对4.2.2版本代码整理下相关知识，当然蓝牙工作的主干流程是没有变的，上电、加载驱动这些动作少不了的，只是这些功能的实现代码位置变了不少。希望本文可以让大家对android4.2的蓝牙部分代码有一个初步的了解。

        正文开始前，先明确代码版本：android  jellyBean 4.2.2，后续的蓝牙相关文章同样如此。

        另推荐个源码在线阅读网址 /，已经知道的童鞋无视这行吧。

        入手一个新的模块或应用，当然首先要知道它都有什么了，与它相关的代码在那里，所以先一起看下蓝牙代码分布吧。

1. 代码分布：

    packages/apps/Bluetooth/     

         看这路径肯定是蓝牙应用方面的代码了，主要是关于蓝牙应用协议的表现代码，包括opp、hfp、hdp、a2dp、pan等等，这些名词后面再解释。

    frameworks/base/core/java/android/server/  

          4.2以后这个目录虽然还有了，但里面代码已经转移到应用层了，就是前面那个目录，所以4.2.2上的蓝牙这里可以忽略。

    framework/base/core/java/android/bluetooth  

           这个目录里的代码更像一个桥梁，里面有供java层使用一些类，也有对应的aidl文件联系C、C++部分的代码，还是挺重要的。

    kernel\drivers\bluetoothBluetooth    

           具体协议实现。包括hci,hid，rfcomm,sco,SDP等协议

    kernel\net\bluetooth Linux kernel

           对各种接口的Bluetoothdevice的驱动。例如：USB接口，串口等，上面kernel这两个目录有可能看不到的，但一定会有的。

    external\bluetooth\bluedroid      BlueZ (应用空间协议)，官方蓝牙协议栈。

    system\bluetoothBluetooth        适配层代码，和framework那个作用类似，是串联framework与blueZ的工具。

        大致代码分布就是这些，初步查看后让我们再来看下蓝牙的整体结构。

2.整体结构：

        这部分直接上图了，看着直观些。图中把JNI部分虽然在目前4.2的代码中在packages层，这里还是画在Framework层了，说明下希望

不要引起理解的误会。从图上可以感觉到整体流程和以前变化不大，所以流程方面的文章看4.1或更早的应该问题也不大。

 PS：上图关于蓝牙协议栈的说明有误，4.2里已经不再是bluez了，在些更正一下，当然协议栈这一部分还是要有的，新的协议栈看下面英文：

Android 4.2 introduces a new Bluetooth stack optimized for use with Android devices. The new Bluetooth stack developed in 

collaboration between Google and Broadcom replaces the stack based on BlueZ and provides improved compatibility and reliability.

google和broadcom合作开发了一个新蓝牙协议栈，老版本的兼容性问题在所难免了。在此感谢网友andger032的提醒。

3.常用类和名词解释：  

   \packages\apps\Settings\src\com\android\settings\bluetooth 目录下

     BluetoothEnabler.java   界面上蓝牙开启、关闭的开关就是它了， 

     BluetoothSettings.java  主界面，用于管理配对和连接设备

     LocalBluetoothManager.java  提供了蓝牙API上的简单调用接口，这里只是开始。

    CachedBluetoothDevice.java   描述蓝牙设备的类，对BluetoothDevice的再封装

    BluetoothPairingDialog.java  那个配对提示的对话框

  /packages/apps/Phone/src/com/android/phone/

    BluetoothPhoneService.java  在phone的目录肯定和电话相关了，蓝牙接听挂断电话会用到这个

 /packages/apps/Bluetooth/src/com/android/bluetooth/btservice/

        AdapterService.java    4.2后才有的代码，蓝牙打开、关闭、扫描、配对都会走到这里，其实更准确的说它替代了4.1之前的BluetoothService.java，原来的工作就由这个类来完成了。说到这里不能不说4.2蓝牙的目录变了，在4.1及以前的代码中packages层的代码只有opp协议相关应用的代码，也就是文件传输那部分，而4.2的代码应用层的代码则丰富了许多，按具体的蓝牙应用协议来区别，分为以下文件夹（这里一并对蓝牙一些名词作个简单解释）：

       a2dp    蓝牙立体声，和蓝牙耳机听歌有关那些，另还有个avrcp--音频/视频远程控制配置文件，是用来听歌时暂停，上下歌曲选择的。
       btservice  这个前面AdapterService.java的描述大家应该能猜到一些，关于蓝牙基本操作的目录，一切由此开始。
       hdp      蓝牙关于医疗方面的应用 Bluetooth Health Device Profile
       hfp       和电话相关，蓝牙接听、挂断电话  Hands-free Profile
       hid      人机交互接口，蓝牙鼠标键盘什么的就是这个了
      opp     不多解释，以前就有。
      pan      描述了两个或更多个 Bluetooth 设备如何构成一个即时网络，和网络有关的还有串行端口功能(SPP)，拨号网络功能(DUN)

      pbap    电话号码簿访问协议(Phonebook Access Profile)

       android 4.2的蓝牙应用层部分代码更丰富了，虽然有些目录还没具体代码，不过说不准哪个版本更新就有了，就像4.0添加了hdp医疗那部分一样。

另外原本在framework的JNI代码也被移到packages/apps/bluetooth当中。     

   /frameworks/base/core/java/android/bluetooth/目录下

      BluetoothA2dp.java A2DP的功能实现
     BluetoothAdapter.java 蓝牙action的定义，虚拟设备属性以及操作方法
     BluetoothAudioGateway.java 蓝牙语音网关
     BluetoothClass.java 蓝牙设备类型的定义
     BluetoothDevice.java 蓝牙设备属性
     BluetoothDevicePicker.java 定义远程蓝牙设备的特性，比如需要认证，设备类型
     BluetoothHeadset.java 定义蓝牙headset功能的属性以及接口
     BluetoothInputStream.java 蓝牙流接口的实现（输入流）
    BluetoothOutputStream.java 蓝牙流接口的实现（输出流）
    BluetoothServerSocket.java 蓝牙socket服务端具备的方法
    BluetoothSocket.java 蓝牙socket的封装
    BluetoothUuid.java 蓝牙uuid的定义以及uuid的解析

    以上java文件在使用具体功能会用到，现在只是简单描述下，至于具体使用在后续文章用到时再给出。同时代码说明部分也就写这些了

对于C、C++部分的代码一方面没看那么多，另一方面根据android JNI的命名习惯，大家找起来也很容易。

4.后续分析：

       前面从整体上描述蓝牙的基本知识，落实在具体的代码分析上，我们按几个主线功能来走，蓝牙的开关、搜索配对、蓝牙耳机与电话和文件传输，

这几个也算是蓝牙的常用必备功能了，所以在后续文章中将按着这个顺序来跟一下它们代码调用流程。希望可以让你快速的了解蓝牙，当然如果有失误

android -- 蓝牙 bluetooth （二） 打开蓝牙

        4.2的蓝牙打开流程这一部分还是有些变化的，从界面上看蓝牙开关就是设置settings里那个switch开关，widget开关当然也可以，起点不同而已，后续的流程是一样的。先来看systemServer.java的代码，蓝牙服务开启的地方，最后一个else分支是我们关心的，前两个是模拟器的一个测试模式的。

1. if (SystemProperties.get("ro.kernel.qemu").equals("1")) {                                            
2.                Slog.i(TAG, "No Bluetooh Service (emulator)");                                     
3.            } else if (factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) {                       
4.                Slog.i(TAG, "No Bluetooth Service (factory test)");                                
5.            } else {                                                                               
6.                Slog.i(TAG, "Bluetooth Manager Service");                                          
7.                bluetooth = new BluetoothManagerService(context);                                  
8.                ServiceManager.addService(BluetoothAdapter.BLUETOOTH_MANAGER_SERVICE, bluetooth);  
9.            }     

         暂且看下bluetoothManagerService的构造方法，代码有点多，我们只看两个地方， loadStoredNameAndAddress()是读取蓝牙打开默认名称的地方，isBluetoothPersistedStateOn()是判断是否已打开蓝牙的，如果已打开，后续操作要执行开启蓝牙的动作，前面那几行注册广播其中就有这个作用。

1. BluetoothManagerService(Context context) {  
2.         ...一些变量声明初始化...  
3.         IntentFilter filter = new IntentFilter(Intent.ACTION_BOOT_COMPLETED);  
4.         filter.addAction(BluetoothAdapter.ACTION_LOCAL_NAME_CHANGED);  
5.         filter.addAction(Intent.ACTION_USER_SWITCHED);  
6.         registerForAirplaneMode(filter);  
7.         mContext.registerReceiver(mReceiver, filter);  
8.         loadStoredNameAndAddress();  
9.         if (isBluetoothPersistedStateOn()) {  
10.             mEnableExternal = true;  
11.         }  
12.     }  

        回到界面开关那个看得着的地方，界面上开关就是BluetoothEnabler.java这个类了，而setBluetoothEnabled()则是具体开关动作。看下代码

1. public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {  
2.        // Show toast message if Bluetooth is not allowed in airplane mode  
3.        if (isChecked &&  
4.                !WirelessSettings.isRadioAllowed(mContext, Settings.Global.RADIO_BLUETOOTH)) {  
5.            Toast.makeText(mContext, R.string.wifi_in_airplane_mode, Toast.LENGTH_SHORT).show();  
6.            // Reset switch to off  
7.            buttonView.setChecked(false);            
8.        }  
9.   
10.        if (mLocalAdapter != null) {  
11.            mLocalAdapter.setBluetoothEnabled(isChecked);  
12.        }  
13.        mSwitch.setEnabled(false);  
14.    }  

这里在判断是飞行模式不知道为什么没有return，如果是飞行模式会有提示toast弹出，既然这样源码为什么还要执行下面打开流程呢，也许是个bug？不细究这个了，继续看setBluetoothEnabled()方法做什么了，很明显mLocalAdapter(LocalBluetoothAdapter )只是个过渡，里面的 mAdapter(BluetoothAdapter)才是真正的主角，代码如下：

1. public void setBluetoothEnabled(boolean enabled) {  
2.     boolean success = enabled   ? mAdapter.enable() : mAdapter.disable();  
3.   
4.     if (success) {  
5.         setBluetoothStateInt(enabled  
6.             ? BluetoothAdapter.STATE_TURNING_ON  
7.             : BluetoothAdapter.STATE_TURNING_OFF);  
8.     } else {  
9.        .........  
10.     }  
11. }  

拿到BluetoothAdapter对象，代码也简单看下吧，里面是典型的binder应用。

1. public static synchronized BluetoothAdapter getDefaultAdapter() {  
2.    if (sAdapter == null) {  
3.        IBinder b = ServiceManager.getService(BLUETOOTH_MANAGER_SERVICE);  
4.        if (b != null) {  
5.            IBluetoothManager managerService = IBluetoothManager.Stub.asInterface(b);  
6.            sAdapter = new BluetoothAdapter(managerService);  
7.        } else {  
8.            Log.e(TAG, "Bluetooth binder is null");  
9.        }  
10.    }  
11.    return sAdapter;  

方法，后面要跳转到新类了，贴出来一起看下，这部分好像不同版本还有些出入，不过核心的启动service是一样的，不影响理解。

1.  private void handleEnable(boolean persist, boolean quietMode) {  
2.  synchronized(mConnection) {  
3.     if ((mBluetooth == null) && (!mBinding)) {  
4.         //Start bind timeout and bind  
5.         Message timeoutMsg=mHandler.obtainMessage(MESSAGE_TIMEOUT_BIND);  
6.         mHandler.sendMessageDelayed(timeoutMsg,TIMEOUT_BIND_MS);  
7.         mConnection.setGetNameAddressOnly(false);  
8.         Intent i = new Intent(IBluetooth.class.getName());  
9.         if (!mContext.bindService(i, mConnection,Context.BIND_AUTO_CREATE,  
10.                                   UserHandle.USER_CURRENT)) {  
11.             mHandler.removeMessages(MESSAGE_TIMEOUT_BIND);  
12.             Log.e(TAG, "Fail to bind to: " + IBluetooth.class.getName());  
13.         } else {  
14.             mBinding = true;  
15.         }  
16.     }   

这样的信息，那就是去AdapterService里看看，里面一共有三个enable()，跳转关系不复杂，我们直接看最后一个关键的。

1. public synchronized boolean enable(boolean quietMode) {  
2.      enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,  
3.              "Need BLUETOOTH ADMIN permission");  
4.      if (DBG)debugLog("Enable called with quiet mode status =  " + mQuietmode);  
5.      mQuietmode  = quietMode;  
6.      Message m =  
7.              mAdapterStateMachine.obtainMessage(AdapterState.USER_TURN_ON);  
8.      mAdapterStateMachine.sendMessage(m);  
9.      return true;  
10.  }  

处理在同文件下面的代码里

1. case STARTED:   {  
2.   if (DBG) Log.d(TAG,"CURRENT_STATE=PENDING, MESSAGE = STARTED, isTurningOn=" + isTurningOn + ", isTurningOff=" + isTurningOff);  
3.   //Remove start timeout  
4.   removeMessages(START_TIMEOUT);  
5.   
6.   //Enable  
7.   boolean ret = mAdapterService.enableNative();  
8.   if (!ret) {  
9.       Log.e(TAG, "Error while turning Bluetooth On");  
10.       notifyAdapterStateChange(BluetoothAdapter.STATE_OFF);  
11.       transitionTo(mOffState);  
12.   } else {  
13.       sendMessageDelayed(ENABLE_TIMEOUT, ENABLE_TIMEOUT_DELAY);  
14.   }   

还是要到下面去的。一起往下看吧。

        根据android JNI的函数命名惯例很容易找到enableNative对应的C++函数在packages/apps/Bluetooth/jni/com_android_bluetooth_btservice_AdapterService.cpp里面

1. static jboolean enableNative(JNIEnv* env, jobject obj) {  
2.    ALOGV("%s:",__FUNCTION__);  
3.    jboolean result = JNI_FALSE;  
4.     if (!sBluetoothInterface) return result;  
5.     int ret = sBluetoothInterface->enable();  
6.     result = (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;  
7.     return result;  
8. }  

代码瞬间简洁了不少，看来更多的故事还在下面，sBluetoothInterface这是什么，直接关系到下一步去哪的问题，看下变量声明，原来是

Const bt_interface_t *sBluetoothInterface = NULL; 再去找在哪初始化，搜索external目录可以找到/external/bluetooth/bluedroid/btif/src/bluetooth.c

1.     static const bt_interface_t bluetoothInterface = {  
2.     sizeof(bt_interface_t),  
3.     init,  
4.     enable,  
5.     disable,  
6.     .............  
7.     start_discovery,  
8.     cancel_discovery,  
9.     create_bond,  
10.     remove_bond,  
11.     cancel_bond,  
12.    ...............  
13. };  

1. static int enable( void )  
2. {  
3.     ALOGI("enable");  
4.   
5.     /* sanity check */  
6.     if (interface_ready() == FALSE)  
7.         return BT_STATUS_NOT_READY;  
8.   
9.     return btif_enable_bluetooth();  
10. }  

1. bt_status_t btif_enable_bluetooth(void)  
2. {  
3.     BTIF_TRACE_DEBUG0("BTIF ENABLE BLUETOOTH");  
4.   
5.     if (btif_core_state != BTIF_CORE_STATE_DISABLED)  
6.     {  
7.         ALOGD("not disabled\n");  
8.         return BT_STATUS_DONE;  
9.     }  
10.   
11.     btif_core_state = BTIF_CORE_STATE_ENABLING;  
12.   
13.     /* Create the GKI tasks and run them */  
14.     bte_main_enable(btif_local_bd_addr.address);  
15.   
16.     return BT_STATUS_SUCCESS;  
17. }  

1. void bte_main_enable(uint8_t *local_addr)  
2. {  
3.     APPL_TRACE_DEBUG1("%s", __FUNCTION__);  
4.     ........................  
5.   
6. #if (defined (BT_CLEAN_TURN_ON_DISABLED) && BT_CLEAN_TURN_ON_DISABLED == TRUE)  
7.         APPL_TRACE_DEBUG1("%s  Not Turninig Off the BT before Turninig ON", __FUNCTION__);  
8.   
9. #else  
10.         /* toggle chip power to ensure we will reset chip in case 
11.            a previous stack shutdown wasn't completed gracefully */  
12.         bt_hc_if->set_power(BT_HC_CHIP_PWR_OFF);  
13. #endif  
14.         bt_hc_if->set_power(BT_HC_CHIP_PWR_ON);  
15.   
16.         bt_hc_if->preload(NULL);  
17.     }  
18.   
19.      .............................  
20. }  

路径在这里/external/bluetooth/bluedroid/hci/src/bt_hci_bdroid.c，看看set_power里面有什么，快到头了

1. static void set_power(bt_hc_chip_power_state_t state)  
2. {  
3.     int pwr_state;  
4.   
5.     BTHCDBG("set_power %d", state);  
6.   
7.     /* Calling vendor-specific part */  
8.     pwr_state = (state == BT_HC_CHIP_PWR_ON) ? BT_VND_PWR_ON : BT_VND_PWR_OFF;  
9.   
10.     if (bt_vnd_if)  
11.         bt_vnd_if->op(BT_VND_OP_POWER_CTRL, &pwr_state);  
12.     else  
13.         ALOGE("vendor lib is missing!");  
14. }  

1. /* Entry point of DLib -- 
2.  *      Vendor library needs to implement the body of bt_vendor_interface_t 
3.  *      structure and uses the below name as the variable name. HCI library 
4.  *      will use this symbol name to get address of the object through the 
5.  *      dlsym call. 
6.  */  
7. extern const bt_vendor_interface_t BLUETOOTH_VENDOR_LIB_INTERFACE;  
8.   
9. bt_vendor_interface_t *bt_vnd_if=NULL;  

1. static const char* BT_DRIVER_MODULE_PATH =    "/system/lib/modules/mbt8xxx.ko";  
2. static const char* BT_DRIVER_MODULE_NAME =     "bt8xxx";  
3. static const char* BT_DRIVER_MODULE_INIT_ARG = " init_cfg=";  
4. static const char* BT_DRIVER_MODULE_INIT_CFG_PATH = "bt_init_cfg.conf";  

在有类似下面的动作，insmod加载驱动，rfkill控制上下电，具体厂商具体做法也不同。

1. ret = insmod(BT_DRIVER_MODULE_PATH, arg_buf);  
2. ret = system("/system/bin/rfkill block all");  

android -- 蓝牙 bluetooth （三）搜索蓝牙

        接上篇打开蓝牙继续，来一起看下蓝牙搜索的流程，触发蓝牙搜索的条件形式上有两种，一是在蓝牙设置界面开启蓝牙会直接开始搜索，另一个是先打开蓝牙开关在进入蓝牙设置界面也会触发搜索，也可能还有其它触发方式，但最后都要来到BluetoothSettngs.java的startScanning()，我们分析的起点也从这里开始，起步代码如下

1. private void updateContent(int bluetoothState, boolean scanState) {  
2.     if (numberOfPairedDevices == 0) {  
3.          preferenceScreen.removePreference(mPairedDevicesCategory);  
4.          if (scanState == true) {  
5.              mActivityStarted = false;  
6.              startScanning();  
7.         } else<span style="font-family: Arial, Helvetica, sans-serif;">    ........</span>  
8. }         
9. private void startScanning() {  
10.         if (!mAvailableDevicesCategoryIsPresent) {  
11.             getPreferenceScreen().addPreference(mAvailableDevicesCategory);  
12.         }  
13.         mLocalAdapter.startScanning(true);  
14.     }  

        其实在这里蓝牙搜索和打开流程是结构上是一致的，利用LocalBluetoothAdapter.java过渡到BluetoothAdapter.java再跳转至AdapterService.java要稍微留意下的是在这个过渡中startScaning()方法变成了startDiscovery()方法，看下代码：packages/apps/Settings/src/com/android/settings/bluetooth/LocalBluetoothAdapter.java

1. void startScanning(boolean force) {  
2. if (!mAdapter.isDiscovering()) {  
3.      if (!force) {  
4.          // Don't scan more than frequently than SCAN_EXPIRATION_MS,  
5.          // unless forced  
6.          if (mLastScan + SCAN_EXPIRATION_MS > System.currentTimeMillis()) {  
7.              return;  
8.          }  
9.          // If we are playing music, don't scan unless forced.  
10.          A2dpProfile a2dp = mProfileManager.getA2dpProfile();  
11.          if (a2dp != null && a2dp.isA2dpPlaying()) {  
12.              return;  
13.          }  
14.      }  
15. //这里才是我们最关注的，前面限制条件关注一下就行了  
16.      if (mAdapter.startDiscovery()) {  
17.          mLastScan = System.currentTimeMillis();  
18.      }  
19. }  

1. public boolean startDiscovery() {  
2.     .............................  
3.     AdapterService service = getService();  
4.     if (service == null) return false;  
5.     return service.startDiscovery();  
6. }  

      下面的代码路径自然是 :packages/apps/Bluetooth/src/com/android/bluetooth/btservice/AdapterService.java，

1. boolean startDiscovery() {  
2.     enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,  
3.             "Need BLUETOOTH ADMIN permission");  
4.   
5.     return startDiscoveryNative();  
6. }  

      和打开蓝牙根本就是一个套路，上面的流程略过一小步，很简单的不写了，下面要怎么走，估计大家也都猜到了，JNI应该出场了，

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

1. static jboolean startDiscoveryNative(JNIEnv* env, jobject obj) {                                                     
2.     ALOGV("%s:",__FUNCTION__);                                  
3.                                                                 
4.     jboolean result = JNI_FALSE;                                
5.     if (!sBluetoothInterface) return result;                    
6.                                                                 
7.     int ret = sBluetoothInterface->start_discovery();           
8.     result = (ret == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;  
9.     return result;                                              
10. }   

      在下面要去哪？稍微要动下脑筋，不过我们在上一篇android -- 蓝牙 bluetooth （二） 打开蓝牙已经说过怎么找了，注意android.mk文件，先找头文件，再找对应的实现C文件代码。就是现在回顾下，蓝牙打开和搜索的代码流程我们都看了，跳转都是一个套路，settings界面发起，LocalBluetoothAdapter.java过渡，去framework的转转（BluetoothAdapter.java）后回到packages的AdapterService.java，再走JNI来的external。流程就是这样的，相信类似的功能跳转(比如蓝牙配对，关闭蓝牙，停止扫描这些)大家都应该熟悉了，后面再有类似的功能就写函数名一笔带过了，还有这里要注意的就是这个start_discovery()实现代码的寻找，留意mk文件就是了，不复杂。小结结束，继续看代码    路径：/external/bluetooth/bluedroid/btif/src/bluetooth.c

1. static int start_discovery(void)  
2. {  
3.     /* sanity check */  
4.     if (interface_ready() == FALSE)  
5.         return BT_STATUS_NOT_READY;  
6.   
7.     return btif_dm_start_discovery();  
8. }     

        下面代码直接跳转就可以找到，路径external/bluetooth/bluedroid/btif/src/btif_dm.c  

        这个代码有点多，不过里面的信息也很多，所以连注释也一起保留的贴出来了，蓝牙的搜索实现并没有像蓝牙打开那样交由vendor厂商实现，在这里已经写出来了，仔细看下那些#if和#else，都是一些查询条件的调置，#if (BLE_INCLUDED == TRUE)   这个应该就google为蓝牙4.0 LE作的准备了，也算是今年google I/O大会上宣布即将支持蓝牙4.0低能耗版一个佐证吧，对于代码里面那些字符串的含义看这里好了external/bluetooth/bluedroid/bta/include/bta_api.h，一个头文件，大部分字符串和结构体的定义都在这了，多少还有些注释。

1. bt_status_t btif_dm_start_discovery(void)                                    
2. {                                                                            
3.     tBTA_DM_INQ inq_params;                                                  
4.     tBTA_SERVICE_MASK services = 0;                                          
5.                                                                              
6.     BTIF_TRACE_EVENT1("%s", __FUNCTION__);                                   
7.     /* TODO: Do we need to handle multiple inquiries at the same time? */    
8.                                                                              
9.     /* Set inquiry params and call API */                                    
10. #if (BLE_INCLUDED == TRUE)                                                   
11.     inq_params.mode = BTA_DM_GENERAL_INQUIRY|BTA_BLE_GENERAL_INQUIRY;        
12. #else                                                                        
13.     inq_params.mode = BTA_DM_GENERAL_INQUIRY;                                
14. #endif                                                                       
15.     inq_params.duration = BTIF_DM_DEFAULT_INQ_MAX_DURATION;                  
16.                                                                              
17.     inq_params.max_resps = BTIF_DM_DEFAULT_INQ_MAX_RESULTS;                  
18.     inq_params.report_dup = TRUE;                                            
19.                                                                              
20.     inq_params.filter_type = BTA_DM_INQ_CLR;                                 
21.     /* TODO: Filter device by BDA needs to be implemented here */            
22.                                                                              
23.     /* Will be enabled to TRUE once inquiry busy level has been received */  
24.     btif_dm_inquiry_in_progress = FALSE;                                     
25.     /* find nearby devices */                                                
26.     BTA_DmSearch(&inq_params, services, bte_search_devices_evt);             
27.                                                                              
28.     return BT_STATUS_SUCCESS;                                                
29. }   

1. static void bte_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)                                                                      {                                                                                                                    
2.        UINT16 param_len = 0;                                                                                           
3.                                                                                                                         
4.        if (p_data)                                                                                                      
5.            param_len += sizeof(tBTA_DM_SEARCH);                                                                         
6.        /* Allocate buffer to hold the pointers (deep copy). The pointers will point to the end of the tBTA_DM_SEARCH */  
7.        switch (event)                                                                                                   
8.        {                                                                                                                
9.            case BTA_DM_INQ_RES_EVT:                                                                                     
10.            {                                                                                                            
11.                if (p_data->inq_res.p_eir)                                                                               
12.                    param_len += HCI_EXT_INQ_RESPONSE_LEN;                                                               
13.            }                                                                                                            
14.            break;                                                                                                              
15.           ..............................                                                                                                
16.        }                                                                                                                
17.        BTIF_TRACE_DEBUG3("%s event=%s param_len=%d", __FUNCTION__, dump_dm_search_event(event), param_len);             
18.                                                                                                                         
19.        /* if remote name is available in EIR, set teh flag so that stack doesnt trigger RNR */                          
20.        if (event == BTA_DM_INQ_RES_EVT)                                                                                 
21.            p_data->inq_res.remt_name_not_required = check_eir_remote_name(p_data, NULL, NULL);                          
22.                                                                                                                         
23.        btif_transfer_context (btif_dm_search_devices_evt , (UINT16) event, (void *)p_data, param_len,                   
24.            (param_len > sizeof(tBTA_DM_SEARCH)) ? search_devices_copy_cb : NULL);                                       
25.    }     

1. static void btif_dm_search_devices_evt (UINT16 event, char *p_param)  
2.   
3.    tBTA_DM_SEARCH *p_search_data;  
4.    BTIF_TRACE_EVENT2("%s event=%s", __FUNCTION__, dump_dm_search_event(event));  
5.   
6.    switch (event)  
7.    {  
8.        case BTA_DM_DISC_RES_EVT:  
9.        {  
10.            p_search_data = (tBTA_DM_SEARCH *)p_param;  
11.            /* Remote name update */  
12.            if (strlen((const char *) p_search_data->disc_res.bd_name))  
13.            {  
14.                bt_property_t properties[1];  
15.                bt_bdaddr_t bdaddr;  
16.                bt_status_t status;  
17.   
18.                properties[0].type = BT_PROPERTY_BDNAME;  
19.                properties[0].val = p_search_data->disc_res.bd_name;  
20.                properties[0].len = strlen((char *)p_search_data->disc_res.bd_name);  
21.                bdcpy(bdaddr.address, p_search_data->disc_res.bd_addr);  
22.   
23.                status = btif_storage_set_remote_device_property(&bdaddr, &properties[0]);  
24.                ASSERTC(status == BT_STATUS_SUCCESS, "failed to save remote device property", status);  
25.                HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb,  
26.                                 status, &bdaddr, 1, properties);  
27.            }  
28.            /* TODO: Services? */  
29.        }  
30.        break;  

1. void BTA_DmSearch(tBTA_DM_INQ *p_dm_inq, tBTA_SERVICE_MASK services, tBTA_DM_SEARCH_CBACK *p_cback)  
2. {  tBTA_DM_API_SEARCH    *p_msg;  
3.     if ((p_msg = (tBTA_DM_API_SEARCH *) GKI_getbuf(sizeof(tBTA_DM_API_SEARCH))) != NULL)  
4.     {  
5.         memset(p_msg, 0, sizeof(tBTA_DM_API_SEARCH));  
6.   
7.         p_msg->hdr.event = BTA_DM_API_SEARCH_EVT;  
8.         memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ));  
9.         p_msg->services = services;  
10.         p_msg->p_cback = p_cback;  
11.         p_msg->rs_res  = BTA_DM_RS_NONE;  
12.         bta_sys_sendmsg(p_msg);  
13.     }  
14. }  

1. method_deviceFoundCallback = env->GetMethodID(jniCallbackClass, "deviceFoundCallback", "([B)V");  

1. void deviceFoundCallback(byte[] address) {  
2.        // The device properties are already registered - we can send the intent  
3.        // now  
4.        BluetoothDevice device = getDevice(address);  
5.        debugLog("deviceFoundCallback: Remote Address is:" + device);  
6.        DeviceProperties deviceProp = getDeviceProperties(device);  
7.        if (deviceProp == null) {  
8.            errorLog("Device Properties is null for Device:" + device);  
9.            return;  
10.        }  
11.   
12.        Intent intent = new Intent(BluetoothDevice.ACTION_FOUND);  
13.        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);  
14.        intent.putExtra(BluetoothDevice.EXTRA_CLASS,  
15.                new BluetoothClass(Integer.valueOf(deviceProp.mBluetoothClass)));  
16.        intent.putExtra(BluetoothDevice.EXTRA_RSSI, deviceProp.mRssi);  
17.        intent.putExtra(BluetoothDevice.EXTRA_NAME, deviceProp.mName);  
18.   
19.        mAdapterService.sendBroadcast(intent, mAdapterService.BLUETOOTH_PERM);  
20.    }  

1. addHandler(BluetoothDevice.ACTION_FOUND, new DeviceFoundHandler());  
2.     private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {  
3.     @Override  
4.     public void onReceive(Context context, Intent intent) {  
5.         String action = intent.getAction();  
6.         BluetoothDevice device = intent  
7.                 .getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);  
8.   
9.         Handler handler = mHandlerMap.get(action);  
10.         if (handler != null) {  
11.             handler.onReceive(context, intent, device);  
12.         }  
13.     }  
14. };  

1.  private class DeviceFoundHandler implements Handler {  
2.     public void onReceive(Context context, Intent intent,  
3.             BluetoothDevice device) {  
4.        ........................  
5.         // TODO Pick up UUID. They should be available for 2.1 devices.  
6.         // Skip for now, there's a bluez problem and we are not getting uuids even for 2.1.  
7.         CachedBluetoothDevice cachedDevice = mDeviceManager.findDevice(device);  
8.         if (cachedDevice == null) {  
9.             cachedDevice = mDeviceManager.addDevice(mLocalAdapter, mProfileManager, device);  
10.             Log.d(TAG, "DeviceFoundHandler created new CachedBluetoothDevice: "  
11.                     + cachedDevice);  
12.             // callback to UI to create Preference for new device  
13.             dispatchDeviceAdded(cachedDevice);  
14.         }  
15.       ......................  
16.     }  
17. }  

1. public void onDeviceAdded(CachedBluetoothDevice cachedDevice) {                   
2.    if (mDevicePreferenceMap.get(cachedDevice) != null) {                          
3.        return;                                                                    
4.    }                                                                              
5.                                                                                   
6.    // Prevent updates while the list shows one of the state messages              
7.    if (mLocalAdapter.getBluetoothState() != BluetoothAdapter.STATE_ON) return;    
8.                                                                                   
9.    if (mFilter.matches(cachedDevice.getDevice())) {                               
10.        createDevicePreference(cachedDevice);                                      
11.    }                                                                              
12. }                     

1.   void createDevicePreference(CachedBluetoothDevice cachedDevice) {  
2.     BluetoothDevicePreference preference = new BluetoothDevicePreference(  
3.             getActivity(), cachedDevice);  
4.   
5.     initDevicePreference(preference);  
6.     mDeviceListGroup.addPreference(preference);  
7.     mDevicePreferenceMap.put(cachedDevice, preference);  
8. }  

        到目前为止，包括前面的打开流程分析，还仅是针对代码流程做的分析，对于蓝牙协议方面东西还没有涉及，比如蓝牙是如何发现其它蓝牙设备，这个流程究竟是怎么工作还不是很清楚，后续会尽量关注这些问题，估计看起来就没那么容易，欢迎有经验的朋友指点一二，当然对于本文不足，欢迎拍砖讨论。分享是快乐的，谢谢！

--------------modify 2013.6.2 21:08--------

android -- 蓝牙 bluetooth （四）OPP文件传输

        在前面android -- 蓝牙 bluetooth （一） 入门文章结尾中提到了会按四个方面来写这系列的文章，前面已写了蓝牙打开和蓝牙搜索，这次一起来看下蓝牙文件分享的流程，也就是蓝牙应用opp目录下的代码，作为蓝牙最基本的一个功能，这部分的代码在之前的版本中就已经有了，新旧版本代码对比很多类名都是一样的，这一部分新东西不多，写在这里帮助大家梳理下流程吧。

        有没有这种感觉，智能手机的普及让我们提高了一点对蓝牙的关注，手机间使用蓝牙互传文件应该是最常用的应用之一，手机与电脑也可以通过蓝牙做同样的事情，大部分笔记本都支持蓝牙功能，本本上蓝牙芯片多数是broadcom的，也有其它厂商（比如东芝）不过数量不多，毕竟broadcom在BT这方面是老大。不过本本上蓝牙一般只支持蓝牙耳机听歌，并没实现对opp的支持，如果体验下手机与电脑的蓝牙文件传输怎么办呢，安装一个叫bluesoleil（中文名好像是千月）软件就可以了，这个软件对蓝牙功能的支持还是比较全的。可能需要卸载本本自带蓝牙驱动。扯淡结束，本文还是要关注手机间蓝牙opp的代码流程，这段的废话也许能帮助你提高下对蓝牙的体验。

        蓝牙发送文件时发送端先来到这里packages/apps/Bluetooth/src/com/android/bluetooth/opp/BluetoothOppLauncherActivity.java，一个没有界面只是提取下文件信息的中转站，源码的注释写的很清楚了，两个分支action.equals(Intent.ACTION_SEND)和action.equals(Intent.ACTION_SEND_MULTIPLE)

1.  if (action.equals(Intent.ACTION_SEND) || action.equals(Intent.ACTION_SEND_MULTIPLE)) {  
2.             //Check if Bluetooth is available in the beginning instead of at the end  
3.             if (!isBluetoothAllowed()) {  
4.                 Intent in = new Intent(this, BluetoothOppBtErrorActivity.class);  
5.                 in.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);  
6.                 in.putExtra("title", this.getString(R.string.airplane_error_title));  
7.                 in.putExtra("content", this.getString(R.string.airplane_error_msg));  
8.                 startActivity(in);  
9.                 finish();  
10.                 return;  
11.             }  
12.             if (action.equals(Intent.ACTION_SEND)) {  
13.                .......   
14.                Thread t = new Thread(new Runnable() {  
15.                             public void run() {  
16.                                 BluetoothOppManager.getInstance(BluetoothOppLauncherActivity.this)  
17.                                     .saveSendingFileInfo(type,fileUri.toString(), false);  
18.                                 //Done getting file info..Launch device picker  
19.                                 //and finish this activity  
20.                                 launchDevicePicker();  
21.                                 finish();  
22.                             }  
23.                         });  ......           
24.             } else if (action.equals(Intent.ACTION_SEND_MULTIPLE)) {  
25.               .......                     
26.             }  

           最前面那个isBluetoothAllowed()会判断是否处于飞行模式，如果是会禁止发送的。在launchDevicePicker()里还会判断蓝牙是否已经打开，就是下面这个条件语句(!BluetoothOppManager.getInstance(this).isEnabled())。如果已经打开了蓝牙，如果蓝牙打开了就进入设备选择界面DeviceListPreferenceFragment(DevicePickerFragment)选择设备，这个跳转过程简单说明下，注意这个new Intent(BluetoothDevicePicker.ACTION_LAUNCH)里字符串，完整定义public static final String ACTION_LAUNCH = "android.bluetooth.devicepicker.action.LAUNCH";路径frameworks/base/core/java/android/bluetooth/BluetoothDevicePicker.java，你会在setting应用的manifest.xml里发现

1. <activity android:name=".bluetooth.DevicePickerActivity"  
2.                 android:theme="@android:style/Theme.Holo.DialogWhenLarge"  
3.                 android:label="@string/device_picker"  
4.                 android:clearTaskOnLaunch="true">  
5.             <intent-filter>  
6.                 <action android:name="android.bluetooth.devicepicker.action.LAUNCH" />  
7.                 <category android:name="android.intent.category.DEFAULT" />  
8.             </intent-filter>  
9.         </activity>  

1. <fragment  
2.         android:id="@+id/bluetooth_device_picker_fragment"  
3.         android:name="com.android.settings.bluetooth.DevicePickerFragment"  
4.         android:layout_width="match_parent"  
5.         android:layout_height="0dip"  
6.         android:layout_weight="1" />  

1.     void onDevicePreferenceClick(BluetoothDevicePreference btPreference) {  
2.         mLocalAdapter.stopScanning();  
3.         LocalBluetoothPreferences.persistSelectedDeviceInPicker(  
4.                 getActivity(), mSelectedDevice.getAddress());  
5.         if ((btPreference.getCachedDevice().getBondState() ==  
6.                 BluetoothDevice.BOND_BONDED) || !mNeedAuth) {  
7.             sendDevicePickedIntent(mSelectedDevice);  
8.             finish();  
9.         } else {  
10.             super.onDevicePreferenceClick(btPreference);  
11.         }  
12.     }<div>    public static final String ACTION_LAUNCH = "android.bluetooth.devicepicker.action.LAUNCH";  
13.          private void sendDevicePickedIntent(BluetoothDevice device) {  
14.          Intent intent = new Intent(BluetoothDevicePicker.ACTION_DEVICE_SELECTED);  
15.          intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);  
16.          if (mLaunchPackage != null && mLaunchClass != null) {  
17.              intent.setClassName(mLaunchPackage, mLaunchClass);  
18.          }  
19.         getActivity().sendBroadcast(intent);｝  
20. </div>  

1. else if (action.equals(BluetoothDevicePicker.ACTION_DEVICE_SELECTED)) {  
2.           BluetoothOppManager mOppManager = BluetoothOppManager.getInstance(context);           
3.           BluetoothDevice remoteDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);   
4.            
5.           // Insert transfer session record to database  
6.           mOppManager.startTransfer(remoteDevice);  
7.            
8.           // Display toast message  
9.           String deviceName = mOppManager.getDeviceName(remoteDevice);  
10.           .......  
11. }  

1.    public void startTransfer(BluetoothDevice device) {  
2.         if (V) Log.v(TAG, "Active InsertShareThread number is : " + mInsertShareThreadNum);  
3.         InsertShareInfoThread insertThread;  
4.         synchronized (BluetoothOppManager.this) {  
5.             if (mInsertShareThreadNum > ALLOWED_INSERT_SHARE_THREAD_NUMBER) {  
6.                 ...........  
7.                 return;  
8.             }  
9.             insertThread = new InsertShareInfoThread(device, mMultipleFlag, mMimeTypeOfSendingFile,  
10.                     mUriOfSendingFile, mMimeTypeOfSendingFiles, mUrisOfSendingFiles,  
11.                     mIsHandoverInitiated);  
12.             if (mMultipleFlag) {  
13.                 mfileNumInBatch = mUrisOfSendingFiles.size();  
14.             }  
15.         }  
16.         insertThread.start();  
17.     }             
18.     public void run() {  
19.             Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
20.             ..........  
21.             if (mIsMultiple) {  
22.                 insertMultipleShare();  
23.             } else {  
24.                 insertSingleShare();  
25.             }  
26.             .......... }  

       以insertSingleShare() 为例，在它的实现会看到mContext.getContentResolver().insert，不多想了，要去provider里找到insert()函数了，

对应的代码在BluetoothOppProvider.java (bluetooth\src\com\android\bluetooth\opp)，insert的函数实现如下，里面又拉起BluetoothOppService，开始还以为只是针对数据库的操作，差点错过了风景。路径/packages/apps/Bluetooth/src/com/android/bluetooth/opp/BluetoothOppService.java

1. public Uri insert(Uri uri, ContentValues values) {  
2.  if (rowID != -1) {  
3.      context.startService(new Intent(context, BluetoothOppService.class));  
4.       ret = Uri.parse(BluetoothShare.CONTENT_URI + "/" + rowID);  
5.      context.getContentResolver().notifyChange(uri, null);  
6.  } else {  
7.       if (D) Log.d(TAG, "couldn't insert into btopp database");  
8.  }  

       在BluetoothOppService的onStartCommand方法中会看到updateFromProvider()，这里又开启了一个线程UpdateThread，后续代码当然是看它的run方法了，这里面内容不少，好在这部分代码注释比较多，理解起来不难。先暂时只关心发送的动作insertShare方法，代码也不少，只贴出了告诉我们接下来去哪里的代码和有关的逻辑注释，在下面的代码我们可以看到 BluetoothOppTransfer.java的对象，下一站就是它了。

1. private void insertShare(Cursor cursor, int arrayPos) {  
2.     .........  
3.     /* 
4.      * Add info into a batch. The logic is 
5.      * 1) Only add valid and readyToStart info 
6.      * 2) If there is no batch, create a batch and insert this transfer into batch, 
7.      * then run the batch 
8.      * 3) If there is existing batch and timestamp match, insert transfer into batch 
9.      * 4) If there is existing batch and timestamp does not match, create a new batch and 
10.      * put in queue 
11.      */  
12.     if (info.isReadyToStart()) {  
13.         .............  
14.         if (mBatchs.size() == 0) {  
15.            ........  
16.             mBatchs.add(newBatch);  
17.             if (info.mDirection == BluetoothShare.DIRECTION_OUTBOUND) {  
18.                  mTransfer = new BluetoothOppTransfer(this, mPowerManager, newBatch);  
19.             } else if (info.mDirection == BluetoothShare.DIRECTION_INBOUND) {  
20.                 mServerTransfer = new BluetoothOppTransfer(this, mPowerManager, newBatch,  
21.                         mServerSession);  
22.             }  
23.   
24.             if (info.mDirection == BluetoothShare.DIRECTION_OUTBOUND && mTransfer != null) {  
25.                 mTransfer.start();  
26.             } else if (info.mDirection == BluetoothShare.DIRECTION_INBOUND  
27.                     && mServerTransfer != null) {  
28.                 mServerTransfer.start();  
29.             }  
30.   
31.         } else {  
32.             .........  
33.     }}  

1. public void start() {  
2.       ....这里省略未贴的代码是检查蓝牙是否打开，一个很谨慎的判断。看似无用，不过还是安全第一。  
3.   
4.       if (mHandlerThread == null) {  
5.           ........  
6.           if (mBatch.mDirection == BluetoothShare.DIRECTION_OUTBOUND) {  
7.               /* for outbound transfer, we do connect first */  
8.               startConnectSession();  
9.           } else if (mBatch.mDirection == BluetoothShare.DIRECTION_INBOUND) {  
10.               /* 
11.                * for inbound transfer, it's already connected, so we start 
12.                * OBEX session directly 
13.                */  
14.               startObexSession();  
15.           }  
16.       }  
17.   }  

        上面的代码是分发送文件和接收文件的，看下这两行代码就很清楚了，如果分享给别人是OUTBOUND，先执行startConnectSession()，这个函数最后还是要跑到startObexSession()这里的，如果收文件直接startObexSession，所以后面就只看startObexSession方法了

1. // This transfer is outbound, e.g. share file to other device.  
2.  public static final int DIRECTION_OUTBOUND = 0;  
3.  // This transfer is inbound, e.g. receive file from other device.  
4.  public static final int DIRECTION_INBOUND = 1;  

1. private void startObexSession() {       
2.       if (mBatch.mDirection == BluetoothShare.DIRECTION_OUTBOUND) {  
3.           if (V) Log.v(TAG, "Create Client session with transport " + mTransport.toString());  
4.           mSession = new BluetoothOppObexClientSession(mContext, mTransport);  
5.       } else if (mBatch.mDirection == BluetoothShare.DIRECTION_INBOUND) {           
6.           if (mSession == null) {  
7.                markBatchFailed();  
8.               mBatch.mStatus = Constants.BATCH_STATUS_FAILED;  
9.               return;  
10.           }  
11.           if (V) Log.v(TAG, "Transfer has Server session" + mSession.toString());  
12.       }  
13.       mSession.start(mSessionHandler);  
14.       processCurrentShare();  
15.   }  

1. private void doSend() {  
2.   
3.      int status = BluetoothShare.STATUS_SUCCESS;  
4.      ........关于status值的判断  
5.      if (status == BluetoothShare.STATUS_SUCCESS) {  
6.          /* do real send */ //看到这个注释了没，它才是真家伙sendFile  
7.          if (mFileInfo.mFileName != null) {  
8.              status = sendFile(mFileInfo);  
9.          } else {  
10.              /* this is invalid request */  
11.              status = mFileInfo.mStatus;  
12.          }  
13.          waitingForShare = true;  
14.      } else {  
15.          Constants.updateShareStatus(mContext1, mInfo.mId, status);  
16.      }  
17.   
18.      if (status == BluetoothShare.STATUS_SUCCESS) {  
19.          Message msg = Message.obtain(mCallback);  
20.          msg.what = BluetoothOppObexSession.MSG_SHARE_COMPLETE;  
21.          msg.obj = mInfo;  
22.          msg.sendToTarget();  
23.      } else {  
24.          Message msg = Message.obtain(mCallback);  
25.          msg.what = BluetoothOppObexSession.MSG_SESSION_ERROR;  
26.          mInfo.mStatus = status;  
27.          msg.obj = mInfo;  
28.          msg.sendToTarget();  
29.      }  
30.  }  

代码路径在frameworks/base/obex/javax/obex/HeaderSet.java。这个sendFile方法行数虽然多，不过逻辑还是比较清晰的，在这里就不贴了。到这蓝牙发送文件流程也就此结束。由于发送文件时长肯定是不确定，所以在这个流程我们看到了很多开启线程代码也是很正常的，对于这线程，直接看对应的run方法就是了。

        对于蓝牙接收文件时会收到MSG_INCOMING_BTOPP_CONNECTION消息，收到这个消息是由于在蓝牙打开，即蓝牙状态是 BluetoothAdapter.STATE_ON时会执行

startSocketListener()，在这个函数开启了监听程序，看下面贴在一起的代码就明白了，

1. if (action.equals(BluetoothAdapter.ACTION_STATE_CHANGED)) {  
2.     switch (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR)) {  
3.         case BluetoothAdapter.STATE_ON:  
4.             if (V) Log.v(TAG,"Receiver BLUETOOTH_STATE_CHANGED_ACTION, BLUETOOTH_STATE_ON");  
5.             startSocketListener();  
6.             break;  
7.                           
8. private void startSocketListener() {  
9.         if (V) Log.v(TAG, "start RfcommListener");  
10.         mSocketListener.start(mHandler);  
11.         if (V) Log.v(TAG, "RfcommListener started");  
12. }  
13. mSocketListener.start(mHandler);这个的实现在这里，比较长，没有贴上来     
14. /packages/apps/Bluetooth/src/com/android/bluetooth/opp/BluetoothOppRfcommListener.java  

1. private void createServerSession(ObexTransport transport) {  
2.      mServerSession = new BluetoothOppObexServerSession(this, transport);  
3.      mServerSession.preStart();       
4.  }  

android -- 蓝牙 bluetooth （五）接电话与听音乐

目录(?)[+]

      1.蓝牙耳机接听电话

1. /* package */ void connectBluetoothAudio() {  
2.   if (VDBG) log("connectBluetoothAudio()...");  
3.   if (mBluetoothHeadset != null) {  
4.       // TODO(BT) check return  
5.       mBluetoothHeadset.connectAudio();  
6.   }  
7.   // Watch out: The bluetooth connection doesn't happen instantly;  
8.   // the connectAudio() call returns instantly but does its real  
9.   // work in another thread.  The mBluetoothConnectionPending flag  
10.   // is just a little trickery to ensure that the onscreen UI updates  
11.   // instantly. (See isBluetoothAudioConnectedOrPending() above.)  
12.   mBluetoothConnectionPending = true;  
13.   mBluetoothConnectionRequestTime = SystemClock.elapsedRealtime();  

1. public boolean connectAudio() {  
2.     HeadsetService service = getService();  
3.     if (service == null) return false;  
4.     return service.connectAudio();  
5. }  

1. boolean connectAudio() {  
2.      // TODO(BT) BLUETOOTH or BLUETOOTH_ADMIN permission  
3.      enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission");  
4.      if (!mStateMachine.isConnected()) {  
5.          return false;  
6.      }  
7.      if (mStateMachine.isAudioOn()) {  
8.          return false;  
9.      }  
10.      mStateMachine.sendMessage(HeadsetStateMachine.CONNECT_AUDIO);  
11.      return true;  
12.  }  

1. static jboolean connectAudioNative(JNIEnv *env, jobject object, jbyteArray address) {  
2.     jbyte *addr;  
3.     bt_status_t status;  
4.   
5.     if (!sBluetoothHfpInterface) return JNI_FALSE;  
6.   
7.     addr = env->GetByteArrayElements(address, NULL);  
8.     if (!addr) {  
9.         jniThrowIOException(env, EINVAL);  
10.         return JNI_FALSE;  
11.     }  
12. //连接在这里  
13.     if ( (status = sBluetoothHfpInterface->connect_audio((bt_bdaddr_t *)addr)) !=    
14.          BT_STATUS_SUCCESS) {  
15.         ALOGE("Failed HF audio connection, status: %d", status);  
16.     }  
17.     env->ReleaseByteArrayElements(address, addr, 0);  
18.     return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;  
19. }  

1. static bt_status_t connect_audio( bt_bdaddr_t *bd_addr )  
2. {  
3.     CHECK_BTHF_INIT();  
4.     if (is_connected(bd_addr))  
5.     {  
6.         BTA_AgAudioOpen(btif_hf_cb.handle);  
7.         /* Inform the application that the audio connection has been initiated successfully */  
8.         btif_transfer_context(btif_in_hf_generic_evt, BTIF_HFP_CB_AUDIO_CONNECTING,  
9.                               (char *)bd_addr, sizeof(bt_bdaddr_t), NULL);  
10.         return BT_STATUS_SUCCESS;  
11.     }  
12.     return BT_STATUS_FAIL;  
13. }  

 2.在蓝牙列表中连接蓝牙耳机

1. DevicePickerFragment.java (settings\src\com\android\settings\bluetooth)     3884     2013-6-26  
2.     void onClicked() {  
3.       int bondState = mCachedDevice.getBondState();  
4.       if (mCachedDevice.isConnected()) {  
5.           askDisconnect();  
6.       } else if (bondState == BluetoothDevice.BOND_BONDED) {  
7.           mCachedDevice.connect(true);  
8.       } .......  
9.   }  
10.   
11.     void connect(boolean connectAllProfiles) {  
12.       if (!ensurePaired()) {  //要先确保配对  
13.           return;  
14.       }  
15.       mConnectAttempted = SystemClock.elapsedRealtime();  
16.       connectWithoutResettingTimer(connectAllProfiles);//没别的了，只能看到这里  
17.   }  

1. // Try to initialize the profiles if they were not.  
2.      ...........  
3.       // Reset the only-show-one-error-dialog tracking variable  
4.       mIsConnectingErrorPossible = true;  
5.   
6.       int preferredProfiles = 0;  
7.       for (LocalBluetoothProfile profile : mProfiles) {  
8.           if (connectAllProfiles ? profile.isConnectable() : profile.isAutoConnectable()) {  
9.               if (profile.isPreferred(mDevice)) {  
10.                   ++preferredProfiles;  
11.                   connectInt(profile);//连接在这里，  
12.               }  
13.           }  
14.       }  
15.      .............  

1. public boolean connect(BluetoothDevice device) {  
2.     if (mService == null) return false;  
3.     List<BluetoothDevice> sinks = getConnectedDevices();  
4.     if (sinks != null) {  
5.         for (BluetoothDevice sink : sinks) {  
6.             mService.disconnect(sink);  
7.     }}  
8.     return mService.connect(device);  
9. }  

1. public boolean connect(BluetoothDevice device) {  
2.       if (mService != null && isEnabled() &&  
3.           isValidDevice(device)) {  
4.           try {  
5.               return mService.connect(device);  
6.           } catch (RemoteException e) {  
7.               Log.e(TAG, "Stack:" + Log.getStackTraceString(new Throwable()));  
8.               return false;  
9.           }  
10.       }...........  
11.       return false;  
12.        
13.       Binder跳转  
14.       public boolean connect(BluetoothDevice device) {  
15.           A2dpService service = getService();  
16.           if (service == null) return false;  
17.           return service.connect(device);  
18.       }  
19.        
20.   }  

1. static jboolean connectA2dpNative(JNIEnv *env, jobject object, jbyteArray address) {  
2.   jbyte *addr;  
3.   bt_bdaddr_t * btAddr;  
4.   bt_status_t status;  
5.   
6.   ALOGI("%s: sBluetoothA2dpInterface: %p", __FUNCTION__, sBluetoothA2dpInterface);  
7.   if (!sBluetoothA2dpInterface) return JNI_FALSE;  
8.   
9.   addr = env->GetByteArrayElements(address, NULL);  
10.   btAddr = (bt_bdaddr_t *) addr;  
11.   if (!addr) {  
12.       jniThrowIOException(env, EINVAL);  
13.       return JNI_FALSE;  
14.   }  
15.   if ((status = sBluetoothA2dpInterface->connect((bt_bdaddr_t *)addr)) != BT_STATUS_SUCCESS) {  
16.       ALOGE("Failed HF connection, status: %d", status);  
17.   }  
18.   env->ReleaseByteArrayElements(address, addr, 0);  
19.   return (status == BT_STATUS_SUCCESS) ? JNI_TRUE : JNI_FALSE;