鸿蒙常见问题分析五：BLE蓝牙setCharacteristicChangeNotification接口

引言：BLE蓝牙开发中的通信痛点

在HarmonyOS应用开发中，蓝牙低功耗（BLE）通信是实现设备间无线数据交换的关键技术。然而，许多开发者在实现BLE特征值通知功能时，常常遇到一个令人头疼的问题：调用setCharacteristicChangeNotification接口时出现2900007或2900099错误码。

这两个错误码看似简单，却可能让开发者陷入长时间的调试困境：

• 2900007：接口调用超时，client端在约10秒内未收到server端应答

• 2900099：接口调用操作失败，通常由接口调用阻塞引起

本文将深入剖析这两个错误码的根源，提供完整的排查解决方案，并分享HarmonyOS BLE开发的最佳实践。

一、问题现象深度分析

1.1 错误码背后的通信机制

2900007错误码的本质：

当client端向server端发起特征值通知请求后，底层会通过描述符（Descriptor）的形式向server端写入一次数据请求。这个请求需要server端通过descriptorWrite监听接收，并调用sendResponse接口向client返回数据。只有在client成功接收到响应后，整个setCharacteristicChangeNotification接口的调用流程才算完成。

如果server端没有及时响应，client端就会在等待约10秒后返回2900007错误。

2900099错误码的常见场景：

1.2 典型错误场景还原

// 错误示例1：缺少descriptorWrite监听
class ProblematicBLEServer {
// server端没有创建descriptorWrite监听
// client端的setCharacteristicChangeNotification会一直等待响应
}

// 错误示例2：响应不及时
class SlowResponseServer {
on('descriptorWrite', (descriptor: BLEDescriptor) => {
// 收到请求后没有及时调用sendResponse
// 或者sendResponse调用失败
// 导致client端超时
});
}

// 错误示例3：接口调用顺序错误
class WrongOrderClient {
async connectAndNotify() {
await this.gattClient.connect();
// 错误：在MTU协商完成前就尝试设置通知
await this.gattClient.setCharacteristicChangeNotification(characteristic, true);
// 可能触发2900099错误
}
}

二、HarmonyOS BLE通信架构解析

2.1 BLE通信的核心组件

组件

角色

职责

2.2 setCharacteristicChangeNotification的工作流程

graph TD
A[Client调用setCharacteristicChangeNotification] –> B[底层向Server写入Descriptor]
B –> C{Server是否有descriptorWrite监听?}
C –>|是| D[Server接收请求]
C –>|否| E[Client等待超时<br/>返回2900007]
D –> F{Server是否调用sendResponse?}
F –>|是| G[Client收到响应<br/>设置成功]
F –>|否| H[Client等待超时<br/>返回2900007]

2.3 完整的BLE通信时序

正确的接口调用顺序至关重要：

关键点：必须在setBLEMtuSize和getServices接口的回调都完成后，才能调用setCharacteristicChangeNotification。

三、完整代码实现与详解

3.1 Server端完整实现

// Server端：正确处理descriptorWrite请求
import { ble, constant } from '@kit.ConnectivityKit';
import { BusinessError } from '@kit.BasicServicesKit';

