更新记录

1.0.1（2025-08-11）

  1. 增加实时监听接口

1.0.0（2025-08-03）

蓝牙、定位

平台兼容性

云端兼容性

阿里云 腾讯云 支付宝云
√ √ √

uni-app(4.07)

Vue2 Vue2插件版本 Vue3 Vue2插件版本 Chrome Safari app-vue app-vue插件版本 app-nvue app-nvue插件版本 Android Android插件版本 iOS iOS插件版本 鸿蒙
√ 1.0.0 √ 1.0.0 - - √ 1.0.0 √ 1.0.0 5.0 1.0.0 12 1.0.0 -
微信小程序 支付宝小程序 抖音小程序 百度小程序 快手小程序 京东小程序 鸿蒙元服务 QQ小程序 飞书小程序 快应用-华为 快应用-联盟
- - - - - - - - - - -

uni-app x(4.07)

Chrome Safari Android Android插件版本 iOS iOS插件版本 鸿蒙 微信小程序
- - 5.0 1.0.0 12 1.0.0 - -

其他

多语言 暗黑模式 宽屏模式
√ √ √

欧姆龙血压计、血糖仪、体脂仪、血氧仪

集成步骤

  1. 登陆欧姆龙https://sdkb.omronhealthcare.com.cn/admin/login?redirect=/index创建应用，申请授权时需要绑定包名
  2. 拷贝demo里的AndroidManifest.xml、Info.plist文件到项目根目录
  3. 集成插件，集成插件步骤请参考 https://www.cnblogs.com/wenrisheng/p/18323027

接口文档


import {
    UTSOmron
} from "@/uni_modules/wrs-uts-omron"
  • 初始化SDK，一般放到onLaunch里，Android如果因为热更新会重复调用时会有红色日志，可以不用理它，正常重新启动是不会有的

        // 启动的时候调用一次就可以了
        UTSOmron.sdkInit()
  • 注册appkey Android需要放到获取了蓝牙定位结果后调用，参考demo iOS因为网络授权问题，需要在监听网络状态UTSOmron.onCellularDataRestrictionDidUpdateNotifier后再此调用，参考demo

var isAndroid = true
switch (uni.getSystemInfoSync().platform) {
    // android
    case 'android':
        isAndroid = true
        break;
    case 'ios':
        isAndroid = false
        break;
    default:

        break;
}
let appKey = "8fa41e756ec74c63b3fef049254fffa2"
let params = {}
// 是否是在线模式
let isOnline = true
if (isAndroid) { // android
    let androidPackageSecret = "addacdcd84d56e8e8dda59808a2e17f58a005ed5d0c1adb41739db874dd718f0"
    if (isOnline) {
        // 在线模式 userID传进去
        params.appKey = appKey
        params.packageSecret = androidPackageSecret
        params.licenseContent = "" // licenseContent为空字符串
        params.userID = "xxx"
    } else {
        // 离线模式
        params.appKey = appKey
        params.packageSecret = androidPackageSecret
        params.licenseContent = "xxxx"
        params.userID = "" // userID为空字符串
    }

} else { // ios 
    let iosPackageSecret = "72f979be74e2ff3e857d33faf9fe0026a07f93f46499015a6564a066d6953071"
    let iosPackageName = "com.yuegeen.syjk"
    if (isOnline) {
        // 在线模式 userID传进去
        params.appKey = appKey
        params.packageName = iosPackageName
        params.packageSecret = iosPackageSecret
        // params.userID = "xxxx"
    } else {
        // 离线模式
        params.appKey = appKey
        params.packageName = iosPackageName
        params.packageSecret = iosPackageSecret
        params.licenseContent = "xxxx"
    }
    if (timeout) {
        params.timeout = timeout
    }
}
UTSOmron.requestIdentifier(params, (resp) => {
    if (isAndroid) {
        let opt = resp.opt
        if (opt == "onSuccess") {
            console.log("SDK初始化成功")
        } else {
            console.log("SDK初始化失败:" + JSON.stringify(resp))
        }
    } else {
        let flag = resp.flag
        switch (flag) {
            case 0: {
                console.log("OMRONLib未初始化")
            }
            break;
            case 1: {
                console.log("OMRONLib初始化成功")
            }
            break;
            case 2: {
                console.log("appKey或ekiKey错误")
            }
            break;
            case 3: {
                console.log("ekiKey过期")
            }
            break;
            case 4: {
                console.log("包名验证失败")
            }
            break;
            case 5: {
                console.log("当前用户已冻结")
            }
            break;
            case 6: {
                console.log("指纹授权量超过")
            }
            break;
            case 7: {
                console.log("网络异常")
            }
            break;
            case 8: {
                console.log("指纹验证失败")
            }
            break;
            default: {
                console.log("requestIdentifier error:" + JSON.stringify(resp))
            }
            break;
        }
    }
})
  • 监听网络请求授权状态，仅支持iOS

