Android4.0中蓝牙适配器state machine（状态机）的分析

最新推荐文章于 2024-04-28 21:57:32 发布
最新推荐文章于 2024-04-28 21:57:32 发布
阅读量278 收藏
点赞数
文章标签： 移动开发 ui java

今天晓东和大家来一起看一下Android4.0中蓝牙适配器（Bluetooth Adapter）的状态机变化的过程。首先，我们需要了解一下，蓝牙适配器究竟有哪些状态，从代码可以清晰地看到（frameworks/base/core/java/android/server/bluetoothadapterstatemachine.java）：

[java] view plain copy
  1. BluetoothAdapterStateMachine(Contextcontext,BluetoothServicebluetoothService,
  2. BluetoothAdapterbluetoothAdapter){
  3. ……
  4. //bluetoothadapter的六个状态
  5. mBluetoothOn=newBluetoothOn();
  6. mSwitching=newSwitching();
  7. mHotOff=newHotOff();
  8. mWarmUp=newWarmUp();
  9. mPowerOff=newPowerOff();
  10. mPerProcessState=newPerProcessState();
  11. ……
  12. }


bluetooth adapter有六个状态，分别为：

1）BluetoothOn：就是打开的状态。

2）Switching：可以认为是正在打开的状态。

3）HotOff：这个状态可以理解为一个预热状态，他是在上电之后进行了一系列硬件初始化成功之后的状态，但是这种状态并不表现到ui上。但是从耗电的状态来看，他和2.3中bluetooth on是一样的。

4）WarmUp：可以理解为正在预热的状态，就是处于从断电到HotOff的状态。

5）PowerOff：就是掉电的状态，也就是正在的关闭状态，这个时候bluetooth是没有耗电（准确说是耗电很少）。

6）PerProcessState：他也是位于HotOff到BluetoothOn之间的一个状态，和Switching的差别在于Swtiching是我们通过ui上去打开的“正在打开”的状态，而perprocess则是应用于一些临时使用蓝牙的application，这些application并不需要完整的蓝牙功能（比如说在蓝牙打开后的自动连接等），也不需要ui上去显示蓝牙的打开。所以，有这样一个过渡的状态，在change到BluetoothOn的时候并不会发出类似state_on的broadcaset。当然，这个状态的使用场合并不是很多，大家了解一下就可以了。

各个状态之间的变化如下图所示。

从图中可以看出，这六个状态中有3个状态是bluetooth有可能长期处于的状态，也就是非中间状态，他们是BluetoothOn，HotOff以及PowerOff。还有3个状态是中间状态，分别是Switching，WarmUp以及PerProcessState。

从代码来看，在最开始会处于PowerOff的状态，如下：

[java] view plain copy
  1. BluetoothAdapterStateMachine(Contextcontext,BluetoothServicebluetoothService,
  2. BluetoothAdapterbluetoothAdapter){
  3. ……
  4. setInitialState(mPowerOff);//初始化为PowerOff的状态
  5. mPublicState=BluetoothAdapter.STATE_OFF;
  6. }

因此，我们首先从PowerOff状态出发来分析：

