wxmini/devices/bt_helper.js

// 引入必要的模块
// const DeviceUtil = require('./DeviceUtil');
// const BtAndroidHelper = require('./BtAndroidHelper');
// const BtIOSHelper = require('./BtIOSHelper');
// const QueueManager = require('./QueueManager');
// const DeviceManager = require('./DeviceManager');
const { CmdBase, BtCmd } = require('./../devices/bluetooth/bt_cmd');
const { EnumCmdEvent, CmdEvent } = require('./../devices/cmd_key_event');
const { addNotification } = require('./../utils/event_bus');
const BtParse = require('./../devices/bluetooth/bt_parse');
// const VolumeUtil = require('./VolumeUtil');
// const EventManager = require('./EventManager');
// const CmdBase = require('./../devices/bluetooth/bt_cmd');
const bleManager = require('./ble_manager');
const QueueManager = require('./QueueManager');

// const EnumConnectStatus = require('./EnumConnectStatus');
// const EnumOpen = require('./EnumOpen');
// const EnumSupplier = require('./EnumSupplier');
// const EnumLowDelayModeOpen = require('./EnumLowDelayModeOpen');
// const EnumLowDelayMode = require('./EnumLowDelayMode');
// const EnumPlayStatus = require('./EnumPlayStatus');




class BtHelper {

    static getInstance() {
        // if (!BtHelper._instance) {
        //     BtHelper._instance = new BtHelper();
        // }
        return BtHelper._instance;
    }

    static _instance = new BtHelper();

    static _isConnecting = false;
    static isDisConnectByOTA = false;

    // _helper;

    constructor() {
        this.timer = null;
        this.bleManager = new bleManager();
        // if (DeviceUtil.isAndroid) {
        //     this._helper = BtAndroidHelper.instance;
        // } else {
        //     this._helper = BtIOSHelper.instance;
        // }

        // QueueManager.instance.listenTask((task) => {
        //     if (!DeviceManager.instance.isWatch) {
        //         this._helper.send({ cmd: task });
        //     }
        // });
        this.queueManager = new QueueManager();
        let _this = this
        this.queueManager.clear();
        this.queueManager.listenTask((task) => {
            _this.bleManager.sendData(task);
        });

        addNotification(CmdEvent.eventName, function (event) {
            console.log("蓝牙helper：", event)
            let device = getApp().globalData.mDeviceList[0] ?? {};
            if (device.connectType != 1 && device.state != "online") {
                return;
            }
            _this.handleCommand(event, device);

        }, this)
    }

