HarmonyOS鸿蒙NEXT开发中，求一个蓝牙开发相关的demo

HarmonyOS鸿蒙NEXT开发中，求一个蓝牙开发相关的demo HarmonyOS NEXT开发中，求一个蓝牙开发相关的demo

蓝牙开发 Demo，包含蓝牙扫描、连接、数据传输，望采纳，谢谢！

配置权限

首先在 module.json5 中添加蓝牙相关权限：

{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.USE_BLUETOOTH",
        "reason": "需要蓝牙功能"
      },
      {
        "name": "ohos.permission.DISCOVER_BLUETOOTH",
        "reason": "需要发现蓝牙设备"
      },
      {
        "name": "ohos.permission.MANAGE_BLUETOOTH",
        "reason": "需要管理蓝牙连接"
      },
      {
        "name": "ohos.permission.LOCATION",
        "reason": "蓝牙扫描需要位置权限"
      }
    ]
  }
}

蓝牙工具类实现

import ble from '@ohos.bluetooth';
import { BusinessError } from '@ohos.base';

class BluetoothController {
  private bondedDevices: Array<ble.BluetoothDevice> = [];
  private foundDevices: Array<ble.BluetoothDevice> = [];
  private gattServer: ble.GattServer | null = null;
  private gattClient: ble.GattClientDevice | null = null;
  private serviceUuid: string = '0000180D-0000-1000-8000-00805F9B34FB'; // 示例服务UUID
  private characteristicUuid: string = '00002A37-0000-1000-8000-00805F9B34FB'; // 示例特征UUID

  // 初始化蓝牙
  async initBluetooth(): Promise<boolean> {
    try {
      if (!ble.getBluetoothState()) {
        console.log('蓝牙未开启，正在尝试打开...');
        await ble.enableBluetooth();
      }
      return true;
    } catch (error) {
      console.error('初始化蓝牙失败:', (error as BusinessError).message);
      return false;
    }
  }

  // 获取已绑定设备
  async getBondedDevices(): Promise<Array<ble.BluetoothDevice>> {
    try {
      this.bondedDevices = await ble.getPairedDevices();
      return this.bondedDevices;
    } catch (error) {
      console.error('获取已绑定设备失败:', (error as BusinessError).message);
      return [];
    }
  }

  // 开始扫描设备
  async startScan(): Promise<void> {
    try {
      this.foundDevices = [];
      
      ble.on('bluetoothDeviceFind', (devices: Array<ble.BluetoothDevice>) => {
        console.log('发现设备:', devices);
        this.foundDevices = [...this.foundDevices, ...devices];
      });
      
      await ble.startBluetoothDiscovery();
      console.log('开始扫描蓝牙设备');
    } catch (error) {
      console.error('扫描失败:', (error as BusinessError).message);
    }
  }

  // 停止扫描
  async stopScan(): Promise<void> {
    try {
      await ble.stopBluetoothDiscovery();
      console.log('停止扫描蓝牙设备');
    } catch (error) {
      console.error('停止扫描失败:', (error as BusinessError).message);
    }
  }

  // 连接设备
  async connectDevice(device: ble.BluetoothDevice): Promise<boolean> {
    try {
      this.gattClient = await ble.createGattClientDevice(device.deviceId);
      
      // 注册连接状态回调
      this.gattClient.on('connectionStateChange', (state: number) => {
        console.log('连接状态变化:', state === 1 ? '已连接' : '已断开');
      });
      
      // 发现服务
      await this.gattClient.connect();
      await this.discoverServices();
      
      return true;
    } catch (error) {
      console.error('连接设备失败:', (error as BusinessError).message);
      return false;
    }
  }