@Entry
@Component
struct BLEServerExample {
private gattServer: ble.GattServerDevice | undefined = undefined;

aboutToAppear(): void {
this.initializeBLEServer();
}

// 初始化BLE Server
async initializeBLEServer(): Promise<void> {
try {
// 创建GATT Server实例
this.gattServer = ble.createGattServerDevice();

// 添加服务
const service: ble.GattService = {
serviceUuid: '0000180F-0000-1000-8000-00805F9B34FB', // 电池服务
isPrimary: true,
characteristics: []
};

// 添加特征值
const characteristic: ble.BLECharacteristic = {
serviceUuid: service.serviceUuid,
characteristicUuid: '00002A19-0000-1000-8000-00805F9B34FB', // 电池电平
properties: [constant.CharacteristicProperty.NOTIFY],
permissions: [constant.AttributePermission.READABLE],
descriptors: []
};

// 添加客户端特征值配置描述符（CCCD）
const cccdDescriptor: ble.BLEDescriptor = {
serviceUuid: service.serviceUuid,
characteristicUuid: characteristic.characteristicUuid,
descriptorUuid: '00002902-0000-1000-8000-00805F9B34FB', // CCCD UUID
permissions: [constant.AttributePermission.READABLE, constant.AttributePermission.WRITEABLE]
};

characteristic.descriptors = [cccdDescriptor];
service.characteristics = [characteristic];

// 添加服务到Server
await this.gattServer.addService(service);

// 关键步骤：监听descriptorWrite事件
this.setupDescriptorWriteListener();

// 开始广播
await this.gattServer.startAdvertising({
advertiseSettings: {
interval: 160, // 广播间隔
txPower: 0, // 发射功率
connectable: true
},
advertiseData: {
serviceUuids: [service.serviceUuid],
localName: 'HarmonyOS-BLE-Server'
}
});

console.info('BLE Server启动成功，开始广播');
} catch (error) {
console.error('初始化BLE Server失败:', error);
}
}

// 设置descriptorWrite监听（解决2900007错误的关键）
setupDescriptorWriteListener(): void {
if (!this.gattServer) return;

try {
this.gattServer.on('descriptorWrite', (descriptor: ble.BLEDescriptor) => {
console.info('收到descriptorWrite请求:', descriptor.descriptorUuid);

// 检查是否是CCCD描述符
if (descriptor.descriptorUuid === '00002902-0000-1000-8000-00805F9B34FB') {
// 解析client的请求（启用或禁用通知）
const value = descriptor.descriptorValue;
if (value && value.byteLength > 0) {
const view = new Uint8Array(value);
const isNotificationEnabled = (view[0] & 0x01) !== 0;

console.info(`Client ${isNotificationEnabled ? '启用' : '禁用'}了通知`);

// 关键步骤：必须调用sendResponse响应client
try {
this.gattServer?.sendResponse(descriptor, constant.GattStatus.SUCCESS);
console.info('已发送响应给Client');
} catch (responseError) {
console.error('发送响应失败:', responseError);
}
}
}
});
} catch (error) {
console.error('设置descriptorWrite监听失败:', error);
}
}

// 发送通知给Client
async sendNotificationToClient(batteryLevel: number): Promise<void> {
if (!this.gattServer) return;

try {
const characteristic: ble.BLECharacteristic = {
serviceUuid: '0000180F-0000-1000-8000-00805F9B34FB',
characteristicUuid: '00002A19-0000-1000-8000-00805F9B34FB',
characteristicValue: new Uint8Array([batteryLevel]).buffer
};

// 发送通知
await this.gattServer.notifyCharacteristicChanged(characteristic);
console.info(`已发送电池电平通知: ${batteryLevel}%`);
} catch (error) {
console.error('发送通知失败:', error);
}
}

build() {
Column() {
Text('BLE Server示例')
.fontSize(20)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 20 });

Button('发送电池通知 (80%)')
.onClick(() => this.sendNotificationToClient(80))
.margin({ bottom: 10 });

Button('发送电池通知 (50%)')
.onClick(() => this.sendNotificationToClient(50))
.margin({ bottom: 10 });

Button('发送电池通知 (20%)')
.onClick(() => this.sendNotificationToClient(20));
}
.width('100%')
.height('100%')
.justifyContent(FlexAlign.Center);
}
}

3.2 Client端完整实现（避免2900007/2900099错误）

// Client端：正确的接口调用顺序
import { ble, constant } from '@kit.ConnectivityKit';
import { abilityAccessCtrl, common, PermissionRequestResult } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';

