apls8000/app.js

// app.js
App({
    data: {//数据
        worker: null,//线程句柄
        recorder: null,//录音设备句柄
        wavFilePath: '',//wav文件路径
        readFileTimes: 0,//读取本地文件次数
        imuStartTimestamp: 0,//IMU开始时间戳
    },
    onLaunch() {
        // 展示本地存储能力
        const logs = wx.getStorageSync('logs') || []
        logs.unshift(Date.now())
        wx.setStorageSync('logs', logs)

        // TODO登录
        wx.login({
            success: (res) => {
                // 发送 res.code 到后台换取 openId, sessionKey, unionId
            }
        })
    },
    //创建线程(listener:线程监听服务程序)
    createWorker(listener) {
        if (this.data.worker == null) {
            this.data.worker = wx.createWorker("worker/worker.js")

            //设置线程监听服务程序
            if (typeof (listener) === 'function') {
                this.setWorkerListener(listener)

                //发消息给worker，加载wasm
                this.data.worker.postMessage({
                    message: 'MAIN_WORKER_LOAD_WX_WASM',
                    data: ''
                })
            }
        }
    },
    //设置线程监听服务程序
    setWorkerListener(listener) {
        if (this.data.worker != null) {
            this.data.worker.onMessage(listener)
        }
    },
    //创建录音设备，并监听录音完成事件
    createRecorder() {
        const self = this

        //获得录音机句柄
        this.data.recorder = wx.getRecorderManager()

        //注册录音回调函数（录音长度达到设定值后执行）
        this.data.recorder.onFrameRecorded((res) => {
            //从返回参数中解构变量isLastFrame和frameBuffer， 其中frameBuffer是二进制数据数组，不能直接读写
            const { isLastFrame, frameBuffer } = res

            //录音时长到了最大值，重新开始录音
            if (isLastFrame) {
                self.startRecord()
            }

            //将数据发送给worker
            self.data.worker.postMessage({
                message: 'MAIN_WORKER_AUDIO_DATA',
                data: frameBuffer
            })

            // //将数据发送给worker
            // self.data.worker.postMessage({
            //     message: 'MAIN_WORKER_SAVE_AUDIO_DATA',
            //     data: frameBuffer
            // })
        })

        //开始录音
        setTimeout(this.startRecord, 2000)
    },
    //开始录音
    startRecord() {
        if (this.data.recorder != null) {
            let options = {}

            //组织录音参数
            options.duration = 600000 //最长连续录音10分钟
            options.sampleRate = 48000 //采样频率
            options.encodeBitRate = 320000 //TODO，编码率，不知道干什么用的
            options.numberOfChannels = 1 //单通道采样
            options.format = "pcm"
            options.frameSize = "22" //单位kB（数据不会太准确，因此需要缓存数据以实施成帧操作）

            //启动录音
            this.data.recorder.start(options)
        }
    },
    //保存音频文件
    //buffer:录音数据，为二进制单字节数据数组(byte)
    saveAduioDataToBin(buffer) {
        console.log("收到保存消息")
        let fileSystemManager = wx.getFileSystemManager()

        try {
            fileSystemManager.appendFileSync(wx.env.USER_DATA_PATH + "/IPS8000.bin", buffer, 'binary')
            return { code: 1, data: 'ok' }
        } catch (e) {
            return { code: 0, data: e }
        }
    },
    //打开蓝牙适配器
    openBleAdapter() {
        let self = this

        wx.openBluetoothAdapter({
            mode: "central",
            success: function (res) {//打开成功，开始扫描周边设备
                wx.startBluetoothDevicesDiscovery({
                    allowDuplicatesKey: true,
                    interval: 2000,//2秒扫描一次
                    powerLevel: "medium",
                    success() {
                        self.monitorBleBtsScanResult()
                    }
                })
            },
            fail: function (err) {//打开失败
                console.log("open ble fail", err)
                setTimeout(() => {
                    self.openBleAdapter()
                }, 3000)
            }
        })

        //this.monitorBleBtsScanResult();


        // // 监听扫描到新设备事件
        // wx.onBluetoothDeviceFound((res) => {
        //     console.log("扫描到了蓝牙设备")
        //     res.devices.forEach((device) => {
        //         console.log('Device Found', device)
        //     })
        // })
    },
    //开始扫描周边蓝牙设备
    startScanNearbyBleBts() {
        let self = this

        //扫描周边设备
        wx.startBluetoothDevicesDiscovery({
            allowDuplicatesKey: true,//允许重复上报已扫描到的设备
            interval: 3000,//3秒扫描一次
            powerLevel: "medium",
            success: function () {
                self.monitorBleBtsScanResult()//监听蓝牙基站扫描结果
            },
            fail: function () {
                //500毫秒之后重新扫描
                setTimeout(self.startScanNearbyBleBts, 500)
            }
        })
    },
    //监听蓝牙基站扫描结果
    monitorBleBtsScanResult() {
        let self = this
        wx.onBluetoothDeviceFound((res) => {
            let findFlag = 0//发现系统基站标识符
            let bleBtsDataList = []//蓝牙基站数据队列

            //遍历蓝牙设备队列
            res.devices.forEach((element) => {
                if (element.name && element.name.length == 23) {

                    let bleName = element.name
                    let subName = bleName.slice(-10)

                    //该设备为本系统设备
                    if (subName === "IPS8000BLE") {
                        if (!findFlag) {
                            findFlag = 1//发现系统基站
                        }

                        let macAddress = bleName.substring(0, 12);//BLE的mac地址
                        let rssi = -10000;
                        if (element.RSSI) {
                            rssi = element.RSSI//接收电平强度
                        }

                        //保存扫描结果
                        let item = {}
                        item['mac'] = macAddress;
                        item['rssi'] = rssi
                        bleBtsDataList.push(item)
                    }
                }
            })

            //成功监听到本系统蓝牙设备
            if (findFlag) {
                //组织本次监听到的蓝牙基站数据
                self.organizeBleBtsData(bleBtsDataList)
            }
        })
    },
    //按照wasm模块所需格式组织蓝牙基站数据
    organizeBleBtsData(bleBtsList) {
        let listLen = 0
        let bleBtsDataList = []//蓝牙基站数据队列
        let rssi = 0
        let strMac = ""
        let macLen = 0
        let oneHexChar = ""
        let oneHexCharValue = 0

        //没有蓝牙基站
        if (!bleBtsList || bleBtsList.length <= 0) {
            return
        }

        //队列长度
        listLen = bleBtsList.length
        if (listLen > 9) {
            listLen = 9//最多9个蓝牙基站
        }

        ////按照WASM模块所需数据格式组织蓝牙基站数据
        bleBtsDataList.push(1)//蓝牙基站有效标识符置1
        bleBtsDataList.push(listLen)//蓝牙基站个数

        //组织RSSI和MAC
        for (let i = 0; i < listLen; i++) {
            rssi = bleBtsList[i].rssi
            bleBtsDataList.push(rssi)//RSSI

            strMac = bleBtsList[i].mac//mac地址16进制字符串
            macLen = strMac.length
            if (macLen == 12) {
                for (let j = 0; j < macLen; j++) {
                    oneHexChar = strMac[j]
                    oneHexCharValue = this.hexCharToValue(oneHexChar)
                    bleBtsDataList.push(oneHexCharValue)//MAC
                }
            } else {
                console.log("长度错误")
            }
        }

        //把数据发送给worker
        if (bleBtsDataList.length > 3) {
            if (this.data.worker != null) {
                this.data.worker.postMessage({
                    message: 'MAIN_WORKER_BLE_BTS_DATA',
                    data: bleBtsDataList
                })
            }
        }
    },
    hexCharToValue(char) {
        // 定义16进制字符到数值的映射  
        const hexValues = {
            '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7,
            '8': 8, '9': 9, 'A': 10, 'B': 11, 'C': 12, 'D': 13, 'E': 14, 'F': 15,
            'a': 10, 'b': 11, 'c': 12, 'd': 13, 'e': 14, 'f': 15
        };

        // 查找字符对应的值  
        return hexValues[char];
    },
    //停止扫描蓝牙设备
    stopScanNearbyBle() {
        let self = this
        wx.stopBluetoothDevicesDiscovery({
            success: function () {
                wx.offBluetoothDeviceFound(function () { })
            },
            fail: function () {
                console.log("没有扫描到基站")
                setTimeout(self.stopScanNearbyBle, 3000)
            }
        })
    },
    //启动加速度计
    startImu() {
        wx.stopAccelerometer()//停止加速度传感器

        //启动加速度传感器，20毫秒采集一次加速度
        wx.startAccelerometer({ interval: "game" })

        //监听加速度传感器
        wx.onAccelerometerChange(this.onAccelerometerChange)

        //生成IMU开始时间戳
        this.data.imuStartTimestamp = new Date().getTime()
    },
    //监测三轴加速度计的变化
    onAccelerometerChange(res) {
        let timestamp = new Date().getTime() - this.data.imuStartTimestamp; //生成时间戳

        let item = {}
        item.timestamp = timestamp
        item.x = res.x
        item.y = res.y
        item.z = res.z

        //把数据发送给线程
        if (this.data.worker != null) {
            this.data.worker.postMessage({
                message: 'MAIN_WORKER_ONE_ACC_DATA',//加速度数据
                data: item
            })
        }
    },
})