1 /*
2 * Copyright (c) 2021-2023 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
16 #include "camera_napi_utils.h"
17
18 namespace OHOS {
19 namespace CameraStandard {
MapExposureModeEnumFromJs(int32_t jsExposureMode,camera_exposure_mode_enum_t & nativeExposureMode)20 int32_t CameraNapiUtils::MapExposureModeEnumFromJs(
21 int32_t jsExposureMode, camera_exposure_mode_enum_t &nativeExposureMode)
22 {
23 MEDIA_INFO_LOG("js exposure mode = %{public}d", jsExposureMode);
24 switch (jsExposureMode) {
25 case EXPOSURE_MODE_LOCKED:
26 nativeExposureMode = OHOS_CAMERA_EXPOSURE_MODE_LOCKED;
27 break;
28 case EXPOSURE_MODE_AUTO:
29 nativeExposureMode = OHOS_CAMERA_EXPOSURE_MODE_AUTO;
30 break;
31 case EXPOSURE_MODE_CONTINUOUS_AUTO:
32 nativeExposureMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO;
33 break;
34 default:
35 MEDIA_ERR_LOG("Invalid exposure mode value received from application");
36 return -1;
37 }
38
39 return 0;
40 }
41
MapExposureModeEnum(camera_exposure_mode_enum_t nativeExposureMode,int32_t & jsExposureMode)42 void CameraNapiUtils::MapExposureModeEnum(camera_exposure_mode_enum_t nativeExposureMode, int32_t &jsExposureMode)
43 {
44 MEDIA_INFO_LOG("native exposure mode = %{public}d", static_cast<int32_t>(nativeExposureMode));
45 switch (nativeExposureMode) {
46 case OHOS_CAMERA_EXPOSURE_MODE_LOCKED:
47 jsExposureMode = EXPOSURE_MODE_LOCKED;
48 break;
49 case OHOS_CAMERA_EXPOSURE_MODE_AUTO:
50 jsExposureMode = EXPOSURE_MODE_AUTO;
51 break;
52 case OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO:
53 jsExposureMode = EXPOSURE_MODE_CONTINUOUS_AUTO;
54 break;
55 default:
56 MEDIA_ERR_LOG("Received native exposure mode is not supported with JS");
57 jsExposureMode = -1;
58 }
59 }
60
MapFocusStateEnum(FocusCallback::FocusState nativeFocusState,int32_t & jsFocusState)61 void CameraNapiUtils::MapFocusStateEnum(FocusCallback::FocusState nativeFocusState, int32_t &jsFocusState)
62 {
63 MEDIA_INFO_LOG("native focus state = %{public}d", static_cast<int32_t>(nativeFocusState));
64 switch (nativeFocusState) {
65 case FocusCallback::SCAN:
66 jsFocusState = FOCUS_STATE_SCAN;
67 break;
68 case FocusCallback::FOCUSED:
69 jsFocusState = FOCUS_STATE_FOCUSED;
70 break;
71 case FocusCallback::UNFOCUSED:
72 default:
73 jsFocusState = FOCUS_STATE_UNFOCUSED;
74 }
75 }
76
MapExposureStateEnum(ExposureCallback::ExposureState nativeExposureState,int32_t & jsExposureState)77 void CameraNapiUtils::MapExposureStateEnum(
78 ExposureCallback::ExposureState nativeExposureState, int32_t &jsExposureState)
79 {
80 MEDIA_INFO_LOG("native exposure state = %{public}d", static_cast<int32_t>(nativeExposureState));
81 switch (nativeExposureState) {
82 case ExposureCallback::SCAN:
83 jsExposureState = EXPOSURE_STATE_SCAN;
84 break;
85 case ExposureCallback::CONVERGED:
86 default:
87 jsExposureState = EXPOSURE_STATE_CONVERGED;
88 }
89 }
90
MapCameraPositionEnum(camera_position_enum_t nativeCamPos,int32_t & jsCameraPosition)91 void CameraNapiUtils::MapCameraPositionEnum(camera_position_enum_t nativeCamPos, int32_t &jsCameraPosition)
92 {
93 MEDIA_INFO_LOG("native cam pos = %{public}d", static_cast<int32_t>(nativeCamPos));
94 switch (nativeCamPos) {
95 case OHOS_CAMERA_POSITION_FRONT:
96 jsCameraPosition = CAMERA_POSITION_FRONT;
97 break;
98 case OHOS_CAMERA_POSITION_BACK:
99 jsCameraPosition = CAMERA_POSITION_BACK;
100 break;
101 case OHOS_CAMERA_POSITION_OTHER:
102 default:
103 jsCameraPosition = CAMERA_POSITION_UNSPECIFIED;
104 }
105 }
106
MapCameraPositionEnumFromJs(int32_t jsCameraPosition,camera_position_enum_t & nativeCamPos)107 int32_t CameraNapiUtils::MapCameraPositionEnumFromJs(int32_t jsCameraPosition, camera_position_enum_t &nativeCamPos)
108 {
109 MEDIA_INFO_LOG("js cam pos = %{public}d", jsCameraPosition);
110 switch (jsCameraPosition) {
111 case CAMERA_POSITION_FRONT:
112 nativeCamPos = OHOS_CAMERA_POSITION_FRONT;
113 break;
114 case CAMERA_POSITION_BACK:
115 nativeCamPos = OHOS_CAMERA_POSITION_BACK;
116 break;
117 case CAMERA_POSITION_UNSPECIFIED:
118 nativeCamPos = OHOS_CAMERA_POSITION_OTHER;
119 break;
120 default:
121 MEDIA_ERR_LOG("Invalid camera position value received from application");
122 return -1;
123 }
124
125 return 0;
126 }
127
MapCameraFormatEnum(camera_format_t nativeCamFormat,int32_t & jsCameraFormat)128 void CameraNapiUtils::MapCameraFormatEnum(camera_format_t nativeCamFormat, int32_t &jsCameraFormat)
129 {
130 MEDIA_INFO_LOG("native cam format = %{public}d", static_cast<int32_t>(nativeCamFormat));
131 switch (nativeCamFormat) {
132 case OHOS_CAMERA_FORMAT_YCRCB_420_SP:
133 jsCameraFormat = CAMERA_FORMAT_YUV_420_SP;
134 break;
135 case OHOS_CAMERA_FORMAT_JPEG:
136 jsCameraFormat = CAMERA_FORMAT_JPEG;
137 break;
138 case OHOS_CAMERA_FORMAT_RGBA_8888:
139 case OHOS_CAMERA_FORMAT_YCBCR_420_888:
140 default:
141 jsCameraFormat = -1;
142 MEDIA_ERR_LOG("The native camera format is not supported with JS");
143 }
144 }
145
MapMetadataObjSupportedTypesEnum(MetadataObjectType nativeMetadataObjType,int32_t & jsMetadataObjType)146 void CameraNapiUtils::MapMetadataObjSupportedTypesEnum(
147 MetadataObjectType nativeMetadataObjType, int32_t &jsMetadataObjType)
148 {
149 MEDIA_INFO_LOG("native metadata Object Type = %{public}d", static_cast<int32_t>(nativeMetadataObjType));
150 switch (nativeMetadataObjType) {
151 case MetadataObjectType::FACE:
152 jsMetadataObjType = JSMetadataObjectType::FACE;
153 break;
154 default:
155 jsMetadataObjType = -1;
156 MEDIA_ERR_LOG("Native Metadata object type not supported with JS");
157 }
158 }
159
MapMetadataObjSupportedTypesEnumFromJS(int32_t jsMetadataObjType,MetadataObjectType & nativeMetadataObjType,bool & isValid)160 void CameraNapiUtils::MapMetadataObjSupportedTypesEnumFromJS(int32_t jsMetadataObjType,
161 MetadataObjectType &nativeMetadataObjType, bool &isValid)
162 {
163 MEDIA_INFO_LOG("JS metadata Object Type = %{public}d", jsMetadataObjType);
164 switch (jsMetadataObjType) {
165 case JSMetadataObjectType::FACE:
166 nativeMetadataObjType = MetadataObjectType::FACE;
167 break;
168 default:
169 isValid = false;
170 MEDIA_ERR_LOG("JS Metadata object type not supported with native");
171 }
172 }
173
MapCameraFormatEnumFromJs(int32_t jsCameraFormat,camera_format_t & nativeCamFormat)174 int32_t CameraNapiUtils::MapCameraFormatEnumFromJs(int32_t jsCameraFormat, camera_format_t &nativeCamFormat)
175 {
176 MEDIA_INFO_LOG("js cam format = %{public}d", jsCameraFormat);
177 switch (jsCameraFormat) {
178 case CAMERA_FORMAT_YUV_420_SP:
179 nativeCamFormat = OHOS_CAMERA_FORMAT_YCRCB_420_SP;
180 break;
181 case CAMERA_FORMAT_JPEG:
182 nativeCamFormat = OHOS_CAMERA_FORMAT_JPEG;
183 break;
184 default:
185 MEDIA_ERR_LOG("Invalid or unsupported camera format value received from application");
186 return -1;
187 }
188
189 return 0;
190 }
191
MapCameraTypeEnum(camera_type_enum_t nativeCamType,int32_t & jsCameraType)192 void CameraNapiUtils::MapCameraTypeEnum(camera_type_enum_t nativeCamType, int32_t &jsCameraType)
193 {
194 MEDIA_INFO_LOG("native cam type = %{public}d", static_cast<int32_t>(nativeCamType));
195 switch (nativeCamType) {
196 case OHOS_CAMERA_TYPE_WIDE_ANGLE:
197 jsCameraType = CAMERA_TYPE_WIDE_ANGLE;
198 break;
199 case OHOS_CAMERA_TYPE_ULTRA_WIDE:
200 jsCameraType = CAMERA_TYPE_ULTRA_WIDE;
201 break;
202 case OHOS_CAMERA_TYPE_TELTPHOTO:
203 jsCameraType = CAMERA_TYPE_TELEPHOTO;
204 break;
205 case OHOS_CAMERA_TYPE_TRUE_DEAPTH:
206 jsCameraType = CAMERA_TYPE_TRUE_DEPTH;
207 break;
208 case OHOS_CAMERA_TYPE_LOGICAL:
209 MEDIA_ERR_LOG("Logical camera type is treated as unspecified");
210 jsCameraType = CAMERA_TYPE_DEFAULT;
211 break;
212 case OHOS_CAMERA_TYPE_UNSPECIFIED:
213 default:
214 jsCameraType = CAMERA_TYPE_DEFAULT;
215 }
216 }
217
MapCameraTypeEnumFromJs(int32_t jsCameraType,camera_type_enum_t & nativeCamType)218 int32_t CameraNapiUtils::MapCameraTypeEnumFromJs(int32_t jsCameraType, camera_type_enum_t &nativeCamType)
219 {
220 MEDIA_INFO_LOG("js cam type = %{public}d", jsCameraType);
221 switch (jsCameraType) {
222 case CAMERA_TYPE_WIDE_ANGLE:
223 nativeCamType = OHOS_CAMERA_TYPE_WIDE_ANGLE;
224 break;
225 case CAMERA_TYPE_ULTRA_WIDE:
226 nativeCamType = OHOS_CAMERA_TYPE_ULTRA_WIDE;
227 break;
228 case CAMERA_TYPE_TELEPHOTO:
229 nativeCamType = OHOS_CAMERA_TYPE_TELTPHOTO;
230 break;
231 case CAMERA_TYPE_TRUE_DEPTH:
232 nativeCamType = OHOS_CAMERA_TYPE_TRUE_DEAPTH;
233 break;
234 case CAMERA_TYPE_DEFAULT:
235 nativeCamType = OHOS_CAMERA_TYPE_UNSPECIFIED;
236 break;
237 default:
238 MEDIA_ERR_LOG("Invalid camera type value received from application");
239 return -1;
240 }
241
242 return 0;
243 }
244
MapCameraConnectionTypeEnum(camera_connection_type_t nativeCamConnType,int32_t & jsCameraConnType)245 void CameraNapiUtils::MapCameraConnectionTypeEnum(
246 camera_connection_type_t nativeCamConnType, int32_t &jsCameraConnType)
247 {
248 MEDIA_INFO_LOG("native cam connection type = %{public}d", static_cast<int32_t>(nativeCamConnType));
249 switch (nativeCamConnType) {
250 case OHOS_CAMERA_CONNECTION_TYPE_REMOTE:
251 jsCameraConnType = CAMERA_CONNECTION_REMOTE;
252 break;
253 case OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN:
254 jsCameraConnType = CAMERA_CONNECTION_USB_PLUGIN;
255 break;
256 case OHOS_CAMERA_CONNECTION_TYPE_BUILTIN:
257 default:
258 jsCameraConnType = CAMERA_CONNECTION_BUILT_IN;
259 }
260 }
261
MapQualityLevelFromJs(int32_t jsQuality,PhotoCaptureSetting::QualityLevel & nativeQuality)262 int32_t CameraNapiUtils::MapQualityLevelFromJs(int32_t jsQuality, PhotoCaptureSetting::QualityLevel &nativeQuality)
263 {
264 MEDIA_INFO_LOG("js quality level = %{public}d", jsQuality);
265 switch (jsQuality) {
266 case QUALITY_LEVEL_HIGH:
267 nativeQuality = PhotoCaptureSetting::QUALITY_LEVEL_HIGH;
268 break;
269 case QUALITY_LEVEL_MEDIUM:
270 nativeQuality = PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM;
271 break;
272 case QUALITY_LEVEL_LOW:
273 nativeQuality = PhotoCaptureSetting::QUALITY_LEVEL_LOW;
274 break;
275 default:
276 MEDIA_ERR_LOG("Invalid quality value received from application");
277 return -1;
278 }
279
280 return 0;
281 }
282
MapImageRotationFromJs(int32_t jsRotation,PhotoCaptureSetting::RotationConfig & nativeRotation)283 int32_t CameraNapiUtils::MapImageRotationFromJs(int32_t jsRotation, PhotoCaptureSetting::RotationConfig &nativeRotation)
284 {
285 MEDIA_INFO_LOG("js rotation = %{public}d", jsRotation);
286 switch (jsRotation) {
287 case ROTATION_0:
288 nativeRotation = PhotoCaptureSetting::Rotation_0;
289 break;
290 case ROTATION_90:
291 nativeRotation = PhotoCaptureSetting::Rotation_90;
292 break;
293 case ROTATION_180:
294 nativeRotation = PhotoCaptureSetting::Rotation_180;
295 break;
296 case ROTATION_270:
297 nativeRotation = PhotoCaptureSetting::Rotation_270;
298 break;
299 default:
300 MEDIA_ERR_LOG("Invalid rotation value received from application");
301 return -1;
302 }
303
304 return 0;
305 }
306
MapCameraStatusEnum(CameraStatus deviceStatus,int32_t & jsCameraStatus)307 void CameraNapiUtils::MapCameraStatusEnum(CameraStatus deviceStatus, int32_t &jsCameraStatus)
308 {
309 MEDIA_INFO_LOG("native camera status = %{public}d", static_cast<int32_t>(deviceStatus));
310 switch (deviceStatus) {
311 case CAMERA_DEVICE_STATUS_UNAVAILABLE:
312 jsCameraStatus = JS_CAMERA_STATUS_UNAVAILABLE;
313 break;
314 case CAMERA_DEVICE_STATUS_AVAILABLE:
315 jsCameraStatus = JS_CAMERA_STATUS_AVAILABLE;
316 break;
317 default:
318 MEDIA_ERR_LOG("Received native camera status is not supported with JS");
319 jsCameraStatus = -1;
320 }
321 }
322
VideoStabilizationModeEnum(CameraVideoStabilizationMode nativeVideoStabilizationMode,int32_t & jsVideoStabilizationMode)323 void CameraNapiUtils::VideoStabilizationModeEnum(
324 CameraVideoStabilizationMode nativeVideoStabilizationMode, int32_t &jsVideoStabilizationMode)
325 {
326 MEDIA_INFO_LOG(
327 "native video stabilization mode = %{public}d", static_cast<int32_t>(nativeVideoStabilizationMode));
328 switch (nativeVideoStabilizationMode) {
329 case OHOS_CAMERA_VIDEO_STABILIZATION_OFF:
330 jsVideoStabilizationMode = OFF;
331 break;
332 case OHOS_CAMERA_VIDEO_STABILIZATION_LOW:
333 jsVideoStabilizationMode = LOW;
334 break;
335 case OHOS_CAMERA_VIDEO_STABILIZATION_MIDDLE:
336 jsVideoStabilizationMode = MIDDLE;
337 break;
338 case OHOS_CAMERA_VIDEO_STABILIZATION_HIGH:
339 jsVideoStabilizationMode = HIGH;
340 break;
341 case OHOS_CAMERA_VIDEO_STABILIZATION_AUTO:
342 jsVideoStabilizationMode = AUTO;
343 break;
344 default:
345 MEDIA_ERR_LOG("Received native video stabilization mode is not supported with JS");
346 jsVideoStabilizationMode = -1;
347 }
348 }
349
CreateNapiErrorObject(napi_env env,int32_t errorCode,const char * errString,std::unique_ptr<JSAsyncContextOutput> & jsContext)350 void CameraNapiUtils::CreateNapiErrorObject(napi_env env, int32_t errorCode, const char* errString,
351 std::unique_ptr<JSAsyncContextOutput> &jsContext)
352 {
353 napi_get_undefined(env, &jsContext->data);
354 napi_value napiErrorCode = nullptr;
355 napi_value napiErrorMsg = nullptr;
356
357 std::string errorCodeStr = std::to_string(errorCode);
358 napi_create_string_utf8(env, errorCodeStr.c_str(), NAPI_AUTO_LENGTH, &napiErrorCode);
359 napi_create_string_utf8(env, errString, NAPI_AUTO_LENGTH, &napiErrorMsg);
360
361 napi_create_object(env, &jsContext->error);
362 napi_set_named_property(env, jsContext->error, "code", napiErrorCode);
363 napi_set_named_property(env, jsContext->error, "message", napiErrorMsg);
364
365 jsContext->status = false;
366 }
367
InvokeJSAsyncMethod(napi_env env,napi_deferred deferred,napi_ref callbackRef,napi_async_work work,const JSAsyncContextOutput & asyncContext)368 void CameraNapiUtils::InvokeJSAsyncMethod(napi_env env, napi_deferred deferred,
369 napi_ref callbackRef, napi_async_work work, const JSAsyncContextOutput &asyncContext)
370 {
371 napi_value retVal;
372 napi_value callback = nullptr;
373 std::string funcName = asyncContext.funcName;
374 MEDIA_INFO_LOG("%{public}s, context->InvokeJSAsyncMethod start", funcName.c_str());
375 /* Deferred is used when JS Callback method expects a promise value */
376 if (deferred) {
377 if (asyncContext.status) {
378 napi_resolve_deferred(env, deferred, asyncContext.data);
379 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod napi_resolve_deferred", funcName.c_str());
380 } else {
381 napi_reject_deferred(env, deferred, asyncContext.error);
382 MEDIA_ERR_LOG("%{public}s, InvokeJSAsyncMethod napi_reject_deferred", funcName.c_str());
383 }
384 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod end deferred", funcName.c_str());
385 } else {
386 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod callback", funcName.c_str());
387 napi_value result[ARGS_TWO];
388 result[PARAM0] = asyncContext.error;
389 result[PARAM1] = asyncContext.data;
390 napi_get_reference_value(env, callbackRef, &callback);
391 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod napi_call_function start", funcName.c_str());
392 napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal);
393 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod napi_call_function end", funcName.c_str());
394 napi_delete_reference(env, callbackRef);
395 }
396 napi_delete_async_work(env, work);
397 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod inner end", funcName.c_str());
398 }
399
IncreamentAndGet(uint32_t & num)400 int32_t CameraNapiUtils::IncreamentAndGet(uint32_t &num)
401 {
402 int32_t temp = num & 0x00ffffff;
403 if (temp >= 0xffff) {
404 num = num & 0xff000000;
405 }
406 num++;
407 return num;
408 }
409
CheckInvalidArgument(napi_env env,size_t argc,int32_t length,napi_value * argv,CameraSteps step)410 bool CameraNapiUtils::CheckInvalidArgument(napi_env env, size_t argc, int32_t length,
411 napi_value *argv, CameraSteps step)
412 {
413 bool isPass = true;
414 napi_valuetype valueTypeArray[length];
415 for (int32_t i = 0; i < length; i++) {
416 napi_typeof(env, argv[i], &valueTypeArray[i]);
417 }
418 switch (step) {
419 case CREATE_CAMERA_INPUT_INSTANCE:
420 if (argc == ARGS_ONE) {
421 isPass = valueTypeArray[0] == napi_object;
422 } else if (argc == ARGS_TWO) {
423 isPass = (valueTypeArray[0] == napi_number) && (valueTypeArray[1] == napi_number);
424 } else {
425 isPass = false;
426 }
427 break;
428
429 case CREATE_PREVIEW_OUTPUT_INSTANCE:
430 isPass = (argc == ARGS_TWO) &&
431 (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_string);
432 break;
433
434 case CREATE_PHOTO_OUTPUT_INSTANCE:
435 isPass = (argc == ARGS_TWO) &&
436 (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_string);
437 break;
438
439 case CREATE_VIDEO_OUTPUT_INSTANCE:
440 isPass = (argc == ARGS_TWO) &&
441 (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_string);
442 break;
443
444 case CREATE_METADATA_OUTPUT_INSTANCE:
445 isPass = argc == ARGS_ONE;
446 if (argc == ARGS_ONE) {
447 napi_is_array(env, argv[0], &isPass);
448 } else {
449 isPass = false;
450 }
451 break;
452
453 case ADD_INPUT:
454 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object);
455 break;
456
457 case REMOVE_INPUT:
458 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object);
459 break;
460
461 case ADD_OUTPUT:
462 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object);
463 break;
464
465 case REMOVE_OUTPUT:
466 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object);
467 break;
468
469 case PHOTO_OUT_CAPTURE:
470 if (argc == ARGS_ZERO) {
471 isPass = true;
472 } else if (argc == ARGS_ONE) {
473 isPass = (valueTypeArray[0] == napi_object) || (valueTypeArray[0] == napi_function) ||
474 (valueTypeArray[0] == napi_undefined);
475 } else if (argc == ARGS_TWO) {
476 isPass = (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_function);
477 } else {
478 isPass = false;
479 }
480 break;
481
482 case ADD_DEFERRED_SURFACE:
483 if (argc == ARGS_ONE) {
484 isPass = valueTypeArray[0] == napi_string;
485 } else if (argc == ARGS_TWO) {
486 isPass = (valueTypeArray[0] == napi_string) && (valueTypeArray[1] == napi_function);
487 } else {
488 isPass = false;
489 }
490 break;
491
492 case CREATE_DEFERRED_PREVIEW_OUTPUT:
493 if (argc == ARGS_ONE) {
494 isPass = valueTypeArray[0] == napi_object;
495 } else {
496 isPass = false;
497 }
498 break;
499
500 default:
501 break;
502 }
503 if (!isPass) {
504 std::string errorCode = std::to_string(CameraErrorCode::INVALID_ARGUMENT);
505 napi_throw_type_error(env, errorCode.c_str(), "");
506 }
507 return isPass;
508 }
509
CheckError(napi_env env,int32_t retCode)510 bool CameraNapiUtils::CheckError(napi_env env, int32_t retCode)
511 {
512 if ((retCode != 0)) {
513 std::string errorCode = std::to_string(retCode);
514 napi_throw_error(env, errorCode.c_str(), "");
515 return false;
516 }
517 return true;
518 }
519
FloatToDouble(float val)520 double CameraNapiUtils::FloatToDouble(float val)
521 {
522 const double precision = 1000000.0;
523 val *= precision;
524 double result = static_cast<double>(val / precision);
525 return result;
526 }
527
CheckSystemApp(napi_env env)528 bool CameraNapiUtils::CheckSystemApp(napi_env env)
529 {
530 uint64_t tokenId = IPCSkeleton::GetSelfTokenID();
531 int32_t errorCode = CameraErrorCode::NO_SYSTEM_APP_PERMISSION;
532 if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(tokenId)) {
533 std::string errorMessage = "System api can be invoked only by system applications";
534 if (napi_throw_error(env, std::to_string(errorCode).c_str(), errorMessage.c_str()) != napi_ok) {
535 MEDIA_ERR_LOG("failed to throw err, code=%{public}d, msg=%{public}s.", errorCode, errorMessage.c_str());
536 }
537 return false;
538 }
539 return true;
540 }
541 } // namespace CameraStandard
542 } // namespace OHOS
543