【蓝牙代码微信名字】使用HarmonyOS Sample的蓝牙传统蓝牙-拍拖百科

此示例说明如何执行蓝牙基本任务，包括打开和关闭蓝牙、设置和获取本机蓝牙名称、扫描和取消扫描外围蓝牙设备、获取本机蓝牙配置文件中其他设备的连接状态，以及获取本机蓝牙配对的蓝牙设备列表。传统蓝牙远程管理任务：主要是远程蓝牙设备的基本任务，包括获取远程蓝牙设备地址、类型、名称和配对状态，以及开始与远程设备配对。有关传统蓝牙和蓝牙的概念，请参阅蓝牙发展概述。调用蓝牙的开放接口需要O权限，调用蓝牙扫描接口需要O权限和O权限。

2.环境建设

安装DevEco Studio。有关详细信息，请参阅下载DevEco Studio。DevEco Studio开发环境设置，DevEco Studio开发环境取决于网络环境。为了正常使用工具，必须连接到网络。开发环境可以在以下两种情况下配置：

如果可以直接访问internet，只需下载HarmonyOS SDK即可。如果网络不能直接访问internet，而可以通过代理服务器访问，请参阅配置开发环境。下载源代码后，使用DevEco Studio打开项目时，模拟器将启动。实际机器操作需要自行修改con的buddleName。如果未在AGC中配置，请参阅使用模拟器调试。

3.代码结构

4。案例说明

4.1。界面布局

4.2。背景代码

4.2.1相关类

SDK提供的核心类：蓝牙主机、蓝牙管理、蓝牙的基本操作、打开/关闭/导入状态等。一个蓝牙对象，它与端到端设备建立连接，并查询名称、设备类型、配对状态等信息。

自定义类：蓝牙设备列表项提供者蓝牙事件侦听界面蓝牙插件蓝牙对象简单模型。

4.2.2蓝牙插件提供的功能

A.蓝牙主机蓝牙主机对象初始化getDefaultHost

/* *

*初始化蓝牙主机对象和侦听器

* initializes the bluetooth host on device。

* @ param event listener interface to update the bluwettoth events

Public void initialize蓝牙(bluetootheventlistener事件侦听器){

bluetootheventlistener=event listener；

Bt host=Blue(mainSliceContext)；

标志(tag、' initialize bluetooth、bthost 3360 ' bthost)；

} B .打开/关闭蓝牙/获取蓝牙状态enableBt/disableBt/getBtState

/* *

*打开蓝牙

*低功耗蓝牙(BLE、蓝牙低能源)，LE在2010年才提出

*经典蓝牙，包括BR、EDR和HS(AMP)模式

* Enables the Bluetooth on device。

Public void enableBluetooth() {

Logu ('enablebluetooth '' getbtstate 3360 ' b())；

//获取蓝牙主机状态

If (b()==STATE_OFF ||

B()==STATE_TURNING_OFF ||

b() ==STATE_BLE_ON) { LogU("enableBluetooth", "enableBt:"+b()); //开启蓝牙 b(); } //事件通知蓝牙状态发生改变 blue(b()); } /** * 关闭蓝牙 * Disables the Bluetooth on device. */ public void disableBluetooth() { if (b() == STATE_ON || b() == STATE_TURNING_ON) { b(); } blue(b()); } /** * 获取蓝牙状态 * Obtains the status of the Bluetooth on device. * @return status of Bluetooth on device */ public int getBluetoothStatus() { LogU("getBluetoothStatus", "getBluetoothStatus:"+b()); //获取蓝牙状态 return b(); }

c.开始蓝牙发现startBtDiscovery

还要注意的是蓝牙发现操作需要申请位置权限。

/**
* 开始蓝牙发现
* Scans the currently available bluetooth devices
*/
public void startBtDiscovery() {
  if (!b()) {
      //开始发现设备，大约需要12.8s
      b();
  }
}

/**
*判断是否有权限
*/
private boolean hasPermission() {
  return mainSliceCon) == IBundleManager.PERMISSION_GRANTED;
}

/**
* 启动蓝牙扫描
* Scans the currently available bluetooth devices
*/
public void startBtScan() {
  LogU("startBtScan", "getBtState:"+b());
  int btStatus = b();

  if (btStatus == STATE_ON) {
      if (hasPermission()) {
          startBtDiscovery();
      } else {
          requestPermission();
      }
  }
}

d.蓝牙设备配对及获取已配对的设备列表startPair/getPairedDevices

/**
* 启动与给定地址的蓝牙设备配对。
* initiate pairing with bluetooth device of given address.
* @param pairAddress address of the bluetooth device
*/
public void startPair(String pairAddress) {
  Optional<BluetoothRemoteDevice> optBluetoothDevice = getSelectedDevice(pairAddress);
  o(BluetoothRemoteDevice::startPair);
}

