内容简介：本文详细分析了android4.0 中蓝牙使能的过程，相比较android2.3，4.0中的蓝牙最大的差别在于UI上on/off的伪开关。在android4.0中加入了 adapter的状态机。所谓的状态机就类似于状态转换图，在一个状态收到某个特定的命令会变成另外一个状态，不同的命令可以跳转到不同的状态（当然也有 可能到同一状态）。adapter的初始状态为poweroff，在android系统启动的时候会进入warmup状态，同时会进行UUID的add， 该操作会引起propertychanged的UUID signal，该signal会使得状态从warmup变换到hotoff状态。因此在UI端off时其实adapter已经处于hotoff状态而不是 poweroff状态。这一点是很关键的。在正文中，我会从假如我不知道这些开始来描绘整个使能的过程。
正文：
毫无疑问，bluetooth的打开是在Settings中进行的操作。因此，冤有头，债有主，我们来到了Settings.java中，果然发现了相关的代码如下：
mBluetoothEnabler =new BluetoothEnabler(context, new Switch(context));
于是，我们得以进入真正的蓝牙操作的殿堂，好好进去看看吧。
代码来源：http://code.metager.de/source/xref/android/
1 1、BluetoothEnabler的构造函数
2
3
4
5 public BluetoothEnabler(Context context,Switch switch_) {
6
7 mContext = context;
8
9 mSwitch = switch_;
10
11 //很简单了，去调用一个LocalBluetoothManager类的getInstance，其实会构造该类的
12
13 LocalBluetoothManager manager =LocalBluetoothManager.getInstance(context);
14
15 if (manager == null) {
16
17 // Bluetooth is not supported
18
19 mLocalAdapter = null;
20
21 mSwitch.setEnabled(false);
22
23 } else {
24
25 //构造成功后，通过manager得到bluetooth的adapter
26
27 mLocalAdapter =manager.getBluetoothAdapter();
28
29 }
30
31 //同时新建一个intent，用于接收ACTION_STATE_CHANGED
32
33 mIntentFilter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
34
35 }
36
37
38
39 2、LocalBluetoothManager类的getInstance 40
41 public static synchronized LocalBluetoothManager getInstance(Context context) {
42
43 if (sInstance == null) {
44
45 //2.1同样的，这个会去调用LocalBluetoothAdapter的getInstance，也会构造该类
46
47 LocalBluetoothAdapter adapter =LocalBluetoothAdapter.getInstance();
48
49 if (adapter == null) {
50
51 return null;
52
53 }
54
55 // This will be around as long asthis process is
56
57 Context appContext =context.getApplicationContext();
58
59 //2.2构造LocalBluetoothManager类
60
61 sInstance = new LocalBluetoothManager(adapter, appContext);
62
63 }
64
65
66
67 return sInstance;
68
69 }
70
71 2.1 LocalBluetoothAdapter的getInstance 72
73
74
75 static synchronized LocalBluetoothAdapter getInstance() {
76
77 if (sInstance == null) {
78
79 //2.1.1通过BluetoothAdapter得到DefaultAdapter
80
81 BluetoothAdapter adapter =BluetoothAdapter.getDefaultAdapter();
82
83 if (adapter != null) {
84
85 //2.1.2若有该DefaultAdapter，则构造LocalBluetoothAdapter
86
87 sInstance = new LocalBluetoothAdapter(adapter);
88
89 }
90
91 }
92
93
94
95 return sInstance;
96
97 }
98
99
100
101 2.1.1BluetoothAdapter得到DefaultAdapter 102
103
104
105 public static synchronized BluetoothAdapter getDefaultAdapter() {
106
107 if (sAdapter == null) {
108
109 IBinder b =ServiceManager.getService(BluetoothAdapter.BLUETOOTH_SERVICE);
110
111 if (b != null) {
112
113 IBluetooth service =IBluetooth.Stub.asInterface(b);
114
115 sAdapter = new BluetoothAdapter(service);
116
117 }
118
119 }
120
121 return sAdapter;
122
123 }
124
125
126
127 2.1.2构造LocalBluetoothAdapter 128
129 //其实就是 mAdapter的初始化而已
130
131 private LocalBluetoothAdapter(BluetoothAdapter adapter) {
132
133 mAdapter = adapter;
134
135 }
136
137 2.2构造LocalBluetoothManager类 138
139 //管理本地蓝牙类，用来在蓝牙API子类上面再封装一个接口
140
141 private LocalBluetoothManager(LocalBluetoothAdapter adapter, Context context) {
142
143 mContext = context;
144
145 //mLocalAdapter初始化为DefaultAdapter中得到的值
146
147 mLocalAdapter= adapter;
148
149 //构造CachedBluetoothDeviceManager，用来管理远程蓝牙设备
150
151 mCachedDeviceManager = new CachedBluetoothDeviceManager(context);
152
153 //2.2.1构建BluetoothEventManager，该类是用来管理广播消息和回调函数的，即分发不同的消息去对UI进行处理
154
155 mEventManager = new BluetoothEventManager(mLocalAdapter,
156
157 mCachedDeviceManager, context);
158
159 //2.2.2该类提供对不同LocalBluetoothProfile object的访问
160
161 mProfileManager = new LocalBluetoothProfileManager(context,
162
163 mLocalAdapter,mCachedDeviceManager, mEventManager);
164
165 }
166
167
168
169 2.2.1构建BluetoothEventManager 170
171
172
173 BluetoothEventManager(LocalBluetoothAdapteradapter,
174
175 CachedBluetoothDeviceManagerdeviceManager, Context context) {
176
177 mLocalAdapter = adapter;
178
179 mDeviceManager = deviceManager;
180
181 //创建两个IntentFilter
182
183 mAdapterIntentFilter = new IntentFilter();
184
185 //这里没有对mProfileIntentFilter进行初始化，这个在LocalBluetoothProfileManager的addProfile中实现
186
187 mProfileIntentFilter = new IntentFilter();
188
189 //创建一个Handler的Hash表
190
191 mHandlerMap = new HashMap<String,Handler>();
192
193 mContext = context;
194
195
196
197 //注册对adapter和Device的几个广播消息的处理回调函数
198
199 //add action到mAdapterIntentFilter
200
201 // Bluetooth on/off broadcasts
202
203 addHandler(BluetoothAdapter.ACTION_STATE_CHANGED, newAdapterStateChangedHandler());
204
205
206
207 // Discovery broadcasts
208
209 addHandler(BluetoothAdapter.ACTION_DISCOVERY_STARTED, newScanningStateChangedHandler(true));
210
211 addHandler(BluetoothAdapter.ACTION_DISCOVERY_FINISHED, newScanningStateChangedHandler(false));
212
213 addHandler(BluetoothDevice.ACTION_FOUND, new DeviceFoundHandler());
214
215 addHandler(BluetoothDevice.ACTION_DISAPPEARED, newDeviceDisappearedHandler());
216
217 addHandler(BluetoothDevice.ACTION_NAME_CHANGED, newNameChangedHandler());
218
219
220
221 // Pairing broadcasts
222
223 addHandler(BluetoothDevice.ACTION_BOND_STATE_CHANGED, newBondStateChangedHandler());
224
225 addHandler(BluetoothDevice.ACTION_PAIRING_CANCEL, newPairingCancelHandler());
226
227
228
229 // Fine-grained state broadcasts
230
231 addHandler(BluetoothDevice.ACTION_CLASS_CHANGED, newClassChangedHandler());
232
233 addHandler(BluetoothDevice.ACTION_UUID,new UuidChangedHandler());
234
235
236
237 // Dock event broadcasts
238
239 addHandler(Intent.ACTION_DOCK_EVENT,new DockEventHandler());
240
241 //mAdapterIntentFilter的接收处理函数
242
243 mContext.registerReceiver(mBroadcastReceiver, mAdapterIntentFilter);
244
245 }
246
247
248
249 2.2.2构造LocalBluetoothProfileManager类 250
251
252
253 LocalBluetoothProfileManager(Contextcontext,
254
255 LocalBluetoothAdapter adapter,
256
257 CachedBluetoothDeviceManagerdeviceManager,
258
259 BluetoothEventManager eventManager){
260
261 mContext = context;
262
263
264
265 //各个类之间进行关联
266
267 mLocalAdapter = adapter;
268
269 mDeviceManager = deviceManager;
270
271 mEventManager = eventManager;
272
273 // pass this reference to adapter andevent manager (circular dependency)
274
275 mLocalAdapter.setProfileManager(this);
276
277 mEventManager.setProfileManager(this);
278
279
280
281 ParcelUuid[] uuids =adapter.getUuids();
282
283
284
285 // uuids may be null if Bluetooth isturned off
286
287 if (uuids != null) {
288
289 //假如已经有了uuid，根据uuid来add并new对应的profile，只针对A2DP,HFP,HSP,OPP四个profile，HID和PAN在下面，每次都add
290
291 updateLocalProfiles(uuids);
292
293 }
294
295
296
297 // Always add HID and PAN profiles
298
299 //加入HID和PAN两个profile
300
301 mHidProfile = new HidProfile(context,mLocalAdapter);
302
303 addProfile(mHidProfile,HidProfile.NAME,
304
305 BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
306
307
308
309 mPanProfile = new PanProfile(context);
310
311 addPanProfile(mPanProfile,PanProfile.NAME,
312
313 BluetoothPan.ACTION_CONNECTION_STATE_CHANGED);
314
315
316
317 Log.d(TAG,"LocalBluetoothProfileManager construction complete");
318
319 }
320
321
322
好吧，其实我们被骗了，刚刚只是一个路引，不是真正的操作，真正的操作向来都是从你滑动界面那个on/off键开始的，因此我们决定把这个键的处理给揪出来。在Settings界面上一共就只有两个on/off键，一个是wifi，另一个就是蓝牙了，我们从这个代码入手：
324
325 case HEADER_TYPE_SWITCH:
326
327 //其实写这个代码的人也比较心虚，假如switch多一点，下面就要重写了
328
329 // Would need a differenttreatment if the main menu had more switches
330
331 if (header.id ==R.id.wifi_settings) {
332
333 mWifiEnabler.setSwitch(holder.switch_);
334
335 } else {
336
337 //这个就是处理了，上面的路引没有白做啊
338
339 mBluetoothEnabler.setSwitch(holder.switch_);
340
341 }
342
343
344
345 3、mBluetoothEnabler.setSwitch分析 346
347
348
349 public void setSwitch(Switch switch_) {
350
351 //若是和上次相同，则不做任何事情，可以理解，代码也懒嘛
352
353 if (mSwitch == switch_) return;
354
355 //把上次的switch的changelistener清空
356
357 mSwitch.setOnCheckedChangeListener(null);
358
359 mSwitch = switch_;
360
361 //重设这次的switch的changelistener
362
363 mSwitch.setOnCheckedChangeListener(this);
364
365
366
367 int bluetoothState =BluetoothAdapter.STATE_OFF;
368
369 //获取getBluetoothState，这个过程也会同步一下state，防止改变
370
371 if (mLocalAdapter != null)bluetoothState = mLocalAdapter.getBluetoothState();
372
373 //根据状态设置一下两个标志位
374
375 boolean isOn = bluetoothState == BluetoothAdapter.STATE_ON;
376
377 boolean isOff = bluetoothState == BluetoothAdapter.STATE_OFF;
378
379 //设置checked的状态位。注意，假如这里状态发生了改变，则会调用this.onCheckedChanged来进行处理
380
381 mSwitch.setChecked(isOn);
382
383 if(WirelessSettings.isRadioAllowed(mContext, Settings.System.RADIO_BLUETOOTH)) {
384
385 //有bluetooth或者不是airplane，则该switch不变灰，否则，灰的。
386
387 mSwitch.setEnabled(isOn || isOff);
388
389 } else {
390
391 mSwitch.setEnabled(false);
392
393 }
394
395 }
396
397
398
399 4、onCheckedChanged 400
401 在switch状态发生改变后，会调用这个地方的回调函数进行处理。
402
403
404
405 public void onCheckedChanged(CompoundButtonbuttonView, boolean isChecked) {
406
407 // Show toast message if Bluetooth isnot allowed in airplane mode
408
409 //若是打开的话，就需要检查一下是否allow Bluetooth（radio，airplane的check）
410
411 if (isChecked &&
412
413 !WirelessSettings.isRadioAllowed(mContext,Settings.System.RADIO_BLUETOOTH)) {
414
415 Toast.makeText(mContext,R.string.wifi_in_airplane_mode, Toast.LENGTH_SHORT).show();
416
417 // Reset switch to off
418
419 //若是不对的话，reset为off
420
421 buttonView.setChecked(false);
422
423 }
424
425
426
427 if (mLocalAdapter != null) {
428
429 //4.1设置scanmode，放心，它会判断state的，不是STATE_ON，会直接返回false的
430
431 mLocalAdapter.setScanMode(BluetoothAdapter.SCAN_MODE_CONNECTABLE);
432
433 //4.2使能或不使能Bluetooth了
434
435 mLocalAdapter.setBluetoothEnabled(isChecked);
436
437 }
438
439 //过程中还是会反灰，直到setBluetoothEnabled的结果返回会改变switch的状态
440
441 mSwitch.setEnabled(false);
442
443 }
444
445
446
447 4.1设置scanmod 448
449
450
451 会调用adapter中的setScanMode，直接去看就可以了，事实上就是设置了两个property标志，没什么
452
453
454
455 public boolean setScanMode(int mode) {
456
457 //这里把这个代码写出来就是证明一下，STATE_ON才会真正做下去，否则免谈
458
459 if (getState() != STATE_ON) returnfalse;
460
461 //这里会调用对应server中的setScanMode
462
463 return setScanMode(mode, 120);
464
465 }
466
467
468
469 public synchronized boolean setScanMode(intmode, int duration) {
470
471 //这里有个permission，好像和2.3中不一样，注意一下 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS,
472
473 "NeedWRITE_SECURE_SETTINGS permission");
474
475 boolean pairable;
476
477 boolean discoverable;
478
479
480
481 switch (mode) {
482
483 case BluetoothAdapter.SCAN_MODE_NONE:
484
485 pairable = false;
486
487 discoverable = false;
488
489 break;
490
491 caseBluetoothAdapter.SCAN_MODE_CONNECTABLE:
492
493 //开始就是这里了，可pairable，但是不可discoverable
494
495 pairable = true;
496
497 discoverable = false;
498
499 break;
500
501 caseBluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE:
502
503 pairable = true;
504
505 discoverable = true;
506
507 if (DBG) Log.d(TAG, "BTDiscoverable for " + duration + " seconds");
508
509 break;
510
511 default:
512
513 Log.w(TAG, "Requested invalidscan mode " + mode);
514
515 return false;
516
517 }
518
519
520
521 //设置这两个property标志
522
523 setPropertyBoolean("Discoverable", discoverable);
524
525 setPropertyBoolean("Pairable", pairable);
526
527 return true;
528
529 }
530
531
532
533 4.2setBluetoothEnabled分析 534
535
536
537 public void setBluetoothEnabled(booleanenabled) {
538
539 //根据enabled的标志设置是enable还是disable，在2.3中，这个地方就是bt_enable哦，这里还不知道，我们在第5步进行详细的分析
540
541 boolean success = enabled
542
543 ? mAdapter.enable()
544
545 : mAdapter.disable();
546
547 //成功了，设置对应的状态位
548
549 if (success) {
550
551 setBluetoothStateInt(enabled
552
553 ?BluetoothAdapter.STATE_TURNING_ON
554
555 :BluetoothAdapter.STATE_TURNING_OFF);
556
557 } else {
558
559 if (Utils.V) {
560
561 Log.v(TAG,"setBluetoothEnabled call, manager didn't return " +
562
563 "success forenabled: " + enabled);
564
565 }
566
567 //同步一下设置的状态
568
569 syncBluetoothState();
570
571 }
572
573 }
574
575 }
576
577
578
579 5、mAdapter.enable或者mAdapter.disable 580
581
582
583 就先分析enable吧，它会调用对应server端的enable(ture),我们来看看源码
584
585
586
587 public synchronized boolean enable(booleansaveSetting) {
588
589 mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
590
591 "Need BLUETOOTH_ADMIN permission");
592
593
594
595 // Airplane mode can prevent Bluetoothradio from being turned on.
596
597 //检查是否是飞行模式
598
599 if (mIsAirplaneSensitive &&isAirplaneModeOn() && !mIsAirplaneToggleable) {
600
601 return false;
602
603 }
604
605 //5.1注意与2.3的不同，在2.3中，这里会调用enablethread去调用native的bt_enable，而4.0没有这么做。没事，我们来分析4.0怎么做的。
606
607 mBluetoothState.sendMessage(BluetoothAdapterStateMachine.USER_TURN_ON,saveSetting);
608
609 return true;
610
611 }
612
613
614
615 5.1mBluetoothState.sendMessage 616
617
618
简单理解一下，mBluetoothState是BluetoothAdapterStateMachine类。因此，在分析的之前，简单说一下，它其实就是类似一个状态转换图，根据你所处于的状态，然后再判断收到的操作，进行不同的处理。根据构造函数中的setInitialState(mPowerOff);可以知道初始状态是PowerOff。但是从它给出的状态机可以看出，在PowerOff的状态时，它是通过TURN_HOT/TURN_ON来改变到HotOff状态的，然后才会收到USER_TURN_ON，去该变到BluetootOn的状态。因此，可以肯定的是我们这里的USER_TURN_ON不是它收到的第一个message，因此我们去纠结一下它是从哪里开始改变PowerOff的状态：extra1，然后再来看这里的处理吧：5.2。
620
621
622
623 extra1、mAdapter.enable之前的状态机转变 624
625
626
627 众所周知，android在启动之后会启动一个serverThread的线程，通过这个线程会启动一系列的服务。我们的蓝牙服务也是在这里启动的，android4.0其实在这个地方对状态机进行了修改，我们来看一下源码：
628
629 该代码位于framworks/base/services/java/com/android/server/systemserver.java
630
631 BluetoothServicebluetooth = null;
632
633 BluetoothA2dpServicebluetoothA2dp = null;
634
635
636
637 //模拟器上是不支持Bluetooth的，工厂测试模式也没有Bluetooth（这个不了解）
638
639 // Skip Bluetooth if we have anemulator kernel
640
641 // TODO: Use a more reliable checkto see if this product should
642
643 // support Bluetooth - see bug988521
644
645 if(SystemProperties.get("ro.kernel.qemu").equals("1")) {
646
647 Slog.i(TAG, "No BluetoohService (emulator)");
648
649 } else if (factoryTest ==SystemServer.FACTORY_TEST_LOW_LEVEL) {
650
651 Slog.i(TAG, "No BluetoothService (factory test)");
652
653 } else {
654
655 Slog.i(TAG, "BluetoothService");
656
657 //新建Bluetoothservice，并把他加入到ServiceManager中
658
659 bluetooth = newBluetoothService(context);
660
661 ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE,bluetooth);
662
663 //extra1.1在启动Bluetooth服务后进行一些初始化，呵呵，这里就对状态机进行了改变
664
665 bluetooth.initAfterRegistration();
666
667
668
669 //新建了BluetoothA2dpService，并把之加入到了ServiceManager中
670
671 bluetoothA2dp= new BluetoothA2dpService(context, bluetooth);
672
673 ServiceManager.addService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE,
674
675 bluetoothA2dp);
676
677 //extra1.2同样的要在之后做些init的工作
678
679 bluetooth.initAfterA2dpRegistration();
680
681 //得到是否飞行
682
683 int airplaneModeOn =Settings.System.getInt(mContentResolver,
684
685 Settings.System.AIRPLANE_MODE_ON, 0);
686
687 //看Bluetooth是否on，若是打开的状态（没有飞行），则这里会调用enable去打开
688
689 int bluetoothOn =Settings.Secure.getInt(mContentResolver,
690
691 Settings.Secure.BLUETOOTH_ON, 0);
692
693 if (airplaneModeOn == 0&& bluetoothOn != 0) {
694
695 bluetooth.enable();
696
697 }
698
699 }
700
701
702
703 extra1.1 initAfterRegistration分析 704
705
706
707 public synchronized voidinitAfterRegistration() {
708
709 //得到default的adapter
710
711 mAdapter =BluetoothAdapter.getDefaultAdapter();
712
713 //创建BluetoothAdapterStateMachine，初始化几个状态，并设初始状态位POWEROFF,这里同时新建了一个EventLoop
714
715 mBluetoothState = newBluetoothAdapterStateMachine(mContext, this, mAdapter);
716
717 mBluetoothState.start();
718
719 //根据这个xml的bool变量来决定是否先期TURN_HOT，该变量位于frameworks/base/core/res/res/values/config.xml中，默认为true
720
721 if (mContext.getResources().getBoolean
722
723 (com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)) {
724
725 //extra1.2发送TURN_HOT的状态变化message
726
727 mBluetoothState.sendMessage(BluetoothAdapterStateMachine.TURN_HOT);
728
729 }
730
731 //得到对应的EventLoop
732
733 mEventLoop =mBluetoothState.getBluetoothEventLoop();
734
735 }
736
737
738
739 extra1.2 TURN_HOT message的处理 740
741
742
743 /**
744
745 * Bluetooth module's power is off,firmware is not loaded.
746
747 */
748
749 private class PowerOff extends State {
750
751 @Override
752
753 public void enter() {
754
755 if (DBG) log("Enter PowerOff:" + getCurrentMessage().what);
756
757 }
758
759 @Override
760
761 public boolean processMessage(Messagemessage) {
762
763 log("PowerOff process message:" + message.what);
764
765
766
767 boolean retValue = HANDLED;
768
769 switch(message.what) {
770
771 ……
772
773 case TURN_HOT:
774
775 //extra1.3这里就是我们寻找了千年的bt_enable所在的地方。我们去看看
776
777 if (prepareBluetooth()) {
778
779 //extra1.5转变状态到warmup，在prepareBluetooth真正完成后，这个状态还会发生改变
780
781 transitionTo(mWarmUp);
782
783 }
784
785 break;
786
787 ……
788
789
790
791 extra1.3prepareBluetooth分析 792
793
794
795 看英文注释就知道了，不解释
796
797 /**
798
799 * Turn on Bluetooth Module, Loadfirmware, and do all the preparation
800
801 * needed to get the Bluetooth Moduleready but keep it not discoverable
802
803 * and not connectable.
804
805 * The last step of this method sets upthe local service record DB.
806
807 * There will be a event reporting thestatus of the SDP setup.
808
809 */
810
811 private boolean prepareBluetooth() {
812
813 //extra1.4首先还是调用了enableNative的本地方法，到这里你会发现终于和2.3相似了（不过请注意调用的时机不同了，这个在初始化，而2.3在界面的on/off滑动的时候），它还是会调用bt_enable，这个就会调用对应的set_bluetooth_power了
814
815 if(mBluetoothService.enableNative() != 0) {
816
817 return false;
818
819 }
820
821
822
823 // try to start event loop, give 2attempts
824
825 //尝试两次去start event loop
826
827 int retryCount = 2;
828
829 boolean eventLoopStarted = false;
830
831 while ((retryCount-- > 0)&& !eventLoopStarted) {
832
833 mEventLoop.start();
834
835 // it may take a moment for theother thread to do its
836
837 // thing. Check periodically for a while.
838
839 int pollCount = 5;
840
841 while ((pollCount-- > 0)&& !eventLoopStarted) {
842
843 if(mEventLoop.isEventLoopRunning()) {
844
845 eventLoopStarted =true;
846
847 break;
848
849 }
850
851 try {
852
853 Thread.sleep(100);
854
855 } catch(InterruptedException e) {
856
857 log("prepareBluetooth sleep interrupted: " + pollCount);
858
859 break;
860
861 }
862
863 }
864
865 }
866
867 //出错处理
868
869 if (!eventLoopStarted) {
870
871 mBluetoothService.disableNative();
872
873 return false;
874
875 }
876
877
878
879 // get BluetoothService ready
880
881 //建立native data以及SDP相关的一些操作，这里将会产生PropertyChanged的UUIDs的signal，对该信号的处理会对状态发生改变，详细分析见extra1.5
882
883 if(!mBluetoothService.prepareBluetooth()) {
884
885 mEventLoop.stop();
886
887 mBluetoothService.disableNative();
888
889 return false;
890
891 }
892
893 //设置一个prepare的超时处理，在该时间内没有收到UUID changed的signal将会进行错误处理
894
895 sendMessageDelayed(PREPARE_BLUETOOTH_TIMEOUT,PREPARE_BLUETOOTH_TIMEOUT_TIME);
896
897 return true;
898
899 }
900
901 }
902
903
904
905 extra1.4 bt_enable分析 906
907
908
909 intbt_enable() {
910
911 LOGV(__FUNCTION__);
912
913
914
915 int ret = -1;
916
917 int hci_sock = -1;
918
919 int attempt;
920
921
922
923 //power的设置，on。不解释，可加入对应板子的gpio口的处理，默认就只用了rfkill的处理
924
925 if (set_bluetooth_power(1) < 0) gotoout;
926
927 //开始hciattach服务，这个我们也做了修改，加入了rtk_h5
928
929 LOGI("Starting hciattachdaemon");
930
931 if (property_set("ctl.start","hciattach") < 0) {
932
933 LOGE("Failed to starthciattach");
934
935 set_bluetooth_power(0);
936
937 goto out;
938
939 }
940
941
942
943
944
945 // Try for 10 seconds, this can onlysucceed once hciattach has sent the
946
947 // firmware and then turned on hci devicevia HCIUARTSETPROTO ioctl
948
949 for (attempt = 1000; attempt > 0; attempt--) {
950
951 //创建hci_sock
952
953 hci_sock = create_hci_sock();
954
955 if (hci_sock < 0) goto out;
956
957 //调用ioctl的HCIDEVUP，来判断hciattach是否已经ok了。
958
959 ret = ioctl(hci_sock, HCIDEVUP,HCI_DEV_ID);
960
961
962
963 LOGI("bt_enable: ret: %d, errno:%d", ret, errno);
964
965 if (!ret) {
966
967 break;
968
969 } else if (errno == EALREADY) {
970
971 LOGW("Bluetoothd alreadystarted, unexpectedly!");
972
973 break;
974
975 }
976
977
978
979 close(hci_sock);
980
981 //等待10 ms后再试一次
982
983 usleep(100000); // 100 ms retry delay
984
985 }
986
987 //10s都没有搞定，需要做个失败的处理
988
989 if (attempt == 0) {
990
991 LOGE("%s: Timeout waiting for HCIdevice to come up, error- %d, ",
992
993 __FUNCTION__, ret);
994
995 if (property_set("ctl.stop","hciattach") < 0) {
996
997 LOGE("Error stoppinghciattach");
998
999 }
1000
1001 set_bluetooth_power(0);
1002
1003 goto out;
1004
1005 }
1006
1007 //启动bluetoothd服务
1008
1009 LOGI("Starting bluetoothddeamon");
1010
1011 if (property_set("ctl.start","bluetoothd") < 0) {
1012
1013 LOGE("Failed to startbluetoothd");
1014
1015 set_bluetooth_power(0);
1016
1017 goto out;
1018
1019 }
1020
1021
1022
1023 ret = 0;
1024
1025
1026
1027 out:
1028
1029 //关闭hci_sock
1030
1031 if (hci_sock >= 0) close(hci_sock);
1032
1033 return ret;
1034
1035 }
1036
1037
1038
1039 extra 1.5 PropetyChanged的UUIDs的处理 1040
1041
1042
1043 event_filter是用来对bluez的dbus的signal进行监听的，有signal产生后，会在这里进行处理。因此，我们直接到这里看看该怎么处理。
1044
1045
1046
1047 //Called by dbus during WaitForAndDispatchEventNative()
1048
1049 staticDBusHandlerResult event_filter(DBusConnection *conn, DBusMessage *msg,
1050
1051 void*data) {
1052
1053 native_data_t *nat;
1054
1055 JNIEnv *env;
1056
1057 DBusError err;
1058
1059 DBusHandlerResult ret;
1060
1061
1062
1063 //err的一个初始化
1064
1065 dbus_error_init(&err);
1066
1067 //得到参数
1068
1069 nat = (native_data_t *)data;
1070
1071 nat->vm->GetEnv((void**)&env,nat->envVer);
1072
1073 if (dbus_message_get_type(msg) !=DBUS_MESSAGE_TYPE_SIGNAL) {
1074
1075 LOGV("%s: not interested (not asignal).", __FUNCTION__);
1076
1077 returnDBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1078
1079 }
1080
1081
1082
1083 LOGV("%s: Received signal %s:%s from%s", __FUNCTION__,
1084
1085 dbus_message_get_interface(msg),dbus_message_get_member(msg),
1086
1087 dbus_message_get_path(msg));
1088
1089
1090
1091 env->PushLocalFrame(EVENT_LOOP_REFS);
1092
1093 ……
1094
1095 //PropertyChanged这个signal的处理
1096
1097 } else if (dbus_message_is_signal(msg,
1098
1099 "org.bluez.Adapter",
1100
1101 "PropertyChanged")) {
1102
1103 //由msg解析参数
1104
1105 jobjectArray str_array =parse_adapter_property_change(env, msg);
1106
1107 if (str_array != NULL) {
1108
1109 /* Check if bluetoothd has(re)started, if so update the path. */
1110
1111 jstring property =(jstring)env->GetObjectArrayElement(str_array, 0);
1112
1113 const char *c_property =env->GetStringUTFChars(property, NULL);
1114
1115 //检查Property是否started
1116
1117 if (!strncmp(c_property,"Powered", strlen("Powered"))) {
1118
1119 //若是powered，则看value是否是true，是ture就得到对应的path
1120
1121 jstring value =
1122
1123 (jstring)env->GetObjectArrayElement(str_array, 1);
1124
1125 const char *c_value =env->GetStringUTFChars(value, NULL);
1126
1127 if (!strncmp(c_value,"true", strlen("true")))
1128
1129 nat->adapter =get_adapter_path(nat->conn);
1130
1131 env->ReleaseStringUTFChars(value, c_value);
1132
1133 }
1134
1135 env->ReleaseStringUTFChars(property, c_property);
1136
1137 //extra1.6调用对应的method_onPropertyChanged函数，该method对应的onPropertyChanged函数
1138
1139 env->CallVoidMethod(nat->me,
1140
1141 method_onPropertyChanged,
1142
1143 str_array);
1144
1145 } elseLOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
1146
1147 goto success;
1148
1149 ……
1150
1151
1152
1153 extra1.6 真正的处理函数onPropertyChanged分析 1154
1155
1156
1157 /**
1158
1159 * Called by native code on aPropertyChanged signal from
1160
1161 * org.bluez.Adapter. This method is alsocalled from
1162
1163 * {@link BluetoothAdapterStateMachine} toset the "Pairable"
1164
1165 * property when Bluetooth is enabled.
1166
1167 *
1168
1169 * @param propValues a string arraycontaining the key and one or more
1170
1171 * values.
1172
1173 */
1174
1175 /*package*/ void onPropertyChanged(String[]propValues) {
1176
1177 BluetoothAdapterPropertiesadapterProperties =
1178
1179 mBluetoothService.getAdapterProperties();
1180
1181 //先fill up cache
1182
1183 if (adapterProperties.isEmpty()) {
1184
1185 // We have got a property changebefore
1186
1187 // we filled up our cache.
1188
1189 adapterProperties.getAllProperties();
1190
1191 }
1192
1193 log("Property Changed: " +propValues[0] + " : " + propValues[1]);
1194
1195 String name = propValues[0];
1196
1197 ……
1198
1199 //对UUIDs的处理
1200
1201 } else if(name.equals("Devices") || name.equals("UUIDs")) {
1202
1203 String value = null;
1204
1205 int len =Integer.valueOf(propValues[1]);
1206
1207 if (len > 0) {
1208
1209 StringBuilder str = newStringBuilder();
1210
1211 for (int i = 2; i <propValues.length; i++) {
1212
1213 str.append(propValues[i]);
1214
1215 str.append(",");
1216
1217 }
1218
1219 value = str.toString();
1220
1221 }
1222
1223 //把name和value值加入到property的map中
1224
1225 adapterProperties.setProperty(name,value);
1226
1227 //extra1.7有UUIDs的change signal会刷新Bluetooth的State
1228
1229 if (name.equals("UUIDs")){
1230
1231 mBluetoothService.updateBluetoothState(value);
1232
1233 }
1234
1235 //对Pairable和Discoverable的处理
1236
1237 } else if(name.equals("Pairable") || name.equals("Discoverable")) {
1238
1239 adapterProperties.setProperty(name,propValues[1]);
1240
1241
1242
1243 if(name.equals("Discoverable")) {
1244
1245 //5.6发送SCAN_MODE_CHANGED的msg，去改变状态机 mBluetoothState.sendMessage(BluetoothAdapterStateMachine.SCAN_MODE_CHANGED);
1246
1247 }
1248
1249 //设置对应的property
1250
1251 String pairable =name.equals("Pairable") ? propValues[1] :
1252
1253 adapterProperties.getProperty("Pairable");
1254
1255 String discoverable =name.equals("Discoverable") ? propValues[1] :
1256
1257 adapterProperties.getProperty("Discoverable");
1258
1259
1260
1261 // This shouldn't happen, unlessAdapter Properties are null.
1262
1263 if (pairable == null ||discoverable == null)
1264
1265 return;
1266
1267
1268
1269 int mode =BluetoothService.bluezStringToScanMode(
1270
1271 pairable.equals("true"),
1272
1273 discoverable.equals("true"));
1274
1275 if (mode >= 0) {
1276
1277 //当pairable和discoverable均为true的时候，会发送一个ACTION_SCAN_MODE_CHANGED的广播消息
1278
1279 Intent intent = newIntent(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
1280
1281 intent.putExtra(BluetoothAdapter.EXTRA_SCAN_MODE, mode);
1282
1283 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
1284
1285 mContext.sendBroadcast(intent,BLUETOOTH_PERM);
1286
1287 }
1288
1289 }
1290
1291
1292
1293 ……
1294
1295
1296
1297 extra1.7 UUIDs改变带来的State的刷新 1298
1299
1300 /**
1301
1302 * This function is called from BluetoothEvent Loop when onPropertyChanged
1303
1304 * for adapter comes in with UUID property.
1305
1306 * @param uuidsThe uuids of adapter asreported by Bluez.
1307
1308 */
1309
1310 /*package*/ synchronized voidupdateBluetoothState(String uuids) {
1311
1312 ParcelUuid[] adapterUuids =convertStringToParcelUuid(uuids);
1313
1314 //为什么必须包含所有已经有的uuid？？感觉有点反了，再看看
1315
1316 if (mAdapterUuids != null &&
1317
1318 BluetoothUuid.containsAllUuids(adapterUuids, mAdapterUuids)) {
1319
1320 //放SERVICE_RECORD_LOADED的信息，此时，处于warm up状态，看extra1.8分析状态如何继续改变 mBluetoothState.sendMessage(BluetoothAdapterStateMachine.SERVICE_RECORD_LOADED);
1321
1322 }
1323
1324 }
1325
1326
1327
1328 extra1.8 UUIDs对状态机改变 1329
1330
1331 /**
1332
1333 * Turning on Bluetooth module's power,loading firmware, starting
1334
1335 * event loop thread to listen on Bluetoothmodule event changes.
1336
1337 */
1338
1339 private class WarmUp extends State {
1340
1341
1342 @Override
1343
1344 public void enter() {
1345
1346 if (DBG) log("Enter WarmUp:" + getCurrentMessage().what);
1347
1348 }
1349
1350
1351 @Override
1352
1353 public boolean processMessage(Messagemessage) {
1354
1355 log("WarmUp process message:" + message.what);
1356
1357 boolean retValue = HANDLED;
1358
1359 switch(message.what) {
1360
1361 case SERVICE_RECORD_LOADED:
1362
1363 //可以看到，首先会把当时从poweroff过来的一个超时message拿remove了。
1364
1365 removeMessages(PREPARE_BLUETOOTH_TIMEOUT);
1366
1367 //转到hotoff状态，在hotoff状态仍会接收到多个SERVICE_RECORD_LOADED的msg，但是那个状态下该msg将没有任何handled，因此会一直处于hotoff状态
1368
1369 transitionTo(mHotOff);
1370
1371 break;
1372
1373 ……
1374
1375
1376
1377 5.2 mAdapter.enable中mBluetoothState.sendMessage后的状态机处理 1378
1379
1380
1381 由extra的分析可知，此时，Bluetooth的State已经处于HotOff状态了，所以，从这里开始处理State的变换。
1382
1383
1384
1385 /**
1386
1387 * Bluetooth Module has powered, firmwareloaded, event loop started,
1388
1389 * SDP loaded, but the modules staysnon-discoverable and
1390
1391 * non-connectable.
1392
1393 */
1394
1395 private class HotOff extends State {
1396
1397 @Override
1398
1399 public void enter() {
1400
1401 if (DBG) log("Enter HotOff:" + getCurrentMessage().what);
1402
1403 }
1404
1405
1406
1407 @Override
1408
1409 public boolean processMessage(Messagemessage) {
1410
1411 log("HotOff process message:" + message.what);
1412
1413
1414
1415 boolean retValue = HANDLED;
1416
1417 switch(message.what) {
1418
1419 case USER_TURN_ON:
1420
1421 //发出BluetoothAdapter.STATE_TURNING_ON的广播消息
1422
1423 broadcastState(BluetoothAdapter.STATE_TURNING_ON);
1424
1425 if ((Boolean) message.obj){
1426
1427 //就是把Settings.Secure.BLUETOOTH_ON设为1。用于标志Bluetooth enable了
1428
1429 persistSwitchSetting(true);
1430
1431 }
1432
1433 // let it fall toTURN_ON_CONTINUE:
1434
1435 //$FALL-THROUGH$
1436
1437 //注意上面没有break哦
1438
1439 case TURN_ON_CONTINUE:
1440
1441 //这里就是把Bluetooth设为connectable就是Powered=1，这里就把prepareBluetooth中设置的不可连接重新设置回来了。这个重连会产生一些新的变化，它会发送WRITE_SCAN_ENABLE的cmd，因此在该cmd_complete时会有一些新的处理：5.3，它会再次引起状态机的改变：5.6
1442
1443 mBluetoothService.switchConnectable(true);
1444
1445 //进入到Switching状态
1446
1447 transitionTo(mSwitching);
1448
1449 break;
1450
1451 ……
1452
1453
1454
1455 5.3 WRITE_SCAN_ENABLE在cmd_complete后的处理 1456
1457
1458
1459 在bluez中是用cmd_complete函数来监视发出cmd完成后的处理的。该函数具体如下：
1460
1461
1462
1463 static inline void cmd_complete(int index, void *ptr)
1464
1465 {
1466
1467 struct dev_info *dev = &devs[index];
1468
1469 evt_cmd_complete*evt = ptr;
1470
1471 uint16_topcode = btohs(evt->opcode);
1472
1473 uint8_tstatus = *((uint8_t *) ptr + EVT_CMD_COMPLETE_SIZE);
1474
1475
1476
1477 switch(opcode) {
1478
1479 ……
1480
1481 //WRITE_SCAN_ENABLE命令完成的处理函数，会再发一个READ_SCAN_ENABLE的命令
1482
1483 case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE):
1484
1485 hci_send_cmd(dev->sk,OGF_HOST_CTL, OCF_READ_SCAN_ENABLE,
1486
1487 0,NULL);
1488
1489 break;
1490
1491 //5.4紧接着就是对READ_SCAN_ENABLE命令完成的处理，它是通过read_scan_complete来实现的
1492
1493 case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SCAN_ENABLE):
1494
1495 ptr+= sizeof(evt_cmd_complete);
1496
1497 read_scan_complete(index,status, ptr);
1498
1499 break;
1500
1501 ……
1502
1503 }
1504
1505
1506
1507 5.4 read_scan命令完成的处理 1508
1509
1510
1511 static void read_scan_complete(int index, uint8_t status, void *ptr)
1512
1513 {
1514
1515 struct btd_adapter *adapter;
1516
1517 read_scan_enable_rp*rp = ptr;
1518
1519
1520
1521 DBG("hci%dstatus %u", index, status);
1522
1523 //由index得到对应的adapter
1524
1525 adapter= manager_find_adapter_by_id(index);
1526
1527 if(!adapter) {
1528
1529 error("Unableto find matching adapter");
1530
1531 return;
1532
1533 }
1534
1535 //5.5这里算是一个通知adapter，mode改变了。
1536
1537 adapter_mode_changed(adapter,rp->enable);
1538
1539 }
1540
1541
1542
1543 5.5 通知adapter，mode发生了改变 1544
1545
1546 void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
1547
1548 {
1549
1550 const gchar *path = adapter_get_path(adapter);
1551
1552 gbooleandiscoverable, pairable;
1553
1554
1555 DBG("old0x%02x new 0x%02x", adapter->scan_mode, scan_mode);
1556
1557 //若相同，则nothing todo
1558
1559 if(adapter->scan_mode == scan_mode){
1560
1561 #ifdefBOARD_HAVE_BLUETOOTH_BCM
1562
1563 /*we may reset scan_mode already inbtd_adapter_stop(), so comes to here*/
1564
1565 set_mode_complete(adapter);
1566
1567 #endif
1568
1569 return;
1570
1571 }
1572
1573 //把discoverable的timeout清空
1574
1575 adapter_remove_discov_timeout(adapter);
1576
1577 //这里开始，是设为SCAN_PAGE| SCAN_INQUIRY
1578
1579 switch(scan_mode) {
1580
1581 caseSCAN_DISABLED:
1582
1583 adapter->mode= MODE_OFF;
1584
1585 discoverable= FALSE;
1586
1587 pairable= FALSE;
1588
1589 break;
1590
1591 caseSCAN_PAGE:
1592
1593 adapter->mode= MODE_CONNECTABLE;
1594
1595 discoverable= FALSE;
1596
1597 pairable= adapter->pairable;
1598
1599 break;
1600
1601 case(SCAN_PAGE | SCAN_INQUIRY):
1602
1603 //设一下模式，在有reply要求的情况下，该步骤还是很重要的
1604
1605 adapter->mode= MODE_DISCOVERABLE;
1606
1607 discoverable= TRUE;
1608
1609 pairable= adapter->pairable;
1610
1611 //还要设一个discoverable的时间
1612
1613 if(adapter->discov_timeout != 0)
1614
1615 adapter_set_discov_timeout(adapter,
1616
1617 adapter->discov_timeout);
1618
1619 break;
1620
1621 caseSCAN_INQUIRY:
1622
1623 /*Address the scenario where a low-level application like
1624
1625 * hciconfig changed the scan mode */
1626
1627 if(adapter->discov_timeout != 0)
1628
1629 adapter_set_discov_timeout(adapter,
1630
1631 adapter->discov_timeout);
1632
1633
1634
1635 /*ignore, this event should not be sent */
1636
1637 default:
1638
1639 /*ignore, reserved */
1640
1641 return;
1642
1643 }
1644
1645
1646
1647 /*If page scanning gets toggled emit the Pairable property */
1648
1649 //这里会发一个property_changed的pairable的signal
1650
1651 if((adapter->scan_mode & SCAN_PAGE) != (scan_mode & SCAN_PAGE))
1652
1653 emit_property_changed(connection,adapter->path,
1654
1655 ADAPTER_INTERFACE,"Pairable",
1656
1657 DBUS_TYPE_BOOLEAN,&pairable);
1658
1659
1660
1661 if(!discoverable)
1662
1663 adapter_set_limited_discoverable(adapter,FALSE);
1664
1665 //这里会发一个property_changed的discoverable的signal
1666
1667 emit_property_changed(connection,path,
1668
1669 ADAPTER_INTERFACE,"Discoverable",
1670
1671 DBUS_TYPE_BOOLEAN,&discoverable);
1672
1673 adapter->scan_mode= scan_mode;
1674
1675
1676
1677 set_mode_complete(adapter);
1678
1679 }
至此，蓝牙的使能主要过程已经全部搞定。