    handleCommand(event, mDevice) {
        let name = event.name;

        switch (name) {
            ///音量  设备控制手机
            case EnumCmdEvent.volume:
                var volume = event.volume;
                // if (ProviderUtil.play.isSimulate) {
                //   _isPhoneVolume = false;
                //   await VolumeUtil.setVolume(volume);
                //   Future.delayed(const Duration(milliseconds: 100), () {
                //     _isPhoneVolume = true;
                //   });
                // }
                mDevice.volume = volume;
                break;

            ///电量
            case EnumCmdEvent.battery:
                mDevice.kwh = event.kwh;
                break;

            ///低时延模式  低时延模式开启 1:音乐 , 2: 游戏 , 3: movie
            case EnumCmdEvent.lowDelayMode:
                mDevice.lowDelayMode = event.lowDelayMode;
                mDevice.lowDelayModeOpen = event.lowDelayModeOpen;
                break;

            ///电量 耳机电量
            case EnumCmdEvent.batteryEarphone:
                mDevice.kwh = event.kwh;
                mDevice.kwhLeft = event.kwhLeft;
                mDevice.kwhRight = event.kwhRight;
                mDevice.kwhBox = event.kwhBox;
                break;

            ///是否支持TTS
            case EnumCmdEvent.enableTTS:
                mDevice.enableTTS = event.enableTTS;
                break;

            ///切换设备连接模式 0:未知 1：低功耗蓝牙 2：wifi类型 3：经典蓝牙(不做任何操作) 4：4G类型
            case EnumCmdEvent.switchDeviceMode:
                var deviceMode = event.deviceMode.index;
                if (deviceMode != null) {
                    L.d("switchDeviceMode======$deviceMode");
                    mDevice.deviceMode = deviceMode;
                }
                break;

            ///4G外插卡  4G虚拟卡 当前使用的sim卡
            case EnumCmdEvent.sim:
                mDevice.sim = event.sim;
                mDevice.eSim = event.eSim;
                mDevice.simIndex = event.simIndex;
                break;

            ///闹钟是否开启  闹钟周期 闹钟唤醒时间
            case EnumCmdEvent.wake:
                mDevice.wakeSwitch = event.wakeSwitch;
                mDevice.wakeCycle = event.wakeCycle;
                mDevice.wakeHour = event.wakeHour;
                mDevice.wakeMinutes = event.wakeMinutes;
                break;

            ///休眠是否开启 休眠时间
            case EnumCmdEvent.sleep:
                mDevice.sleepSwitch = event.sleepSwitch;
                mDevice.sleepHour = event.sleepHour;
                mDevice.sleepMinutes = event.sleepMinutes;
                break;

            ///版本和型号
            case EnumCmdEvent.version:
                mDevice.version = event.version;
                var clientType = mDevice.clientType ?? "";

                ///验证设备首页固件升级图标
                // getCheckOTAIndexProvider.refresh();

                // // TODO 校验版本是否升级
                // if (clientType.isNotEmpty) {
                //     var response = await DeviceService.getDeviceDetail(
                //         clientType: clientType,
                //         version: event.version,
                //         type: mDevice.deviceMode ?? EnumDeviceMode.ble.index,
                //     );

                //     if (response.isSuccess) {
                //         DeviceDetailEntity ? updateData = response.data;
                //         if (updateData != null) {
                //             // mDevice.typeList = updateData.typeList;
                //             // 是否强制升级0-无更新 1-是,2-否
                //             var force = updateData.isEnforcement;
                //             var hasNewVersion = force == 1 || force == 2;


                //             // if (force == 1) {
                //             //     EventManager.fire(OtaUpdateEvent(updateData: updateData));
                //             // }
                //         }
                //     }
                // }
                break;

            ///云小微授权
            case EnumCmdEvent.auth:
                var authInfo = event.authInfo;
                mDevice.authInfo = authInfo;
                // QQMusicManager.auth(authInfo: authInfo);
                // CacheUtil.saveDSN(dsn: authInfo.dsn ?? "");
                break;
            case EnumCmdEvent.btMac:
                var btMac = event.btMac;
                mDevice.btMac = btMac;
                // // 更新一下 imei
                // getDeviceImei().then((e) {
                //     mDevice.imei = e;
                // });
                break;

            ///EQ音效
            case EnumCmdEvent.eq:
                mDevice.eqs = event.eqs;
                break;

            ///payId 充流量使用
            case EnumCmdEvent.payId:
                mDevice.payId = event.payId;
                break;

            ///QQ音乐使用dsn授权
            case EnumCmdEvent.dsn:
                var dsn = event.dsn;
                mDevice.dsn = dsn;
                // //存储设备的DSN
                // await CacheUtil.saveDSN(dsn: dsn ?? "");
                // ProviderUtil.twelvePublic.wifiDeviceConnected();
                break;

            ///自动切换 0，1不能
            ///
            case EnumCmdEvent.netModeAuto:
                mDevice.netModeAuto = event.netModeAuto;
                break;

            ///解绑设备
            case EnumCmdEvent.unbind:
                //   let unbindAddress = event.item.address ?? "";
                //     if (unbindAddress != mDevice.address) {
                //         _resetList();
                //         return;
                //     }
                //     _lastConnectAddress = null;
                //     bondedDeviceData.remove(mDevice);
                //     if (mDevice.address == event.item.address) {
                //         mDevice = null;
                //     }
                //     _resetList();

                break;

            ///解绑设备
            case EnumCmdEvent.ctrlStatus:
                // List < int > ctrlList = event.ctrlStatus;
                // if (ctrlList.length == 3) {
                //     mDevice.singleClick = ctrlList[0];
                //     mDevice.doubleClick = ctrlList[1];
                //     mDevice.longPressClick = ctrlList[2];
                // }
                break;

            case EnumCmdEvent.lowPowerOpen:
                let lowPower = event.lowPowerOpen ?? 0;
                mDevice.lowPowerOpen = lowPower;
                break;

            case EnumCmdEvent.authSleepStatus:
                let pauseSleep = event.pauseSleep;
                mDevice.pauseSleep = pauseSleep;

                notifyListeners();
                break;

            ///设备信息
            case EnumCmdEvent.getDeviceInfo:
                //   List list = [];
                //   String userId = ProviderUtil.user.userModel.uid ?? "";
                //     for (var element in bondedDeviceData) {
                //         list.add({
                //             "clientType": element.clientType ?? "",
                //             "userId": userId,
                //             "deviceName": element.name ?? "",
                //             "mac": element.address,
                //             "deviceId": element.deviceId ?? 0,
                //         });
                //     }

                //     MobClickEvent.mobClickEvent(EnumMobEvent.eventDevicesConnect, params: { "devices": list });
                //     if (mDevice != null) {
                //         mDevice.imei ??= await CacheUtil.getImei(address: mDevice.address ?? "");

                //         /// 用户绑定设备
                //         await CacheUtil.addDevice(item: mDevice!);

                //         // String dsn = await CacheUtil.getDSN();
                //         // if (dsn.isEmpty) {
                //         // 获取设备dsn
                //         DeviceManager.instance.auth();
                //         // }
                //         //延迟
                //         var address = mDevice.address ?? "";
                //     bool isSuccess = await ProviderUtil.twelve.questDeviceTwelveData(address);
                //         if (isSuccess) {
                //       bool showDevice = await DeviceChannelAllPage.presentPage();
                //             if (!showDevice) {
                //                 VipOpenAiTingDialogWidget.presentPage();
                //             }
                //         }
                //     }
                //     await CacheUtil.saveConnectedDevice(list: bondedDeviceData);

                break;
            default:
                break;
        }
    }

