1 /*
2 * Copyright (c) 2021-2024 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 "input/camera_manager_napi.h"
17
18 #include <cstddef>
19 #include <cstdint>
20 #include <mutex>
21 #include <string>
22 #include <unordered_map>
23 #include <utility>
24 #include <uv.h>
25
26 #include "camera_device.h"
27 #include "camera_error_code.h"
28 #include "camera_log.h"
29 #include "camera_manager.h"
30 #include "camera_napi_const.h"
31 #include "camera_napi_event_emitter.h"
32 #include "camera_napi_object_types.h"
33 #include "camera_napi_param_parser.h"
34 #include "camera_napi_security_utils.h"
35 #include "camera_napi_template_utils.h"
36 #include "camera_napi_utils.h"
37 #include "camera_output_capability.h"
38 #include "camera_xcollie.h"
39 #include "capture_scene_const.h"
40 #include "input/camera_napi.h"
41 #include "input/prelaunch_config.h"
42 #include "js_native_api.h"
43 #include "js_native_api_types.h"
44 #include "mode/aperture_video_session_napi.h"
45 #include "mode/fluorescence_photo_session_napi.h"
46 #include "mode/high_res_photo_session_napi.h"
47 #include "mode/light_painting_session_napi.h"
48 #include "mode/macro_photo_session_napi.h"
49 #include "mode/macro_video_session_napi.h"
50 #include "mode/night_session_napi.h"
51 #include "mode/photo_session_for_sys_napi.h"
52 #include "mode/photo_session_napi.h"
53 #include "mode/portrait_session_napi.h"
54 #include "mode/profession_session_napi.h"
55 #include "mode/quick_shot_photo_session_napi.h"
56 #include "mode/secure_camera_session_napi.h"
57 #include "mode/slow_motion_session_napi.h"
58 #include "mode/time_lapse_photo_session_napi.h"
59 #include "mode/video_session_for_sys_napi.h"
60 #include "mode/video_session_napi.h"
61 #include "napi/native_common.h"
62 #include "refbase.h"
63 #include "napi/native_node_api.h"
64
65 namespace OHOS {
66 namespace CameraStandard {
67 namespace {
68 thread_local std::unordered_map<std::string, napi_ref> g_napiValueCacheMap {};
CacheNapiValue(napi_env env,const std::string & key,napi_value value)69 void CacheNapiValue(napi_env env, const std::string& key, napi_value value)
70 {
71 napi_ref ref;
72 napi_status status = napi_create_reference(env, value, 0, &ref); // 0 is weakref.
73 if (status == napi_ok) {
74 g_napiValueCacheMap[key] = ref;
75 MEDIA_DEBUG_LOG("CacheNapiValue cache->%{public}s", key.c_str());
76 }
77 }
78
GetCacheNapiValue(napi_env env,const std::string & key)79 napi_value GetCacheNapiValue(napi_env env, const std::string& key)
80 {
81 napi_ref ref;
82 auto it = g_napiValueCacheMap.find(key);
83 CHECK_ERROR_RETURN_RET(it == g_napiValueCacheMap.end(), nullptr);
84 ref = it->second;
85 napi_value result;
86 napi_status status = napi_get_reference_value(env, ref, &result);
87 if (status == napi_ok) {
88 MEDIA_DEBUG_LOG("GetCacheNapiValue hit cache->%{public}s", key.c_str());
89 return result;
90 }
91 return nullptr;
92 }
93
CacheSupportedOutputCapability(napi_env env,const std::string & cameraId,int32_t mode,napi_value value)94 void CacheSupportedOutputCapability(napi_env env, const std::string& cameraId, int32_t mode, napi_value value)
95 {
96 std::string key = "OutputCapability:" + cameraId + ":\t" + to_string(mode);
97 CacheNapiValue(env, key, value);
98 MEDIA_DEBUG_LOG("CacheSupportedOutputCapability cache->%{public}s:%{public}d", key.c_str(), mode);
99 }
100
GetCachedSupportedOutputCapability(napi_env env,const std::string & cameraId,int32_t mode)101 napi_value GetCachedSupportedOutputCapability(napi_env env, const std::string& cameraId, int32_t mode)
102 {
103 std::string key = "OutputCapability:" + cameraId + ":\t" + to_string(mode);
104 napi_value result = GetCacheNapiValue(env, key);
105 if (result != nullptr) {
106 MEDIA_DEBUG_LOG("GetCachedSupportedOutputCapability hit cache->%{public}s:%{public}d", key.c_str(), mode);
107 }
108 return result;
109 }
110
CacheSupportedCameras(napi_env env,const std::vector<sptr<CameraDevice>> & cameras,napi_value value)111 void CacheSupportedCameras(napi_env env, const std::vector<sptr<CameraDevice>>& cameras, napi_value value)
112 {
113 std::string key = "SupportedCameras:";
114 for (auto& camera : cameras) {
115 if (camera->GetConnectionType() != CAMERA_CONNECTION_BUILT_IN) {
116 // Exist none built_in camera. Give up cache.
117 MEDIA_DEBUG_LOG("CacheSupportedCameras exist none built_in camera. Give up cache");
118 return;
119 }
120 key.append("\t:");
121 key.append(camera->GetID());
122 }
123 CacheNapiValue(env, key, value);
124 MEDIA_DEBUG_LOG("CacheSupportedCameras cache->%{public}s", key.c_str());
125 }
126
GetCachedSupportedCameras(napi_env env,const std::vector<sptr<CameraDevice>> & cameras)127 napi_value GetCachedSupportedCameras(napi_env env, const std::vector<sptr<CameraDevice>>& cameras)
128 {
129 std::string key = "SupportedCameras:";
130 for (auto& camera : cameras) {
131 if (camera->GetConnectionType() != CAMERA_CONNECTION_BUILT_IN) {
132 // Exist none built_in camera. Give up cache.
133 MEDIA_DEBUG_LOG("GetCachedSupportedCameras exist none built_in camera. Give up cache");
134 return nullptr;
135 }
136 key.append("\t:");
137 key.append(camera->GetID());
138 }
139 napi_value result = GetCacheNapiValue(env, key);
140 if (result != nullptr) {
141 MEDIA_DEBUG_LOG("GetCachedSupportedCameras hit cache->%{public}s", key.c_str());
142 }
143 return result;
144 }
145 } // namespace
146
147 using namespace std;
148 using namespace CameraNapiSecurity;
149 thread_local napi_ref CameraManagerNapi::sConstructor_ = nullptr;
150 thread_local uint32_t CameraManagerNapi::cameraManagerTaskId = CAMERA_MANAGER_TASKID;
151
152 const std::unordered_map<SceneMode, JsSceneMode> g_nativeToNapiSupportedModeForSystem_ = {
153 {SceneMode::CAPTURE, JsSceneMode::JS_CAPTURE},
154 {SceneMode::VIDEO, JsSceneMode::JS_VIDEO},
155 {SceneMode::PORTRAIT, JsSceneMode::JS_PORTRAIT},
156 {SceneMode::NIGHT, JsSceneMode::JS_NIGHT},
157 {SceneMode::CAPTURE_MACRO, JsSceneMode::JS_CAPTURE_MARCO},
158 {SceneMode::VIDEO_MACRO, JsSceneMode::JS_VIDEO_MARCO},
159 {SceneMode::SLOW_MOTION, JsSceneMode::JS_SLOW_MOTION},
160 {SceneMode::PROFESSIONAL_PHOTO, JsSceneMode::JS_PROFESSIONAL_PHOTO},
161 {SceneMode::PROFESSIONAL_VIDEO, JsSceneMode::JS_PROFESSIONAL_VIDEO},
162 {SceneMode::HIGH_RES_PHOTO, JsSceneMode::JS_HIGH_RES_PHOTO},
163 {SceneMode::SECURE, JsSceneMode::JS_SECURE_CAMERA},
164 {SceneMode::QUICK_SHOT_PHOTO, JsSceneMode::JS_QUICK_SHOT_PHOTO},
165 {SceneMode::APERTURE_VIDEO, JsSceneMode::JS_APERTURE_VIDEO},
166 {SceneMode::PANORAMA_PHOTO, JsSceneMode::JS_PANORAMA_PHOTO},
167 {SceneMode::LIGHT_PAINTING, JsSceneMode::JS_LIGHT_PAINTING},
168 {SceneMode::TIMELAPSE_PHOTO, JsSceneMode::JS_TIMELAPSE_PHOTO},
169 {SceneMode::FLUORESCENCE_PHOTO, JsSceneMode::JS_FLUORESCENCE_PHOTO},
170 };
171
172 const std::unordered_map<SceneMode, JsSceneMode> g_nativeToNapiSupportedMode_ = {
173 {SceneMode::CAPTURE, JsSceneMode::JS_CAPTURE},
174 {SceneMode::VIDEO, JsSceneMode::JS_VIDEO},
175 {SceneMode::SECURE, JsSceneMode::JS_SECURE_CAMERA},
176 };
177
CameraManagerCallbackNapi(napi_env env)178 CameraManagerCallbackNapi::CameraManagerCallbackNapi(napi_env env): ListenerBase(env)
179 {}
180
~CameraManagerCallbackNapi()181 CameraManagerCallbackNapi::~CameraManagerCallbackNapi()
182 {
183 }
184
OnCameraStatusCallbackAsync(const CameraStatusInfo & cameraStatusInfo) const185 void CameraManagerCallbackNapi::OnCameraStatusCallbackAsync(const CameraStatusInfo &cameraStatusInfo) const
186 {
187 MEDIA_DEBUG_LOG("OnCameraStatusCallbackAsync is called");
188 std::unique_ptr<CameraStatusCallbackInfo> callbackInfo =
189 std::make_unique<CameraStatusCallbackInfo>(cameraStatusInfo, shared_from_this());
190 CameraStatusCallbackInfo *event = callbackInfo.get();
191 auto task = [event]() {
192 CameraStatusCallbackInfo* callbackInfo = reinterpret_cast<CameraStatusCallbackInfo *>(event);
193 if (callbackInfo) {
194 auto listener = callbackInfo->listener_.lock();
195 CHECK_EXECUTE(listener, listener->OnCameraStatusCallback(callbackInfo->info_));
196 delete callbackInfo;
197 }
198 };
199 if (napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) {
200 MEDIA_ERR_LOG("failed to execute work");
201 } else {
202 callbackInfo.release();
203 }
204 }
205
OnCameraStatusCallback(const CameraStatusInfo & cameraStatusInfo) const206 void CameraManagerCallbackNapi::OnCameraStatusCallback(const CameraStatusInfo& cameraStatusInfo) const
207 {
208 MEDIA_DEBUG_LOG("OnCameraStatusCallback is called");
209 napi_value result[ARGS_TWO];
210 napi_value retVal;
211 napi_value propValue;
212 napi_value undefinedResult;
213
214 napi_get_undefined(env_, &result[PARAM0]);
215 napi_get_undefined(env_, &result[PARAM1]);
216 napi_get_undefined(env_, &undefinedResult);
217 CAMERA_NAPI_CHECK_NULL_PTR_RETURN_VOID(cameraStatusInfo.cameraDevice, "callback cameraDevice is null");
218 napi_create_object(env_, &result[PARAM1]);
219
220 if (cameraStatusInfo.cameraDevice != nullptr) {
221 napi_value cameraDeviceNapi = CameraNapiObjCameraDevice(*cameraStatusInfo.cameraDevice).GenerateNapiValue(env_);
222 napi_set_named_property(env_, result[PARAM1], "camera", cameraDeviceNapi);
223 } else {
224 MEDIA_ERR_LOG("Camera info is null");
225 napi_set_named_property(env_, result[PARAM1], "camera", undefinedResult);
226 }
227
228 int32_t jsCameraStatus = -1;
229 jsCameraStatus = cameraStatusInfo.cameraStatus;
230 napi_create_int64(env_, jsCameraStatus, &propValue);
231 napi_set_named_property(env_, result[PARAM1], "status", propValue);
232 MEDIA_INFO_LOG("CameraId: %{public}s, CameraStatus: %{public}d", cameraStatusInfo.cameraDevice->GetID().c_str(),
233 cameraStatusInfo.cameraStatus);
234
235 ExecuteCallbackNapiPara callbackNapiPara { .recv = nullptr, .argc = ARGS_TWO, .argv = result, .result = &retVal };
236 ExecuteCallback("cameraStatus", callbackNapiPara);
237 }
238
OnCameraStatusChanged(const CameraStatusInfo & cameraStatusInfo) const239 void CameraManagerCallbackNapi::OnCameraStatusChanged(const CameraStatusInfo &cameraStatusInfo) const
240 {
241 MEDIA_DEBUG_LOG("OnCameraStatusChanged is called, CameraStatus: %{public}d", cameraStatusInfo.cameraStatus);
242 OnCameraStatusCallbackAsync(cameraStatusInfo);
243 }
244
OnFlashlightStatusChanged(const std::string & cameraID,const FlashStatus flashStatus) const245 void CameraManagerCallbackNapi::OnFlashlightStatusChanged(const std::string &cameraID,
246 const FlashStatus flashStatus) const
247 {
248 (void)cameraID;
249 (void)flashStatus;
250 }
251
CameraMuteListenerNapi(napi_env env)252 CameraMuteListenerNapi::CameraMuteListenerNapi(napi_env env): ListenerBase(env)
253 {
254 MEDIA_DEBUG_LOG("CameraMuteListenerNapi is called.");
255 }
256
~CameraMuteListenerNapi()257 CameraMuteListenerNapi::~CameraMuteListenerNapi()
258 {
259 MEDIA_DEBUG_LOG("~CameraMuteListenerNapi is called.");
260 }
261
OnCameraMuteCallbackAsync(bool muteMode) const262 void CameraMuteListenerNapi::OnCameraMuteCallbackAsync(bool muteMode) const
263 {
264 std::unique_ptr<CameraMuteCallbackInfo> callbackInfo =
265 std::make_unique<CameraMuteCallbackInfo>(muteMode, shared_from_this());
266 CameraMuteCallbackInfo *event = callbackInfo.get();
267 auto task = [event]() {
268 CameraMuteCallbackInfo* callbackInfo = reinterpret_cast<CameraMuteCallbackInfo *>(event);
269 if (callbackInfo) {
270 auto listener = callbackInfo->listener_.lock();
271 CHECK_EXECUTE(listener != nullptr, listener->OnCameraMuteCallback(callbackInfo->muteMode_));
272 delete callbackInfo;
273 }
274 };
275 if (napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) {
276 MEDIA_ERR_LOG("Failed to execute work");
277 } else {
278 callbackInfo.release();
279 }
280 }
281
OnCameraMuteCallback(bool muteMode) const282 void CameraMuteListenerNapi::OnCameraMuteCallback(bool muteMode) const
283 {
284 MEDIA_DEBUG_LOG("OnCameraMuteCallback is called, muteMode: %{public}d", muteMode);
285 napi_value result[ARGS_TWO];
286 napi_value retVal;
287 napi_get_undefined(env_, &result[PARAM0]);
288 napi_get_undefined(env_, &result[PARAM1]);
289 napi_get_boolean(env_, muteMode, &result[PARAM1]);
290
291 ExecuteCallbackNapiPara callbackNapiPara { .recv = nullptr, .argc = ARGS_TWO, .argv = result, .result = &retVal };
292 ExecuteCallback("cameraMute", callbackNapiPara);
293 }
294
OnCameraMute(bool muteMode) const295 void CameraMuteListenerNapi::OnCameraMute(bool muteMode) const
296 {
297 MEDIA_DEBUG_LOG("OnCameraMute is called, muteMode: %{public}d", muteMode);
298 OnCameraMuteCallbackAsync(muteMode);
299 }
300
TorchListenerNapi(napi_env env)301 TorchListenerNapi::TorchListenerNapi(napi_env env): ListenerBase(env)
302 {
303 MEDIA_INFO_LOG("TorchListenerNapi is called.");
304 }
305
~TorchListenerNapi()306 TorchListenerNapi::~TorchListenerNapi()
307 {
308 MEDIA_DEBUG_LOG("~TorchListenerNapi is called.");
309 }
310
OnTorchStatusChangeCallbackAsync(const TorchStatusInfo & torchStatusInfo) const311 void TorchListenerNapi::OnTorchStatusChangeCallbackAsync(const TorchStatusInfo &torchStatusInfo) const
312 {
313 MEDIA_DEBUG_LOG("OnTorchStatusChangeCallbackAsync is called");
314 std::unique_ptr<TorchStatusChangeCallbackInfo> callbackInfo =
315 std::make_unique<TorchStatusChangeCallbackInfo>(torchStatusInfo, shared_from_this());
316 TorchStatusChangeCallbackInfo *event = callbackInfo.get();
317 auto task = [event]() {
318 TorchStatusChangeCallbackInfo* callbackInfo = reinterpret_cast<TorchStatusChangeCallbackInfo *>(event);
319 if (callbackInfo) {
320 auto listener = callbackInfo->listener_.lock();
321 CHECK_EXECUTE(listener != nullptr, listener->OnTorchStatusChangeCallback(callbackInfo->info_));
322 delete callbackInfo;
323 }
324 };
325 if (napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) {
326 MEDIA_ERR_LOG("Failed to execute work");
327 } else {
328 callbackInfo.release();
329 }
330 }
331
OnTorchStatusChangeCallback(const TorchStatusInfo & torchStatusInfo) const332 void TorchListenerNapi::OnTorchStatusChangeCallback(const TorchStatusInfo& torchStatusInfo) const
333 {
334 MEDIA_DEBUG_LOG("OnTorchStatusChangeCallback is called");
335 ExecuteCallbackScopeSafe("torchStatusChange", [&]() {
336 napi_value errCode = CameraNapiUtils::GetUndefinedValue(env_);
337 napi_value callbackObj;
338 TorchStatusInfo info = torchStatusInfo;
339 CameraNapiObject torchStateObj {{
340 { "isTorchAvailable", &info.isTorchAvailable },
341 { "isTorchActive", &info.isTorchActive },
342 { "torchLevel", &info.torchLevel }
343 }};
344 callbackObj = torchStateObj.CreateNapiObjFromMap(env_);
345 return ExecuteCallbackData(env_, errCode, callbackObj);
346 });
347 }
348
OnTorchStatusChange(const TorchStatusInfo & torchStatusInfo) const349 void TorchListenerNapi::OnTorchStatusChange(const TorchStatusInfo &torchStatusInfo) const
350 {
351 MEDIA_DEBUG_LOG("OnTorchStatusChange is called");
352 OnTorchStatusChangeCallbackAsync(torchStatusInfo);
353 }
354
FoldListenerNapi(napi_env env)355 FoldListenerNapi::FoldListenerNapi(napi_env env): ListenerBase(env)
356 {
357 MEDIA_DEBUG_LOG("FoldListenerNapi is called.");
358 }
359
~FoldListenerNapi()360 FoldListenerNapi::~FoldListenerNapi()
361 {
362 MEDIA_DEBUG_LOG("~FoldListenerNapi is called.");
363 }
364
OnFoldStatusChangedCallbackAsync(const FoldStatusInfo & foldStatusInfo) const365 void FoldListenerNapi::OnFoldStatusChangedCallbackAsync(const FoldStatusInfo &foldStatusInfo) const
366 {
367 MEDIA_DEBUG_LOG("OnFoldStatusChangedCallbackAsync is called");
368 std::unique_ptr<FoldStatusChangeCallbackInfo> callbackInfo =
369 std::make_unique<FoldStatusChangeCallbackInfo>(foldStatusInfo, shared_from_this());
370 FoldStatusChangeCallbackInfo *event = callbackInfo.get();
371 auto task = [event]() {
372 FoldStatusChangeCallbackInfo* callbackInfo = reinterpret_cast<FoldStatusChangeCallbackInfo *>(event);
373 if (callbackInfo) {
374 auto listener = callbackInfo->listener_.lock();
375 if (listener != nullptr) {
376 listener->OnFoldStatusChangedCallback(callbackInfo->info_);
377 }
378 delete callbackInfo;
379 }
380 };
381 if (napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) {
382 MEDIA_ERR_LOG("Failed to execute work");
383 } else {
384 callbackInfo.release();
385 }
386 }
387
OnFoldStatusChangedCallback(const FoldStatusInfo & foldStatusInfo) const388 void FoldListenerNapi::OnFoldStatusChangedCallback(const FoldStatusInfo& foldStatusInfo) const
389 {
390 MEDIA_DEBUG_LOG("OnFoldStatusChangedCallback is called");
391 napi_handle_scope scope = nullptr;
392 napi_open_handle_scope(env_, &scope);
393 CHECK_ERROR_RETURN_LOG(scope == nullptr, "scope is null");
394 napi_value result[ARGS_TWO];
395 napi_value retVal = nullptr;
396 napi_value propValue = nullptr;
397 napi_value errCode;
398
399 napi_create_object(env_, &result[PARAM0]);
400 napi_create_object(env_, &result[PARAM1]);
401 napi_create_int32(env_, foldStatusInfo.foldStatus, &propValue);
402 napi_set_named_property(env_, result[PARAM1], "foldStatus", propValue);
403 CHECK_ERROR_RETURN_LOG(napi_create_array(env_, &propValue) != napi_ok,
404 "Failed to create array napi wrapper object");
405 auto supportedCameras = foldStatusInfo.supportedCameras;
406 if (!supportedCameras.empty()) {
407 napi_create_int32(env_, 0, &errCode);
408 napi_set_named_property(env_, result[PARAM0], "code", errCode);
409 for (size_t i = 0; i < supportedCameras.size(); i++) {
410 if (supportedCameras[i] == nullptr) {
411 MEDIA_ERR_LOG("cameraDevice is null");
412 continue;
413 }
414 napi_value camera = CameraNapiObjCameraDevice(*supportedCameras[i]).GenerateNapiValue(env_);
415 CHECK_ERROR_RETURN_LOG(napi_set_element(env_, propValue, i, camera) != napi_ok,
416 "Failed to create profile napi wrapper object");
417 }
418 } else {
419 MEDIA_ERR_LOG("supportedCameras is empty");
420 napi_create_int32(env_, CameraErrorCode::SERVICE_FATL_ERROR, &errCode);
421 napi_set_named_property(env_, result[PARAM0], "code", errCode);
422 }
423 napi_set_named_property(env_, result[PARAM1], "supportedCameras", propValue);
424 ExecuteCallbackNapiPara callbackNapiPara { .recv = nullptr, .argc = ARGS_TWO, .argv = result, .result = &retVal };
425 ExecuteCallback("foldStatusChange", callbackNapiPara);
426 napi_close_handle_scope(env_, scope);
427 }
428
OnFoldStatusChanged(const FoldStatusInfo & foldStatusInfo) const429 void FoldListenerNapi::OnFoldStatusChanged(const FoldStatusInfo &foldStatusInfo) const
430 {
431 MEDIA_DEBUG_LOG("OnFoldStatusChanged is called");
432 OnFoldStatusChangedCallbackAsync(foldStatusInfo);
433 }
434
435 const std::unordered_map<JsSceneMode, SceneMode> g_jsToFwMode_ = {
436 {JsSceneMode::JS_NORMAL, SceneMode::NORMAL},
437 {JsSceneMode::JS_CAPTURE, SceneMode::CAPTURE},
438 {JsSceneMode::JS_VIDEO, SceneMode::VIDEO},
439 {JsSceneMode::JS_SECURE_CAMERA, SceneMode::SECURE},
440 };
441
442 const std::unordered_map<JsSceneMode, SceneMode> g_jsToFwMode4Sys_ = {
443 {JsSceneMode::JS_NORMAL, SceneMode::NORMAL},
444 {JsSceneMode::JS_CAPTURE, SceneMode::CAPTURE},
445 {JsSceneMode::JS_VIDEO, SceneMode::VIDEO},
446 {JsSceneMode::JS_PORTRAIT, SceneMode::PORTRAIT},
447 {JsSceneMode::JS_NIGHT, SceneMode::NIGHT},
448 {JsSceneMode::JS_SLOW_MOTION, SceneMode::SLOW_MOTION},
449 {JsSceneMode::JS_CAPTURE_MARCO, SceneMode::CAPTURE_MACRO},
450 {JsSceneMode::JS_VIDEO_MARCO, SceneMode::VIDEO_MACRO},
451 {JsSceneMode::JS_PROFESSIONAL_PHOTO, SceneMode::PROFESSIONAL_PHOTO},
452 {JsSceneMode::JS_PROFESSIONAL_VIDEO, SceneMode::PROFESSIONAL_VIDEO},
453 {JsSceneMode::JS_HIGH_RES_PHOTO, SceneMode::HIGH_RES_PHOTO},
454 {JsSceneMode::JS_SECURE_CAMERA, SceneMode::SECURE},
455 {JsSceneMode::JS_QUICK_SHOT_PHOTO, SceneMode::QUICK_SHOT_PHOTO},
456 {JsSceneMode::JS_APERTURE_VIDEO, SceneMode::APERTURE_VIDEO},
457 {JsSceneMode::JS_PANORAMA_PHOTO, SceneMode::PANORAMA_PHOTO},
458 {JsSceneMode::JS_LIGHT_PAINTING, SceneMode::LIGHT_PAINTING},
459 {JsSceneMode::JS_TIMELAPSE_PHOTO, SceneMode::TIMELAPSE_PHOTO},
460 {JsSceneMode::JS_FLUORESCENCE_PHOTO, SceneMode::FLUORESCENCE_PHOTO},
461 };
462
463 static std::unordered_map<JsPolicyType, PolicyType> g_jsToFwPolicyType_ = {
464 {JsPolicyType::JS_PRIVACY, PolicyType::PRIVACY},
465 };
466
467 std::unordered_map<int32_t, std::function<napi_value(napi_env)>> g_sessionFactories4Sys_ = {
__anonb829a37a0702() 468 {JsSceneMode::JS_CAPTURE, [] (napi_env env) {
469 return PhotoSessionForSysNapi::CreateCameraSession(env); }},
__anonb829a37a0802() 470 {JsSceneMode::JS_VIDEO, [] (napi_env env) {
471 return VideoSessionForSysNapi::CreateCameraSession(env); }},
__anonb829a37a0902() 472 {JsSceneMode::JS_PORTRAIT, [] (napi_env env) { return PortraitSessionNapi::CreateCameraSession(env); }},
__anonb829a37a0a02() 473 {JsSceneMode::JS_NIGHT, [] (napi_env env) { return NightSessionNapi::CreateCameraSession(env); }},
__anonb829a37a0b02() 474 {JsSceneMode::JS_SLOW_MOTION, [] (napi_env env) { return SlowMotionSessionNapi::CreateCameraSession(env); }},
__anonb829a37a0c02() 475 {JsSceneMode::JS_PROFESSIONAL_PHOTO, [] (napi_env env) {
476 return ProfessionSessionNapi::CreateCameraSession(env, SceneMode::PROFESSIONAL_PHOTO); }},
__anonb829a37a0d02() 477 {JsSceneMode::JS_PROFESSIONAL_VIDEO, [] (napi_env env) {
478 return ProfessionSessionNapi::CreateCameraSession(env, SceneMode::PROFESSIONAL_VIDEO); }},
__anonb829a37a0e02() 479 {JsSceneMode::JS_CAPTURE_MARCO, [] (napi_env env) {
480 return MacroPhotoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a0f02() 481 {JsSceneMode::JS_VIDEO_MARCO, [] (napi_env env) {
482 return MacroVideoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1002() 483 {JsSceneMode::JS_HIGH_RES_PHOTO, [] (napi_env env) {
484 return HighResPhotoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1102() 485 {JsSceneMode::JS_SECURE_CAMERA, [] (napi_env env) {
486 return SecureCameraSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1202() 487 {JsSceneMode::JS_QUICK_SHOT_PHOTO, [] (napi_env env) {
488 return QuickShotPhotoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1302() 489 {JsSceneMode::JS_APERTURE_VIDEO, [] (napi_env env) {
490 return ApertureVideoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1402() 491 {JsSceneMode::JS_PANORAMA_PHOTO, [] (napi_env env) {
492 return PanoramaSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1502() 493 {JsSceneMode::JS_LIGHT_PAINTING, [] (napi_env env) {
494 return LightPaintingSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1602() 495 {JsSceneMode::JS_TIMELAPSE_PHOTO, [] (napi_env env) {
496 return TimeLapsePhotoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1702() 497 {JsSceneMode::JS_FLUORESCENCE_PHOTO, [] (napi_env env) {
498 return FluorescencePhotoSessionNapi::CreateCameraSession(env); }},
499 };
500
501 std::unordered_map<int32_t, std::function<napi_value(napi_env)>> g_sessionFactories = {
__anonb829a37a1802() 502 {JsSceneMode::JS_CAPTURE, [] (napi_env env) {
503 return PhotoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1902() 504 {JsSceneMode::JS_VIDEO, [] (napi_env env) {
505 return VideoSessionNapi::CreateCameraSession(env); }},
__anonb829a37a1a02() 506 {JsSceneMode::JS_SECURE_CAMERA, [] (napi_env env) {
507 return SecureCameraSessionNapi::CreateCameraSession(env); }},
508 };
509
CameraManagerNapi()510 CameraManagerNapi::CameraManagerNapi() : env_(nullptr)
511 {
512 CAMERA_SYNC_TRACE;
513 }
514
~CameraManagerNapi()515 CameraManagerNapi::~CameraManagerNapi()
516 {
517 MEDIA_DEBUG_LOG("~CameraManagerNapi is called");
518 }
519
520 // Constructor callback
CameraManagerNapiConstructor(napi_env env,napi_callback_info info)521 napi_value CameraManagerNapi::CameraManagerNapiConstructor(napi_env env, napi_callback_info info)
522 {
523 MEDIA_DEBUG_LOG("CameraManagerNapiConstructor is called");
524 napi_status status;
525 napi_value result = nullptr;
526 napi_value thisVar = nullptr;
527
528 napi_get_undefined(env, &result);
529 CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
530
531 if (status == napi_ok && thisVar != nullptr) {
532 std::unique_ptr<CameraManagerNapi> obj = std::make_unique<CameraManagerNapi>();
533 obj->env_ = env;
534 obj->cameraManager_ = CameraManager::GetInstance();
535 CHECK_ERROR_RETURN_RET_LOG(obj->cameraManager_ == nullptr, result,
536 "Failure wrapping js to native napi, obj->cameraManager_ null");
537 status = napi_wrap(env, thisVar, reinterpret_cast<void*>(obj.get()),
538 CameraManagerNapi::CameraManagerNapiDestructor, nullptr, nullptr);
539 if (status == napi_ok) {
540 obj.release();
541 return thisVar;
542 } else {
543 MEDIA_ERR_LOG("Failure wrapping js to native napi");
544 }
545 }
546 MEDIA_ERR_LOG("CameraManagerNapiConstructor call Failed!");
547 return result;
548 }
549
CameraManagerNapiDestructor(napi_env env,void * nativeObject,void * finalize_hint)550 void CameraManagerNapi::CameraManagerNapiDestructor(napi_env env, void* nativeObject, void* finalize_hint)
551 {
552 MEDIA_DEBUG_LOG("CameraManagerNapiDestructor is called");
553 CameraManagerNapi* camera = reinterpret_cast<CameraManagerNapi*>(nativeObject);
554 if (camera != nullptr) {
555 delete camera;
556 }
557 }
558
Init(napi_env env,napi_value exports)559 napi_value CameraManagerNapi::Init(napi_env env, napi_value exports)
560 {
561 MEDIA_DEBUG_LOG("Init is called");
562 napi_status status;
563 napi_value ctorObj;
564 int32_t refCount = 1;
565
566 napi_property_descriptor camera_mgr_properties[] = {
567 // CameraManager
568 DECLARE_NAPI_FUNCTION("getSupportedCameras", GetSupportedCameras),
569 DECLARE_NAPI_FUNCTION("getSupportedSceneModes", GetSupportedModes),
570 DECLARE_NAPI_FUNCTION("getSupportedOutputCapability", GetSupportedOutputCapability),
571 DECLARE_NAPI_FUNCTION("isCameraMuted", IsCameraMuted),
572 DECLARE_NAPI_FUNCTION("isCameraMuteSupported", IsCameraMuteSupported),
573 DECLARE_NAPI_FUNCTION("muteCamera", MuteCamera),
574 DECLARE_NAPI_FUNCTION("muteCameraPersistent", MuteCameraPersist),
575 DECLARE_NAPI_FUNCTION("prelaunch", PrelaunchCamera),
576 DECLARE_NAPI_FUNCTION("preSwitchCamera", PreSwitchCamera),
577 DECLARE_NAPI_FUNCTION("isPrelaunchSupported", IsPrelaunchSupported),
578 DECLARE_NAPI_FUNCTION("setPrelaunchConfig", SetPrelaunchConfig),
579 DECLARE_NAPI_FUNCTION("createCameraInput", CreateCameraInputInstance),
580 DECLARE_NAPI_FUNCTION("createCaptureSession", CreateCameraSessionInstance),
581 DECLARE_NAPI_FUNCTION("createSession", CreateSessionInstance),
582 DECLARE_NAPI_FUNCTION("createPreviewOutput", CreatePreviewOutputInstance),
583 DECLARE_NAPI_FUNCTION("createDeferredPreviewOutput", CreateDeferredPreviewOutputInstance),
584 DECLARE_NAPI_FUNCTION("createPhotoOutput", CreatePhotoOutputInstance),
585 DECLARE_NAPI_FUNCTION("createVideoOutput", CreateVideoOutputInstance),
586 DECLARE_NAPI_FUNCTION("createMetadataOutput", CreateMetadataOutputInstance),
587 DECLARE_NAPI_FUNCTION("createDepthDataOutput", CreateDepthDataOutputInstance),
588 DECLARE_NAPI_FUNCTION("isTorchSupported", IsTorchSupported),
589 DECLARE_NAPI_FUNCTION("isTorchModeSupported", IsTorchModeSupported),
590 DECLARE_NAPI_FUNCTION("getTorchMode", GetTorchMode),
591 DECLARE_NAPI_FUNCTION("setTorchMode", SetTorchMode),
592 DECLARE_NAPI_FUNCTION("getCameraDevice", GetCameraDevice),
593 DECLARE_NAPI_FUNCTION("getCameraConcurrentInfos", GetCameraConcurrentInfos),
594 DECLARE_NAPI_FUNCTION("on", On),
595 DECLARE_NAPI_FUNCTION("once", Once),
596 DECLARE_NAPI_FUNCTION("off", Off)
597 };
598
599 status = napi_define_class(env, CAMERA_MANAGER_NAPI_CLASS_NAME, NAPI_AUTO_LENGTH,
600 CameraManagerNapiConstructor, nullptr,
601 sizeof(camera_mgr_properties) / sizeof(camera_mgr_properties[PARAM0]),
602 camera_mgr_properties, &ctorObj);
603 if (status == napi_ok) {
604 if (napi_create_reference(env, ctorObj, refCount, &sConstructor_) == napi_ok) {
605 status = napi_set_named_property(env, exports, CAMERA_MANAGER_NAPI_CLASS_NAME, ctorObj);
606 CHECK_ERROR_RETURN_RET(status == napi_ok, exports);
607 }
608 }
609 MEDIA_ERR_LOG("Init call Failed!");
610 return nullptr;
611 }
612
CreateCameraManager(napi_env env)613 napi_value CameraManagerNapi::CreateCameraManager(napi_env env)
614 {
615 MEDIA_INFO_LOG("CreateCameraManager is called");
616 napi_status status;
617 napi_value result = nullptr;
618 napi_value ctor;
619
620 status = napi_get_reference_value(env, sConstructor_, &ctor);
621 if (status == napi_ok) {
622 status = napi_new_instance(env, ctor, 0, nullptr, &result);
623 if (status == napi_ok) {
624 MEDIA_INFO_LOG("CreateCameraManager is ok");
625 return result;
626 } else {
627 MEDIA_ERR_LOG("New instance could not be obtained");
628 }
629 }
630 napi_get_undefined(env, &result);
631 MEDIA_ERR_LOG("CreateCameraManager call Failed!");
632 return result;
633 }
634
CreateCameraJSArray(napi_env env,std::vector<sptr<CameraDevice>> cameraObjList)635 static napi_value CreateCameraJSArray(napi_env env, std::vector<sptr<CameraDevice>> cameraObjList)
636 {
637 MEDIA_DEBUG_LOG("CreateCameraJSArray is called");
638 napi_value cameraArray = nullptr;
639
640 CHECK_ERROR_PRINT_LOG(cameraObjList.empty(), "cameraObjList is empty");
641
642 napi_status status = napi_create_array(env, &cameraArray);
643 if (status == napi_ok) {
644 for (size_t i = 0; i < cameraObjList.size(); i++) {
645 if (cameraObjList[i] == nullptr) {
646 continue;
647 }
648 napi_value camera = CameraNapiObjCameraDevice(*cameraObjList[i]).GenerateNapiValue(env);
649 CHECK_ERROR_RETURN_RET_LOG(camera == nullptr || napi_set_element(env, cameraArray, i, camera) != napi_ok,
650 nullptr, "Failed to create camera napi wrapper object");
651 }
652 }
653 return cameraArray;
654 }
655
CreateCameraSessionInstance(napi_env env,napi_callback_info info)656 napi_value CameraManagerNapi::CreateCameraSessionInstance(napi_env env, napi_callback_info info)
657 {
658 MEDIA_INFO_LOG("CreateCameraSessionInstance is called");
659 napi_status status;
660 napi_value result = nullptr;
661 size_t argc = ARGS_ZERO;
662 napi_value argv[ARGS_ZERO];
663 napi_value thisVar = nullptr;
664
665 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
666
667 napi_get_undefined(env, &result);
668
669 CameraManagerNapi* cameraManagerNapi = nullptr;
670 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&cameraManagerNapi));
671 CHECK_ERROR_RETURN_RET_LOG(status != napi_ok || cameraManagerNapi == nullptr, nullptr, "napi_unwrap failure!");
672 result = CameraSessionNapi::CreateCameraSession(env);
673 return result;
674 }
675
CreateSessionInstance(napi_env env,napi_callback_info info)676 napi_value CameraManagerNapi::CreateSessionInstance(napi_env env, napi_callback_info info)
677 {
678 MEDIA_INFO_LOG("CreateSessionInstance is called");
679 CameraManagerNapi* cameraManagerNapi = nullptr;
680 int32_t jsModeName = -1;
681 CameraNapiParamParser jsParamParser(env, info, cameraManagerNapi, jsModeName);
682 CHECK_ERROR_PRINT_LOG(!jsParamParser.AssertStatus(INVALID_ARGUMENT, "Create session invalid argument!"),
683 "CameraManagerNapi::CreateSessionInstance invalid argument: %{public}d", jsModeName);
684 MEDIA_INFO_LOG("CameraManagerNapi::CreateSessionInstance mode = %{public}d", jsModeName);
685 napi_value result = nullptr;
686 std::unordered_map<int32_t, std::function<napi_value(napi_env)>> sessionFactories = g_sessionFactories;
687 if (CameraNapiSecurity::CheckSystemApp(env, false)) {
688 sessionFactories = g_sessionFactories4Sys_;
689 }
690 if (sessionFactories.find(jsModeName) != sessionFactories.end()) {
691 result = sessionFactories[jsModeName](env);
692 } else {
693 MEDIA_ERR_LOG("CameraManagerNapi::CreateSessionInstance mode = %{public}d not supported", jsModeName);
694 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "Invalid js mode");
695 }
696 return result;
697 }
698
ParsePrelaunchConfig(napi_env env,napi_value root,PrelaunchConfig * prelaunchConfig)699 bool ParsePrelaunchConfig(napi_env env, napi_value root, PrelaunchConfig* prelaunchConfig)
700 {
701 napi_value res = nullptr;
702 int32_t intValue;
703 std::string cameraId {};
704 CameraNapiObject cameraInfoObj { { { "cameraId", &cameraId } } };
705 CameraNapiObject cameraDeviceObj { { { "cameraDevice", &cameraInfoObj } } };
706 CameraNapiParamParser paramParser { env, { root }, cameraDeviceObj };
707 CHECK_ERROR_RETURN_RET_LOG(!paramParser.AssertStatus(INVALID_ARGUMENT, "camera info is invalid."),
708 false, "ParsePrelaunchConfig get camera device failure!");
709 prelaunchConfig->cameraDevice_ = CameraManager::GetInstance()->GetCameraDeviceFromId(cameraId);
710 CHECK_ERROR_PRINT_LOG(prelaunchConfig->cameraDevice_ == nullptr,
711 "ParsePrelaunchConfig get camera device failure! cameraId:%{public}s", cameraId.c_str());
712 if (napi_get_named_property(env, root, "restoreParamType", &res) == napi_ok) {
713 napi_get_value_int32(env, res, &intValue);
714 prelaunchConfig->restoreParamType = static_cast<RestoreParamType>(intValue);
715 MEDIA_INFO_LOG("SetPrelaunchConfig restoreParamType = %{public}d", intValue);
716 }
717
718 if (napi_get_named_property(env, root, "activeTime", &res) == napi_ok) {
719 napi_get_value_int32(env, res, &intValue);
720 prelaunchConfig->activeTime = intValue;
721 MEDIA_INFO_LOG("SetPrelaunchConfig activeTime = %{public}d", intValue);
722 }
723 return true;
724 }
725
ParseSettingParam(napi_env env,napi_value root,EffectParam * effectParam)726 bool ParseSettingParam(napi_env env, napi_value root, EffectParam* effectParam)
727 {
728 napi_value res = nullptr;
729 if (napi_get_named_property(env, root, "settingParam", &res) == napi_ok) {
730 napi_value tempValue = nullptr;
731 int32_t effectValue;
732 if (napi_get_named_property(env, res, "skinSmoothLevel", &tempValue) == napi_ok) {
733 napi_get_value_int32(env, tempValue, &effectValue);
734 effectParam->skinSmoothLevel = effectValue;
735 }
736 if (napi_get_named_property(env, res, "faceSlender", &tempValue) == napi_ok) {
737 napi_get_value_int32(env, tempValue, &effectValue);
738 effectParam->faceSlender = effectValue;
739 }
740
741 if (napi_get_named_property(env, res, "skinTone", &tempValue) == napi_ok) {
742 napi_get_value_int32(env, tempValue, &effectValue);
743 effectParam->skinTone = effectValue;
744 }
745 MEDIA_INFO_LOG("SetPrelaunchConfig effectParam = %{public}d", effectParam->skinSmoothLevel);
746 }
747 return true;
748 }
749
CreatePreviewOutputInstance(napi_env env,napi_callback_info info)750 napi_value CameraManagerNapi::CreatePreviewOutputInstance(napi_env env, napi_callback_info info)
751 {
752 MEDIA_INFO_LOG("CreatePreviewOutputInstance is called");
753 std::string surfaceId;
754 CameraManagerNapi* cameraManagerNapi = nullptr;
755 size_t napiArgsSize = CameraNapiUtils::GetNapiArgs(env, info);
756 MEDIA_INFO_LOG("CameraManagerNapi::CreatePreviewOutputInstance napi args size is %{public}zu", napiArgsSize);
757
758 // Check two parameters
759 if (napiArgsSize == 2) { // 2 parameters condition
760 Profile profile;
761 CameraNapiObject profileSizeObj {{
762 { "width", &profile.size_.width },
763 { "height", &profile.size_.height }
764 }};
765 CameraNapiObject profileNapiOjbect {{
766 { "size", &profileSizeObj },
767 { "format", reinterpret_cast<int32_t*>(&profile.format_) }
768 }};
769 CameraNapiParamParser jsParamParser(env, info, cameraManagerNapi, profileNapiOjbect, surfaceId);
770 CHECK_ERROR_RETURN_RET(!jsParamParser.AssertStatus(INVALID_ARGUMENT,
771 "CameraManagerNapi::CreatePreviewOutputInstance 2 args parse error"), nullptr);
772 MEDIA_INFO_LOG("CameraManagerNapi::CreatePreviewOutputInstance ParseProfile "
773 "size.width = %{public}d, size.height = %{public}d, format = %{public}d, surfaceId = %{public}s",
774 profile.size_.width, profile.size_.height, profile.format_, surfaceId.c_str());
775 return PreviewOutputNapi::CreatePreviewOutput(env, profile, surfaceId);
776 }
777
778 // Check one parameters
779 CameraNapiParamParser jsParamParser = CameraNapiParamParser(env, info, cameraManagerNapi, surfaceId);
780 CHECK_ERROR_RETURN_RET(!jsParamParser.AssertStatus(INVALID_ARGUMENT,
781 "CameraManagerNapi::CreatePreviewOutputInstance 1 args parse error"), nullptr);
782 MEDIA_INFO_LOG("CameraManagerNapi::CreatePreviewOutputInstance surfaceId : %{public}s", surfaceId.c_str());
783 return PreviewOutputNapi::CreatePreviewOutput(env, surfaceId);
784 }
785
CreateDeferredPreviewOutputInstance(napi_env env,napi_callback_info info)786 napi_value CameraManagerNapi::CreateDeferredPreviewOutputInstance(napi_env env, napi_callback_info info)
787 {
788 MEDIA_INFO_LOG("CreateDeferredPreviewOutputInstance is called");
789 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env), nullptr,
790 "SystemApi CreateDeferredPreviewOutputInstance is called!");
791
792 CameraManagerNapi* cameraManagerNapi = nullptr;
793 Profile profile;
794 CameraNapiObject profileSizeObj {{
795 { "width", &profile.size_.width },
796 { "height", &profile.size_.height }
797 }};
798 CameraNapiObject profileNapiOjbect {{
799 { "size", &profileSizeObj },
800 { "format", reinterpret_cast<int32_t*>(&profile.format_) }
801 }};
802
803 CameraNapiParamParser jsParamParser(env, info, cameraManagerNapi, profileNapiOjbect);
804 CHECK_ERROR_RETURN_RET(!jsParamParser.AssertStatus(INVALID_ARGUMENT,
805 "CameraManagerNapi::CreateDeferredPreviewOutput args parse error"), nullptr);
806 MEDIA_INFO_LOG("CameraManagerNapi::CreateDeferredPreviewOutput ParseProfile "
807 "size.width = %{public}d, size.height = %{public}d, format = %{public}d",
808 profile.size_.width, profile.size_.height, profile.format_);
809 return PreviewOutputNapi::CreateDeferredPreviewOutput(env, profile);
810 }
811
CreatePhotoOutputInstance(napi_env env,napi_callback_info info)812 napi_value CameraManagerNapi::CreatePhotoOutputInstance(napi_env env, napi_callback_info info)
813 {
814 MEDIA_INFO_LOG("CreatePhotoOutputInstance is called");
815 std::string surfaceId;
816 CameraManagerNapi* cameraManagerNapi = nullptr;
817 size_t napiArgsSize = CameraNapiUtils::GetNapiArgs(env, info);
818 MEDIA_INFO_LOG("CameraManagerNapi::CreatePhotoOutputInstance napi args size is %{public}zu", napiArgsSize);
819
820 Profile profile;
821 CameraNapiObject profileSizeObj {{
822 { "width", &profile.size_.width },
823 { "height", &profile.size_.height }
824 }};
825 CameraNapiObject profileNapiOjbect {{
826 { "size", &profileSizeObj },
827 { "format", reinterpret_cast<int32_t*>(&profile.format_) }
828 }};
829
830 if (napiArgsSize == 2) { // 2 parameters condition
831 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi,
832 profileNapiOjbect, surfaceId).AssertStatus(INVALID_ARGUMENT,
833 "CameraManagerNapi::CreatePhotoOutputInstance 2 args parse error"), nullptr);
834 MEDIA_INFO_LOG("CameraManagerNapi::CreatePhotoOutputInstance ParseProfile "
835 "size.width = %{public}d, size.height = %{public}d, format = %{public}d, surfaceId = %{public}s",
836 profile.size_.width, profile.size_.height, profile.format_, surfaceId.c_str());
837 return PhotoOutputNapi::CreatePhotoOutput(env, profile, surfaceId);
838 } else if (napiArgsSize == 1) { // 1 parameters condition
839 // Check one parameter only profile
840 if (CameraNapiParamParser(env, info, cameraManagerNapi, profileNapiOjbect).IsStatusOk()) {
841 MEDIA_INFO_LOG(
842 "CameraManagerNapi::CreatePhotoOutputInstance ParseProfile "
843 "size.width = %{public}d, size.height = %{public}d, format = %{public}d, surfaceId = %{public}s",
844 profile.size_.width, profile.size_.height, profile.format_, surfaceId.c_str());
845 return PhotoOutputNapi::CreatePhotoOutput(env, profile, "");
846 }
847
848 // Check one parameter only surfaceId
849 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi, surfaceId).AssertStatus(
850 INVALID_ARGUMENT, "CameraManagerNapi::CreatePhotoOutputInstance 1 args parse error"), nullptr);
851 MEDIA_INFO_LOG("CameraManagerNapi::CreatePhotoOutputInstance surfaceId : %{public}s", surfaceId.c_str());
852 return PhotoOutputNapi::CreatePhotoOutput(env, surfaceId);
853 }
854
855 MEDIA_WARNING_LOG("CameraManagerNapi::CreatePhotoOutputInstance with none parameter");
856 // Check none parameter
857 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi).AssertStatus(INVALID_ARGUMENT,
858 "CameraManagerNapi::CreatePhotoOutputInstance args parse error"), nullptr);
859 return PhotoOutputNapi::CreatePhotoOutput(env, "");
860 }
861
CreateVideoOutputInstance(napi_env env,napi_callback_info info)862 napi_value CameraManagerNapi::CreateVideoOutputInstance(napi_env env, napi_callback_info info)
863 {
864 MEDIA_INFO_LOG("CreateVideoOutputInstance is called");
865 std::string surfaceId;
866 CameraManagerNapi* cameraManagerNapi = nullptr;
867 size_t napiArgsSize = CameraNapiUtils::GetNapiArgs(env, info);
868 MEDIA_INFO_LOG("CameraManagerNapi::CreateVideoOutputInstance napi args size is %{public}zu", napiArgsSize);
869
870 if (napiArgsSize == 2) { // 2 parameters condition
871 VideoProfile videoProfile;
872 videoProfile.framerates_.resize(2); // framerate size is 2
873 CameraNapiObject profileSizeObj {{
874 { "width", &videoProfile.size_.width },
875 { "height", &videoProfile.size_.height }
876 }};
877 CameraNapiObject profileFrameRateObj {{
878 { "min", &videoProfile.framerates_[0] },
879 { "max", &videoProfile.framerates_[1] }
880 }};
881 CameraNapiObject profileNapiOjbect {{
882 { "size", &profileSizeObj },
883 { "frameRateRange", &profileFrameRateObj },
884 { "format", reinterpret_cast<int32_t*>(&videoProfile.format_) }
885 }};
886
887 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi, profileNapiOjbect, surfaceId)
888 .AssertStatus(INVALID_ARGUMENT, "CameraManagerNapi::CreateVideoOutputInstance 2 args parse error"),
889 nullptr);
890 MEDIA_INFO_LOG(
891 "CameraManagerNapi::CreateVideoOutputInstance ParseVideoProfile "
892 "size.width = %{public}d, size.height = %{public}d, format = %{public}d, frameRateMin = %{public}d, "
893 "frameRateMax = %{public}d, surfaceId = %{public}s",
894 videoProfile.size_.width, videoProfile.size_.height, videoProfile.format_, videoProfile.framerates_[0],
895 videoProfile.framerates_[1], surfaceId.c_str());
896 return VideoOutputNapi::CreateVideoOutput(env, videoProfile, surfaceId);
897 }
898
899 MEDIA_WARNING_LOG("CameraManagerNapi::CreateVideoOutputInstance with only surfaceId");
900 // Check one parameters only surfaceId
901 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi, surfaceId).AssertStatus(
902 INVALID_ARGUMENT, "CameraManagerNapi::CreateVideoOutputInstance args parse error"), nullptr);
903 MEDIA_INFO_LOG("CameraManagerNapi::CreateVideoOutputInstance surfaceId : %{public}s", surfaceId.c_str());
904 return VideoOutputNapi::CreateVideoOutput(env, surfaceId);
905 }
906
CreateDepthDataOutputInstance(napi_env env,napi_callback_info info)907 napi_value CameraManagerNapi::CreateDepthDataOutputInstance(napi_env env, napi_callback_info info)
908 {
909 MEDIA_INFO_LOG("CreateDepthDataOutputInstance is called");
910 CameraManagerNapi* cameraManagerNapi = nullptr;
911 size_t napiArgsSize = CameraNapiUtils::GetNapiArgs(env, info);
912 MEDIA_INFO_LOG("CameraManagerNapi::CreateDepthDataOutputInstance napi args size is %{public}zu", napiArgsSize);
913
914 DepthProfile depthProfile;
915 CameraNapiObject profileSizeObj {{
916 { "width", &depthProfile.size_.width },
917 { "height", &depthProfile.size_.height }
918 }};
919 CameraNapiObject profileNapiOjbect {{
920 { "size", &profileSizeObj },
921 { "dataAccuracy", reinterpret_cast<int32_t*>(&depthProfile.dataAccuracy_) },
922 { "format", reinterpret_cast<int32_t*>(&depthProfile.format_) }
923 }};
924
925 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi, profileNapiOjbect).AssertStatus(
926 INVALID_ARGUMENT, "CameraManagerNapi::CreateDepthDataOutputInstance 1 args parse error"), nullptr);
927 MEDIA_INFO_LOG(
928 "CameraManagerNapi::CreateDepthDataOutputInstance ParseDepthProfile "
929 "size.width = %{public}d, size.height = %{public}d, format = %{public}d, dataAccuracy = %{public}d,",
930 depthProfile.size_.width, depthProfile.size_.height, depthProfile.format_, depthProfile.dataAccuracy_);
931 return DepthDataOutputNapi::CreateDepthDataOutput(env, depthProfile);
932 }
933
CreateMetadataOutputInstance(napi_env env,napi_callback_info info)934 napi_value CameraManagerNapi::CreateMetadataOutputInstance(napi_env env, napi_callback_info info)
935 {
936 MEDIA_INFO_LOG("CreateMetadataOutputInstance is called");
937 napi_status status;
938 napi_value result = nullptr;
939 size_t argc = ARGS_ONE;
940 napi_value argv[ARGS_ONE] = {0};
941 napi_value thisVar = nullptr;
942
943 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
944 CHECK_ERROR_RETURN_RET(!CameraNapiUtils::CheckInvalidArgument(env, argc, ARGS_ONE,
945 argv, CREATE_METADATA_OUTPUT_INSTANCE), result);
946
947 napi_get_undefined(env, &result);
948 CameraManagerNapi* cameraManagerNapi = nullptr;
949 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&cameraManagerNapi));
950 CHECK_ERROR_RETURN_RET_LOG(status != napi_ok || cameraManagerNapi == nullptr, nullptr, "napi_unwrap failure!");
951 std::vector<MetadataObjectType> metadataObjectTypes;
952 CameraNapiUtils::ParseMetadataObjectTypes(env, argv[PARAM0], metadataObjectTypes);
953 result = MetadataOutputNapi::CreateMetadataOutput(env, metadataObjectTypes);
954 return result;
955 }
956
GetSupportedCameras(napi_env env,napi_callback_info info)957 napi_value CameraManagerNapi::GetSupportedCameras(napi_env env, napi_callback_info info)
958 {
959 MEDIA_INFO_LOG("GetSupportedCameras is called");
960 CameraManagerNapi* cameraManagerNapi;
961 CameraNapiParamParser paramParser(env, info, cameraManagerNapi);
962 CHECK_ERROR_RETURN_RET_LOG(!paramParser.AssertStatus(INVALID_ARGUMENT, "invalid argument."), nullptr,
963 "CameraManagerNapi::GetSupportedCameras invalid argument");
964 std::vector<sptr<CameraDevice>> cameraObjList = cameraManagerNapi->cameraManager_->GetSupportedCameras();
965 napi_value result = GetCachedSupportedCameras(env, cameraObjList);
966 if (result == nullptr) {
967 result = CreateCameraJSArray(env, cameraObjList);
968 CacheSupportedCameras(env, cameraObjList, result);
969 }
970 MEDIA_DEBUG_LOG("CameraManagerNapi::GetSupportedCameras size=[%{public}zu]", cameraObjList.size());
971 return result;
972 }
973
GetCameraDevice(napi_env env,napi_callback_info info)974 napi_value CameraManagerNapi::GetCameraDevice(napi_env env, napi_callback_info info)
975 {
976 MEDIA_INFO_LOG("GetCameraDevice is called");
977 CameraManagerNapi* cameraManagerNapi;
978 int32_t cameraPosition;
979 int32_t cameraType;
980 sptr<CameraDevice> cameraInfo = nullptr;
981 CameraNapiParamParser jsParamParser(env, info, cameraManagerNapi, cameraPosition, cameraType);
982 if (!jsParamParser.AssertStatus(PARAMETER_ERROR, "GetCameraDevice with 2 invalid arguments!")) {
983 MEDIA_ERR_LOG("CameraManagerNapi::GetCameraDevice 2 invalid arguments");
984 return nullptr;
985 }
986 ProcessCameraInfo(cameraManagerNapi->cameraManager_, static_cast<const CameraPosition>(cameraPosition),
987 static_cast<const CameraType>(cameraType), cameraInfo);
988 if (cameraInfo == nullptr) {
989 MEDIA_ERR_LOG("cameraInfo is null");
990 CameraNapiUtils::ThrowError(env, SERVICE_FATL_ERROR, "cameraInfo is null.");
991 return nullptr;
992 }
993 napi_value result = nullptr;
994 result = CameraNapiObjCameraDevice(*cameraInfo).GenerateNapiValue(env);
995 return result;
996 }
997
GetCameraConcurrentInfos(napi_env env,napi_callback_info info)998 napi_value CameraManagerNapi::GetCameraConcurrentInfos(napi_env env, napi_callback_info info)
999 {
1000 MEDIA_INFO_LOG("GetCameraConcurrentInfos is called");
1001 CameraManagerNapi* cameraManagerNapi;
1002 std::vector<bool> cameraConcurrentType = {};
1003 std::vector<std::vector<SceneMode>> modes = {};
1004 std::vector<std::vector<sptr<CameraOutputCapability>>> outputCapabilities = {};
1005 size_t argc = ARGS_ONE;
1006 napi_value argv[ARGS_ONE] = {0};
1007 napi_value thisVar = nullptr;
1008 napi_status status;
1009
1010 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1011 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&cameraManagerNapi));
1012 if (status != napi_ok) {
1013 CameraNapiUtils::ThrowError(env, PARAMETER_ERROR,
1014 "CameraManagerNapi::GetCameraConcurrentInfos can not get thisVar");
1015 return nullptr;
1016 }
1017 if (argc != ARGS_ONE) {
1018 CameraNapiUtils::ThrowError(env, PARAMETER_ERROR,
1019 "CameraManagerNapi::GetCameraConcurrentInfos argc is not ARGS_ONE");
1020 return nullptr;
1021 }
1022 napi_valuetype argvType;
1023 napi_typeof(env, argv[PARAM0], &argvType);
1024 if (argvType != napi_object) {
1025 CameraNapiUtils::ThrowError(env, PARAMETER_ERROR,
1026 "CameraManagerNapi::GetCameraConcurrentInfos type of array is error");
1027 return nullptr;
1028 }
1029
1030 std::vector<string>cameraIdv = {};
1031 cameraManagerNapi->ParseGetCameraConcurrentInfos(env, argv[PARAM0], cameraIdv);
1032 vector<sptr<CameraDevice>> cameraDeviceArrray = {};
1033 for (auto cameraidonly : cameraIdv) {
1034 cameraDeviceArrray.push_back(cameraManagerNapi->cameraManager_->GetCameraDeviceFromId(cameraidonly));
1035 }
1036
1037 bool issupported = cameraManagerNapi->cameraManager_->GetConcurrentType(cameraDeviceArrray, cameraConcurrentType);
1038 vector<sptr<CameraDevice>> cameraReturnNull = {};
1039 if (issupported == false) {
1040 MEDIA_ERR_LOG("CameraManagerNapi::Camera is not support ConcurrentType");
1041 return CreateCameraConcurrentResult(env, cameraReturnNull, cameraConcurrentType, modes, outputCapabilities);
1042 }
1043 issupported = cameraManagerNapi->cameraManager_->CheckConcurrentExecution(cameraDeviceArrray);
1044 if (issupported == false) {
1045 MEDIA_ERR_LOG("CameraManagerNapi::Camera is not support ConcurrentType");
1046 return CreateCameraConcurrentResult(env, cameraReturnNull, cameraConcurrentType, modes, outputCapabilities);
1047 }
1048
1049 cameraManagerNapi->cameraManager_->GetCameraConcurrentInfos(cameraDeviceArrray,
1050 cameraConcurrentType, modes, outputCapabilities);
1051 return CreateCameraConcurrentResult(env, cameraDeviceArrray, cameraConcurrentType, modes, outputCapabilities);
1052 }
1053
ParseGetCameraConcurrentInfos(napi_env env,napi_value arrayParam,std::vector<std::string> & cameraIdv)1054 void CameraManagerNapi::ParseGetCameraConcurrentInfos(napi_env env, napi_value arrayParam,
1055 std::vector<std::string> &cameraIdv)
1056 {
1057 MEDIA_DEBUG_LOG("ParseGetCameraConcurrentInfos is called");
1058 uint32_t length = 0;
1059 napi_value value;
1060 napi_get_array_length(env, arrayParam, &length);
1061 for (uint32_t i = 0; i < length; i++) {
1062 napi_get_element(env, arrayParam, i, &value);
1063 napi_value res = nullptr;
1064 if (napi_get_named_property(env, value, "cameraId", &res) == napi_ok) {
1065 size_t sizeofres;
1066 char buffer[PATH_MAX];
1067 napi_get_value_string_utf8(env, res, buffer, PATH_MAX, &sizeofres);
1068 std::string cameraidonly = std::string(buffer);
1069 cameraIdv.push_back(cameraidonly);
1070 }
1071 }
1072 }
1073
CreateCameraConcurrentResult(napi_env env,vector<sptr<CameraDevice>> & cameraDeviceArrray,std::vector<bool> & cameraConcurrentType,std::vector<std::vector<SceneMode>> & modes,std::vector<std::vector<sptr<CameraOutputCapability>>> & outputCapabilities)1074 napi_value CameraManagerNapi::CreateCameraConcurrentResult(napi_env env, vector<sptr<CameraDevice>> &cameraDeviceArrray,
1075 std::vector<bool> &cameraConcurrentType, std::vector<std::vector<SceneMode>> &modes,
1076 std::vector<std::vector<sptr<CameraOutputCapability>>> &outputCapabilities)
1077 {
1078 napi_value resjsArray = nullptr;
1079 napi_status resjsArraystatus = napi_create_array(env, &resjsArray);
1080 if (resjsArraystatus != napi_ok) {
1081 MEDIA_ERR_LOG("resjsArray create is fail");
1082 return nullptr;
1083 }
1084 for (size_t i = 0; i < cameraDeviceArrray.size(); i++) {
1085 napi_value obj = nullptr;
1086 napi_create_object(env, &obj);
1087 napi_value cameranow = CameraNapiObjCameraDevice(*cameraDeviceArrray[i]).GenerateNapiValue(env);
1088 napi_set_named_property(env, obj, "device", cameranow);
1089 napi_value cameraconcurrent = nullptr;
1090 napi_get_boolean(env, cameraConcurrentType[i], &cameraconcurrent);
1091 napi_set_named_property(env, obj, "type", cameraconcurrent);
1092 napi_value scenemodearray = nullptr;
1093 napi_status scenemodearraystatus = napi_create_array(env, &scenemodearray);
1094 if (scenemodearraystatus != napi_ok) {
1095 MEDIA_ERR_LOG("scenemodearray create is fail");
1096 continue;
1097 }
1098 int32_t index = 0;
1099 for (auto modenow : modes[i]) {
1100 auto itr = g_nativeToNapiSupportedMode_.find(modenow);
1101 if (itr != g_nativeToNapiSupportedMode_.end()) {
1102 napi_value modeitem = nullptr;
1103 napi_create_int32(env, itr->second, &modeitem);
1104 napi_set_element(env, scenemodearray, index, modeitem);
1105 index++;
1106 }
1107 }
1108 napi_set_named_property(env, obj, "modes", scenemodearray);
1109 napi_value outputcapabilitiyarray = nullptr;
1110 napi_status status = napi_create_array(env, &outputcapabilitiyarray);
1111 if (status != napi_ok) {
1112 MEDIA_ERR_LOG("outputcapabilitiyarray create is fail");
1113 continue;
1114 }
1115 index = 0;
1116 for (auto outputCapability : outputCapabilities[i]) {
1117 napi_value outputcapability = CameraNapiObjCameraOutputCapability(*outputCapability).GenerateNapiValue(env);
1118 napi_set_element(env, outputcapabilitiyarray, index, outputcapability);
1119 index++;
1120 }
1121 napi_set_named_property(env, obj, "outputCapabilities", outputcapabilitiyarray);
1122 napi_set_element(env, resjsArray, i, obj);
1123 }
1124 return resjsArray;
1125 }
1126
CreateSceneModeJSArray(napi_env env,std::vector<SceneMode> nativeArray)1127 static napi_value CreateSceneModeJSArray(napi_env env, std::vector<SceneMode> nativeArray)
1128 {
1129 MEDIA_DEBUG_LOG("CreateSceneModeJSArray is called");
1130 napi_value jsArray = nullptr;
1131 napi_value item = nullptr;
1132
1133 CHECK_ERROR_PRINT_LOG(nativeArray.empty(), "nativeArray is empty");
1134
1135 napi_status status = napi_create_array(env, &jsArray);
1136 std::unordered_map<SceneMode, JsSceneMode> nativeToNapiMap = g_nativeToNapiSupportedMode_;
1137 if (CameraNapiSecurity::CheckSystemApp(env, false)) {
1138 nativeToNapiMap = g_nativeToNapiSupportedModeForSystem_;
1139 }
1140 if (status == napi_ok) {
1141 uint8_t index = 0;
1142 for (size_t i = 0; i < nativeArray.size(); i++) {
1143 auto itr = nativeToNapiMap.find(nativeArray[i]);
1144 if (itr != nativeToNapiMap.end()) {
1145 napi_create_int32(env, itr->second, &item);
1146 napi_set_element(env, jsArray, index, item);
1147 index++;
1148 }
1149 }
1150 }
1151 return jsArray;
1152 }
1153
GetSupportedModes(napi_env env,napi_callback_info info)1154 napi_value CameraManagerNapi::GetSupportedModes(napi_env env, napi_callback_info info)
1155 {
1156 MEDIA_INFO_LOG("GetSupportedModes is called");
1157 CameraManagerNapi* cameraManagerNapi = nullptr;
1158 std::string cameraId {};
1159 CameraNapiObject cameraInfoObj { { { "cameraId", &cameraId } } };
1160 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi, cameraInfoObj).AssertStatus(
1161 INVALID_ARGUMENT, "GetSupportedModes args parse error"), nullptr);
1162 sptr<CameraDevice> cameraInfo = cameraManagerNapi->cameraManager_->GetCameraDeviceFromId(cameraId);
1163 if (cameraInfo == nullptr) {
1164 MEDIA_ERR_LOG("CameraManagerNapi::GetSupportedModes get camera info fail");
1165 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "Get camera info fail");
1166 return nullptr;
1167 }
1168
1169 std::vector<SceneMode> modeObjList = cameraManagerNapi->cameraManager_->GetSupportedModes(cameraInfo);
1170 for (auto it = modeObjList.begin(); it != modeObjList.end(); it++) {
1171 if (*it == SCAN) {
1172 modeObjList.erase(it);
1173 break;
1174 }
1175 }
1176 if (modeObjList.empty()) {
1177 modeObjList.emplace_back(CAPTURE);
1178 modeObjList.emplace_back(VIDEO);
1179 }
1180 MEDIA_INFO_LOG("CameraManagerNapi::GetSupportedModes size=[%{public}zu]", modeObjList.size());
1181 return CreateSceneModeJSArray(env, modeObjList);
1182 }
1183
GetSupportedOutputCapabilityAdaptNormalMode(SceneMode fwkMode,sptr<CameraDevice> & cameraInfo,sptr<CameraOutputCapability> & outputCapability)1184 void CameraManagerNapi::GetSupportedOutputCapabilityAdaptNormalMode(
1185 SceneMode fwkMode, sptr<CameraDevice>& cameraInfo, sptr<CameraOutputCapability>& outputCapability)
1186 {
1187 if (fwkMode == SceneMode::NORMAL && cameraInfo->GetPosition() == CAMERA_POSITION_FRONT) {
1188 auto defaultVideoProfiles = cameraInfo->modeVideoProfiles_[SceneMode::NORMAL];
1189 if (!defaultVideoProfiles.empty()) {
1190 MEDIA_INFO_LOG("return align videoProfile size = %{public}zu", defaultVideoProfiles.size());
1191 outputCapability->SetVideoProfiles(defaultVideoProfiles);
1192 }
1193 }
1194 }
1195
GetSupportedOutputCapabilityGetCameraInfo(napi_env env,napi_callback_info info,CameraManagerNapi * & cameraManagerNapi,int32_t & jsSceneMode)1196 sptr<CameraDevice> CameraManagerNapi::GetSupportedOutputCapabilityGetCameraInfo(
1197 napi_env env, napi_callback_info info, CameraManagerNapi*& cameraManagerNapi, int32_t& jsSceneMode)
1198 {
1199 std::string cameraId {};
1200 CameraNapiObject cameraInfoObj { { { "cameraId", &cameraId } } };
1201 size_t napiArgsSize = CameraNapiUtils::GetNapiArgs(env, info);
1202 MEDIA_INFO_LOG("CameraManagerNapi::GetSupportedOutputCapability napi args size is %{public}zu", napiArgsSize);
1203 if (napiArgsSize == ARGS_ONE) {
1204 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi, cameraInfoObj)
1205 .AssertStatus(INVALID_ARGUMENT, "GetSupportedOutputCapability 1 args parse error"), nullptr);
1206 } else if (napiArgsSize == ARGS_TWO) {
1207 CHECK_ERROR_RETURN_RET(!CameraNapiParamParser(env, info, cameraManagerNapi, cameraInfoObj, jsSceneMode)
1208 .AssertStatus(INVALID_ARGUMENT, "GetSupportedOutputCapability 2 args parse error"), nullptr);
1209 if (jsSceneMode == JsSceneMode::JS_NORMAL) {
1210 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "invalid js mode");
1211 return nullptr;
1212 }
1213 } else {
1214 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "Args size error");
1215 return nullptr;
1216 }
1217 return cameraManagerNapi->cameraManager_->GetCameraDeviceFromId(cameraId);
1218 }
1219
GetSupportedOutputCapability(napi_env env,napi_callback_info info)1220 napi_value CameraManagerNapi::GetSupportedOutputCapability(napi_env env, napi_callback_info info)
1221 {
1222 MEDIA_INFO_LOG("GetSupportedOutputCapability is called");
1223 CameraManagerNapi* cameraManagerNapi = nullptr;
1224 int32_t jsSceneMode = JsSceneMode::JS_NORMAL;
1225 sptr<CameraDevice> cameraInfo =
1226 GetSupportedOutputCapabilityGetCameraInfo(env, info, cameraManagerNapi, jsSceneMode);
1227
1228 if (cameraInfo == nullptr) {
1229 MEDIA_ERR_LOG("CameraManagerNapi::GetSupportedOutputCapability get camera info fail");
1230 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "Get camera info fail");
1231 return nullptr;
1232 }
1233 std::string cameraId = cameraInfo->GetID();
1234 napi_value cachedResult = GetCachedSupportedOutputCapability(env, cameraId, jsSceneMode);
1235 CHECK_ERROR_RETURN_RET(cachedResult != nullptr, cachedResult);
1236 SceneMode fwkMode = SceneMode::NORMAL;
1237 std::unordered_map<JsSceneMode, SceneMode> jsToFwModeMap = g_jsToFwMode_;
1238 if (CameraNapiSecurity::CheckSystemApp(env, false)) {
1239 jsToFwModeMap = g_jsToFwMode4Sys_;
1240 }
1241 auto itr = jsToFwModeMap.find(static_cast<JsSceneMode>(jsSceneMode));
1242 if (itr != jsToFwModeMap.end()) {
1243 fwkMode = itr->second;
1244 } else {
1245 MEDIA_ERR_LOG("CreateCameraSessionInstance mode = %{public}d not supported", jsSceneMode);
1246 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "Not support the input mode");
1247 return nullptr;
1248 }
1249 auto outputCapability = cameraManagerNapi->cameraManager_->GetSupportedOutputCapability(cameraInfo, fwkMode);
1250 CHECK_ERROR_RETURN_RET_LOG(outputCapability == nullptr, nullptr, "failed to create CreateCameraOutputCapability");
1251 outputCapability->RemoveDuplicatesProfiles();
1252 GetSupportedOutputCapabilityAdaptNormalMode(fwkMode, cameraInfo, outputCapability);
1253 napi_value result = CameraNapiObjCameraOutputCapability(*outputCapability).GenerateNapiValue(env);
1254 CHECK_EXECUTE(cameraInfo->GetConnectionType() == CAMERA_CONNECTION_BUILT_IN,
1255 CacheSupportedOutputCapability(env, cameraId, jsSceneMode, result));
1256 return result;
1257 }
1258
IsCameraMuted(napi_env env,napi_callback_info info)1259 napi_value CameraManagerNapi::IsCameraMuted(napi_env env, napi_callback_info info)
1260 {
1261 MEDIA_INFO_LOG("IsCameraMuted is called");
1262 napi_value result = nullptr;
1263 size_t argc = ARGS_ONE;
1264 napi_value argv[ARGS_ONE] = {0};
1265 napi_value thisVar = nullptr;
1266
1267 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1268 NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
1269 bool isMuted = CameraManager::GetInstance()->IsCameraMuted();
1270 MEDIA_DEBUG_LOG("IsCameraMuted : %{public}d", isMuted);
1271 napi_get_boolean(env, isMuted, &result);
1272 return result;
1273 }
1274
IsCameraMuteSupported(napi_env env,napi_callback_info info)1275 napi_value CameraManagerNapi::IsCameraMuteSupported(napi_env env, napi_callback_info info)
1276 {
1277 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env), nullptr,
1278 "SystemApi IsCameraMuteSupported is called!");
1279 MEDIA_INFO_LOG("IsCameraMuteSupported is called");
1280 napi_value result = nullptr;
1281 size_t argc = ARGS_ONE;
1282 napi_value argv[ARGS_ONE] = {0};
1283 napi_value thisVar = nullptr;
1284
1285 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1286 NAPI_ASSERT(env, argc <= ARGS_ONE, "requires 1 parameters maximum");
1287
1288 bool isMuteSupported = CameraManager::GetInstance()->IsCameraMuteSupported();
1289 MEDIA_DEBUG_LOG("isMuteSupported: %{public}d", isMuteSupported);
1290 napi_get_boolean(env, isMuteSupported, &result);
1291 return result;
1292 }
1293
MuteCamera(napi_env env,napi_callback_info info)1294 napi_value CameraManagerNapi::MuteCamera(napi_env env, napi_callback_info info)
1295 {
1296 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env), nullptr, "SystemApi MuteCamera is called!");
1297 MEDIA_INFO_LOG("MuteCamera is called");
1298 napi_value result = nullptr;
1299 size_t argc = ARGS_TWO;
1300 napi_value argv[ARGS_TWO] = {0};
1301 napi_value thisVar = nullptr;
1302
1303 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1304 NAPI_ASSERT(env, argc <= ARGS_TWO, "requires 1 parameters maximum");
1305 bool isSupported;
1306 napi_get_value_bool(env, argv[PARAM0], &isSupported);
1307 CameraManager::GetInstance()->MuteCamera(isSupported);
1308 napi_get_undefined(env, &result);
1309 return result;
1310 }
1311
MuteCameraPersist(napi_env env,napi_callback_info info)1312 napi_value CameraManagerNapi::MuteCameraPersist(napi_env env, napi_callback_info info)
1313 {
1314 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env), nullptr,
1315 "SystemApi MuteCameraPersist is called!");
1316 MEDIA_INFO_LOG("MuteCamera is called");
1317 napi_value result = nullptr;
1318 size_t argc = ARGS_TWO;
1319 napi_value argv[ARGS_TWO] = {0};
1320 napi_value thisVar = nullptr;
1321
1322 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1323 NAPI_ASSERT(env, argc == ARGS_TWO, "requires 2 parameters");
1324 bool muteMode;
1325 int32_t jsPolicyType;
1326 napi_get_value_bool(env, argv[PARAM0], &muteMode);
1327 napi_get_value_int32(env, argv[PARAM1], &jsPolicyType);
1328 NAPI_ASSERT(env, g_jsToFwPolicyType_.count(static_cast<JsPolicyType>(jsPolicyType)) != 0,
1329 "invalid policyType value");
1330 CameraManager::GetInstance()->MuteCameraPersist(g_jsToFwPolicyType_[static_cast<JsPolicyType>(jsPolicyType)],
1331 muteMode);
1332 napi_get_undefined(env, &result);
1333 return result;
1334 }
1335
CreateCameraInputInstance(napi_env env,napi_callback_info info)1336 napi_value CameraManagerNapi::CreateCameraInputInstance(napi_env env, napi_callback_info info)
1337 {
1338 MEDIA_INFO_LOG("CreateCameraInputInstance is called");
1339 CameraManagerNapi* cameraManagerNapi = nullptr;
1340 size_t argSize = CameraNapiUtils::GetNapiArgs(env, info);
1341 sptr<CameraDevice> cameraInfo = nullptr;
1342 if (argSize == ARGS_ONE) {
1343 std::string cameraId {};
1344 CameraNapiObject cameraInfoObj { { { "cameraId", &cameraId } } };
1345 CameraNapiParamParser jsParamParser(env, info, cameraManagerNapi, cameraInfoObj);
1346 CHECK_ERROR_RETURN_RET_LOG(!jsParamParser.AssertStatus(INVALID_ARGUMENT,
1347 "Create cameraInput invalid argument!"), nullptr,
1348 "CameraManagerNapi::CreateCameraInputInstance invalid argument");
1349 cameraInfo = cameraManagerNapi->cameraManager_->GetCameraDeviceFromId(cameraId);
1350 } else if (argSize == ARGS_TWO) {
1351 int32_t cameraPosition;
1352 int32_t cameraType;
1353 CameraNapiParamParser jsParamParser(env, info, cameraManagerNapi, cameraPosition, cameraType);
1354 CHECK_ERROR_RETURN_RET_LOG(!jsParamParser.AssertStatus(INVALID_ARGUMENT,
1355 "Create cameraInput with 2 invalid arguments!"), nullptr,
1356 "CameraManagerNapi::CreateCameraInputInstance 2 invalid arguments");
1357 ProcessCameraInfo(cameraManagerNapi->cameraManager_, static_cast<const CameraPosition>(cameraPosition),
1358 static_cast<const CameraType>(cameraType), cameraInfo);
1359 } else {
1360 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "invalid argument.");
1361 return nullptr;
1362 }
1363 if (cameraInfo == nullptr) {
1364 MEDIA_ERR_LOG("cameraInfo is null");
1365 CameraNapiUtils::ThrowError(env, SERVICE_FATL_ERROR, "cameraInfo is null.");
1366 return nullptr;
1367 }
1368 sptr<CameraInput> cameraInput = nullptr;
1369 int retCode = cameraManagerNapi->cameraManager_->CreateCameraInput(cameraInfo, &cameraInput);
1370 if (retCode == CAMERA_NO_PERMISSION) {
1371 CameraNapiUtils::ThrowError(env, OPERATION_NOT_ALLOWED, "not allowed, because have no permission.");
1372 return nullptr;
1373 }
1374 CHECK_ERROR_RETURN_RET(!CameraNapiUtils::CheckError(env, retCode), nullptr);
1375 return CameraInputNapi::CreateCameraInput(env, cameraInput);
1376 }
1377
ProcessCameraInfo(sptr<CameraManager> & cameraManager,const CameraPosition cameraPosition,const CameraType cameraType,sptr<CameraDevice> & cameraInfo)1378 void CameraManagerNapi::ProcessCameraInfo(sptr<CameraManager>& cameraManager, const CameraPosition cameraPosition,
1379 const CameraType cameraType, sptr<CameraDevice>& cameraInfo)
1380 {
1381 std::vector<sptr<CameraDevice>> cameraObjList = cameraManager->GetSupportedCameras();
1382 MEDIA_DEBUG_LOG("cameraInfo is null, the cameraObjList size is %{public}zu", cameraObjList.size());
1383 for (size_t i = 0; i < cameraObjList.size(); i++) {
1384 sptr<CameraDevice> cameraDevice = cameraObjList[i];
1385 if (cameraDevice == nullptr) {
1386 continue;
1387 }
1388 if (cameraDevice->GetPosition() == cameraPosition &&
1389 cameraDevice->GetCameraType() == cameraType) {
1390 cameraInfo = cameraDevice;
1391 break;
1392 }
1393 }
1394 }
1395
RegisterCameraStatusCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args,bool isOnce)1396 void CameraManagerNapi::RegisterCameraStatusCallbackListener(
1397 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args, bool isOnce)
1398 {
1399 auto listener = CameraNapiEventListener<CameraManagerCallbackNapi>::RegisterCallbackListener(
1400 eventName, env, callback, args, isOnce);
1401 CHECK_ERROR_RETURN_LOG(
1402 listener == nullptr, "CameraManagerNapi::RegisterCameraStatusCallbackListener listener is null");
1403 cameraManager_->RegisterCameraStatusCallback(listener);
1404 }
1405
UnregisterCameraStatusCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args)1406 void CameraManagerNapi::UnregisterCameraStatusCallbackListener(
1407 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args)
1408 {
1409 auto listener =
1410 CameraNapiEventListener<CameraManagerCallbackNapi>::UnregisterCallbackListener(eventName, env, callback, args);
1411 CHECK_ERROR_RETURN(listener == nullptr);
1412 if (listener->IsEmpty(eventName)) {
1413 cameraManager_->UnregisterCameraStatusCallback(listener);
1414 }
1415 }
1416
RegisterCameraMuteCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args,bool isOnce)1417 void CameraManagerNapi::RegisterCameraMuteCallbackListener(
1418 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args, bool isOnce)
1419 {
1420 CHECK_ERROR_RETURN_LOG(!CameraNapiSecurity::CheckSystemApp(env), "SystemApi On cameraMute is called!");
1421 auto listener = CameraNapiEventListener<CameraMuteListenerNapi>::RegisterCallbackListener(
1422 eventName, env, callback, args, isOnce);
1423 CHECK_ERROR_RETURN_LOG(
1424 listener == nullptr, "CameraManagerNapi::RegisterCameraMuteCallbackListener listener is null");
1425 cameraManager_->RegisterCameraMuteListener(listener);
1426 }
1427
UnregisterCameraMuteCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args)1428 void CameraManagerNapi::UnregisterCameraMuteCallbackListener(
1429 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args)
1430 {
1431 CHECK_ERROR_RETURN_LOG(!CameraNapiSecurity::CheckSystemApp(env), "SystemApi On cameraMute is called!");
1432 auto listener =
1433 CameraNapiEventListener<CameraMuteListenerNapi>::UnregisterCallbackListener(eventName, env, callback, args);
1434 CHECK_ERROR_RETURN(listener == nullptr);
1435 if (listener->IsEmpty(eventName)) {
1436 cameraManager_->UnregisterCameraMuteListener(listener);
1437 }
1438 }
1439
RegisterTorchStatusCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args,bool isOnce)1440 void CameraManagerNapi::RegisterTorchStatusCallbackListener(
1441 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args, bool isOnce)
1442 {
1443 auto listener =
1444 CameraNapiEventListener<TorchListenerNapi>::RegisterCallbackListener(eventName, env, callback, args, isOnce);
1445 CHECK_ERROR_RETURN_LOG(
1446 listener == nullptr, "CameraManagerNapi::RegisterTorchStatusCallbackListener listener is null");
1447 cameraManager_->RegisterTorchListener(listener);
1448 }
1449
UnregisterTorchStatusCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args)1450 void CameraManagerNapi::UnregisterTorchStatusCallbackListener(
1451 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args)
1452 {
1453 auto listener =
1454 CameraNapiEventListener<TorchListenerNapi>::UnregisterCallbackListener(eventName, env, callback, args);
1455 CHECK_ERROR_RETURN(listener == nullptr);
1456 if (listener->IsEmpty(eventName)) {
1457 cameraManager_->UnregisterTorchListener(listener);
1458 }
1459 }
1460
RegisterFoldStatusCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args,bool isOnce)1461 void CameraManagerNapi::RegisterFoldStatusCallbackListener(
1462 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args, bool isOnce)
1463 {
1464 auto listener =
1465 CameraNapiEventListener<FoldListenerNapi>::RegisterCallbackListener(eventName, env, callback, args, isOnce);
1466 CHECK_ERROR_RETURN_LOG(
1467 listener == nullptr, "CameraManagerNapi::RegisterTorchStatusCallbackListener listener is null");
1468 cameraManager_->RegisterFoldListener(listener);
1469 }
1470
UnregisterFoldStatusCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const std::vector<napi_value> & args)1471 void CameraManagerNapi::UnregisterFoldStatusCallbackListener(
1472 const std::string& eventName, napi_env env, napi_value callback, const std::vector<napi_value>& args)
1473 {
1474 auto listener =
1475 CameraNapiEventListener<FoldListenerNapi>::UnregisterCallbackListener(eventName, env, callback, args);
1476 CHECK_ERROR_RETURN(listener == nullptr);
1477 if (listener->IsEmpty(eventName)) {
1478 cameraManager_->UnregisterFoldListener(listener);
1479 }
1480 }
1481
GetEmitterFunctions()1482 const CameraManagerNapi::EmitterFunctions& CameraManagerNapi::GetEmitterFunctions()
1483 {
1484 static const EmitterFunctions funMap = {
1485 { "cameraStatus", {
1486 &CameraManagerNapi::RegisterCameraStatusCallbackListener,
1487 &CameraManagerNapi::UnregisterCameraStatusCallbackListener } },
1488 { "cameraMute", {
1489 &CameraManagerNapi::RegisterCameraMuteCallbackListener,
1490 &CameraManagerNapi::UnregisterCameraMuteCallbackListener } },
1491 { "torchStatusChange", {
1492 &CameraManagerNapi::RegisterTorchStatusCallbackListener,
1493 &CameraManagerNapi::UnregisterTorchStatusCallbackListener } },
1494 { "foldStatusChange", {
1495 &CameraManagerNapi::RegisterFoldStatusCallbackListener,
1496 &CameraManagerNapi::UnregisterFoldStatusCallbackListener } } };
1497 return funMap;
1498 }
1499
IsPrelaunchSupported(napi_env env,napi_callback_info info)1500 napi_value CameraManagerNapi::IsPrelaunchSupported(napi_env env, napi_callback_info info)
1501 {
1502 MEDIA_INFO_LOG("IsPrelaunchSupported is called");
1503 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env), nullptr,
1504 "SystemApi IsPrelaunchSupported is called!");
1505 CameraManagerNapi* cameraManagerNapi = nullptr;
1506 std::string cameraId {};
1507 CameraNapiObject cameraInfoObj { { { "cameraId", &cameraId } } };
1508 CameraNapiParamParser jsParamParser(env, info, cameraManagerNapi, cameraInfoObj);
1509 CHECK_ERROR_RETURN_RET_LOG(!jsParamParser.AssertStatus(INVALID_ARGUMENT, "invalid argument!"), nullptr,
1510 "CameraManagerNapi::IsPrelaunchSupported invalid argument");
1511 sptr<CameraDevice> cameraInfo = cameraManagerNapi->cameraManager_->GetCameraDeviceFromId(cameraId);
1512 if (cameraInfo != nullptr) {
1513 bool isPrelaunchSupported = cameraManagerNapi->cameraManager_->IsPrelaunchSupported(cameraInfo);
1514 MEDIA_DEBUG_LOG("isPrelaunchSupported: %{public}d", isPrelaunchSupported);
1515 napi_value result;
1516 napi_get_boolean(env, isPrelaunchSupported, &result);
1517 return result;
1518 }
1519 MEDIA_ERR_LOG("CameraManagerNapi::IsPrelaunchSupported cameraInfo is null!");
1520 CameraNapiUtils::ThrowError(env, INVALID_ARGUMENT, "cameraInfo is null.");
1521 return nullptr;
1522 }
1523
PrelaunchCamera(napi_env env,napi_callback_info info)1524 napi_value CameraManagerNapi::PrelaunchCamera(napi_env env, napi_callback_info info)
1525 {
1526 MEDIA_INFO_LOG("PrelaunchCamera is called");
1527 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env),
1528 nullptr, "SystemApi PrelaunchCamera is called!");
1529 napi_value result = nullptr;
1530 int32_t retCode = CameraManager::GetInstance()->PrelaunchCamera();
1531 CHECK_ERROR_RETURN_RET(!CameraNapiUtils::CheckError(env, retCode), result);
1532 MEDIA_INFO_LOG("PrelaunchCamera");
1533 napi_get_undefined(env, &result);
1534 return result;
1535 }
1536
PreSwitchCamera(napi_env env,napi_callback_info info)1537 napi_value CameraManagerNapi::PreSwitchCamera(napi_env env, napi_callback_info info)
1538 {
1539 MEDIA_INFO_LOG("PreSwitchCamera is called");
1540 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env),
1541 nullptr, "SystemApi PreSwitchCamera is called!");
1542 napi_value result = nullptr;
1543 size_t argc = ARGS_ONE;
1544 napi_value argv[ARGS_ONE] = { 0 };
1545 napi_value thisVar = nullptr;
1546 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1547 NAPI_ASSERT(env, argc < ARGS_TWO, "requires 1 parameters maximum");
1548 char buffer[PATH_MAX];
1549 size_t length;
1550 napi_get_value_string_utf8(env, argv[ARGS_ZERO], buffer, PATH_MAX, &length);
1551 int32_t retCode = CameraManager::GetInstance()->PreSwitchCamera(std::string(buffer));
1552 CHECK_ERROR_RETURN_RET(!CameraNapiUtils::CheckError(env, retCode), result);
1553 MEDIA_INFO_LOG("PreSwitchCamera");
1554 napi_get_undefined(env, &result);
1555 return result;
1556 }
1557
SetPrelaunchConfig(napi_env env,napi_callback_info info)1558 napi_value CameraManagerNapi::SetPrelaunchConfig(napi_env env, napi_callback_info info)
1559 {
1560 MEDIA_INFO_LOG("SetPrelaunchConfig is called");
1561 CHECK_ERROR_RETURN_RET_LOG(!CameraNapiSecurity::CheckSystemApp(env),
1562 nullptr, "SystemApi SetPrelaunchConfig is called!");
1563
1564 size_t argc = ARGS_ONE;
1565 napi_value argv[ARGS_ONE] = {0};
1566 napi_value thisVar = nullptr;
1567 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1568 NAPI_ASSERT(env, argc < ARGS_TWO, "requires 1 parameters maximum");
1569 PrelaunchConfig prelaunchConfig;
1570 EffectParam effectParam;
1571 napi_value result = nullptr;
1572
1573 bool isConfigSuccess = ParsePrelaunchConfig(env, argv[PARAM0], &prelaunchConfig);
1574 CHECK_ERROR_RETURN_RET_LOG(!isConfigSuccess, result, "SetPrelaunchConfig failed");
1575 ParseSettingParam(env, argv[PARAM0], &effectParam);
1576 std::string cameraId = prelaunchConfig.GetCameraDevice()->GetID();
1577 MEDIA_INFO_LOG("SetPrelaunchConfig cameraId = %{public}s", cameraId.c_str());
1578
1579 int32_t retCode = CameraManager::GetInstance()->SetPrelaunchConfig(cameraId,
1580 static_cast<RestoreParamTypeOhos>(prelaunchConfig.restoreParamType), prelaunchConfig.activeTime, effectParam);
1581 CHECK_ERROR_RETURN_RET(!CameraNapiUtils::CheckError(env, retCode), result);
1582 napi_get_undefined(env, &result);
1583 return result;
1584 }
1585
IsTorchSupported(napi_env env,napi_callback_info info)1586 napi_value CameraManagerNapi::IsTorchSupported(napi_env env, napi_callback_info info)
1587 {
1588 MEDIA_INFO_LOG("IsTorchSupported is called");
1589 napi_status status;
1590 napi_value result = nullptr;
1591 size_t argc = ARGS_ZERO;
1592 napi_value argv[ARGS_ZERO];
1593 napi_value thisVar = nullptr;
1594
1595 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1596
1597 napi_get_undefined(env, &result);
1598 CameraManagerNapi* cameraManagerNapi = nullptr;
1599 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&cameraManagerNapi));
1600 if (status == napi_ok && cameraManagerNapi != nullptr) {
1601 bool isTorchSupported = CameraManager::GetInstance()->IsTorchSupported();
1602 MEDIA_DEBUG_LOG("IsTorchSupported : %{public}d", isTorchSupported);
1603 napi_get_boolean(env, isTorchSupported, &result);
1604 } else {
1605 MEDIA_ERR_LOG("IsTorchSupported call Failed!");
1606 }
1607 return result;
1608 }
1609
IsTorchModeSupported(napi_env env,napi_callback_info info)1610 napi_value CameraManagerNapi::IsTorchModeSupported(napi_env env, napi_callback_info info)
1611 {
1612 MEDIA_INFO_LOG("IsTorchModeSupported is called");
1613 napi_status status;
1614 napi_value result = nullptr;
1615 size_t argc = ARGS_ONE;
1616 napi_value argv[ARGS_ONE];
1617 napi_value thisVar = nullptr;
1618
1619 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1620
1621 napi_get_undefined(env, &result);
1622 CameraManagerNapi* cameraManagerNapi = nullptr;
1623 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&cameraManagerNapi));
1624 if (status == napi_ok && cameraManagerNapi != nullptr) {
1625 int32_t mode;
1626 napi_get_value_int32(env, argv[PARAM0], &mode);
1627 MEDIA_INFO_LOG("CameraManagerNapi::IsTorchModeSupported mode = %{public}d", mode);
1628 TorchMode torchMode = (TorchMode)mode;
1629 bool isTorchModeSupported = CameraManager::GetInstance()->IsTorchModeSupported(torchMode);
1630 MEDIA_DEBUG_LOG("IsTorchModeSupported : %{public}d", isTorchModeSupported);
1631 napi_get_boolean(env, isTorchModeSupported, &result);
1632 } else {
1633 MEDIA_ERR_LOG("GetTorchMode call Failed!");
1634 }
1635 return result;
1636 }
1637
GetTorchMode(napi_env env,napi_callback_info info)1638 napi_value CameraManagerNapi::GetTorchMode(napi_env env, napi_callback_info info)
1639 {
1640 MEDIA_INFO_LOG("GetTorchMode is called");
1641 napi_status status;
1642 napi_value result = nullptr;
1643 size_t argc = ARGS_ZERO;
1644 napi_value argv[ARGS_ZERO];
1645 napi_value thisVar = nullptr;
1646
1647 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1648
1649 napi_get_undefined(env, &result);
1650 CameraManagerNapi* cameraManagerNapi = nullptr;
1651 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&cameraManagerNapi));
1652 if (status == napi_ok && cameraManagerNapi != nullptr) {
1653 TorchMode torchMode = CameraManager::GetInstance()->GetTorchMode();
1654 MEDIA_DEBUG_LOG("GetTorchMode : %{public}d", torchMode);
1655 napi_create_int32(env, torchMode, &result);
1656 } else {
1657 MEDIA_ERR_LOG("GetTorchMode call Failed!");
1658 }
1659 return result;
1660 }
1661
SetTorchMode(napi_env env,napi_callback_info info)1662 napi_value CameraManagerNapi::SetTorchMode(napi_env env, napi_callback_info info)
1663 {
1664 MEDIA_INFO_LOG("SetTorchMode is called");
1665 napi_status status;
1666 napi_value result = nullptr;
1667 size_t argc = ARGS_ONE;
1668 napi_value argv[ARGS_ONE];
1669 napi_value thisVar = nullptr;
1670
1671 CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
1672
1673 napi_get_undefined(env, &result);
1674 CameraManagerNapi* cameraManagerNapi = nullptr;
1675 status = napi_unwrap(env, thisVar, reinterpret_cast<void**>(&cameraManagerNapi));
1676 if (status == napi_ok && cameraManagerNapi != nullptr) {
1677 int32_t mode;
1678 napi_get_value_int32(env, argv[PARAM0], &mode);
1679 MEDIA_INFO_LOG("CameraManagerNapi::SetTorchMode mode = %{public}d", mode);
1680 TorchMode torchMode = (TorchMode)mode;
1681 int32_t retCode = CameraManager::GetInstance()->SetTorchMode(torchMode);
1682 if (!CameraNapiUtils::CheckError(env, retCode)) {
1683 MEDIA_DEBUG_LOG("SetTorchMode fail throw error");
1684 }
1685 } else {
1686 MEDIA_ERR_LOG("GetTorchMode call Failed!");
1687 }
1688 return result;
1689 }
1690
On(napi_env env,napi_callback_info info)1691 napi_value CameraManagerNapi::On(napi_env env, napi_callback_info info)
1692 {
1693 return ListenerTemplate<CameraManagerNapi>::On(env, info);
1694 }
1695
Once(napi_env env,napi_callback_info info)1696 napi_value CameraManagerNapi::Once(napi_env env, napi_callback_info info)
1697 {
1698 return ListenerTemplate<CameraManagerNapi>::Once(env, info);
1699 }
1700
Off(napi_env env,napi_callback_info info)1701 napi_value CameraManagerNapi::Off(napi_env env, napi_callback_info info)
1702 {
1703 return ListenerTemplate<CameraManagerNapi>::Off(env, info);
1704 }
1705 } // namespace CameraStandard
1706 } // namespace OHOS