@Entry
@Component
struct BLEClientExample {
@State gattClient: ble.GattClientDevice | undefined = undefined;
@State connectionStatus: string = '未连接';
@State batteryLevel: number = 0;

// 状态标记
private isMtuNegotiated: boolean = false;
private isServicesDiscovered: boolean = false;
private isSettingNotification: boolean = false;

aboutToAppear(): void {
this.requestBluetoothPermission();
}

// 请求蓝牙权限
async requestBluetoothPermission(): Promise<void> {
try {
const atManager = abilityAccessCtrl.createAtManager();
await atManager.requestPermissionsFromUser(
this.getUIContext()?.getHostContext() as common.UIAbilityContext,
['ohos.permission.ACCESS_BLUETOOTH']
);
console.info('蓝牙权限获取成功');
} catch (error) {
console.error('蓝牙权限获取失败:', error);
}
}

// 连接BLE设备
async connectToDevice(): Promise<void> {
try {
// 1. 创建Client实例
this.gattClient = ble.createGattClientDevice('AA:BB:CC:DD:EE:FF'); // 替换为实际设备地址

// 2. 设置连接状态监听
this.setupConnectionStateListener();

// 3. 设置MTU变化监听
this.setupMtuChangeListener();

// 4. 设置特征值变化监听
this.setupCharacteristicChangeListener();

// 5. 连接设备
await this.gattClient.connect();
this.connectionStatus = '连接中…';

} catch (error) {
console.error('连接设备失败:', error);
this.connectionStatus = '连接失败';
}
}

// 连接状态监听
setupConnectionStateListener(): void {
if (!this.gattClient) return;

try {
this.gattClient.on('BLEConnectionStateChange', (state: ble.BLEConnectionChangeState) => {
console.info(`连接状态变化: ${state.state}`);

if (state.state === constant.ProfileConnectionState.STATE_CONNECTED) {
this.connectionStatus = '已连接';
console.info('BLE连接成功');

// 连接成功后开始MTU协商
this.negotiateMtu();

} else if (state.state === constant.ProfileConnectionState.STATE_DISCONNECTED) {
this.connectionStatus = '已断开';
console.info('BLE连接断开');

// 重置状态
this.isMtuNegotiated = false;
this.isServicesDiscovered = false;
this.isSettingNotification = false;
}
});
} catch (error) {
console.error('设置连接状态监听失败:', error);
}
}

// MTU变化监听
setupMtuChangeListener(): void {
if (!this.gattClient) return;

try {
this.gattClient.on('BLEMtuChange', (mtu: number) => {
console.info(`MTU协商成功: ${mtu}`);
this.isMtuNegotiated = true;

// MTU协商成功后获取服务
this.discoverServices();
});
} catch (error) {
console.error('设置MTU变化监听失败:', error);
}
}

// 特征值变化监听
setupCharacteristicChangeListener(): void {
if (!this.gattClient) return;

try {
this.gattClient.on('characteristicChange', (characteristic: ble.BLECharacteristic) => {
console.info('收到特征值变化通知');

// 处理接收到的数据
if (characteristic.characteristicValue) {
const value = new Uint8Array(characteristic.characteristicValue);
this.batteryLevel = value[0];
console.info(`电池电平更新: ${this.batteryLevel}%`);
}
});
} catch (error) {
console.error('设置特征值变化监听失败:', error);
}
}

// MTU协商
async negotiateMtu(): Promise<void> {
if (!this.gattClient) return;

try {
console.info('开始MTU协商…');
await this.gattClient.setBLEMtuSize(128); // 协商MTU大小为128
} catch (error) {
console.error('MTU协商失败:', error);
this.isMtuNegotiated = false;
}
}

// 发现服务
async discoverServices(): Promise<void> {
if (!this.gattClient || !this.isMtuNegotiated) {
console.error('MTU未协商完成，无法发现服务');
return;
}

try {
console.info('开始发现服务…');
const services = await this.gattClient.getServices();
console.info(`发现${services.length}个服务`);

this.isServicesDiscovered = true;

// 服务发现成功后设置通知
this.setupCharacteristicNotification(services);

} catch (error) {
console.error('发现服务失败:', error);
this.isServicesDiscovered = false;
}
}

// 设置特征值通知（关键函数）
async setupCharacteristicNotification(services: Array<ble.GattService>): Promise<void> {
if (!this.gattClient || !this.isServicesDiscovered) {
console.error('服务未发现完成，无法设置通知');
return;
}

if (this.isSettingNotification) {
console.warn('正在设置通知，请勿重复调用');
return;
}

this.isSettingNotification = true;

try {
// 查找电池服务
const batteryService = services.find(service =>
service.serviceUuid === '0000180F-0000-1000-8000-00805F9B34FB'
);

if (!batteryService) {
console.error('未找到电池服务');
this.isSettingNotification = false;
return;
}

// 查找电池电平特征值
const batteryLevelChar = batteryService.characteristics?.find(char =>
char.characteristicUuid === '00002A19-0000-1000-8000-00805F9B34FB'
);

if (!batteryLevelChar) {
console.error('未找到电池电平特征值');
this.isSettingNotification = false;
return;
}

// 创建characteristic对象（关键：必须包含descriptors）
const characteristic: ble.BLECharacteristic = {
serviceUuid: batteryService.serviceUuid,
characteristicUuid: batteryLevelChar.characteristicUuid,
characteristicValue: new ArrayBuffer(0),
descriptors: batteryLevelChar.descriptors || [] // 重要：必须传递descriptors
};

console.info('开始设置特征值通知…');

// 调用setCharacteristicChangeNotification
await this.gattClient.setCharacteristicChangeNotification(characteristic, true, (err: BusinessError) => {
if (err) {
console.error(`设置通知失败，错误码: ${err.code}, 消息: ${err.message}`);

// 根据错误码提供具体建议
if (err.code === 2900007) {
console.error('错误2900007: Server端未响应，请检查：');
console.error('1. Server端是否设置了descriptorWrite监听');
console.error('2. Server端是否调用了sendResponse');
console.error('3. 网络连接是否稳定');
} else if (err.code === 2900099) {
console.error('错误2900099: 接口调用失败，请检查：');
console.error('1. 是否在setBLEMtuSize/getServices回调完成前调用');
console.error('2. 是否重复创建了gattClient实例');
console.error('3. characteristic参数是否正确');
}
} else {
console.info('特征值通知设置成功！');
}

this.isSettingNotification = false;
});

} catch (error) {
console.error('设置特征值通知异常:', error);
this.isSettingNotification = false;
}
}

// 断开连接
async disconnect(): Promise<void> {
if (!this.gattClient) return;

try {
await this.gattClient.disconnect();
this.connectionStatus = '已断开';

// 重要：及时销毁gattClient对象
this.gattClient = undefined;
console.info('已断开连接并销毁gattClient对象');

} catch (error) {
console.error('断开连接失败:', error);
}
}

build() {
Column() {
Text('BLE Client示例')
.fontSize(20)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 20 });

Text(`连接状态: ${this.connectionStatus}`)
.fontSize(16)
.margin({ bottom: 10 });

Text(`电池电量: ${this.batteryLevel}%`)
.fontSize(16)
.margin({ bottom: 20 });

Button('连接设备')
.onClick(() => this.connectToDevice())
.margin({ bottom: 10 })
.width('80%');

Button('断开连接')
.onClick(() => this.disconnect())
.margin({ bottom: 20 })
.width('80%');

// 调试信息区域
Column() {
Text('调试信息:')
.fontSize(14)
.fontWeight(FontWeight.Bold)
.margin({ bottom: 5 });

Text(`MTU协商: ${this.isMtuNegotiated ? '完成' : '未完成'}`)
.fontSize(12)
.margin({ bottom: 2 });

Text(`服务发现: ${this.isServicesDiscovered ? '完成' : '未完成'}`)
.fontSize(12)
.margin({ bottom: 2 });

Text(`通知设置: ${this.isSettingNotification ? '进行中' : '未进行'}`)
.fontSize(12);
}
.padding(10)
.backgroundColor('#F5F5F5')
.borderRadius(8)
.width('80%');
}
.width('100%')
.height('100%')
.justifyContent(FlexAlign.Center);
}
}

