(转)android4.0蓝牙使能的详细解析

内容简介：本文详细分析了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));

于是，我们得以进入真正的蓝牙操作的殿堂，好好进去看看吧。

1、BluetoothEnabler的构造函数
  
   
  
      public BluetoothEnabler(Context context,Switch switch_) {
  
          mContext = context;
  
          mSwitch = switch_;
  
  //很简单了，去调用一个LocalBluetoothManager类的getInstance，其实会构造该类的
  
          LocalBluetoothManager manager =LocalBluetoothManager.getInstance(context);
  
          if (manager == null) {
  
              // Bluetooth is not supported
  
              mLocalAdapter = null;
  
              mSwitch.setEnabled(false);
  
          } else {
  
  //构造成功后，通过manager得到bluetooth的adapter
  
              mLocalAdapter =manager.getBluetoothAdapter();
  
          }
  
  //同时新建一个intent，用于接收ACTION_STATE_CHANGED
  
          mIntentFilter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
  
      }
  
   
  
2、LocalBluetoothManager类的getInstance
  
      public static synchronized LocalBluetoothManager getInstance(Context context) {
  
          if (sInstance == null) {
  
  //2.1同样的，这个会去调用LocalBluetoothAdapter的getInstance，也会构造该类
  
              LocalBluetoothAdapter adapter =LocalBluetoothAdapter.getInstance();
  
              if (adapter == null) {
  
                  return null;
  
              }
  
              // This will be around as long asthis process is
  
              Context appContext =context.getApplicationContext();
  
  //2.2构造LocalBluetoothManager类
  
              sInstance = new LocalBluetoothManager(adapter, appContext);
  
          }
  
   
  
          return sInstance;
  
      }
  
2.1 LocalBluetoothAdapter的getInstance
  
   
  
      static synchronized LocalBluetoothAdapter getInstance() {
  
          if (sInstance == null) {
  
  //2.1.1通过BluetoothAdapter得到DefaultAdapter
  
              BluetoothAdapter adapter =BluetoothAdapter.getDefaultAdapter();
  
              if (adapter != null) {
  
  //2.1.2若有该DefaultAdapter，则构造LocalBluetoothAdapter
  
                  sInstance = new LocalBluetoothAdapter(adapter);
  
              }
  
          }
  
   
  
          return sInstance;
  
      }
  
   
  
2.1.1BluetoothAdapter得到DefaultAdapter
  
   
  
      public static synchronized BluetoothAdapter getDefaultAdapter() {
  
          if (sAdapter == null) {
  
              IBinder b =ServiceManager.getService(BluetoothAdapter.BLUETOOTH_SERVICE);
  
              if (b != null) {
  
                  IBluetooth service =IBluetooth.Stub.asInterface(b);
  
                  sAdapter = new BluetoothAdapter(service);
  
              }
  
          }
  
          return sAdapter;
  
      }
  
   
  
2.1.2构造LocalBluetoothAdapter
  
  //其实就是 mAdapter的初始化而已
  
      private LocalBluetoothAdapter(BluetoothAdapter adapter) {
  
          mAdapter = adapter;
  
      }
  
2.2构造LocalBluetoothManager类
  
  //管理本地蓝牙类，用来在蓝牙API子类上面再封装一个接口
  
      private LocalBluetoothManager(LocalBluetoothAdapter adapter, Context context) {
  
          mContext = context;
  
  //mLocalAdapter初始化为DefaultAdapter中得到的值
  
  mLocalAdapter= adapter;
  
  //构造CachedBluetoothDeviceManager，用来管理远程蓝牙设备
  
          mCachedDeviceManager = new CachedBluetoothDeviceManager(context);
  
  //2.2.1构建BluetoothEventManager，该类是用来管理广播消息和回调函数的，即分发不同的消息去对UI进行处理
  
          mEventManager = new BluetoothEventManager(mLocalAdapter,
  
                  mCachedDeviceManager, context);
  
  //2.2.2该类提供对不同LocalBluetoothProfile object的访问
  
          mProfileManager = new LocalBluetoothProfileManager(context,
  
                  mLocalAdapter,mCachedDeviceManager, mEventManager);
  
      }
  
   
  