  // 发现服务
  private async discoverServices(): Promise<void> {
    if (!this.gattClient) return;
    
    try {
      const services = await this.gattClient.getServices();
      console.log('发现服务:', services);
      
      for (const service of services) {
        if (service.uuid === this.serviceUuid) {
          const characteristics = await service.getCharacteristics();
          console.log('发现特征:', characteristics);
          
          // 订阅特征值变化
          for (const char of characteristics) {
            if (char.uuid === this.characteristicUuid) {
              this.gattClient.on('characteristicRead', (value: Uint8Array) => {
                console.log('收到数据:', this.bytesToString(value));
              });
              
              await char.setNotifyEnable(true);
            }
          }
        }
      }
    } catch (error) {
      console.error('发现服务失败:', (error as BusinessError).message);
    }
  }

  // 发送数据
  async sendData(data: string): Promise<boolean> {
    if (!this.gattClient) return false;
    
    try {
      const services = await this.gattClient.getServices();
      for (const service of services) {
        if (service.uuid === this.serviceUuid) {
          const characteristics = await service.getCharacteristics();
          for (const char of characteristics) {
            if (char.uuid === this.characteristicUuid) {
              await char.writeValue(this.stringToBytes(data));
              console.log('数据发送成功');
              return true;
            }
          }
        }
      }
      return false;
    } catch (error) {
      console.error('发送数据失败:', (error as BusinessError).message);
      return false;
    }
  }

  // 断开连接
  async disconnect(): Promise<void> {
    try {
      if (this.gattClient) {
        await this.gattClient.disconnect();
        this.gattClient = null;
        console.log('已断开连接');
      }
    } catch (error) {
      console.error('断开连接失败:', (error as BusinessError).message);
    }
  }

  // 工具方法：字符串转字节数组
  private stringToBytes(str: string): Uint8Array {
    const encoder = new TextEncoder();
    return encoder.encode(str);
  }

  // 工具方法：字节数组转字符串
  private bytesToString(bytes: Uint8Array): string {
    const decoder = new TextDecoder();
    return decoder.decode(bytes);
  }
}

UI 界面实现

@Entry
@Component
struct BluetoothPage {
  private btController: BluetoothController = new BluetoothController();
  @State bondedDevices: Array<ble.BluetoothDevice> = [];
  @State foundDevices: Array<ble.BluetoothDevice> = [];
  @State isScanning: boolean = false;
  @State isConnected: boolean = false;
  @State message: string = '';

  aboutToAppear() {
    this.initBluetooth();
  }

  async initBluetooth() {
    const success = await this.btController.initBluetooth();
    if (success) {
      this.bondedDevices = await this.btController.getBondedDevices();
    }
  }

  async toggleScan() {
    if (this.isScanning) {
      await this.btController.stopScan();
      this.isScanning = false;
    } else {
      this.foundDevices = [];
      await this.btController.startScan();
      this.isScanning = true;
      
      // 10秒后自动停止扫描
      setTimeout(async () => {
        if (this.isScanning) {
          await this.btController.stopScan();
          this.isScanning = false;
        }
      }, 10000);
    }
  }

  async connectDevice(device: ble.BluetoothDevice) {
    const success = await this.btController.connectDevice(device);
    this.isConnected = success;
    if (success) {
      prompt.showToast({ message: `已连接: ${device.deviceName}` });
    }
  }

  async sendMessage() {
    if (this.message.trim() === '') return;
    
    const success = await this.btController.sendData(this.message);
    if (success) {
      this.message = '';
      prompt.showToast({ message: '发送成功' });
    }
  }

  build() {
    Column({ space: 10 }) {
      // 已绑定设备列表
      Text('已绑定设备').fontSize(18).margin(10)
      List() {
        ForEach(this.bondedDevices, (device) => {
          ListItem() {
            Column() {
              Text(device.deviceName || '未知设备')
              Text(device.deviceId).fontSize(12).fontColor(Color.Gray)
            }
            .onClick(() => {
              this.connectDevice(device);
            })
          }
        })
      }
      .height('20%')
      .width('100%')

      // 扫描控制
      Row() {
        Button(this.isScanning ? '停止扫描' : '开始扫描')
          .onClick(() => {
            this.toggleScan();
          })
        
        if (this.isConnected) {
          Button('断开连接')
            .margin({ left: 10 })
            .onClick(async () => {
              await this.btController.disconnect();
              this.isConnected = false;
            })
        }
      }

      // 发现的设备列表
      Text('发现的设备').fontSize(18).margin(10)
      List() {
        ForEach(this.foundDevices, (device) => {
          ListItem() {
            Column() {
              Text(device.deviceName || '未知设备')
              Text(device.deviceId).fontSize(12).fontColor(Color.Gray)
            }
            .onClick(() => {
              this.connectDevice(device);
            })
          }
        })
      }
      .height('20%')
      .width('100%')

      // 消息发送区域
      if (this.isConnected) {
        TextInput({ placeholder: '输入要发送的消息' })
          .onChange((value: string) => {
            this.message = value;
          })
          .value(this.message)
        
        Button('发送')
          .onClick(() => {
            this.sendMessage();
          })
      }
    }
    .width('100%')
    .height('100%')
    .padding(10)
  }
}