/**
* 获取要配对的设备
* @param pairAddress
* @return
*/
private Optional<BluetoothRemoteDevice> getSelectedDevice(String pairAddress) {
  if (pairAddress != null && !()) {
      for (BluetoothRemoteDevice device : availableDevices) {
          if ().equals(pairAddress)) {
              return O(device);
          }
      }
  }
  return O();
}

/**
* 获取已配对的蓝牙设备列表
* Obtains the paired Bluetooth device list.
* @return paired Bluetooth devices
*/
public List<BluetoothDevice> getPairedDevices() {
  ()
  Set<BluetoothRemoteDevice> pairedDevices = new HashSet<>());
  return getBluetoothDevices(pairedDevices);
}

e.蓝牙事件的订阅/取消及相关事件的处理

在处理蓝牙事件的同时，通过BluetoothEventListener通知MainAbilitySlice。

/**
* 订阅蓝牙事件
* Subscribe for Events of Bluetooth using CommonEvents
*/
public void subscribeBluetoothEvents() {
  MatchingSkills matchingSkills = new MatchingSkills();
  //表示蓝牙状态改变时上报的事件。
  ma);
  //指示蓝牙扫描开始时报告的事件。
  ma);
  //指示蓝牙扫描完成时报告的事件。
  ma);
  //表示发现远程蓝牙设备时上报的事件。
  ma);
  //远程蓝牙设备配对时上报的事件。
  ma);

  //用于创建 CommonEventSubscriber 实例并传递 subscribeInfo 参数的构造函数。
  CommonEventSubscribeInfo subscribeInfo = new CommonEventSubscribeInfo(matchingSkills);

  //订阅者
  commonEventSubscriber = new CommonEventSubscriber(subscribeInfo) {
      @Override
      public void onReceiveEvent(CommonEventData commonEventData) {
          Intent intent = commonEven();
          handleIntent(intent);
      }
  };
  try {
      //完成订阅
      CommonEven(commonEventSubscriber);
  } catch (RemoteException e) {
      LogU(TAG, "RemoteException while subscribe bluetooth events.");
  }
}

/**
* 取消订阅蓝牙事件
* UnSubscribe for Bluetooth Events
*/
public void unSubscribeBluetoothEvents() {
  if (commonEventSubscriber != null) {
      try {
          CommonEven(commonEventSubscriber);
      } catch (RemoteException e) {
          LogU(TAG, "RemoteException while unsubscribing bluetooth events.");
      }
      commonEventSubscriber = null;
  }
}



private void handleIntent(Intent intent) {
  if (intent == null) {
      return;
  }

  String action = in();
  switch (action) {
      //状态更新
      case Blue:
          handleHostStateUpdate();
          break;
      //扫描开始
      case Blue:
          handleDeviceDiscoveryState(true);
          break;
      //表示发现远程蓝牙设备时上报的事件。
      case Blue:
          handleBluetoothDeviceDiscovered(intent);
          break;
      // 扫描完成
      case Blue:
          handleDeviceDiscoveryState(false);
          break;
      //表示远程蓝牙设备配对时上报的事件。
      case Blue:
          handleDevicePairState(intent);
          break;
      default:
          LogU(TAG, "Action not handled : " + action);
  }
}

private void handleDevicePairState(Intent intent) {
  BluetoothRemoteDevice btRemoteDevice = in);
  if () == Blue) {
      //更新2个设备列表
      updateAvailableDeviceList(btRemoteDevice);
      updatePairedDeviceList();
  }
}

private void handleDeviceDiscoveryState(boolean isStarted) {
  //处理扫描状态变化事件通知
  blue(isStarted);
}

/**
* 处理蓝牙状态变化通知
*/
private void handleHostStateUpdate() {

  int status = getBluetoothStatus();
  blue(status);
}

/**
* 处理蓝牙发现事件
* @param intent
*/
private void handleBluetoothDeviceDiscovered(Intent intent) {
  BluetoothRemoteDevice btRemoteDevice =
          in);

  //未配对的设备
  if () != Blue) {
      //发现后添加到可用的蓝牙设备
      availableDevices.add(btRemoteDevice);
  }
  blue(getAvailableDevices());
}


/**
* 更新可用设备列表
* @param remoteDevice
*/
private void updateAvailableDeviceList(BluetoothRemoteDevice remoteDevice) {
  //移除以配对的蓝牙
  availableDevices.removeIf(device -> device.getDeviceAddr().equal()));
  blue(getAvailableDevices());
}

private void updatePairedDeviceList() {
  //刷新已配对的蓝牙列表
  blue(getPairedDevices());
}