四、常见问题解决方案

4.1 错误2900007：接口调用超时

问题现象：

Client端调用setCharacteristicChangeNotification后，等待约10秒返回错误码2900007。

根本原因：

Server端没有正确响应Client端的描述符写入请求。

解决方案：

方案一：检查Server端descriptorWrite监听

// Server端必须设置descriptorWrite监听
class BLEServerSolution {
setupDescriptorWriteListener(): void {
this.gattServer.on('descriptorWrite', (descriptor: ble.BLEDescriptor) => {
console.info('收到descriptorWrite请求');

// 关键：必须调用sendResponse
this.gattServer.sendResponse(descriptor, constant.GattStatus.SUCCESS)
.then(() => {
console.info('成功响应Client请求');
})
.catch((error) => {
console.error('响应失败:', error);
});
});
}
}

方案二：添加超时重试机制

// Client端添加超时重试
class BLEClientWithRetry {
private retryCount: number = 0;
private maxRetries: number = 3;

async setNotificationWithRetry(
characteristic: ble.BLECharacteristic,
enable: boolean
): Promise<void> {
return new Promise((resolve, reject) => {
const timeoutId = setTimeout(() => {
if (this.retryCount < this.maxRetries) {
this.retryCount++;
console.warn(`第${this.retryCount}次重试…`);
this.setNotificationWithRetry(characteristic, enable)
.then(resolve)
.catch(reject);
} else {
reject(new Error(`设置通知失败，已重试${this.maxRetries}次`));
}
}, 10000); // 10秒超时

this.gattClient.setCharacteristicChangeNotification(
characteristic,
enable,
(err: BusinessError) => {
clearTimeout(timeoutId);
if (err) {
reject(err);
} else {
this.retryCount = 0;
resolve();
}
}
);
});
}
}