[java] view plain copy
  1. privateclassPowerOffextendsState{
  2. @Override
  3. publicvoidenter(){
  4. if(DBG)log("EnterPowerOff:"+getCurrentMessage().what);
  5. }
  6. @Override
  7. publicbooleanprocessMessage(Messagemessage){
  8. log("PowerOffprocessmessage:"+message.what);
  10. booleanretValue=HANDLED;
  11. switch(message.what){
  12. //收到USER_TURN_ON的消息，一般而言，这个是用户在ui上点打开蓝牙会出现在这里。在bluetoothquickswitch关闭的情况下，这个消息是蓝牙真正打开的第一步。当然，若是bluetoothquickswitch打开了，是不会在这个状态收到这个消息的（除非出现了问题）
  13. caseUSER_TURN_ON:
  14. //startsturningonBTmodule,broadcastthisout
  15. //广播STATE_TURNING_ON的消息，可以做ui上显示等的处理
  16. broadcastState(BluetoothAdapter.STATE_TURNING_ON);
  17. //change到WarmUp的状态
  18. transitionTo(mWarmUp);
  19. //对蓝牙的初始化，我们暂时不管，后面我们有专门的文章来解释
  20. if(prepareBluetooth()){
  21. //thisisuserrequest,savethesetting
  22. if((Boolean)message.obj){
  23. persistSwitchSetting(true);
  24. }
  25. //WewillcontinueturntheBTonallthewaytotheBluetoothOnstate
  26. //若是成功，我们会发TURN_ON_CONTINUE的msg，
  27. //需要注意的是这个msg，是在warmup状态中进行处理的哦
  28. deferMessage(obtainMessage(TURN_ON_CONTINUE));
  29. }else{
  30. //当然，若是失败，我们需要回到poweroff的状态
  31. Log.e(TAG,"failedtopreparebluetooth,abortturningon");
  32. transitionTo(mPowerOff);
  33. broadcastState(BluetoothAdapter.STATE_OFF);
  34. }
  35. break;
  36. //这个case，TURN_HOT就是在bluetoothquickswitch打开的情况下，我们接收到这个msg，使得在开机之后，即使蓝牙没有打开，我们也会去做蓝牙controller初始化相关的操作，在上一篇文章中的《Android启动之bluetooth》中我们在initAfterRegistration中就有这个msg的发出，同样是根据quickswitch来判断的。
  37. caseTURN_HOT:
  38. //这里我们会发现，我们还是去初始化蓝牙相关的操作，不同的是，我们没有任何的广播消息发出，所以别的recever包括ui都是不知道我们偷偷做这个操作的。
  39. if(prepareBluetooth()){
  40. transitionTo(mWarmUp);//在初始化成功后，我们仍然会change到WarmUp
  41. }
  42. break;
  43. //对于飞行模式，我们并不陌生，它主要控制电话，wifi，和蓝牙，所以，毫无疑问，我们需要对飞行模式做一些处理。其实用脚趾头想我们都知道做了些什么，若是打开飞行模式之前蓝牙是打开的，那么关闭飞行模式，我们仍然需要打开它。若是打开飞行模式之前蓝牙是关闭的，那么关闭飞行模式的时候，我们根据quickswitch的值来判断是否重新打开
  44. caseAIRPLANE_MODE_OFF:
  45. if(getBluetoothPersistedSetting()){
  46. //之前是打开的，和USER_TURN_ON的处理是相同的
  47. //startsturningonBTmodule,broadcastthisout
  48. broadcastState(BluetoothAdapter.STATE_TURNING_ON);
  49. transitionTo(mWarmUp);
  50. if(prepareBluetooth()){
  51. //WewillcontinueturntheBTonallthewaytotheBluetoothOnstate
  52. deferMessage(obtainMessage(TURN_ON_CONTINUE));
  53. transitionTo(mWarmUp);
  54. }else{
  55. Log.e(TAG,"failedtopreparebluetooth,abortturningon");
  56. transitionTo(mPowerOff);
  57. broadcastState(BluetoothAdapter.STATE_OFF);
  58. }
  59. //之前是关闭的，需要根据quickswitch的值来进行判断，看是否发送TURN_HOT的msg
  60. }elseif(mContext.getResources().getBoolean
  61. (com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)){
  62. sendMessage(TURN_HOT);
  63. }
  64. break;
  65. //这个是上文所说的一些应用直接调用changeApplicationBluetoothStateapi之后会发出的msg，只会做蓝牙的打开操作，同样不会有任何的ui上的显示。
  66. casePER_PROCESS_TURN_ON:
  67. if(prepareBluetooth()){
  68. transitionTo(mWarmUp);
  69. }
  70. deferMessage(obtainMessage(PER_PROCESS_TURN_ON));
  71. break;
  72. //其它的msg都是无关紧要的，不加以分析了
  73. ……
  74. returnretValue;
  75. }

到这里，我们可以看到Poweroff状态下的msg分析就已经都完成了，比较关键的几个msg是USER_TURN_ON—UI上打开蓝牙的msg；TURN_HOT—quick switch打开的时候，默认打开蓝牙的msg；AIRPLANE_MODE_OFF—飞行模式关闭的msg。ok，下面我们去看一下warmup这个状态的处理。

[java] view plain copy
  1. privateclassWarmUpextendsState{
  3. @Override
  4. publicvoidenter(){
  5. if(DBG)log("EnterWarmUp:"+getCurrentMessage().what);
  6. }
  8. @Override
  9. publicbooleanprocessMessage(Messagemessage){
  10. log("WarmUpprocessmessage:"+message.what);
  12. booleanretValue=HANDLED;
  13. switch(message.what){
  14. //sdpok，则把刚刚preparebluetooth中启动的一个定时器（10s）remove掉，同时change到hotoff的状态
  15. caseSERVICE_RECORD_LOADED:
  16. removeMessages(PREPARE_BLUETOOTH_TIMEOUT);
  17. transitionTo(mHotOff);
  18. break;
  19. casePREPARE_BLUETOOTH_TIMEOUT:
  20. Log.e(TAG,"BluetoothadapterSDPfailedtoload");
  21. //若是tiemout的话，我们就只能change到poweroff状态了。
  22. shutoffBluetooth();
  23. transitionTo(mPowerOff);
  24. broadcastState(BluetoothAdapter.STATE_OFF);
  25. break;
  26. caseUSER_TURN_ON://handlethisatHotOffstate
  27. caseTURN_ON_CONTINUE://OnceinHotOffstate,continueturnbluetooth
  28. //ontotheBluetoothOnstate
  29. caseAIRPLANE_MODE_ON:
  30. caseAIRPLANE_MODE_OFF:
  31. casePER_PROCESS_TURN_ON:
  32. casePER_PROCESS_TURN_OFF:
  33. //收到以上这些消息都是直接defer就可以了，到下一个状态中去处理，再刚刚poweroff状态收到user_turn_on的时候，是发了TURN_ON_CONTINUE这个msg的，这个msg会在hotoff状态中继续起作用哦
  34. deferMessage(message);
  35. break;
  36. caseUSER_TURN_OFF:
  37. Log.w(TAG,"WarmUpreceived:"+message.what);
  38. break;
  39. default:
  40. returnNOT_HANDLED;
  41. }
  42. returnretValue;
  43. }
  45. }


总的来看，warmup状态并没有做什么特别的事情，就是检测了sdp是否ok，去除了prepare了timeout，仅此而已。所以，继续看hotoff的状态。

hotoff状态比较神奇，他就是为quick swtich而生的。对蓝牙controller而言，他是一个打开的状态，对上层应用来说，他就是一个关闭的状态。

[java] view plain copy
  1. privateclassHotOffextendsState{
  2. @Override
  3. publicvoidenter(){
  4. if(DBG)log("EnterHotOff:"+getCurrentMessage().what);
  5. }
  7. @Override
  8. publicbooleanprocessMessage(Messagemessage){
  9. log("HotOffprocessmessage:"+message.what);
  11. booleanretValue=HANDLED;
  12. switch(message.what){
  13. //这里其实就是ui上打开蓝牙了，需要注意的是，这里是不是没有change到别的状态哦？
  14. //这是为什么呢？这个case之后没有break啊，没有break，懂了吧。。。
  15. caseUSER_TURN_ON:
  16. broadcastState(BluetoothAdapter.STATE_TURNING_ON);
  17. if((Boolean)message.obj){
  18. persistSwitchSetting(true);
  19. }
  20. //这是什么，这是上面传下来的哦，所以ui在hotoff的状态下发这个msg，这里会继续处理的哦
  21. caseTURN_ON_CONTINUE:
  22. //这里就是蓝牙从hotoff到turnon之间要做的一个事情就是设置为connectable
  23. mBluetoothService.switchConnectable(true);
  24. //到switching的状态。
  25. transitionTo(mSwitching);
  26. break;
  27. //这里有两个msg，一个是飞行模式开，一个turncold，都会真正地去关闭蓝牙。
  28. //所以无论quickswitch是开还是关，之后飞行模式开了，都是会真正去关闭蓝牙的。
  29. caseAIRPLANE_MODE_ON:
  30. caseTURN_COLD:
  31. shutoffBluetooth();
  32. transitionTo(mPowerOff);
  33. broadcastState(BluetoothAdapter.STATE_OFF);
  34. break;
  35. //同样的飞行模式的打开的处理
  36. caseAIRPLANE_MODE_OFF:
  37. if(getBluetoothPersistedSetting()){
  38. broadcastState(BluetoothAdapter.STATE_TURNING_ON);
  39. transitionTo(mSwitching);
  40. mBluetoothService.switchConnectable(true);
  41. }
  42. break;
  43. break;
  44. //这里，不会走到swtiching的状态，会到mPerProcessState的状态，上面有详细的介绍
  45. casePER_PROCESS_TURN_ON:
  46. transitionTo(mPerProcessState);
  48. //ResendthePER_PROCESS_TURN_ONmessagesothatthecallback
  49. //canbesentthrough.
  50. deferMessage(message);
  52. mBluetoothService.switchConnectable(true);
  53. break;
  54. casePER_PROCESS_TURN_OFF:
  55. perProcessCallback(false,(IBluetoothStateChangeCallback)message.obj);
  56. break;
  57. caseUSER_TURN_OFF://ignore
  58. break;
  59. casePOWER_STATE_CHANGED:
  60. if((Boolean)message.obj){
  61. recoverStateMachine(TURN_HOT,null);
  62. }
  63. break;
  64. default:
  65. returnNOT_HANDLED;
  66. }
  67. returnretValue;
  68. }
  70. }


从代码来看，hotoff的状态就是对上层ui上的一些操作进行了响应，以及兼容了no quick swtich下面的ui打开操作。它会change到swtiching的状态或者mPerProcessState的状态。我们来看看吧

[java] view plain copy
  1. privateclassSwitchingextendsState{
  3. @Override
  4. publicvoidenter(){
  5. if(DBG)log("EnterSwitching:"+getCurrentMessage().what);
  6. }
  7. @Override
  8. publicbooleanprocessMessage(Messagemessage){
  9. log("Switchingprocessmessage:"+message.what);
  11. booleanretValue=HANDLED;
  12. switch(message.what){
  13. //从注释可以清晰地看到，这个msg是我们上面调用BluetoothService.switchConnectable(true);这个函数的正确回应
  14. caseSCAN_MODE_CHANGED:
  15. //ThiseventmatchesmBluetoothService.switchConnectableaction
  16. if(mPublicState==BluetoothAdapter.STATE_TURNING_ON){
  17. //setpairableifit'snot
  18. //设为可配对
  19. mBluetoothService.setPairable();
  20. //初始化bluetooth
  21. mBluetoothService.initBluetoothAfterTurningOn();
  22. //正式change到bluetoothon的状态
  23. transitionTo(mBluetoothOn);
  24. broadcastState(BluetoothAdapter.STATE_ON);
  25. //runbluetoothnowthatit'sturnedon
  26. //NoterunBluetoothshouldbecalledonlyinadapterSTATE_ON
  27. //这个函数做的事情其实就是打开后的自动连接了。
  28. mBluetoothService.runBluetooth();
  29. }
  30. break;
  31. casePOWER_STATE_CHANGED:
  32. removeMessages(POWER_DOWN_TIMEOUT);
  33. //power可以理解为电压的关闭
  34. if(!((Boolean)message.obj)){
  35. if(mPublicState==BluetoothAdapter.STATE_TURNING_OFF){
  36. //就是关闭了，change到hotoff状态
  37. transitionTo(mHotOff);
  38. finishSwitchingOff();
  39. //若是quickswitch没有设置，则会change到poweroff的状态
  40. if(!mContext.getResources().getBoolean
  41. (com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)){
  42. deferMessage(obtainMessage(TURN_COLD));
  43. }
  44. }
  45. }else{
  46. //在turningon就没有什么好做的，否则，就是看到poweroff还是hotoff了
  47. if(mPublicState!=BluetoothAdapter.STATE_TURNING_ON){
  48. if(mContext.getResources().getBoolean
  49. (com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)){
  50. recoverStateMachine(TURN_HOT,null);
  51. }else{
  52. recoverStateMachine(TURN_COLD,null);
  53. }
  54. }
  55. }
  56. break;
  57. //所有的remotedevice都断开连接了，则我们会在5s后发送一个POWER_DOWN_TIMEOUT的msg，这个msg和下面几个msg都是从on->switching的过程中要处理的，可以见下面bluetooth_on的msg处理分析
  58. caseALL_DEVICES_DISCONNECTED:
  59. removeMessages(DEVICES_DISCONNECT_TIMEOUT);
  60. mBluetoothService.switchConnectable(false);
  61. sendMessageDelayed(POWER_DOWN_TIMEOUT,POWER_DOWN_TIMEOUT_TIME);
  62. break;
  63. //设备断开超时了，直接复位一下
  64. caseDEVICES_DISCONNECT_TIMEOUT:
  65. sendMessage(ALL_DEVICES_DISCONNECTED);
  66. //resetthehardwareforerrorrecovery
  67. Log.e(TAG,"Devicesfailedtodisconnect,reseting...");
  68. deferMessage(obtainMessage(TURN_COLD));
  69. if(mContext.getResources().getBoolean
  70. (com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)){
  71. deferMessage(obtainMessage(TURN_HOT));
  72. }
  73. break;
  74. //powerdowntimeout,也是直接复位
  75. casePOWER_DOWN_TIMEOUT:
  76. transitionTo(mHotOff);
  77. finishSwitchingOff();
  78. //resetthehardwareforerrorrecovery
  79. Log.e(TAG,"Devicesfailedtopowerdown,reseting...");
  80. deferMessage(obtainMessage(TURN_COLD));
  81. if(mContext.getResources().getBoolean
  82. (com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)){
  83. deferMessage(obtainMessage(TURN_HOT));
  84. }
  85. break;
  86. ……


从上面可以看到switching主要是等待BluetoothService.switchConnectable(true)的结果，若是ok，就会到turn on的状态了，进入到打开的模式。至于PerProcessState的状体和swtiching的状态比较类似，只是少了一些通知而已，大家自己去分析哦。下面我们继续看bluetooth on的状态。

[java] view plain copy
  1. privateclassBluetoothOnextendsState{
  3. @Override
  4. publicvoidenter(){
  5. if(DBG)log("EnterBluetoothOn:"+getCurrentMessage().what);
  6. }
  7. @Override
  8. publicbooleanprocessMessage(Messagemessage){
  9. log("BluetoothOnprocessmessage:"+message.what);
  11. booleanretValue=HANDLED;
  12. switch(message.what){
  13. //这个是off的操作，就是ui上的关闭了
  14. caseUSER_TURN_OFF:
  15. if((Boolean)message.obj){
  16. persistSwitchSetting(false);
  17. }
  19. if(mBluetoothService.isDiscovering()){
  20. mBluetoothService.cancelDiscovery();
  21. }
  22. if(!mBluetoothService.isApplicationStateChangeTrackerEmpty()){
  23. transitionTo(mPerProcessState);
  24. deferMessage(obtainMessage(TURN_HOT));
  25. break;
  26. }
  27. //同样要注意，这里没有break哦
  28. //$FALL-THROUGH$toAIRPLANE_MODE_ON
  29. //和飞行模式打开的操作
  30. caseAIRPLANE_MODE_ON:
  31. broadcastState(BluetoothAdapter.STATE_TURNING_OFF);
  32. transitionTo(mSwitching);
  33. if(mBluetoothService.getAdapterConnectionState()!=
  34. BluetoothAdapter.STATE_DISCONNECTED){
  35. //需要把所有已经连接的设备都disconnect掉
  36. mBluetoothService.disconnectDevices();
  37. sendMessageDelayed(DEVICES_DISCONNECT_TIMEOUT,
  38. DEVICES_DISCONNECT_TIMEOUT_TIME);
  39. }else{
  40. //没有连接设备，直接powerdown
  41. mBluetoothService.switchConnectable(false);
  42. sendMessageDelayed(POWER_DOWN_TIMEOUT,POWER_DOWN_TIMEOUT_TIME);
  43. }
  45. //weturnallthewaytoPowerOffwithAIRPLANE_MODE_ON
  46. if(message.what==AIRPLANE_MODE_ON){
  47. //Weinformalltheperprocesscallbacks
  48. allProcessesCallback(false);
  49. deferMessage(obtainMessage(AIRPLANE_MODE_ON));
  50. }
  51. break;
  52. ……
  53. returnretValue;
  54. }
  56. }

所以，看起来bluetooth_on的处理也比较单纯，就是一些关闭的尾巴处理。

至此，bluetoothadapter的state machine就已经全部分析完成了，回顾一下，有六个状态，BluetoothOn，Switching，HotOff，WarmUp，PowerOff，PerProcessState，他们之间可以相互转换，从而达到打开关闭蓝牙的目的。

修改记录1：原本的状态图中，hotoff到poweroff有一个箭头画反了。


iteye_264
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
蓝牙之三-StateMachine
shichaog的专栏
07-31 5437
蓝牙和wifi的管理上都使用到了状态机。 该状态机属于分层状态机管理消息。一个状态对应于一个对象，并且状态必须实现>方法，可选的实现方法是，方法对应于构造和析构函数，它们被用于初始化和清理状态。方法返回状态的名称，缺省的方式是返回返回类名称，但是也许返回实例的名称是使用者更想要的方式，尤其是一个状态类具有多个实例的时候。 当状态机使用创建后，方法用于创建状态层次，用于标识哪些是初始的状态。构造
【微服务】spring状态机模式使用详解
congge
03-31 4659
spring状态机模式使用详解
Android蓝牙源码分析——StateMachine状态机
风语的专栏
08-18 3997
StateMachine有自己单独的工作线程，protected StateMachine(String name) { mSmThread = new HandlerThread(name); mSmThread.start(); Looper looper = mSmThread.getLooper(); initStateMachine(name, looper)
Android 蓝牙启动状态机
wsb1321的专栏
10-31 3294
Bluetooth状态转换图如下： (BluetootOn)<----------------------<- 40 * | ^ -------------------->- | 41 * | |
Bluetooth技术学习笔记 ——L2CAP之状态机
白萝卜
04-02 1002
今晚月色真美。
Android 蓝牙 搜索周围设备代码流程分析-framework到协议栈流程
手机-手表蓝牙开发工程师的博客
05-08 1726
本文详细的将Android 蓝牙扫描周围设备流程进行了梳理，从UI开始扫描到协议栈发送扫描命令到controller，进行了源码分析。 更多源码分析： android-蓝牙A2dp-avrcp-hfp-opp-配对流程-ble-rfcomm源码流程 Android 蓝牙配对连接源码分析文档大全，非常详细的从btif-bta-btm-hci 数据流程走向 - 点击下载 蓝牙UI开始扫描位于setting的 /packages/apps/Settings/src/com/android/settin
aasm：AASM-Ruby类的状态机（普通Ruby，ActiveRecord，Mongoid，NoBrainer）
01-31
AASM-Ruby状态机 指数 该软件包包含AASM，这是一个用于向Ruby类添加有限状态机的库。 AASM最初是基于act_as_state_machine插件，但已经演变成一个更通用的库，不再仅针对ActiveRecord模型。 它当前为许多ORM提供...
USB4 1.0 ECN - Host Router State Machine.pdf
11-17
本工程变更通知（Engineering Change Notice，ECN）主要关注Host Router的状态机，即USB4规范中主机路由器的状态转换流程。ECR（Engineering Change Request，工程变更请求）将主机路由器和设备路由器的状态机分离，...
Android 蓝牙状态获取
ansondroider的博客
12-08 7073
1. 蓝牙状态是否连接: public static boolean isBTConnected(){ BluetoothAdapter blueadapter = BluetoothAdapter.getDefaultAdapter(); //adapter也有getState(), 可获取ON/OFF...其它状态 int a2dp = blue
android蓝牙打开流程之BleOn状态至On状态
最新发布
zzl580的博客
04-28 595
详细介绍android上蓝牙打开流程中从BleOn状态至On状态的过程。
Android无线蓝牙开发总结
JimLau
07-31 481
一.蓝牙基础知识       蓝牙（Bluetooth）是一种短距离的无线通信技术标准。这个名子来源于10世纪丹麦国王Harald Blatand，英文名子是Harold Bluetooth。 （一）蓝牙的四层协议       蓝牙协议分为4层，即核心协议层、电缆替代协议层、电话控制协议层和采纳的其它协议层。这4种协议中最重要的是核心协议。蓝牙的核心协议包括基带、链路管理、逻辑链
蓝牙配对笔记
这都是什么
01-12 582
显示列表 packages/apps/Settings/src/com/android/settings/bluetooth/DeviceListPreferenceFragment.java DeviceListPreferenceFragment 初始化操作 @Override public void onCreate(Bundle savedInstanceState) {...
3、获取蓝牙适配器状态(getBluetoothAdapterState)
无聊达的博客
04-11 9051
wx.getBluetoothAdapterState(Object object) 基础库 1.1.0 开始支持，低版本需做兼容处理。 获取本机蓝牙适配器状态。 参数 Object object 属性 类型 默认值 必填 说明 success function 否 接口调用成功的回调函数 fail function ...
android状态机statemachine详解
热门推荐
pi9nc的专栏
05-29 2万+
android状态机statemachine详解 分类： android应用分析2013-08-13 07:18 1749人阅读 评论(1) 收藏 举报 android状态机详解statemachineandroid状态state         先说两句题外话，很感谢android，在这里能看到很多优秀的代码。同时也感觉到外面的工程师真的很厉害，都是java人家就能写出
蓝牙通话机制原理
Jack的博客
09-20 1万+
[摘要]: 本文主要论述基于android 6.0的蓝牙上层(Java层)通话机制;总结了蓝牙通话框架,并且给出了接听电话的详细的流程图;最后说明了apk的实现以及总结了蓝牙/android 相关的知识点。 1, 蓝牙框架 主要代码路径: 路径1: frameworks\base\core\java\android\bluetooth\   蓝牙相关接口,蓝牙各种功能的发起点。 路径2
Android 12 BT 配对流程[1]
无线互联&网络介绍
10-23 1400
IBluetooth 是system/bt/service/common/android/bluetooth/IBluetooth.aidl一个AIDL接口，这里是跨进程调用，看哪里实现了这个AIDL接口即可！这里走 createBondNative还是createBondOutOfBandNative取决于上层的调用没有数据，这里我们分析createBondNative。这里调用到JNI了，不懂的可以学习下JNI的动态注册，具体怎么看出来的呢？这里记录上层应用的调用流程！后面继续，回去洗洗睡！
android 获取蓝牙各种连接状态
小李子No1的专栏
05-15 1万+
蓝牙之间的配对及连接 //蓝牙已打开 if(mAdapter.isEnabled()){ int a2dp = mAdapter.getProfileConnectionState(BluetoothProfile.A2DP); // 可操控蓝牙设备，如带播放暂停功能的蓝牙耳机 int headset = mAdapter.getProfileConnectionStat
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值