• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "sensor_js.h"
16 
17 #include <cinttypes>
18 #include <cstdlib>
19 #include <map>
20 #include <cmath>
21 #include <string>
22 #include <unistd.h>
23 
24 #include "refbase.h"
25 #include "securec.h"
26 
27 #include "geomagnetic_field.h"
28 #include "sensor_algorithm.h"
29 #include "sensor_napi_error.h"
30 #include "sensor_napi_utils.h"
31 #include "sensor_system_js.h"
32 
33 namespace OHOS {
34 namespace Sensors {
35 namespace {
36 constexpr int32_t QUATERNION_LENGTH = 4;
37 constexpr int32_t ROTATION_VECTOR_LENGTH = 3;
38 constexpr int32_t REPORTING_INTERVAL = 200000000;
39 constexpr int32_t INVALID_SENSOR_ID = -1;
40 constexpr int32_t SENSOR_SUBSCRIBE_FAILURE = 1001;
41 constexpr int32_t INPUT_ERROR = 202;
42 constexpr float BODY_STATE_EXCEPT = 1.0f;
43 constexpr float THRESHOLD = 0.000001f;
44 }
45 static std::map<std::string, int64_t> g_samplingPeriod = {
46     {"normal", 200000000},
47     {"ui", 60000000},
48     {"game", 20000000},
49 };
50 static std::mutex mutex_;
51 static std::mutex bodyMutex_;
52 static float g_bodyState = -1.0f;
53 static std::map<int32_t, std::vector<sptr<AsyncCallbackInfo>>> g_subscribeCallbacks;
54 static std::mutex onMutex_;
55 static std::mutex onceMutex_;
56 static std::map<int32_t, std::vector<sptr<AsyncCallbackInfo>>> g_onceCallbackInfos;
57 static std::map<int32_t, std::vector<sptr<AsyncCallbackInfo>>> g_onCallbackInfos;
58 
CheckSubscribe(int32_t sensorTypeId)59 static bool CheckSubscribe(int32_t sensorTypeId)
60 {
61     std::lock_guard<std::mutex> onCallbackLock(onMutex_);
62     auto iter = g_onCallbackInfos.find(sensorTypeId);
63     return iter != g_onCallbackInfos.end();
64 }
65 
copySensorData(sptr<AsyncCallbackInfo> callbackInfo,SensorEvent * event)66 static bool copySensorData(sptr<AsyncCallbackInfo> callbackInfo, SensorEvent *event)
67 {
68     CHKPF(callbackInfo);
69     CHKPF(event);
70     int32_t sensorTypeId = event->sensorTypeId;
71     callbackInfo->data.sensorData.sensorTypeId = sensorTypeId;
72     callbackInfo->data.sensorData.dataLength = event->dataLen;
73     callbackInfo->data.sensorData.timestamp = event->timestamp;
74     CHKPF(event->data);
75     auto data = reinterpret_cast<float *>(event->data);
76     if (sensorTypeId == SENSOR_TYPE_ID_WEAR_DETECTION && callbackInfo->type == SUBSCRIBE_CALLBACK) {
77         std::lock_guard<std::mutex> onBodyLock(bodyMutex_);
78         g_bodyState = *data;
79         callbackInfo->data.sensorData.data[0] =
80             (fabs(g_bodyState - BODY_STATE_EXCEPT) < THRESHOLD) ? true : false;
81         return true;
82     }
83     if (memcpy_s(callbackInfo->data.sensorData.data, sizeof(callbackInfo->data.sensorData.data),
84         data, event->dataLen) != EOK) {
85         SEN_HILOGE("Copy data failed");
86         return false;
87     }
88     return true;
89 }
90 
CheckSystemSubscribe(int32_t sensorTypeId)91 static bool CheckSystemSubscribe(int32_t sensorTypeId)
92 {
93     std::lock_guard<std::mutex> subscribeLock(mutex_);
94     auto iter = g_subscribeCallbacks.find(sensorTypeId);
95     if (iter == g_subscribeCallbacks.end()) {
96         return false;
97     }
98     return true;
99 }
100 
EmitSubscribeCallback(SensorEvent * event)101 static void EmitSubscribeCallback(SensorEvent *event)
102 {
103     CHKPV(event);
104     int32_t sensorTypeId = event->sensorTypeId;
105     if (!CheckSystemSubscribe(sensorTypeId)) {
106         return;
107     }
108     std::lock_guard<std::mutex> subscribeLock(mutex_);
109     auto callbacks = g_subscribeCallbacks[sensorTypeId];
110     for (auto &callback : callbacks) {
111         if (!copySensorData(callback, event)) {
112             SEN_HILOGE("Copy sensor data failed");
113             continue;
114         }
115         EmitUvEventLoop(callback);
116     }
117 }
118 
EmitOnCallback(SensorEvent * event)119 static void EmitOnCallback(SensorEvent *event)
120 {
121     CHKPV(event);
122     int32_t sensorTypeId = event->sensorTypeId;
123     if (!CheckSubscribe(sensorTypeId)) {
124         return;
125     }
126     std::lock_guard<std::mutex> onCallbackLock(onMutex_);
127     auto onCallbackInfos = g_onCallbackInfos[sensorTypeId];
128     for (auto &onCallbackInfo : onCallbackInfos) {
129         if (!copySensorData(onCallbackInfo, event)) {
130             SEN_HILOGE("Copy sensor data failed");
131             continue;
132         }
133         EmitUvEventLoop(onCallbackInfo);
134     }
135 }
136 
EmitOnceCallback(SensorEvent * event)137 static void EmitOnceCallback(SensorEvent *event)
138 {
139     CHKPV(event);
140     int32_t sensorTypeId = event->sensorTypeId;
141     std::lock_guard<std::mutex> onceCallbackLock(onceMutex_);
142     auto iter = g_onceCallbackInfos.find(sensorTypeId);
143     if (iter == g_onceCallbackInfos.end()) {
144         return;
145     }
146     auto& onceCallbackInfos = iter->second;
147     while (!onceCallbackInfos.empty()) {
148         auto onceCallbackInfo = onceCallbackInfos.front();
149         auto beginIter = onceCallbackInfos.begin();
150         onceCallbackInfos.erase(beginIter);
151         if (!copySensorData(onceCallbackInfo, event)) {
152             SEN_HILOGE("Copy sensor data failed");
153             continue;
154         }
155         EmitUvEventLoop(std::move(onceCallbackInfo));
156     }
157     g_onceCallbackInfos.erase(sensorTypeId);
158 
159     CHKCV((!CheckSubscribe(sensorTypeId)), "Has client subscribe, not need cancel subscribe");
160     CHKCV((!CheckSystemSubscribe(sensorTypeId)), "Has client subscribe system api, not need cancel subscribe");
161     UnsubscribeSensor(sensorTypeId);
162 }
163 
DataCallbackImpl(SensorEvent * event)164 void DataCallbackImpl(SensorEvent *event)
165 {
166     CHKPV(event);
167     EmitOnCallback(event);
168     EmitSubscribeCallback(event);
169     EmitOnceCallback(event);
170 }
171 
172 const SensorUser user = {
173     .callback = DataCallbackImpl
174 };
175 
UnsubscribeSensor(int32_t sensorTypeId)176 int32_t UnsubscribeSensor(int32_t sensorTypeId)
177 {
178     CALL_LOG_ENTER;
179     int32_t ret = DeactivateSensor(sensorTypeId, &user);
180     if (ret != ERR_OK) {
181         SEN_HILOGE("DeactivateSensor failed");
182         return ret;
183     }
184     return UnsubscribeSensor(sensorTypeId, &user);
185 }
186 
SubscribeSensor(int32_t sensorTypeId,int64_t interval,RecordSensorCallback callback)187 int32_t SubscribeSensor(int32_t sensorTypeId, int64_t interval, RecordSensorCallback callback)
188 {
189     CALL_LOG_ENTER;
190     int32_t ret = SubscribeSensor(sensorTypeId, &user);
191     if (ret != ERR_OK) {
192         SEN_HILOGE("SubscribeSensor failed");
193         return ret;
194     }
195     ret = SetBatch(sensorTypeId, &user, interval, 0);
196     if (ret != ERR_OK) {
197         SEN_HILOGE("SetBatch failed");
198         return ret;
199     }
200     return ActivateSensor(sensorTypeId, &user);
201 }
202 
IsOnceSubscribed(napi_env env,int32_t sensorTypeId,napi_value callback)203 static bool IsOnceSubscribed(napi_env env, int32_t sensorTypeId, napi_value callback)
204 {
205     CALL_LOG_ENTER;
206     if (auto iter = g_onceCallbackInfos.find(sensorTypeId); iter == g_onceCallbackInfos.end()) {
207         SEN_HILOGW("Already subscribed, sensorTypeId:%{public}d", sensorTypeId);
208         return false;
209     }
210     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_onceCallbackInfos[sensorTypeId];
211     for (auto callbackInfo : callbackInfos) {
212         CHKPC(callbackInfo);
213         if (callbackInfo->env != env) {
214             continue;
215         }
216         napi_value sensorCallback = nullptr;
217         CHKNRF(env, napi_get_reference_value(env, callbackInfo->callback[0], &sensorCallback),
218             "napi_get_reference_value");
219         if (IsSameValue(env, callback, sensorCallback)) {
220             return true;
221         }
222     }
223     return false;
224 }
225 
UpdateOnceCallback(napi_env env,int32_t sensorTypeId,napi_value callback)226 static void UpdateOnceCallback(napi_env env, int32_t sensorTypeId, napi_value callback)
227 {
228     CALL_LOG_ENTER;
229     std::lock_guard<std::mutex> onceCallbackLock(onceMutex_);
230     CHKCV((!IsOnceSubscribed(env, sensorTypeId, callback)), "The callback has been subscribed");
231     sptr<AsyncCallbackInfo> asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env, ONCE_CALLBACK);
232     CHKPV(asyncCallbackInfo);
233     napi_status status = napi_create_reference(env, callback, 1, &asyncCallbackInfo->callback[0]);
234     if (status != napi_ok) {
235         ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
236         return;
237     }
238     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_onceCallbackInfos[sensorTypeId];
239     callbackInfos.push_back(asyncCallbackInfo);
240     g_onceCallbackInfos[sensorTypeId] = callbackInfos;
241 }
242 
Once(napi_env env,napi_callback_info info)243 static napi_value Once(napi_env env, napi_callback_info info)
244 {
245     CALL_LOG_ENTER;
246     size_t argc = 2;
247     napi_value args[2] = { 0 };
248     napi_value thisVar = nullptr;
249     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
250     if (status != napi_ok || argc < 2) {
251         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
252         return nullptr;
253     }
254     if ((!IsMatchType(env, args[0], napi_number)) || (!IsMatchType(env, args[1], napi_function))) {
255         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type");
256         return nullptr;
257     }
258     int32_t sensorTypeId = INVALID_SENSOR_ID;
259     if (!GetNativeInt32(env, args[0], sensorTypeId)) {
260         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, get number fail");
261         return nullptr;
262     }
263     if (!CheckSubscribe(sensorTypeId)) {
264         SEN_HILOGD("No subscription to change sensor data, registration is required");
265         int32_t ret = SubscribeSensor(sensorTypeId, REPORTING_INTERVAL, DataCallbackImpl);
266         if (ret != ERR_OK) {
267             ThrowErr(env, ret, "SubscribeSensor fail");
268             return nullptr;
269         }
270     }
271     UpdateOnceCallback(env, sensorTypeId, args[1]);
272     return nullptr;
273 }
274 
IsSubscribed(napi_env env,int32_t sensorTypeId,napi_value callback)275 static bool IsSubscribed(napi_env env, int32_t sensorTypeId, napi_value callback)
276 {
277     CALL_LOG_ENTER;
278     if (auto iter = g_onCallbackInfos.find(sensorTypeId); iter == g_onCallbackInfos.end()) {
279         SEN_HILOGW("No client subscribe, sensorTypeId:%{public}d", sensorTypeId);
280         return false;
281     }
282     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_onCallbackInfos[sensorTypeId];
283     for (auto callbackInfo : callbackInfos) {
284         CHKPC(callbackInfo);
285         if (callbackInfo->env != env) {
286             continue;
287         }
288         napi_value sensorCallback = nullptr;
289         CHKNRF(env, napi_get_reference_value(env, callbackInfo->callback[0], &sensorCallback),
290             "napi_get_reference_value");
291         if (IsSameValue(env, callback, sensorCallback)) {
292             return true;
293         }
294     }
295     return false;
296 }
297 
UpdateCallbackInfos(napi_env env,int32_t sensorTypeId,napi_value callback)298 static void UpdateCallbackInfos(napi_env env, int32_t sensorTypeId, napi_value callback)
299 {
300     CALL_LOG_ENTER;
301     std::lock_guard<std::mutex> onCallbackLock(onMutex_);
302     CHKCV((!IsSubscribed(env, sensorTypeId, callback)), "The callback has been subscribed");
303     sptr<AsyncCallbackInfo> asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env, ON_CALLBACK);
304     CHKPV(asyncCallbackInfo);
305     napi_status status = napi_create_reference(env, callback, 1, &asyncCallbackInfo->callback[0]);
306     if (status != napi_ok) {
307         ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
308         return;
309     }
310     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_onCallbackInfos[sensorTypeId];
311     callbackInfos.push_back(asyncCallbackInfo);
312     g_onCallbackInfos[sensorTypeId] = callbackInfos;
313 }
314 
On(napi_env env,napi_callback_info info)315 static napi_value On(napi_env env, napi_callback_info info)
316 {
317     CALL_LOG_ENTER;
318     size_t argc = 3;
319     napi_value args[3] = { 0 };
320     napi_value thisVar = nullptr;
321     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
322     if (status != napi_ok || argc < 2) {
323         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
324         return nullptr;
325     }
326     if ((!IsMatchType(env, args[0], napi_number)) || (!IsMatchType(env, args[1], napi_function))) {
327         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type");
328         return nullptr;
329     }
330     int32_t sensorTypeId = INVALID_SENSOR_ID;
331     if (!GetNativeInt32(env, args[0], sensorTypeId)) {
332         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, get number fail");
333         return nullptr;
334     }
335     int64_t interval = REPORTING_INTERVAL;
336     if (argc >= 3 && IsMatchType(env, args[2], napi_object)) {
337         napi_value value = GetNamedProperty(env, args[2], "interval");
338         if (IsMatchType(env, value, napi_number)) {
339             GetNativeInt64(env, value, interval);
340         }
341     }
342     SEN_HILOGD("Interval is %{public}" PRId64, interval);
343     int32_t ret = SubscribeSensor(sensorTypeId, interval, DataCallbackImpl);
344     if (ret != ERR_OK) {
345         ThrowErr(env, ret, "SubscribeSensor fail");
346         return nullptr;
347     }
348     UpdateCallbackInfos(env, sensorTypeId, args[1]);
349     return nullptr;
350 }
351 
RemoveAllCallback(napi_env env,int32_t sensorTypeId)352 static int32_t RemoveAllCallback(napi_env env, int32_t sensorTypeId)
353 {
354     CALL_LOG_ENTER;
355     std::lock_guard<std::mutex> onCallbackLock(onMutex_);
356     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_onCallbackInfos[sensorTypeId];
357     for (auto iter = callbackInfos.begin(); iter != callbackInfos.end();) {
358         CHKPC(*iter);
359         if ((*iter)->env != env) {
360             ++iter;
361             continue;
362         }
363         iter = callbackInfos.erase(iter);
364     }
365     if (callbackInfos.empty()) {
366         SEN_HILOGD("No subscription to change sensor data");
367         g_onCallbackInfos.erase(sensorTypeId);
368         return 0;
369     }
370     g_onCallbackInfos[sensorTypeId] = callbackInfos;
371     return callbackInfos.size();
372 }
373 
RemoveCallback(napi_env env,int32_t sensorTypeId,napi_value callback)374 static int32_t RemoveCallback(napi_env env, int32_t sensorTypeId, napi_value callback)
375 {
376     CALL_LOG_ENTER;
377     std::lock_guard<std::mutex> onCallbackLock(onMutex_);
378     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_onCallbackInfos[sensorTypeId];
379     for (auto iter = callbackInfos.begin(); iter != callbackInfos.end(); ++iter) {
380         CHKPC(*iter);
381         if ((*iter)->env != env) {
382             continue;
383         }
384         napi_value sensorCallback = nullptr;
385         if (napi_get_reference_value(env, (*iter)->callback[0], &sensorCallback) != napi_ok) {
386             SEN_HILOGE("napi_get_reference_value fail");
387             continue;
388         }
389         if (IsSameValue(env, callback, sensorCallback)) {
390             callbackInfos.erase(iter++);
391             SEN_HILOGD("Remove callback success");
392             break;
393         }
394     }
395     if (callbackInfos.empty()) {
396         SEN_HILOGD("No subscription to change sensor data");
397         g_onCallbackInfos.erase(sensorTypeId);
398         return 0;
399     }
400     g_onCallbackInfos[sensorTypeId] = callbackInfos;
401     return callbackInfos.size();
402 }
403 
Off(napi_env env,napi_callback_info info)404 static napi_value Off(napi_env env, napi_callback_info info)
405 {
406     CALL_LOG_ENTER;
407     size_t argc = 2;
408     napi_value args[2] = { 0 };
409     napi_value thisVar = nullptr;
410     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
411     if (status != napi_ok || argc < 1) {
412         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
413         return nullptr;
414     }
415     int32_t sensorTypeId = INVALID_SENSOR_ID;
416     if ((!IsMatchType(env, args[0], napi_number)) || (!GetNativeInt32(env, args[0], sensorTypeId))) {
417         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type or get number fail");
418         return nullptr;
419     }
420     int32_t subscribeSize = -1;
421     if (argc == 1) {
422         subscribeSize = RemoveAllCallback(env, sensorTypeId);
423     } else if (IsMatchType(env, args[1], napi_undefined) || IsMatchType(env, args[1], napi_null)) {
424         subscribeSize = RemoveAllCallback(env, sensorTypeId);
425     } else if (IsMatchType(env, args[1], napi_function)) {
426         subscribeSize = RemoveCallback(env, sensorTypeId, args[1]);
427     } else {
428         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, args[1] should is napi_function");
429         return nullptr;
430     }
431     if (CheckSystemSubscribe(sensorTypeId) || (subscribeSize > 0)) {
432         SEN_HILOGW("There are other client subscribe system js api as well, not need unsubscribe");
433         return nullptr;
434     }
435     int32_t ret = UnsubscribeSensor(sensorTypeId);
436     if (ret == PARAMETER_ERROR || ret == PERMISSION_DENIED) {
437         ThrowErr(env, ret, "UnsubscribeSensor fail");
438     }
439     return nullptr;
440 }
441 
GetGeomagneticField(napi_env env,napi_callback_info info)442 static napi_value GetGeomagneticField(napi_env env, napi_callback_info info)
443 {
444     CALL_LOG_ENTER;
445     size_t argc = 3;
446     napi_value args[3] = { 0 };
447     napi_value thisVar = nullptr;
448     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
449     if (status != napi_ok || argc < 2) {
450         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
451         return nullptr;
452     }
453     if ((!IsMatchType(env, args[0], napi_object)) || (!IsMatchType(env, args[1], napi_number))) {
454         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type");
455         return nullptr;
456     }
457     napi_value napiLatitude = GetNamedProperty(env, args[0], "latitude");
458     if (napiLatitude == nullptr) {
459         ThrowErr(env, PARAMETER_ERROR, "napiLatitude is null");
460         return nullptr;
461     }
462     double latitude = 0;
463     if (!GetNativeDouble(env, napiLatitude, latitude)) {
464         ThrowErr(env, PARAMETER_ERROR, "Get latitude fail");
465         return nullptr;
466     }
467     napi_value napiLongitude = GetNamedProperty(env, args[0], "longitude");
468     if (napiLongitude == nullptr) {
469         ThrowErr(env, PARAMETER_ERROR, "napiLongitude is null");
470         return nullptr;
471     }
472     double longitude = 0;
473     if (!GetNativeDouble(env, napiLongitude, longitude)) {
474         ThrowErr(env, PARAMETER_ERROR, "Get longitude fail");
475         return nullptr;
476     }
477     napi_value napiAltitude = GetNamedProperty(env, args[0], "altitude");
478     if (napiAltitude == nullptr) {
479         ThrowErr(env, PARAMETER_ERROR, "napiAltitude is null");
480         return nullptr;
481     }
482     double altitude = 0;
483     if (!GetNativeDouble(env, napiAltitude, altitude)) {
484         ThrowErr(env, PARAMETER_ERROR, "Get altitude fail");
485         return nullptr;
486     }
487     int64_t timeMillis = 0;
488     if (!GetNativeInt64(env, args[1], timeMillis)) {
489         ThrowErr(env, PARAMETER_ERROR, "Get timeMillis fail");
490         return nullptr;
491     }
492     GeomagneticField geomagneticField(latitude, longitude, altitude, timeMillis);
493     sptr<AsyncCallbackInfo> asyncCallbackInfo =
494         new (std::nothrow) AsyncCallbackInfo(env, GET_GEOMAGNETIC_FIELD);
495     CHKPP(asyncCallbackInfo);
496     asyncCallbackInfo->data.geomagneticData = {
497         .x = geomagneticField.ObtainX(),
498         .y = geomagneticField.ObtainY(),
499         .z = geomagneticField.ObtainZ(),
500         .geomagneticDip = geomagneticField.ObtainGeomagneticDip(),
501         .deflectionAngle = geomagneticField.ObtainDeflectionAngle(),
502         .levelIntensity = geomagneticField.ObtainLevelIntensity(),
503         .totalIntensity = geomagneticField.ObtainTotalIntensity(),
504     };
505     if (argc >=3 && IsMatchType(env, args[2], napi_function)) {
506         status = napi_create_reference(env, args[2], 1, &asyncCallbackInfo->callback[0]);
507         if (status != napi_ok) {
508             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
509             return nullptr;
510         }
511         EmitAsyncCallbackWork(asyncCallbackInfo);
512         return nullptr;
513     }
514     napi_value promise = nullptr;
515     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
516     if (status != napi_ok) {
517         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
518         return nullptr;
519     }
520     EmitPromiseWork(asyncCallbackInfo);
521     return promise;
522 }
523 
GetAxisX(napi_env env,napi_value value)524 static napi_value GetAxisX(napi_env env, napi_value value)
525 {
526     return GetNamedProperty(env, value, "x");
527 }
528 
GetAxisY(napi_env env,napi_value value)529 static napi_value GetAxisY(napi_env env, napi_value value)
530 {
531     return GetNamedProperty(env, value, "y");
532 }
533 
TransformCoordinateSystem(napi_env env,napi_callback_info info)534 static napi_value TransformCoordinateSystem(napi_env env, napi_callback_info info)
535 {
536     CALL_LOG_ENTER;
537     size_t argc = 3;
538     napi_value args[3]  = { 0 };
539     napi_value thisVar = nullptr;
540     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
541     if (status != napi_ok || argc < 2) {
542         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
543         return nullptr;
544     }
545     if ((!IsMatchArrayType(env, args[0])) || (!IsMatchType(env, args[1], napi_object))) {
546         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type");
547         return nullptr;
548     }
549     std::vector<float> inRotationVector;
550     if (!GetFloatArray(env, args[0], inRotationVector)) {
551         ThrowErr(env, PARAMETER_ERROR, "Get inRotationVector fail");
552         return nullptr;
553     }
554     size_t length = inRotationVector.size();
555     if ((length != DATA_LENGTH) && (length != THREE_DIMENSIONAL_MATRIX_LENGTH)) {
556         ThrowErr(env, PARAMETER_ERROR, "Wrong inRotationVector length");
557         return nullptr;
558     }
559     napi_value napiAxisX = GetAxisX(env, args[1]);
560     if (napiAxisX == nullptr) {
561         ThrowErr(env, PARAMETER_ERROR, "napiAxisX is null");
562         return nullptr;
563     }
564     int32_t axisX = 0;
565     if (!GetNativeInt32(env, napiAxisX, axisX)) {
566         ThrowErr(env, PARAMETER_ERROR, "Get axisY fail");
567         return nullptr;
568     }
569     napi_value napiAxisY = GetAxisY(env, args[1]);
570     if (napiAxisY == nullptr) {
571         ThrowErr(env, PARAMETER_ERROR, "napiAxisY is null");
572         return nullptr;
573     }
574     int32_t axisY = 0;
575     if (!GetNativeInt32(env, napiAxisY, axisY)) {
576         ThrowErr(env, PARAMETER_ERROR, "Get axisY fail");
577         return nullptr;
578     }
579     sptr<AsyncCallbackInfo> asyncCallbackInfo =
580         new (std::nothrow) AsyncCallbackInfo(env, TRANSFORM_COORDINATE_SYSTEM);
581     CHKPP(asyncCallbackInfo);
582     std::vector<float> outRotationVector(length);
583     SensorAlgorithm sensorAlgorithm;
584     int32_t ret = sensorAlgorithm.TransformCoordinateSystem(inRotationVector, axisX, axisY, outRotationVector);
585     if (ret != OHOS::ERR_OK) {
586         ThrowErr(env, ret, "Transform coordinate system fail");
587         return nullptr;
588     } else {
589         for (size_t i = 0; i < length; ++i) {
590             asyncCallbackInfo->data.reserveData.reserve[i] = outRotationVector[i];
591         }
592         asyncCallbackInfo->data.reserveData.length = static_cast<int32_t>(length);
593     }
594     if (argc >= 3 && IsMatchType(env, args[2], napi_function)) {
595         status = napi_create_reference(env, args[2], 1, &asyncCallbackInfo->callback[0]);
596         if (status != napi_ok) {
597             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
598             return nullptr;
599         }
600         EmitAsyncCallbackWork(asyncCallbackInfo);
601         return nullptr;
602     }
603     napi_value promise = nullptr;
604     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
605     if (status != napi_ok) {
606         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
607         return nullptr;
608     }
609     EmitPromiseWork(asyncCallbackInfo);
610     return promise;
611 }
612 
GetAngleModify(napi_env env,napi_callback_info info)613 static napi_value GetAngleModify(napi_env env, napi_callback_info info)
614 {
615     CALL_LOG_ENTER;
616     size_t argc = 3;
617     napi_value args[3] = { 0 };
618     napi_value thisVar = nullptr;
619     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
620     if (status != napi_ok || argc < 2) {
621         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
622         return nullptr;
623     }
624     if (!IsMatchArrayType(env, args[0])) {
625         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be array");
626         return nullptr;
627     }
628     if (!IsMatchArrayType(env, args[1])) {
629         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be array");
630         return nullptr;
631     }
632     sptr<AsyncCallbackInfo> asyncCallbackInfo =
633         new (std::nothrow) AsyncCallbackInfo(env, GET_ANGLE_MODIFY);
634     CHKPP(asyncCallbackInfo);
635     std::vector<float> curRotationVector;
636     if (!GetFloatArray(env, args[0], curRotationVector)) {
637         ThrowErr(env, PARAMETER_ERROR, "Get curRotationVector fail");
638         return nullptr;
639     }
640     std::vector<float> preRotationVector;
641     if (!GetFloatArray(env, args[1], preRotationVector)) {
642         ThrowErr(env, PARAMETER_ERROR, "Get preRotationVector fail");
643         return nullptr;
644     }
645     std::vector<float> angleChange(ROTATION_VECTOR_LENGTH);
646     SensorAlgorithm sensorAlgorithm;
647     int32_t ret = sensorAlgorithm.GetAngleModify(curRotationVector, preRotationVector, angleChange);
648     if (ret != OHOS::ERR_OK) {
649         ThrowErr(env, ret, "Get angle modify fail");
650         return nullptr;
651     } else {
652         asyncCallbackInfo->data.reserveData.length = ROTATION_VECTOR_LENGTH;
653         for (int32_t i = 0; i < ROTATION_VECTOR_LENGTH; ++i) {
654             asyncCallbackInfo->data.reserveData.reserve[i] = angleChange[i];
655         }
656     }
657     if (argc >= 3 && IsMatchType(env, args[2], napi_function)) {
658         status = napi_create_reference(env, args[2], 1, &asyncCallbackInfo->callback[0]);
659         if (status != napi_ok) {
660             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
661             return nullptr;
662         }
663         EmitAsyncCallbackWork(asyncCallbackInfo);
664         return nullptr;
665     }
666     napi_value promise = nullptr;
667     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
668     if (status != napi_ok) {
669         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
670         return nullptr;
671     }
672     EmitPromiseWork(asyncCallbackInfo);
673     return promise;
674 }
675 
GetDirection(napi_env env,napi_callback_info info)676 static napi_value GetDirection(napi_env env, napi_callback_info info)
677 {
678     CALL_LOG_ENTER;
679     size_t argc = 3;
680     napi_value args[3] = { 0 };
681     napi_value thisVar = nullptr;
682     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
683     if (status != napi_ok || argc < 1) {
684         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
685         return nullptr;
686     }
687     if (!IsMatchArrayType(env, args[0])) {
688         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be array");
689         return nullptr;
690     }
691     sptr<AsyncCallbackInfo> asyncCallbackInfo =
692         new (std::nothrow) AsyncCallbackInfo(env, GET_DIRECTION);
693     CHKPP(asyncCallbackInfo);
694     std::vector<float> rotationMatrix;
695     if (!GetFloatArray(env, args[0], rotationMatrix)) {
696         ThrowErr(env, PARAMETER_ERROR, "Get rotationMatrix fail");
697         return nullptr;
698     }
699     std::vector<float> rotationAngle(ROTATION_VECTOR_LENGTH);
700     SensorAlgorithm sensorAlgorithm;
701     int32_t ret = sensorAlgorithm.GetDirection(rotationMatrix, rotationAngle);
702     if (ret != OHOS::ERR_OK) {
703         ThrowErr(env, ret, "Get direction fail");
704         return nullptr;
705     } else {
706         asyncCallbackInfo->data.reserveData.length = ROTATION_VECTOR_LENGTH;
707         for (int32_t i = 0; i < ROTATION_VECTOR_LENGTH; ++i) {
708             asyncCallbackInfo->data.reserveData.reserve[i] = rotationAngle[i];
709         }
710     }
711     if (argc >= 2 && IsMatchType(env, args[1], napi_function)) {
712         status = napi_create_reference(env, args[1], 1, &asyncCallbackInfo->callback[0]);
713         if (status != napi_ok) {
714             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
715             return nullptr;
716         }
717         EmitAsyncCallbackWork(asyncCallbackInfo);
718         return nullptr;
719     }
720     napi_value promise = nullptr;
721     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
722     if (status != napi_ok) {
723         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
724         return nullptr;
725     }
726     EmitPromiseWork(asyncCallbackInfo);
727     return promise;
728 }
729 
CreateQuaternion(napi_env env,napi_callback_info info)730 static napi_value CreateQuaternion(napi_env env, napi_callback_info info)
731 {
732     CALL_LOG_ENTER;
733     size_t argc = 2;
734     napi_value args[2] = { 0 };
735     napi_value thisVar = nullptr;
736     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
737     if (status != napi_ok || argc < 1) {
738         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
739         return nullptr;
740     }
741     if (!IsMatchArrayType(env, args[0])) {
742         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be array");
743         return nullptr;
744     }
745     sptr<AsyncCallbackInfo> asyncCallbackInfo =
746         new (std::nothrow) AsyncCallbackInfo(env, CREATE_QUATERNION);
747     CHKPP(asyncCallbackInfo);
748     std::vector<float> rotationVector;
749     if (!GetFloatArray(env, args[0], rotationVector)) {
750         ThrowErr(env, PARAMETER_ERROR, "Get rotationVector fail");
751         return nullptr;
752     }
753     std::vector<float> quaternion(QUATERNION_LENGTH);
754     SensorAlgorithm sensorAlgorithm;
755     int32_t ret = sensorAlgorithm.CreateQuaternion(rotationVector, quaternion);
756     if (ret != OHOS::ERR_OK) {
757         ThrowErr(env, ret, "CreateQuaternion fail");
758         return nullptr;
759     } else {
760         asyncCallbackInfo->data.reserveData.length = QUATERNION_LENGTH;
761         for (int32_t i = 0; i < QUATERNION_LENGTH; ++i) {
762             asyncCallbackInfo->data.reserveData.reserve[i] = quaternion[i];
763         }
764     }
765     if (argc >= 2 && IsMatchType(env, args[1], napi_function)) {
766         status = napi_create_reference(env, args[1], 1, &asyncCallbackInfo->callback[0]);
767         if (status != napi_ok) {
768             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
769             return nullptr;
770         }
771         EmitAsyncCallbackWork(asyncCallbackInfo);
772         return nullptr;
773     }
774     napi_value promise = nullptr;
775     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
776     if (status != napi_ok) {
777         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
778         return nullptr;
779     }
780     EmitPromiseWork(asyncCallbackInfo);
781     return promise;
782 }
783 
GetAltitude(napi_env env,napi_callback_info info)784 static napi_value GetAltitude(napi_env env, napi_callback_info info)
785 {
786     CALL_LOG_ENTER;
787     size_t argc = 3;
788     napi_value args[3] = { 0 };
789     napi_value thisVar = nullptr;
790     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
791     if (status != napi_ok || argc < 2) {
792         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
793         return nullptr;
794     }
795     if ((!IsMatchType(env, args[0], napi_number)) || (!IsMatchType(env, args[1], napi_number))) {
796         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type");
797         return nullptr;
798     }
799     sptr<AsyncCallbackInfo> asyncCallbackInfo =
800         new (std::nothrow) AsyncCallbackInfo(env, GET_ALTITUDE);
801     CHKPP(asyncCallbackInfo);
802     float seaPressure = 0;
803     if (!GetNativeFloat(env, args[0], seaPressure)) {
804         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, get seaPressure fail");
805         return nullptr;
806     }
807     float currentPressure = 0;
808     if (!GetNativeFloat(env, args[1], currentPressure)) {
809         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, get currentPressure fail");
810         return nullptr;
811     }
812     float altitude = 0;
813     SensorAlgorithm sensorAlgorithm;
814     int32_t ret = sensorAlgorithm.GetAltitude(seaPressure, currentPressure, &altitude);
815     if (ret != OHOS::ERR_OK) {
816         ThrowErr(env, ret, "Get altitude fail");
817         return nullptr;
818     } else {
819         asyncCallbackInfo->data.reserveData.reserve[0] = altitude;
820     }
821     if (argc >= 3 && IsMatchType(env, args[2], napi_function)) {
822         status = napi_create_reference(env, args[2], 1, &asyncCallbackInfo->callback[0]);
823         if (status != napi_ok) {
824             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
825             return nullptr;
826         }
827         EmitAsyncCallbackWork(asyncCallbackInfo);
828         return nullptr;
829     }
830     napi_value promise = nullptr;
831     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
832     if (status != napi_ok) {
833         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
834         return nullptr;
835     }
836     EmitPromiseWork(asyncCallbackInfo);
837     return promise;
838 }
839 
GetGeomagneticDip(napi_env env,napi_callback_info info)840 static napi_value GetGeomagneticDip(napi_env env, napi_callback_info info)
841 {
842     CALL_LOG_ENTER;
843     size_t argc = 2;
844     napi_value args[2] = { 0 };
845     napi_value thisVar = nullptr;
846     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
847     if (status != napi_ok || argc < 1) {
848         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
849         return nullptr;
850     }
851     if (!IsMatchArrayType(env, args[0])) {
852         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be array");
853         return nullptr;
854     }
855     sptr<AsyncCallbackInfo> asyncCallbackInfo =
856         new (std::nothrow) AsyncCallbackInfo(env, GET_GEOMAGNETIC_DIP);
857     CHKPP(asyncCallbackInfo);
858     std::vector<float> inclinationMatrix;
859     if (!GetFloatArray(env, args[0], inclinationMatrix)) {
860         ThrowErr(env, PARAMETER_ERROR, "Get inclinationMatrix fail");
861         return nullptr;
862     }
863     float geomagneticDip = 0;
864     SensorAlgorithm sensorAlgorithm;
865     int32_t ret = sensorAlgorithm.GetGeomagneticDip(inclinationMatrix, &geomagneticDip);
866     if (ret != OHOS::ERR_OK) {
867         ThrowErr(env, ret, "Get geomagnetic dip fail");
868         return nullptr;
869     } else {
870         asyncCallbackInfo->data.reserveData.reserve[0] = geomagneticDip;
871     }
872     if (argc >= 2 && IsMatchType(env, args[1], napi_function)) {
873         status = napi_create_reference(env, args[1], 1, &asyncCallbackInfo->callback[0]);
874         if (status != napi_ok) {
875             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
876             return nullptr;
877         }
878         EmitAsyncCallbackWork(asyncCallbackInfo);
879         return nullptr;
880     }
881     napi_value promise = nullptr;
882     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
883     if (status != napi_ok) {
884         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
885         return nullptr;
886     }
887     EmitPromiseWork(asyncCallbackInfo);
888     return promise;
889 }
890 
CreateRotationAndInclination(const napi_env & env,napi_value args[],size_t argc)891 static napi_value CreateRotationAndInclination(const napi_env &env, napi_value args[], size_t argc)
892 {
893     CALL_LOG_ENTER;
894     if (argc < 2) {
895         ThrowErr(env, PARAMETER_ERROR, "The number of parameters is not valid");
896         return nullptr;
897     }
898     std::vector<float> gravity;
899     if (!GetFloatArray(env, args[0], gravity)) {
900         ThrowErr(env, PARAMETER_ERROR, "Get gravity fail");
901         return nullptr;
902     }
903     std::vector<float> geomagnetic;
904     if (!GetFloatArray(env, args[1], geomagnetic)) {
905         ThrowErr(env, PARAMETER_ERROR, "Get geomagnetic fail");
906         return nullptr;
907     }
908     std::vector<float> rotation(THREE_DIMENSIONAL_MATRIX_LENGTH);
909     std::vector<float> inclination(THREE_DIMENSIONAL_MATRIX_LENGTH);
910     sptr<AsyncCallbackInfo> asyncCallbackInfo =
911         new (std::nothrow) AsyncCallbackInfo(env, ROTATION_INCLINATION_MATRIX);
912     CHKPP(asyncCallbackInfo);
913     SensorAlgorithm sensorAlgorithm;
914     int32_t ret = sensorAlgorithm.CreateRotationAndInclination(gravity, geomagnetic, rotation, inclination);
915     if (ret != OHOS::ERR_OK) {
916         ThrowErr(env, ret, "Create rotation and inclination matrix fail");
917         return nullptr;
918     } else {
919         asyncCallbackInfo->data.reserveData.length = THREE_DIMENSIONAL_MATRIX_LENGTH;
920         for (int32_t i = 0; i < THREE_DIMENSIONAL_MATRIX_LENGTH; ++i) {
921             asyncCallbackInfo->data.rationMatrixData.rotationMatrix[i] = rotation[i];
922         }
923         for (int32_t i = 0; i < THREE_DIMENSIONAL_MATRIX_LENGTH; ++i) {
924             asyncCallbackInfo->data.rationMatrixData.inclinationMatrix[i] = inclination[i];
925         }
926     }
927     napi_status status;
928     if (argc >= 3 && IsMatchType(env, args[2], napi_function)) {
929         status = napi_create_reference(env, args[2], 1, &asyncCallbackInfo->callback[0]);
930         if (status != napi_ok) {
931             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
932             return nullptr;
933         }
934         EmitAsyncCallbackWork(asyncCallbackInfo);
935         return nullptr;
936     }
937     napi_value promise = nullptr;
938     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
939     if (status != napi_ok) {
940         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
941         return nullptr;
942     }
943     EmitPromiseWork(asyncCallbackInfo);
944     return promise;
945 }
946 
GetRotationMatrix(const napi_env & env,napi_value args[],size_t argc)947 static napi_value GetRotationMatrix(const napi_env &env, napi_value args[], size_t argc)
948 {
949     CALL_LOG_ENTER;
950     if (argc < 1) {
951         ThrowErr(env, PARAMETER_ERROR, "The number of parameters is not valid");
952         return nullptr;
953     }
954     std::vector<float> rotationVector;
955     if (!GetFloatArray(env, args[0], rotationVector)) {
956         ThrowErr(env, PARAMETER_ERROR, "Get rotationVector fail");
957         return nullptr;
958     }
959     sptr<AsyncCallbackInfo> asyncCallbackInfo =
960         new (std::nothrow) AsyncCallbackInfo(env, CREATE_ROTATION_MATRIX);
961     CHKPP(asyncCallbackInfo);
962     std::vector<float> rotationMatrix(THREE_DIMENSIONAL_MATRIX_LENGTH);
963     SensorAlgorithm sensorAlgorithm;
964     int32_t ret = sensorAlgorithm.CreateRotationMatrix(rotationVector, rotationMatrix);
965     if (ret != OHOS::ERR_OK) {
966         ThrowErr(env, ret, "Create rotation matrix fail");
967         return nullptr;
968     } else {
969         asyncCallbackInfo->data.reserveData.length = THREE_DIMENSIONAL_MATRIX_LENGTH;
970         for (int32_t i = 0; i < THREE_DIMENSIONAL_MATRIX_LENGTH; ++i) {
971             asyncCallbackInfo->data.reserveData.reserve[i] = rotationMatrix[i];
972         }
973     }
974     napi_status status;
975     if (argc >= 2 && IsMatchType(env, args[1], napi_function)) {
976         status = napi_create_reference(env, args[1], 1, &asyncCallbackInfo->callback[0]);
977         if (status != napi_ok) {
978             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
979             return nullptr;
980         }
981         EmitAsyncCallbackWork(asyncCallbackInfo);
982         return nullptr;
983     }
984     napi_value promise = nullptr;
985     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
986     if (status != napi_ok) {
987         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
988         return nullptr;
989     }
990     EmitPromiseWork(asyncCallbackInfo);
991     return promise;
992 }
993 
CreateRotationMatrix(napi_env env,napi_callback_info info)994 static napi_value CreateRotationMatrix(napi_env env, napi_callback_info info)
995 {
996     CALL_LOG_ENTER;
997     size_t argc = 3;
998     napi_value args[3] = { 0 };
999     napi_value thisVar = nullptr;
1000     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
1001     if (status != napi_ok || argc < 1) {
1002         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
1003         return nullptr;
1004     }
1005     if (!IsMatchArrayType(env, args[0])) {
1006         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be array");
1007         return nullptr;
1008     }
1009     if (argc >= 2 && IsMatchArrayType(env, args[1])) {
1010         return CreateRotationAndInclination(env, args, argc);
1011     } else {
1012         return GetRotationMatrix(env, args, argc);
1013     }
1014 }
1015 
GetSensorList(napi_env env,napi_callback_info info)1016 static napi_value GetSensorList(napi_env env, napi_callback_info info)
1017 {
1018     CALL_LOG_ENTER;
1019     size_t argc = 1;
1020     napi_value args[1] = { 0 };
1021     napi_value thisVar = nullptr;
1022     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
1023     if (status != napi_ok) {
1024         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail");
1025         return nullptr;
1026     }
1027     sptr<AsyncCallbackInfo> asyncCallbackInfo =
1028         new (std::nothrow) AsyncCallbackInfo(env, GET_SENSOR_LIST);
1029     CHKPP(asyncCallbackInfo);
1030     SensorInfo *sensorInfos = nullptr;
1031     int32_t count = 0;
1032     int32_t ret = GetAllSensors(&sensorInfos, &count);
1033     if (ret != OHOS::ERR_OK) {
1034         SEN_HILOGE("Get sensor list fail");
1035         asyncCallbackInfo->type = FAIL;
1036         asyncCallbackInfo->error.code = ret;
1037     } else {
1038         for (int32_t i = 0; i < count; ++i) {
1039             asyncCallbackInfo->sensorInfos.push_back(*(sensorInfos + i));
1040         }
1041     }
1042     if (argc >= 1 && IsMatchType(env, args[0], napi_function)) {
1043         status = napi_create_reference(env, args[0], 1, &asyncCallbackInfo->callback[0]);
1044         if (status != napi_ok) {
1045             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
1046             return nullptr;
1047         }
1048         EmitAsyncCallbackWork(asyncCallbackInfo);
1049         return nullptr;
1050     }
1051     napi_value promise = nullptr;
1052     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
1053     if (status != napi_ok) {
1054         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
1055         return nullptr;
1056     }
1057     EmitPromiseWork(asyncCallbackInfo);
1058     return promise;
1059 }
1060 
GetSingleSensor(napi_env env,napi_callback_info info)1061 static napi_value GetSingleSensor(napi_env env, napi_callback_info info)
1062 {
1063     CALL_LOG_ENTER;
1064     size_t argc = 2;
1065     napi_value args[2] = { 0 };
1066     napi_value thisVar = nullptr;
1067     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
1068     if (status != napi_ok || argc < 1) {
1069         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
1070         return nullptr;
1071     }
1072     int32_t sensorTypeId = INVALID_SENSOR_ID;
1073     if (!GetNativeInt32(env, args[0], sensorTypeId)) {
1074         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, get number fail");
1075         return nullptr;
1076     }
1077     sptr<AsyncCallbackInfo> asyncCallbackInfo =
1078         new (std::nothrow) AsyncCallbackInfo(env, GET_SINGLE_SENSOR);
1079     CHKPP(asyncCallbackInfo);
1080     SensorInfo *sensorInfos = nullptr;
1081     int32_t count = 0;
1082     int32_t ret = GetAllSensors(&sensorInfos, &count);
1083     if (ret != OHOS::ERR_OK) {
1084         SEN_HILOGE("Get sensor list fail");
1085         asyncCallbackInfo->type = FAIL;
1086         asyncCallbackInfo->error.code = ret;
1087     } else {
1088         for (int32_t i = 0; i < count; ++i) {
1089             if (sensorInfos[i].sensorTypeId == sensorTypeId) {
1090                 asyncCallbackInfo->sensorInfos.push_back(*(sensorInfos + i));
1091                 break;
1092             }
1093         }
1094         if (asyncCallbackInfo->sensorInfos.empty()) {
1095             ThrowErr(env, PARAMETER_ERROR, "Can't find the sensorId");
1096             return nullptr;
1097         }
1098     }
1099     if (argc >= 2 && IsMatchType(env, args[1], napi_function)) {
1100         status = napi_create_reference(env, args[1], 1, &asyncCallbackInfo->callback[0]);
1101         if (status != napi_ok) {
1102             ThrowErr(env, PARAMETER_ERROR, "napi_create_reference fail");
1103             return nullptr;
1104         }
1105         EmitAsyncCallbackWork(asyncCallbackInfo);
1106         return nullptr;
1107     }
1108     napi_value promise = nullptr;
1109     status = napi_create_promise(env, &asyncCallbackInfo->deferred, &promise);
1110     if (status != napi_ok) {
1111         ThrowErr(env, PARAMETER_ERROR, "napi_create_promise fail");
1112         return nullptr;
1113     }
1114     EmitPromiseWork(asyncCallbackInfo);
1115     return promise;
1116 }
1117 
Subscribe(napi_env env,napi_callback_info info,int32_t sensorTypeId,CallbackDataType type)1118 napi_value Subscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId, CallbackDataType type)
1119 {
1120     CALL_LOG_ENTER;
1121     size_t argc = 1;
1122     napi_value args[1] = { 0 };
1123     napi_value thisVar = nullptr;
1124     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
1125     if (status != napi_ok || argc < 1) {
1126         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
1127         return nullptr;
1128     }
1129     if (!IsMatchType(env, args[0], napi_object)) {
1130         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be object");
1131         return nullptr;
1132     }
1133     string interval = "normal";
1134     if ((sensorTypeId == SENSOR_TYPE_ID_ACCELEROMETER) ||
1135         ((sensorTypeId == SENSOR_TYPE_ID_ORIENTATION) && (type != SUBSCRIBE_COMPASS))
1136         || (sensorTypeId == SENSOR_TYPE_ID_GYROSCOPE)) {
1137         napi_value napiInterval = GetNamedProperty(env, args[0], "interval");
1138         CHKCP(GetStringValue(env, napiInterval, interval), "get interval fail");
1139     }
1140     sptr<AsyncCallbackInfo> asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env, type);
1141     CHKPP(asyncCallbackInfo);
1142     napi_value napiSuccess = GetNamedProperty(env, args[0], "success");
1143     CHKCP(IsMatchType(env, napiSuccess, napi_function), "get napiSuccess fail");
1144     CHKCP(RegisterNapiCallback(env, napiSuccess, asyncCallbackInfo->callback[0]),
1145         "register success callback fail");
1146     napi_value napiFail = GetNamedProperty(env, args[0], "fail");
1147     if (IsMatchType(env, napiFail, napi_function)) {
1148         SEN_HILOGD("Has fail callback");
1149         CHKCP(RegisterNapiCallback(env, napiFail, asyncCallbackInfo->callback[1]),
1150             "register fail callback fail");
1151     }
1152     if (auto iter = g_samplingPeriod.find(interval); iter == g_samplingPeriod.end()) {
1153         CHKCP(IsMatchType(env, napiFail, napi_function), "input error, interval is invalid");
1154         CreateFailMessage(SUBSCRIBE_FAIL, INPUT_ERROR, "input error", asyncCallbackInfo);
1155         EmitAsyncCallbackWork(asyncCallbackInfo);
1156         return nullptr;
1157     }
1158     int32_t ret = SubscribeSensor(sensorTypeId, g_samplingPeriod[interval], DataCallbackImpl);
1159     if (ret != OHOS::ERR_OK) {
1160         CHKCP(IsMatchType(env, napiFail, napi_function), "subscribe fail");
1161         CreateFailMessage(SUBSCRIBE_FAIL, SENSOR_SUBSCRIBE_FAILURE, "subscribe fail", asyncCallbackInfo);
1162         EmitAsyncCallbackWork(asyncCallbackInfo);
1163         return nullptr;
1164     }
1165     std::lock_guard<std::mutex> subscribeLock(mutex_);
1166     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_subscribeCallbacks[sensorTypeId];
1167     callbackInfos.push_back(asyncCallbackInfo);
1168     g_subscribeCallbacks[sensorTypeId] = callbackInfos;
1169     return nullptr;
1170 }
1171 
RemoveSubscribeCallback(napi_env env,int32_t sensorTypeId)1172 static bool RemoveSubscribeCallback(napi_env env, int32_t sensorTypeId)
1173 {
1174     CALL_LOG_ENTER;
1175     std::lock_guard<std::mutex> subscribeCallbackLock(mutex_);
1176     std::vector<sptr<AsyncCallbackInfo>> callbackInfos = g_subscribeCallbacks[sensorTypeId];
1177     for (auto iter = callbackInfos.begin(); iter != callbackInfos.end();) {
1178         CHKPC(*iter);
1179         if ((*iter)->env != env) {
1180             ++iter;
1181             continue;
1182         }
1183         iter = callbackInfos.erase(iter);
1184     }
1185     if (callbackInfos.empty()) {
1186         g_subscribeCallbacks.erase(sensorTypeId);
1187         return true;
1188     }
1189     return false;
1190 }
1191 
Unsubscribe(napi_env env,napi_callback_info info,int32_t sensorTypeId)1192 napi_value Unsubscribe(napi_env env, napi_callback_info info, int32_t sensorTypeId)
1193 {
1194     CALL_LOG_ENTER;
1195     size_t argc = 1;
1196     napi_value args[1] = { 0 };
1197     napi_value thisVar = nullptr;
1198     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
1199     if (status != napi_ok) {
1200         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail");
1201         return nullptr;
1202     }
1203     if (!RemoveSubscribeCallback(env, sensorTypeId) || CheckSubscribe(sensorTypeId)) {
1204         SEN_HILOGW("There are other client subscribe as well, not need unsubscribe");
1205         return nullptr;
1206     }
1207     if (UnsubscribeSensor(sensorTypeId) != OHOS::ERR_OK) {
1208         SEN_HILOGW("UnsubscribeSensor failed");
1209         return nullptr;
1210     }
1211     return nullptr;
1212 }
1213 
GetBodyState(napi_env env,napi_callback_info info)1214 napi_value GetBodyState(napi_env env, napi_callback_info info)
1215 {
1216     CALL_LOG_ENTER;
1217     size_t argc = 1;
1218     napi_value args[1] = { 0 };
1219     napi_value thisVar = nullptr;
1220     napi_status status = napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr);
1221     if (status != napi_ok || argc < 1) {
1222         ThrowErr(env, PARAMETER_ERROR, "napi_get_cb_info fail or number of parameter invalid");
1223         return nullptr;
1224     }
1225     if (!IsMatchType(env, args[0], napi_object)) {
1226         ThrowErr(env, PARAMETER_ERROR, "Wrong argument type, should be object");
1227         return nullptr;
1228     }
1229     sptr<AsyncCallbackInfo> asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo(env, GET_BODY_STATE);
1230     CHKPP(asyncCallbackInfo);
1231     napi_value napiSuccess = GetNamedProperty(env, args[0], "success");
1232     CHKCP(IsMatchType(env, napiSuccess, napi_function), "get napiSuccess fail");
1233     CHKCP(RegisterNapiCallback(env, napiSuccess, asyncCallbackInfo->callback[0]),
1234         "register success callback fail");
1235     std::lock_guard<std::mutex> onBodyLock(bodyMutex_);
1236     asyncCallbackInfo->data.sensorData.data[0] =
1237         (fabs(g_bodyState - BODY_STATE_EXCEPT) < THRESHOLD) ? true : false;
1238     EmitUvEventLoop(asyncCallbackInfo);
1239     return nullptr;
1240 }
1241 
EnumClassConstructor(napi_env env,napi_callback_info info)1242 static napi_value EnumClassConstructor(napi_env env, napi_callback_info info)
1243 {
1244     size_t argc = 0;
1245     napi_value args[1] = {0};
1246     napi_value ret = nullptr;
1247     void *data = nullptr;
1248     CHKNRP(env, napi_get_cb_info(env, info, &argc, args, &ret, &data), "napi_get_cb_info");
1249     return ret;
1250 }
1251 
CreateEnumSensorType(napi_env env,napi_value exports)1252 static napi_value CreateEnumSensorType(napi_env env, napi_value exports)
1253 {
1254     napi_property_descriptor desc[] = {
1255         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_ACCELEROMETER", GetNapiInt32(env, SENSOR_TYPE_ID_ACCELEROMETER)),
1256         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_GYROSCOPE", GetNapiInt32(env, SENSOR_TYPE_ID_GYROSCOPE)),
1257         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_AMBIENT_LIGHT", GetNapiInt32(env, SENSOR_TYPE_ID_AMBIENT_LIGHT)),
1258         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_MAGNETIC_FIELD", GetNapiInt32(env, SENSOR_TYPE_ID_MAGNETIC_FIELD)),
1259         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_BAROMETER", GetNapiInt32(env, SENSOR_TYPE_ID_BAROMETER)),
1260         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_HALL", GetNapiInt32(env, SENSOR_TYPE_ID_HALL)),
1261         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_TEMPERATURE", GetNapiInt32(env, SENSOR_TYPE_ID_TEMPERATURE)),
1262         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_PROXIMITY", GetNapiInt32(env, SENSOR_TYPE_ID_PROXIMITY)),
1263         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_HUMIDITY", GetNapiInt32(env, SENSOR_TYPE_ID_HUMIDITY)),
1264         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_COLOR", GetNapiInt32(env, SENSOR_TYPE_ID_COLOR)),
1265         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_SAR", GetNapiInt32(env, SENSOR_TYPE_ID_SAR)),
1266         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_ORIENTATION", GetNapiInt32(env, SENSOR_TYPE_ID_ORIENTATION)),
1267         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_GRAVITY", GetNapiInt32(env, SENSOR_TYPE_ID_GRAVITY)),
1268         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_LINEAR_ACCELERATION",
1269             GetNapiInt32(env, SENSOR_TYPE_ID_LINEAR_ACCELERATION)),
1270         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_ROTATION_VECTOR",
1271             GetNapiInt32(env, SENSOR_TYPE_ID_ROTATION_VECTOR)),
1272         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_AMBIENT_TEMPERATURE",
1273             GetNapiInt32(env, SENSOR_TYPE_ID_AMBIENT_TEMPERATURE)),
1274         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_MAGNETIC_FIELD_UNCALIBRATED",
1275             GetNapiInt32(env, SENSOR_TYPE_ID_MAGNETIC_FIELD_UNCALIBRATED)),
1276         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_GYROSCOPE_UNCALIBRATED",
1277             GetNapiInt32(env, SENSOR_TYPE_ID_GYROSCOPE_UNCALIBRATED)),
1278         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_SIGNIFICANT_MOTION",
1279             GetNapiInt32(env, SENSOR_TYPE_ID_SIGNIFICANT_MOTION)),
1280         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_PEDOMETER_DETECTION",
1281             GetNapiInt32(env, SENSOR_TYPE_ID_PEDOMETER_DETECTION)),
1282         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_PEDOMETER", GetNapiInt32(env, SENSOR_TYPE_ID_PEDOMETER)),
1283         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_HEART_RATE", GetNapiInt32(env, SENSOR_TYPE_ID_HEART_RATE)),
1284         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_WEAR_DETECTION", GetNapiInt32(env, SENSOR_TYPE_ID_WEAR_DETECTION)),
1285         DECLARE_NAPI_STATIC_PROPERTY("SENSOR_TYPE_ID_ACCELEROMETER_UNCALIBRATED",
1286             GetNapiInt32(env, SENSOR_TYPE_ID_ACCELEROMETER_UNCALIBRATED)),
1287     };
1288     napi_value result = nullptr;
1289     CHKNRP(env, napi_define_class(env, "SensorType", NAPI_AUTO_LENGTH, EnumClassConstructor, nullptr,
1290         sizeof(desc) / sizeof(*desc), desc, &result), "napi_define_class");
1291     CHKNRP(env, napi_set_named_property(env, exports, "SensorType", result), "napi_set_named_property fail");
1292     return exports;
1293 }
1294 
CreateEnumSensorId(napi_env env,napi_value exports)1295 static napi_value CreateEnumSensorId(napi_env env, napi_value exports)
1296 {
1297     napi_property_descriptor desc[] = {
1298         DECLARE_NAPI_STATIC_PROPERTY("ACCELEROMETER", GetNapiInt32(env, SENSOR_TYPE_ID_ACCELEROMETER)),
1299         DECLARE_NAPI_STATIC_PROPERTY("GYROSCOPE", GetNapiInt32(env, SENSOR_TYPE_ID_GYROSCOPE)),
1300         DECLARE_NAPI_STATIC_PROPERTY("AMBIENT_LIGHT", GetNapiInt32(env, SENSOR_TYPE_ID_AMBIENT_LIGHT)),
1301         DECLARE_NAPI_STATIC_PROPERTY("MAGNETIC_FIELD", GetNapiInt32(env, SENSOR_TYPE_ID_MAGNETIC_FIELD)),
1302         DECLARE_NAPI_STATIC_PROPERTY("BAROMETER", GetNapiInt32(env, SENSOR_TYPE_ID_BAROMETER)),
1303         DECLARE_NAPI_STATIC_PROPERTY("HALL", GetNapiInt32(env, SENSOR_TYPE_ID_HALL)),
1304         DECLARE_NAPI_STATIC_PROPERTY("TEMPERATURE", GetNapiInt32(env, SENSOR_TYPE_ID_TEMPERATURE)),
1305         DECLARE_NAPI_STATIC_PROPERTY("PROXIMITY", GetNapiInt32(env, SENSOR_TYPE_ID_PROXIMITY)),
1306         DECLARE_NAPI_STATIC_PROPERTY("HUMIDITY", GetNapiInt32(env, SENSOR_TYPE_ID_HUMIDITY)),
1307         DECLARE_NAPI_STATIC_PROPERTY("COLOR", GetNapiInt32(env, SENSOR_TYPE_ID_COLOR)),
1308         DECLARE_NAPI_STATIC_PROPERTY("SAR", GetNapiInt32(env, SENSOR_TYPE_ID_SAR)),
1309         DECLARE_NAPI_STATIC_PROPERTY("ORIENTATION", GetNapiInt32(env, SENSOR_TYPE_ID_ORIENTATION)),
1310         DECLARE_NAPI_STATIC_PROPERTY("GRAVITY", GetNapiInt32(env, SENSOR_TYPE_ID_GRAVITY)),
1311         DECLARE_NAPI_STATIC_PROPERTY("LINEAR_ACCELEROMETER", GetNapiInt32(env, SENSOR_TYPE_ID_LINEAR_ACCELERATION)),
1312         DECLARE_NAPI_STATIC_PROPERTY("ROTATION_VECTOR", GetNapiInt32(env, SENSOR_TYPE_ID_ROTATION_VECTOR)),
1313         DECLARE_NAPI_STATIC_PROPERTY("AMBIENT_TEMPERATURE", GetNapiInt32(env, SENSOR_TYPE_ID_AMBIENT_TEMPERATURE)),
1314         DECLARE_NAPI_STATIC_PROPERTY("MAGNETIC_FIELD_UNCALIBRATED",
1315             GetNapiInt32(env, SENSOR_TYPE_ID_MAGNETIC_FIELD_UNCALIBRATED)),
1316         DECLARE_NAPI_STATIC_PROPERTY("GYROSCOPE_UNCALIBRATED",
1317             GetNapiInt32(env, SENSOR_TYPE_ID_GYROSCOPE_UNCALIBRATED)),
1318         DECLARE_NAPI_STATIC_PROPERTY("SIGNIFICANT_MOTION", GetNapiInt32(env, SENSOR_TYPE_ID_SIGNIFICANT_MOTION)),
1319         DECLARE_NAPI_STATIC_PROPERTY("PEDOMETER_DETECTION", GetNapiInt32(env, SENSOR_TYPE_ID_PEDOMETER_DETECTION)),
1320         DECLARE_NAPI_STATIC_PROPERTY("PEDOMETER", GetNapiInt32(env, SENSOR_TYPE_ID_PEDOMETER)),
1321         DECLARE_NAPI_STATIC_PROPERTY("HEART_RATE", GetNapiInt32(env, SENSOR_TYPE_ID_HEART_RATE)),
1322         DECLARE_NAPI_STATIC_PROPERTY("WEAR_DETECTION", GetNapiInt32(env, SENSOR_TYPE_ID_WEAR_DETECTION)),
1323         DECLARE_NAPI_STATIC_PROPERTY("ACCELEROMETER_UNCALIBRATED",
1324             GetNapiInt32(env, SENSOR_TYPE_ID_ACCELEROMETER_UNCALIBRATED)),
1325     };
1326     napi_value result = nullptr;
1327     CHKNRP(env, napi_define_class(env, "SensorId", NAPI_AUTO_LENGTH, EnumClassConstructor, nullptr,
1328         sizeof(desc) / sizeof(*desc), desc, &result), "napi_define_class");
1329     CHKNRP(env, napi_set_named_property(env, exports, "SensorId", result), "napi_set_named_property fail");
1330     return exports;
1331 }
1332 
Init(napi_env env,napi_value exports)1333 static napi_value Init(napi_env env, napi_value exports)
1334 {
1335     napi_property_descriptor desc[] = {
1336         DECLARE_NAPI_FUNCTION("on", On),
1337         DECLARE_NAPI_FUNCTION("once", Once),
1338         DECLARE_NAPI_FUNCTION("off", Off),
1339         DECLARE_NAPI_FUNCTION("getGeomagneticField", GetGeomagneticField),
1340         DECLARE_NAPI_FUNCTION("getGeomagneticInfo", GetGeomagneticField),
1341         DECLARE_NAPI_FUNCTION("transformCoordinateSystem", TransformCoordinateSystem),
1342         DECLARE_NAPI_FUNCTION("transformRotationMatrix", TransformCoordinateSystem),
1343         DECLARE_NAPI_FUNCTION("getAngleModify", GetAngleModify),
1344         DECLARE_NAPI_FUNCTION("getAngleVariation", GetAngleModify),
1345         DECLARE_NAPI_FUNCTION("getDirection", GetDirection),
1346         DECLARE_NAPI_FUNCTION("getOrientation", GetDirection),
1347         DECLARE_NAPI_FUNCTION("createQuaternion", CreateQuaternion),
1348         DECLARE_NAPI_FUNCTION("getQuaternion", CreateQuaternion),
1349         DECLARE_NAPI_FUNCTION("getAltitude", GetAltitude),
1350         DECLARE_NAPI_FUNCTION("getDeviceAltitude", GetAltitude),
1351         DECLARE_NAPI_FUNCTION("getGeomagneticDip", GetGeomagneticDip),
1352         DECLARE_NAPI_FUNCTION("getInclination", GetGeomagneticDip),
1353         DECLARE_NAPI_FUNCTION("createRotationMatrix", CreateRotationMatrix),
1354         DECLARE_NAPI_FUNCTION("getRotationMatrix", CreateRotationMatrix),
1355         DECLARE_NAPI_FUNCTION("getSensorList", GetSensorList),
1356         DECLARE_NAPI_FUNCTION("getSingleSensor", GetSingleSensor),
1357         DECLARE_NAPI_FUNCTION("subscribeAccelerometer", SubscribeAccelerometer),
1358         DECLARE_NAPI_FUNCTION("unsubscribeAccelerometer", UnsubscribeAccelerometer),
1359         DECLARE_NAPI_FUNCTION("subscribeCompass", SubscribeCompass),
1360         DECLARE_NAPI_FUNCTION("unsubscribeCompass", UnsubscribeCompass),
1361         DECLARE_NAPI_FUNCTION("subscribeProximity", SubscribeProximity),
1362         DECLARE_NAPI_FUNCTION("unsubscribeProximity", UnsubscribeProximity),
1363         DECLARE_NAPI_FUNCTION("subscribeLight", SubscribeLight),
1364         DECLARE_NAPI_FUNCTION("unsubscribeLight", UnsubscribeLight),
1365         DECLARE_NAPI_FUNCTION("subscribeStepCounter", SubscribeStepCounter),
1366         DECLARE_NAPI_FUNCTION("unsubscribeStepCounter", UnsubscribeStepCounter),
1367         DECLARE_NAPI_FUNCTION("subscribeBarometer", SubscribeBarometer),
1368         DECLARE_NAPI_FUNCTION("unsubscribeBarometer", UnsubscribeBarometer),
1369         DECLARE_NAPI_FUNCTION("subscribeHeartRate", SubscribeHeartRate),
1370         DECLARE_NAPI_FUNCTION("unsubscribeHeartRate", UnsubscribeHeartRate),
1371         DECLARE_NAPI_FUNCTION("subscribeOnBodyState", SubscribeOnBodyState),
1372         DECLARE_NAPI_FUNCTION("unsubscribeOnBodyState", UnsubscribeOnBodyState),
1373         DECLARE_NAPI_FUNCTION("getOnBodyState", GetOnBodyState),
1374         DECLARE_NAPI_FUNCTION("subscribeDeviceOrientation", SubscribeDeviceOrientation),
1375         DECLARE_NAPI_FUNCTION("unsubscribeDeviceOrientation", UnsubscribeDeviceOrientation),
1376         DECLARE_NAPI_FUNCTION("subscribeGyroscope", SubscribeGyroscope),
1377         DECLARE_NAPI_FUNCTION("unsubscribeGyroscope", UnsubscribeGyroscope),
1378         DECLARE_NAPI_FUNCTION("subscribeGravity", SubscribeGravity),
1379         DECLARE_NAPI_FUNCTION("unsubscribeGravity", UnsubscribeGravity),
1380         DECLARE_NAPI_FUNCTION("subscribeMagnetic", SubscribeMagnetic),
1381         DECLARE_NAPI_FUNCTION("unsubscribeMagnetic", UnsubscribeMagnetic),
1382         DECLARE_NAPI_FUNCTION("subscribeHall", SubscribeHall),
1383         DECLARE_NAPI_FUNCTION("unsubscribeHall", UnsubscribeHall),
1384     };
1385     CHKNRP(env, napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc),
1386         "napi_define_properties");
1387     CHKCP(CreateEnumSensorType(env, exports), "Create enum sensor type fail");
1388     CHKCP(CreateEnumSensorId(env, exports), "Create enum sensor id fail");
1389     return exports;
1390 }
1391 
1392 static napi_module _module = {
1393     .nm_version = 1,
1394     .nm_flags = 0,
1395     .nm_filename = nullptr,
1396     .nm_register_func = Init,
1397     .nm_modname = "sensor",
1398     .nm_priv = ((void *)0),
1399     .reserved = {0}
1400 };
1401 
RegisterModule(void)1402 extern "C" __attribute__((constructor)) void RegisterModule(void)
1403 {
1404     napi_module_register(&_module);
1405 }
1406 }  // namespace Sensors
1407 }  // namespace OHOS