1 /*
2  * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "mode/time_lapse_photo_session_napi.h"
16 #include "camera_napi_param_parser.h"
17 #include <uv.h>
18 
19 using namespace std;
20 
21 namespace {
22 template<typename T>
Unwrap(napi_env env,napi_value jsObject)23 T* Unwrap(napi_env env, napi_value jsObject)
24 {
25     void *result;
26     napi_unwrap(env, jsObject, &result);
27     return reinterpret_cast<T*>(result);
28 }
29 }
30 
31 namespace OHOS {
32 namespace CameraStandard {
33 thread_local napi_ref TimeLapsePhotoSessionNapi::sConstructor_{nullptr};
34 thread_local napi_ref TryAEInfoNapi::sConstructor_{nullptr};
35 
36 const unordered_map<string, TimeLapseRecordState> TimeLapseRecordStateMap = {
37     {"IDLE", TimeLapseRecordState::IDLE },
38     {"RECORDING", TimeLapseRecordState::RECORDING },
39 };
40 
41 const unordered_map<string, TimeLapsePreviewType> TimeLapsePreviewTypeMap = {
42     {"DARK", TimeLapsePreviewType::DARK},
43     {"LIGHT", TimeLapsePreviewType::LIGHT},
44 };
45 
TryAEInfoNapi()46 TryAEInfoNapi::TryAEInfoNapi() {}
47 
~TryAEInfoNapi()48 TryAEInfoNapi::~TryAEInfoNapi()
49 {
50     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
51     if (tryAEInfo_) {
52         tryAEInfo_ = nullptr;
53     }
54 }
55 
Init(napi_env env,napi_value exports)56 napi_value TryAEInfoNapi::Init(napi_env env, napi_value exports)
57 {
58     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
59     napi_status status;
60     napi_value ctorObj;
61     int32_t refCount = 1;
62 
63     napi_property_descriptor try_ae_info_properties[] = {
64         DECLARE_NAPI_GETTER("isTryAEDone", IsTryAEDone),
65         DECLARE_NAPI_GETTER("isTryAEHintNeeded", IsTryAEHintNeeded),
66         DECLARE_NAPI_GETTER("previewType", GetPreviewType),
67         DECLARE_NAPI_GETTER("captureInterval", GetCaptureInterval),
68     };
69 
70     status = napi_define_class(env, TRY_AE_INFO_NAPI_CLASS_NAME, NAPI_AUTO_LENGTH,
71                                Constructor, nullptr,
72                                sizeof(try_ae_info_properties) / sizeof(try_ae_info_properties[PARAM0]),
73                                try_ae_info_properties, &ctorObj);
74     if (status == napi_ok) {
75         if (napi_create_reference(env, ctorObj, refCount, &sConstructor_) == napi_ok) {
76             if (napi_set_named_property(env, exports, TRY_AE_INFO_NAPI_CLASS_NAME, ctorObj) == napi_ok) {
77                 return exports;
78             }
79         }
80     }
81     MEDIA_ERR_LOG("%{public}s: Failed", __FUNCTION__);
82     return nullptr;
83 }
84 
NewInstance(napi_env env)85 napi_value TryAEInfoNapi::NewInstance(napi_env env)
86 {
87     CAMERA_NAPI_VALUE  result = nullptr;
88     CAMERA_NAPI_VALUE  constructor;
89     if (napi_get_reference_value(env, sConstructor_, &constructor) == napi_ok) {
90         napi_new_instance(env, constructor, 0, nullptr, &result);
91     }
92     return result;
93 }
94 
IsTryAEDone(napi_env env,napi_callback_info info)95 napi_value TryAEInfoNapi::IsTryAEDone(napi_env env, napi_callback_info info)
96 {
97     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
98     napi_status status;
99     napi_value thisVar;
100     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
101     TryAEInfoNapi* obj = Unwrap<TryAEInfoNapi>(env, thisVar);
102     if (obj == nullptr || obj->tryAEInfo_ == nullptr) {
103         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
104         return nullptr;
105     }
106     auto value = obj->tryAEInfo_->isTryAEDone;
107     napi_value result;
108     napi_get_boolean(env, value, &result);
109     return result;
110 }
111 
IsTryAEHintNeeded(napi_env env,napi_callback_info info)112 napi_value TryAEInfoNapi::IsTryAEHintNeeded(napi_env env, napi_callback_info info)
113 {
114     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
115     napi_status status;
116     napi_value thisVar;
117     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
118     TryAEInfoNapi* obj = Unwrap<TryAEInfoNapi>(env, thisVar);
119     if (obj == nullptr || obj->tryAEInfo_ == nullptr) {
120         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
121         return nullptr;
122     }
123     auto value = obj->tryAEInfo_->isTryAEHintNeeded;
124     napi_value result;
125     napi_get_boolean(env, value, &result);
126     return result;
127 }
128 
GetPreviewType(napi_env env,napi_callback_info info)129 napi_value TryAEInfoNapi::GetPreviewType(napi_env env, napi_callback_info info)
130 {
131     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
132     napi_status status;
133     napi_value thisVar;
134     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
135     TryAEInfoNapi* obj = Unwrap<TryAEInfoNapi>(env, thisVar);
136     if (obj == nullptr || obj->tryAEInfo_ == nullptr) {
137         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
138         return nullptr;
139     }
140     auto value = obj->tryAEInfo_->previewType;
141     napi_value result;
142     napi_create_int32(env, static_cast<int32_t>(value), &result);
143     return result;
144 }
145 
GetCaptureInterval(napi_env env,napi_callback_info info)146 napi_value TryAEInfoNapi::GetCaptureInterval(napi_env env, napi_callback_info info)
147 {
148     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
149     napi_status status;
150     napi_value thisVar;
151     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
152     TryAEInfoNapi* obj = Unwrap<TryAEInfoNapi>(env, thisVar);
153     if (obj == nullptr || obj->tryAEInfo_ == nullptr) {
154         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
155         return nullptr;
156     }
157     auto value = obj->tryAEInfo_->captureInterval;
158     napi_value result;
159     napi_create_int32(env, value, &result);
160     return result;
161 }
162 
Constructor(napi_env env,napi_callback_info info)163 napi_value TryAEInfoNapi::Constructor(napi_env env, napi_callback_info info)
164 {
165     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
166     napi_status status;
167     napi_value thisVar;
168     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
169 
170     if (status == napi_ok && thisVar != nullptr) {
171         auto obj = std::make_unique<TryAEInfoNapi>();
172         status = napi_wrap(env, thisVar, reinterpret_cast<void*>(obj.get()),
173                            Destructor, nullptr, nullptr);
174         if (status == napi_ok) {
175             (void)obj.release();
176             return thisVar;
177         } else {
178             MEDIA_ERR_LOG("Failure wrapping js to native napi");
179         }
180     }
181     MEDIA_ERR_LOG("%{public}s: Failed", __FUNCTION__);
182     return nullptr;
183 }
184 
Destructor(napi_env env,void * nativeObject,void * finalize)185 void TryAEInfoNapi::Destructor(napi_env env, void* nativeObject, void* finalize)
186 {
187     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
188     TryAEInfoNapi* obj = reinterpret_cast<TryAEInfoNapi*>(nativeObject);
189     if (obj != nullptr) {
190         delete obj;
191     }
192 }
193 
TimeLapsePhotoSessionNapi()194 TimeLapsePhotoSessionNapi::TimeLapsePhotoSessionNapi() {}
195 
~TimeLapsePhotoSessionNapi()196 TimeLapsePhotoSessionNapi::~TimeLapsePhotoSessionNapi()
197 {
198     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
199     if (timeLapsePhotoSession_) {
200         timeLapsePhotoSession_ = nullptr;
201     }
202 }
203 
204 const vector<napi_property_descriptor> TimeLapsePhotoSessionNapi::time_lapse_photo_props = {
205     // TimeLapsePhotoSession properties
206     DECLARE_NAPI_FUNCTION("on", On),
207     DECLARE_NAPI_FUNCTION("off", Off),
208     DECLARE_NAPI_FUNCTION("isTryAENeeded", IsTryAENeeded),
209     DECLARE_NAPI_FUNCTION("startTryAE", StartTryAE),
210     DECLARE_NAPI_FUNCTION("stopTryAE", StopTryAE),
211     DECLARE_NAPI_FUNCTION("getSupportedTimeLapseIntervalRange", GetSupportedTimeLapseIntervalRange),
212     DECLARE_NAPI_FUNCTION("getTimeLapseInterval", GetTimeLapseInterval),
213     DECLARE_NAPI_FUNCTION("setTimeLapseInterval", SetTimeLapseInterval),
214     DECLARE_NAPI_FUNCTION("setTimeLapseRecordState", SetTimeLapseRecordState),
215     DECLARE_NAPI_FUNCTION("setTimeLapsePreviewType", SetTimeLapsePreviewType),
216 };
217 
218 const vector<napi_property_descriptor> TimeLapsePhotoSessionNapi::manual_exposure_props = {
219     // ManualExposure properties
220     DECLARE_NAPI_FUNCTION("getExposure", GetExposure),
221     DECLARE_NAPI_FUNCTION("setExposure", SetExposure),
222     DECLARE_NAPI_FUNCTION("getSupportedExposureRange", GetSupportedExposureRange),
223     DECLARE_NAPI_FUNCTION("getSupportedMeteringModes", GetSupportedMeteringModes),
224     DECLARE_NAPI_FUNCTION("isExposureMeteringModeSupported", IsExposureMeteringModeSupported),
225     DECLARE_NAPI_FUNCTION("getExposureMeteringMode", GetExposureMeteringMode),
226     DECLARE_NAPI_FUNCTION("setExposureMeteringMode", SetExposureMeteringMode),
227 };
228 
229 const vector<napi_property_descriptor> TimeLapsePhotoSessionNapi::manual_iso_props = {
230     // ManualIso properties
231     DECLARE_NAPI_FUNCTION("getIso", GetIso),
232     DECLARE_NAPI_FUNCTION("setIso", SetIso),
233     DECLARE_NAPI_FUNCTION("isManualIsoSupported", IsManualIsoSupported),
234     DECLARE_NAPI_FUNCTION("getIsoRange", GetIsoRange),
235 };
236 
237 const vector<napi_property_descriptor> TimeLapsePhotoSessionNapi::white_balance_props = {
238     // WhiteBalance properties.
239     DECLARE_NAPI_FUNCTION("isWhiteBalanceModeSupported", IsWhiteBalanceModeSupported),
240     DECLARE_NAPI_FUNCTION("getWhiteBalanceRange", GetWhiteBalanceRange),
241     DECLARE_NAPI_FUNCTION("getWhiteBalanceMode", GetWhiteBalanceMode),
242     DECLARE_NAPI_FUNCTION("setWhiteBalanceMode", SetWhiteBalanceMode),
243     DECLARE_NAPI_FUNCTION("getWhiteBalance", GetWhiteBalance),
244     DECLARE_NAPI_FUNCTION("setWhiteBalance", SetWhiteBalance),
245 };
246 
Init(napi_env env,napi_value exports)247 napi_value TimeLapsePhotoSessionNapi::Init(napi_env env, napi_value exports)
248 {
249     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
250     napi_status status;
251     napi_value ctorObj;
252     int32_t refCount = 1;
253     vector<vector<napi_property_descriptor>> descriptors = {
254         camera_process_props,
255         flash_props,
256         auto_exposure_props,
257         focus_props,
258         zoom_props,
259         color_effect_props,
260         manual_focus_props,
261         time_lapse_photo_props,
262         manual_exposure_props,
263         manual_iso_props,
264         white_balance_props,
265     };
266     vector<napi_property_descriptor> properties = CameraNapiUtils::GetPropertyDescriptor(descriptors);
267     status = napi_define_class(env, TIME_LAPSE_PHOTO_SESSION_NAPI_CLASS_NAME, NAPI_AUTO_LENGTH,
268                                Constructor, nullptr,
269                                properties.size(),
270                                properties.data(), &ctorObj);
271     if (status == napi_ok) {
272         if (napi_create_reference(env, ctorObj, refCount, &sConstructor_) == napi_ok) {
273             if (napi_set_named_property(env, exports, TIME_LAPSE_PHOTO_SESSION_NAPI_CLASS_NAME, ctorObj) == napi_ok) {
274                 return exports;
275             }
276         }
277     }
278     MEDIA_ERR_LOG("%{public}s: Failed", __FUNCTION__);
279     return nullptr;
280 }
281 
CreateCameraSession(napi_env env)282 napi_value TimeLapsePhotoSessionNapi::CreateCameraSession(napi_env env)
283 {
284     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
285     CAMERA_SYNC_TRACE;
286     napi_status status;
287     napi_value result = nullptr;
288     napi_value constructor;
289     status = napi_get_reference_value(env, sConstructor_, &constructor);
290     if (status == napi_ok) {
291         sCameraSession_ = CameraManager::GetInstance()->CreateCaptureSession(SceneMode::TIMELAPSE_PHOTO);
292         if (sCameraSession_ == nullptr) {
293             MEDIA_ERR_LOG("Failed to create Profession session instance");
294             napi_get_undefined(env, &result);
295             return result;
296         }
297         status = napi_new_instance(env, constructor, 0, nullptr, &result);
298         sCameraSession_ = nullptr;
299         if (status == napi_ok && result != nullptr) {
300             MEDIA_DEBUG_LOG("success to create Profession session napi instance");
301             return result;
302         } else {
303             MEDIA_ERR_LOG("Failed to create Profession session napi instance");
304         }
305     }
306     MEDIA_ERR_LOG("Failed to create Profession session napi instance last");
307     napi_get_undefined(env, &result);
308     return result;
309 }
310 
On(napi_env env,napi_callback_info info)311 napi_value TimeLapsePhotoSessionNapi::On(napi_env env, napi_callback_info info)
312 {
313     return ListenerTemplate<CameraSessionNapi>::On(env, info);
314 }
315 
Off(napi_env env,napi_callback_info info)316 napi_value TimeLapsePhotoSessionNapi::Off(napi_env env, napi_callback_info info)
317 {
318     return ListenerTemplate<CameraSessionNapi>::Off(env, info);
319 }
320 
IsTryAENeeded(napi_env env,napi_callback_info info)321 napi_value TimeLapsePhotoSessionNapi::IsTryAENeeded(napi_env env, napi_callback_info info)
322 {
323     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
324     napi_status status;
325     napi_value thisVar;
326     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
327     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
328     if (obj == nullptr) {
329         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
330         return nullptr;
331     }
332     bool needed;
333     int32_t ret = obj->timeLapsePhotoSession_->IsTryAENeeded(needed);
334     if (ret != CameraErrorCode::SUCCESS) {
335         MEDIA_ERR_LOG("%{public}s: IsTryAENeeded() Failed", __FUNCTION__);
336         return nullptr;
337     }
338     napi_value result;
339     if (napi_get_boolean(env, ret, &result) != napi_ok) {
340         MEDIA_ERR_LOG("%{public}s: Napi Get Boolean Failed", __FUNCTION__);
341     }
342     return result;
343 }
344 
StartTryAE(napi_env env,napi_callback_info info)345 napi_value TimeLapsePhotoSessionNapi::StartTryAE(napi_env env, napi_callback_info info)
346 {
347     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
348     napi_status status;
349     napi_value thisVar;
350     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
351     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
352     if (obj == nullptr) {
353         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
354         return nullptr;
355     }
356     obj->timeLapsePhotoSession_->LockForControl();
357     int32_t ret = obj->timeLapsePhotoSession_->StartTryAE();
358     obj->timeLapsePhotoSession_->UnlockForControl();
359     if (ret != CameraErrorCode::SUCCESS) {
360         MEDIA_ERR_LOG("%{public}s: StartTryAE() Failed", __FUNCTION__);
361         return nullptr;
362     }
363     napi_value reslut;
364     napi_get_undefined(env, &reslut);
365     return reslut;
366 }
367 
StopTryAE(napi_env env,napi_callback_info info)368 napi_value TimeLapsePhotoSessionNapi::StopTryAE(napi_env env, napi_callback_info info)
369 {
370     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
371     napi_status status;
372     napi_value thisVar;
373     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
374     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
375     if (obj == nullptr) {
376         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
377         return nullptr;
378     }
379     obj->timeLapsePhotoSession_->LockForControl();
380     int32_t ret = obj->timeLapsePhotoSession_->StopTryAE();
381     obj->timeLapsePhotoSession_->UnlockForControl();
382     if (ret != CameraErrorCode::SUCCESS) {
383         MEDIA_ERR_LOG("%{public}s: StopTryAE() Failed", __FUNCTION__);
384         return nullptr;
385     }
386     napi_value reslut;
387     napi_get_undefined(env, &reslut);
388     return reslut;
389 }
390 
GetSupportedTimeLapseIntervalRange(napi_env env,napi_callback_info info)391 napi_value TimeLapsePhotoSessionNapi::GetSupportedTimeLapseIntervalRange(napi_env env, napi_callback_info info)
392 {
393     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
394     napi_status status;
395     napi_value thisVar;
396     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
397     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
398     if (obj == nullptr) {
399         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
400         return nullptr;
401     }
402     vector<int32_t> range;
403     int32_t ret = obj->timeLapsePhotoSession_->GetSupportedTimeLapseIntervalRange(range);
404     if (ret != CameraErrorCode::SUCCESS) {
405         MEDIA_ERR_LOG("%{public}s: GetSupportedTimeLapseIntervalRange() Failed", __FUNCTION__);
406         return nullptr;
407     }
408     napi_value result;
409     if (napi_create_array_with_length(env, range.size(), &result) == napi_ok) {
410         napi_value value;
411         for (uint32_t i = 0; i < range.size(); i++) {
412             napi_create_int32(env, range[i], &value);
413             napi_set_element(env, result, i, value);
414         }
415     } else {
416         MEDIA_ERR_LOG("%{public}s: Napi Create Array With Length Failed", __FUNCTION__);
417     }
418     return result;
419 }
420 
GetTimeLapseInterval(napi_env env,napi_callback_info info)421 napi_value TimeLapsePhotoSessionNapi::GetTimeLapseInterval(napi_env env, napi_callback_info info)
422 {
423     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
424     napi_status status;
425     napi_value thisVar;
426     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
427     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
428     if (obj == nullptr) {
429         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
430         return nullptr;
431     }
432     int32_t interval;
433     int32_t ret = obj->timeLapsePhotoSession_->GetTimeLapseInterval(interval);
434     if (ret != CameraErrorCode::SUCCESS) {
435         MEDIA_ERR_LOG("%{public}s: GetTimeLapseInterval() Failed", __FUNCTION__);
436         return nullptr;
437     }
438     napi_value result;
439     if (napi_create_int32(env, interval, &result) != napi_ok) {
440         MEDIA_ERR_LOG("%{public}s: Napi Create Int32 Failed", __FUNCTION__);
441     }
442     return result;
443 }
444 
SetTimeLapseInterval(napi_env env,napi_callback_info info)445 napi_value TimeLapsePhotoSessionNapi::SetTimeLapseInterval(napi_env env, napi_callback_info info)
446 {
447     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
448     TimeLapsePhotoSessionNapi* obj;
449     int32_t interval;
450     CameraNapiParamParser parser(env, info, obj, interval);
451     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
452         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
453         return nullptr;
454     }
455     MEDIA_DEBUG_LOG("interval = %{public}d", interval);
456     obj->timeLapsePhotoSession_->LockForControl();
457     int32_t ret = obj->timeLapsePhotoSession_->SetTimeLapseInterval(interval);
458     obj->timeLapsePhotoSession_->UnlockForControl();
459     if (ret != CameraErrorCode::SUCCESS) {
460         MEDIA_ERR_LOG("%{public}s: SetTimeLapseInterval() Failed", __FUNCTION__);
461         return nullptr;
462     }
463     napi_value reslut;
464     napi_get_undefined(env, &reslut);
465     return reslut;
466 }
467 
SetTimeLapseRecordState(napi_env env,napi_callback_info info)468 napi_value TimeLapsePhotoSessionNapi::SetTimeLapseRecordState(napi_env env, napi_callback_info info)
469 {
470     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
471     TimeLapsePhotoSessionNapi* obj;
472     int32_t state;
473     CameraNapiParamParser parser(env, info, obj, state);
474     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
475         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
476         return nullptr;
477     }
478     MEDIA_DEBUG_LOG("state = %{public}d", state);
479     obj->timeLapsePhotoSession_->LockForControl();
480     int32_t ret = obj->timeLapsePhotoSession_->SetTimeLapseRecordState(static_cast<TimeLapseRecordState>(state));
481     obj->timeLapsePhotoSession_->UnlockForControl();
482     if (ret != CameraErrorCode::SUCCESS) {
483         MEDIA_ERR_LOG("%{public}s: SetTimeLapseRecordState() Failed", __FUNCTION__);
484         return nullptr;
485     }
486     napi_value reslut;
487     napi_get_undefined(env, &reslut);
488     return reslut;
489 }
490 
SetTimeLapsePreviewType(napi_env env,napi_callback_info info)491 napi_value TimeLapsePhotoSessionNapi::SetTimeLapsePreviewType(napi_env env, napi_callback_info info)
492 {
493     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
494     TimeLapsePhotoSessionNapi* obj;
495     int32_t type;
496     CameraNapiParamParser parser(env, info, obj, type);
497     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
498         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
499         return nullptr;
500     }
501     MEDIA_DEBUG_LOG("type = %{public}d", type);
502     obj->timeLapsePhotoSession_->LockForControl();
503     int32_t ret = obj->timeLapsePhotoSession_->SetTimeLapsePreviewType(static_cast<TimeLapsePreviewType>(type));
504     obj->timeLapsePhotoSession_->UnlockForControl();
505     if (ret != CameraErrorCode::SUCCESS) {
506         MEDIA_ERR_LOG("%{public}s: SetTimeLapsePreviewType() Failed", __FUNCTION__);
507         return nullptr;
508     }
509     napi_value reslut;
510     napi_get_undefined(env, &reslut);
511     return reslut;
512 }
513 
514 // ManualExposure
GetExposure(napi_env env,napi_callback_info info)515 napi_value TimeLapsePhotoSessionNapi::GetExposure(napi_env env, napi_callback_info info)
516 {
517     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
518     napi_status status;
519     napi_value thisVar;
520     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
521     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
522     if (obj == nullptr) {
523         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
524         return nullptr;
525     }
526     uint32_t exposure;
527     int32_t ret = obj->timeLapsePhotoSession_->GetExposure(exposure);
528     if (ret != CameraErrorCode::SUCCESS) {
529         MEDIA_ERR_LOG("%{public}s: getExposure() Failed", __FUNCTION__);
530         return nullptr;
531     }
532     napi_value result;
533     if (napi_create_uint32(env, exposure, &result) != napi_ok) {
534         MEDIA_ERR_LOG("%{public}s: Napi Create Double Failed", __FUNCTION__);
535     }
536     return result;
537 }
538 
SetExposure(napi_env env,napi_callback_info info)539 napi_value TimeLapsePhotoSessionNapi::SetExposure(napi_env env, napi_callback_info info)
540 {
541     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
542     TimeLapsePhotoSessionNapi* obj;
543     uint32_t exposure;
544     CameraNapiParamParser parser(env, info, obj, exposure);
545     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
546         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
547         return nullptr;
548     }
549     MEDIA_DEBUG_LOG("exposure = %{public}d", exposure);
550     obj->timeLapsePhotoSession_->LockForControl();
551     int32_t ret = obj->timeLapsePhotoSession_->SetExposure(exposure);
552     obj->timeLapsePhotoSession_->UnlockForControl();
553     if (ret != CameraErrorCode::SUCCESS) {
554         MEDIA_ERR_LOG("%{public}s: setExposure() Failed", __FUNCTION__);
555         return nullptr;
556     }
557     napi_value reslut;
558     napi_get_undefined(env, &reslut);
559     return reslut;
560 }
561 
GetSupportedExposureRange(napi_env env,napi_callback_info info)562 napi_value TimeLapsePhotoSessionNapi::GetSupportedExposureRange(napi_env env, napi_callback_info info)
563 {
564     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
565     napi_status status;
566     napi_value thisVar;
567     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
568     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
569     if (obj == nullptr) {
570         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
571         return nullptr;
572     }
573     vector<uint32_t> range;
574     int32_t ret = obj->timeLapsePhotoSession_->GetSupportedExposureRange(range);
575     if (ret != CameraErrorCode::SUCCESS) {
576         MEDIA_ERR_LOG("%{public}s: getSupportedExposureRange() Failed", __FUNCTION__);
577         return nullptr;
578     }
579     napi_value result;
580     if (napi_create_array_with_length(env, range.size(), &result) == napi_ok) {
581         napi_value value;
582         for (uint32_t i = 0; i < range.size(); i++) {
583             napi_create_uint32(env, range[i], &value);
584             napi_set_element(env, result, i, value);
585         }
586     } else {
587         MEDIA_ERR_LOG("%{public}s: Napi Create Array With Length Failed", __FUNCTION__);
588     }
589     return result;
590 }
591 
GetSupportedMeteringModes(napi_env env,napi_callback_info info)592 napi_value TimeLapsePhotoSessionNapi::GetSupportedMeteringModes(napi_env env, napi_callback_info info)
593 {
594     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
595     napi_status status;
596     napi_value thisVar;
597     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
598     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
599     if (obj == nullptr) {
600         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
601         return nullptr;
602     }
603     vector<MeteringMode> modes;
604     int32_t ret = obj->timeLapsePhotoSession_->GetSupportedMeteringModes(modes);
605     if (ret != CameraErrorCode::SUCCESS) {
606         MEDIA_ERR_LOG("%{public}s: GetSupportedMeteringModes() Failed", __FUNCTION__);
607         return nullptr;
608     }
609     napi_value result;
610     if (napi_create_array_with_length(env, modes.size(), &result) == napi_ok) {
611         napi_value value;
612         for (uint32_t i = 0; i < modes.size(); i++) {
613             napi_create_int32(env, modes[i], &value);
614             napi_set_element(env, result, i, value);
615         }
616     } else {
617         MEDIA_ERR_LOG("%{public}s: Napi Create Array With Length Failed", __FUNCTION__);
618     }
619     return result;
620 }
621 
IsExposureMeteringModeSupported(napi_env env,napi_callback_info info)622 napi_value TimeLapsePhotoSessionNapi::IsExposureMeteringModeSupported(napi_env env, napi_callback_info info)
623 {
624     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
625     TimeLapsePhotoSessionNapi* obj;
626     int32_t mode;
627     CameraNapiParamParser parser(env, info, obj, mode);
628     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
629         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
630         return nullptr;
631     }
632     bool supported;
633     int32_t ret = obj->timeLapsePhotoSession_->IsExposureMeteringModeSupported(
634         static_cast<MeteringMode>(mode), supported);
635     if (ret != CameraErrorCode::SUCCESS) {
636         MEDIA_ERR_LOG("%{public}s: IsExposureMeteringModeSupported() Failed", __FUNCTION__);
637         return nullptr;
638     }
639     napi_value result;
640     if (napi_get_boolean(env, supported, &result) != napi_ok) {
641         MEDIA_ERR_LOG("%{public}s: Napi Get Boolean Failed", __FUNCTION__);
642     }
643     return result;
644 }
645 
GetExposureMeteringMode(napi_env env,napi_callback_info info)646 napi_value TimeLapsePhotoSessionNapi::GetExposureMeteringMode(napi_env env, napi_callback_info info)
647 {
648     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
649     napi_status status;
650     napi_value thisVar;
651     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
652     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
653     if (obj == nullptr) {
654         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
655         return nullptr;
656     }
657     MeteringMode mode;
658     int32_t ret = obj->timeLapsePhotoSession_->GetExposureMeteringMode(mode);
659     if (ret != CameraErrorCode::SUCCESS) {
660         MEDIA_ERR_LOG("%{public}s: GetExposureMeteringMode() Failed", __FUNCTION__);
661         return nullptr;
662     }
663     napi_value result;
664     if (napi_create_int32(env, static_cast<int32_t>(mode), &result) != napi_ok) {
665         MEDIA_ERR_LOG("%{public}s: Napi Create Int32 Failed", __FUNCTION__);
666     }
667     return result;
668 }
669 
SetExposureMeteringMode(napi_env env,napi_callback_info info)670 napi_value TimeLapsePhotoSessionNapi::SetExposureMeteringMode(napi_env env, napi_callback_info info)
671 {
672     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
673     TimeLapsePhotoSessionNapi* obj;
674     int32_t mode;
675     CameraNapiParamParser parser(env, info, obj, mode);
676     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
677         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
678         return nullptr;
679     }
680     MEDIA_DEBUG_LOG("mode = %{public}d", mode);
681     obj->timeLapsePhotoSession_->LockForControl();
682     int32_t ret = obj->timeLapsePhotoSession_->SetExposureMeteringMode(static_cast<MeteringMode>(mode));
683     obj->timeLapsePhotoSession_->UnlockForControl();
684     if (ret != CameraErrorCode::SUCCESS) {
685         MEDIA_ERR_LOG("%{public}s: SetExposureMeteringMode() Failed", __FUNCTION__);
686         return nullptr;
687     }
688     napi_value reslut;
689     napi_get_undefined(env, &reslut);
690     return reslut;
691 }
692 
693 // ManualIso
GetIso(napi_env env,napi_callback_info info)694 napi_value TimeLapsePhotoSessionNapi::GetIso(napi_env env, napi_callback_info info)
695 {
696     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
697     napi_status status;
698     napi_value thisVar;
699     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
700     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
701     if (obj == nullptr) {
702         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
703         return nullptr;
704     }
705     int32_t iso;
706     int32_t ret = obj->timeLapsePhotoSession_->GetIso(iso);
707     if (ret != CameraErrorCode::SUCCESS) {
708         MEDIA_ERR_LOG("%{public}s: getIso() Failed", __FUNCTION__);
709         return nullptr;
710     }
711     napi_value result;
712     if (napi_create_int32(env, iso, &result) != napi_ok) {
713         MEDIA_ERR_LOG("%{public}s: Napi Create Int32 Failed", __FUNCTION__);
714     }
715     return result;
716 }
717 
SetIso(napi_env env,napi_callback_info info)718 napi_value TimeLapsePhotoSessionNapi::SetIso(napi_env env, napi_callback_info info)
719 {
720     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
721     TimeLapsePhotoSessionNapi* obj;
722     int32_t iso;
723     CameraNapiParamParser parser(env, info, obj, iso);
724     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
725         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
726         return nullptr;
727     }
728     MEDIA_DEBUG_LOG("iso = %{public}d", iso);
729     obj->timeLapsePhotoSession_->LockForControl();
730     int32_t ret = obj->timeLapsePhotoSession_->SetIso(iso);
731     obj->timeLapsePhotoSession_->UnlockForControl();
732     if (ret != CameraErrorCode::SUCCESS) {
733         MEDIA_ERR_LOG("%{public}s: setIso() Failed", __FUNCTION__);
734         return nullptr;
735     }
736     napi_value reslut;
737     napi_get_undefined(env, &reslut);
738     return reslut;
739 }
740 
IsManualIsoSupported(napi_env env,napi_callback_info info)741 napi_value TimeLapsePhotoSessionNapi::IsManualIsoSupported(napi_env env, napi_callback_info info)
742 {
743     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
744     napi_status status;
745     napi_value thisVar;
746     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
747     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
748     if (obj == nullptr) {
749         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
750         return nullptr;
751     }
752     bool supported;
753     int32_t ret = obj->timeLapsePhotoSession_->IsManualIsoSupported(supported);
754     if (ret != CameraErrorCode::SUCCESS) {
755         MEDIA_ERR_LOG("%{public}s: isManualIsoSupported() Failed", __FUNCTION__);
756         return nullptr;
757     }
758     napi_value result;
759     if (napi_get_boolean(env, supported, &result) != napi_ok) {
760         MEDIA_ERR_LOG("%{public}s: Napi Get Boolean Failed", __FUNCTION__);
761     }
762     return result;
763 }
764 
GetIsoRange(napi_env env,napi_callback_info info)765 napi_value TimeLapsePhotoSessionNapi::GetIsoRange(napi_env env, napi_callback_info info)
766 {
767     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
768     napi_status status;
769     napi_value thisVar;
770     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
771     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
772     if (obj == nullptr) {
773         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
774         return nullptr;
775     }
776     vector<int32_t> range;
777     int32_t ret = obj->timeLapsePhotoSession_->GetIsoRange(range);
778     if (ret != CameraErrorCode::SUCCESS) {
779         MEDIA_ERR_LOG("%{public}s: getIsoRange() Failed", __FUNCTION__);
780         return nullptr;
781     }
782     napi_value result;
783     if (napi_create_array_with_length(env, range.size(), &result) == napi_ok) {
784         napi_value value;
785         for (uint32_t i = 0; i < range.size(); i++) {
786             napi_create_int32(env, range[i], &value);
787             napi_set_element(env, result, i, value);
788         }
789     } else {
790         MEDIA_ERR_LOG("%{public}s: Napi Create Array With Length Failed", __FUNCTION__);
791     }
792     return result;
793 }
794 
795 // WhiteBalance
IsWhiteBalanceModeSupported(napi_env env,napi_callback_info info)796 napi_value TimeLapsePhotoSessionNapi::IsWhiteBalanceModeSupported(napi_env env, napi_callback_info info)
797 {
798     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
799     size_t argc;
800     napi_value argv[1];
801     napi_value thisVar;
802     CAMERA_NAPI_GET_JS_ARGS(env, info, argc, argv, thisVar);
803     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
804     if (obj == nullptr) {
805         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
806         return nullptr;
807     }
808     int32_t mode;
809     napi_get_value_int32(env, argv[0], &mode);
810     bool supported;
811     int32_t ret = obj->timeLapsePhotoSession_->IsWhiteBalanceModeSupported(
812         static_cast<WhiteBalanceMode>(mode), supported);
813     if (ret != CameraErrorCode::SUCCESS) {
814         MEDIA_ERR_LOG("%{public}s: isWhiteBalanceModeSupported() Failed", __FUNCTION__);
815         return nullptr;
816     }
817     napi_value result;
818     if (napi_get_boolean(env, supported, &result) != napi_ok) {
819         MEDIA_ERR_LOG("%{public}s: Napi Get Boolean Failed", __FUNCTION__);
820     }
821     return result;
822 }
823 
GetWhiteBalanceRange(napi_env env,napi_callback_info info)824 napi_value TimeLapsePhotoSessionNapi::GetWhiteBalanceRange(napi_env env, napi_callback_info info)
825 {
826     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
827     napi_status status;
828     napi_value thisVar;
829     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
830     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
831     if (obj == nullptr) {
832         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
833         return nullptr;
834     }
835     vector<int32_t> range;
836     int32_t ret = obj->timeLapsePhotoSession_->GetWhiteBalanceRange(range);
837     if (ret != CameraErrorCode::SUCCESS) {
838         MEDIA_ERR_LOG("%{public}s: getWhiteBalanceRange() Failed", __FUNCTION__);
839         return nullptr;
840     }
841     napi_value result;
842     if (napi_create_array_with_length(env, range.size(), &result) == napi_ok) {
843         napi_value value;
844         for (uint32_t i = 0; i < range.size(); i++) {
845             napi_create_int32(env, range[i], &value);
846             napi_set_element(env, result, i, value);
847         }
848     } else {
849         MEDIA_ERR_LOG("%{public}s: Napi Create Array With Length Failed", __FUNCTION__);
850     }
851     return result;
852 }
853 
GetWhiteBalanceMode(napi_env env,napi_callback_info info)854 napi_value TimeLapsePhotoSessionNapi::GetWhiteBalanceMode(napi_env env, napi_callback_info info)
855 {
856     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
857     napi_status status;
858     napi_value thisVar;
859     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
860     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
861     if (obj == nullptr) {
862         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
863         return nullptr;
864     }
865     WhiteBalanceMode mode;
866     int32_t ret = obj->timeLapsePhotoSession_->GetWhiteBalanceMode(mode);
867     if (ret != CameraErrorCode::SUCCESS) {
868         MEDIA_ERR_LOG("%{public}s: getWhiteBalanceMode() Failed", __FUNCTION__);
869         return nullptr;
870     }
871     napi_value result;
872     if (napi_create_int32(env, static_cast<int32_t>(mode), &result) != napi_ok) {
873         MEDIA_ERR_LOG("%{public}s: Napi Create Int32 Failed", __FUNCTION__);
874     }
875     return result;
876 }
877 
SetWhiteBalanceMode(napi_env env,napi_callback_info info)878 napi_value TimeLapsePhotoSessionNapi::SetWhiteBalanceMode(napi_env env, napi_callback_info info)
879 {
880     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
881     TimeLapsePhotoSessionNapi* obj;
882     int32_t mode;
883     CameraNapiParamParser parser(env, info, obj, mode);
884     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
885         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
886         return nullptr;
887     }
888     MEDIA_DEBUG_LOG("mode = %{public}d", mode);
889     obj->timeLapsePhotoSession_->LockForControl();
890     int32_t ret = obj->timeLapsePhotoSession_->SetWhiteBalanceMode(static_cast<WhiteBalanceMode>(mode));
891     obj->timeLapsePhotoSession_->UnlockForControl();
892     if (ret != CameraErrorCode::SUCCESS) {
893         MEDIA_ERR_LOG("%{public}s: setWhiteBalanceMode() Failed", __FUNCTION__);
894         return nullptr;
895     }
896     napi_value reslut;
897     napi_get_undefined(env, &reslut);
898     return reslut;
899 }
900 
GetWhiteBalance(napi_env env,napi_callback_info info)901 napi_value TimeLapsePhotoSessionNapi::GetWhiteBalance(napi_env env, napi_callback_info info)
902 {
903     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
904     napi_status status;
905     napi_value thisVar;
906     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
907     TimeLapsePhotoSessionNapi* obj = Unwrap<TimeLapsePhotoSessionNapi>(env, thisVar);
908     if (obj == nullptr) {
909         MEDIA_ERR_LOG("%{public}s: Unwrap Napi Object Failed", __FUNCTION__);
910         return nullptr;
911     }
912     int32_t balance;
913     int32_t ret = obj->timeLapsePhotoSession_->GetWhiteBalance(balance);
914     if (ret != CameraErrorCode::SUCCESS) {
915         MEDIA_ERR_LOG("%{public}s: getWhiteBalance() Failed", __FUNCTION__);
916         return nullptr;
917     }
918     napi_value result;
919     if (napi_create_int32(env, balance, &result) != napi_ok) {
920         MEDIA_ERR_LOG("%{public}s: Napi Create Int32 Failed", __FUNCTION__);
921     }
922     return result;
923 }
924 
SetWhiteBalance(napi_env env,napi_callback_info info)925 napi_value TimeLapsePhotoSessionNapi::SetWhiteBalance(napi_env env, napi_callback_info info)
926 {
927     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
928     TimeLapsePhotoSessionNapi* obj;
929     int32_t balance;
930     CameraNapiParamParser parser(env, info, obj, balance);
931     if (!parser.AssertStatus(INVALID_ARGUMENT, "Invalid argument!")) {
932         MEDIA_ERR_LOG("%{public}s: Read Params Error", __FUNCTION__);
933         return nullptr;
934     }
935     MEDIA_DEBUG_LOG("balance = %{public}d", balance);
936     obj->timeLapsePhotoSession_->LockForControl();
937     int32_t ret = obj->timeLapsePhotoSession_->SetWhiteBalance(balance);
938     obj->timeLapsePhotoSession_->UnlockForControl();
939     if (ret != CameraErrorCode::SUCCESS) {
940         MEDIA_ERR_LOG("%{public}s: setWhiteBalance() Failed", __FUNCTION__);
941         return nullptr;
942     }
943     napi_value reslut;
944     napi_get_undefined(env, &reslut);
945     return reslut;
946 }
947 
Constructor(napi_env env,napi_callback_info info)948 napi_value TimeLapsePhotoSessionNapi::Constructor(napi_env env, napi_callback_info info)
949 {
950     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
951     napi_status status;
952     napi_value thisVar;
953     CAMERA_NAPI_GET_JS_OBJ_WITH_ZERO_ARGS(env, info, status, thisVar);
954 
955     if (status == napi_ok && thisVar != nullptr) {
956         auto obj = std::make_unique<TimeLapsePhotoSessionNapi>();
957         obj->timeLapsePhotoSession_ = static_cast<TimeLapsePhotoSession*>(sCameraSession_.GetRefPtr());
958         obj->cameraSession_ = obj->timeLapsePhotoSession_;
959         if (obj->timeLapsePhotoSession_ == nullptr) {
960             MEDIA_ERR_LOG("%{public}s: timeLapsePhotoSession_ is nullptr", __FUNCTION__);
961             return nullptr;
962         }
963         status = napi_wrap(env, thisVar, reinterpret_cast<void*>(obj.get()),
964                            Destructor, nullptr, nullptr);
965         if (status == napi_ok) {
966             (void)obj.release();
967             return thisVar;
968         } else {
969             MEDIA_ERR_LOG("Failure wrapping js to native napi");
970         }
971     }
972     MEDIA_ERR_LOG("%{public}s: Failed", __FUNCTION__);
973     return nullptr;
974 }
975 
Destructor(napi_env env,void * nativeObject,void * finalize)976 void TimeLapsePhotoSessionNapi::Destructor(napi_env env, void* nativeObject, void* finalize)
977 {
978     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
979     TimeLapsePhotoSessionNapi* obj = reinterpret_cast<TimeLapsePhotoSessionNapi*>(nativeObject);
980     if (obj != nullptr) {
981         delete obj;
982     }
983 }
984 
RegisterIsoInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args,bool isOnce)985 void TimeLapsePhotoSessionNapi::RegisterIsoInfoCallbackListener(const std::string& eventName, napi_env env,
986     napi_value callback, const vector<napi_value>& args, bool isOnce)
987 {
988     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
989     if (isoInfoCallback_ == nullptr) {
990         isoInfoCallback_ = make_shared<IsoInfoCallbackListener>(env);
991         timeLapsePhotoSession_->SetIsoInfoCallback(isoInfoCallback_);
992     }
993     isoInfoCallback_->SaveCallbackReference(eventName, callback, isOnce);
994 }
995 
UnregisterIsoInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args)996 void TimeLapsePhotoSessionNapi::UnregisterIsoInfoCallbackListener(const std::string& eventName, napi_env env,
997     napi_value callback, const vector<napi_value>& args)
998 {
999     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1000     if (isoInfoCallback_ == nullptr) {
1001         MEDIA_ERR_LOG("isoInfoCallback is null");
1002     } else {
1003         isoInfoCallback_->RemoveCallbackRef(eventName, callback);
1004     }
1005 }
1006 
RegisterExposureInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args,bool isOnce)1007 void TimeLapsePhotoSessionNapi::RegisterExposureInfoCallbackListener(const std::string& eventName, napi_env env,
1008     napi_value callback, const vector<napi_value>& args, bool isOnce)
1009 {
1010     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1011     if (exposureInfoCallback_ == nullptr) {
1012         exposureInfoCallback_ = make_shared<ExposureInfoCallbackListener>(env);
1013         timeLapsePhotoSession_->SetExposureInfoCallback(exposureInfoCallback_);
1014     }
1015     exposureInfoCallback_->SaveCallbackReference(eventName, callback, isOnce);
1016 }
1017 
UnregisterExposureInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args)1018 void TimeLapsePhotoSessionNapi::UnregisterExposureInfoCallbackListener(const std::string& eventName, napi_env env,
1019     napi_value callback, const vector<napi_value>& args)
1020 {
1021     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1022     if (exposureInfoCallback_ == nullptr) {
1023         MEDIA_ERR_LOG("exposureInfoCallback is null");
1024     } else {
1025         exposureInfoCallback_->RemoveCallbackRef(eventName, callback);
1026     }
1027 }
1028 
RegisterLuminationInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args,bool isOnce)1029 void TimeLapsePhotoSessionNapi::RegisterLuminationInfoCallbackListener(const std::string& eventName, napi_env env,
1030     napi_value callback, const vector<napi_value>& args, bool isOnce)
1031 {
1032     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1033     if (luminationInfoCallback_ == nullptr) {
1034         ExposureHintMode mode = EXPOSURE_HINT_MODE_ON;
1035         timeLapsePhotoSession_->LockForControl();
1036         timeLapsePhotoSession_->SetExposureHintMode(mode);
1037         timeLapsePhotoSession_->UnlockForControl();
1038         MEDIA_INFO_LOG("TimeLapsePhotoSessionNapi SetExposureHintMode exposureHint = %{public}d", mode);
1039         luminationInfoCallback_ = make_shared<LuminationInfoCallbackListener>(env);
1040         timeLapsePhotoSession_->SetLuminationInfoCallback(luminationInfoCallback_);
1041     }
1042     luminationInfoCallback_->SaveCallbackReference(eventName, callback, isOnce);
1043 }
1044 
UnregisterLuminationInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args)1045 void TimeLapsePhotoSessionNapi::UnregisterLuminationInfoCallbackListener(const std::string& eventName, napi_env env,
1046     napi_value callback, const vector<napi_value>& args)
1047 {
1048     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1049     if (luminationInfoCallback_ == nullptr) {
1050         MEDIA_ERR_LOG("luminationInfoCallback is null");
1051     } else {
1052         ExposureHintMode mode = EXPOSURE_HINT_MODE_OFF;
1053         timeLapsePhotoSession_->LockForControl();
1054         timeLapsePhotoSession_->SetExposureHintMode(mode);
1055         timeLapsePhotoSession_->UnlockForControl();
1056         MEDIA_INFO_LOG("TimeLapsePhotoSessionNapi SetExposureHintMode exposureHint = %{public}d!", mode);
1057         luminationInfoCallback_->RemoveCallbackRef(eventName, callback);
1058     }
1059 }
1060 
RegisterTryAEInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args,bool isOnce)1061 void TimeLapsePhotoSessionNapi::RegisterTryAEInfoCallbackListener(const std::string& eventName, napi_env env,
1062     napi_value callback, const vector<napi_value>& args, bool isOnce)
1063 {
1064     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1065     if (tryAEInfoCallback_ == nullptr) {
1066         tryAEInfoCallback_ = make_shared<TryAEInfoCallbackListener>(env);
1067         timeLapsePhotoSession_->SetTryAEInfoCallback(tryAEInfoCallback_);
1068     }
1069     tryAEInfoCallback_->SaveCallbackReference(eventName, callback, isOnce);
1070 }
1071 
UnregisterTryAEInfoCallbackListener(const std::string & eventName,napi_env env,napi_value callback,const vector<napi_value> & args)1072 void TimeLapsePhotoSessionNapi::UnregisterTryAEInfoCallbackListener(const std::string& eventName, napi_env env,
1073     napi_value callback, const vector<napi_value>& args)
1074 {
1075     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1076     if (tryAEInfoCallback_ == nullptr) {
1077         MEDIA_ERR_LOG("tryAEInfoCallback is null");
1078     } else {
1079         tryAEInfoCallback_->RemoveCallbackRef(eventName, callback);
1080     }
1081 }
1082 
OnTryAEInfoChanged(TryAEInfo info)1083 void TryAEInfoCallbackListener::OnTryAEInfoChanged(TryAEInfo info)
1084 {
1085     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1086     MEDIA_DEBUG_LOG("isTryAEDone = %{isTryAEDone}d", info.isTryAEDone);
1087     MEDIA_DEBUG_LOG("isTryAEHintNeeded = %{isTryAEHintNeeded}d", info.isTryAEHintNeeded);
1088     MEDIA_DEBUG_LOG("previewType = %{previewType}d", info.previewType);
1089     MEDIA_DEBUG_LOG("captureInterval = %{captureInterval}d", info.captureInterval);
1090     OnTryAEInfoChangedCallbackAsync(info);
1091 }
1092 
OnTryAEInfoChangedCallback(TryAEInfo info) const1093 void TryAEInfoCallbackListener::OnTryAEInfoChangedCallback(TryAEInfo info) const
1094 {
1095     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1096     napi_value result[ARGS_TWO] = { nullptr, nullptr };
1097     napi_value retVal;
1098 
1099     napi_get_undefined(env_, &result[PARAM0]);
1100     result[PARAM1] = TryAEInfoNapi::NewInstance(env_);
1101     TryAEInfoNapi *obj = Unwrap<TryAEInfoNapi>(env_, result[PARAM1]);
1102     if (obj) {
1103         obj->tryAEInfo_ = make_unique<TryAEInfo>(info);
1104         MEDIA_DEBUG_LOG("isTryAEDone = %{isTryAEDone}d", obj->tryAEInfo_->isTryAEDone);
1105         MEDIA_DEBUG_LOG("isTryAEHintNeeded = %{isTryAEHintNeeded}d", obj->tryAEInfo_->isTryAEHintNeeded);
1106         MEDIA_DEBUG_LOG("previewType = %{previewType}d", obj->tryAEInfo_->previewType);
1107         MEDIA_DEBUG_LOG("captureInterval = %{captureInterval}d", obj->tryAEInfo_->captureInterval);
1108     } else {
1109         MEDIA_ERR_LOG("%{public}s: Enter, TryAEInfoNapi* is nullptr", __FUNCTION__);
1110     }
1111     ExecuteCallbackNapiPara callbackPara { .recv = nullptr, .argc = ARGS_TWO, .argv = result, .result = &retVal };
1112     ExecuteCallback("tryAEInfoChange", callbackPara);
1113 }
1114 
OnTryAEInfoChangedCallbackAsync(TryAEInfo info) const1115 void TryAEInfoCallbackListener::OnTryAEInfoChangedCallbackAsync(TryAEInfo info) const
1116 {
1117     MEDIA_DEBUG_LOG("%{public}s: Enter", __FUNCTION__);
1118     uv_loop_s* loop = nullptr;
1119     napi_get_uv_event_loop(env_, &loop);
1120     if (!loop) {
1121         MEDIA_ERR_LOG("failed to get event loop");
1122         return;
1123     }
1124     uv_work_t* work = new(std::nothrow) uv_work_t;
1125     if (!work) {
1126         MEDIA_ERR_LOG("failed to allocate work");
1127         return;
1128     }
1129     auto callback = make_unique<TryAEInfoChangedCallback>(info, this);
1130     work->data = callback.get();
1131     int ret = uv_queue_work_with_qos(loop, work, [] (uv_work_t* work) {},
1132         [] (uv_work_t* work, int status) {
1133             TryAEInfoChangedCallback* callback = reinterpret_cast<TryAEInfoChangedCallback *>(work->data);
1134             if (callback) {
1135                 callback->listener_->OnTryAEInfoChangedCallback(callback->info_);
1136                 delete callback;
1137             }
1138             delete work;
1139         }, uv_qos_user_initiated);
1140     if (ret) {
1141         MEDIA_ERR_LOG("failed to execute work");
1142         delete work;
1143     } else {
1144         (void)callback.release();
1145     }
1146 }
1147 
1148 }
1149 }