1# Sensor 2<!--Kit: Sensor Service Kit--> 3<!--Subsystem: Sensors--> 4<!--Owner: @dilligencer--> 5<!--Designer: @butterls--> 6<!--Tester: @murphy84--> 7<!--Adviser: @hu-zhiqiong--> 8 9## 概述 10 11提供API来使用常见的传感器特性。例如，调用API来获取传感器和订阅或取消订阅传感器数据。 12 13提供标准的开放api，定义常用传感器属性。 14 15**起始版本**：11 16 17 18## 汇总 19 20 21### 文件 22 23| 名称 | 描述 | 24| -------- | -------- | 25| [oh_sensor.h](oh_sensor_8h.md) | 声明操作传感器的API，包括获取传感器信息和订阅取消订阅传感器数据。 | 26| [oh_sensor_type.h](oh_sensor_type_8h.md) | 定义常用传感器属性。 | 27 28 29### 类型定义 30 31| 名称 | 描述 | 32| -------- | -------- | 33| [Sensor_Type](#sensor_type) | 枚举传感器类型。 | 34| [Sensor_Result](#sensor_result) | 定义传感器错误码。 | 35| [Sensor_Accuracy](#sensor_accuracy) | 枚举传感器上报的数据的精度级别。 | 36| [Sensor_Info](#sensor_info) | 定义传感器信息。 | 37| [Sensor_Event](#sensor_event) | 定义传感器数据信息。 | 38| [Sensor_SubscriptionId](#sensor_subscriptionid) | 定义传感器订阅ID，唯一标识传感器。 | 39| [Sensor_SubscriptionAttribute](#sensor_subscriptionattribute) | 定义传感器订阅属性。 | 40| void ([*Sensor_EventCallback](#sensor_eventcallback)) ([Sensor_Event](#sensor_event) \*event) | 定义用于传感器数据的回调函数。 | 41| [Sensor_Subscriber](#sensor_subscriber) | 定义传感器订阅者信息。 | 42 43 44### 枚举 45 46| 名称 | 描述 | 47| -------- | -------- | 48| [Sensor_Type](#sensor_type) {<br/>SENSOR_TYPE_ACCELEROMETER = 1, <br/>SENSOR_TYPE_GYROSCOPE = 2,<br/> SENSOR_TYPE_AMBIENT_LIGHT = 5, <br/>SENSOR_TYPE_MAGNETIC_FIELD = 6,<br/>SENSOR_TYPE_BAROMETER = 8,<br/> SENSOR_TYPE_HALL = 10, <br/>SENSOR_TYPE_PROXIMITY = 12,<br/> SENSOR_TYPE_ORIENTATION = 256,<br/>SENSOR_TYPE_GRAVITY = 257, <br/>SENSOR_TYPE_LINEAR_ACCELERATION = 258,<br/>SENSOR_TYPE_ROTATION_VECTOR = 259,<br/>SENSOR_TYPE_GAME_ROTATION_VECTOR = 262,<br/>SENSOR_TYPE_PEDOMETER_DETECTION = 265,<br/> SENSOR_TYPE_PEDOMETER = 266,<br/>SENSOR_TYPE_HEART_RATE = 278<br/>} | 枚举传感器类型。 | 49| [Sensor_Result](#sensor_result) { <br/>SENSOR_SUCCESS = 0,<br/> SENSOR_PERMISSION_DENIED = 201, <br/>SENSOR_PARAMETER_ERROR = 401,<br/> SENSOR_SERVICE_EXCEPTION = 14500101<br/> } | 定义传感器错误码。 | 50| [Sensor_Accuracy](#sensor_accuracy) { <br/>SENSOR_ACCURACY_UNRELIABLE = 0, <br/>SENSOR_ACCURACY_LOW = 1,<br/> SENSOR_ACCURACY_MEDIUM = 2, <br/>SENSOR_ACCURACY_HIGH = 3 <br/>} | 枚举传感器上报数据的精度级别。 | 51 52 53### 函数 54 55| 名称 | 描述 | 56| -------- | -------- | 57| [OH_Sensor_GetInfos](#oh_sensor_getinfos)([Sensor_Info](#sensor_info) **infos, uint32_t *count) | 获取设备上所有传感器的信息。 | 58| [OH_Sensor_Subscribe](#oh_sensor_subscribe)(const [Sensor_SubscriptionId](#sensor_subscriptionid) *id, const [Sensor_SubscriptionAttribute](#sensor_subscriptionattribute) *attribute, const [Sensor_Subscriber](#sensor_subscriber) *subscriber) | 订阅传感器数据。系统将以指定的频率向用户上报传感器数据。<br/>订阅加速度传感器，需要申请ohos.permission.ACCELEROMETER权限；<br/>订阅陀螺仪传感器，需要申请ohos.permission.GYROSCOPE权限；<br/>订阅计步器相关传感器时，需要申请ohos.permission.ACTIVITY_MOTION权限；<br/>订阅与健康相关的传感器时，比如心率传感器需要申请ohos.permission.READ_HEALTH_DATA权限，否则订阅失败;<br/>订阅其余传感器不需要申请权限。 | 59| [OH_Sensor_Unsubscribe](#oh_sensor_unsubscribe)(const [Sensor_SubscriptionId](#sensor_subscriptionid) *id, const [Sensor_Subscriber](#sensor_subscriber) *subscriber) | 取消订阅传感器数据。<br/>取消订阅加速度计传感器，需要申请ohos.permission.ACCELEROMETER权限； <br/>取消订阅陀螺仪传感器，需要申请ohos.permission.GYROSCOPE权限； <br/>取消订阅计步器相关传感器时，需要申请ohos.permission.ACTIVITY_MOTION权限；<br/>取消订阅与健康相关的传感器时，需要申请ohos.permission.READ_HEALTH_DATA权限，否则取消订阅失败。 <br/>取消订阅其余传感器不需要申请权限。 | 60| [OH_Sensor_CreateInfos](#oh_sensor_createinfos)(uint32_t count) | 用给定的数字创建一个实例数组，请参考[Sensor_Info](#sensor_info)。 | 61| [OH_Sensor_DestroyInfos](#oh_sensor_destroyinfos)([Sensor_Info](#sensor_info) **sensors, uint32_t count) | 销毁实例数组并回收内存，请参考[Sensor_Info](#sensor_info)。 | 62| [OH_SensorInfo_GetName](#oh_sensorinfo_getname)([Sensor_Info](#sensor_info) *sensor, char *sensorName, uint32_t *length) | 获取传感器名称。 | 63| [OH_SensorInfo_GetVendorName](#oh_sensorinfo_getvendorname)([Sensor_Info](#sensor_info)* sensor, char *vendorName, uint32_t *length) | 获取传感器的厂商名称。 | 64| [OH_SensorInfo_GetType](#oh_sensorinfo_gettype)([Sensor_Info](#sensor_info)* sensor, [Sensor_Type](#sensor_type) *sensorType) | 获取传感器类型。 | 65| [OH_SensorInfo_GetResolution](#oh_sensorinfo_getresolution)([Sensor_Info](#sensor_info)* sensor, float *resolution) | 获取传感器分辨率。 | 66| [OH_SensorInfo_GetMinSamplingInterval](#oh_sensorinfo_getminsamplinginterval)([Sensor_Info](#sensor_info)* sensor, int64_t *minSamplingInterval) | 获取传感器的最小数据上报间隔。 | 67| [OH_SensorInfo_GetMaxSamplingInterval](#oh_sensorinfo_getmaxsamplinginterval)([Sensor_Info](#sensor_info)* sensor, int64_t *maxSamplingInterval) | 获取传感器的最大数据上报间隔时间。 | 68| [OH_SensorEvent_GetType](#oh_sensorevent_gettype)([Sensor_Event](#sensor_event)* sensorEvent, [Sensor_Type](#sensor_type) *sensorType) | 获取传感器类型。 | 69| [OH_SensorEvent_GetTimestamp](#oh_sensorevent_gettimestamp)([Sensor_Event](#sensor_event)* sensorEvent, int64_t *timestamp) | 获取传感器数据的时间戳。 | 70| [OH_SensorEvent_GetAccuracy](#oh_sensorevent_getaccuracy)([Sensor_Event](#sensor_event)* sensorEvent, Sensor_Accuracy *accuracy) | 获取传感器数据的精度。 | 71| [OH_SensorEvent_GetData](#oh_sensorevent_getdata)([Sensor_Event](#sensor_event)* sensorEvent, float **data, uint32_t *length) | 获取传感器数据。<br/>数据的长度和内容依赖于监听的传感器类型，传感器上报的数据格式如下：<br/>1.SENSOR_TYPE_ACCELEROMETER:data[0]、data[1]、data[2]分别表示设备x、y、z轴的加速度分量，单位m/s²；<br/>2.SENSOR_TYPE_GYROSCOPE:data[0]、data[1]、data[2]分别表示设备x、y、z轴的旋转角速度，单位弧度/s；<br/>3.SENSOR_TYPE_AMBIENT_LIGHT:data[0]表示环境光强度，单位lux；从API Version 12开始，将返回两个额外的数据，其中data[1]表示色温，单位kelvin；data[2]表示红外亮度，单位cd/m²；<br/>4. SENSOR_TYPE_MAGNETIC_FIELD:data[0]、data[1]、data[2]分别表示设备x、y、z轴的地磁分量，单位微特斯拉； <br/>5.SENSOR_TYPE_BAROMETER:data[0]表示气压值，单位hPa；<br/>6.SENSOR_TYPE_HALL:data[0]表示皮套吸合状态，0表示打开，大于0表示吸附；<br/>7.SENSOR_TYPE_PROXIMITY:data[0]表示接近状态，0表示接近，大于0表示远离；<br/>8.SENSOR_TYPE_ORIENTATION:data[0]、data[1]、data[2]分别表示设备绕z、x、y轴的角度，单位度；<br/>9.SENSOR_TYPE_GRAVITY:data[0]、data[1]、data[2]分别表示设备x、y、z轴的重力加速度分量，单位m/s²；<br/>10.SENSOR_TYPE_ROTATION_VECTOR:data[0]、data[1]、data[2]分别表示设备x、y、z轴的旋转角度，单位度，data[3]表示旋转向量元素；<br/>11.SENSOR_TYPE_PEDOMETER_DETECTION:data[0]表示计步检测状态，1表示检测到了步数变化；<br/>12.SENSOR_TYPE_PEDOMETER:data[0]表示步数；<br/>13.SENSOR_TYPE_HEART_RATE:data[0]表示心率数值；<br/>14.SENSOR_TYPE_LINEAR_ACCELERATION:从API Version 13开始支持，data[0]、data[1]、data[2]分别表示绕设备的x、y、z的线性加速度，单位m/s²；<br/>15.SENSOR_TYPE_GAME_ROTATION_VECTOR:从API Version 13开始支持，data[0]、data[1]、data[2]分别表示设备分别围绕x、y、z的旋转角度，单位为度，data[3]表示旋转向量。 | 72| [OH_Sensor_CreateSubscriptionId](#oh_sensor_createsubscriptionid)(void) | 创建一个[Sensor_SubscriptionId](#sensor_subscriptionid)实例。 | 73| [OH_Sensor_DestroySubscriptionId](#oh_sensor_destroysubscriptionid)([Sensor_SubscriptionId](#sensor_subscriptionid) *id) | 销毁[Sensor_SubscriptionId](#sensor_subscriptionid)实例并回收内存。 | 74| [OH_SensorSubscriptionId_GetType](#oh_sensorsubscriptionid_gettype)([Sensor_SubscriptionId](#sensor_subscriptionid) *id, [Sensor_Type](#sensor_type) *sensorType) | 获取传感器类型。 | 75| [OH_SensorSubscriptionId_SetType](#oh_sensorsubscriptionid_settype)([Sensor_SubscriptionId](#sensor_subscriptionid)* id, const [Sensor_Type](#sensor_type) sensorType) | 设置传感器类型。 | 76| [OH_Sensor_CreateSubscriptionAttribute](#oh_sensor_createsubscriptionattribute)(void) | 创建[Sensor_SubscriptionAttribute](#sensor_subscriptionattribute)实例。 | 77| [OH_Sensor_DestroySubscriptionAttribute](#oh_sensor_destroysubscriptionattribute)([Sensor_SubscriptionAttribute](#sensor_subscriptionattribute) *attribute) | 销毁[Sensor_SubscriptionAttribute](#sensor_subscriptionattribute)实例并回收内存。 | 78| [OH_SensorSubscriptionAttribute_SetSamplingInterval](#oh_sensorsubscriptionattribute_setsamplinginterval)([Sensor_SubscriptionAttribute](#sensor_subscriptionattribute)* attribute, const int64_t samplingInterval) | 设置传感器数据上报间隔。 | 79| [OH_SensorSubscriptionAttribute_GetSamplingInterval](#oh_sensorsubscriptionattribute_getsamplinginterval) ([Sensor_SubscriptionAttribute](#sensor_subscriptionattribute)* attribute, int64_t *samplingInterval) | 获取传感器数据上报间隔。 | 80| [OH_Sensor_CreateSubscriber](#oh_sensor_createsubscriber)(void) | 创建一个[Sensor_Subscriber](#sensor_subscriber)实例。 | 81| [OH_Sensor_DestroySubscriber](#oh_sensor_destroysubscriber)([Sensor_Subscriber](#sensor_subscriber) *subscriber) | 销毁[Sensor_Subscriber](#sensor_subscriber)实例并回收内存。 | 82| [OH_SensorSubscriber_SetCallback](#oh_sensorsubscriber_setcallback)([Sensor_Subscriber](#sensor_subscriber)* subscriber, const [Sensor_EventCallback](#sensor_eventcallback) callback) | 设置一个回调函数来上报传感器数据。 | 83| [OH_SensorSubscriber_GetCallback](#oh_sensorsubscriber_getcallback)([Sensor_Subscriber](#sensor_subscriber)* subscriber, [Sensor_EventCallback](#sensor_eventcallback) *callback) | 获取用于上报传感器数据的回调函数。 | 84 85 86## 类型定义说明 87 88 89### Sensor_Accuracy 90 91``` 92typedef enum Sensor_Accuracy Sensor_Accuracy 93``` 94**描述**： 95 96枚举传感器上报的数据的精度级别。 97 98**起始版本**：11 99 100 101### Sensor_Event 102 103``` 104typedef struct Sensor_Event Sensor_Event 105``` 106**描述**： 107 108定义传感器数据信息。 109 110**起始版本**：11 111 112 113### Sensor_EventCallback 114 115``` 116typedef void(*Sensor_EventCallback)(Sensor_Event *event) 117``` 118**描述**： 119 120定义用于上报传感器数据的回调函数。 121 122**起始版本**：11 123 124 125### Sensor_Info 126 127``` 128typedef struct Sensor_Info Sensor_Info 129``` 130**描述**： 131 132定义传感器信息。 133 134**起始版本**：11 135 136 137### Sensor_Result 138 139``` 140typedef enum Sensor_Result Sensor_Result 141``` 142**描述**： 143 144定义传感器错误码。 145 146**起始版本**：11 147 148 149### Sensor_Subscriber 150 151``` 152typedef struct Sensor_Subscriber Sensor_Subscriber 153``` 154**描述**： 155 156定义传感器订阅者信息。 157 158**起始版本**：11 159 160 161### Sensor_SubscriptionAttribute 162 163``` 164typedef struct Sensor_SubscriptionAttribute Sensor_SubscriptionAttribute 165``` 166**描述**： 167 168定义传感器订阅属性。 169 170**起始版本**：11 171 172 173### Sensor_SubscriptionId 174 175``` 176typedef struct Sensor_SubscriptionId Sensor_SubscriptionId 177``` 178**描述**： 179 180定义传感器订阅ID，唯一标识传感器。 181 182**起始版本**：11 183 184 185### Sensor_Type 186 187``` 188typedef enum Sensor_Type Sensor_Type 189``` 190**描述**： 191 192枚举传感器类型。 193 194**起始版本**：11 195 196 197## 枚举类型说明 198 199 200### Sensor_Accuracy 201 202``` 203enum Sensor_Accuracy 204``` 205**描述**： 206 207枚举传感器上报的数据的精度级别。 208 209**起始版本**：11 210 211| 枚举值 | 描述 | 212| -------- | -------- | 213| SENSOR_ACCURACY_UNRELIABLE | 传感器数据不可靠。有可能传感器不与设备接触而进行测量。 | 214| SENSOR_ACCURACY_LOW | 传感器数据精度较低。数据在使用前必须根据环境进行校准。 | 215| SENSOR_ACCURACY_MEDIUM | 传感器数据处于中等精度水平。建议用户在使用前根据实际环境进行数据校准。 | 216| SENSOR_ACCURACY_HIGH | 传感器数据具有很高的精度。数据可以直接使用。 | 217 218 219### Sensor_Result 220 221``` 222enum Sensor_Result 223``` 224**描述**： 225 226定义传感器错误码。 227 228**起始版本**：11 229 230| 枚举值 | 描述 | 231| -------- | -------- | 232| SENSOR_SUCCESS | 操作成功。 | 233| SENSOR_PERMISSION_DENIED | 权限验证失败。 | 234| SENSOR_PARAMETER_ERROR | 参数检查失败。例如，没有传入强制参数，或者传入的参数类型不正确。 | 235| SENSOR_SERVICE_EXCEPTION | 传感器服务异常。 | 236 237 238### Sensor_Type 239 240``` 241enum Sensor_Type 242``` 243**描述**： 244 245枚举传感器类型。 246 247**起始版本**：11 248 249| 枚举值 | 描述 | 250| -------- | -------- | 251| SENSOR_TYPE_ACCELEROMETER | 加速度传感器。 | 252| SENSOR_TYPE_GYROSCOPE | 陀螺仪传感器。 | 253| SENSOR_TYPE_AMBIENT_LIGHT | 环境光传感器。 | 254| SENSOR_TYPE_MAGNETIC_FIELD | 地磁传感器。 | 255| SENSOR_TYPE_BAROMETER | 气压传感器。 | 256| SENSOR_TYPE_HALL | 霍尔传感器。 | 257| SENSOR_TYPE_PROXIMITY | 接近光传感器。 | 258| SENSOR_TYPE_ORIENTATION | 方向传感器。 | 259| SENSOR_TYPE_GRAVITY | 重力传感器。 | 260| SENSOR_TYPE_ROTATION_VECTOR | 旋转矢量传感器。 | 261| SENSOR_TYPE_PEDOMETER_DETECTION | 计步器检测传感器。 | 262| SENSOR_TYPE_PEDOMETER | 计步器传感器。 | 263| SENSOR_TYPE_HEART_RATE | 心率传感器。 | 264 265 266## 函数说明 267 268 269### OH_Sensor_CreateInfos() 270 271``` 272Sensor_Info **OH_Sensor_CreateInfos(uint32_t count) 273``` 274**描述**： 275 276用给定的数字创建一个实例数组，请参考 [Sensor_Info](#sensor_info)。 277 278**起始版本**：11 279 280**参数**： 281 282| 名称 | 描述 | 283| -------- | -------- | 284| count | 要创建的实例的数量，请参考 [Sensor_Info](#sensor_info)。 | 285 286**返回**： 287 288如果操作成功，返回指向 [Sensor_Info](#sensor_info) 实例数组的双指针；否则返回**NULL**。 289 290 291### OH_Sensor_CreateSubscriber() 292 293``` 294Sensor_Subscriber *OH_Sensor_CreateSubscriber(void) 295``` 296**描述**： 297 298创建一个 [Sensor_Subscriber ](#sensor_subscriber)实例。 299 300**起始版本**：11 301 302**返回**： 303 304如果操作成功，返回指向 [Sensor_Subscriber](#sensor_subscriber) 实例的指针；否则返回**NULL**。 305 306**示例**： 307 308详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 309 310 ```c 311 #include "sensors/oh_sensor.h" 312 #include "napi/native_api.h" 313 #include "hilog/log.h" 314 315 const int SENSOR_LOG_DOMAIN = 0xD002700; 316 const char *TAG = "[Sensor]"; 317 318 static napi_value CreateSubscriber(napi_env env, napi_callback_info info) { 319 Sensor_Result ret; 320 // 创建Sensor_Subscriber实例 321 Sensor_Subscriber *subscriberTemp = OH_Sensor_CreateSubscriber(); 322 if (subscriberTemp == nullptr) { 323 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_CreateSubscriber failed"); 324 ret = SENSOR_SERVICE_EXCEPTION; 325 } else { 326 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_CreateSubscriber successful"); 327 ret = SENSOR_SUCCESS; 328 } 329 // 销毁Sensor_Subscriber实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁 330 if (subscriberTemp != nullptr) { 331 OH_Sensor_DestroySubscriber(subscriberTemp); 332 } 333 napi_value result; 334 napi_create_int32(env, ret, &result); 335 return result; 336 } 337 ``` 338 339### OH_Sensor_CreateSubscriptionAttribute() 340 341``` 342Sensor_SubscriptionAttribute *OH_Sensor_CreateSubscriptionAttribute(void) 343``` 344**描述**： 345 346创建 [Sensor_SubscriptionAttribute ](#sensor_subscriptionattribute)实例。 347 348**起始版本**：11 349 350**返回**： 351 352如果操作成功，返回指向 [Sensor_SubscriptionAttribute](#sensor_subscriptionattribute) 实例的指针；否则返回**NULL**。 353 354**示例**： 355 356详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 357 358 ```c 359 #include "sensors/oh_sensor.h" 360 #include "napi/native_api.h" 361 #include "hilog/log.h" 362 363 const int SENSOR_LOG_DOMAIN = 0xD002700; 364 const char *TAG = "[Sensor]"; 365 366 static napi_value CreateSubscriptionAttribute(napi_env env, napi_callback_info info) { 367 Sensor_Result ret; 368 // 创建Sensor_SubscriptionAttribute实例 369 Sensor_SubscriptionAttribute *attr = OH_Sensor_CreateSubscriptionAttribute(); 370 if (attr == nullptr) { 371 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_CreateSubscriptionAttribute failed"); 372 ret = SENSOR_SERVICE_EXCEPTION; 373 } else { 374 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_CreateSubscriptionAttribute successful"); 375 ret = SENSOR_SUCCESS; 376 } 377 // 销毁Sensor_SubscriptionAttribute实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁 378 if (attr != nullptr) { 379 OH_Sensor_DestroySubscriptionAttribute(attr); 380 } 381 napi_value result; 382 napi_create_int32(env, ret, &result); 383 return result; 384 } 385 ``` 386 387### OH_Sensor_CreateSubscriptionId() 388 389``` 390Sensor_SubscriptionId *OH_Sensor_CreateSubscriptionId(void) 391``` 392**描述**： 393 394创建一个 [Sensor_SubscriptionId](#sensor_subscriptionid) 实例。 395 396**起始版本**：11 397 398**返回**： 399 400如果操作成功，返回指向 [Sensor_SubscriptionId](#sensor_subscriptionid) 实例的指针；否则返回**NULL**。 401 402**示例**： 403 404详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 405 406 ```c 407 #include "sensors/oh_sensor.h" 408 #include "napi/native_api.h" 409 #include "hilog/log.h" 410 411 const int SENSOR_LOG_DOMAIN = 0xD002700; 412 const char *TAG = "[Sensor]"; 413 414 static napi_value CreateSubscriptionId(napi_env env, napi_callback_info info) { 415 Sensor_Result ret; 416 // 创建Sensor_SubscriptionId实例 417 Sensor_SubscriptionId *id = OH_Sensor_CreateSubscriptionId(); 418 if (id == nullptr) { 419 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_CreateSubscriptionId failed"); 420 ret = SENSOR_SERVICE_EXCEPTION; 421 } else { 422 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_CreateSubscriptionId successful"); 423 ret = SENSOR_SUCCESS; 424 } 425 // 销毁Sensor_SubscriptionId实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁 426 if (id != nullptr) { 427 OH_Sensor_DestroySubscriptionId(id); 428 } 429 napi_value result; 430 napi_create_int32(env, ret, &result); 431 return result; 432 } 433 ``` 434 435### OH_Sensor_DestroyInfos() 436 437``` 438int32_t OH_Sensor_DestroyInfos(Sensor_Info **sensors, uint32_t count) 439``` 440**描述**： 441 442销毁实例数组并回收内存，请参考 [Sensor_Info](#sensor_info)。 443 444**起始版本**：11 445 446**参数**： 447 448| 名称 | 描述 | 449| -------- | -------- | 450| sensors | 指向 [Sensor_Info](#sensor_info) 实例数组的双指针。 | 451| count | 要销毁的 [Sensor_Info](#sensor_info) 实例的数量。 | 452 453**返回**： 454 455如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 456 457 458### OH_Sensor_DestroySubscriber() 459 460``` 461int32_t OH_Sensor_DestroySubscriber(Sensor_Subscriber *subscriber) 462``` 463**描述**： 464 465销毁 [Sensor_Subscriber ](#sensor_subscriber)实例并回收内存。 466 467**起始版本**：11 468 469**参数**： 470 471| 名称 | 描述 | 472| -------- | -------- | 473| subscriber | 指向 [Sensor_Subscriber](#sensor_subscriber) 实例的指针。 | 474 475**返回**： 476 477如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 478 479**示例**： 480 481详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 482 483 ```c 484 #include "sensors/oh_sensor.h" 485 #include "napi/native_api.h" 486 #include "hilog/log.h" 487 488 const int SENSOR_LOG_DOMAIN = 0xD002700; 489 const char *TAG = "[Sensor]"; 490 491 static napi_value DestroySubscriber(napi_env env, napi_callback_info info) { 492 // 创建Sensor_Subscriber实例。 493 Sensor_Subscriber *subscriberTemp = OH_Sensor_CreateSubscriber(); 494 // 销毁Sensor_Subscriber实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁。 495 int32_t ret = OH_Sensor_DestroySubscriber(subscriberTemp); 496 if (ret != SENSOR_SUCCESS) { 497 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_DestroySubscriber failed"); 498 } else { 499 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_DestroySubscriber successful"); 500 } 501 napi_value result; 502 napi_create_int32(env, ret, &result); 503 return result; 504 } 505 ``` 506 507### OH_Sensor_DestroySubscriptionAttribute() 508 509``` 510int32_t OH_Sensor_DestroySubscriptionAttribute(Sensor_SubscriptionAttribute *attribute) 511``` 512**描述**： 513 514销毁 [Sensor_SubscriptionAttribute](#sensor_subscriptionattribute) 实例并回收内存。 515 516**起始版本**：11 517 518**参数**： 519 520| 名称 | 描述 | 521| -------- | -------- | 522| attribute | 指向 [Sensor_SubscriptionAttribute](#sensor_subscriptionattribute) 实例的指针。 | 523 524**返回**： 525 526如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 527 528**示例**： 529 530详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 531 532 ```c 533 #include "sensors/oh_sensor.h" 534 #include "napi/native_api.h" 535 #include "hilog/log.h" 536 537 const int SENSOR_LOG_DOMAIN = 0xD002700; 538 const char *TAG = "[Sensor]"; 539 540 static napi_value DestroySubscriptionAttribute(napi_env env, napi_callback_info info) { 541 // 创建Sensor_SubscriptionAttribute实例。 542 Sensor_SubscriptionAttribute *attr = OH_Sensor_CreateSubscriptionAttribute(); 543 if (attr == nullptr) { 544 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_CreateSubscriptionAttribute failed"); 545 return nullptr; 546 } 547 // 销毁Sensor_SubscriptionAttribute实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁。 548 int32_t ret = OH_Sensor_DestroySubscriptionAttribute(attr); 549 if (ret != SENSOR_SUCCESS) { 550 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_DestroySubscriptionAttribute failed"); 551 } else { 552 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_DestroySubscriptionAttribute successful"); 553 } 554 napi_value result; 555 napi_create_int32(env, ret, &result); 556 return result; 557 } 558 ``` 559 560### OH_Sensor_DestroySubscriptionId() 561 562``` 563int32_t OH_Sensor_DestroySubscriptionId(Sensor_SubscriptionId *id) 564``` 565**描述**： 566 567销毁 [Sensor_SubscriptionId](#sensor_subscriptionid) 实例并回收内存。 568 569**起始版本**：11 570 571**参数**： 572 573| 名称 | 描述 | 574| -------- | -------- | 575| id | 指向 [Sensor_SubscriptionId](#sensor_subscriptionid) 实例的指针。 | 576 577**返回**： 578 579如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 580 581**示例**： 582 583详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 584 585 ```c 586 #include "sensors/oh_sensor.h" 587 #include "napi/native_api.h" 588 #include "hilog/log.h" 589 590 const int SENSOR_LOG_DOMAIN = 0xD002700; 591 const char *TAG = "[Sensor]"; 592 593 static napi_value DestroySubscriptionId(napi_env env, napi_callback_info info) { 594 // 创建Sensor_SubscriptionId实例。 595 Sensor_SubscriptionId *id = OH_Sensor_CreateSubscriptionId(); 596 // 销毁Sensor_SubscriptionId实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁。 597 int32_t ret = OH_Sensor_DestroySubscriptionId(id); 598 if (ret != SENSOR_SUCCESS) { 599 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_DestroySubscriptionId failed"); 600 } else { 601 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_DestroySubscriptionId successful"); 602 } 603 napi_value result; 604 napi_create_int32(env, ret, &result); 605 return result; 606 } 607 ``` 608 609### OH_Sensor_GetInfos() 610 611``` 612Sensor_Result OH_Sensor_GetInfos(Sensor_Info **infos, uint32_t *count) 613``` 614**描述**： 615 616获取设备上所有传感器的信息。 617 618**起始版本**：11 619 620**参数**： 621 622| 名称 | 描述 | 623| -------- | -------- | 624| infos | 双指针指向设备上所有传感器的信息。请参考 [Sensor_Info](#sensor_info)。 | 625| count | 指向设备上传感器数量的指针。 | 626 627**返回**： 628 629如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 630 631 632### OH_Sensor_Subscribe() 633 634``` 635Sensor_Result OH_Sensor_Subscribe(const Sensor_SubscriptionId *id, const Sensor_SubscriptionAttribute *attribute, const Sensor_Subscriber *subscriber) 636``` 637**描述**： 638 639订阅传感器数据。系统将以指定的频率向用户上报传感器数据。 订阅加速度传感器，需要申请ohos.permission.ACCELEROMETER权限； 订阅陀螺仪传感器，需要申请ohos.permission.GYROSCOPE权限； 订阅计步器相关传感器时，需要申请ohos.permission.ACTIVITY_MOTION权限； 订阅与健康相关的传感器时，比如心率传感器，需要申请ohos.permission.READ_HEALTH_DATA权限，否则订阅失败。 订阅其余传感器不需要申请权限。 640 641**起始版本**：11 642 643**参数**： 644 645| 名称 | 描述 | 646| -------- | -------- | 647| id | 指向传感器订阅ID的指针。请参考 [Sensor_SubscriptionId](#sensor_subscriptionid)。 | 648| attribute | 指向订阅属性的指针，该属性用于指定数据报告频率。请参考 [Sensor_SubscriptionAttribute](#sensor_subscriptionattribute)。 | 649| subscriber | 指向订阅者信息的指针，该信息用于指定的回调函数报告传感器数据。请参考 [Sensor_Subscriber](#sensor_subscriber)。 | 650 651**返回**： 652 653如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 654 655**Permission**: 656 657ohos.permission.ACCELEROMETER or ohos.permission.GYROSCOPE or ohos.permission.ACTIVITY_MOTION or ohos.permission.READ_HEALTH_DATA 658 659**示例**： 660 661详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 662 663 ```c 664 #include "sensors/oh_sensor.h" 665 #include "napi/native_api.h" 666 #include "hilog/log.h" 667 #include <thread> 668 669 const int SENSOR_LOG_DOMAIN = 0xD002700; 670 const char *TAG = "[Sensor]"; 671 constexpr Sensor_Type SENSOR_ID { SENSOR_TYPE_ACCELEROMETER }; 672 constexpr uint32_t SENSOR_NAME_LENGTH_MAX = 64; 673 constexpr int64_t SENSOR_SAMPLE_PERIOD = 200000000; 674 constexpr int32_t SLEEP_TIME_MS = 1000; 675 constexpr int64_t INVALID_VALUE = -1; 676 constexpr float INVALID_RESOLUTION = -1.0F; 677 Sensor_Subscriber *g_user = nullptr; 678 679 // 定义回调函数 680 void SensorDataCallbackImpl(Sensor_Event *event) { 681 if (event == nullptr) { 682 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "event is null"); 683 return; 684 } 685 int64_t timestamp = INVALID_VALUE; 686 // 获取传感器数据的时间戳。 687 int32_t ret = OH_SensorEvent_GetTimestamp(event, ×tamp); 688 if (ret != SENSOR_SUCCESS) { 689 return; 690 } 691 Sensor_Type sensorType; 692 // 获取传感器类型。 693 ret = OH_SensorEvent_GetType(event, &sensorType); 694 if (ret != SENSOR_SUCCESS) { 695 return; 696 } 697 Sensor_Accuracy accuracy = SENSOR_ACCURACY_UNRELIABLE; 698 // 获取传感器数据的精度。 699 ret = OH_SensorEvent_GetAccuracy(event, &accuracy); 700 if (ret != SENSOR_SUCCESS) { 701 return; 702 } 703 float *data = nullptr; 704 uint32_t length = 0; 705 // 获取传感器数据。 706 ret = OH_SensorEvent_GetData(event, &data, &length); 707 if (ret != SENSOR_SUCCESS) { 708 return; 709 } 710 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "sensorType:%{public}d, dataLen:%{public}d, accuracy:%{public}d", sensorType, length, accuracy); 711 for (uint32_t i = 0; i < length; ++i) { 712 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "accData[%{public}d]:%{public}f", i, data[i]); 713 } 714 } 715 716 static napi_value Subscribe(napi_env env, napi_callback_info info) { 717 // 创建Sensor_Subscriber实例。 718 g_user = OH_Sensor_CreateSubscriber(); 719 // 设置回调函数来报告传感器数据。 720 int32_t ret = OH_SensorSubscriber_SetCallback(g_user, SensorDataCallbackImpl); 721 if (ret != SENSOR_SUCCESS) { 722 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriber_SetCallback failed"); 723 return nullptr; 724 } 725 // 创建Sensor_SubscriptionId实例。 726 Sensor_SubscriptionId *id = OH_Sensor_CreateSubscriptionId(); 727 // 设置传感器类型,示例中设置的是SENSOR_TYPE_ACCELEROMETER类型，需开通ohos.permission.ACCELEROMETER权限 728 // 参考传感器开发指导中 开发步骤第2点配置加速度传感器权限。 729 ret = OH_SensorSubscriptionId_SetType(id, SENSOR_ID); 730 if (ret != SENSOR_SUCCESS) { 731 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionId_SetType failed"); 732 return nullptr; 733 } 734 // 创建Sensor_SubscriptionAttribute实例。 735 Sensor_SubscriptionAttribute *attr = OH_Sensor_CreateSubscriptionAttribute(); 736 // 设置传感器数据报告间隔。 737 ret = OH_SensorSubscriptionAttribute_SetSamplingInterval(attr, SENSOR_SAMPLE_PERIOD); 738 if (ret != SENSOR_SUCCESS) { 739 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionAttribute_SetSamplingInterval failed"); 740 return nullptr; 741 } 742 // 订阅传感器数据。 743 ret = OH_Sensor_Subscribe(id, attr, g_user); 744 if (ret != SENSOR_SUCCESS) { 745 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Subscribe failed"); 746 return nullptr; 747 } 748 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Subscribe successful"); 749 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS)); 750 // 取消订阅传感器数据。 751 ret = OH_Sensor_Unsubscribe(id, g_user); 752 if (ret != SENSOR_SUCCESS) { 753 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Unsubscribe failed"); 754 return nullptr; 755 } 756 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Unsubscribe successful"); 757 if (id != nullptr) { 758 // 销毁Sensor_SubscriptionId实例。 759 OH_Sensor_DestroySubscriptionId(id); 760 } 761 if (attr != nullptr) { 762 // 销毁Sensor_SubscriptionAttribute实例。 763 OH_Sensor_DestroySubscriptionAttribute(attr); 764 } 765 if (g_user != nullptr) { 766 // 销毁Sensor_Subscriber实例并回收内存。 767 OH_Sensor_DestroySubscriber(g_user); 768 g_user = nullptr; 769 } 770 return nullptr; 771 } 772 ``` 773 774### OH_Sensor_Unsubscribe() 775 776``` 777Sensor_Result OH_Sensor_Unsubscribe(const Sensor_SubscriptionId *id, const Sensor_Subscriber *subscriber) 778``` 779**描述**： 780 781取消订阅传感器数据。 取消订阅加速度计传感器，需要申请ohos.permission.ACCELEROMETER权限； 取消订阅陀螺仪传感器，需要申请ohos.permission.GYROSCOPE权限； 取消订阅计步器相关传感器时，需要申请ohos.permission.ACTIVITY_MOTION权限； 取消订阅与健康相关的传感器时，需要申请ohos.permission.READ_HEALTH_DATA权限，否则取消订阅失败。 取消订阅其余传感器不需要申请权限。 782 783**起始版本**：11 784 785**参数**： 786 787| 名称 | 描述 | 788| -------- | -------- | 789| id | 指向传感器订阅ID的指针。请参考 [Sensor_SubscriptionId](#sensor_subscriptionid)。 | 790| subscriber | 指向订阅者信息的指针，该信息用于指定的回调函数报告传感器数据。请参考 [Sensor_Subscriber](#sensor_subscriber)。 | 791 792**返回**： 793 794如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 795 796**Permission**: 797 798ohos.permission.ACCELEROMETER or ohos.permission.GYROSCOPE or ohos.permission.ACTIVITY_MOTION or ohos.permission.READ_HEALTH_DATA 799 800**示例**： 801 802详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 803 804 ```c 805 #include "sensors/oh_sensor.h" 806 #include "napi/native_api.h" 807 #include "hilog/log.h" 808 #include <thread> 809 810 const int SENSOR_LOG_DOMAIN = 0xD002700; 811 const char *TAG = "[Sensor]"; 812 constexpr Sensor_Type SENSOR_ID { SENSOR_TYPE_ACCELEROMETER }; 813 constexpr uint32_t SENSOR_NAME_LENGTH_MAX = 64; 814 constexpr int64_t SENSOR_SAMPLE_PERIOD = 200000000; 815 constexpr int32_t SLEEP_TIME_MS = 1000; 816 constexpr int64_t INVALID_VALUE = -1; 817 constexpr float INVALID_RESOLUTION = -1.0F; 818 Sensor_Subscriber *g_user = nullptr; 819 820 // 定义回调函数 821 void SensorDataCallbackImpl(Sensor_Event *event) { 822 if (event == nullptr) { 823 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "event is null"); 824 return; 825 } 826 int64_t timestamp = INVALID_VALUE; 827 // 获取传感器数据的时间戳。 828 int32_t ret = OH_SensorEvent_GetTimestamp(event, ×tamp); 829 if (ret != SENSOR_SUCCESS) { 830 return; 831 } 832 Sensor_Type sensorType; 833 // 获取传感器类型。 834 ret = OH_SensorEvent_GetType(event, &sensorType); 835 if (ret != SENSOR_SUCCESS) { 836 return; 837 } 838 Sensor_Accuracy accuracy = SENSOR_ACCURACY_UNRELIABLE; 839 // 获取传感器数据的精度。 840 ret = OH_SensorEvent_GetAccuracy(event, &accuracy); 841 if (ret != SENSOR_SUCCESS) { 842 return; 843 } 844 float *data = nullptr; 845 uint32_t length = 0; 846 // 获取传感器数据。 847 ret = OH_SensorEvent_GetData(event, &data, &length); 848 if (ret != SENSOR_SUCCESS) { 849 return; 850 } 851 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "sensorType:%{public}d, dataLen:%{public}d, accuracy:%{public}d", sensorType, length, accuracy); 852 for (uint32_t i = 0; i < length; ++i) { 853 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "accData[%{public}d]:%{public}f", i, data[i]); 854 } 855 } 856 857 static napi_value Unsubscribe(napi_env env, napi_callback_info info) { 858 // 创建Sensor_Subscriber实例。 859 g_user = OH_Sensor_CreateSubscriber(); 860 // 设置回调函数来报告传感器数据。 861 int32_t ret = OH_SensorSubscriber_SetCallback(g_user, SensorDataCallbackImpl); 862 if (ret != SENSOR_SUCCESS) { 863 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriber_SetCallback failed"); 864 return nullptr; 865 } 866 // 创建Sensor_SubscriptionId实例。 867 Sensor_SubscriptionId *id = OH_Sensor_CreateSubscriptionId(); 868 // 设置传感器类型,示例中设置的是SENSOR_TYPE_ACCELEROMETER类型，需开通ohos.permission.ACCELEROMETER权限 869 // 参考传感器开发指导中 开发步骤第2点配置加速度传感器权限。 870 ret = OH_SensorSubscriptionId_SetType(id, SENSOR_ID); 871 if (ret != SENSOR_SUCCESS) { 872 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionId_SetType failed"); 873 return nullptr; 874 } 875 // 创建Sensor_SubscriptionAttribute实例。 876 Sensor_SubscriptionAttribute *attr = OH_Sensor_CreateSubscriptionAttribute(); 877 // 设置传感器数据报告间隔。 878 ret = OH_SensorSubscriptionAttribute_SetSamplingInterval(attr, SENSOR_SAMPLE_PERIOD); 879 if (ret != SENSOR_SUCCESS) { 880 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionAttribute_SetSamplingInterval failed"); 881 return nullptr; 882 } 883 // 订阅传感器数据。 884 ret = OH_Sensor_Subscribe(id, attr, g_user); 885 if (ret != SENSOR_SUCCESS) { 886 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Subscribe failed"); 887 return nullptr; 888 } 889 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Subscribe successful"); 890 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS)); 891 // 取消订阅传感器数据。 892 ret = OH_Sensor_Unsubscribe(id, g_user); 893 if (ret != SENSOR_SUCCESS) { 894 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Unsubscribe failed"); 895 return nullptr; 896 } 897 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Unsubscribe successful"); 898 if (id != nullptr) { 899 // 销毁Sensor_SubscriptionId实例。 900 OH_Sensor_DestroySubscriptionId(id); 901 } 902 if (attr != nullptr) { 903 // 销毁Sensor_SubscriptionAttribute实例。 904 OH_Sensor_DestroySubscriptionAttribute(attr); 905 } 906 if (g_user != nullptr) { 907 // 销毁Sensor_Subscriber实例并回收内存。 908 OH_Sensor_DestroySubscriber(g_user); 909 g_user = nullptr; 910 } 911 return nullptr; 912 } 913 ``` 914 915### OH_SensorEvent_GetAccuracy() 916 917``` 918int32_t OH_SensorEvent_GetAccuracy(Sensor_Event* sensorEvent, Sensor_Accuracy *accuracy) 919``` 920**描述**： 921 922获取传感器数据的精度。 923 924**起始版本**：11 925 926**参数**： 927 928| 名称 | 描述 | 929| -------- | -------- | 930| sensorEvent | 指向传感器数据信息的指针。 | 931| accuracy | 指向精度的指针。 | 932 933**返回**： 934 935如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 936 937 938### OH_SensorEvent_GetData() 939 940``` 941int32_t OH_SensorEvent_GetData(Sensor_Event* sensorEvent, float **data, uint32_t *length) 942``` 943**描述**： 944 945获取传感器数据。数据的长度和内容依赖于监听的传感器类型，传感器上报的数据格式如下： 946 947SENSOR_TYPE_ACCELEROMETER:data[0]、data[1]、data[2]分别表示设备x、y、z轴的加速度分量，单位m/s²； 948 949SENSOR_TYPE_GYROSCOPE:data[0]、data[1]、data[2]分别表示设备x、y、z轴的旋转角速度，单位弧度/s； 950 951SENSOR_TYPE_AMBIENT_LIGHT:data[0]表示环境光强度，in lux； 952 953SENSOR_TYPE_MAGNETIC_FIELD:data[0]、data[1]、data[2]分别表示设备x、y、z轴的地磁分量，单位微特斯拉； 954 955SENSOR_TYPE_BAROMETER:data[0]表示气压值，单位hPa； 956 957SENSOR_TYPE_HALL:data[0]表示皮套吸合状态，0表示打开，大于0表示吸附； 958 959SENSOR_TYPE_PROXIMITY:data[0]表示接近状态，0表示接近，大于0表示远离； 960 961SENSOR_TYPE_ORIENTATION:data[0]、data[1]、data[2]分别表示设备绕z、x、y轴的角度，单位度； 962 963SENSOR_TYPE_GRAVITY:data[0]、data[1]、data[2]分别表示设备x、y、z轴的重力加速度分量，单位m/s²； 964 965SENSOR_TYPE_ROTATION_VECTOR:data[0]、data[1]、data[2]分别表示设备x、y、z轴的旋转角度，单位度，data[3]表示旋转向量元素； 966 967SENSOR_TYPE_PEDOMETER_DETECTION:data[0]表示计步检测状态，1表示检测到了步数变化； 968 969SENSOR_TYPE_PEDOMETER:data[0]表示步数； 970 971SENSOR_TYPE_HEART_RATE:data[0]表示心率数值； 972 973SENSOR_TYPE_LINEAR_ACCELERATION:从API Version 13开始支持，data[0]、data[1]、data[2]分别表示绕设备的x、y、z的线性加速度，单位m/s²； 974 975SENSOR_TYPE_GAME_ROTATION_VECTOR:从API Version 13开始支持，data[0]、data[1]、data[2]分别表示设备分别围绕x、y、z的旋转角度，单位为度，data[3]表示旋转向量。 976 977**起始版本**：11 978 979**参数**： 980 981| 名称 | 描述 | 982| -------- | -------- | 983| sensorEvent | 传感器数据信息。 | 984| data | 出参，传感器数据。 | 985| length | 出参，数组长度。 | 986 987**返回**： 988 989如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 990 991**示例**： 992 993详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 994 995 ```c 996 #include "sensors/oh_sensor.h" 997 #include "napi/native_api.h" 998 #include "hilog/log.h" 999 #include <thread> 1000 1001 const int SENSOR_LOG_DOMAIN = 0xD002700; 1002 const char *TAG = "[Sensor]"; 1003 constexpr Sensor_Type SENSOR_ID { SENSOR_TYPE_ACCELEROMETER }; 1004 constexpr uint32_t SENSOR_NAME_LENGTH_MAX = 64; 1005 constexpr int64_t SENSOR_SAMPLE_PERIOD = 200000000; 1006 constexpr int32_t SLEEP_TIME_MS = 1000; 1007 constexpr int64_t INVALID_VALUE = -1; 1008 constexpr float INVALID_RESOLUTION = -1.0F; 1009 Sensor_Subscriber *g_user = nullptr; 1010 1011 // 定义回调函数 1012 void SensorDataCallbackImpl(Sensor_Event *event) { 1013 if (event == nullptr) { 1014 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "event is null"); 1015 return; 1016 } 1017 int64_t timestamp = INVALID_VALUE; 1018 // 获取传感器数据的时间戳。 1019 int32_t ret = OH_SensorEvent_GetTimestamp(event, ×tamp); 1020 if (ret != SENSOR_SUCCESS) { 1021 return; 1022 } 1023 Sensor_Type sensorType; 1024 // 获取传感器类型。 1025 ret = OH_SensorEvent_GetType(event, &sensorType); 1026 if (ret != SENSOR_SUCCESS) { 1027 return; 1028 } 1029 Sensor_Accuracy accuracy = SENSOR_ACCURACY_UNRELIABLE; 1030 // 获取传感器数据的精度。 1031 ret = OH_SensorEvent_GetAccuracy(event, &accuracy); 1032 if (ret != SENSOR_SUCCESS) { 1033 return; 1034 } 1035 float *data = nullptr; 1036 uint32_t length = 0; 1037 // 获取传感器数据。 1038 ret = OH_SensorEvent_GetData(event, &data, &length); 1039 if (ret != SENSOR_SUCCESS) { 1040 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorEvent_GetData failed"); 1041 return; 1042 } 1043 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorEvent_GetData successful"); 1044 for (uint32_t i = 0; i < length; ++i) { 1045 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "accData[%{public}d]:%{public}f", i, data[i]); 1046 } 1047 } 1048 1049 static napi_value SensorEventGetData(napi_env env, napi_callback_info info) { 1050 // 创建Sensor_Subscriber实例。 1051 g_user = OH_Sensor_CreateSubscriber(); 1052 // 设置回调函数来报告传感器数据。 1053 int32_t ret = OH_SensorSubscriber_SetCallback(g_user, SensorDataCallbackImpl); 1054 if (ret != SENSOR_SUCCESS) { 1055 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriber_SetCallback failed"); 1056 return nullptr; 1057 } 1058 // 创建Sensor_SubscriptionId实例。 1059 Sensor_SubscriptionId *id = OH_Sensor_CreateSubscriptionId(); 1060 // 设置传感器类型,示例中设置的是SENSOR_TYPE_ACCELEROMETER类型，需开通ohos.permission.ACCELEROMETER权限 1061 // 参考传感器开发指导中 开发步骤第2点配置加速度传感器权限。 1062 ret = OH_SensorSubscriptionId_SetType(id, SENSOR_ID); 1063 if (ret != SENSOR_SUCCESS) { 1064 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionId_SetType failed"); 1065 return nullptr; 1066 } 1067 // 创建Sensor_SubscriptionAttribute实例。 1068 Sensor_SubscriptionAttribute *attr = OH_Sensor_CreateSubscriptionAttribute(); 1069 // 设置传感器数据报告间隔。 1070 ret = OH_SensorSubscriptionAttribute_SetSamplingInterval(attr, SENSOR_SAMPLE_PERIOD); 1071 if (ret != SENSOR_SUCCESS) { 1072 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionAttribute_SetSamplingInterval failed"); 1073 return nullptr; 1074 } 1075 // 订阅传感器数据。 1076 ret = OH_Sensor_Subscribe(id, attr, g_user); 1077 if (ret != SENSOR_SUCCESS) { 1078 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Subscribe failed"); 1079 return nullptr; 1080 } 1081 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Subscribe successful"); 1082 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_TIME_MS)); 1083 // 取消订阅传感器数据。 1084 ret = OH_Sensor_Unsubscribe(id, g_user); 1085 if (ret != SENSOR_SUCCESS) { 1086 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Unsubscribe failed"); 1087 return nullptr; 1088 } 1089 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_Sensor_Unsubscribe successful"); 1090 if (id != nullptr) { 1091 // 销毁Sensor_SubscriptionId实例。 1092 OH_Sensor_DestroySubscriptionId(id); 1093 } 1094 if (attr != nullptr) { 1095 // 销毁Sensor_SubscriptionAttribute实例。 1096 OH_Sensor_DestroySubscriptionAttribute(attr); 1097 } 1098 if (g_user != nullptr) { 1099 // 销毁Sensor_Subscriber实例并回收内存。 1100 OH_Sensor_DestroySubscriber(g_user); 1101 g_user = nullptr; 1102 } 1103 return nullptr; 1104 } 1105 ``` 1106 1107### OH_SensorEvent_GetTimestamp() 1108 1109``` 1110int32_t OH_SensorEvent_GetTimestamp(Sensor_Event* sensorEvent, int64_t *timestamp) 1111``` 1112**描述**： 1113 1114获取传感器数据的时间戳。 1115 1116**起始版本**：11 1117 1118**参数**： 1119 1120| 名称 | 描述 | 1121| -------- | -------- | 1122| sensorEvent | 指向传感器数据信息的指针。 | 1123| timestamp | 时间戳指针。 | 1124 1125**返回**： 1126 1127如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1128 1129 1130### OH_SensorEvent_GetType() 1131 1132``` 1133int32_t OH_SensorEvent_GetType(Sensor_Event* sensorEvent, Sensor_Type *sensorType) 1134``` 1135**描述**： 1136 1137获取传感器类型。 1138 1139**起始版本**：11 1140 1141**参数**： 1142 1143| 名称 | 描述 | 1144| -------- | -------- | 1145| sensorEvent | 指向传感器数据信息的指针。 | 1146| sensorType | 指向传感器类型的指针。 | 1147 1148**返回**： 1149 1150如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1151 1152 1153### OH_SensorInfo_GetMaxSamplingInterval() 1154 1155``` 1156int32_t OH_SensorInfo_GetMaxSamplingInterval(Sensor_Info* sensor, int64_t *maxSamplingInterval) 1157``` 1158**描述**： 1159 1160获取传感器的最大数据上报间隔时间。 1161 1162**起始版本**：11 1163 1164**参数**： 1165 1166| 名称 | 描述 | 1167| -------- | -------- | 1168| sensor | 指向传感器信息的指针。 | 1169| maxSamplingInterval | 指向最大数据报告间隔的指针，单位为纳秒。 | 1170 1171**返回**： 1172 1173如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1174 1175 1176### OH_SensorInfo_GetMinSamplingInterval() 1177 1178``` 1179int32_t OH_SensorInfo_GetMinSamplingInterval(Sensor_Info* sensor, int64_t *minSamplingInterval) 1180``` 1181**描述**： 1182 1183获取传感器的最小数据上报间隔。 1184 1185**起始版本**：11 1186 1187**参数**： 1188 1189| 名称 | 描述 | 1190| -------- | -------- | 1191| sensor | 指向传感器信息的指针。 | 1192| minSamplingInterval | 指向最小数据报告间隔的指针，以纳秒为单位。 | 1193 1194**返回**： 1195 1196如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1197 1198 1199### OH_SensorInfo_GetName() 1200 1201``` 1202int32_t OH_SensorInfo_GetName (Sensor_Info* sensor, char *sensorName, uint32_t *length) 1203``` 1204**描述**： 1205 1206获取传感器名称。 1207 1208**起始版本**：11 1209 1210**参数**： 1211 1212| 名称 | 描述 | 1213| -------- | -------- | 1214| sensor | 指向传感器信息的指针。 | 1215| sensorName | 指向传感器名称的指针。 | 1216| length | 指向长度的指针，以字节为单位。 | 1217 1218**返回**： 1219 1220如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1221 1222 1223### OH_SensorInfo_GetResolution() 1224 1225``` 1226int32_t OH_SensorInfo_GetResolution(Sensor_Info* sensor, float *resolution) 1227``` 1228**描述**： 1229 1230获取传感器分辨率。 1231 1232**起始版本**：11 1233 1234**参数**： 1235 1236| 名称 | 描述 | 1237| -------- | -------- | 1238| sensor | 指向传感器信息的指针。 | 1239| resolution | 指向传感器分辨率的指针。 | 1240 1241**返回**： 1242 1243如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1244 1245 1246### OH_SensorInfo_GetType() 1247 1248``` 1249int32_t OH_SensorInfo_GetType(Sensor_Info* sensor, Sensor_Type *sensorType) 1250``` 1251**描述**： 1252 1253获取传感器类型。 1254 1255**起始版本**： 11 1256 1257**参数**： 1258 1259| 名称 | 描述 | 1260| -------- | -------- | 1261| sensor | 指向传感器信息的指针。 | 1262| sensorType | 指向传感器类型的指针。 | 1263 1264**返回**： 1265 1266如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1267 1268 1269### OH_SensorInfo_GetVendorName() 1270 1271``` 1272int32_t OH_SensorInfo_GetVendorName(Sensor_Info* sensor, char *vendorName, uint32_t *length) 1273``` 1274**描述**： 1275 1276获取传感器的厂商名称。 1277 1278**起始版本**：11 1279 1280**参数**： 1281 1282| 名称 | 描述 | 1283| -------- | -------- | 1284| sensor | 指向传感器信息的指针。 | 1285| vendorName | 指向供应商名称的指针。 | 1286| length | 指向长度的指针，以字节为单位。 | 1287 1288**返回**： 1289 1290如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1291 1292 1293### OH_SensorSubscriber_GetCallback() 1294 1295``` 1296int32_t OH_SensorSubscriber_GetCallback(Sensor_Subscriber* subscriber, Sensor_EventCallback *callback) 1297``` 1298**描述**： 1299 1300获取用于上报传感器数据的回调函数。 1301 1302**起始版本**：11 1303 1304**参数**： 1305 1306| 名称 | 描述 | 1307| -------- | -------- | 1308| subscriber | 指向传感器订阅者信息的指针。 | 1309| callback | 指向回调函数的指针。 | 1310 1311**返回**： 1312 1313如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1314 1315 1316### OH_SensorSubscriber_SetCallback() 1317 1318``` 1319int32_t OH_SensorSubscriber_SetCallback (Sensor_Subscriber* subscriber, const Sensor_EventCallback callback ) 1320``` 1321**描述**： 1322 1323设置一个回调函数来上报传感器数据。 1324 1325**起始版本**：11 1326 1327**参数**： 1328 1329| 名称 | 描述 | 1330| -------- | -------- | 1331| subscriber | 指向传感器订阅者信息的指针。 | 1332| callback | 设置回调函数。 | 1333 1334**返回**： 1335 1336如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1337 1338**示例**： 1339 1340详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 1341 1342 ```c 1343 #include "sensors/oh_sensor.h" 1344 #include "napi/native_api.h" 1345 #include "hilog/log.h" 1346 1347 const int SENSOR_LOG_DOMAIN = 0xD002700; 1348 const char *TAG = "[Sensor]"; 1349 constexpr int64_t INVALID_VALUE = -1; 1350 1351 void SensorDataCallbackImpl(Sensor_Event *event) { 1352 if (event == nullptr) { 1353 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "event is null"); 1354 return; 1355 } 1356 int64_t timestamp = INVALID_VALUE; 1357 // 获取传感器数据的时间戳。 1358 int32_t ret = OH_SensorEvent_GetTimestamp(event, ×tamp); 1359 if (ret != SENSOR_SUCCESS) { 1360 return; 1361 } 1362 Sensor_Type sensorType; 1363 // 获取传感器类型。 1364 ret = OH_SensorEvent_GetType(event, &sensorType); 1365 if (ret != SENSOR_SUCCESS) { 1366 return; 1367 } 1368 Sensor_Accuracy accuracy = SENSOR_ACCURACY_UNRELIABLE; 1369 // 获取传感器数据的精度。 1370 ret = OH_SensorEvent_GetAccuracy(event, &accuracy); 1371 if (ret != SENSOR_SUCCESS) { 1372 return; 1373 } 1374 float *data = nullptr; 1375 uint32_t length = 0; 1376 // 获取传感器数据。 1377 ret = OH_SensorEvent_GetData(event, &data, &length); 1378 if (ret != SENSOR_SUCCESS) { 1379 return; 1380 } 1381 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "sensorType:%{public}d, dataLen:%{public}d, accuracy:%{public}d", sensorType, length, accuracy); 1382 for (uint32_t i = 0; i < length; ++i) { 1383 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "data[%{public}d]:%{public}f", i, data[i]); 1384 } 1385 } 1386 1387 static napi_value SensorSubscriberSetCallback(napi_env env, napi_callback_info info) { 1388 // 创建Sensor_Subscriber实例。 1389 Sensor_Subscriber *subscriberTemp = OH_Sensor_CreateSubscriber(); 1390 int32_t ret = OH_SensorSubscriber_SetCallback(subscriberTemp, SensorDataCallbackImpl); 1391 if (ret != SENSOR_SUCCESS) { 1392 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriber_SetCallback failed"); 1393 } else { 1394 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriber_SetCallback successful"); 1395 } 1396 // 销毁Sensor_Subscriber实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁 1397 if (subscriberTemp != nullptr) { 1398 OH_Sensor_DestroySubscriber(subscriberTemp); 1399 } 1400 napi_value result; 1401 napi_create_int32(env, ret, &result); 1402 return result; 1403 } 1404 ``` 1405 1406### OH_SensorSubscriptionAttribute_GetSamplingInterval() 1407 1408``` 1409int32_t OH_SensorSubscriptionAttribute_GetSamplingInterval (Sensor_SubscriptionAttribute * attribute, int64_t * samplingInterval ) 1410``` 1411**描述**： 1412 1413获取传感器数据上报间隔。 1414 1415**起始版本**：11 1416 1417**参数**： 1418 1419| 名称 | 描述 | 1420| -------- | -------- | 1421| attribute | 指向传感器订阅属性的指针。 | 1422| samplingInterval | 指向数据报告间隔的指针，以纳秒为单位。 | 1423 1424**返回**： 1425 1426如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1427 1428 1429### OH_SensorSubscriptionAttribute_SetSamplingInterval() 1430 1431``` 1432int32_t OH_SensorSubscriptionAttribute_SetSamplingInterval(Sensor_SubscriptionAttribute* attribute, const int64_t samplingInterval) 1433``` 1434**描述**： 1435 1436设置传感器数据上报间隔。 1437 1438**起始版本**：11 1439 1440**参数**： 1441 1442| 名称 | 描述 | 1443| -------- | -------- | 1444| attribute | 指向传感器订阅属性的指针。 | 1445| samplingInterval | 要设置的数据报告间隔，以纳秒为单位。 | 1446 1447**返回**： 1448 1449如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1450 1451**示例**： 1452 1453详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 1454 1455 ```c 1456 #include "sensors/oh_sensor.h" 1457 #include "napi/native_api.h" 1458 #include "hilog/log.h" 1459 1460 const int SENSOR_LOG_DOMAIN = 0xD002700; 1461 const char *TAG = "[Sensor]"; 1462 1463 static napi_value SensorSubscriptionAttributeSetSamplingInterval(napi_env env, napi_callback_info info) { 1464 // 创建Sensor_SubscriptionAttribute实例。 1465 Sensor_SubscriptionAttribute *attr = OH_Sensor_CreateSubscriptionAttribute(); 1466 int64_t sensorSamplePeriod = 200000000; 1467 int32_t ret = OH_SensorSubscriptionAttribute_SetSamplingInterval(attr, sensorSamplePeriod); 1468 if (ret != SENSOR_SUCCESS) { 1469 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionAttribute_SetSamplingInterval failed"); 1470 } else { 1471 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionAttribute_SetSamplingInterval successful"); 1472 } 1473 // 销毁Sensor_SubscriptionAttribute实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁 1474 if (attr != nullptr) { 1475 OH_Sensor_DestroySubscriptionAttribute(attr); 1476 } 1477 napi_value result; 1478 napi_create_int32(env, ret, &result); 1479 return result; 1480 } 1481 ``` 1482 1483### OH_SensorSubscriptionId_GetType() 1484 1485``` 1486int32_t OH_SensorSubscriptionId_GetType(Sensor_SubscriptionId* id, Sensor_Type *sensorType) 1487``` 1488**描述**： 1489 1490获取传感器类型。 1491 1492**起始版本**：11 1493 1494**参数**： 1495 1496| 名称 | 描述 | 1497| -------- | -------- | 1498| id | 指向传感器订阅ID的指针。 | 1499| sensorType | 指向传感器类型的指针。 | 1500 1501**返回**： 1502 1503如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1504 1505 1506### OH_SensorSubscriptionId_SetType() 1507 1508``` 1509int32_t OH_SensorSubscriptionId_SetType(Sensor_SubscriptionId* id, const Sensor_Type sensorType) 1510``` 1511**描述**： 1512 1513设置传感器类型。 1514 1515**起始版本**：11 1516 1517**参数**： 1518 1519| 名称 | 描述 | 1520| -------- | -------- | 1521| id | 指向传感器订阅ID的指针。 | 1522| sensorType | 要设置的传感器类型。 | 1523 1524**返回**： 1525 1526如果操作成功返回**SENSOR_SUCCESS**；否则返回 [Sensor_Result](#sensor_result) 中定义的错误代码。 1527 1528**示例**： 1529 1530详细的开发步骤请参考[传感器开发指导](../../device/sensor/sensor-guidelines-capi.md)。 1531 1532 ```c 1533 #include "sensors/oh_sensor.h" 1534 #include "napi/native_api.h" 1535 #include "hilog/log.h" 1536 1537 const int SENSOR_LOG_DOMAIN = 0xD002700; 1538 const char *TAG = "[Sensor]"; 1539 1540 static napi_value SensorSubscriptionIdSetType(napi_env env, napi_callback_info info) { 1541 // 创建Sensor_SubscriptionId实例。 1542 Sensor_SubscriptionId *id = OH_Sensor_CreateSubscriptionId(); 1543 Sensor_Type sensorId { SENSOR_TYPE_ACCELEROMETER }; 1544 int32_t ret = OH_SensorSubscriptionId_SetType(id, sensorId); 1545 if (ret != SENSOR_SUCCESS) { 1546 OH_LOG_Print(LOG_APP, LOG_ERROR, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionId_SetType failed"); 1547 } else { 1548 OH_LOG_Print(LOG_APP, LOG_INFO, SENSOR_LOG_DOMAIN, TAG, "OH_SensorSubscriptionId_SetType successful"); 1549 } 1550 // 销毁Sensor_SubscriptionId实例：在实际应用中，创建的实例会被用于后续操作，在不再使用时销毁 1551 if (id != nullptr) { 1552 OH_Sensor_DestroySubscriptionId(id); 1553 } 1554 napi_value result; 1555 napi_create_int32(env, ret, &result); 1556 return result; 1557 } 1558 ```