504 lines
15 KiB
Plaintext
504 lines
15 KiB
Plaintext
// 蓝牙相关接口和类型定义
|
||
|
||
// 基础设备信息类型
|
||
export type BleDeviceInfo = {
|
||
deviceId : string;
|
||
name : string;
|
||
RSSI ?: number;
|
||
connected ?: boolean;
|
||
// 新增
|
||
serviceId ?: string;
|
||
writeCharId ?: string;
|
||
notifyCharId ?: string;
|
||
}
|
||
export type AutoDiscoverAllResult = {
|
||
services : BleService[];
|
||
characteristics : BleCharacteristic[];
|
||
}
|
||
|
||
// 服务信息类型
|
||
export type BleServiceInfo = {
|
||
uuid : string;
|
||
isPrimary : boolean;
|
||
}
|
||
|
||
// 特征值属性类型
|
||
export type BleCharacteristicProperties = {
|
||
read : boolean;
|
||
write : boolean;
|
||
notify : boolean;
|
||
indicate : boolean;
|
||
writeWithoutResponse ?: boolean;
|
||
canRead ?: boolean;
|
||
canWrite ?: boolean;
|
||
canNotify ?: boolean;
|
||
}
|
||
|
||
// 特征值信息类型
|
||
export type BleCharacteristicInfo = {
|
||
uuid : string;
|
||
serviceId : string;
|
||
properties : BleCharacteristicProperties;
|
||
}
|
||
|
||
// 错误状态码
|
||
export enum BleErrorCode {
|
||
UNKNOWN_ERROR = 0,
|
||
BLUETOOTH_UNAVAILABLE = 1,
|
||
PERMISSION_DENIED = 2,
|
||
DEVICE_NOT_CONNECTED = 3,
|
||
SERVICE_NOT_FOUND = 4,
|
||
CHARACTERISTIC_NOT_FOUND = 5,
|
||
OPERATION_TIMEOUT = 6
|
||
}
|
||
|
||
// 命令类型
|
||
export enum CommandType {
|
||
BATTERY = 1,
|
||
DEVICE_INFO = 2,
|
||
CUSTOM = 99,
|
||
TestBatteryLevel = 0x01
|
||
}
|
||
|
||
// 错误接口
|
||
export type BleError {
|
||
errCode : number;
|
||
errMsg : string;
|
||
errSubject ?: string;
|
||
}
|
||
|
||
|
||
// 连接选项
|
||
export type BleConnectOptions = {
|
||
deviceId : string;
|
||
timeout ?: number;
|
||
success ?: (result : any) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// 断开连接选项
|
||
export type BleDisconnectOptions = {
|
||
deviceId : string;
|
||
success ?: (result : any) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// 获取特征值选项
|
||
export type BleCharacteristicOptions = {
|
||
deviceId : string;
|
||
serviceId : string;
|
||
characteristicId : string;
|
||
success ?: (result : any) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// 写入特征值选项
|
||
export type BleWriteOptions = {
|
||
deviceId : string;
|
||
serviceId : string;
|
||
characteristicId : string;
|
||
value : Uint8Array;
|
||
writeType ?: number;
|
||
success ?: (result : any) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// Options for writeCharacteristic helper
|
||
export type WriteCharacteristicOptions = {
|
||
waitForResponse ?: boolean;
|
||
maxAttempts ?: number;
|
||
retryDelayMs ?: number;
|
||
giveupTimeoutMs ?: number;
|
||
forceWriteTypeNoResponse ?: boolean;
|
||
}
|
||
|
||
// 通知特征值回调函数
|
||
export type BleNotifyCallback = (data : Uint8Array) => void;
|
||
|
||
// 通知特征值选项
|
||
export type BleNotifyOptions = {
|
||
deviceId : string;
|
||
serviceId : string;
|
||
characteristicId : string;
|
||
state ?: boolean; // true: 启用通知，false: 禁用通知
|
||
onCharacteristicValueChange : BleNotifyCallback;
|
||
success ?: (result : any) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// 获取服务选项
|
||
export type BleDeviceServicesOptions = {
|
||
deviceId : string;
|
||
success ?: (result : BleServicesResult) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// 获取特征值选项
|
||
export type BleDeviceCharacteristicsOptions = {
|
||
deviceId : string;
|
||
serviceId : string;
|
||
success ?: (result : BleCharacteristicsResult) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// 蓝牙扫描选项
|
||
export type BluetoothScanOptions = {
|
||
services ?: string[];
|
||
timeout ?: number;
|
||
onDeviceFound ?: (device : BleDeviceInfo) => void;
|
||
success ?: (result : BleScanResult) => void;
|
||
fail ?: (error : BleError) => void;
|
||
complete ?: (result : any) => void;
|
||
}
|
||
|
||
// 扫描结果
|
||
|
||
// 服务结果
|
||
export type BleServicesResult = {
|
||
services : BleServiceInfo[];
|
||
errMsg ?: string;
|
||
}
|
||
|
||
// 特征值结果
|
||
export type BleCharacteristicsResult = {
|
||
characteristics : BleCharacteristicInfo[];
|
||
errMsg ?: string;
|
||
}
|
||
|
||
// 定义连接状态枚举
|
||
export enum BLE_CONNECTION_STATE {
|
||
DISCONNECTED = 0,
|
||
CONNECTING = 1,
|
||
CONNECTED = 2,
|
||
DISCONNECTING = 3
|
||
}
|
||
|
||
// 电池状态类型定义
|
||
export type BatteryStatus = {
|
||
batteryLevel : number; // 电量百分比
|
||
isCharging : boolean; // 充电状态
|
||
}
|
||
|
||
// 蓝牙服务接口类型定义 - 转换为type类型
|
||
export type BleService = {
|
||
uuid : string;
|
||
isPrimary : boolean;
|
||
}
|
||
|
||
// 蓝牙特征值接口定义 - 转换为type类型
|
||
export type BleCharacteristic = {
|
||
uuid : string;
|
||
service : BleService;
|
||
properties : BleCharacteristicProperties;
|
||
}
|
||
|
||
// PendingPromise接口定义
|
||
export interface PendingCallback {
|
||
resolve : (data : any) => void;
|
||
reject : (err ?: any) => void;
|
||
timer ?: number;
|
||
}
|
||
|
||
// 蓝牙相关接口和类型定义
|
||
export type BleDevice = {
|
||
deviceId : string;
|
||
name : string;
|
||
rssi ?: number;
|
||
lastSeen ?: number; // 新增
|
||
// 新增
|
||
serviceId ?: string;
|
||
writeCharId ?: string;
|
||
notifyCharId ?: string;
|
||
}
|
||
|
||
// BLE常规选项
|
||
export type BleOptions = {
|
||
timeout ?: number;
|
||
success ?: (result : any) => void;
|
||
fail ?: (error : any) => void;
|
||
complete ?: () => void;
|
||
}
|
||
|
||
export type BleConnectionState = number; // 0: DISCONNECTED, 1: CONNECTING, 2: CONNECTED, 3: DISCONNECTING
|
||
|
||
export type BleConnectOptionsExt = {
|
||
timeout ?: number;
|
||
services ?: string[];
|
||
requireResponse ?: boolean;
|
||
autoReconnect ?: boolean;
|
||
maxAttempts ?: number;
|
||
interval ?: number;
|
||
};
|
||
|
||
// 回调函数类型
|
||
export type BleDeviceFoundCallback = (device : BleDevice) => void;
|
||
export type BleConnectionStateChangeCallback = (deviceId : string, state : BleConnectionState) => void;
|
||
|
||
export type BleDataPayload = {
|
||
deviceId : string;
|
||
serviceId ?: string;
|
||
characteristicId ?: string;
|
||
data : string | ArrayBuffer;
|
||
format ?: number; // 0: JSON, 1: XML, 2: RAW
|
||
}
|
||
|
||
export type BleDataSentCallback = (payload : BleDataPayload, success : boolean, error ?: BleError) => void;
|
||
export type BleErrorCallback = (error : BleError) => void;
|
||
|
||
// 健康数据类型定义
|
||
export enum HealthDataType {
|
||
HEART_RATE = 1,
|
||
BLOOD_OXYGEN = 2,
|
||
TEMPERATURE = 3,
|
||
STEP_COUNT = 4,
|
||
SLEEP_DATA = 5,
|
||
HEALTH_DATA = 6
|
||
}
|
||
|
||
// Shared health notification payloads used by protocol handler and UI consumers
|
||
export type HealthSubscription = {
|
||
serviceUuid : string
|
||
charUuid : string
|
||
}
|
||
|
||
export type WbbpPacket = {
|
||
cmd : number
|
||
seq : number
|
||
payload : Uint8Array
|
||
}
|
||
|
||
export type HealthData = {
|
||
type : 'heart' | 'spo2' | 'steps' | 'raw'
|
||
cmd ?: number
|
||
seq ?: number
|
||
timestamp ?: number
|
||
heartRate ?: number
|
||
spo2 ?: number
|
||
pulse ?: number
|
||
steps ?: number
|
||
distance ?: number
|
||
calories ?: number
|
||
quality ?: number
|
||
activity ?: number
|
||
raw ?: Uint8Array
|
||
payload?: Uint8Array;
|
||
data?: Uint8Array;
|
||
}
|
||
|
||
// Platform-specific services should be imported from per-platform entrypoints
|
||
// (e.g. './app-android/index.uts' or './web/index.uts').
|
||
// Avoid re-exporting platform modules at the SDK root to prevent bundlers
|
||
// Platform-specific services should be imported from per-platform entrypoints
|
||
// (e.g. './app-android/index.uts' or './web/index.uts').
|
||
// Avoid re-exporting platform modules at the SDK root to prevent bundlers
|
||
// from pulling android.* symbols into web bundles.
|
||
// If a typed ambient reference is required, declare the shape here instead of importing implementation.
|
||
// Example lightweight typed placeholder (do not import platform code here):
|
||
// export type BluetoothService = any; // platform-specific implementation exported from platform index files
|
||
|
||
|
||
|
||
// ====== 新增多协议、统一事件、协议适配、状态管理支持 ======
|
||
export type BleProtocolType =
|
||
| 'standard'
|
||
| 'custom'
|
||
| 'health'
|
||
| 'ibeacon'
|
||
| 'mesh';
|
||
|
||
export type BleEvent =
|
||
| 'deviceFound'
|
||
| 'scanFinished'
|
||
| 'connectionStateChanged'
|
||
| 'dataReceived'
|
||
| 'dataSent'
|
||
| 'error'
|
||
| 'servicesDiscovered'
|
||
| 'connected' // 新增
|
||
| 'disconnected'; // 新增
|
||
|
||
// 事件回调参数
|
||
export type BleEventPayload = {
|
||
event : BleEvent;
|
||
device ?: BleDevice;
|
||
protocol ?: BleProtocolType;
|
||
state ?: BleConnectionState;
|
||
data ?: ArrayBuffer | string | object;
|
||
format ?: string;
|
||
error ?: BleError;
|
||
extra ?: any;
|
||
}
|
||
|
||
// 事件回调函数
|
||
export type BleEventCallback = (payload : BleEventPayload) => void;
|
||
|
||
// 多协议设备信息（去除交叉类型，直接展开字段）
|
||
export type MultiProtocolDevice = {
|
||
deviceId : string;
|
||
name : string;
|
||
rssi ?: number;
|
||
protocol : BleProtocolType;
|
||
};
|
||
|
||
export type ScanDevicesOptions = {
|
||
protocols ?: BleProtocolType[];
|
||
optionalServices ?: string[];
|
||
timeout ?: number;
|
||
onDeviceFound ?: (device : BleDevice) => void;
|
||
onScanFinished ?: () => void;
|
||
};
|
||
// Named payload type used by sendData
|
||
export type SendDataPayload = {
|
||
deviceId : string;
|
||
serviceId ?: string;
|
||
characteristicId ?: string;
|
||
data : string | ArrayBuffer;
|
||
format ?: number;
|
||
protocol : BleProtocolType;
|
||
}
|
||
// 协议处理器接口（为 protocol-handler 适配器预留）
|
||
export type ScanHandler = {
|
||
protocol : BleProtocolType;
|
||
scanDevices ?: (options : ScanDevicesOptions) => Promise<void>;
|
||
connect : (device : BleDevice, options ?: BleConnectOptionsExt) => Promise<void>;
|
||
disconnect : (device : BleDevice) => Promise<void>;
|
||
// Optional: send arbitrary data via the protocol's write characteristic
|
||
sendData ?: (device : BleDevice, payload : SendDataPayload, options ?: BleOptions) => Promise<void>;
|
||
// Optional: try to connect and discover service/characteristic ids for this device
|
||
autoConnect ?: (device : BleDevice, options ?: BleConnectOptionsExt) => Promise<AutoBleInterfaces>;
|
||
|
||
}
|
||
|
||
|
||
// 自动发现服务和特征返回类型
|
||
export type AutoBleInterfaces = {
|
||
serviceId : string;
|
||
writeCharId : string;
|
||
notifyCharId : string;
|
||
}
|
||
export type ResponseCallbackEntry = {
|
||
cb : (data : Uint8Array) => boolean | void;
|
||
multi : boolean;
|
||
};
|
||
|
||
// Result returned by a DFU control parser. Use a plain string `type` to keep
|
||
// the generated Kotlin simple and avoid inline union types which the generator
|
||
// does not handle well.
|
||
export type ControlParserResult = {
|
||
type : string; // e.g. 'progress', 'success', 'error', 'info'
|
||
progress ?: number;
|
||
error ?: any;
|
||
}
|
||
|
||
// DFU types
|
||
export type DfuOptions = {
|
||
mtu ?: number;
|
||
useNordic ?: boolean;
|
||
// If true, the DFU upload will await a write response per-packet. Set false to use
|
||
// WRITE_NO_RESPONSE (fire-and-forget) for higher throughput. Default: false.
|
||
waitForResponse ?: boolean;
|
||
// Maximum number of outstanding NO_RESPONSE writes to allow before throttling.
|
||
// This implements a simple sliding window. Default: 32.
|
||
maxOutstanding ?: number;
|
||
// Per-chunk sleep (ms) to yield to event loop / Android BLE stack. Default: 2.
|
||
writeSleepMs ?: number;
|
||
// Retry delay (ms) used by the Android write helper when gatt.writeCharacteristic
|
||
// returns false. Smaller values can improve throughput on congested stacks.
|
||
writeRetryDelayMs ?: number;
|
||
// Maximum number of immediate write attempts before falling back to the give-up timeout.
|
||
writeMaxAttempts ?: number;
|
||
// Timeout (ms) to wait for a late onCharacteristicWrite callback after all retries fail.
|
||
writeGiveupTimeoutMs ?: number;
|
||
// Packet Receipt Notification (PRN) window size in packets. If set, DFU
|
||
// manager will send a Set PRN command to the device and wait for PRN
|
||
// notifications after this many packets. Default: 12.
|
||
prn ?: number;
|
||
// Timeout (ms) to wait for a PRN notification once the window is reached.
|
||
// Default: 10000 (10s).
|
||
prnTimeoutMs ?: number;
|
||
// When true, disable PRN waits automatically after the first timeout to prevent
|
||
// repeated long stalls on devices that do not send PRNs. Default: true.
|
||
disablePrnOnTimeout ?: boolean;
|
||
// Time (ms) to wait for outstanding fire-and-forget writes to drain before issuing
|
||
// the activate/validate control command. Default: 3000.
|
||
drainOutstandingTimeoutMs ?: number;
|
||
controlTimeout ?: number;
|
||
onProgress ?: (percent : number) => void;
|
||
onLog ?: (message : string) => void;
|
||
controlParser ?: (data : Uint8Array) => ControlParserResult | null;
|
||
}
|
||
|
||
export type DfuManagerType = {
|
||
startDfu : (deviceId : string, firmwareBytes : Uint8Array, options ?: DfuOptions) => Promise<void>;
|
||
}
|
||
|
||
// Lightweight runtime / UTS shims and missing types
|
||
// These are conservative placeholders to satisfy typings used across platform files.
|
||
// UTSJSONObject: bundler environments used by the build may not support
|
||
// TypeScript-style index signatures in this .uts context. Use a conservative
|
||
// 'any' alias so generated code doesn't rely on unsupported syntax while
|
||
// preserving a usable type at the source level.
|
||
export type UTSJSONObject = any;
|
||
|
||
// ByteArray / Int are used in the Android platform code to interop with Java APIs.
|
||
// Define minimal aliases so source can compile. Runtime uses Uint8Array and number.
|
||
export type ByteArray = any; // runtime will use Java byte[] via UTS bridge; keep as any here
|
||
|
||
// Callback types used by service_manager and index wrappers
|
||
export type BleDataReceivedCallback = (data: Uint8Array) => void;
|
||
export type BleScanResult = {
|
||
deviceId: string;
|
||
name?: string;
|
||
rssi?: number;
|
||
advertising?: any;
|
||
};
|
||
|
||
// Minimal UI / framework placeholders (some files reference these in types only)
|
||
export type ComponentPublicInstance = any;
|
||
export type UniElement = any;
|
||
export type UniPage = any;
|
||
|
||
// Platform service contract (actual implementations live in per-platform entrypoints).
|
||
// Provide a lightweight interface so source-level code can rely on concrete method
|
||
// names and signatures without emitting duplicate runtime classes from this shared file.
|
||
export interface BluetoothService {
|
||
// Event emitter style
|
||
on(event: BleEvent | string, callback: BleEventCallback): void;
|
||
off(event: BleEvent | string, callback?: BleEventCallback): void;
|
||
|
||
// Scanning / discovery
|
||
scanDevices(options?: ScanDevicesOptions): Promise<void>;
|
||
|
||
// Connection management
|
||
connectDevice(deviceId: string, protocol?: string, options?: BleConnectOptionsExt): Promise<void>;
|
||
disconnectDevice(deviceId: string, protocol?: string): Promise<void>;
|
||
getConnectedDevices(): MultiProtocolDevice[];
|
||
|
||
// Services / characteristics
|
||
getServices(deviceId: string): Promise<BleService[]>;
|
||
getCharacteristics(deviceId: string, serviceId: string): Promise<BleCharacteristic[]>;
|
||
|
||
// Read / write / notify
|
||
readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<ArrayBuffer>;
|
||
writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, value: Uint8Array | ArrayBuffer, options?: WriteCharacteristicOptions): Promise<boolean>;
|
||
subscribeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: BleNotifyCallback): Promise<void>;
|
||
unsubscribeCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<void>;
|
||
|
||
// Convenience helpers
|
||
getAutoBleInterfaces(deviceId: string): Promise<AutoBleInterfaces>;
|
||
}
|
||
|
||
// Runtime protocol handler base class. Exporting a concrete class ensures the
|
||
// generator emits a resolvable runtime type that platform handlers can extend.
|
||
// Source-level code can still use the ScanHandler type for typing.
|
||
// Runtime ProtocolHandler is implemented in `protocol_handler.uts`.
|
||
// Keep the public typing in this file minimal to avoid duplicate runtime
|
||
// declarations. Consumers that need the runtime class should import it from
|
||
// './protocol_handler.uts'. |