UTSOmron.onCellularDataRestrictionDidUpdateNotifier((resp) => {
    let status = resp.status
    switch (status) {
        // restrictedStateUnknown
        case 0:
            break;
            // restricted
        case 1:
            this.requestIdentifier(1)
            break;
            //notRestricted
        case 2:
            this.requestIdentifier(1)
            break;
        default:
            break;
    }
})
  • 监听设备扫描绑定状态

// 这个接口一定要调用，否则iOS添加设备的时候会闪退
UTSOmron.onStatus((resp) => {
    // this.showMsg("onStatus:" + JSON.stringify(resp))
    let status = resp.status
    switch (status) {
        // OMRONLIB_SCAN,                //开始扫描
        case 0:
            this.showMsg("开始扫描")
            break;
            // OMRONLIB_CONNECT,             //开始链接
        case 1:
            this.showMsg("开始链接")
            break;
            // OMRONLIB_SYNC_DATA,            //开始数据同步
        case 2:
            this.showMsg("开始数据同步")
            break;
            // OMRONLIB_SYNC_DATA_SUCCESS,    //数据同步成功
        case 3:
            this.showMsg("数据同步成功")
            break;
            // OMRONLIB_SYNC_DATA_ERROR,      //数据同步失败
        case 4:
            this.showMsg("数据同步失败")
            break;
            // OMRONLIB_DISCONNECTED          //断开链接
        case 5:
            this.showMsg("断开链接")
            break;
        default:
            break;
    }
})
  • 扫描蓝牙设备

let params = {}
params.deviceCategory = 0 // 0:所有设备 1:血压计 2: 血糖仪 4：体脂仪 5: 血氧
if (this.isAndroid) {
    params.scanPeriod = 30 // 扫描周期
}
UTSOmron.startBindScan(params, (resp) => {
    // console.log("startBindScan callback:" + JSON.stringify(resp))
    if (this.isAndroid) { // android
        let opt = resp.opt
        switch (opt) {
            case "onBleScanFailure": {
                UTSOmron.stopScan()
                let errMsg = resp.errMsg
                this.showToast(errMsg)
            }
            break;
            case "onCycleEnd": {
                UTSOmron.stopScan()
            }
            break;
            case "onBleScan": {
                // 扫描到设备
                let device = resp.device
                let name = device.name
                let isExist = false
                for (let i = 0; i < this.deviceArray.length; i++) {
                    if (name == this.deviceArray[i].name) {
                        isExist = true
                        break
                    }
                }
                if (!isExist) {
                    this.deviceArray.push(device)
                }
            }
            break;
            default:
                break;
        }
    } else { // ios
        let status = resp.status
        if (status == 0) { // 扫描到设备
            let device = resp.device
            if (device) { //
                let serialNum = device.serialNum
                let isExist = false
                for (let i = 0; i < this.deviceArray.length; i++) {
                    if (serialNum == this.deviceArray[i].serialNum) {
                        isExist = true
                        break
                    }
                }
                if (!isExist) {
                    this.deviceArray.push(device)
                }
            }
        } else if (status != 16) { // 扫描到期不提示

            let desc = UTSOmron.getOMRONSDKStatusDesc({
                status: status
            })
            this.showToast(desc)
        }
    }
})
  • 停止扫描

