文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

HarmonyOS Sample之Bluetooth传统蓝牙的使用

2024-12-02 21:36

关注

想了解更多内容，请访问：

51CTO和华为官方合作共建的鸿蒙技术社区

https://harmonyos.51cto.com

1.介绍

本示例演示了如何对蓝牙进行基本操作，

传统蓝牙本机管理：

主要是针对蓝牙本机的基本操作，包括：打开和关闭蓝牙、设置和获取本机蓝牙名称、扫描和取消扫描周边蓝牙设备、获取本机蓝牙profile对其他设备的连接状态、获取本机蓝牙已配对的蓝牙设备列表。

传统蓝牙远端管理操作：

主要是针对远端蓝牙设备的基本操作，包括：获取远端蓝牙设备地址、类型、名称和配对状态，以及向远端设备发起配对。

传统蓝牙和BLE的的概念请参考 蓝牙开发概述

还有一个小知识点，

调用蓝牙的打开接口需要ohos.permission.USE_BLUETOOTH权限，

调用蓝牙扫描接口需要ohos.permission.LOCATION权限和ohos.permission.DISCOVER_BLUETOOTH权限。

2.搭建环境

安装DevEco Studio，详情请参考DevEco Studio下载。

设置DevEco Studio开发环境，DevEco Studio开发环境需要依赖于网络环境，需要连接上网络才能确保工具的正常使用，可以根据如下两种情况来配置开发环境：

如果可以直接访问Internet，只需进行下载HarmonyOS SDK操作。

如果网络不能直接访问Internet，需要通过代理服务器才可以访问，请参考配置开发环境。

下载源码后，使用DevEco Studio 打开项目，模拟器运行即可。

真机运行需要将config.json中的buddleName修改为自己的，如果没有请到AGC上进行配置,参见 使用模拟器进行调试 。

3.代码结构


4.实例讲解

4.1.界面布局

 布局效果

4.2.后台代码

4.2.1 涉及的相关类

SDK提供的核心类：

BluetoothHost.java//蓝牙主机，可以管理蓝牙，提供了蓝牙的基本操作，打开/关闭/获取状态等。

BluetoothRemoteDevice.java//蓝牙对象，用于建立与对端设备的连接并查询名称、设备类型和配对状态等信息。

自定义的类：

BluetoothItemProvider.java//蓝牙设备列表项提供程序

BluetoothEventListener.java//蓝牙事件监听接口

BluetoothPlugin.java//蓝牙插件

BluetoothDevice.java//蓝牙对象简易模型

4.2.2 BluetoothPlugin.java 蓝牙插件提供的功能

a.初始化BluetoothHost蓝牙主机对象getDefaultHost

  1.  
  2. public void initializeBluetooth(BluetoothEventListener eventListener) { 
  3.   bluetoothEventListener = eventListener; 
  4.   btHost = BluetoothHost.getDefaultHost(mainSliceContext); 
  5.   LogUtil.info(TAG, "initializeBluetooth, btHost:"+btHost); 
  6. } 

b.开启/关闭蓝牙/获取蓝牙状态enableBt/disableBt/getBtState

  1.  
  2. public void enableBluetooth() { 
  3.   LogUtil.info("enableBluetooth", "getBtState:"+btHost.getBtState()); 
  4.   //获取蓝牙主机的状态 
  5.   if (btHost.getBtState() == STATE_OFF || 
  6.           btHost.getBtState() == STATE_TURNING_OFF || 
  7.           btHost.getBtState() ==STATE_BLE_ON) { 
  8.       LogUtil.info("enableBluetooth", "enableBt:"+btHost.getBtState()); 
  9.       //开启蓝牙 
  10.       btHost.enableBt(); 
  11.   } 
  12.   //事件通知蓝牙状态发生改变 
  13.   bluetoothEventListener.notifyBluetoothStatusChanged(btHost.getBtState()); 
  14. } 
  15.  
  16. public void disableBluetooth() { 
  17.   if (btHost.getBtState() == STATE_ON || btHost.getBtState() == STATE_TURNING_ON) { 
  18.       btHost.disableBt(); 
  19.   } 
  20.   bluetoothEventListener.notifyBluetoothStatusChanged(btHost.getBtState()); 
  21. } 
  22.  
  23.  
  24. public int getBluetoothStatus() { 
  25.   LogUtil.info("getBluetoothStatus", "getBluetoothStatus:"+btHost.getBtState()); 
  26.   //获取蓝牙状态 
  27.   return btHost.getBtState(); 
  28. } 

