Android4.42-Setting源码分析之蓝牙模块Bluetooth（下）

boolean readPairedDevices() {
       //mLocalAdapter是将BluetoothAdapter映射到本地，其内部代码不再书写，获取到已配对设备
       Set<BluetoothDevice> bondedDevices = mLocalAdapter.getBondedDevices();
        if (bondedDevices == null) {
            return false;
        }
        boolean deviceAdded = false;
        for (BluetoothDevice device : bondedDevices) {
            //这一步调用的是设备缓存列表的管理类CachedBluetoothDeviceManager中的方法findDevice
            //用于检查缓存列表中是否已经存在该device，若存在就将device返回，若不存在就返回null
            CachedBluetoothDevice cachedDevice = mDeviceManager.findDevice(device);
            if (cachedDevice == null) {
                //如果缓存列表中没有该设备就调用管理类CachedBluetoothDeviceManager中的addDevice
                //将设备添加到缓存列表中
               cachedDevice = mDeviceManager.addDevice(mLocalAdapter, mProfileManager, device);
              //将设备更新到屏幕上
               dispatchDeviceAdded(cachedDevice);
                deviceAdded = true;
            }
        }
        return deviceAdded;
    }

 void setBluetoothStateOn() {
        ParcelUuid[] uuids = mLocalAdapter.getUuids();
        if (uuids != null) {
		
            updateLocalProfiles(uuids);
        }
        mEventManager.readPairedDevices();
    }

private void addDeviceCategory(PreferenceGroup preferenceGroup, int titleId,
            BluetoothDeviceFilter.Filter filter) {
        //设置preferenceGroup的标题
       preferenceGroup.setTitle(titleId);
      //为PreferenceScreen添加preferenceGroup，注意此时preferenceGroup里为空没有任何的preference
      getPreferenceScreen().addPreference(preferenceGroup);
        //设置过滤器，调用的是DeviceListPreferenceFragment中方法
        setFilter(filter);
       //调用DeviceListPreferencFragment中的方法，讲preferenceGroup传过去，方便对其操作
        setDeviceListGroup(preferenceGroup);
        //调用DeviceListPreferenceFragment中的方法
        addCachedDevices();
       //将preference设置为可点击的状态
        preferenceGroup.setEnabled(true);
    }

void addCachedDevices() {
     //用于获取到缓存列表的复制
     Collection<CachedBluetoothDevice> cachedDevices =
                mLocalManager.getCachedDeviceManager().getCachedDevicesCopy();
        for (CachedBluetoothDevice cachedDevice : cachedDevices) {
            //该方法用于将设备显示出来
           onDeviceAdded(cachedDevice);
        }
    }

public void onDeviceAdded(CachedBluetoothDevice cachedDevice) {
        if (mDevicePreferenceMap.get(cachedDevice) != null) {
            return;
        }

        // Prevent updates while the list shows one of the state messages
        if (mLocalAdapter.getBluetoothState() != BluetoothAdapter.STATE_ON) return;
          //这就是过滤器的作用了，首先过滤出要求的设备，要求已配对或者是附近可用设备
          //列表过滤后，就可以加载出来了
        if (mFilter.matches(cachedDevice.getDevice())) {
            createDevicePreference(cachedDevice);
        }
     }

 //注，Filter为BluetoothDeviceFilter的内部接口
private static final class BondedDeviceFilter implements Filter {
        public boolean matches(BluetoothDevice device) {
            return device.getBondState() == BluetoothDevice.BOND_BONDED;
        }
    }

 void createDevicePreference(CachedBluetoothDevice cachedDevice) {
        //构造preference对象
      BluetoothDevicePreference preference = new BluetoothDevicePreference(
                getActivity(), cachedDevice);
         //在该方法对preference进行初始化，可按需实现
        initDevicePreference(preference);
        //将preference显示出来
       mDeviceListGroup.addPreference(preference);
        mDevicePreferenceMap.put(cachedDevice, preference);
    }

