更新记录

1.0.1(2026-04-23)

  1. 增加加速度、陀螺仪、接近、计步、光照等二十多种传感器
  2. 实现计步、摇一摇、靠近熄屏切换扬声器等

1.0.0(2026-04-22)

  1. 陀螺仪传感器

平台兼容性

uni-app(3.7.6)

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

uni-app x(3.7.6)

Chrome Safari Android iOS 鸿蒙 微信小程序
- - 5.0 - -

其他

多语言 暗黑模式 宽屏模式

全部传感器(加速度、陀螺仪、接近、计步、光照等),实现计步、摇一摇、靠近熄屏切换扬声器等

集成步骤

  1. 拷贝demo里的AndroidManifest.xml、Info.plist、harmony-configs文件到项目根目录
  2. 点击右上角"试用"按钮绑定appid和导入插件到项目
  3. 删除本地基座和手机上现有app,重新自定义基座运行
  4. 插件咨询或定制请点击上面"进入交流群"私聊作者

接口

    import {
    UTSSensor
} from "@/uni_modules/wrs-uts-sensor"
  • 设置传感器回调
UTSSensor.onSetCallback((resp) => {
    console.log("onSetCallback resp:" + JSON.stringify(resp))
    let type = resp.type
    switch (type) {
        // 陀螺仪传感器
        case 4: {
            let opt = resp.opt
            switch (opt) {
                // 传感器数据变化时调用
                case "onSensorChanged": {
                    let sensorEvent = resp.sensorEvent
                    if (sensorEvent) {
                        if (sensorEvent.values.length >= 3) {
                            let x = sensorEvent.values[0]
                            let y = sensorEvent.values[1]
                            let z = sensorEvent.values[2]

                            let deltaX = x - this.x;
                            let deltaY = y - this.y;
                            let deltaZ = z - this.z;

                            this.gyro_x = x
                            this.gyro_y = y
                            this.gyro_z = z
                        }
                    }
                }
                break;
                // 传感器精度变化时调用
                case "onAccuracyChanged": {

                }
                break;
                default: {
                    console.log("出错:" + JSON.stringify(resp))
                }
                break;
            }

        }
        break;
        // 加速度传感器
        case 1: {
            let opt = resp.opt
            switch (opt) {
                // 传感器数据变化时调用
                case "onSensorChanged": {
                    console.log("加速度")
                    let sensorEvent = resp.sensorEvent
                    if (sensorEvent) {
                        if (sensorEvent.values.length >= 3) {
                            let x = sensorEvent.values[0]
                            let y = sensorEvent.values[1]
                            let z = sensorEvent.values[2]

                            let deltaX = x - this.accelerometer_x;
                            let deltaY = y - this.accelerometer_y;
                            let deltaZ = z - this.accelerometer_z;

                            this.accelerometer_x = x
                            this.accelerometer_x = y
                            this.accelerometer_x = z

                            switch (uni.getSystemInfoSync().platform) {
                                case 'harmonyos':
                                case 'android': {

                                    let magnitude = Math.sqrt(x * x + y * y + z * z)
                                    // 摇一摇敏感度,可以自行调节
                                    let SHAKE_THRESHOLD = 15
                                    if (magnitude > SHAKE_THRESHOLD) {
                                        // 毫秒
                                        let currentTime = Date.now()
                                        if (this.lastShakeTime == 0) {
                                            this.lastShakeTime = currentTime
                                        } else {
                                            let between = currentTime - this.lastShakeTime
                                            if (between >= 1000) {
                                                // 检测到摇一摇
                                                this.shakeAction()
                                            }
                                            this.lastShakeTime = currentTime
                                        }
                                    }
                                }
                                break;
                                case 'ios': {
                                    let accelerameter = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2))
                                    let magnitude = Math.sqrt(x * x + y * y + z * z)
                                    let SHAKE_THRESHOLD = 15
                                    console.log("magnitude:" + magnitude)
                                    // 摇一摇敏感度,可以自行调节
                                    // if (accelerameter > 0.7) { 
                                    if (magnitude > 2) {
                                        // 毫秒
                                        let currentTime = Date.now()
                                        if (this.lastShakeTime == 0) {
                                            this.lastShakeTime = currentTime
                                        } else {
                                            var between = currentTime - this.lastShakeTime
                                            if (between > 1000) {
                                                this.shakeAction()
                                            }
                                            this.lastShakeTime = currentTime
                                        }
                                    }
                                }
                                break;
                                default:
                                    break;
                            }
                        }
                    }
                }
                break;
                // 传感器精度变化时调用
                case "onAccuracyChanged": {

                }
                break;
                default: {
                    console.log("出错:" + JSON.stringify(resp))
                }
                break;
            }

        }
        break;
        // 光线传感器
        case 5: {
            let opt = resp.opt
            switch (opt) {
                // 传感器数据变化时调用
                case "onSensorChanged": {
                    let sensorEvent = resp.sensorEvent
                    if (sensorEvent) {
                        let lux = 0
                        switch (uni.getSystemInfoSync().platform) {
                            case 'harmonyos': {
                                lux = sensorEvent.intensity
                            }
                            break;
                            case 'android': {
                                if (sensorEvent.values.length >= 1) {
                                    lux = sensorEvent.values[0]
                                }
                            }
                            break;
                        }
                        this.light_x = lux
                        // 根据lux计算目标亮度比例 (取值范围 0.0 - 1.0)
                        let brightness = this.calculateBrightness(lux)
                        this.light_y = "设置亮度:" + brightness
                        UTSSensor.setScreenBrightness({
                            screenBrightness: brightness
                        })

                    }
                }
                break;
                // 传感器精度变化时调用
                case "onAccuracyChanged": {

                }
                break;
                default: {
                    console.log("出错:" + JSON.stringify(resp))
                }
                break;
            }

        }
        break;
        // 接近传感器
        case 8: {
            let opt = resp.opt
            switch (opt) {
                // 传感器数据变化时调用
                case "onSensorChanged": {
                    let isClosed = false
                    switch (uni.getSystemInfoSync().platform) {
                        case "harmonyos": {
                            let sensorEvent = resp.sensorEvent
                            if (sensorEvent) {
                                let distance = sensorEvent.distance

                                if (distance < 5 && distance >= 0) {
                                    // 靠近耳朵 -> 切换到听筒 (Earpiece)
                                    isClosed = true
                                } else {
                                    isClosed = false
                                }
                            }
                        }
                        break;
                        case "android": {
                            let sensorEvent = resp.sensorEvent
                            if (sensorEvent) {
                                if (sensorEvent.values.length >= 1) {
                                    let distance = sensorEvent.values[0]
                                    this.light_x = distance
                                    // 根据x(lux)计算目标亮度比例 (取值范围 0.0 - 1.0)
                                    // 当距离小于最大值(通常 < 5cm),表示手机贴近耳朵
                                    if (distance < 5 && distance >= 0) {
                                        // 靠近耳朵 -> 切换到听筒 (Earpiece)
                                        isClosed = true
                                    } else {
                                        isClosed = false
                                    }
                                }
                            }
                        }
                        break;
                        case "ios": {
                            isClosed = resp.state
                        }
                        break;

                    }
                    if (isClosed) {
                        // 靠近耳朵 -> 切换到听筒 (Earpiece)

                        this.originBrightness = UTSSensor.getScreenBrightness()
                        // let mode = UTSSensor.getScreenBrightnessMode()
                        // // 当前亮度是自动模式时,需要改为手动模式
                        // if (mode == 1) {
                        //  // UTSSensor.setScreenBrightnessMode({
                        //  //  mode: 0
                        //  // })
                        // }
                        // 亮度设置为0
                        UTSSensor.setScreenBrightness({
                            screenBrightness: 0.01 // 鸿蒙里设置亮度为0不生效,设置为一个接近0的数
                        })
                        // 切换为听筒
                        UTSSensor.setSpeakerEnable(false)
                        console.log("靠近耳朵 -> 切换到听筒和熄屏")
                        this.near_x = "靠近耳朵 -> 切换到听筒和熄屏"
                    } else {
                        // 远离耳朵 -> 切换到扬声器 (Speaker)
                        console.log(" 远离耳朵 -> 切换到扬声器和亮屏")
                        this.near_x = "远离耳朵 -> 切换到扬声器和亮屏"
                        // 还原亮度
                        UTSSensor.setScreenBrightness({
                            screenBrightness: this.originBrightness
                        })
                        // 切换为扬声器
                        UTSSensor.setSpeakerEnable(true)
                    }
                }
                break;
                // 传感器精度变化时调用
                case "onAccuracyChanged": {

                }
                break;
                default: {
                    console.log("出错:" + JSON.stringify(resp))
                }
                break;
            }

        }
        break;
        // 步数检测传感器,实时事件模型
        case 18: {
            let opt = resp.opt
            switch (opt) {
                // 传感器数据变化时调用
                case "onSensorChanged": {
                    // 每走一步,此方法被调用一次
                    switch (uni.getSystemInfoSync().platform) {
                        case "android": {
                            this.numberOfSteps = this.numberOfSteps + 1
                        }
                        break;
                        case "harmonyos": {
                            let sensorEvent = resp.sensorEvent
                            let scalar = sensorEvent.scalar
                            if (scalar == 1) { // 取值为1则代表用户产生了计步行走的动作
                                this.numberOfSteps = this.numberOfSteps + 1
                            } else {

                            }
                        }
                        break;
                        default:
                            break;
                    }

                }
            }
        }
        break;
        // 累计步数传感器
        case 19: {
            let opt = resp.opt
            switch (opt) {
                // 传感器数据变化时调用
                case "onSensorChanged": {
                    let isClosed = false
                    switch (uni.getSystemInfoSync().platform) {
                        case "harmonyos": {
                            let sensorEvent = resp.sensorEvent
                            if (sensorEvent) {
                                let steps = sensorEvent.steps
                                this.stepDesc = "总步数 (自开机):" + steps + " 当前走了" + this
                                    .numberOfSteps + "步"
                            }
                        }
                        break;
                        case "android": {
                            let sensorEvent = resp.sensorEvent
                            if (sensorEvent) {
                                if (sensorEvent.values.length >= 1) {
                                    let totalStepsSinceBoot = sensorEvent.values[0]
                                    this.stepDesc = "总步数 (自开机):" + totalStepsSinceBoot + " 当前走了" + this
                                        .numberOfSteps + "步"
                                }
                            }
                        }
                        break;
                        case "ios": {
                            let sensorEvent = resp.sensorEvent
                            let startDate = sensorEvent.startDate
                            let endDate = sensorEvent.endDate
                            // 下楼楼层
                            let floorsDescended = sensorEvent.floorsDescended
                            // 上楼楼层
                            let floorsAscended = sensorEvent.floorsAscended
                            // 平均步速,,秒/米
                            let averageActivePace = sensorEvent.averageActivePace
                            // 距离,米
                            let distance = sensorEvent.distance
                            //  累计步数
                            let numberOfSteps = sensorEvent.numberOfSteps
                            // 步速,秒/米
                            let currentPace = sensorEvent.currentPace
                            // 步频,步数/秒
                            let currentCadence = sensorEvent.currentCadence
                            this.stepDesc = "总步数:" + numberOfSteps + " 步速:" + currentPace +
                                " 步频:" + currentCadence + " 上楼:" + floorsAscended + " 下楼:" +
                                floorsDescended
                        }
                        break;
                        default:
                            break;
                    }
                }
                default:
                    break;
            }

        }
        break;
        default:
            break;
    }
})
  • 启动传感器