2.2.1构建BluetoothEventManager
  
   
  
      BluetoothEventManager(LocalBluetoothAdapteradapter,
  
              CachedBluetoothDeviceManagerdeviceManager, Context context) {
  
          mLocalAdapter = adapter;
  
          mDeviceManager = deviceManager;
  
  //创建两个IntentFilter
  
          mAdapterIntentFilter = new IntentFilter();
  
  //这里没有对mProfileIntentFilter进行初始化，这个在LocalBluetoothProfileManager的addProfile中实现
  
          mProfileIntentFilter = new IntentFilter();
  
  //创建一个Handler的Hash表
  
          mHandlerMap = new HashMap<String,Handler>();
  
          mContext = context;
  
   
  
  //注册对adapter和Device的几个广播消息的处理回调函数
  
  //add action到mAdapterIntentFilter
  
          // Bluetooth on/off broadcasts
  
         addHandler(BluetoothAdapter.ACTION_STATE_CHANGED, newAdapterStateChangedHandler());
  
   
  
          // Discovery broadcasts
  
         addHandler(BluetoothAdapter.ACTION_DISCOVERY_STARTED, newScanningStateChangedHandler(true));
  
         addHandler(BluetoothAdapter.ACTION_DISCOVERY_FINISHED, newScanningStateChangedHandler(false));
  
         addHandler(BluetoothDevice.ACTION_FOUND, new DeviceFoundHandler());
  
         addHandler(BluetoothDevice.ACTION_DISAPPEARED, newDeviceDisappearedHandler());
  
         addHandler(BluetoothDevice.ACTION_NAME_CHANGED, newNameChangedHandler());
  
   
  
          // Pairing broadcasts
  
         addHandler(BluetoothDevice.ACTION_BOND_STATE_CHANGED, newBondStateChangedHandler());
  
         addHandler(BluetoothDevice.ACTION_PAIRING_CANCEL, newPairingCancelHandler());
  
   
  
          // Fine-grained state broadcasts
  
         addHandler(BluetoothDevice.ACTION_CLASS_CHANGED, newClassChangedHandler());
  
         addHandler(BluetoothDevice.ACTION_UUID,new UuidChangedHandler());
  
   
  
          // Dock event broadcasts
  
         addHandler(Intent.ACTION_DOCK_EVENT,new DockEventHandler());
  
         //mAdapterIntentFilter的接收处理函数
  
         mContext.registerReceiver(mBroadcastReceiver, mAdapterIntentFilter);
  
      }
  
   
  
2.2.2构造LocalBluetoothProfileManager类
  
   
  
      LocalBluetoothProfileManager(Contextcontext,
  
              LocalBluetoothAdapter adapter,
  
              CachedBluetoothDeviceManagerdeviceManager,
  
              BluetoothEventManager eventManager){
  
          mContext = context;
  
   
  
          //各个类之间进行关联
  
          mLocalAdapter = adapter;
  
          mDeviceManager = deviceManager;
  
          mEventManager = eventManager;
  
          // pass this reference to adapter andevent manager (circular dependency)
  
          mLocalAdapter.setProfileManager(this);
  
          mEventManager.setProfileManager(this);
  
   
  
          ParcelUuid[] uuids =adapter.getUuids();
  
   
  
          // uuids may be null if Bluetooth isturned off
  
          if (uuids != null) {
  
  //假如已经有了uuid，根据uuid来add并new对应的profile，只针对A2DP,HFP,HSP,OPP四个profile，HID和PAN在下面，每次都add
  
              updateLocalProfiles(uuids);
  
          }
  
   
  
          // Always add HID and PAN profiles
  
  //加入HID和PAN两个profile
  
          mHidProfile = new HidProfile(context,mLocalAdapter);
  
          addProfile(mHidProfile,HidProfile.NAME,
  
                 BluetoothInputDevice.ACTION_CONNECTION_STATE_CHANGED);
  
   
  
          mPanProfile = new PanProfile(context);
  
          addPanProfile(mPanProfile,PanProfile.NAME,
  
                 BluetoothPan.ACTION_CONNECTION_STATE_CHANGED);
  
   
  
          Log.d(TAG,"LocalBluetoothProfileManager construction complete");
  
      }
  
   
  
好吧，其实我们被骗了，刚刚只是一个路引，不是真正的操作，真正的操作向来都是从你滑动界面那个on/off键开始的，因此我们决定把这个键的处理给揪出来。在Settings界面上一共就只有两个on/off键，一个是wifi，另一个就是蓝牙了，我们从这个代码入手：
  
                  case HEADER_TYPE_SWITCH:
  
  //其实写这个代码的人也比较心虚，假如switch多一点，下面就要重写了
  
                      // Would need a differenttreatment if the main menu had more switches
  
                      if (header.id ==R.id.wifi_settings) {
  
                         mWifiEnabler.setSwitch(holder.switch_);
  
                      } else {
  
  //这个就是处理了，上面的路引没有白做啊
  
                         mBluetoothEnabler.setSwitch(holder.switch_);
  
                      }
  
   
  
3、mBluetoothEnabler.setSwitch分析
  
   
  
      public void setSwitch(Switch switch_) {
  
  //若是和上次相同，则不做任何事情，可以理解，代码也懒嘛
  
          if (mSwitch == switch_) return;
  
  //把上次的switch的changelistener清空
  
         mSwitch.setOnCheckedChangeListener(null);
  
          mSwitch = switch_;
  
  //重设这次的switch的changelistener
  
         mSwitch.setOnCheckedChangeListener(this);
  
   
  
          int bluetoothState =BluetoothAdapter.STATE_OFF;
  
  //获取getBluetoothState，这个过程也会同步一下state，防止改变
  
          if (mLocalAdapter != null)bluetoothState = mLocalAdapter.getBluetoothState();
  
  //根据状态设置一下两个标志位
  
          boolean isOn = bluetoothState == BluetoothAdapter.STATE_ON;
  
          boolean isOff = bluetoothState == BluetoothAdapter.STATE_OFF;
  
  //设置checked的状态位。注意，假如这里状态发生了改变，则会调用this.onCheckedChanged来进行处理
  
          mSwitch.setChecked(isOn);
  
          if(WirelessSettings.isRadioAllowed(mContext, Settings.System.RADIO_BLUETOOTH)) {
  
  //有bluetooth或者不是airplane，则该switch不变灰，否则，灰的。
  
              mSwitch.setEnabled(isOn || isOff);
  
          } else {
  
              mSwitch.setEnabled(false);
  
          }
  
      }
  
   
  