void startScanning(boolean force) {
        // Only start if we're not already scanning
        if (!mAdapter.isDiscovering()) {
            if (!force) {
                // Don't scan more than frequently than SCAN_EXPIRATION_MS,
                // unless forced
                if (mLastScan + SCAN_EXPIRATION_MS > System.currentTimeMillis()) {
                    return;
                }

                // If we are playing music, don't scan unless forced.
                A2dpProfile a2dp = mProfileManager.getA2dpProfile();
                if (a2dp != null && a2dp.isA2dpPlaying()) {
                    return;
                }
            }

            if (mAdapter.startDiscovery()) {
                mLastScan = System.currentTimeMillis();
            }
        }
    }

 private class ScanningStateChangedHandler implements Handler {
        private final boolean mStarted;
       //开始扫描时传入的为true
        ScanningStateChangedHandler(boolean started) {
            mStarted = started;
        }
        public void onReceive(Context context, Intent intent,
                BluetoothDevice device) {
            synchronized (mCallbacks) {
                for (BluetoothCallback callback : mCallbacks) {
                         //调用DeviceListPreferenceFragment.java中的方法显示扫描指示progress
                        callback.onScanningStateChanged(mStarted);
                }
            }
            //首先更新缓存列表，然后对显示列表进行排序更新显示。
            //排序规则代码在CachedBluetoothDevice.java中
          mDeviceManager.onScanningStateChanged(mStarted);
           //该方法用于保存开始扫描的时间
             LocalBluetoothPreferences.persistDiscoveringTimestamp(context);
        }
    }

 private class DeviceFoundHandler implements Handler {
        public void onReceive(Context context, Intent intent,
                BluetoothDevice device) {
            //获取到蓝牙的信号强度，默认为Short类型的最小值-2的15次方
            short rssi = intent.getShortExtra(BluetoothDevice.EXTRA_RSSI, Short.MIN_VALUE);
            //获取到远程设备的类型
             BluetoothClass btClass = intent.getParcelableExtra(BluetoothDevice.EXTRA_CLASS);
           //获取到远程设备的name
            String name = intent.getStringExtra(BluetoothDevice.EXTRA_NAME);
            //获取到远程设备后检测是否在缓存列表中，若有就返回设备，若没有返回null
            CachedBluetoothDevice cachedDevice = mDeviceManager.findDevice(device);
            if (cachedDevice == null) {
               //将设备添加到缓存列表中
               cachedDevice = mDeviceManager.addDevice(mLocalAdapter, mProfileManager, device);
                // callback to UI to create Preference for new device
               //将添加的设备更新到显示列表
              dispatchDeviceAdded(cachedDevice);
            }
            //缓存device的信号强度，设备类型，name
            cachedDevice.setRssi(rssi);
            cachedDevice.setBtClass(btClass);
            cachedDevice.setName(name);
            //在这里不是设置可见性，与列表的排序相关
           cachedDevice.setVisible(true);
        }
    }

//该方法返回true代表正在进行配对操作，若返回false则表示配对操作失败弹出失败弹窗
 boolean startPairing() {
          //首先查看一下，远程设备是否正在配对，如果正在配对就返回true，
          if(mLocalAdapter.checkPairingState() == true)
        {
            return true;
        }
          //将本机蓝牙适配器的配对状态设为true
        mLocalAdapter.setPairingState(true);
        // Pairing is unreliable while scanning, so cancel discovery
        //如果本机蓝牙正在进行扫描蓝牙的操作，则停止该操作，因为该操作会阻塞
       if (mLocalAdapter.isDiscovering()) {
            mLocalAdapter.cancelDiscovery();
        }
        //调用framework层的方法，判断远程蓝牙设备是否可以配对以及请求配对是否超时，
       //如果可以配对就把远程蓝牙设备的配对状态设置为正在配对
      if (!mDevice.createBond()) {
           //如果与远程蓝牙设备创建配对失败则将本机蓝牙配对状态设为false
           mLocalAdapter.setPairingState(false);
            return false;
        }
       //配对之后是否进行自动连接，true为自动进行连接
       mConnectAfterPairing = true;  // auto-connect after pairing
        return true;
    }

 void connect(boolean connectAllProfiles) {
        //如果没有配对，就进行配对，并且退出连接的方法
       if (!ensurePaired()) {
            return;
        }
	//获取到系统启动到现在的时间间隔
        mConnectAttempted = SystemClock.elapsedRealtime();
       //从英语中可以看出意思是在连接时不重置定时器
        connectWithoutResettingTimer(connectAllProfiles);
    }

private void connectWithoutResettingTimer(boolean connectAllProfiles) {
        // Try to initialize the profiles if they were not.
        //本机蓝牙与远程设备通信的配置规范，如果没有配置文件则不能进行通信
        //配置规范指定所使用的蓝牙通信协议，用户界面格式等等
        if (mProfiles.isEmpty()) {
            Log.d(TAG, "No profiles. Maybe we will connect later");	
            return;
        }

        // Reset the only-show-one-error-dialog tracking variable
        //当我们去连接多个设备发生错误时我们只想显示一个错误对话框，
       mIsConnectingErrorPossible = true;
	
        int preferredProfiles = 0;
        for (LocalBluetoothProfile profile : mProfiles) {
		
            if (connectAllProfiles ? profile.isConnectable() : profile.isAutoConnectable()) {
				

				if (profile.isPreferred(mDevice)) {
                    ++preferredProfiles;
			//连接设备，具体的可以查看关于profile的内容	
                    connectInt(profile);
					
                }
            }
        }
        if (DEBUG) Log.d(TAG, "Preferred profiles = " + preferredProfiles);

        if (preferredProfiles == 0) {
            connectAutoConnectableProfiles();
        }
    }