c.开始蓝牙发现startBtDiscovery

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

  1.  
  2. public void startBtDiscovery() { 
  3.   if (!btHost.isBtDiscovering()) { 
  4.       //开始发现设备，大约需要12.8s 
  5.       btHost.startBtDiscovery(); 
  6.   } 
  7. } 
  8.  
  9.  
  10. private boolean hasPermission() { 
  11.   return mainSliceContext.verifySelfPermission(Constants.PERM_LOCATION) == IBundleManager.PERMISSION_GRANTED; 
  12. } 
  13.  
  14.  
  15. public void startBtScan() { 
  16.   LogUtil.info("startBtScan", "getBtState:"+btHost.getBtState()); 
  17.   int btStatus = btHost.getBtState(); 
  18.  
  19.   if (btStatus == STATE_ON) { 
  20.       if (hasPermission()) { 
  21.           startBtDiscovery(); 
  22.       } else { 
  23.           requestPermission(); 
  24.       } 
  25.   } 
  26. } 

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

  1.  
  2. public void startPair(String pairAddress) { 
  3.   Optional optBluetoothDevice = getSelectedDevice(pairAddress); 
  4.   optBluetoothDevice.ifPresent(BluetoothRemoteDevice::startPair); 
  5. } 
  6.  
  7.  
  8. private Optional getSelectedDevice(String pairAddress) { 
  9.   if (pairAddress != null && !pairAddress.isEmpty()) { 
  10.       for (BluetoothRemoteDevice device : availableDevices) { 
  11.           if (device.getDeviceAddr().equals(pairAddress)) { 
  12.               return Optional.ofNullable(device); 
  13.           } 
  14.       } 
  15.   } 
  16.   return Optional.empty(); 
  17. } 
  18.  
  19.  
  20. public List getPairedDevices() { 
  21.   //btHost.getPairedDevices() 
  22.   Set pairedDevices = new HashSet<>(btHost.getPairedDevices()); 
  23.   return getBluetoothDevices(pairedDevices); 
  24. } 

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

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

  1.  
  2. public void subscribeBluetoothEvents() { 
  3.   MatchingSkills matchingSkills = new MatchingSkills(); 
  4.   //表示蓝牙状态改变时上报的事件。 
  5.   matchingSkills.addEvent(BluetoothHost.EVENT_HOST_STATE_UPDATE); 
  6.   //指示蓝牙扫描开始时报告的事件。 
  7.   matchingSkills.addEvent(BluetoothHost.EVENT_HOST_DISCOVERY_STARTED); 
  8.   //指示蓝牙扫描完成时报告的事件。 
  9.   matchingSkills.addEvent(BluetoothHost.EVENT_HOST_DISCOVERY_FINISHED); 
  10.   //表示发现远程蓝牙设备时上报的事件。 
  11.   matchingSkills.addEvent(BluetoothRemoteDevice.EVENT_DEVICE_DISCOVERED); 
  12.   //远程蓝牙设备配对时上报的事件。 
  13.   matchingSkills.addEvent(BluetoothRemoteDevice.EVENT_DEVICE_PAIR_STATE); 
  14.  
  15.   //用于创建 CommonEventSubscriber 实例并传递 subscribeInfo 参数的构造函数。 
  16.   CommonEventSubscribeInfo subscribeInfo = new CommonEventSubscribeInfo(matchingSkills); 
  17.  
  18.   //订阅者 
  19.   commonEventSubscriber = new CommonEventSubscriber(subscribeInfo) { 
  20.       @Override 
  21.       public void onReceiveEvent(CommonEventData commonEventData) { 
  22.           Intent intent = commonEventData.getIntent(); 
  23.           handleIntent(intent); 
  24.       } 
  25.   }; 
  26.   try { 
  27.       //完成订阅 
  28.       CommonEventManager.subscribeCommonEvent(commonEventSubscriber); 
  29.   } catch (RemoteException e) { 
  30.       LogUtil.error(TAG, "RemoteException while subscribe bluetooth events."); 
  31.   } 
  32. } 
  33.  
  34.  
  35. public void unSubscribeBluetoothEvents() { 
  36.   if (commonEventSubscriber != null) { 
  37.       try { 
  38.           CommonEventManager.unsubscribeCommonEvent(commonEventSubscriber); 
  39.       } catch (RemoteException e) { 
  40.           LogUtil.error(TAG, "RemoteException while unsubscribing bluetooth events."); 
  41.       } 
  42.       commonEventSubscriber = null; 
  43.   } 
  44. } 
  45.  
  46.  
  47.  
  48. private void handleIntent(Intent intent) { 
  49.   if (intent == null) { 
  50.       return; 
  51.   } 
  52.  
  53.   String action = intent.getAction(); 
  54.   switch (action) { 
  55.       //状态更新 
  56.       case BluetoothHost.EVENT_HOST_STATE_UPDATE: 
  57.           handleHostStateUpdate(); 
  58.           break; 
  59.       //扫描开始 
  60.       case BluetoothHost.EVENT_HOST_DISCOVERY_STARTED: 
  61.           handleDeviceDiscoveryState(true); 
  62.           break; 
  63.       //表示发现远程蓝牙设备时上报的事件。 
  64.       case BluetoothRemoteDevice.EVENT_DEVICE_DISCOVERED: 
  65.           handleBluetoothDeviceDiscovered(intent); 
  66.           break; 
  67.       // 扫描完成 
  68.       case BluetoothHost.EVENT_HOST_DISCOVERY_FINISHED: 
  69.           handleDeviceDiscoveryState(false); 
  70.           break; 
  71.       //表示远程蓝牙设备配对时上报的事件。 
  72.       case BluetoothRemoteDevice.EVENT_DEVICE_PAIR_STATE: 
  73.           handleDevicePairState(intent); 
  74.           break; 
  75.       default: 
  76.           LogUtil.info(TAG, "Action not handled : " + action); 
  77.   } 
  78. } 
  79.  
  80. private void handleDevicePairState(Intent intent) { 
  81.   BluetoothRemoteDevice btRemoteDevice = intent.getSequenceableParam(BluetoothRemoteDevice.REMOTE_DEVICE_PARAM_DEVICE); 
  82.   if (btRemoteDevice.getPairState() == BluetoothRemoteDevice.PAIR_STATE_PAIRED) { 
  83.       //更新2个设备列表 
  84.       updateAvailableDeviceList(btRemoteDevice); 
  85.       updatePairedDeviceList(); 
  86.   } 
  87. } 
  88.  
  89. private void handleDeviceDiscoveryState(boolean isStarted) { 
  90.   //处理扫描状态变化事件通知 
  91.   bluetoothEventListener.notifyDiscoveryState(isStarted); 
  92. } 
  93.  
  94.  
  95. private void handleHostStateUpdate() { 
  96.  
  97.   int status = getBluetoothStatus(); 
  98.   bluetoothEventListener.notifyBluetoothStatusChanged(status); 
  99. } 
  100.  
  101.  
  102. private void handleBluetoothDeviceDiscovered(Intent intent) { 
  103.   BluetoothRemoteDevice btRemoteDevice = 
  104.           intent.getSequenceableParam(BluetoothRemoteDevice.REMOTE_DEVICE_PARAM_DEVICE); 
  105.  
  106.   //未配对的设备 
  107.   if (btRemoteDevice.getPairState() != BluetoothRemoteDevice.PAIR_STATE_PAIRED) { 
  108.       //发现后添加到可用的蓝牙设备 
  109.       availableDevices.add(btRemoteDevice); 
  110.   } 
  111.   bluetoothEventListener.updateAvailableDevices(getAvailableDevices()); 
  112. } 
  113.  
  114.  
  115.  
  116. private void updateAvailableDeviceList(BluetoothRemoteDevice remoteDevice) { 
  117.   //移除以配对的蓝牙 
  118.   availableDevices.removeIf(device -> device.getDeviceAddr().equals(remoteDevice.getDeviceAddr())); 
  119.   bluetoothEventListener.updateAvailableDevices(getAvailableDevices()); 
  120. } 
  121.  
  122. private void updatePairedDeviceList() { 
  123.   //刷新已配对的蓝牙列表 
  124.   bluetoothEventListener.updatePairedDevices(getPairedDevices()); 
  125. } 
  126.  
  127. public List getAvailableDevices() { 
  128.   return getBluetoothDevices(availableDevices); 
  129. } 
  130.  
  131.  
  132. public List getPairedDevices() { 
  133.   //btHost.getPairedDevices() 
  134.   Set pairedDevices = new HashSet<>(btHost.getPairedDevices()); 
  135.   return getBluetoothDevices(pairedDevices); 
  136. } 
  137.  
  138. private List getBluetoothDevices(Set remoteDeviceList) { 
  139.   List btDevicesList = new ArrayList<>(); 
  140.   if (remoteDeviceList != null) { 
  141.       // 
  142.       btDevicesList = remoteDeviceList.stream().map(BluetoothDevice::new).collect(Collectors.toList()); 
  143.   } 
  144.   return btDevicesList; 
  145. } 