4、onCheckedChanged
  
  在switch状态发生改变后，会调用这个地方的回调函数进行处理。
  
   
  
      public void onCheckedChanged(CompoundButtonbuttonView, boolean isChecked) {
  
          // Show toast message if Bluetooth isnot allowed in airplane mode
  
  //若是打开的话，就需要检查一下是否allow Bluetooth（radio，airplane的check）
  
          if (isChecked &&
  
                 !WirelessSettings.isRadioAllowed(mContext,Settings.System.RADIO_BLUETOOTH)) {
  
              Toast.makeText(mContext,R.string.wifi_in_airplane_mode, Toast.LENGTH_SHORT).show();
  
              // Reset switch to off
  
  //若是不对的话，reset为off
  
              buttonView.setChecked(false);
  
          }
  
   
  
          if (mLocalAdapter != null) {
  
  //4.1设置scanmode，放心，它会判断state的，不是STATE_ON，会直接返回false的
  
             mLocalAdapter.setScanMode(BluetoothAdapter.SCAN_MODE_CONNECTABLE);
  
  //4.2使能或不使能Bluetooth了
  
             mLocalAdapter.setBluetoothEnabled(isChecked);
  
          }
  
  //过程中还是会反灰，直到setBluetoothEnabled的结果返回会改变switch的状态
  
          mSwitch.setEnabled(false);
  
      }
  
   
  
4.1设置scanmod
  
   
  
  会调用adapter中的setScanMode，直接去看就可以了，事实上就是设置了两个property标志，没什么
  
   
  
      public boolean setScanMode(int mode) {
  
  //这里把这个代码写出来就是证明一下，STATE_ON才会真正做下去，否则免谈
  
          if (getState() != STATE_ON) returnfalse;
  
  //这里会调用对应server中的setScanMode
  
          return setScanMode(mode, 120);
  
      }
  
   
  
      public synchronized boolean setScanMode(intmode, int duration) {
  
  //这里有个permission，好像和2.3中不一样，注意一下     mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS,
  
  "NeedWRITE_SECURE_SETTINGS permission");
  
          boolean pairable;
  
          boolean discoverable;
  
   
  
          switch (mode) {
  
          case BluetoothAdapter.SCAN_MODE_NONE:
  
              pairable = false;
  
              discoverable = false;
  
              break;
  
          caseBluetoothAdapter.SCAN_MODE_CONNECTABLE:
  
  //开始就是这里了，可pairable，但是不可discoverable
  
              pairable = true;
  
              discoverable = false;
  
              break;
  
          caseBluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE:
  
              pairable = true;
  
              discoverable = true;
  
              if (DBG) Log.d(TAG, "BTDiscoverable for " + duration + " seconds");
  
              break;
  
          default:
  
              Log.w(TAG, "Requested invalidscan mode " + mode);
  
              return false;
  
          }
  
   
  
  //设置这两个property标志
  
         setPropertyBoolean("Discoverable", discoverable);
  
         setPropertyBoolean("Pairable", pairable);
  
          return true;
  
      }
  
   
  
4.2setBluetoothEnabled分析
  
   
  
      public void setBluetoothEnabled(booleanenabled) {
  
  //根据enabled的标志设置是enable还是disable，在2.3中，这个地方就是bt_enable哦，这里还不知道，我们在第5步进行详细的分析
  
          boolean success = enabled
  
                  ? mAdapter.enable()
  
                  : mAdapter.disable();
  
  //成功了，设置对应的状态位
  
          if (success) {
  
              setBluetoothStateInt(enabled
  
                  ?BluetoothAdapter.STATE_TURNING_ON
  
                  :BluetoothAdapter.STATE_TURNING_OFF);
  
          } else {
  
              if (Utils.V) {
  
                  Log.v(TAG,"setBluetoothEnabled call, manager didn't return " +
  
                          "success forenabled: " + enabled);
  
              }
  
  //同步一下设置的状态
  
              syncBluetoothState();
  
          }
  
      }
  
  }
  
   
  
5、mAdapter.enable或者mAdapter.disable
  
   
  
  就先分析enable吧，它会调用对应server端的enable(ture),我们来看看源码
  
   
  
      public synchronized boolean enable(booleansaveSetting) {
  
         mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM,
  
                                                 "Need BLUETOOTH_ADMIN permission");
  
   
  
          // Airplane mode can prevent Bluetoothradio from being turned on.
  
  //检查是否是飞行模式
  
          if (mIsAirplaneSensitive &&isAirplaneModeOn() && !mIsAirplaneToggleable) {
  
              return false;
  
          }
  
  //5.1注意与2.3的不同，在2.3中，这里会调用enablethread去调用native的bt_enable，而4.0没有这么做。没事，我们来分析4.0怎么做的。
  
         mBluetoothState.sendMessage(BluetoothAdapterStateMachine.USER_TURN_ON,saveSetting);
  
          return true;
  
      }
  
   
  