if (this.isAndroid) { // Android
    UTSOmron.stopScan()
} else { // iOS
    UTSOmron.stopScanBindDevices()
}
  • 根据设备类型分别绑定血压计、血糖仪、体脂仪、血氧仪

let device = this.deviceArray[i]
let deviceCategory = device.deviceCategory
switch (deviceCategory) {
    // 血压计
    case 1: {
        let params = {}
        params.deviceType = device.deviceType
        if (this.isAndroid) {
            params.address = device.address
        } else {
            params.deviceSerialNum = device.name
        }

        // 绑定血压计
        UTSOmron.bindBpDevice(params, (resp) => {
            if (this.isAndroid) { // android
                let opt = resp.opt
                switch (opt) {
                    // 绑定失败
                    case "onFailure": {
                        this.showToast("血压计绑定失败：" + JSON.stringify(resp))
                    }
                    break;
                    // 绑定成功
                    case "onBindComplete": {
                        console.log("血压计绑定成功" + JSON.stringify(resp))
                        this.showMsg("血压计绑定成功" + JSON.stringify(resp))
                        let userIndex = "0"

                        // 血压计设备信息保存到本地
                        let deviceSerialNum = device.address;
                        let deviceInfo = resp.deviceInfo
                        let otherParams = resp
                        localStoreSaveOtherParams(deviceCategory, device.deviceType,
                            deviceSerialNum,
                            userIndex,
                            deviceInfo, otherParams)

                        // 血压数据保存到本地
                        let dataList = resp.dataList
                        if (dataList && dataList.length > 0) {
                            saveBpDataList(dataList)
                        }

                    }
                    break;
                    case "onDataReadComplete": {

                    }
                    break;
                    default:
                        break;
                }
            } else { // ios
                let status = resp.status
                if (status === 0) { // 绑定成功
                    this.showMsg("血压计绑定成功:" + JSON.stringify(resp))
                    this.showToast("血压计绑定成功:" + JSON.stringify(resp))
                    let deviceId = resp.deviceId
                    let userIndex = ""
                    if (deviceId.length > 1) {
                        userIndex = 0
                    } else {
                        userIndex = deviceId
                    }
                    // 血压计设备信息保存到本地
                    let deviceSerialNum = device.name
                    localStoreSave(deviceCategory, device.deviceType, deviceSerialNum, userIndex,
                        resp
                        .deviceInfo)

                    // 血压数据保存到本地
                    let dataList = resp.dataList
                    if (dataList && dataList.length > 0) {
                        saveBpDataList(dataList)
                    }

                } else {
                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }
            }
        })
    }
    break;
    // 血糖仪
    case 2: {
        if (this.isAndroid) {
            let params = {}
            params.deviceType = device.deviceType
            params.address = device.address
            // 绑定血糖仪
            UTSOmron.bindBgDevice(params, (resp) => {
                let opt = resp.opt
                switch (opt) {
                    case "onFailure": {
                        this.showToast(resp.errMsg)
                    }
                    break;
                    case "onBindComplete": {
                        this.showMsg("血糖仪绑定成功" + JSON.stringify(resp))
                        this.showToast("血糖仪绑定成功" + JSON.stringify(resp))
                        let userIndex = "0"

                        // 血糖仪设备信息保存到本地
                        let deviceSerialNum = device.address;
                        let deviceInfo = resp.deviceInfo
                        let otherParams = resp
                        localStoreSaveOtherParams(deviceCategory, device.deviceType,
                            deviceSerialNum,
                            userIndex,
                            deviceInfo, otherParams)

                        // localStoreSave(deviceCategory, device.deviceType, device.address,
                        //  userIndex,
                        //  resp
                        //  .deviceInfo)

                        // 血糖数据保存到本地
                        let dataList = resp.dataList
                        if (dataList && dataList.length > 0) {
                            saveBGDataList(dataList)
                        }

                    }
                    break;
                    case "onDataReadComplete": {

                    }
                    break;
                    default:
                        break;
                }
            })
        } else { // ios
            let params = {}
            params.deviceCategory = deviceCategory
            params.deviceType = device.deviceType
            params.deviceSerialNum = device.serialNum
            UTSOmron.scanAllDevices(params, (resp) => {
                let status = resp.status
                if (status === 0) { // 扫描成功
                    let deviceSerialNum = resp.deviceSerialNum
                    let bindParams = {}
                    bindParams.uuid = resp.device.uuid
                    bindParams.deviceType = device.deviceType
                    bindParams.deviceSerialNum = deviceSerialNum

                    UTSOmron.bindBgDevice(bindParams, (bindResp) => {
                        this.showMsg("血糖仪绑定结果" + JSON.stringify(bindResp))
                        let bindStatus = bindResp.status
                        if (bindStatus == 0) { // 成功

                            this.showMsg("血糖仪绑定成功" + JSON.stringify(bindResp))
                            let userIndex = "1"

                            // 血糖仪设备信息数据保存到本地
                            localStoreSave(deviceCategory, device.deviceType,
                                deviceSerialNum,
                                userIndex, bindResp
                                .deviceInfo)

                            // 血糖数据保存到本地
                            let dataList = bindResp.dataList
                            if (dataList && dataList.length > 0) {
                                saveBGDataList(dataList)
                            }

                        } else {

                            let desc = UTSOmron.getOMRONSDKStatusDesc({
                                status: bindStatus
                            })
                            this.showMsg("血糖仪绑定失败:" + desc)
                        }
                    })
                } else { // 扫描失败
                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }
            })
        }

    }
    break;
    //  体脂仪
    case 4: {
        let params = {}
        params.deviceType = device.deviceType
        params.birth = "2020-01-01"
        params.sex = "Male" // Male、Female
        params.height = "175"
        if (this.isAndroid) {

        } else {
            params.userIndex = [1]
        }
        // 绑定体脂仪
        UTSOmron.bindBfDevice(params, (resp) => {
            let opt = resp.opt
            if (this.isAndroid) {
                switch (opt) {
                    // 绑定失败
                    case "onFailure": {
                        this.showToast(resp.errMsg)
                    }
                    break;
                    case "onBindBodyFatComplete": {
                        this.showMsg("体脂仪绑定成功" + JSON.stringify(resp))
                        this.showToast("体脂仪绑定成功")
                        let userIndex = "0"

                        // 体脂仪设备信息保存到本地
                        let deviceSerialNum = device.address;
                        let deviceInfo = resp.deviceInfo
                        let otherParams = resp
                        localStoreSaveOtherParams(deviceCategory, device.deviceType,
                            deviceSerialNum,
                            userIndex,
                            deviceInfo, otherParams)

                        // localStoreSave(deviceCategory, device.deviceType, device.address,
                        //  userIndex,
                        //  resp
                        //  .deviceInfo)
                        // 体脂数据保存到本地
                        let dataList = resp.dataList
                        if (dataList && dataList.length > 0) {
                            saveBFDataList(dataList)
                        }

                    }
                    break;
                    case "onBodyFatDataReadComplete": {

                    }
                    break;
                    default:
                        break;
                }
            } else {
                switch (opt) {
                    case "statusChange": {
                        let status = resp.status
                        if (status == 4) {
                            //蓝牙取消配对
                        }
                    }
                    break;
                    case "userIndexChange": {
                        this.showToast("绑定设备……")
                    }
                    break;
                    case "complete": {
                        let status = resp.status
                        if (status === 0) { // 成功
                            this.showMsg("体脂仪绑定成功" + JSON.stringify(resp))
                            this.showToast("体脂仪绑定成功")
                            // 体脂仪设备信息保存到本地
                            localStoreSave(deviceCategory, device.deviceType, device.serialNum,
                                resp.userIndex, resp.deviceInfo)

                            // 体脂数据保存到本地
                            let dataList = resp.dataList
                            if (dataList && dataList.length > 0) {
                                saveBFDataList(dataList)
                            }

                        } else {
                            let desc = UTSOmron.getOMRONSDKStatusDesc({
                                status: status
                            })
                            this.showToast(desc)
                        }
                    }
                    break;
                    default:
                        break;
                }
            }

        })
    }
    break;
    // 血氧仪
    case 5: {
        let params = {}
        params.deviceType = device.deviceType
        if (this.isAndroid) {

        } else {
            params.deviceSerialNum = device.serialNum
        }
        // 绑定血氧仪
        UTSOmron.bindBoDevice(params, (resp) => {
            if (this.isAndroid) {
                let opt = resp.opt
                switch (opt) {
                    // 绑定失败
                    case "onFailure": {
                        this.showToast(resp.errMsg)
                    }
                    break;
                    // 绑定成功
                    case "onBoComplete": {
                        this.showMsg("血氧绑定成功" + JSON.stringify(resp))
                        this.showToast("血氧绑定成功")
                        let userIndex = "0"
                        // 血氧仪设备信息保存到本地
                        localStoreSave(deviceCategory, device.deviceType, device.address,
                            userIndex,
                            resp
                            .deviceInfo)
                        // 血氧数据保存到本地
                        let dataList = resp.dataList
                        if (dataList && dataList.length > 0) {
                            saveBODataList(dataList)
                        }

                    }
                    break;
                    case "onBoDataReadComplete": {

                    }
                    break;
                    default:
                        break;
                }
            } else {
                let status = resp.status
                if (status === 0) { // 成功
                    this.showMsg("血氧绑定成功" + JSON.stringify(resp))
                    this.showToast("血氧仪绑定成功")
                    let deviceId = resp.deviceId
                    let userIndex = "1"
                    // 血氧仪设备信息保存到本地
                    localStoreSave(deviceCategory, device.deviceType, device.serialNum,
                        userIndex, resp.deviceInfo)

                    // 血氧数据保存到本地
                    let dataList = resp.dataList
                    if (dataList && dataList.length > 0) {
                        saveBODataList(dataList)
                    }

                } else {
                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }
            }

        })
    }
    break;
    default: {
        this.showToast("无法识别的设备类别")
    }
    break;
}
  • 同步蓝牙扫描过滤本地保存的设备