4.2 错误2900099：接口调用操作失败

问题现象：

调用setCharacteristicChangeNotification立即返回错误码2900099。

根本原因：

解决方案：

方案一：确保接口调用顺序

// 正确的接口调用顺序
class CorrectCallOrder {
async setupBLEConnection(): Promise<void> {
// 1. 创建连接
await this.connect();

// 2. 等待MTU协商完成
await this.waitForMtuNegotiation();

// 3. 获取服务
const services = await this.getServices();

// 4. 设置通知（必须在前面步骤完成后）
await this.setCharacteristicNotification(services);

// 5. 写入数据（必须在设置通知完成后）
await this.writeData();
}

private async waitForMtuNegotiation(): Promise<void> {
return new Promise((resolve) => {
this.gattClient.on('BLEMtuChange', () => {
resolve();
});
});
}
}

方案二：避免重复创建gattClient

// 单例模式管理gattClient
class GattClientManager {
private static instance: GattClientManager;
private gattClient: ble.GattClientDevice | null = null;

private constructor() {}

static getInstance(): GattClientManager {
if (!GattClientManager.instance) {
GattClientManager.instance = new GattClientManager();
}
return GattClientManager.instance;
}

getGattClient(deviceAddress: string): ble.GattClientDevice {
if (!this.gattClient) {
this.gattClient = ble.createGattClientDevice(deviceAddress);
}
return this.gattClient;
}

destroyGattClient(): void {
if (this.gattClient) {
// 先断开连接
this.gattClient.disconnect();
// 释放资源
this.gattClient = null;
}
}
}

方案三：正确构造characteristic参数

// 正确构造characteristic对象
class CharacteristicBuilder {
buildCharacteristic(
service: ble.GattService,
charUuid: string
): ble.BLECharacteristic {
const characteristic = service.characteristics?.find(
char => char.characteristicUuid === charUuid
);

if (!characteristic) {
throw new Error(`未找到特征值: ${charUuid}`);
}

// 关键：必须包含descriptors字段
return {
serviceUuid: service.serviceUuid,
characteristicUuid: characteristic.characteristicUuid,
characteristicValue: new ArrayBuffer(0), // 可以为空
descriptors: characteristic.descriptors || [] // 重要：不能省略
};
}
}

4.3 兼容性处理：早期设备无descriptors

问题：

早期存量设备的特征值可能没有descriptors字段。

解决方案：

// 兼容性处理
class CompatibilityHandler {
async setNotificationSafely(
characteristic: ble.BLECharacteristic
): Promise<void> {
// 检查是否有descriptors
if (!characteristic.descriptors || characteristic.descriptors.length === 0) {
console.warn('特征值没有descriptors，使用空数组');

// 创建包含空descriptors的新对象
const compatibleChar: ble.BLECharacteristic = {
serviceUuid: characteristic.serviceUuid,
characteristicUuid: characteristic.characteristicUuid,
characteristicValue: characteristic.characteristicValue,
descriptors: [] // 传入空数组
};

return this.setNotification(compatibleChar);
} else {
return this.setNotification(characteristic);
}
}

private async setNotification(
characteristic: ble.BLECharacteristic
): Promise<void> {
// 正常的设置通知逻辑
}
}

五、最佳实践与优化建议

5.1 错误处理最佳实践

// 健壮的错误处理框架
class BLEErrorHandler {
private errorCallbacks: Map<number, (error: BusinessError) => void> = new Map();

constructor() {
this.registerErrorHandlers();
}

private registerErrorHandlers(): void {
// 2900007: 接口调用超时
this.errorCallbacks.set(2900007, (error) => {
console.error('错误2900007处理:');
console.error('1. 检查Server端descriptorWrite监听');
console.error('2. 检查Server端sendResponse调用');
console.error('3. 检查网络连接状态');
console.error('4. 考虑增加超时重试机制');

// 可以自动重试
this.retryWithBackoff();
});

// 2900099: 接口调用操作失败
this.errorCallbacks.set(2900099, (error) => {
console.error('错误2900099处理:');
console.error('1. 检查接口调用顺序');
console.error('2. 检查是否重复创建gattClient');
console.error('3. 验证characteristic参数');
console.error('4. 检查前一个异步操作是否完成');

// 重置连接状态
this.resetConnection();
});
}

handleError(error: BusinessError): void {
const handler = this.errorCallbacks.get(error.code);
if (handler) {
handler(error);
} else {
console.error(`未知错误: ${error.code}, ${error.message}`);
}
}
}