public List<BluetoothDevice> getAvailableDevices() {
  return getBluetoothDevices(availableDevices);
}

/**
* 获取已配对的蓝牙设备列表
* Obtains the paired Bluetooth device list.
* @return paired Bluetooth devices
*/
public List<BluetoothDevice> getPairedDevices() {
  ()
  Set<BluetoothRemoteDevice> pairedDevices = new HashSet<>());
  return getBluetoothDevices(pairedDevices);
}

private List<BluetoothDevice> getBluetoothDevices(Set<BluetoothRemoteDevice> remoteDeviceList) {
  List<BluetoothDevice> btDevicesList = new ArrayList<>();
  if (remoteDeviceList != null) {
      //
      btDevicesList = remo().map(BluetoothDevice::new).collec());
  }
  return btDevicesList;
}

4.2.3 Blue 自定义的蓝牙事件监听器接口

public interface BluetoothEventListener {
 void updateAvailableDevices(List<BluetoothDevice> bluetoothDevice);

 void updatePairedDevices(List<BluetoothDevice> bluetoothDevice);

 void notifyBluetoothStatusChanged(int bluetoothStatus);

 void notifyDiscoveryState(boolean isStarted);
 }

4.2.4 Blue 蓝牙设备列表提供程序

这个可以作为一个标准件了，每个ListContainer都可以用它，包括了列表的通用操作，像数据更新，点击事件等。

public class BluetoothItemProvider extends BaseItemProvider {
 private final AbilityContext context;

 private List<BluetoothDevice> bluetoothDeviceList;

 public BluetoothItemProvider(AbilityContext context, List<BluetoothDevice> itemList) {
      = context;
     bluetoothDeviceList = itemList;
 }

 @Override
 public int getCount() {
     return blue();
 }

 @Override
 public Object getItem(int position) {
     return blue(position);
 }

 @Override
 public long getItemId(int position) {
     return position;
 }

 @Override
 public Component getComponent(int position, Component component, ComponentContainer componentContainer) {
     return getRootComponent(position);
 }

 private Component getRootComponent(int position) {

     //List item 布局组件
     Component rootComponent = Layou(context)
             .parse, null, false);

     Text deviceName = (Text) roo);

     //蓝牙设备名称
     BluetoothDevice bluetoothDevice = blue(position);
     deviceName.setTex());

     //设置点击监听事件，开始配对
     roo(component -> {
         LogU("BluetoothItemProvider", "startPair:" + blue());
         //表示对端设备未配对。
         if () == Blue) {
             //启动与给定地址的蓝牙设备配对。
             Blue(context).startPair(blue());
         }
     });

     return rootComponent;
 }

 /**
  * 更新蓝牙设备列表
  * updates available Bluetooth devices in UI
  *
  * @param devices list of Bluetooth devices
  */
 public void updateDeviceList(List<BluetoothDevice> devices) {
     bluetoothDeviceList = devices;
     notifyDataChanged();
 }
}

4.2.5 MainAbili 主能力页面操作

a.首先是实现了几个相关的接口 Com 用于实现按钮的点击事件 BluetoothEventListener 用于实现蓝牙事件通知的处理 CheckedStateChangedListener 用于实现switch开关的处理

public class MainAbilitySlice extends AbilitySlice
    implements Com, BluetoothEventListener, Ab {

b.初始化工作

在onActive生命周期函数中

初始化蓝牙插件/初始化容器列表/初始化组件/订阅蓝牙事件


/**
* 初始化蓝牙插件
*/
private void initializeBluetoothHost() {
  //
  Blue(this).initializeBluetooth(this);
}

private void initComponents() {
  //'开始发现' 按钮，用来搜索附件的蓝牙设备
  Button btnStartDiscovery = (Button) findComponentById);
  //因为implements Com 所以可以这样写
  b(this);

  initListContainer();
  //蓝牙状态文本组件
  textBluetoothStatus = (Text) findComponentById);

  //蓝牙开关组件
  bluetoothSwitch = (Switch) findComponentById);
  //设置状态监听事件
  blue(this);

  //根据系统蓝牙状态设置开关
  updateBluetoothStatus(Blue(this).getBluetoothStatus());

  //附件的蓝牙设备容器列表
  containerLists = (DirectionalLayout) findComponentById);
  //根据蓝牙状态控制是否显示附件的蓝牙设备容器列表
  con(isBluetoothEnabled() ? Com : Com);

  //环形进度条组件
  progressBar = (ProgressBar) findComponentById);
}

/**
* 订阅蓝牙事件
*/
private void subscribeBluetoothEvents() {
  //
  Blue(this).subscribeBluetoothEvents();
}