    resetConnectState(connect) {
        // BtHelper._isConnecting = connect;
    }

    async search(stopCall) {
        let res = await this.bleManager.startScan()
        this.timer = null;
        this.timer = setTimeout(() => {
            this.stopSearch();
            if (stopCall) {
                stopCall()
            }
        }, 10000);
        // console.log(res);
        // return await this._helper.search();
    }

    async findDevices(callback) {
        this.bleManager.onBluetoothDeviceFound(callback)
        // return await this._helper.search();
    }

    async stopSearch() {
        clearTimeout(this.timer);
        this.timer = null;
        await this.bleManager.stopScan();
    }

    async _connectSuccess() {
        this.checkDevice()
        this.getDeviceInfo()

    }

    async connect(data, onChanged) {
        // await this._helper.connect({ data, onChanged, isClick });

        clearTimeout(this.timer);
        this.timer = null;
        this.bleManager.stopScan()
        var res = await this.bleManager.connectToDevice(data);
        console.log(res ? '连接成功' : '连接失败');
        // this.setData({ connectedDeviceId: deviceId });
        if (res === false) {
            console.log("连接失败")
            this.disconnect(data)
            if (onChanged) {
                onChanged(false)
            }
            return
        }
        const serviceId = await this.bleManager.discoverServices(data.deviceId);
        if (serviceId == "") {
            console.log("连接失败")
            this.disconnect(data)
            if (onChanged) {
                onChanged(false)
            }
            return
        }
        // this.setData({ services });
        console.log("服务ID:" + serviceId)

        var characteristics = await this.bleManager.discoverCharacteristics(data.deviceId, serviceId)
        if (characteristics == "") {
            console.log("连接失败")
            this.disconnect(data)
            if (onChanged) {
                onChanged(false)
            }
            return
        }
        console.log('device特征值:', characteristics)
        let uuids = ["AB01", "FFC1"];
        for (let i = 0; i < characteristics.length; i++) {
            let charc = characteristics[i];
            if (uuids.includes(charc.uuid.toUpperCase())) {
                console.log('有特征值：', charc.uuid);
            }

            if (charc.properties.notify) {
                console.log('订阅数据：', charc.uuid);
                // 订阅的
                this.bleManager.notifyCharacteristicValueChange(charc.uuid, (res) => {
                    BtParse.parseTLV(res);
                })
            }
            if (charc.properties.write || charc.properties.writeWithoutResponse) {
                // 写入的
                this.bleManager.setWrite(charc, charc.uuid)
                setTimeout(() => {
                    this._connectSuccess()
                }, 100);
                if (onChanged) {
                    onChanged(true)
                }
            }



            // if (charc.properties.read) {
            //     var chara = await this.bleManager.readCharacteristicValue(charc.uuid,)
            // }
        }


        // this.setData({ characteristics: { ...this.data.characteristics, [service.uuid]: characteristics } });

    }