let array = localStoreGetAllDevice()
if (array) {
    let deviceList = []
    for (let i = 0; i < array.length; i++) {
        let device = array[i]
        if (this.isAndroid) {
            deviceList.push({
                deviceType: device.deviceType,
                name: device.otherParams.deviceName,
                address: device.deviceSerialNum
            })
        } else {
            deviceList.push({
                deviceType: device.deviceType,
                name: device.deviceSerialNum,
                deviceCategory: device.deviceCategory,
                userIndex: device.userIndex
            })
        }

    }
    let params = {}
    params.deviceList = deviceList
    if (this.isAndroid) {
        params.scanPeriod = 30
    }
    console.log("startSyncScan params:" + JSON.stringify(params))
    UTSOmron.startSyncScan(params, (resp) => {
        if (this.isAndroid) {
            let opt = resp.opt
            switch (opt) {
                // 扫描到设备
                case "onBleScan":
                    let device = resp.device
                    let exist = false
                    for (let i = 0; i < this.dataArray.length; i++) {
                        let localDevice = this.dataArray[i]
                        if (device.name === localDevice.name) {
                            // 已经显示到界面的设备不需要重复显示
                            exist = true
                            break;
                        }
                    }
                    if (!exist) {
                        this.dataArray.push(device)
                    }
                    break;
                    // 扫描失败
                case "onBleScanFailure":
                    this.showMsg("扫描失败")
                    break;
                default:
                    break;
            }
        } else {
            let status = resp.status
            if (status == 0 && resp.device) { // 扫描到设备
                let device = resp.device
                let exist = false
                for (let i = 0; i < this.dataArray.length; i++) {
                    let localDevice = this.dataArray[i]
                    if (device.name === localDevice.name) {
                        // 已经显示到界面的设备不需要重复显示
                        exist = true
                        break;
                    }
                }
                if (!exist) {
                    this.dataArray.push(device)
                }
            } else {
                if (this.isAndroid) {
                    this.showMsg(JSON.stringify(resp))
                } else {
                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }

            }
        }

    })
} else {
    console.log("本地没有保存有设备")
}
  • 停止同步蓝牙扫描过滤本地保存的设备