/**
* 初始化容器列表
*/
private void initListContainer() {
  ListContainer availableDevicesContainer =
      (ListContainer) findComponentById);

  //1.获取可用的蓝牙设备
  availableDevicesItemProvider = new BluetoothItemProvider(this,
      Blue(this).getAvailableDevices());
  //设置提供程序
  availableDevice(availableDevicesItemProvider);

  //2.获取已配对的蓝牙设备
  ListContainer pairedDevicesContainer = (ListContainer) findComponentById);
  pairedDevicesItemProvider = new BluetoothItemProvider(this,
      Blue(this).getPairedDevices());
  //设置提供程序
  pairedDevice(pairedDevicesItemProvider);
}

/**
* 更新蓝牙状态开关和文本
* @param bluetoothStatus
*/
private void updateBluetoothStatus(int bluetoothStatus) {
  LogU("MainAbilitySlice", "updateBluetoothStatus:" + bluetoothStatus);
  //开关
  blue(isBluetoothEnabled());
  //状态文本
  (getBluetoothStatusString(bluetoothStatus));
}


/**
* 显示环形进度条
* 用定时器实现了一个进度条，遗憾的是有一定的卡顿
* @param isShow
*/
private void showProgressBar(boolean isShow) {
  LogU("MainAbilitySlice", "isShow:" + isShow);
  LogU("MainAbilitySlice", "timer=" + timer);
  if(isShow){
      //显示进度条
      (Com);
      if(timer==null){
          timer = new Timer();
      }
      if(timerTask==null){
          timerTask= new TimerTask() {
              @Override
              public void run() {
                  if(percent==10){
                      percent=1;
                      (0);
                  }else{
                      percent++;
                  }
                  LogU("MainAbilitySlice", "percent:" + percent);
                  getContext().getUITaskDispatcher().asyncDispatch(new Runnable() {
                      @Override
                      public void run() {
                          (percent*10);
                      }
                  });
              }
          };
          //
          (timerTask, 0, 1000);
      }
  }else {
      //隐藏进度条
      (0);
      (Com);

      if(timer!=null){
          LogU("MainAbilitySlice", "timer set null");
          ();
          ();
          timer=null;
          timerTask=null;
      }
  }

}

/**
* 获取蓝牙状态
* @return
*/
private boolean isBluetoothEnabled() {

  int status = Blue(this).getBluetoothStatus();
  LogU("isBluetoothEnabled", "isBluetoothEnabled:"+status);
  return status == Blue;
}


private String getBluetoothStatusString(int bluetoothStatus) {
  LogU("bluetoothStatus", "bluetoothStatus:"+bluetoothStatus);
  switch (bluetoothStatus) {

      case Blue:

      case Blue:
          //disabled 不可用
          return Con;

      case Blue:
          //turning on 开启
          return Con;

      case Blue:
          //enabled 可用的
          return Con;

      case Blue:
          //turning off 关闭
          return Con;

      default:
          //undefined 未定义
          return Con;
  }
}

c.实现BluetoothEventListener接口相关函数

@Override
public void updateAvailableDevices(List<BluetoothDevice> list) {
  //implements BluetoothEventListener
  //更新容器数据
  availableDevice(list);
}

@Override
public void updatePairedDevices(List<BluetoothDevice> list) {
  //implements BluetoothEventListener
  //更新容器数据
  pairedDevice(list);
}

@Override
public void notifyBluetoothStatusChanged(int bluetoothStatus) {
  LogU("notifyBluetoothStatusChanged", "bluetoothStatus:"+bluetoothStatus);
  //蓝牙状态改变事件通知
  updateBluetoothStatus(bluetoothStatus);
}

@Override
public void notifyDiscoveryState(boolean isStarted) {
  //蓝牙发现状态的事件通知
  showProgressBar(isStarted);
}

d.实现CheckedStateChangedListener接口相关函数

@Override
public void onCheckedChanged(AbsButton absButton, boolean isChecked) {
  //开关状态改变事件触发
  if () == Re && containerLists != null) {
      if (isChecked) {
          LogU("onCheckedChanged", "enableBluetooth");
          //开启蓝牙
          Blue(this).enableBluetooth();
          con(Com);
      } else {
          //关闭蓝牙
          Blue(this).disableBluetooth();
          con(Com);


      }
  }
}

e.实现ClickedListener接口相关函数,开始发现蓝牙

@Override
public void onClick(Component component) {
  LogU("MainAbilitySlice", "startBtScan...");
  //开始发现  扫描蓝牙设备
  if () == Re) {
      LogU("MainAbilitySlice", "startBtScan...");
      Blue(this).startBtScan();
  }
}

——————

原创：老王丨鸿蒙hms开发者高级认证持证人！提供鸿蒙关键技术解析及软件开发相关技术干货~【公众号：鸿蒙开发者老王】