1 /* 2 * Copyright (c) 2021-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 16 #ifndef CAMERA_NAPI_UTILS_H_ 17 #define CAMERA_NAPI_UTILS_H_ 18 19 #include <vector> 20 #include "camera_error_code.h" 21 #include "camera_device_ability_items.h" 22 #include "input/camera_input.h" 23 #include "camera_log.h" 24 #include "napi/native_api.h" 25 #include "napi/native_node_api.h" 26 #include "output/photo_output.h" 27 #include "input/camera_manager.h" 28 29 #define CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar) \ 30 do { \ 31 void* data; \ 32 napi_get_cb_info(env, info, &(argc), argv, &(thisVar), &data); \ 33 } while (0) 34 35 #define CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar) \ 36 do { \ 37 void* data; \ 38 status = napi_get_cb_info(env, info, nullptr, nullptr, &(thisVar), &data); \ 39 } while (0) 40 41 #define CAMERA_NAPI_GET_JS_ASYNC_CB_REF(env, arg, count, cbRef) \ 42 do { \ 43 napi_valuetype valueType = napi_undefined; \ 44 napi_typeof(env, arg, &valueType); \ 45 if (valueType == napi_function) { \ 46 napi_create_reference(env, arg, count, &(cbRef)); \ 47 } else { \ 48 NAPI_ASSERT(env, false, "type mismatch"); \ 49 } \ 50 } while (0); 51 52 #define CAMERA_NAPI_ASSERT_NULLPTR_CHECK(env, result) \ 53 do { \ 54 if ((result) == nullptr) { \ 55 napi_get_undefined(env, &(result)); \ 56 return result; \ 57 } \ 58 } while (0); 59 60 #define CAMERA_NAPI_CREATE_PROMISE(env, callbackRef, deferred, result) \ 61 do { \ 62 if ((callbackRef) == nullptr) { \ 63 napi_create_promise(env, &(deferred), &(result)); \ 64 } \ 65 } while (0); 66 67 #define CAMERA_NAPI_CREATE_RESOURCE_NAME(env, resource, resourceName) \ 68 do { \ 69 napi_create_string_utf8(env, resourceName, NAPI_AUTO_LENGTH, &(resource)); \ 70 } while (0); 71 72 #define CAMERA_NAPI_CHECK_NULL_PTR_RETURN_UNDEFINED(env, ptr, ret, message) \ 73 do { \ 74 if ((ptr) == nullptr) { \ 75 HiLog::Error(LABEL, message); \ 76 napi_get_undefined(env, &(ret)); \ 77 return ret; \ 78 } \ 79 } while (0) 80 81 #define CAMERA_NAPI_CHECK_NULL_PTR_RETURN_VOID(ptr, message) \ 82 do { \ 83 if ((ptr) == nullptr) { \ 84 HiLog::Error(LABEL, message); \ 85 return; \ 86 } \ 87 } while (0) 88 89 #define CAMERA_NAPI_ASSERT_EQUAL(condition, errMsg) \ 90 do { \ 91 if (!(condition)) { \ 92 HiLog::Error(LABEL, errMsg); \ 93 return; \ 94 } \ 95 } while (0) 96 97 #define CAMERA_NAPI_CHECK_AND_BREAK_LOG(cond, fmt, ...) \ 98 do { \ 99 if (!(cond)) { \ 100 MEDIA_ERR_LOG(fmt, ##__VA_ARGS__); \ 101 break; \ 102 } \ 103 } while (0) 104 105 #define CAMERA_NAPI_CHECK_AND_RETURN_LOG(cond, fmt, ...) \ 106 do { \ 107 if (!(cond)) { \ 108 MEDIA_ERR_LOG(fmt, ##__VA_ARGS__); \ 109 return; \ 110 } \ 111 } while (0) 112 113 namespace OHOS { 114 namespace CameraStandard { 115 /* Constants for array index */ 116 const int32_t PARAM0 = 0; 117 const int32_t PARAM1 = 1; 118 const int32_t PARAM2 = 2; 119 120 /* Constants for array size */ 121 const int32_t ARGS_ZERO = 0; 122 const int32_t ARGS_ONE = 1; 123 const int32_t ARGS_TWO = 2; 124 const int32_t ARGS_THREE = 3; 125 const int32_t SIZE = 100; 126 127 struct AsyncContext { 128 napi_env env; 129 napi_async_work work; 130 napi_deferred deferred; 131 napi_ref callbackRef; 132 bool status; 133 int32_t taskId; 134 int32_t errorCode; 135 std::string errorMsg; 136 std::string funcName; 137 bool isInvalidArgument; 138 }; 139 140 struct JSAsyncContextOutput { 141 napi_value error; 142 napi_value data; 143 bool status; 144 bool bRetBool; 145 std::string funcName; 146 }; 147 148 enum JSQualityLevel { 149 QUALITY_LEVEL_HIGH = 0, 150 QUALITY_LEVEL_MEDIUM, 151 QUALITY_LEVEL_LOW 152 }; 153 154 enum JSImageRotation { 155 ROTATION_0 = 0, 156 ROTATION_90 = 90, 157 ROTATION_180 = 180, 158 ROTATION_270 = 270 159 }; 160 161 enum JSCameraStatus { 162 JS_CAMERA_STATUS_APPEAR = 0, 163 JS_CAMERA_STATUS_DISAPPEAR = 1, 164 JS_CAMERA_STATUS_AVAILABLE = 2, 165 JS_CAMERA_STATUS_UNAVAILABLE = 3 166 }; 167 168 enum CameraTaskId { 169 CAMERA_MANAGER_TASKID = 0x01000000, 170 CAMERA_INPUT_TASKID = 0x02000000, 171 CAMERA_PHOTO_OUTPUT_TASKID = 0x03000000, 172 CAMERA_PREVIEW_OUTPUT_TASKID = 0x04000000, 173 CAMERA_VIDEO_OUTPUT_TASKID = 0x05000000, 174 CAMERA_SESSION_TASKID = 0x06000000 175 }; 176 177 enum JSMetadataObjectType { 178 FACE = 0 179 }; 180 181 enum NapiCheckInvalidArgumentModes { 182 CREATE_CAMERA_INPUT_INSTANCE, 183 CREATE_PREVIEW_OUTPUT_INSTANCE, 184 CREATE_PHOTO_OUTPUT_INSTANCE, 185 CREATE_VIDEO_OUTPUT_INSTANCE, 186 CREATE_METADATA_OUTPUT_INSTANCE, 187 ADD_INPUT, 188 REMOVE_INPUT, 189 ADD_OUTPUT, 190 REMOVE_OUTPUT, 191 PHOTO_OUT_CAPTURE, 192 }; 193 194 /* Util class used by napi asynchronous methods for making call to js callback function */ 195 class CameraNapiUtils { 196 public: MapExposureModeEnumFromJs(int32_t jsExposureMode,camera_exposure_mode_enum_t & nativeExposureMode)197 static int32_t MapExposureModeEnumFromJs(int32_t jsExposureMode, camera_exposure_mode_enum_t &nativeExposureMode) 198 { 199 MEDIA_INFO_LOG("js exposure mode = %{public}d", jsExposureMode); 200 switch (jsExposureMode) { 201 case EXPOSURE_MODE_LOCKED: 202 nativeExposureMode = OHOS_CAMERA_EXPOSURE_MODE_LOCKED; 203 break; 204 case EXPOSURE_MODE_AUTO: 205 nativeExposureMode = OHOS_CAMERA_EXPOSURE_MODE_AUTO; 206 break; 207 case EXPOSURE_MODE_CONTINUOUS_AUTO: 208 nativeExposureMode = OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO; 209 break; 210 default: 211 MEDIA_ERR_LOG("Invalid exposure mode value received from application"); 212 return -1; 213 } 214 215 return 0; 216 } 217 MapExposureModeEnum(camera_exposure_mode_enum_t nativeExposureMode,int32_t & jsExposureMode)218 static void MapExposureModeEnum(camera_exposure_mode_enum_t nativeExposureMode, int32_t &jsExposureMode) 219 { 220 MEDIA_INFO_LOG("native exposure mode = %{public}d", static_cast<int32_t>(nativeExposureMode)); 221 switch (nativeExposureMode) { 222 case OHOS_CAMERA_EXPOSURE_MODE_LOCKED: 223 jsExposureMode = EXPOSURE_MODE_LOCKED; 224 break; 225 case OHOS_CAMERA_EXPOSURE_MODE_AUTO: 226 jsExposureMode = EXPOSURE_MODE_AUTO; 227 break; 228 case OHOS_CAMERA_EXPOSURE_MODE_CONTINUOUS_AUTO: 229 jsExposureMode = EXPOSURE_MODE_CONTINUOUS_AUTO; 230 break; 231 default: 232 MEDIA_ERR_LOG("Received native exposure mode is not supported with JS"); 233 jsExposureMode = -1; 234 } 235 } 236 MapFocusStateEnum(FocusCallback::FocusState nativeFocusState,int32_t & jsFocusState)237 static void MapFocusStateEnum(FocusCallback::FocusState nativeFocusState, int32_t &jsFocusState) 238 { 239 MEDIA_INFO_LOG("native focus state = %{public}d", static_cast<int32_t>(nativeFocusState)); 240 switch (nativeFocusState) { 241 case FocusCallback::SCAN: 242 jsFocusState = FOCUS_STATE_SCAN; 243 break; 244 case FocusCallback::FOCUSED: 245 jsFocusState = FOCUS_STATE_FOCUSED; 246 break; 247 case FocusCallback::UNFOCUSED: 248 default: 249 jsFocusState = FOCUS_STATE_UNFOCUSED; 250 } 251 } 252 MapExposureStateEnum(ExposureCallback::ExposureState nativeExposureState,int32_t & jsExposureState)253 static void MapExposureStateEnum(ExposureCallback::ExposureState nativeExposureState, int32_t &jsExposureState) 254 { 255 MEDIA_INFO_LOG("native exposure state = %{public}d", static_cast<int32_t>(nativeExposureState)); 256 switch (nativeExposureState) { 257 case ExposureCallback::SCAN: 258 jsExposureState = EXPOSURE_STATE_SCAN; 259 break; 260 case ExposureCallback::CONVERGED: 261 default: 262 jsExposureState = EXPOSURE_STATE_CONVERGED; 263 } 264 } 265 MapCameraPositionEnum(camera_position_enum_t nativeCamPos,int32_t & jsCameraPosition)266 static void MapCameraPositionEnum(camera_position_enum_t nativeCamPos, int32_t &jsCameraPosition) 267 { 268 MEDIA_INFO_LOG("native cam pos = %{public}d", static_cast<int32_t>(nativeCamPos)); 269 switch (nativeCamPos) { 270 case OHOS_CAMERA_POSITION_FRONT: 271 jsCameraPosition = CAMERA_POSITION_FRONT; 272 break; 273 case OHOS_CAMERA_POSITION_BACK: 274 jsCameraPosition = CAMERA_POSITION_BACK; 275 break; 276 case OHOS_CAMERA_POSITION_OTHER: 277 default: 278 jsCameraPosition = CAMERA_POSITION_UNSPECIFIED; 279 } 280 } 281 MapCameraPositionEnumFromJs(int32_t jsCameraPosition,camera_position_enum_t & nativeCamPos)282 static int32_t MapCameraPositionEnumFromJs(int32_t jsCameraPosition, camera_position_enum_t &nativeCamPos) 283 { 284 MEDIA_INFO_LOG("js cam pos = %{public}d", jsCameraPosition); 285 switch (jsCameraPosition) { 286 case CAMERA_POSITION_FRONT: 287 nativeCamPos = OHOS_CAMERA_POSITION_FRONT; 288 break; 289 case CAMERA_POSITION_BACK: 290 nativeCamPos = OHOS_CAMERA_POSITION_BACK; 291 break; 292 case CAMERA_POSITION_UNSPECIFIED: 293 nativeCamPos = OHOS_CAMERA_POSITION_OTHER; 294 break; 295 default: 296 MEDIA_ERR_LOG("Invalid camera position value received from application"); 297 return -1; 298 } 299 300 return 0; 301 } 302 MapCameraFormatEnum(camera_format_t nativeCamFormat,int32_t & jsCameraFormat)303 static void MapCameraFormatEnum(camera_format_t nativeCamFormat, int32_t &jsCameraFormat) 304 { 305 MEDIA_INFO_LOG("native cam format = %{public}d", static_cast<int32_t>(nativeCamFormat)); 306 switch (nativeCamFormat) { 307 case OHOS_CAMERA_FORMAT_YCRCB_420_SP: 308 jsCameraFormat = CAMERA_FORMAT_YUV_420_SP; 309 break; 310 case OHOS_CAMERA_FORMAT_JPEG: 311 jsCameraFormat = CAMERA_FORMAT_JPEG; 312 break; 313 case OHOS_CAMERA_FORMAT_RGBA_8888: 314 case OHOS_CAMERA_FORMAT_YCBCR_420_888: 315 default: 316 jsCameraFormat = -1; 317 MEDIA_ERR_LOG("The native camera format is not supported with JS"); 318 } 319 } 320 MapMetadataObjSupportedTypesEnum(MetadataObjectType nativeMetadataObjType,int32_t & jsMetadataObjType)321 static void MapMetadataObjSupportedTypesEnum(MetadataObjectType nativeMetadataObjType, int32_t &jsMetadataObjType) 322 { 323 MEDIA_INFO_LOG("native metadata Object Type = %{public}d", static_cast<int32_t>(nativeMetadataObjType)); 324 switch (nativeMetadataObjType) { 325 case MetadataObjectType::FACE: 326 jsMetadataObjType = JSMetadataObjectType::FACE; 327 break; 328 default: 329 jsMetadataObjType = -1; 330 MEDIA_ERR_LOG("Native Metadata object type not supported with JS"); 331 } 332 } 333 MapMetadataObjSupportedTypesEnumFromJS(int32_t jsMetadataObjType,MetadataObjectType & nativeMetadataObjType,bool & isValid)334 static void MapMetadataObjSupportedTypesEnumFromJS(int32_t jsMetadataObjType, 335 MetadataObjectType &nativeMetadataObjType, bool &isValid) 336 { 337 MEDIA_INFO_LOG("JS metadata Object Type = %{public}d", jsMetadataObjType); 338 switch (jsMetadataObjType) { 339 case JSMetadataObjectType::FACE: 340 nativeMetadataObjType = MetadataObjectType::FACE; 341 break; 342 default: 343 isValid = false; 344 MEDIA_ERR_LOG("JS Metadata object type not supported with native"); 345 } 346 } 347 MapCameraFormatEnumFromJs(int32_t jsCameraFormat,camera_format_t & nativeCamFormat)348 static int32_t MapCameraFormatEnumFromJs(int32_t jsCameraFormat, camera_format_t &nativeCamFormat) 349 { 350 MEDIA_INFO_LOG("js cam format = %{public}d", jsCameraFormat); 351 switch (jsCameraFormat) { 352 case CAMERA_FORMAT_YUV_420_SP: 353 nativeCamFormat = OHOS_CAMERA_FORMAT_YCRCB_420_SP; 354 break; 355 case CAMERA_FORMAT_JPEG: 356 nativeCamFormat = OHOS_CAMERA_FORMAT_JPEG; 357 break; 358 default: 359 MEDIA_ERR_LOG("Invalid or unsupported camera format value received from application"); 360 return -1; 361 } 362 363 return 0; 364 } 365 MapCameraTypeEnum(camera_type_enum_t nativeCamType,int32_t & jsCameraType)366 static void MapCameraTypeEnum(camera_type_enum_t nativeCamType, int32_t &jsCameraType) 367 { 368 MEDIA_INFO_LOG("native cam type = %{public}d", static_cast<int32_t>(nativeCamType)); 369 switch (nativeCamType) { 370 case OHOS_CAMERA_TYPE_WIDE_ANGLE: 371 jsCameraType = CAMERA_TYPE_WIDE_ANGLE; 372 break; 373 case OHOS_CAMERA_TYPE_ULTRA_WIDE: 374 jsCameraType = CAMERA_TYPE_ULTRA_WIDE; 375 break; 376 case OHOS_CAMERA_TYPE_TELTPHOTO: 377 jsCameraType = CAMERA_TYPE_TELEPHOTO; 378 break; 379 case OHOS_CAMERA_TYPE_TRUE_DEAPTH: 380 jsCameraType = CAMERA_TYPE_TRUE_DEPTH; 381 break; 382 case OHOS_CAMERA_TYPE_LOGICAL: 383 MEDIA_ERR_LOG("Logical camera type is treated as unspecified"); 384 jsCameraType = CAMERA_TYPE_DEFAULT; 385 break; 386 case OHOS_CAMERA_TYPE_UNSPECIFIED: 387 default: 388 jsCameraType = CAMERA_TYPE_DEFAULT; 389 } 390 } 391 MapCameraTypeEnumFromJs(int32_t jsCameraType,camera_type_enum_t & nativeCamType)392 static int32_t MapCameraTypeEnumFromJs(int32_t jsCameraType, camera_type_enum_t &nativeCamType) 393 { 394 MEDIA_INFO_LOG("js cam type = %{public}d", jsCameraType); 395 switch (jsCameraType) { 396 case CAMERA_TYPE_WIDE_ANGLE: 397 nativeCamType = OHOS_CAMERA_TYPE_WIDE_ANGLE; 398 break; 399 case CAMERA_TYPE_ULTRA_WIDE: 400 nativeCamType = OHOS_CAMERA_TYPE_ULTRA_WIDE; 401 break; 402 case CAMERA_TYPE_TELEPHOTO: 403 nativeCamType = OHOS_CAMERA_TYPE_TELTPHOTO; 404 break; 405 case CAMERA_TYPE_TRUE_DEPTH: 406 nativeCamType = OHOS_CAMERA_TYPE_TRUE_DEAPTH; 407 break; 408 case CAMERA_TYPE_DEFAULT: 409 nativeCamType = OHOS_CAMERA_TYPE_UNSPECIFIED; 410 break; 411 default: 412 MEDIA_ERR_LOG("Invalid camera type value received from application"); 413 return -1; 414 } 415 416 return 0; 417 } 418 MapCameraConnectionTypeEnum(camera_connection_type_t nativeCamConnType,int32_t & jsCameraConnType)419 static void MapCameraConnectionTypeEnum(camera_connection_type_t nativeCamConnType, int32_t &jsCameraConnType) 420 { 421 MEDIA_INFO_LOG("native cam connection type = %{public}d", static_cast<int32_t>(nativeCamConnType)); 422 switch (nativeCamConnType) { 423 case OHOS_CAMERA_CONNECTION_TYPE_REMOTE: 424 jsCameraConnType = CAMERA_CONNECTION_REMOTE; 425 break; 426 case OHOS_CAMERA_CONNECTION_TYPE_USB_PLUGIN: 427 jsCameraConnType = CAMERA_CONNECTION_USB_PLUGIN; 428 break; 429 case OHOS_CAMERA_CONNECTION_TYPE_BUILTIN: 430 default: 431 jsCameraConnType = CAMERA_CONNECTION_BUILT_IN; 432 } 433 } 434 MapQualityLevelFromJs(int32_t jsQuality,PhotoCaptureSetting::QualityLevel & nativeQuality)435 static int32_t MapQualityLevelFromJs(int32_t jsQuality, PhotoCaptureSetting::QualityLevel &nativeQuality) 436 { 437 MEDIA_INFO_LOG("js quality level = %{public}d", jsQuality); 438 switch (jsQuality) { 439 case QUALITY_LEVEL_HIGH: 440 nativeQuality = PhotoCaptureSetting::QUALITY_LEVEL_HIGH; 441 break; 442 case QUALITY_LEVEL_MEDIUM: 443 nativeQuality = PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM; 444 break; 445 case QUALITY_LEVEL_LOW: 446 nativeQuality = PhotoCaptureSetting::QUALITY_LEVEL_LOW; 447 break; 448 default: 449 MEDIA_ERR_LOG("Invalid quality value received from application"); 450 return -1; 451 } 452 453 return 0; 454 } 455 MapImageRotationFromJs(int32_t jsRotation,PhotoCaptureSetting::RotationConfig & nativeRotation)456 static int32_t MapImageRotationFromJs(int32_t jsRotation, PhotoCaptureSetting::RotationConfig &nativeRotation) 457 { 458 MEDIA_INFO_LOG("js rotation = %{public}d", jsRotation); 459 switch (jsRotation) { 460 case ROTATION_0: 461 nativeRotation = PhotoCaptureSetting::Rotation_0; 462 break; 463 case ROTATION_90: 464 nativeRotation = PhotoCaptureSetting::Rotation_90; 465 break; 466 case ROTATION_180: 467 nativeRotation = PhotoCaptureSetting::Rotation_180; 468 break; 469 case ROTATION_270: 470 nativeRotation = PhotoCaptureSetting::Rotation_270; 471 break; 472 default: 473 MEDIA_ERR_LOG("Invalid rotation value received from application"); 474 return -1; 475 } 476 477 return 0; 478 } 479 MapCameraStatusEnum(CameraStatus deviceStatus,int32_t & jsCameraStatus)480 static void MapCameraStatusEnum(CameraStatus deviceStatus, int32_t &jsCameraStatus) 481 { 482 MEDIA_INFO_LOG("native camera status = %{public}d", static_cast<int32_t>(deviceStatus)); 483 switch (deviceStatus) { 484 case CAMERA_DEVICE_STATUS_UNAVAILABLE: 485 jsCameraStatus = JS_CAMERA_STATUS_UNAVAILABLE; 486 break; 487 case CAMERA_DEVICE_STATUS_AVAILABLE: 488 jsCameraStatus = JS_CAMERA_STATUS_AVAILABLE; 489 break; 490 default: 491 MEDIA_ERR_LOG("Received native camera status is not supported with JS"); 492 jsCameraStatus = -1; 493 } 494 } 495 VideoStabilizationModeEnum(CameraVideoStabilizationMode nativeVideoStabilizationMode,int32_t & jsVideoStabilizationMode)496 static void VideoStabilizationModeEnum( 497 CameraVideoStabilizationMode nativeVideoStabilizationMode, int32_t &jsVideoStabilizationMode) 498 { 499 MEDIA_INFO_LOG( 500 "native video stabilization mode = %{public}d", static_cast<int32_t>(nativeVideoStabilizationMode)); 501 switch (nativeVideoStabilizationMode) { 502 case OHOS_CAMERA_VIDEO_STABILIZATION_OFF: 503 jsVideoStabilizationMode = OFF; 504 break; 505 case OHOS_CAMERA_VIDEO_STABILIZATION_LOW: 506 jsVideoStabilizationMode = LOW; 507 break; 508 case OHOS_CAMERA_VIDEO_STABILIZATION_MIDDLE: 509 jsVideoStabilizationMode = MIDDLE; 510 break; 511 case OHOS_CAMERA_VIDEO_STABILIZATION_HIGH: 512 jsVideoStabilizationMode = HIGH; 513 break; 514 case OHOS_CAMERA_VIDEO_STABILIZATION_AUTO: 515 jsVideoStabilizationMode = AUTO; 516 break; 517 default: 518 MEDIA_ERR_LOG("Received native video stabilization mode is not supported with JS"); 519 jsVideoStabilizationMode = -1; 520 } 521 } 522 CreateNapiErrorObject(napi_env env,int32_t errorCode,const char * errString,std::unique_ptr<JSAsyncContextOutput> & jsContext)523 static void CreateNapiErrorObject(napi_env env, int32_t errorCode, const char* errString, 524 std::unique_ptr<JSAsyncContextOutput> &jsContext) 525 { 526 napi_get_undefined(env, &jsContext->data); 527 napi_value napiErrorCode = nullptr; 528 napi_value napiErrorMsg = nullptr; 529 530 std::string errorCodeStr = std::to_string(errorCode); 531 napi_create_string_utf8(env, errorCodeStr.c_str(), NAPI_AUTO_LENGTH, &napiErrorCode); 532 napi_create_string_utf8(env, errString, NAPI_AUTO_LENGTH, &napiErrorMsg); 533 534 napi_create_object(env, &jsContext->error); 535 napi_set_named_property(env, jsContext->error, "code", napiErrorCode); 536 napi_set_named_property(env, jsContext->error, "message", napiErrorMsg); 537 538 jsContext->status = false; 539 } 540 InvokeJSAsyncMethod(napi_env env,napi_deferred deferred,napi_ref callbackRef,napi_async_work work,const JSAsyncContextOutput & asyncContext)541 static void InvokeJSAsyncMethod(napi_env env, napi_deferred deferred, 542 napi_ref callbackRef, napi_async_work work, const JSAsyncContextOutput &asyncContext) 543 { 544 napi_value retVal; 545 napi_value callback = nullptr; 546 std::string funcName = asyncContext.funcName; 547 MEDIA_INFO_LOG("%{public}s, context->InvokeJSAsyncMethod start", funcName.c_str()); 548 /* Deferred is used when JS Callback method expects a promise value */ 549 if (deferred) { 550 if (asyncContext.status) { 551 napi_resolve_deferred(env, deferred, asyncContext.data); 552 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod napi_resolve_deferred", funcName.c_str()); 553 } else { 554 napi_reject_deferred(env, deferred, asyncContext.error); 555 MEDIA_ERR_LOG("%{public}s, InvokeJSAsyncMethod napi_reject_deferred", funcName.c_str()); 556 } 557 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod end deferred", funcName.c_str()); 558 } else { 559 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod callback", funcName.c_str()); 560 napi_value result[ARGS_TWO]; 561 result[PARAM0] = asyncContext.error; 562 result[PARAM1] = asyncContext.data; 563 napi_get_reference_value(env, callbackRef, &callback); 564 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod napi_call_function start", funcName.c_str()); 565 napi_call_function(env, nullptr, callback, ARGS_TWO, result, &retVal); 566 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod napi_call_function end", funcName.c_str()); 567 napi_delete_reference(env, callbackRef); 568 } 569 napi_delete_async_work(env, work); 570 MEDIA_INFO_LOG("%{public}s, InvokeJSAsyncMethod inner end", funcName.c_str()); 571 } 572 IncreamentAndGet(uint32_t & num)573 static int32_t IncreamentAndGet(uint32_t &num) 574 { 575 int32_t temp = num & 0x00ffffff; 576 if (temp >= 0xffff) { 577 num = num & 0xff000000; 578 } 579 num++; 580 return num; 581 } 582 CheckInvalidArgument(napi_env env,size_t argc,int32_t length,napi_value * argv,NapiCheckInvalidArgumentModes mode)583 static bool CheckInvalidArgument(napi_env env, size_t argc, int32_t length, 584 napi_value *argv, NapiCheckInvalidArgumentModes mode) 585 { 586 bool isPass = true; 587 napi_valuetype valueTypeArray[length]; 588 for (int32_t i = 0; i < length; i++) { 589 napi_typeof(env, argv[i], &valueTypeArray[i]); 590 } 591 switch (mode) { 592 case CREATE_CAMERA_INPUT_INSTANCE: 593 if (argc == ARGS_ONE) { 594 isPass = valueTypeArray[0] == napi_object; 595 } else if (argc == ARGS_TWO) { 596 isPass = (valueTypeArray[0] == napi_number) && (valueTypeArray[1] == napi_number); 597 } else { 598 isPass = false; 599 } 600 break; 601 602 case CREATE_PREVIEW_OUTPUT_INSTANCE: 603 isPass = (argc == ARGS_TWO) && 604 (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_string); 605 break; 606 607 case CREATE_PHOTO_OUTPUT_INSTANCE: 608 isPass = (argc == ARGS_TWO) && 609 (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_string); 610 break; 611 612 case CREATE_VIDEO_OUTPUT_INSTANCE: 613 isPass = (argc == ARGS_TWO) && 614 (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_string); 615 break; 616 617 case CREATE_METADATA_OUTPUT_INSTANCE: 618 isPass = argc == ARGS_ONE; 619 if (argc == ARGS_ONE) { 620 napi_is_array(env, argv[0], &isPass); 621 } else { 622 isPass = false; 623 } 624 break; 625 626 case ADD_INPUT: 627 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object); 628 break; 629 630 case REMOVE_INPUT: 631 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object); 632 break; 633 634 case ADD_OUTPUT: 635 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object); 636 break; 637 638 case REMOVE_OUTPUT: 639 isPass = (argc == ARGS_ONE) && (valueTypeArray[0] == napi_object); 640 break; 641 642 case PHOTO_OUT_CAPTURE: 643 if (argc == ARGS_ZERO) { 644 isPass = true; 645 } else if (argc == ARGS_ONE) { 646 isPass = valueTypeArray[0] == napi_object || valueTypeArray[0] == napi_function; 647 } else if (argc == ARGS_TWO) { 648 isPass = (valueTypeArray[0] == napi_object) && (valueTypeArray[1] == napi_function); 649 } else { 650 isPass = false; 651 } 652 break; 653 default: 654 break; 655 } 656 if (!isPass) { 657 std::string errorCode = std::to_string(CameraErrorCode::INVALID_ARGUMENT); 658 napi_throw_type_error(env, errorCode.c_str(), ""); 659 } 660 return isPass; 661 } 662 CheckError(napi_env env,int32_t retCode)663 static bool CheckError(napi_env env, int32_t retCode) 664 { 665 if ((retCode != 0)) { 666 std::string errorCode = std::to_string(retCode); 667 napi_throw_error(env, errorCode.c_str(), ""); 668 return false; 669 } 670 return true; 671 } 672 }; 673 } // namespace CameraStandard 674 } // namespace OHOS 675 #endif /* CAMERA_NAPI_UTILS_H_ */ 676