UTSOmron.stopSyncScan()
  • 获取同步扫描的设备的数据

let device = this.dataArray[i]
console.log("syncData click:" + JSON.stringify(device))
let deviceCategory = device.deviceCategory
switch (deviceCategory) {
    // 血压计
    case 1: {
        let params = {}
        params.deviceType = device.deviceType
        if (this.isAndroid) {
            params.name = device.name
            params.address = device.address
        } else {
            params.deviceSerialNum = device.name
        }
        // 获取血压数据
        UTSOmron.getBpDeviceData(params, (resp) => {
            console.log("getBpDeviceData resp:" + JSON.stringify(resp))
            if (this.isAndroid) {
                let opt = resp.opt
                switch (opt) {
                    case "onFailure":
                        let errMsg = resp.errMsg
                        this.showToast(errMsg)
                        break;
                    case "onDataReadComplete": {
                        let dataList = resp.dataList
                        saveBpDataList(dataList)
                        // 最后一条数据用来刷新界面
                        if (dataList.length > 0) {
                            this.refreshBloodPressure(dataList[dataList.length - 1])
                        }
                    }
                    break;
                    default:
                        break;
                }
            } else { // ios
                let status = resp.status
                if (status == 0) {
                    let dataList = resp.dataList
                    saveBpDataList(dataList)

                    // 最后一条数据用来刷新界面
                    if (dataList.length > 0) {
                        this.refreshBloodPressure(dataList[dataList.length - 1])
                    }

                } else if (status != 16) { // 扫描到期不提示
                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }
            }
        })
    }
    break;
    // 血糖仪
    case 2: {
        if (this.isAndroid) {
            // console.log("getBgDeviceData params:" + JSON.stringify(params))
            let dataParams = {}
            dataParams.deviceType = device.deviceType
            dataParams.address = device.address
            console.log("getBgDeviceData params:" + JSON.stringify(dataParams))
            UTSOmron.getBgDeviceData(dataParams, (resp) => {
                console.log("getBgDeviceData:" + JSON.stringify(resp))
                let opt = resp.opt
                switch (opt) {
                    case "onFailure":
                        let errMsg = resp.errMsg
                        this.showToast(errMsg)
                        break;
                    case "onDataReadComplete": {
                        let dataList = resp.dataList
                        saveBGDataList(dataList)
                        // 最后一条数据用来刷新界面
                        if (dataList.length > 0) {
                            this.refreshBlooeGlucose(dataList[dataList.length - 1])
                        }
                    }
                    break;
                    default:
                        break;
                }

            })
        } else {
            console.log("syncData device:" + JSON.stringify(device))
            let params = {}
            params.deviceCategory = deviceCategory
            params.deviceType = device.deviceType
            params.deviceSerialNum = device.name
            console.log("scanAllDevices params:" + JSON.stringify(params))
            UTSOmron.scanAllDevices(params, (resp) => {
                let status = resp.status
                if (status === 0) { // 成功
                    let dataParams = {}
                    dataParams.deviceType = device.deviceType
                    // demo里deviceSerialNum传的是name字段，需要测试下
                    dataParams.deviceSerialNum = device.name
                    dataParams.uuid = resp.device.uuid
                    UTSOmron.getBgDeviceData(dataParams, (dataResp) => {
                        console.log("getBgDeviceData resp:" + JSON.stringify(dataResp))
                        let status = dataResp.status
                        if (status == 0) {
                            let dataList = dataResp.dataList
                            saveBGDataList(dataList)
                            // 最后一条数据用来刷新界面
                            if (dataList.length > 0) {
                                this.refreshBlooeGlucose(dataList[dataList.length - 1])
                            }
                        } else if (status != 16) { // 扫描到期不提示

                            let desc = UTSOmron.getOMRONSDKStatusDesc({
                                status: status
                            })
                            this.showToast(desc)
                        }
                    })
                } else if (status != 16) { // 扫描到期不提示

                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }
            })
        }
    }
    break;
    //  体脂仪
    case 4: {
        let params = {}
        params.deviceType = device.deviceType

        params.birth = "2022-01-01"
        params.sex = "Male"
        params.height = "170"
        params.userIndex = parseInt(device.userIndex)
        if (this.isAndroid) {
            params.address = device.serialNum
            params.deviceId = device.deviceName
        } else {
            params.deviceSerialNum = device.serialNum
        }
        UTSOmron.getBfDeviceData(params, (resp) => {
            if (this.isAndroid) {
                let opt = resp.opt
                switch (opt) {
                    case "onFailure":
                        let errMsg = resp.errMsg
                        this.showToast(errMsg)
                        break;
                    case "onBodyFatDataReadComplete": {
                        let dataList = resp.dataList
                        saveBFDataList(dataList)
                        // 最后一条数据用来刷新界面
                        if (dataList.length > 0) {
                            this.refreshBodyFat(dataList[dataList.length - 1])
                        }
                    }
                    break;
                    default:
                        break;
                }
            } else {
                let status = resp.status
                if (status == 0) {
                    let dataList = resp.dataList
                    saveBFDataList(dataList)

                    // 最后一条数据用来刷新界面
                    if (dataList.length > 0) {
                        this.refreshBodyFat(dataList[dataList.length - 1])
                    }
                } else if (status != 16) { // 扫描到期不提示

                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }
            }

        })
    }
    break;
    // 血氧
    case 5: {
        let params = {}
        params.deviceType = device.deviceType
        if (this.isAndroid) {
            params.address = device.serialNum
            params.name = device.name
        } else {
            params.deviceSerialNum = device.serialNum
        }

        UTSOmron.getBoDeviceData(params, (resp) => {
            if (this.isAndroid) {
                let opt = resp.opt
                switch (opt) {
                    case "onFailure":
                        let errMsg = resp.errMsg
                        this.showToast(errMsg)
                        break;
                    case "onBoDataReadComplete": {
                        let dataList = resp.dataList
                        saveBODataList(dataList)
                        // 最后一条数据用来刷新界面
                        if (dataList.length > 0) {
                            this.refreshBloodOxygen(dataList[dataList.length - 1])
                        }
                    }
                    break;
                    default:
                        break;
                }
            } else {
                let status = resp.status
                if (status == 0) {
                    let dataList = resp.dataList
                    saveBODataList(dataList)

                    // 最后一条数据用来刷新界面
                    if (dataList.length > 0) {
                        this.refreshBloodOxygen(dataList[dataList.length - 1])
                    }
                } else if (status != 16) { // 扫描到期不提示

                    let desc = UTSOmron.getOMRONSDKStatusDesc({
                        status: status
                    })
                    this.showToast(desc)
                }
            }

        })
    }
    break;
    default: {
        this.showToast("无法识别的设备类别")
    }
    break;
}
  • 停止绑定流程

