From 044671b59006f7b2d415a3625150758259fbcc06 Mon Sep 17 00:00:00 2001 From: hellohyh001 Date: Fri, 15 Apr 2022 17:24:27 +0800 Subject: [PATCH 1/3] modify napi code Signed-off-by: hellohyh001 --- .../plugin/include/async_callback_info.h | 6 +- interfaces/plugin/include/sensor_js.h | 11 +- interfaces/plugin/include/sensor_napi_utils.h | 8 +- interfaces/plugin/include/sensor_system_js.h | 3 +- interfaces/plugin/src/sensor_js.cpp | 145 ++++++- interfaces/plugin/src/sensor_napi_utils.cpp | 63 ++- interfaces/plugin/src/sensor_system_js.cpp | 101 ++--- .../plugin/test/ExampleJsunit.test_system.js | 379 ++++++++++++++++++ 8 files changed, 643 insertions(+), 73 deletions(-) create mode 100644 interfaces/plugin/test/ExampleJsunit.test_system.js diff --git a/interfaces/plugin/include/async_callback_info.h b/interfaces/plugin/include/async_callback_info.h index 1b609643..e8e94a7d 100644 --- a/interfaces/plugin/include/async_callback_info.h +++ b/interfaces/plugin/include/async_callback_info.h @@ -14,6 +14,7 @@ */ #ifndef ASYNC_CALLBACK_INFO_H #define ASYNC_CALLBACK_INFO_H +#include #include "napi/native_api.h" #include "napi/native_node_api.h" @@ -46,7 +47,10 @@ enum CallbackDataType { GET_DIRECTION = 10, ROTATION_INCLINATION_MATRIX = 11, GET_SENSOR_LIST = 12, - GET_SINGLE_SENSOR = 13 + GET_SINGLE_SENSOR = 13, + SUBSCRIBE_CALLBACK = 14, + SUBSCRIBE_COMPASS = 15, + GET_BODY_STATE = 16, }; struct GeomagneticData { diff --git a/interfaces/plugin/include/sensor_js.h b/interfaces/plugin/include/sensor_js.h index 8f5b1afb..61fe210b 100644 --- a/interfaces/plugin/include/sensor_js.h +++ b/interfaces/plugin/include/sensor_js.h @@ -14,12 +14,17 @@ */ #ifndef SENSOR_JS_H #define SENSOR_JS_H +#include "napi/native_api.h" +#include "napi/native_node_api.h" #include "sensor_agent.h" namespace OHOS { namespace Sensors { -static bool UnsubscribeSensor(int32_t sensorTypeId); -static void DataCallbackImpl(SensorEvent *event); -static bool SubscribeSensor(int32_t sensorTypeId, int64_t interval, RecordSensorCallback callback); +bool UnsubscribeSensor(int32_t sensorTypeId); +void DataCallbackImpl(SensorEvent *event); +bool SubscribeSensor(int32_t sensorTypeId, int64_t interval, RecordSensorCallback callback); +napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId, CallbackDataType type); +napi_value Unsubscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId); +napi_value GetBodyState(napi_env env, napi_callback_info info); } // namespace Sensors } // namespace OHOS #endif // SENSOR_JS_H \ No newline at end of file diff --git a/interfaces/plugin/include/sensor_napi_utils.h b/interfaces/plugin/include/sensor_napi_utils.h index aaf3623d..469b3370 100644 --- a/interfaces/plugin/include/sensor_napi_utils.h +++ b/interfaces/plugin/include/sensor_napi_utils.h @@ -16,7 +16,6 @@ #define SENSOR_NAPI_UTILS_H #include -#include #include "async_callback_info.h" #include "refbase.h" @@ -35,9 +34,11 @@ bool GetCppDouble(const napi_env &env, const napi_value &value, double &number); bool GetCppBool(const napi_env &env, const napi_value &value); bool GetFloatArray(const napi_env &env, const napi_value &value, vector &array); bool GetCppInt64(const napi_env &env, const napi_value &value, int64_t &number); +bool RegisterNapiCallback(const napi_env &env, const napi_value &value, napi_ref &callback); napi_value GetNamedProperty(const napi_env &env, const napi_value &object, string name); bool GetCppFloat(const napi_env &env, const napi_value &value, float &number); napi_value GetNapiInt32(const napi_env &env, int32_t number); +bool GetStringValue(const napi_env &env, const napi_value &value, string &result); void EmitAsyncCallbackWork(sptr asyncCallbackInfo); void EmitUvEventLoop(sptr asyncCallbackInfo); void EmitPromiseWork(sptr asyncCallbackInfo); @@ -53,6 +54,11 @@ bool ConvertToSensorData(const napi_env &env, sptr asyncCallb bool CreateNapiArray(const napi_env &env, float *data, int32_t dataLength, napi_value &result); bool ConvertToSensorInfos(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]); bool ConvertToSingleSensor(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]); +bool ConvertToBodyData(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]); +bool CreateFailMessage(CallbackDataType type, int32_t code, string message, + sptr &asyncCallbackInfo); +bool ConvertToBodyData(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]); +bool ConvertToCompass(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]); #define GET_AND_THROW_NAPI_ERROR(env, message) \ do { \ diff --git a/interfaces/plugin/include/sensor_system_js.h b/interfaces/plugin/include/sensor_system_js.h index 6235883f..803a5255 100644 --- a/interfaces/plugin/include/sensor_system_js.h +++ b/interfaces/plugin/include/sensor_system_js.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -14,6 +14,7 @@ */ #ifndef SENSOR_SYSTEM_JS_H #define SENSOR_SYSTEM_JS_H +#include "async_callback_info.h" #include "napi/native_api.h" #include "napi/native_node_api.h" namespace OHOS { diff --git a/interfaces/plugin/src/sensor_js.cpp b/interfaces/plugin/src/sensor_js.cpp index c0cc3a63..1d953759 100644 --- a/interfaces/plugin/src/sensor_js.cpp +++ b/interfaces/plugin/src/sensor_js.cpp @@ -26,9 +26,6 @@ #include #include "geomagnetic_field.h" - -#include "napi/native_api.h" -#include "napi/native_node_api.h" #include "refbase.h" #include "securec.h" #include "sensor_algorithm.h" @@ -41,12 +38,25 @@ constexpr int32_t QUATERNION_LENGTH = 4; constexpr int32_t ROTATION_VECTOR_LENGTH = 3; constexpr int32_t REPORTING_INTERVAL = 200000000; constexpr int32_t INVALID_SENSOR_ID = -1; +constexpr int32_t SENSOR_SUBSCRIBE_FAILURE = 1001; +constexpr int32_t INPUT_ERROR = 202; +constexpr float BODY_STATE_EXCEPT = 1.0f; +constexpr float THREESHOLD = 0.000001f; } - +static std::map g_samplingPeriod = { + {"normal", 200000000}, + {"ui", 60000000}, + {"game", 20000000}, +}; +static std::mutex mutex_; +static std::mutex bodyMutex_; +static float g_bodyState = -1.0f; +static std::map> g_subscribeCallbacks; static std::mutex onMutex_; static std::mutex onceMutex_; static std::map>> g_onceCallbackInfos; static std::map>> g_onCallbackInfos; + static bool CheckSubscribe(int32_t sensorTypeId) { std::lock_guard onCallbackLock(onMutex_); @@ -59,10 +69,18 @@ static bool copySensorData(sptr callbackInfo, SensorEvent *ev { CHKPF(callbackInfo); CHKPF(event); - callbackInfo->data.sensorData.sensorTypeId = event->sensorTypeId; + int32_t sensorTypeId = event->sensorTypeId; + callbackInfo->data.sensorData.sensorTypeId = sensorTypeId; callbackInfo->data.sensorData.dataLength = event->dataLen; callbackInfo->data.sensorData.timestamp = event->timestamp; auto data = reinterpret_cast(event->data); + if (sensorTypeId == SENSOR_TYPE_ID_WEAR_DETECTION && callbackInfo->type == SUBSCRIBE_CALLBACK) { + std::lock_guard onBodyLock(bodyMutex_); + g_bodyState = *data; + callbackInfo->data.sensorData.data[0] = + (fabs(g_bodyState - BODY_STATE_EXCEPT) < THREESHOLD) ? true : false; + return true; + } CHKPF(data); if (memcpy_s(callbackInfo->data.sensorData.data, event->dataLen, data, event->dataLen) != EOK) { SEN_HILOGE("Copy data failed"); @@ -71,6 +89,26 @@ static bool copySensorData(sptr callbackInfo, SensorEvent *ev return true; } +static bool CheckSystemSubscribe(int32_t sensorTypeId) +{ + std::lock_guard subscribeLock(mutex_); + auto iter = g_subscribeCallbacks.find(sensorTypeId); + CHKCF((iter != g_subscribeCallbacks.end()), "No client subscribe"); + return true; +} + +static void EmitSubscribeCallback(SensorEvent *event) +{ + CHKPV(event); + int32_t sensorTypeId = event->sensorTypeId; + CHKCV(CheckSystemSubscribe(sensorTypeId), "No client subscribe"); + + std::lock_guard subscribeLock(mutex_); + auto callback = g_subscribeCallbacks[sensorTypeId]; + CHKCV(copySensorData(callback, event), "Copy sensor data failed"); + EmitUvEventLoop(callback); +} + static void EmitOnCallback(SensorEvent *event) { CHKPV(event); @@ -111,18 +149,19 @@ static void EmitOnceCallback(SensorEvent *event) UnsubscribeSensor(sensorTypeId); } -static void DataCallbackImpl(SensorEvent *event) +void DataCallbackImpl(SensorEvent *event) { CHKPV(event); EmitOnCallback(event); + EmitSubscribeCallback(event); EmitOnceCallback(event); } -static const SensorUser user = { +const SensorUser user = { .callback = DataCallbackImpl }; -static bool UnsubscribeSensor(int32_t sensorTypeId) +bool UnsubscribeSensor(int32_t sensorTypeId) { CALL_LOG_ENTER; CHKCF((DeactivateSensor(sensorTypeId, &user) == SUCCESS), "DeactivateSensor failed"); @@ -130,7 +169,7 @@ static bool UnsubscribeSensor(int32_t sensorTypeId) return true; } -static bool SubscribeSensor(int32_t sensorTypeId, int64_t interval, RecordSensorCallback callback) +bool SubscribeSensor(int32_t sensorTypeId, int64_t interval, RecordSensorCallback callback) { CALL_LOG_ENTER; CHKCF((SubscribeSensor(sensorTypeId, &user) == ERR_OK), "SubscribeSensor failed"); @@ -309,6 +348,10 @@ static napi_value Off(napi_env env, napi_callback_info info) CHKNCP(env, (RemoveCallback(env, sensorTypeId, args[1]) == 0), "There are other client subscribe as well, not need unsubscribe"); } + if (CheckSystemSubscribe(sensorTypeId)) { + SEN_HILOGW("There are other client subscribe system js api as well, not need unsubscribe"); + return nullptr; + } CHKNCP(env, UnsubscribeSensor(sensorTypeId), "UnsubscribeSensor failed"); return nullptr; } @@ -817,6 +860,90 @@ static napi_value GetSingleSensor(napi_env env, napi_callback_info info) return nullptr; } +napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId, CallbackDataType type) +{ + CALL_LOG_ENTER; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value thisVar = nullptr; + CHKNRP(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr), "napi_get_cb_info"); + CHKNCP(env, (argc == 1), "The number of parameters is not valid"); + CHKNCP(env, IsMatchType(env, args[0], napi_object), "Wrong argument type, should be object"); + + string interval = "normal"; + if ((sensorTypeId == SENSOR_TYPE_ID_ACCELEROMETER) || (sensorTypeId == SENSOR_TYPE_ID_ORIENTATION) + || (sensorTypeId == SENSOR_TYPE_ID_GYROSCOPE)) { + napi_value napiInterval = GetNamedProperty(env, args[0], "interval"); + CHKNCP(env, GetStringValue(env, napiInterval, interval), "get interval fail"); + } + sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env, type); + CHKPP(asyncCallbackInfo); + napi_value napiSuccess = GetNamedProperty(env, args[0], "success"); + CHKNCP(env, RegisterNapiCallback(env, napiSuccess, asyncCallbackInfo->callback[0]), + "register callback fail"); + napi_value napiFail = GetNamedProperty(env, args[0], "success"); + if (napiFail != nullptr) { + SEN_HILOGD("has fail callback"); + CHKNCP(env, RegisterNapiCallback(env, napiFail, asyncCallbackInfo->callback[1]), + "register callback fail"); + } + if (auto iter = g_samplingPeriod.find(interval); iter == g_samplingPeriod.end()) { + CHKNCP(env, (napiFail != nullptr), "input error, interval is invalid"); + CreateFailMessage(FAIL, INPUT_ERROR, "input error", asyncCallbackInfo); + EmitAsyncCallbackWork(asyncCallbackInfo); + return nullptr; + } + std::lock_guard subscribeCallbackLock(mutex_); + bool ret = SubscribeSensor(sensorTypeId, g_samplingPeriod[interval], DataCallbackImpl); + if (!ret) { + CHKNCP(env, (napiFail != nullptr), "subscribe fail"); + CreateFailMessage(FAIL, SENSOR_SUBSCRIBE_FAILURE, "subscribe fail", asyncCallbackInfo); + EmitAsyncCallbackWork(asyncCallbackInfo); + return nullptr; + } + g_subscribeCallbacks[sensorTypeId] = asyncCallbackInfo; + return nullptr; +} + +napi_value Unsubscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId) +{ + CALL_LOG_ENTER; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value thisVar = nullptr; + CHKNRP(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr), "napi_get_cb_info"); + CHKNCP(env, (argc == 0), "The number of parameters is not valid"); + std::lock_guard subscribeCallbackLock(mutex_); + g_subscribeCallbacks[sensorTypeId] = nullptr; + if (CheckSubscribe(sensorTypeId)) { + SEN_HILOGW("There are other client subscribe as well, not need unsubscribe"); + return nullptr; + } + CHKNCP(env, UnsubscribeSensor(sensorTypeId), "UnsubscribeSensor failed"); + return nullptr; +} + +napi_value GetBodyState(napi_env env, napi_callback_info info) +{ + CALL_LOG_ENTER; + size_t argc = 1; + napi_value args[1] = { 0 }; + napi_value thisVar = nullptr; + CHKNRP(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr), "napi_get_cb_info"); + CHKNCP(env, (argc == 1), "The number of parameters is not valid"); + CHKNCP(env, IsMatchType(env, args[0], napi_object), "Wrong argument type, should be object"); + sptr asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env, GET_BODY_STATE); + CHKPP(asyncCallbackInfo); + napi_value napiSuccess = GetNamedProperty(env, args[0], "success"); + CHKNCP(env, RegisterNapiCallback(env, napiSuccess, asyncCallbackInfo->callback[0]), + "register success callback fail"); + std::lock_guard onBodyLock(bodyMutex_); + asyncCallbackInfo->data.sensorData.data[0] = + (fabs(g_bodyState - BODY_STATE_EXCEPT) < THREESHOLD) ? true : false; + EmitUvEventLoop(asyncCallbackInfo); + return nullptr; +} + static napi_value EnumClassConstructor(napi_env env, napi_callback_info info) { size_t argc = 0; diff --git a/interfaces/plugin/src/sensor_napi_utils.cpp b/interfaces/plugin/src/sensor_napi_utils.cpp index 3d5edf47..aa6da876 100644 --- a/interfaces/plugin/src/sensor_napi_utils.cpp +++ b/interfaces/plugin/src/sensor_napi_utils.cpp @@ -21,7 +21,9 @@ namespace OHOS { namespace Sensors { -using namespace OHOS::HiviewDFX; +namespace { + constexpr int32_t STRING_LENGTH_MAX = 64; +} bool IsSameValue(const napi_env &env, const napi_value &lhs, const napi_value &rhs) { CALL_LOG_ENTER; @@ -116,6 +118,36 @@ napi_value GetNapiInt32(const napi_env &env, int32_t number) return value; } +bool GetStringValue(const napi_env &env, const napi_value &value, string &result) +{ + CALL_LOG_ENTER; + CHKNCF(env, IsMatchType(env, value, napi_string), "Wrong argument type. String or function expected"); + char buf[STRING_LENGTH_MAX] = { 0 }; + size_t copyLength = 0; + CHKNRF(env, napi_get_value_string_utf8(env, value, buf, STRING_LENGTH_MAX, ©Length), + "napi_get_value_string_utf8"); + result = std::string(buf); + return true; +} + +bool RegisterNapiCallback(const napi_env &env, const napi_value &value, + napi_ref &callback) +{ + CHKNCF(env, IsMatchType(env, value, napi_function), "Wrong argument type, should be function"); + CHKNRF(env, napi_create_reference(env, value, 1, &callback), "napi_create_reference"); + return true; +} + +bool CreateFailMessage(CallbackDataType type, int32_t code, string message, + sptr &asyncCallbackInfo) +{ + CHKPF(asyncCallbackInfo); + asyncCallbackInfo->type = type; + asyncCallbackInfo->error.code = code; + asyncCallbackInfo->error.message = message; + return true; +} + std::map> g_sensorAttributeList = { { 0, { "x" } }, { SENSOR_TYPE_ID_ACCELEROMETER, { "x", "y", "z" } }, @@ -156,6 +188,9 @@ std::map g_convertfuncList = { {ROTATION_INCLINATION_MATRIX, ConvertToRotationMatrix}, {GET_SENSOR_LIST, ConvertToSensorInfos}, {GET_SINGLE_SENSOR, ConvertToSingleSensor}, + {GET_BODY_STATE, ConvertToBodyData}, + {SUBSCRIBE_CALLBACK, ConvertToSensorData}, + {SUBSCRIBE_COMPASS, ConvertToCompass}, }; bool getJsonObject(const napi_env &env, sptr asyncCallbackInfo, napi_value &result) @@ -274,6 +309,10 @@ bool ConvertToSensorData(const napi_env &env, sptr asyncCallb CHKPF(asyncCallbackInfo); int32_t sensorTypeId = asyncCallbackInfo->data.sensorData.sensorTypeId; CHKNCF(env, (g_sensorAttributeList.find(sensorTypeId) != g_sensorAttributeList.end()), "Invalid sensor type"); + if (sensorTypeId == SENSOR_TYPE_ID_WEAR_DETECTION && asyncCallbackInfo->type == SUBSCRIBE_CALLBACK) { + return ConvertToBodyData(env, asyncCallbackInfo, result); + } + size_t size = g_sensorAttributeList[sensorTypeId].size(); uint32_t dataLenth = asyncCallbackInfo->data.sensorData.dataLength / sizeof(float); CHKNCF(env, (size <= dataLenth), "Data length mismatch"); @@ -301,6 +340,28 @@ bool ConvertToGeomagneticData(const napi_env &env, sptr async return getJsonObject(env, asyncCallbackInfo, result[1]); } +bool ConvertToBodyData(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]) +{ + CALL_LOG_ENTER; + CHKPF(asyncCallbackInfo); + napi_value status = nullptr; + CHKNRF(env, napi_get_boolean(env, asyncCallbackInfo->data.sensorData.data[0], &status), + "napi_get_boolean"); + CHKNRF(env, napi_set_named_property(env, result[1], "value", status), "napi_set_named_property"); + return true; +} + +bool ConvertToCompass(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]) +{ + CALL_LOG_ENTER; + CHKPF(asyncCallbackInfo); + napi_value message = nullptr; + CHKNRF(env, napi_create_double(env, asyncCallbackInfo->data.sensorData.data[0], &message), + "napi_create_double"); + CHKNRF(env, napi_set_named_property(env, result[1], "direction", message), "napi_set_named_property"); + return true; +} + bool ConvertToNumber(const napi_env &env, sptr asyncCallbackInfo, napi_value result[2]) { CALL_LOG_ENTER; diff --git a/interfaces/plugin/src/sensor_system_js.cpp b/interfaces/plugin/src/sensor_system_js.cpp index 39d4cbb5..0cb17ae1 100644 --- a/interfaces/plugin/src/sensor_system_js.cpp +++ b/interfaces/plugin/src/sensor_system_js.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2022 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -13,183 +13,170 @@ * limitations under the License. */ #include "sensor_system_js.h" +#include "sensor_js.h" +#include "sensor_napi_utils.h" -#include "hilog/log.h" -#include "sensor_agent_type.h" namespace OHOS { namespace Sensors { -using namespace OHOS::HiviewDFX; -static constexpr HiLogLabel LABEL = {LOG_CORE, 0xD002708, "SensorSystemJs"}; - -static napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId) -{ - return nullptr; -} - -static napi_value Unsubscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId) -{ - return nullptr; -} - napi_value SubscribeAccelerometer(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_ACCELEROMETER); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_ACCELEROMETER, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeAccelerometer(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_ACCELEROMETER); } napi_value SubscribeCompass(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_ORIENTATION); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_ORIENTATION, SUBSCRIBE_COMPASS); } napi_value UnsubscribeCompass(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_ORIENTATION); } napi_value SubscribeProximity(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_PROXIMITY); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_PROXIMITY, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeProximity(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_PROXIMITY); } napi_value SubscribeLight(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_AMBIENT_LIGHT); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_AMBIENT_LIGHT, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeLight(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_AMBIENT_LIGHT); } napi_value SubscribeStepCounter(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_PEDOMETER); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_PEDOMETER, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeStepCounter(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_PEDOMETER); } napi_value SubscribeBarometer(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_BAROMETER); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_BAROMETER, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeBarometer(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_BAROMETER); } napi_value SubscribeHeartRate(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_HEART_RATE); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_HEART_RATE, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeHeartRate(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_HEART_RATE); } napi_value SubscribeOnBodyState(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_WEAR_DETECTION); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_WEAR_DETECTION, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeOnBodyState(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_WEAR_DETECTION); } napi_value GetOnBodyState(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return nullptr; + CALL_LOG_ENTER; + return GetBodyState(env, info); } napi_value SubscribeDeviceOrientation(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_ORIENTATION); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_ORIENTATION, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeDeviceOrientation(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_ORIENTATION); } napi_value SubscribeGyroscope(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_GYROSCOPE); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_GYROSCOPE, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeGyroscope(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_GYROSCOPE); } napi_value SubscribeGravity(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_GRAVITY); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_GRAVITY, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeGravity(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_GRAVITY); } napi_value SubscribeMagnetic(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_MAGNETIC_FIELD); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_MAGNETIC_FIELD, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeMagnetic(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_MAGNETIC_FIELD); } napi_value SubscribeHall(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); - return Subscribe(env, info, SENSOR_TYPE_ID_HALL); + CALL_LOG_ENTER; + return Subscribe(env, info, SENSOR_TYPE_ID_HALL, SUBSCRIBE_CALLBACK); } napi_value UnsubscribeHall(napi_env env, napi_callback_info info) { - HiLog::Debug(LABEL, "%{public}s in", __func__); + CALL_LOG_ENTER; return Unsubscribe(env, info, SENSOR_TYPE_ID_HALL); } } // namespace Sensors diff --git a/interfaces/plugin/test/ExampleJsunit.test_system.js b/interfaces/plugin/test/ExampleJsunit.test_system.js new file mode 100644 index 00000000..17233466 --- /dev/null +++ b/interfaces/plugin/test/ExampleJsunit.test_system.js @@ -0,0 +1,379 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import sensor from '@system.sensor' + +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' + +describe("SensorJsTest", function () { + beforeAll(function() { + /* + * @tc.setup: setup invoked before all testcases + */ + console.info('beforeAll caled') + }) + + afterAll(function() { + /* + * @tc.teardown: teardown invoked after all testcases + */ + console.info('afterAll caled') + }) + + beforeEach(function() { + /* + * @tc.setup: setup invoked before each testcases + */ + console.info('beforeEach caled') + }) + + afterEach(function() { + /* + * @tc.teardown: teardown invoked after each testcases + */ + console.info('afterEach caled') + }) + + /* + * @tc.name:SensorJsTest001 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest001", 0, async function (done) { + console.info('----------------------SensorJsTest001---------------------------'); + sensor.subscribeAccelerometer({ + interval: 'normal', + success: function(data) { + expect(typeof(data.x)).assertEqual("number"); + expect(typeof(data.y)).assertEqual("number"); + expect(typeof(data.z)).assertEqual("number"); + console.info("callback2" + JSON.stringify(data)); + done(); + }, + fail: function(data, code) { + expect(false).assertTrue(); + console.error('Subscription failed. Code: ' + code + '; Data: ' + data); + done(); + }, + }); + }) + + /* + * @tc.name:SensorJsTest002 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest002", 0, async function (done) { + console.info('----------------------SensorJsTest002---------------------------'); + try { + sensor.unsubscribeAccelerometer(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) + + /* + * @tc.name:SensorJsTest003 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest003", 0, async function (done) { + console.info('----------------------SensorJsTest003---------------------------'); + sensor.subscribeCompass({ + success: function(data) { + console.log('get data direction:' + ret.direction); + expect(typeof(data.direction)).assertEqual("number"); + done(); + }, + fail: function(data, code) { + console.info(error); + expect(false).assertTrue(); + done(); + }, + }); + }) + + /* + * @tc.name:SensorJsTest004 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest004", 0, function (done) { + console.info('----------------------SensorJsTest004---------------------------'); + try { + sensor.unsubscribeCompass(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) + + /* + * @tc.name:SensorJsTest005 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest005", 0, async function (done) { + sensor.subscribeProximity({ + success: function(data) { + expect(typeof(data.distance)).assertEqual("number"); + console.info("subscribeProximity" + JSON.stringify(data)); + done(); + }, + fail: function(data, code) { + console.info(error); + expect(false).assertTrue(); + done(); + }, + }); + }) + + /* + * @tc.name:SensorJsTest006 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest006", 0, async function (done) { + try { + sensor.unsubscribeProximity(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) + + /* + * @tc.name:SensorJsTest007 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest007", 0, function (done) { + sensor.subscribeLight({ + success: function(data) { + expect(typeof(data.intensity)).assertEqual("number"); + console.info("subscribeLight" + JSON.stringify(data)); + done(); + }, + fail: function(data, code) { + console.info(error); + expect(false).assertTrue(); + done(); + }, + }); + }) + + /* + * @tc.name:SensorJsTest008 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest008", 0, async function (done) { + try { + sensor.unsubscribeLight(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) + + /* + * @tc.name:SensorJsTest009 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest009", 0, async function (done) { + sensor.subscribeStepCounter({ + success: function(data) { + expect(typeof(data.steps)).assertEqual("number"); + console.info("subscribeStepCounter" + JSON.stringify(data)); + done(); + }, + fail: function(data, code) { + console.info(error); + expect(false).assertTrue(); + done(); + }, + }); + }) + + /* + * @tc.name:SensorJsTest010 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest010", 0, async function (done) { + try { + sensor.unsubscribeStepCounter(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) + + /* + * @tc.name:SensorJsTest011 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest011", 0, async function (done) { + sensor.subscribeBarometer({ + success: function(data) { + expect(typeof(data.pressure)).assertEqual("number"); + console.info("subscribeBarometer" + JSON.stringify(data)); + done(); + }, + fail: function(data, code) { + console.info(error); + expect(false).assertTrue(); + done(); + }, + }); + }) + + /* + * @tc.name:SensorJsTest012 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest012", 0, async function (done) { + try { + sensor.unsubscribeBarometer(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) + + /* + * @tc.name:SensorJsTest013 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest013", 0, function (done) { + sensor.subscribeHeartRate({ + success: function(data) { + expect(typeof(data.heartRate)).assertEqual("number"); + console.info("subscribeHeartRate" + JSON.stringify(data)); + done(); + }, + fail: function(data, code) { + console.info(error); + expect(false).assertTrue(); + done(); + }, + }); + }) + + /* + * @tc.name:SensorJsTest014 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest014", 0, async function (done) { + try { + sensor.unsubscribeHeartRate(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) + + /* + * @tc.name:SensorJsTest015 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest015", 0, async function (done) { + console.info('----------------------SensorJsTest015---------------------------'); + sensor.subscribeOnBodyState({ + success: function(data) { + expect(typeof(data.value)).assertEqual("number"); + console.info("subscribeOnBodyState" + JSON.stringify(data)); + done(); + }, + fail: function(data, code) { + console.info(error); + expect(false).assertTrue(); + done(); + }, + }); + }) + + /** + * test + * + * @tc.name: SensorJsTest_016 + * @tc.desc: Verification results of the incorrect parameters of the test interface. + * @tc.require: AR000GH2U6 + * @tc.author: + */ + it('SensorJsTest016', 0, async function (done) { + console.info("---------------------------SensorJsTest016----------------------------------"); + sensor.getOnBodyState({ + success: function(data) { + expect(typeof(data.value)).assertEqual("number"); + console.info("subscribeOnBodyState" + JSON.stringify(data)); + done(); + } + }); + }) + + /* + * @tc.name:SensorJsTest017 + * @tc.desc:verify app info is not null + * @tc.type: FUNC + * @tc.require: Issue Number + */ + it("SensorJsTest017", 0, async function (done) { + console.info('----------------------SensorJsTest017---------------------------'); + try { + sensor.unsubscribeOnBodyState(); + } catch (error) { + console.info(error); + expect(false).assertTrue(); + done(); + } + expect(true).assertTrue(); + }) +}) -- Gitee From fa7526c665ff68c2c322b6751a386f1a70f63483 Mon Sep 17 00:00:00 2001 From: hellohyh001 Date: Sat, 16 Apr 2022 10:09:45 +0800 Subject: [PATCH 2/3] modify napi code Signed-off-by: hellohyh001 --- interfaces/plugin/include/async_callback_info.h | 1 + interfaces/plugin/include/sensor_js.h | 1 + interfaces/plugin/include/sensor_system_js.h | 1 - interfaces/plugin/src/sensor_js.cpp | 10 ++++++---- interfaces/plugin/src/sensor_napi_utils.cpp | 16 ++++++++++++++-- 5 files changed, 22 insertions(+), 7 deletions(-) diff --git a/interfaces/plugin/include/async_callback_info.h b/interfaces/plugin/include/async_callback_info.h index e8e94a7d..17d9c2a7 100644 --- a/interfaces/plugin/include/async_callback_info.h +++ b/interfaces/plugin/include/async_callback_info.h @@ -33,6 +33,7 @@ constexpr int32_t THREE_DIMENSIONAL_MATRIX_LENGTH = 9; constexpr static int32_t DATA_LENGTH = 16; constexpr int32_t CALLBACK_NUM = 3; enum CallbackDataType { + SUBSCRIBE_FAIL = -2, FAIL = -1, OFF_CALLBACK = 0, ON_CALLBACK = 1, diff --git a/interfaces/plugin/include/sensor_js.h b/interfaces/plugin/include/sensor_js.h index 61fe210b..3f4e8c34 100644 --- a/interfaces/plugin/include/sensor_js.h +++ b/interfaces/plugin/include/sensor_js.h @@ -14,6 +14,7 @@ */ #ifndef SENSOR_JS_H #define SENSOR_JS_H +#include "async_callback_info.h" #include "napi/native_api.h" #include "napi/native_node_api.h" #include "sensor_agent.h" diff --git a/interfaces/plugin/include/sensor_system_js.h b/interfaces/plugin/include/sensor_system_js.h index 803a5255..e8ba5634 100644 --- a/interfaces/plugin/include/sensor_system_js.h +++ b/interfaces/plugin/include/sensor_system_js.h @@ -14,7 +14,6 @@ */ #ifndef SENSOR_SYSTEM_JS_H #define SENSOR_SYSTEM_JS_H -#include "async_callback_info.h" #include "napi/native_api.h" #include "napi/native_node_api.h" namespace OHOS { diff --git a/interfaces/plugin/src/sensor_js.cpp b/interfaces/plugin/src/sensor_js.cpp index 1d953759..a3d9c68a 100644 --- a/interfaces/plugin/src/sensor_js.cpp +++ b/interfaces/plugin/src/sensor_js.cpp @@ -146,6 +146,7 @@ static void EmitOnceCallback(SensorEvent *event) g_onceCallbackInfos.erase(sensorTypeId); CHKCV((!CheckSubscribe(sensorTypeId)), "Has client subscribe, not need cancel subscribe"); + CHKCV((!CheckSystemSubscribe(sensorTypeId)), "Has client subscribe system api, not need cancel subscribe"); UnsubscribeSensor(sensorTypeId); } @@ -239,7 +240,7 @@ static bool IsSubscribed(napi_env env, int32_t sensorTypeId, napi_value callback { CALL_LOG_ENTER; if (auto iter = g_onCallbackInfos.find(sensorTypeId); iter == g_onCallbackInfos.end()) { - SEN_HILOGW("already subscribe, sensorTypeId: %{public}d", sensorTypeId); + SEN_HILOGW("no client subscribe, sensorTypeId: %{public}d", sensorTypeId); return false; } std::vector> callbackInfos = g_onCallbackInfos[sensorTypeId]; @@ -871,7 +872,8 @@ napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId CHKNCP(env, IsMatchType(env, args[0], napi_object), "Wrong argument type, should be object"); string interval = "normal"; - if ((sensorTypeId == SENSOR_TYPE_ID_ACCELEROMETER) || (sensorTypeId == SENSOR_TYPE_ID_ORIENTATION) + if ((sensorTypeId == SENSOR_TYPE_ID_ACCELEROMETER) || + ((sensorTypeId == SENSOR_TYPE_ID_ORIENTATION) && (type != SUBSCRIBE_COMPASS)) || (sensorTypeId == SENSOR_TYPE_ID_GYROSCOPE)) { napi_value napiInterval = GetNamedProperty(env, args[0], "interval"); CHKNCP(env, GetStringValue(env, napiInterval, interval), "get interval fail"); @@ -889,7 +891,7 @@ napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId } if (auto iter = g_samplingPeriod.find(interval); iter == g_samplingPeriod.end()) { CHKNCP(env, (napiFail != nullptr), "input error, interval is invalid"); - CreateFailMessage(FAIL, INPUT_ERROR, "input error", asyncCallbackInfo); + CreateFailMessage(SUBSCRIBE_FAIL, INPUT_ERROR, "input error", asyncCallbackInfo); EmitAsyncCallbackWork(asyncCallbackInfo); return nullptr; } @@ -897,7 +899,7 @@ napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId bool ret = SubscribeSensor(sensorTypeId, g_samplingPeriod[interval], DataCallbackImpl); if (!ret) { CHKNCP(env, (napiFail != nullptr), "subscribe fail"); - CreateFailMessage(FAIL, SENSOR_SUBSCRIBE_FAILURE, "subscribe fail", asyncCallbackInfo); + CreateFailMessage(SUBSCRIBE_FAIL, SENSOR_SUBSCRIBE_FAILURE, "subscribe fail", asyncCallbackInfo); EmitAsyncCallbackWork(asyncCallbackInfo); return nullptr; } diff --git a/interfaces/plugin/src/sensor_napi_utils.cpp b/interfaces/plugin/src/sensor_napi_utils.cpp index aa6da876..7c95eca1 100644 --- a/interfaces/plugin/src/sensor_napi_utils.cpp +++ b/interfaces/plugin/src/sensor_napi_utils.cpp @@ -344,6 +344,7 @@ bool ConvertToBodyData(const napi_env &env, sptr asyncCallbac { CALL_LOG_ENTER; CHKPF(asyncCallbackInfo); + CHKNRF(env, napi_create_object(env, &result[1]), "napi_create_object"); napi_value status = nullptr; CHKNRF(env, napi_get_boolean(env, asyncCallbackInfo->data.sensorData.data[0], &status), "napi_get_boolean"); @@ -355,6 +356,7 @@ bool ConvertToCompass(const napi_env &env, sptr asyncCallback { CALL_LOG_ENTER; CHKPF(asyncCallbackInfo); + CHKNRF(env, napi_create_object(env, &result[1]), "napi_create_object"); napi_value message = nullptr; CHKNRF(env, napi_create_double(env, asyncCallbackInfo->data.sensorData.data[0], &message), "napi_create_double"); @@ -461,10 +463,20 @@ void EmitAsyncCallbackWork(sptr asyncCallbackInfo) // The reference count of asyncCallbackInfo is subtracted by 1, and the function exits the destructor asyncCallbackInfo->callbackInfo = nullptr; napi_value callback = nullptr; - CHKNRV(env, napi_get_reference_value(env, asyncCallbackInfo->callback[0], &callback), - "napi_get_reference_value"); napi_value callResult = nullptr; napi_value result[2] = {0}; + if (asyncCallbackInfo->type == SUBSCRIBE_FAIL) { + CHKNRV(env, napi_get_reference_value(env, asyncCallbackInfo->callback[1], &callback), + "napi_get_reference_value") + CHKNRV(env, napi_create_string_utf8(env, asyncCallbackInfo->error.message.c_str(), + NAPI_AUTO_LENGTH, &result[0]), "napi_create_string_utf8"); + CHKNRV(env, napi_create_int32(env, asyncCallbackInfo->error.code, &result[1]), "napi_create_int32"); + CHKNRV(env, napi_call_function(env, nullptr, callback, 2, result, &callResult), + "napi_call_function"); + return; + } + CHKNRV(env, napi_get_reference_value(env, asyncCallbackInfo->callback[0], &callback), + "napi_get_reference_value"); CHKNCV(env, (g_convertfuncList.find(asyncCallbackInfo->type) != g_convertfuncList.end()), "Callback type invalid in async work"); bool ret = g_convertfuncList[asyncCallbackInfo->type](env, asyncCallbackInfo, result); -- Gitee From 190819bdc43c28d32f6d2c503adcad8816e8484a Mon Sep 17 00:00:00 2001 From: SUE Date: Sat, 16 Apr 2022 03:02:12 +0000 Subject: [PATCH 3/3] Signed-off-by:hellohyh001 --- interfaces/plugin/src/sensor_napi_utils.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/interfaces/plugin/src/sensor_napi_utils.cpp b/interfaces/plugin/src/sensor_napi_utils.cpp index 7c95eca1..d00ac1b9 100644 --- a/interfaces/plugin/src/sensor_napi_utils.cpp +++ b/interfaces/plugin/src/sensor_napi_utils.cpp @@ -467,7 +467,7 @@ void EmitAsyncCallbackWork(sptr asyncCallbackInfo) napi_value result[2] = {0}; if (asyncCallbackInfo->type == SUBSCRIBE_FAIL) { CHKNRV(env, napi_get_reference_value(env, asyncCallbackInfo->callback[1], &callback), - "napi_get_reference_value") + "napi_get_reference_value"); CHKNRV(env, napi_create_string_utf8(env, asyncCallbackInfo->error.message.c_str(), NAPI_AUTO_LENGTH, &result[0]), "napi_create_string_utf8"); CHKNRV(env, napi_create_int32(env, asyncCallbackInfo->error.code, &result[1]), "napi_create_int32"); -- Gitee