更多关于HarmonyOS鸿蒙NEXT开发中，求一个蓝牙开发相关的demo的实战系列教程也可以访问 https://www.itying.com/category-93-b0.html

yuanlaile 2楼•9 天前

在HarmonyOS鸿蒙NEXT开发中，进行蓝牙开发可以使用ArkTS语言。以下是一个简单的蓝牙开发demo示例，展示了如何扫描和连接蓝牙设备。

import bluetooth from '@ohos.bluetooth';

class BluetoothDemo {
  // 初始化蓝牙适配器
  async initBluetoothAdapter() {
    try {
      await bluetooth.getDefaultAdapter();
      console.log('Bluetooth adapter initialized');
    } catch (error) {
      console.error('Failed to initialize Bluetooth adapter', error);
    }
  }

  // 扫描蓝牙设备
  async startScan() {
    try {
      await bluetooth.startBluetoothDiscovery();
      console.log('Bluetooth scan started');
    } catch (error) {
      console.error('Failed to start Bluetooth scan', error);
    }
  }

  // 停止扫描蓝牙设备
  async stopScan() {
    try {
      await bluetooth.stopBluetoothDiscovery();
      console.log('Bluetooth scan stopped');
    } catch (error) {
      console.error('Failed to stop Bluetooth scan', error);
    }
  }

  // 连接蓝牙设备
  async connectDevice(deviceId: string) {
    try {
      await bluetooth.connect(deviceId);
      console.log('Bluetooth device connected', deviceId);
    } catch (error) {
      console.error('Failed to connect Bluetooth device', error);
    }
  }
}

// 使用示例
const demo = new BluetoothDemo();
demo.initBluetoothAdapter();
demo.startScan();
// 假设获取到的设备ID
const deviceId = 'example-device-id';
demo.connectDevice(deviceId);
demo.stopScan();

此demo展示了如何初始化蓝牙适配器、扫描蓝牙设备、停止扫描以及连接蓝牙设备。你可以根据实际需求进一步扩展功能，如处理扫描结果、管理连接状态等。

phonegap100 3楼•9 天前

在HarmonyOS鸿蒙NEXT开发中，蓝牙开发相关的Demo可以通过以下步骤实现：

初始化蓝牙：使用BluetoothManager初始化蓝牙适配器。
扫描设备：调用BluetoothAdapter.startDiscovery()方法扫描附近的蓝牙设备。
连接设备：通过BluetoothDevice.createBond()方法与目标设备建立连接。
数据传输：使用BluetoothSocket进行数据传输，通过OutputStream和InputStream读写数据。

示例代码片段如下：

BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
bluetoothAdapter.startDiscovery();

BluetoothDevice device = bluetoothAdapter.getRemoteDevice(deviceAddress);
BluetoothSocket socket = device.createRfcommSocketToServiceRecord(MY_UUID);
socket.connect();

OutputStream outputStream = socket.getOutputStream();
outputStream.write(data);

InputStream inputStream = socket.getInputStream();
inputStream.read(buffer);

确保在manifest文件中声明蓝牙权限：

<uses-permission ohos:name="ohos.permission.USE_BLUETOOTH"/>
<uses-permission ohos:name="ohos.permission.DISCOVER_BLUETOOTH"/>