4.2.3 BluetoothEventListener.java 自定义的蓝牙事件监听器接口

  1. public interface BluetoothEventListener { 
  2.  void updateAvailableDevices(List bluetoothDevice); 
  3.  
  4.  void updatePairedDevices(List bluetoothDevice); 
  5.  
  6.  void notifyBluetoothStatusChanged(int bluetoothStatus); 
  7.  
  8.  void notifyDiscoveryState(boolean isStarted); 
  9.  } 

4.2.4 BluetoothItemProvider.java 蓝牙设备列表提供程序

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

  1. public class BluetoothItemProvider extends BaseItemProvider { 
  2.  private final AbilityContext context; 
  3.  
  4.  private List bluetoothDeviceList; 
  5.  
  6.  public BluetoothItemProvider(AbilityContext context, List itemList) { 
  7.      this.context = context; 
  8.      bluetoothDeviceList = itemList; 
  9.  } 
  10.  
  11.  @Override 
  12.  public int getCount() { 
  13.      return bluetoothDeviceList.size(); 
  14.  } 
  15.  
  16.  @Override 
  17.  public Object getItem(int position) { 
  18.      return bluetoothDeviceList.get(position); 
  19.  } 
  20.  
  21.  @Override 
  22.  public long getItemId(int position) { 
  23.      return position; 
  24.  } 
  25.  
  26.  @Override 
  27.  public Component getComponent(int position, Component component, ComponentContainer componentContainer) { 
  28.      return getRootComponent(position); 
  29.  } 
  30.  
  31.  private Component getRootComponent(int position) { 
  32.  
  33.      //List item 布局组件 
  34.      Component rootComponent = LayoutScatter.getInstance(context) 
  35.              .parse(ResourceTable.Layout_list_item, null, false); 
  36.  
  37.      Text deviceName = (Text) rootComponent.findComponentById(ResourceTable.Id_bluetooth_device_name); 
  38.  
  39.      //蓝牙设备名称 
  40.      BluetoothDevice bluetoothDevice = bluetoothDeviceList.get(position); 
  41.      deviceName.setText(bluetoothDevice.getName()); 
  42.  
  43.      //设置点击监听事件，开始配对 
  44.      rootComponent.setClickedListener(component -> { 
  45.          LogUtil.info("BluetoothItemProvider", "startPair:" + bluetoothDevice.getAddress()); 
  46.          //表示对端设备未配对。 
  47.          if (bluetoothDevice.getPairState() == BluetoothRemoteDevice.PAIR_STATE_NONE) { 
  48.              //启动与给定地址的蓝牙设备配对。 
  49.              BluetoothPlugin.getInstance(context).startPair(bluetoothDevice.getAddress()); 
  50.          } 
  51.      }); 
  52.  
  53.      return rootComponent; 
  54.  } 
  55.  
  56.   
  57.  public void updateDeviceList(List devices) { 
  58.      bluetoothDeviceList = devices; 
  59.      notifyDataChanged(); 
  60.  } 
  61. } 