// 血压计
UTSOmron.stopBpConnect()

// 体脂仪
UTSOmron.stopBfConnect()

// 血糖仪
UTSOmron.stopBgConnect()

// 血氧仪
UTSOmron.stopBoConnect()
  • 开启设备监听

// 血压计
let deviceList = []
for (let i = 0; i < array.length; i++) {
    let device = array[i]
    if (this.isAndroid) {
        deviceList.push({
            deviceType: device.deviceType,
            name: device.otherParams.deviceName,
            address: device.deviceSerialNum
        })
    } else {
        deviceList.push({
            deviceType: device.deviceType,
            name: device.deviceSerialNum,
            deviceCategory: device.deviceCategory,
            userIndex: device.userIndex
        })
    }

}
let params = {}
params.deviceList = deviceList
UTSOmron.startBpMonitoring(bpParams, (resp)=>{
    if (this.isAndroid) {
        let opt = resp.opt
        switch(opt) {
            case "onFailure": {

            }
            break;
            case "onDataReadComplete": {
                let dataList = resp.dataList
            }
            break;
        }
    } else {
        let status = resp.status
        if(status == 0) {// 成功
            let dataList = resp.dataList
        } else { // 失败

        }
    }

})

// 血糖仪
UTSOmron.startBgMonitoring(params, (resp)=>{
    if (this.isAndroid) {
        let opt = resp.opt
        switch(opt) {
            case "onFailure": {

            }
            break;
            case "onDataReadComplete": {
                let dataList = resp.dataList
            }
            break;
        }
    } else {
        let status = resp.status
        if(status == 0) {// 成功
            let dataList = resp.dataList
        } else { // 失败

        }
    }
})