5.1mBluetoothState.sendMessage
  
   
  
简单理解一下，mBluetoothState是BluetoothAdapterStateMachine类。因此，在分析的之前，简单说一下，它其实就是类似一个状态转换图，根据你所处于的状态，然后再判断收到的操作，进行不同的处理。根据构造函数中的setInitialState(mPowerOff);可以知道初始状态是PowerOff。但是从它给出的状态机可以看出，在PowerOff的状态时，它是通过TURN_HOT/TURN_ON来改变到HotOff状态的，然后才会收到USER_TURN_ON，去该变到BluetootOn的状态。因此，可以肯定的是我们这里的USER_TURN_ON不是它收到的第一个message，因此我们去纠结一下它是从哪里开始改变PowerOff的状态：extra1，然后再来看这里的处理吧：5.2。
  
   
  
  extra1、mAdapter.enable之前的状态机转变
  
   
  
  众所周知，android在启动之后会启动一个serverThread的线程，通过这个线程会启动一系列的服务。我们的蓝牙服务也是在这里启动的，android4.0其实在这个地方对状态机进行了修改，我们来看一下源码：
  
  该代码位于framworks/base/services/java/com/android/server/systemserver.java
  
  BluetoothServicebluetooth = null;
  
  BluetoothA2dpServicebluetoothA2dp = null;
  
   
  
  //模拟器上是不支持Bluetooth的，工厂测试模式也没有Bluetooth（这个不了解）
  
              // Skip Bluetooth if we have anemulator kernel
  
              // TODO: Use a more reliable checkto see if this product should
  
              // support Bluetooth - see bug988521
  
              if(SystemProperties.get("ro.kernel.qemu").equals("1")) {
  
                  Slog.i(TAG, "No BluetoohService (emulator)");
  
              } else if (factoryTest ==SystemServer.FACTORY_TEST_LOW_LEVEL) {
  
                  Slog.i(TAG, "No BluetoothService (factory test)");
  
              } else {
  
                  Slog.i(TAG, "BluetoothService");
  
  //新建Bluetoothservice，并把他加入到ServiceManager中
  
                  bluetooth = newBluetoothService(context);
  
                 ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE,bluetooth);
  
  //extra1.1在启动Bluetooth服务后进行一些初始化，呵呵，这里就对状态机进行了改变
  
                 bluetooth.initAfterRegistration();
  
   
  
  //新建了BluetoothA2dpService，并把之加入到了ServiceManager中
  
  bluetoothA2dp= new BluetoothA2dpService(context, bluetooth);
  
                 ServiceManager.addService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE,
  
                                           bluetoothA2dp);
  
  //extra1.2同样的要在之后做些init的工作
  
                 bluetooth.initAfterA2dpRegistration();
  
  //得到是否飞行
  
                  int airplaneModeOn =Settings.System.getInt(mContentResolver,
  
                         Settings.System.AIRPLANE_MODE_ON, 0);
  
  //看Bluetooth是否on，若是打开的状态（没有飞行），则这里会调用enable去打开
  
                  int bluetoothOn =Settings.Secure.getInt(mContentResolver,
  
                     Settings.Secure.BLUETOOTH_ON, 0);
  
                  if (airplaneModeOn == 0&& bluetoothOn != 0) {
  
                      bluetooth.enable();
  
                  }
  
              }
  
   
  
  extra1.1 initAfterRegistration分析
  
   
  
      public synchronized voidinitAfterRegistration() {
  
  //得到default的adapter
  
          mAdapter =BluetoothAdapter.getDefaultAdapter();
  
  //创建BluetoothAdapterStateMachine，初始化几个状态，并设初始状态位POWEROFF,这里同时新建了一个EventLoop
  
          mBluetoothState = newBluetoothAdapterStateMachine(mContext, this, mAdapter);
  
          mBluetoothState.start();
  
  //根据这个xml的bool变量来决定是否先期TURN_HOT，该变量位于frameworks/base/core/res/res/values/config.xml中，默认为true
  
          if (mContext.getResources().getBoolean
  
             (com.android.internal.R.bool.config_bluetooth_adapter_quick_switch)) {
  
  //extra1.2发送TURN_HOT的状态变化message
  
             mBluetoothState.sendMessage(BluetoothAdapterStateMachine.TURN_HOT);
  
          }
  
  //得到对应的EventLoop
  
          mEventLoop =mBluetoothState.getBluetoothEventLoop();
  
      }
  
   
  
  extra1.2  TURN_HOT message的处理
  
   
  
      /**
  
       * Bluetooth module's power is off,firmware is not loaded.
  
       */
  
      private class PowerOff extends State {
  
          @Override
  
          public void enter() {
  
              if (DBG) log("Enter PowerOff:" + getCurrentMessage().what);
  
          }
  
          @Override
  
          public boolean processMessage(Messagemessage) {
  
              log("PowerOff process message:" + message.what);
  
   
  
              boolean retValue = HANDLED;
  
              switch(message.what) {
  
  ……
  
                 case TURN_HOT:
  
  //extra1.3这里就是我们寻找了千年的bt_enable所在的地方。我们去看看
  
                      if (prepareBluetooth()) {
  
  //extra1.5转变状态到warmup，在prepareBluetooth真正完成后，这个状态还会发生改变
  
                          transitionTo(mWarmUp);
  
                      }
  
                      break;
  
  ……
  
   
  
  extra1.3prepareBluetooth分析
  
   
  
  看英文注释就知道了，不解释
  
          /**
  
           * Turn on Bluetooth Module, Loadfirmware, and do all the preparation
  
           * needed to get the Bluetooth Moduleready but keep it not discoverable
  
           * and not connectable.
  
           * The last step of this method sets upthe local service record DB.
  
           * There will be a event reporting thestatus of the SDP setup.
  
           */
  
          private boolean prepareBluetooth() {
  
  //extra1.4首先还是调用了enableNative的本地方法，到这里你会发现终于和2.3相似了（不过请注意调用的时机不同了，这个在初始化，而2.3在界面的on/off滑动的时候），它还是会调用bt_enable，这个就会调用对应的set_bluetooth_power了
  
              if(mBluetoothService.enableNative() != 0) {
  
                  return false;
  
              }
  
   
  
              // try to start event loop, give 2attempts
  
  //尝试两次去start event loop
  
              int retryCount = 2;
  
              boolean eventLoopStarted = false;
  
              while ((retryCount-- > 0)&& !eventLoopStarted) {
  
                  mEventLoop.start();
  
                  // it may take a moment for theother thread to do its
  
                  // thing.  Check periodically for a while.
  
                  int pollCount = 5;
  
                  while ((pollCount-- > 0)&& !eventLoopStarted) {
  
                      if(mEventLoop.isEventLoopRunning()) {
  
                          eventLoopStarted =true;
  
                          break;
  
                      }
  
                      try {
  
                          Thread.sleep(100);
  
                      } catch(InterruptedException e) {
  
                         log("prepareBluetooth sleep interrupted: " + pollCount);
  
                          break;
  
                      }
  
                  }
  
              }
  
  //出错处理
  
              if (!eventLoopStarted) {
  
                 mBluetoothService.disableNative();
  
                  return false;
  
              }
  
   
  
              // get BluetoothService ready
  
  //建立native data以及SDP相关的一些操作，这里将会产生PropertyChanged的UUIDs的signal，对该信号的处理会对状态发生改变，详细分析见extra1.5
  
              if(!mBluetoothService.prepareBluetooth()) {
  
                  mEventLoop.stop();
  
                 mBluetoothService.disableNative();
  
                  return false;
  
              }
  
  //设置一个prepare的超时处理，在该时间内没有收到UUID changed的signal将会进行错误处理
  
             sendMessageDelayed(PREPARE_BLUETOOTH_TIMEOUT,PREPARE_BLUETOOTH_TIMEOUT_TIME);
  
              return true;
  
          }
  
      }
  
   
  
  extra1.4  bt_enable分析
  
   
  
  intbt_enable() {
  
      LOGV(__FUNCTION__);
  
   
  
      int ret = -1;
  
      int hci_sock = -1;
  
      int attempt;
  
   
  
  //power的设置，on。不解释，可加入对应板子的gpio口的处理，默认就只用了rfkill的处理
  
      if (set_bluetooth_power(1) < 0) gotoout;
  
  //开始hciattach服务，这个我们也做了修改，加入了rtk_h5
  
      LOGI("Starting hciattachdaemon");
  
      if (property_set("ctl.start","hciattach") < 0) {
  
          LOGE("Failed to starthciattach");
  
          set_bluetooth_power(0);
  
          goto out;
  
      }
  
   
  
   
  
      // Try for 10 seconds, this can onlysucceed once hciattach has sent the
  
      // firmware and then turned on hci devicevia HCIUARTSETPROTO ioctl
  
      for (attempt = 1000; attempt > 0;  attempt--) {
  
  //创建hci_sock
  
          hci_sock = create_hci_sock();
  
          if (hci_sock < 0) goto out;
  
  //调用ioctl的HCIDEVUP，来判断hciattach是否已经ok了。
  
          ret = ioctl(hci_sock, HCIDEVUP,HCI_DEV_ID);
  
   
  
          LOGI("bt_enable: ret: %d, errno:%d", ret, errno);
  
          if (!ret) {
  
              break;
  
          } else if (errno == EALREADY) {
  
              LOGW("Bluetoothd alreadystarted, unexpectedly!");
  
              break;
  
          }
  
   
  
          close(hci_sock);
  
  //等待10 ms后再试一次
  
          usleep(100000);  // 100 ms retry delay
  
      }
  
  //10s都没有搞定，需要做个失败的处理
  
      if (attempt == 0) {
  
          LOGE("%s: Timeout waiting for HCIdevice to come up, error- %d, ",
  
              __FUNCTION__, ret);
  
          if (property_set("ctl.stop","hciattach") < 0) {
  
              LOGE("Error stoppinghciattach");
  
          }
  
          set_bluetooth_power(0);
  
          goto out;
  
      }
  
  //启动bluetoothd服务
  
      LOGI("Starting bluetoothddeamon");
  
      if (property_set("ctl.start","bluetoothd") < 0) {
  
          LOGE("Failed to startbluetoothd");
  
          set_bluetooth_power(0);
  
          goto out;
  
      }
  
   
  
      ret = 0;
  
   
  
  out:
  
  //关闭hci_sock
  
      if (hci_sock >= 0) close(hci_sock);
  
      return ret;
  
  }
  
   
  
  extra 1.5  PropetyChanged的UUIDs的处理
  
   
  
  event_filter是用来对bluez的dbus的signal进行监听的，有signal产生后，会在这里进行处理。因此，我们直接到这里看看该怎么处理。
  
   
  
  //Called by dbus during WaitForAndDispatchEventNative()
  
  staticDBusHandlerResult event_filter(DBusConnection *conn, DBusMessage *msg,
  
                                        void*data) {
  
      native_data_t *nat;
  
      JNIEnv *env;
  
      DBusError err;
  
      DBusHandlerResult ret;
  
   
  
  //err的一个初始化
  
      dbus_error_init(&err);
  
  //得到参数
  
      nat = (native_data_t *)data;
  
      nat->vm->GetEnv((void**)&env,nat->envVer);
  
      if (dbus_message_get_type(msg) !=DBUS_MESSAGE_TYPE_SIGNAL) {
  
          LOGV("%s: not interested (not asignal).", __FUNCTION__);
  
          returnDBUS_HANDLER_RESULT_NOT_YET_HANDLED;
  
      }
  
   
  
      LOGV("%s: Received signal %s:%s from%s", __FUNCTION__,
  
          dbus_message_get_interface(msg),dbus_message_get_member(msg),
  
          dbus_message_get_path(msg));
  
   
  
      env->PushLocalFrame(EVENT_LOOP_REFS);
  
  ……
  
  //PropertyChanged这个signal的处理
  
      } else if (dbus_message_is_signal(msg,
  
                                       "org.bluez.Adapter",
  
                                       "PropertyChanged")) {
  
  //由msg解析参数
  
          jobjectArray str_array =parse_adapter_property_change(env, msg);
  
          if (str_array != NULL) {
  
              /* Check if bluetoothd has(re)started, if so update the path. */
  
              jstring property =(jstring)env->GetObjectArrayElement(str_array, 0);
  
              const char *c_property =env->GetStringUTFChars(property, NULL);
  
  //检查Property是否started
  
              if (!strncmp(c_property,"Powered", strlen("Powered"))) {
  
  //若是powered，则看value是否是true，是ture就得到对应的path
  
                  jstring value =
  
                      (jstring)env->GetObjectArrayElement(str_array, 1);
  
                  const char *c_value =env->GetStringUTFChars(value, NULL);
  
                  if (!strncmp(c_value,"true", strlen("true")))
  
                      nat->adapter =get_adapter_path(nat->conn);
  
                 env->ReleaseStringUTFChars(value, c_value);
  
              }
  
             env->ReleaseStringUTFChars(property, c_property);
  
  //extra1.6调用对应的method_onPropertyChanged函数，该method对应的onPropertyChanged函数
  
              env->CallVoidMethod(nat->me,
  
                               method_onPropertyChanged,
  
                                str_array);
  
          } elseLOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg);
  
          goto success;
  
  ……
  
   
  
  extra1.6  真正的处理函数onPropertyChanged分析
  
   
  
   /**
  
       * Called by native code on aPropertyChanged signal from
  
       * org.bluez.Adapter. This method is alsocalled from
  
       * {@link BluetoothAdapterStateMachine} toset the "Pairable"
  
       * property when Bluetooth is enabled.
  
       *
  
       * @param propValues a string arraycontaining the key and one or more
  
       * values.
  
       */
  
      /*package*/ void onPropertyChanged(String[]propValues) {
  
          BluetoothAdapterPropertiesadapterProperties =
  
                 mBluetoothService.getAdapterProperties();
  
  //先fill up cache
  
          if (adapterProperties.isEmpty()) {
  
              // We have got a property changebefore
  
              // we filled up our cache.
  
             adapterProperties.getAllProperties();
  
          }
  
          log("Property Changed: " +propValues[0] + " : " + propValues[1]);
  
          String name = propValues[0];
  
  ……
  
  //对UUIDs的处理
  
          } else if(name.equals("Devices") || name.equals("UUIDs")) {
  
              String value = null;
  
              int len =Integer.valueOf(propValues[1]);
  
              if (len > 0) {
  
                  StringBuilder str = newStringBuilder();
  
                  for (int i = 2; i <propValues.length; i++) {
  
                      str.append(propValues[i]);
  
                      str.append(",");
  
                  }
  
                  value = str.toString();
  
              }
  
  //把name和value值加入到property的map中
  
              adapterProperties.setProperty(name,value);
  
  //extra1.7有UUIDs的change signal会刷新Bluetooth的State
  
              if (name.equals("UUIDs")){
  
                 mBluetoothService.updateBluetoothState(value);
  
              }
  
  //对Pairable和Discoverable的处理
  
         } else if(name.equals("Pairable") || name.equals("Discoverable")) {
  
              adapterProperties.setProperty(name,propValues[1]);
  
   
  
              if(name.equals("Discoverable")) {
  
     //5.6发送SCAN_MODE_CHANGED的msg，去改变状态机      mBluetoothState.sendMessage(BluetoothAdapterStateMachine.SCAN_MODE_CHANGED);
  
              }
  
  //设置对应的property
  
              String pairable =name.equals("Pairable") ? propValues[1] :
  
                 adapterProperties.getProperty("Pairable");
  
              String discoverable =name.equals("Discoverable") ? propValues[1] :
  
                 adapterProperties.getProperty("Discoverable");
  
   
  
              // This shouldn't happen, unlessAdapter Properties are null.
  
              if (pairable == null ||discoverable == null)
  
                  return;
  
   
  
              int mode =BluetoothService.bluezStringToScanMode(
  
                     pairable.equals("true"),
  
                     discoverable.equals("true"));
  
              if (mode >= 0) {
  
  //当pairable和discoverable均为true的时候，会发送一个ACTION_SCAN_MODE_CHANGED的广播消息
  
                  Intent intent = newIntent(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
  
                 intent.putExtra(BluetoothAdapter.EXTRA_SCAN_MODE, mode);
  
                 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
  
                  mContext.sendBroadcast(intent,BLUETOOTH_PERM);
  
              }
  
          }
  
   
  
  ……
  
   
  
  extra1.7  UUIDs改变带来的State的刷新
  
  
      /**
  
       * This function is called from BluetoothEvent Loop when onPropertyChanged
  
       * for adapter comes in with UUID property.
  
       * @param uuidsThe uuids of adapter asreported by Bluez.
  
       */
  
      /*package*/ synchronized voidupdateBluetoothState(String uuids) {
  
          ParcelUuid[] adapterUuids =convertStringToParcelUuid(uuids);
  
  //为什么必须包含所有已经有的uuid？？感觉有点反了，再看看
  
          if (mAdapterUuids != null &&
  
             BluetoothUuid.containsAllUuids(adapterUuids, mAdapterUuids)) {
  
  //放SERVICE_RECORD_LOADED的信息，此时，处于warm up状态，看extra1.8分析状态如何继续改变          mBluetoothState.sendMessage(BluetoothAdapterStateMachine.SERVICE_RECORD_LOADED);
  
          }
  
      }
  
   
  
  extra1.8 UUIDs对状态机改变
  
  
     /**
  
       * Turning on Bluetooth module's power,loading firmware, starting
  
       * event loop thread to listen on Bluetoothmodule event changes.
  
       */
  
      private class WarmUp extends State {
  
 
          @Override
  
          public void enter() {
  
              if (DBG) log("Enter WarmUp:" + getCurrentMessage().what);
  
          }
  
  
          @Override
  
          public boolean processMessage(Messagemessage) {
  
              log("WarmUp process message:" + message.what);
  
              boolean retValue = HANDLED;
  
              switch(message.what) {
  
                  case SERVICE_RECORD_LOADED:
  
  //可以看到，首先会把当时从poweroff过来的一个超时message拿remove了。
  
                     removeMessages(PREPARE_BLUETOOTH_TIMEOUT);
  
  //转到hotoff状态，在hotoff状态仍会接收到多个SERVICE_RECORD_LOADED的msg，但是那个状态下该msg将没有任何handled，因此会一直处于hotoff状态
  
                      transitionTo(mHotOff);
  
                      break;
  
  ……
  
   
  
  5.2 mAdapter.enable中mBluetoothState.sendMessage后的状态机处理
  
   
  
  由extra的分析可知，此时，Bluetooth的State已经处于HotOff状态了，所以，从这里开始处理State的变换。
  
   
  
      /**
  
       * Bluetooth Module has powered, firmwareloaded, event loop started,
  
       * SDP loaded, but the modules staysnon-discoverable and
  
       * non-connectable.
  
       */
  
      private class HotOff extends State {
  
          @Override
  
          public void enter() {
  
              if (DBG) log("Enter HotOff:" + getCurrentMessage().what);
  
          }
  
   
  
          @Override
  
          public boolean processMessage(Messagemessage) {
  
              log("HotOff process message:" + message.what);
  
   
  
              boolean retValue = HANDLED;
  
              switch(message.what) {
  
                  case USER_TURN_ON:
  
  //发出BluetoothAdapter.STATE_TURNING_ON的广播消息
  
                     broadcastState(BluetoothAdapter.STATE_TURNING_ON);
  
                      if ((Boolean) message.obj){
  
  //就是把Settings.Secure.BLUETOOTH_ON设为1。用于标志Bluetooth enable了
  
                         persistSwitchSetting(true);
  
                      }
  
                      // let it fall toTURN_ON_CONTINUE:
  
                      //$FALL-THROUGH$
  
  //注意上面没有break哦
  
                  case TURN_ON_CONTINUE:
  
  //这里就是把Bluetooth设为connectable就是Powered=1，这里就把prepareBluetooth中设置的不可连接重新设置回来了。这个重连会产生一些新的变化，它会发送WRITE_SCAN_ENABLE的cmd，因此在该cmd_complete时会有一些新的处理：5.3，它会再次引起状态机的改变：5.6
  
                     mBluetoothService.switchConnectable(true);
  
  //进入到Switching状态
  
                      transitionTo(mSwitching);
  
                      break;
  
  ……
  
   
  
  5.3 WRITE_SCAN_ENABLE在cmd_complete后的处理
  
   
  
  在bluez中是用cmd_complete函数来监视发出cmd完成后的处理的。该函数具体如下：
  
   
  
  static inline void cmd_complete(int index, void *ptr)
  
  {
  
  struct dev_info *dev = &devs[index];
  
  evt_cmd_complete*evt = ptr;
  
  uint16_topcode = btohs(evt->opcode);
  
  uint8_tstatus = *((uint8_t *) ptr + EVT_CMD_COMPLETE_SIZE);
  
   
  
  switch(opcode) {
  
  ……
  
  //WRITE_SCAN_ENABLE命令完成的处理函数，会再发一个READ_SCAN_ENABLE的命令
  
  case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_SCAN_ENABLE):
  
  hci_send_cmd(dev->sk,OGF_HOST_CTL, OCF_READ_SCAN_ENABLE,
  
  0,NULL);
  
  break;
  
  //5.4紧接着就是对READ_SCAN_ENABLE命令完成的处理，它是通过read_scan_complete来实现的
  
  case cmd_opcode_pack(OGF_HOST_CTL, OCF_READ_SCAN_ENABLE):
  
  ptr+= sizeof(evt_cmd_complete);
  
  read_scan_complete(index,status, ptr);
  
  break;
  
  ……
  
  }
  
   
  
  5.4 read_scan命令完成的处理
  
   
  
  static void read_scan_complete(int index, uint8_t status, void *ptr)
  
  {
  
  struct btd_adapter *adapter;
  
  read_scan_enable_rp*rp = ptr;
  
   
  
  DBG("hci%dstatus %u", index, status);
  
  //由index得到对应的adapter
  
  adapter= manager_find_adapter_by_id(index);
  
  if(!adapter) {
  
  error("Unableto find matching adapter");
  
  return;
  
  }
  
  //5.5这里算是一个通知adapter，mode改变了。
  
  adapter_mode_changed(adapter,rp->enable);
  
  }
  
   
  
  5.5 通知adapter，mode发生了改变
  
  
  void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
  
  {
  
  const gchar *path = adapter_get_path(adapter);
  
  gbooleandiscoverable, pairable;
  
  
  DBG("old0x%02x new 0x%02x", adapter->scan_mode, scan_mode);
  
  //若相同，则nothing todo
  
  if(adapter->scan_mode == scan_mode){
  
  #ifdefBOARD_HAVE_BLUETOOTH_BCM
  
      /*we may reset scan_mode already inbtd_adapter_stop(), so comes to here*/
  
      set_mode_complete(adapter);
  
  #endif
  
      return;
  
  }
  
  //把discoverable的timeout清空
  
  adapter_remove_discov_timeout(adapter);
  
  //这里开始，是设为SCAN_PAGE| SCAN_INQUIRY
  
  switch(scan_mode) {
  
  caseSCAN_DISABLED:
  
  adapter->mode= MODE_OFF;
  
  discoverable= FALSE;
  
  pairable= FALSE;
  
  break;
  
  caseSCAN_PAGE:
  
  adapter->mode= MODE_CONNECTABLE;
  
  discoverable= FALSE;
  
  pairable= adapter->pairable;
  
  break;
  
  case(SCAN_PAGE | SCAN_INQUIRY):
  
  //设一下模式，在有reply要求的情况下，该步骤还是很重要的
  
  adapter->mode= MODE_DISCOVERABLE;
  
  discoverable= TRUE;
  
  pairable= adapter->pairable;
  
  //还要设一个discoverable的时间
  
  if(adapter->discov_timeout != 0)
  
  adapter_set_discov_timeout(adapter,
  
  adapter->discov_timeout);
  
  break;
  
  caseSCAN_INQUIRY:
  
  /*Address the scenario where a low-level application like
  
   * hciconfig changed the scan mode */
  
  if(adapter->discov_timeout != 0)
  
  adapter_set_discov_timeout(adapter,
  
  adapter->discov_timeout);
  
   
  
  /*ignore, this event should not be sent */
  
  default:
  
  /*ignore, reserved */
  
  return;
  
  }
  
   
  
  /*If page scanning gets toggled emit the Pairable property */
  
  //这里会发一个property_changed的pairable的signal
  
  if((adapter->scan_mode & SCAN_PAGE) != (scan_mode & SCAN_PAGE))
  
  emit_property_changed(connection,adapter->path,
  
  ADAPTER_INTERFACE,"Pairable",
  
  DBUS_TYPE_BOOLEAN,&pairable);
  
   
  
  if(!discoverable)
  
  adapter_set_limited_discoverable(adapter,FALSE);
  
  //这里会发一个property_changed的discoverable的signal
  
  emit_property_changed(connection,path,
  
  ADAPTER_INTERFACE,"Discoverable",
  
  DBUS_TYPE_BOOLEAN,&discoverable);
  
  adapter->scan_mode= scan_mode;
  
   
  
  set_mode_complete(adapter);
  
  }

 

至此，蓝牙的使能主要过程已经全部搞定。

原文地址：http://blog.csdn.net/xdyang1987/article/details/7771388