5.2 性能优化建议

连接池管理

// BLE连接池
class BLEConnectionPool {
private connections: Map<string, ble.GattClientDevice> = new Map();
private connectionStates: Map<string, ConnectionState> = new Map();

async getConnection(deviceAddress: string): Promise<ble.GattClientDevice> {
// 检查现有连接
if (this.connections.has(deviceAddress)) {
const client = this.connections.get(deviceAddress)!;
const state = this.connectionStates.get(deviceAddress);

if (state === ConnectionState.CONNECTED) {
return client;
}
}

// 创建新连接
const client = await this.createNewConnection(deviceAddress);
this.connections.set(deviceAddress, client);
this.connectionStates.set(deviceAddress, ConnectionState.CONNECTED);

return client;
}

// 连接状态监控
monitorConnectionHealth(): void {
setInterval(() => {
this.connections.forEach((client, address) => {
this.checkConnectionHealth(client, address);
});
}, 30000); // 每30秒检查一次
}
}

异步操作队列

// 异步操作队列，避免冲突
class BLEOperationQueue {
private queue: Array<() => Promise<any>> = [];
private isProcessing: boolean = false;

async enqueue(operation: () => Promise<any>): Promise<any> {
return new Promise((resolve, reject) => {
this.queue.push(async () => {
try {
const result = await operation();
resolve(result);
} catch (error) {
reject(error);
}
});

this.processQueue();
});
}

private async processQueue(): Promise<void> {
if (this.isProcessing || this.queue.length === 0) {
return;
}

this.isProcessing = true;

while (this.queue.length > 0) {
const operation = this.queue.shift()!;
await operation();

// 添加延迟，避免操作过于密集
await new Promise(resolve => setTimeout(resolve, 50));
}

this.isProcessing = false;
}
}

5.3 调试与日志记录

// 详细的BLE调试工具
class BLEDebugger {
private logLevel: LogLevel = LogLevel.DEBUG;
private logs: Array<BLELog> = [];

log(level: LogLevel, message: string, data?: any): void {
if (level >= this.logLevel) {
const logEntry: BLELog = {
timestamp: new Date(),
level,
message,
data
};

this.logs.push(logEntry);

// 控制台输出
const prefix = this.getLevelPrefix(level);
console.log(`${prefix} ${message}`, data || '');

// 保持日志数量可控
if (this.logs.length > 1000) {
this.logs = this.logs.slice(-500);
}
}
}

// 专门记录setCharacteristicChangeNotification调用
logNotificationCall(
characteristic: ble.BLECharacteristic,
enable: boolean
): void {
this.log(LogLevel.INFO, '调用setCharacteristicChangeNotification', {
serviceUuid: characteristic.serviceUuid,
characteristicUuid: characteristic.characteristicUuid,
enable,
hasDescriptors: !!characteristic.descriptors,
descriptorCount: characteristic.descriptors?.length || 0,
timestamp: Date.now()
});
}

// 生成错误报告
generateErrorReport(error: BusinessError): string {
const recentLogs = this.logs.slice(-20); // 最近20条日志
return JSON.stringify({
error: {
code: error.code,
message: error.message
},
context: {
timestamp: new Date().toISOString(),
recentLogs
}
}, null, 2);
}
}

六、总结与展望

6.1 核心问题总结

通过对setCharacteristicChangeNotification接口2900007和2900099错误码的深入分析，我们可以总结出以下关键点：

6.2 最佳实践要点

6.3 未来优化方向

随着HarmonyOS生态的不断发展，BLE蓝牙开发也将迎来更多改进：

6.4 给开发者的建议

BLE蓝牙开发虽然有一定复杂度，但只要掌握了正确的方法和技巧，就能高效地构建稳定可靠的蓝牙应用。希望本文能帮助你在HarmonyOS BLE开发中少走弯路，快速解决遇到的问题。