4.2.5 MainAbilitySlice.java 主能力页面操作

a.首先是实现了几个相关的接口

Component.ClickedListener 用于实现按钮的点击事件

BluetoothEventListener 用于实现蓝牙事件通知的处理

CheckedStateChangedListener 用于实现switch开关的处理

  1. public class MainAbilitySlice extends AbilitySlice 
  2.     implements Component.ClickedListener, BluetoothEventListener, AbsButton.CheckedStateChangedListener { 

b.初始化工作

在onActive生命周期函数中

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

  1.  
  2. private void initializeBluetoothHost() { 
  3.   // 
  4.   BluetoothPlugin.getInstance(this).initializeBluetooth(this); 
  5. } 
  6.  
  7. private void initComponents() { 
  8.   //'开始发现' 按钮，用来搜索附件的蓝牙设备 
  9.   Button btnStartDiscovery = (Button) findComponentById(ResourceTable.Id_btn_start_discovery); 
  10.   //因为implements Component.ClickedListener 所以可以这样写 
  11.   btnStartDiscovery.setClickedListener(this); 
  12.  
  13.   initListContainer(); 
  14.   //蓝牙状态文本组件 
  15.   textBluetoothStatus = (Text) findComponentById(ResourceTable.Id_bluetooth_status); 
  16.  
  17.   //蓝牙开关组件 
  18.   bluetoothSwitch = (Switch) findComponentById(ResourceTable.Id_bt_switch); 
  19.   //设置状态监听事件 
  20.   bluetoothSwitch.setCheckedStateChangedListener(this); 
  21.  
  22.   //根据系统蓝牙状态设置开关 
  23.   updateBluetoothStatus(BluetoothPlugin.getInstance(this).getBluetoothStatus()); 
  24.  
  25.   //附件的蓝牙设备容器列表 
  26.   containerLists = (DirectionalLayout) findComponentById(ResourceTable.Id_container_lists); 
  27.   //根据蓝牙状态控制是否显示附件的蓝牙设备容器列表 
  28.   containerLists.setVisibility(isBluetoothEnabled() ? Component.VISIBLE : Component.HIDE); 
  29.  
  30.   //环形进度条组件 
  31.   progressBar = (ProgressBar) findComponentById(ResourceTable.Id_progressbar); 
  32. } 
  33.  
  34.  
  35. private void subscribeBluetoothEvents() { 
  36.   // 
  37.   BluetoothPlugin.getInstance(this).subscribeBluetoothEvents(); 
  38. } 
  39.  
  40.  
  41. private void initListContainer() { 
  42.   ListContainer availableDevicesContainer = 
  43.       (ListContainer) findComponentById(ResourceTable.Id_list_available_devices); 
  44.  
  45.   //1.获取可用的蓝牙设备 
  46.   availableDevicesItemProvider = new BluetoothItemProvider(this, 
  47.       BluetoothPlugin.getInstance(this).getAvailableDevices()); 
  48.   //设置提供程序 
  49.   availableDevicesContainer.setItemProvider(availableDevicesItemProvider); 
  50.  
  51.   //2.获取已配对的蓝牙设备 
  52.   ListContainer pairedDevicesContainer = (ListContainer) findComponentById(ResourceTable.Id_list_paired_devices); 
  53.   pairedDevicesItemProvider = new BluetoothItemProvider(this, 
  54.       BluetoothPlugin.getInstance(this).getPairedDevices()); 
  55.   //设置提供程序 
  56.   pairedDevicesContainer.setItemProvider(pairedDevicesItemProvider); 
  57. } 
  58.  
  59.  
  60. private void updateBluetoothStatus(int bluetoothStatus) { 
  61.   LogUtil.info("MainAbilitySlice", "updateBluetoothStatus:" + bluetoothStatus); 
  62.   //开关 
  63.   bluetoothSwitch.setChecked(isBluetoothEnabled()); 
  64.   //状态文本 
  65.   textBluetoothStatus.setText(getBluetoothStatusString(bluetoothStatus)); 
  66. } 
  67.  
  68.  
  69.  
  70. private void showProgressBar(boolean isShow) { 
  71.   LogUtil.info("MainAbilitySlice", "isShow:" + isShow); 
  72.   LogUtil.info("MainAbilitySlice", "timer=" + timer); 
  73.   if(isShow){ 
  74.       //显示进度条 
  75.       progressBar.setVisibility(Component.VISIBLE); 
  76.       if(timer==null){ 
  77.           timer = new Timer(); 
  78.       } 
  79.       if(timerTask==null){ 
  80.           timerTask= new TimerTask() { 
  81.               @Override 
  82.               public void run() { 
  83.                   if(percent==10){ 
  84.                       percent=1; 
  85.                       progressBar.setProgressValue(0); 
  86.                   }else{ 
  87.                       percent++; 
  88.                   } 
  89.                   LogUtil.info("MainAbilitySlice", "percent:" + percent); 
  90.                   getContext().getUITaskDispatcher().asyncDispatch(new Runnable() { 
  91.                       @Override 
  92.                       public void run() { 
  93.                           progressBar.setProgressValue(percent*10); 
  94.                       } 
  95.                   }); 
  96.               } 
  97.           }; 
  98.           // 
  99.           timer.schedule(timerTask, 0, 1000); 
  100.       } 
  101.   }else { 
  102.       //隐藏进度条 
  103.       progressBar.setProgressValue(0); 
  104.       progressBar.setVisibility(Component.HIDE); 
  105.  
  106.       if(timer!=null){ 
  107.           LogUtil.info("MainAbilitySlice", "timer set null"); 
  108.           timer.cancel(); 
  109.           timerTask.cancel(); 
  110.           timer=null; 
  111.           timerTask=null; 
  112.       } 
  113.   } 
  114.  
  115. } 
  116.  
  117.  
  118. private boolean isBluetoothEnabled() { 
  119.  
  120.   int status = BluetoothPlugin.getInstance(this).getBluetoothStatus(); 
  121.   LogUtil.info("isBluetoothEnabled", "isBluetoothEnabled:"+status); 
  122.   return status == BluetoothHost.STATE_ON; 
  123. } 
  124.  
  125.  
  126. private String getBluetoothStatusString(int bluetoothStatus) { 
  127.   LogUtil.info("bluetoothStatus", "bluetoothStatus:"+bluetoothStatus); 
  128.   switch (bluetoothStatus) { 
  129.  
  130.       case BluetoothHost.STATE_OFF: 
  131.  
  132.       case BluetoothHost.STATE_BLE_TURNING_OFF: 
  133.           //disabled 不可用 
  134.           return Constants.BT_DISABLED; 
  135.  
  136.       case BluetoothHost.STATE_TURNING_ON: 
  137.           //turning on 开启 
  138.           return Constants.BT_TURNING_ON; 
  139.  
  140.       case BluetoothHost.STATE_ON: 
  141.           //enabled 可用的 
  142.           return Constants.BT_ENABLED; 
  143.  
  144.       case BluetoothHost.STATE_TURNING_OFF: 
  145.           //turning off 关闭 
  146.           return Constants.BT_TURNING_OFF; 
  147.  
  148.       default: 
  149.           //undefined 未定义 
  150.           return Constants.BT_UNDEFINED; 
  151.   } 
  152. } 

c.实现BluetoothEventListener接口相关函数

  1. @Override 
  2. public void updateAvailableDevices(List list) { 
  3.   //implements BluetoothEventListener 
  4.   //更新容器数据 
  5.   availableDevicesItemProvider.updateDeviceList(list); 
  6. } 
  7.  
  8. @Override 
  9. public void updatePairedDevices(List list) { 
  10.   //implements BluetoothEventListener 
  11.   //更新容器数据 
  12.   pairedDevicesItemProvider.updateDeviceList(list); 
  13. } 
  14.  
  15. @Override 
  16. public void notifyBluetoothStatusChanged(int bluetoothStatus) { 
  17.   LogUtil.info("notifyBluetoothStatusChanged", "bluetoothStatus:"+bluetoothStatus); 
  18.   //蓝牙状态改变事件通知 
  19.   updateBluetoothStatus(bluetoothStatus); 
  20. } 
  21.  
  22. @Override 
  23. public void notifyDiscoveryState(boolean isStarted) { 
  24.   //蓝牙发现状态的事件通知 
  25.   showProgressBar(isStarted); 
  26. } 

d.实现CheckedStateChangedListener接口相关函数

  1. @Override 
  2. public void onCheckedChanged(AbsButton absButton, boolean isChecked) { 
  3.   //开关状态改变事件触发 
  4.   if (absButton.getId() == ResourceTable.Id_bt_switch && containerLists != null) { 
  5.       if (isChecked) { 
  6.           LogUtil.info("onCheckedChanged", "enableBluetooth"); 
  7.           //开启蓝牙 
  8.           BluetoothPlugin.getInstance(this).enableBluetooth(); 
  9.           containerLists.setVisibility(Component.VISIBLE); 
  10.       } else { 
  11.           //关闭蓝牙 
  12.           BluetoothPlugin.getInstance(this).disableBluetooth(); 
  13.           containerLists.setVisibility(Component.HIDE); 
  14.  
  15.  
  16.       } 
  17.   } 
  18. } 

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

  1. @Override 
  2. public void onClick(Component component) { 
  3.   LogUtil.info("MainAbilitySlice", "startBtScan..."); 
  4.   //开始发现  扫描蓝牙设备 
  5.   if (component.getId() == ResourceTable.Id_btn_start_discovery) { 
  6.       LogUtil.info("MainAbilitySlice", "startBtScan..."); 
  7.       BluetoothPlugin.getInstance(this).startBtScan(); 
  8.   } 
  9. } 

5.完整代码

附件直接下载

想了解更多内容，请访问：

51CTO和华为官方合作共建的鸿蒙技术社区

https://harmonyos.51cto.com

 

来源：鸿蒙社区内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

HarmonyOS Sample之Bluetooth传统蓝牙的使用

后端开发鸿蒙HarmonyOS2024-12-02

Win7 Win8使用蓝牙传输文件通过运行fsquirt的命令来实现

后端开发2023-06-06

无法使用win10系统蓝牙耳机连接电脑麦克风的解决方案

后端开发2023-07-10
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