    async disconnect() {
        this.bleManager.disconnect()
    }

    async dispose() {
        // await this._helper.dispose();
    }

    async sendNow(cmd) {
        if (cmd) {
            this.bleManager.sendData(cmd)
        }
    }
    async send(cmd, type) {
        if (cmd) {
            this.queueManager.addTask(cmd)
        }
        // QueueManager.instance.addTask({ task: cmd });
    }

    // onLoad: function () {
    //     bleManager = new bleManager();
    //     this.initBluetooth();
    //   }

    async initBluetooth(callback) {
        let adpter = await this.bleManager.initBluetoothAdapter((res) => {
            if (!res) {
                wx.showToast({
                    title: '请开启蓝牙功能',
                    icon: 'none'
                })
                if (callback) {
                    callback(false, false)
                }
                return
            }
        });
        // console.log(res)


        this.bleManager.checkBluetoothPermission(function (per) {
            if (!per) {
                wx.showToast({
                    title: '没有蓝牙权限',
                    icon: 'none'
                })
            }
            if (callback) {
                callback(adpter, per)
            }
        });
    }

    closeBle() {
        this.bleManager.closeBle()
    }

    async getConnectedDevices() {
        try {
            const connectedDevices = await this.bleManager.getConnectedDevices();
            console.log("全部设备1：", connectedDevices)
            if (connectedDevices.length) {
                // todo 已经连接上的设备
            }
            const allDevices = await this.bleManager.getAllConnectedDevices()
            console.log("全部设备2：", allDevices)
            let newDevices = connectedDevices.concat(allDevices);
            return newDevices
        } catch (error) {
            console.error(error);
            return []
        }
    }

    async checkDevice() {
        // console.log("校验设备：", BtCmd); // 输出: EarPhone Info
        this.sendNow(BtCmd.checkDevice());
        //2.0有发这个，不知道是啥
        this.send([0x54, 0x44, 0x44, 0x48, 0x01, 0x09, 0x26, 0x01, 0x01]);
    }

    async getVersion() {
        this.send(BtCmd.queryVersion());
    }

    _time() {
        return 400;
    }

    getDeviceInfo() {
        // if (DeviceManager.instance.isEarphone) {
        //     this.send(BtCmd.queryKwhEarPhone);
        //     this.send(BtCmd.queryLowDelayMode);
        //     this.send(BtCmd.queryEQ);
        //     this.send(BtCmd.queryLowPower);
        //     this.send(BtCmd.queryCtrlStatus);
        // } else {
        // this.send(BtCmd.setDevTime());

        this.send(BtCmd.queryKwh());
        this.getSleep();
        this.getAlert();
        this.send(BtCmd.queryRGB());
        this.getVolume();
        this.setVolume(8)
        this.getPauseSleep();

        this.send(BtCmd.getClientType());
        this.send(BtCmd.getIsConnect());
        this.send(BtCmd.getMac());

        // }
    }

    async getAlert() {
        this.send(BtCmd.queryAlarm());
    }

    async getSleep() {
        this.send(BtCmd.querySleep());
    }

    async setAlert(open, weekCycle, hour, minutes, channel = 1) {
        this.send(BtCmd.setAlarm({ switchStatus: open, weekCycle, hour, minutes }));
    }

    async setAutoPlay(open) {
        this.send(BtCmd.setAutoPlay({ switchStatus: open }));
    }

    async getAutoPlay() {
        this.send(BtCmd.getAutoPlay);
    }

    async setLowKwhWarningTone(notify) {
        this.send(BtCmd.setLowKwhWarningTone({ notify }));
    }

    async setPauseSleep(time) {
        this.send(BtCmd.setSleepAfterPlayPause({ time }));
    }

    async getPauseSleep() {
        this.send(BtCmd.querySleepAfterPlayPause());
    }

    async setRGB(r, g, b) {
        this.send(BtCmd.setRGB({ r, g, b }));
    }

    async setSleep(open, hour, minutes) {
        let defaultMin = minutes ?? 10;
        let defaultHour = hour ?? 0;
        this.send(BtCmd.setSleep({ switchStatus: open, defaultHour, defaultMin }));
    }