// 传感器类型
// 1:加速度传感器,测量设备在各个轴向上的加速度(m/s²),常用于计步、屏幕旋转、摇一摇等
// 2:磁场传感器,不支持iOS,测量三个轴向上的环境磁场(μT),常用于电子罗盘
// 3:方向传感器,不支持iOS,获取设备的方位角、俯仰角和横滚角
// 4:陀螺仪传感器,测量设备在三个轴向上的旋转角速度(rad/s),常用于游戏、导航等
// 5:光线传感器,不支持iOS,测量环境光的强度(lx),常用于自动调节屏幕亮度
// 7:环境空气温度,不支持iOS
// 6:压力传感器,不支持iOS,测量环境气压(hPa),常用于海拔高度测算
// 8:接近传感器,测量物体与设备屏幕的距离(cm),常用于通话时自动息屏
// 9:重力传感器,不支持iOS,测量重力在各个轴向上的分量(m/s²)
// 10:线性加速度传感器,不支持iOS
// 11:旋转矢量传感器,不支持iOS,能直接告诉你手机当前是横着放、竖着放、屏幕朝上还是朝下,并且平滑地跟踪这些旋转变化。
// 12: 湿度传感器,不支持iOS
// 13:设备自身温度温度传感器,仅支持Android,测量环境温度(℃)
// 14: 未校准磁场传感器,不支持iOS
// 15: TYPE_GAME_ROTATION_VECTOR,不支持iOS
// 16: 未校准陀螺仪传感器,不支持iOS
// 17: TYPE_SIGNIFICANT_MOTION,不支持iOS, 大幅度动作传感器
// 18:步数检测,实时事件模型,不支持iOS
// 19:计步传感器,累计事件
// 20: TYPE_GEOMAGNETIC_ROTATION_VECTOR,仅支持Android
// 21:心率传感器,不支持iOS
let type = 19 // 计步传感器