// 体脂仪
let bfParams = {}
bfParams.birth = "2020-01-01"
bfParams.sex = "Male" // Male、Female
bfParams.height = "175"
UTSOmron.startBfMonitoring(bfParams, (resp)=>{
    if (this.isAndroid) {
        let opt = resp.opt
        switch(opt) {
            case "onFailure": {

            }
            break;
            case "onBodyFatDataReadComplete": {
                let dataList = resp.dataList
            }
            break;
        }
    } else {
        let status = resp.status
        if(status == 0) {// 成功
            let dataList = resp.dataList
        } else { // 失败

        }
    }
})

// 血氧仪
let boParams = {}
UTSOmron.startBoMonitoring(params, (resp)=>{
    if (this.isAndroid) {
        let opt = resp.opt
        switch(opt) {
            case "onFailure": {

            }
            break;
            case "onBoDataReadComplete": {
                let dataList = resp.dataList
            }
            break;
        }
    } else {
        let status = resp.status
        if(status == 0) {// 成功
            let dataList = resp.dataList
        } else { // 失败

        }
    }
})
  • 停止设备监听

// 血压计
UTSOmron.stopBpMonitoring()

// 体脂仪
UTSOmron.stopBfMonitoring()

// 血糖仪
UTSOmron.stopBgMonitoring()

// 血氧仪
UTSOmron.stopBoMonitoring()
  • 设置用户敏感信息可见等级

let params = {}
params.type = "all" // none、all、default
UTSOmron.setLogType(params)
  • 获取设备指纹

let deviceFinger = UTSOmron.getDeviceFinger()

隐私、权限声明

1. 本插件需要申请的系统权限列表：

蓝牙、定位

2. 本插件采集的数据、发送的服务器地址、以及数据用途说明：

插件不采集任何数据

3. 本插件是否包含广告，如包含需详细说明广告表达方式、展示频率：

无

评论列表 撰写评论 向官方投诉

暂无用户评论。