    async setTime() {
        console.log("setTime========111")
        // this.send(BtCmd.setTime());
    }

    async setVolume(volume) {
        // VolumeUtil.setVolume(volume, { hideVolumeView: true });

        const phoneMax = 15;//await VolumeUtil.getMaxVolume();
        const result = Math.floor(CmdBase.volumeMax * volume / phoneMax);

        console.log(`phoneMax=${phoneMax}, deviceMax=${CmdBase.volumeMax}, setVolume=${volume}, result=${result}`);

        this.send(BtCmd.setVolume(8));
    }

    async getVolume() {
        this.send(BtCmd.queryVolume());
    }

    stop() {
        // EventManager.fire({ event: 'playStatus', playStatus: EnumPlayStatus.stop.index });
    }

    next() {
        // TODO: implement next
    }

    pause() {
        // EventManager.fire({ event: 'playStatus', playStatus: EnumPlayStatus.pause.index });
    }

    play() {
        // TODO: implement play
    }

    previous() {
        // TODO: implement previous
    }

    startVoiceRecordResponse(supplier) {
        console.log(`回调开始录音：${supplier}`);
        // switch (supplier) {
        //     case EnumSupplier.jieLi:
        //         this.send(BtCmd.jlStartVoiceResponse);
        //         break;
        //     case EnumSupplier.lingXin:
        //         this.send(BtCmd.lxStartVoiceResponse);
        //         break;
        //     case EnumSupplier.qiXinWei:
        //         this.send(BtCmd.b1StartVoiceResponse);
        //         break;
        // }
    }

    stopVoiceRecordResponse(supplier) {
        console.log(`回调结束录音：${supplier}`);
        // switch (supplier) {
        //     case EnumSupplier.jieLi:
        //         this.send(BtCmd.jlStopVoiceResponse());
        //         break;
        //     case EnumSupplier.lingXin:
        //         this.send(BtCmd.lxStopVoiceResponse());
        //         break;
        //     case EnumSupplier.qiXinWei:
        //         this.send(BtCmd.b1StopVoiceResponse());
        //         break;
        // }
    }

    async getLowDelayMode() {
        this.send(BtCmd.queryLowDelayMode());
    }

    async setLowDelayMode(open, mode) {
        // 0 open,
        // 1 close,
        // mode 1:音乐 , 2: 游戏 , 3: movie
        this.send(BtCmd.setLowDelayMode({ open, mode }));
    }

    async setLowPowerMode(isOpen) {
        this.send(BtCmd.setLowPowerMode({ isOpen: isOpen ? EnumOpen.open : EnumOpen.close }));
    }

    async queryLowPower() {
        this.send(BtCmd.queryLowPower());
    }

    async setCtrlStatus(singleClick, doubleClick, longClick) {
        this.send(BtCmd.setCtrlStatus({ singleClick, doubleClick, longClick }));
    }

    async getEQ() {
        this.send(BtCmd.queryEQ());
    }

    async setEQ(list) {
        this.send(BtCmd.setEQ({ list }));
    }

    async queryLowKwhWarningTone() {
        this.send(BtCmd.queryLowKwhWarningTone());
    }

    async changeChannelCallBack() {
        this.send(Uint8Array.from([0x54, 0x44, 0x44, 0x48, 0x01, 0x0a, 0x29, 0x02, 0x00, 0x01]));
        this.send(Uint8Array.from([0x54, 0x44, 0x44, 0x48, 0x01, 0x09, 0x39, 0x01, 0x00]));
    }

    /* 黑胶音箱的指令 */
    // 壁纸指令 1开始， 0结束
    static wallPaper(value) {
        this.send(BtCmd.wallPaper(value));
    }
    // 壁纸指令 
    static wallPaperData(value) {
        this.send(BtCmd.wallPaperData(value));
    }
    // 背景图指令
    static backgroudImg(value) {
        this.send(BtCmd.backgroudImg(value));
    }   // 背景图指令
    static backgroudImgData(value) {
        this.send(BtCmd.backgroudImgData(value));
    }
    // OTA指令
    static otaCmd(value) {
        this.send(BtCmd.otaCmd(value));
    } static otaData(value) {
        this.send(BtCmd.otaData(value));
    }
}

// 导出 BtHelper 类
// const btHelper = new BtHelper();

module.exports = { BtHelper }