let params = {}
params.type = type
switch (uni.getSystemInfoSync().platform) {
    case 'android': {
        //  * 多久获取一次数据
        // 0: SENSOR_DELAY_FASTEST 最快
        // 1: SENSOR_DELAY_GAME 适合游戏
        // 2: SENSOR_DELAY_UI 绘画UI
        // 3: SENSOR_DELAY_NORMAL 普通界面
        params.samplingPeriodUs = 2
    }
    break;
    case 'harmonyos': {
        // 上报间隔
        params.interval = 100000000 // 单位纳秒 
    }
    break;
    default:
        break;
}

UTSSensor.startSensor(params)
  • 停止传感器

let type = 4 // 陀螺仪
UTSSensor.stopSensor({
    type: type
})
  • 获取屏幕亮度

let originBrightness = UTSSensor.getScreenBrightness()
  • 设置屏幕亮度

// 亮度设置为0
UTSSensor.setScreenBrightness({
    screenBrightness: 0.01 // 0~1,鸿蒙里设置亮度为0不生效,设置为一个接近0的数
})
  • 切换听筒和扬声器

UTSSensor.setSpeakerEnable(false)

隐私、权限声明

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

<uses-permission android:name="android.permission.VIBRATE" /> <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />

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

插件不采集任何数据

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