1 /*
2  * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "session/profession_session.h"
17 #include "camera_log.h"
18 #include "camera_metadata_operator.h"
19 #include "camera_util.h"
20 #include "hcapture_session_callback_stub.h"
21 #include "metadata_common_utils.h"
22 #include "input/camera_input.h"
23 #include "output/photo_output.h"
24 #include "output/preview_output.h"
25 #include "output/video_output.h"
26 #include <algorithm>
27 #include <cstdint>
28 
29 namespace OHOS {
30 namespace CameraStandard {
31 constexpr int32_t DEFAULT_ITEMS = 10;
32 constexpr int32_t DEFAULT_DATA_LENGTH = 100;
33 
~ProfessionSession()34 ProfessionSession::~ProfessionSession()
35 {
36     exposureInfoCallback_ = nullptr;
37     isoInfoCallback_ = nullptr;
38     apertureInfoCallback_ = nullptr;
39     luminationInfoCallback_ = nullptr;
40 }
41 // metering mode
42 const std::unordered_map<camera_meter_mode_t, MeteringMode> ProfessionSession::metaMeteringModeMap_ = {
43     {OHOS_CAMERA_SPOT_METERING,             METERING_MODE_SPOT},
44     {OHOS_CAMERA_REGION_METERING,           METERING_MODE_REGION},
45     {OHOS_CAMERA_OVERALL_METERING,          METERING_MODE_OVERALL},
46     {OHOS_CAMERA_CENTER_WEIGHTED_METERING,  METERING_MODE_CENTER_WEIGHTED}
47 };
48 
49 const std::unordered_map<MeteringMode, camera_meter_mode_t> ProfessionSession::fwkMeteringModeMap_ = {
50     {METERING_MODE_SPOT,                    OHOS_CAMERA_SPOT_METERING},
51     {METERING_MODE_REGION,                  OHOS_CAMERA_REGION_METERING},
52     {METERING_MODE_OVERALL,                 OHOS_CAMERA_OVERALL_METERING},
53     {METERING_MODE_CENTER_WEIGHTED,         OHOS_CAMERA_CENTER_WEIGHTED_METERING}
54 };
55 
56 // FocusAssistFlash mode
57 const std::unordered_map<camera_focus_assist_flash_mode_enum_t, FocusAssistFlashMode>
58     ProfessionSession::metaFocusAssistFlashModeMap_ = {
59     { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT,  FOCUS_ASSIST_FLASH_MODE_DEFAULT },
60     { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_AUTO,     FOCUS_ASSIST_FLASH_MODE_AUTO },
61     { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_ON,       FOCUS_ASSIST_FLASH_MODE_ON },
62     { OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_OFF,      FOCUS_ASSIST_FLASH_MODE_OFF },
63 };
64 const std::unordered_map<FocusAssistFlashMode, camera_focus_assist_flash_mode_enum_t>
65     ProfessionSession::fwkFocusAssistFlashModeMap_ = {
66     { FOCUS_ASSIST_FLASH_MODE_DEFAULT,  OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT },
67     { FOCUS_ASSIST_FLASH_MODE_AUTO,     OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_AUTO },
68     { FOCUS_ASSIST_FLASH_MODE_ON,       OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_ON },
69     { FOCUS_ASSIST_FLASH_MODE_OFF,      OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_OFF },
70 };
71 // ExposureHintMode
72 const std::unordered_map<camera_exposure_hint_mode_enum_t, ExposureHintMode>
73     ProfessionSession::metaExposureHintModeMap_ = {
74     { OHOS_CAMERA_EXPOSURE_HINT_UNSUPPORTED, EXPOSURE_HINT_UNSUPPORTED },
75     { OHOS_CAMERA_EXPOSURE_HINT_MODE_ON, EXPOSURE_HINT_MODE_ON },
76     { OHOS_CAMERA_EXPOSURE_HINT_MODE_OFF, EXPOSURE_HINT_MODE_OFF },
77 };
78 const std::unordered_map<ExposureHintMode, camera_exposure_hint_mode_enum_t>
79     ProfessionSession::fwkExposureHintModeMap_ = {
80     { EXPOSURE_HINT_UNSUPPORTED, OHOS_CAMERA_EXPOSURE_HINT_UNSUPPORTED },
81     { EXPOSURE_HINT_MODE_ON, OHOS_CAMERA_EXPOSURE_HINT_MODE_ON },
82     { EXPOSURE_HINT_MODE_OFF, OHOS_CAMERA_EXPOSURE_HINT_MODE_OFF },
83 };
84 // metering mode
GetSupportedMeteringModes(std::vector<MeteringMode> & supportedMeteringModes)85 int32_t ProfessionSession::GetSupportedMeteringModes(std::vector<MeteringMode> &supportedMeteringModes)
86 {
87     supportedMeteringModes.clear();
88     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
89         "ProfessionSession::GetSupportedMeteringModes Session is not Commited");
90     auto inputDevice = GetInputDevice();
91     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
92         "ProfessionSession::GetSupportedMeteringModes camera device is null");
93     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
94     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, PortraitEffect::OFF_EFFECT,
95         "ProfessionSession::GetSupportedMeteringModes camera deviceInfo is null");
96     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
97     camera_metadata_item_t item;
98     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_METER_MODES, &item);
99     if (ret != CAM_META_SUCCESS) {
100         MEDIA_ERR_LOG("ProfessionSession::GetSupportedMeteringModes Failed with return code %{public}d", ret);
101         return CameraErrorCode::SUCCESS;
102     }
103     for (uint32_t i = 0; i < item.count; i++) {
104         auto itr = metaMeteringModeMap_.find(static_cast<camera_meter_mode_t>(item.data.u8[i]));
105         if (itr != metaMeteringModeMap_.end()) {
106             supportedMeteringModes.emplace_back(itr->second);
107         }
108     }
109     return CameraErrorCode::SUCCESS;
110 }
111 
IsMeteringModeSupported(MeteringMode meteringMode,bool & isSupported)112 int32_t ProfessionSession::IsMeteringModeSupported(MeteringMode meteringMode, bool &isSupported)
113 {
114     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
115         "ProfessionSession::IsMeteringModeSupported Session is not Commited");
116     std::vector<MeteringMode> vecSupportedMeteringModeList;
117     (void)this->GetSupportedMeteringModes(vecSupportedMeteringModeList);
118     if (find(vecSupportedMeteringModeList.begin(), vecSupportedMeteringModeList.end(),
119         meteringMode) != vecSupportedMeteringModeList.end()) {
120         isSupported = true;
121         return CameraErrorCode::SUCCESS;
122     }
123     isSupported = false;
124     return CameraErrorCode::SUCCESS;
125 }
126 
SetMeteringMode(MeteringMode mode)127 int32_t ProfessionSession::SetMeteringMode(MeteringMode mode)
128 {
129     CAMERA_SYNC_TRACE;
130     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
131         "ProfessionSession::SetMeteringMode Session is not Commited");
132     CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
133         "ProfessionSession::SetMeteringMode Need to call LockForControl() before setting camera properties");
134     camera_meter_mode_t meteringMode = OHOS_CAMERA_SPOT_METERING;
135     auto itr = fwkMeteringModeMap_.find(mode);
136     if (itr == fwkMeteringModeMap_.end()) {
137         MEDIA_ERR_LOG("ProfessionSession::SetMeteringMode Unknown exposure mode");
138     } else {
139         meteringMode = itr->second;
140     }
141     bool status = false;
142     int32_t ret;
143     uint32_t count = 1;
144     camera_metadata_item_t item;
145 
146     MEDIA_DEBUG_LOG("ProfessionSession::SetMeteringMode metering mode: %{public}d", meteringMode);
147 
148     ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_METER_MODE, &item);
149     if (ret == CAM_META_ITEM_NOT_FOUND) {
150         status = changedMetadata_->addEntry(OHOS_CONTROL_METER_MODE, &meteringMode, count);
151     } else if (ret == CAM_META_SUCCESS) {
152         status = changedMetadata_->updateEntry(OHOS_CONTROL_METER_MODE, &meteringMode, count);
153     }
154     CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetMeteringMode Failed to set focus mode");
155     return CameraErrorCode::SUCCESS;
156 }
157 
GetMeteringMode(MeteringMode & meteringMode)158 int32_t ProfessionSession::GetMeteringMode(MeteringMode &meteringMode)
159 {
160     meteringMode = METERING_MODE_SPOT;
161     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
162         "ProfessionSession::GetMeteringMode Session is not Commited");
163     auto inputDevice = GetInputDevice();
164     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
165         "ProfessionSession::GetMeteringMode camera device is null");
166     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
167     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
168         "ProfessionSession::GetMeteringMode camera deviceInfo is null");
169     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
170     camera_metadata_item_t item;
171     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_METER_MODE, &item);
172     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
173         "ProfessionSession::GetMeteringMode Failed with return code %{public}d", ret);
174     auto itr = metaMeteringModeMap_.find(static_cast<camera_meter_mode_t>(item.data.u8[0]));
175     if (itr != metaMeteringModeMap_.end()) {
176         meteringMode = itr->second;
177         return CameraErrorCode::SUCCESS;
178     }
179     return CameraErrorCode::SUCCESS;
180 }
181 // ISO
GetIsoRange(std::vector<int32_t> & isoRange)182 int32_t ProfessionSession::GetIsoRange(std::vector<int32_t> &isoRange)
183 {
184     isoRange.clear();
185     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
186         "ProfessionSession::GetIsoRange Session is not Commited");
187     auto inputDevice = GetInputDevice();
188     CHECK_ERROR_RETURN_RET_LOG(!inputDevice || !inputDevice->GetCameraDeviceInfo(),
189         CameraErrorCode::SUCCESS, "ProfessionSession::GetIsoRange camera device is null");
190 
191     std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = GetMetadata();
192     CHECK_ERROR_RETURN_RET_LOG(metadata == nullptr, CameraErrorCode::INVALID_ARGUMENT, "GetIsoRange metadata is null");
193 
194     camera_metadata_item_t item;
195     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_ISO_VALUES, &item);
196     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS || item.count == 0, CameraErrorCode::INVALID_ARGUMENT,
197         "ProfessionSession::GetIsoRange Failed with return code %{public}d", ret);
198     std::vector<std::vector<int32_t> > modeIsoRanges = {};
199         std::vector<int32_t> modeRange = {};
200     for (uint32_t i = 0; i < item.count; i++) {
201         if (item.data.i32[i] != -1) {
202             modeRange.emplace_back(item.data.i32[i]);
203             continue;
204         }
205         MEDIA_DEBUG_LOG("ProfessionSession::GetIsoRange mode %{public}d, range=%{public}s",
206                         GetMode(), Container2String(modeRange.begin(), modeRange.end()).c_str());
207         modeIsoRanges.emplace_back(std::move(modeRange));
208         modeRange.clear();
209     }
210 
211     for (auto it : modeIsoRanges) {
212         MEDIA_DEBUG_LOG("ProfessionSession::GetIsoRange ranges=%{public}s",
213                         Container2String(it.begin(), it.end()).c_str());
214         if (GetMode() == it.at(0)) {
215             isoRange.resize(it.size() - 1);
216             std::copy(it.begin() + 1, it.end(), isoRange.begin());
217         }
218     }
219     MEDIA_INFO_LOG("ProfessionSessionNapi::GetIsoRange isoRange=%{public}s, len = %{public}zu",
220                    Container2String(isoRange.begin(), isoRange.end()).c_str(), isoRange.size());
221     return CameraErrorCode::SUCCESS;
222 }
223 
SetISO(int32_t iso)224 int32_t ProfessionSession::SetISO(int32_t iso)
225 {
226     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
227         "ProfessionSession::SetISO Session is not Commited");
228     CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
229         "ProfessionSession::SetISO Need to call LockForControl() before setting camera properties");
230 
231     bool status = false;
232     int32_t count = 1;
233     camera_metadata_item_t item;
234     MEDIA_DEBUG_LOG("ProfessionSession::SetISO iso value: %{public}d", iso);
235     auto inputDevice = GetInputDevice();
236     CHECK_ERROR_RETURN_RET_LOG(!inputDevice || !inputDevice->GetCameraDeviceInfo(),
237         CameraErrorCode::SUCCESS, "ProfessionSession::SetISO camera device is null");
238 
239     std::vector<int32_t> isoRange;
240     CHECK_ERROR_RETURN_RET_LOG((GetIsoRange(isoRange) != CameraErrorCode::SUCCESS) && isoRange.empty(),
241         CameraErrorCode::OPERATION_NOT_ALLOWED, "ProfessionSession::SetISO range is empty");
242 
243     const int32_t autoIsoValue = 0;
244     if (iso != autoIsoValue && std::find(isoRange.begin(), isoRange.end(), iso) == isoRange.end()) {
245         return CameraErrorCode::INVALID_ARGUMENT;
246     }
247     int ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_ISO_VALUE, &item);
248     if (ret == CAM_META_ITEM_NOT_FOUND) {
249         status = changedMetadata_->addEntry(OHOS_CONTROL_ISO_VALUE, &iso, count);
250     } else if (ret == CAM_META_SUCCESS) {
251         status = changedMetadata_->updateEntry(OHOS_CONTROL_ISO_VALUE, &iso, count);
252     }
253     CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetISO Failed to set exposure compensation");
254     isoValue_ = static_cast<uint32_t>(iso);
255     return CameraErrorCode::SUCCESS;
256 }
257 
GetISO(int32_t & iso)258 int32_t ProfessionSession::GetISO(int32_t &iso)
259 {
260     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
261         "ProfessionSession::GetISO Session is not Commited");
262     auto inputDevice = GetInputDevice();
263     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::INVALID_ARGUMENT,
264         "ProfessionSession::GetISO camera device is null");
265     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
266     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
267         "ProfessionSession::GetISO camera deviceInfo is null");
268     std::shared_ptr<OHOS::Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
269     camera_metadata_item_t item;
270     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_ISO_VALUE, &item);
271     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::INVALID_ARGUMENT,
272         "ProfessionSession::GetISO Failed with return code %{public}d", ret);
273     iso = item.data.i32[0];
274     MEDIA_DEBUG_LOG("iso: %{public}d", iso);
275     return CameraErrorCode::SUCCESS;
276 }
277 
IsManualIsoSupported()278 bool ProfessionSession::IsManualIsoSupported()
279 {
280     CAMERA_SYNC_TRACE;
281     MEDIA_DEBUG_LOG("Enter IsManualIsoSupported");
282 
283     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), false,
284         "ProfessionSession::IsManualIsoSupported Session is not Commited");
285 
286     auto inputDevice = GetInputDevice();
287     CHECK_ERROR_RETURN_RET_LOG(inputDevice == nullptr, false,
288         "ProfessionSession::IsManualIsoSupported camera device is null");
289 
290     auto deviceInfo = inputDevice->GetCameraDeviceInfo();
291     CHECK_ERROR_RETURN_RET_LOG(deviceInfo == nullptr, false,
292         "ProfessionSession::IsManualIsoSupported camera deviceInfo is null");
293     std::shared_ptr<Camera::CameraMetadata> metadata = deviceInfo->GetMetadata();
294     camera_metadata_item_t item;
295     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_ISO_VALUES, &item);
296     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS || item.count == 0, false,
297         "ProfessionSession::IsMacroSupported Failed with return code %{public}d", ret);
298     return true;
299 }
300 
301 // focus mode
GetSupportedFocusModes(std::vector<FocusMode> & supportedFocusModes)302 int32_t ProfessionSession::GetSupportedFocusModes(std::vector<FocusMode> &supportedFocusModes)
303 {
304     supportedFocusModes.clear();
305     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
306         "ProfessionSession::GetSupportedFocusModes Session is not Commited");
307 
308     auto inputDevice = GetInputDevice();
309     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
310         "ProfessionSession::GetSupportedFocusModes camera device is null");
311     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
312     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
313         "ProfessionSession::GetSupportedFocusModes camera deviceInfo is null");
314     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
315     camera_metadata_item_t item;
316     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FOCUS_MODES, &item);
317     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
318         "ProfessionSession::GetSupportedFocusModes Failed with return code %{public}d", ret);
319     for (uint32_t i = 0; i < item.count; i++) {
320         auto itr = g_metaFocusModeMap_.find(static_cast<camera_focus_mode_enum_t>(item.data.u8[i]));
321         if (itr != g_metaFocusModeMap_.end()) {
322             supportedFocusModes.emplace_back(itr->second);
323         }
324     }
325     return CameraErrorCode::SUCCESS;
326 }
327 
IsFocusModeSupported(FocusMode focusMode,bool & isSupported)328 int32_t ProfessionSession::IsFocusModeSupported(FocusMode focusMode, bool &isSupported)
329 {
330     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
331         "ProfessionSession::IsFocusModeSupported Session is not Commited");
332     std::vector<FocusMode> vecSupportedMeteringModeList;
333     (void)(this->GetSupportedFocusModes(vecSupportedMeteringModeList));
334     if (find(vecSupportedMeteringModeList.begin(), vecSupportedMeteringModeList.end(),
335         focusMode) != vecSupportedMeteringModeList.end()) {
336         isSupported = true;
337         return CameraErrorCode::SUCCESS;
338     }
339     isSupported = false;
340     return CameraErrorCode::SUCCESS;
341 }
342 
SetFocusMode(FocusMode focusMode)343 int32_t ProfessionSession::SetFocusMode(FocusMode focusMode)
344 {
345     CAMERA_SYNC_TRACE;
346     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
347         "ProfessionSession::SetFocusMode Session is not Commited");
348     CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
349         "ProfessionSession::SetFocusMode Need to call LockForControl() before setting camera properties");
350     uint8_t focus = FOCUS_MODE_LOCKED;
351     auto itr = g_fwkFocusModeMap_.find(focusMode);
352     if (itr == g_fwkFocusModeMap_.end()) {
353         MEDIA_ERR_LOG("ProfessionSession::SetFocusMode Unknown exposure mode");
354     } else {
355         focus = itr->second;
356     }
357     bool status = false;
358     int32_t ret;
359     uint32_t count = 1;
360     camera_metadata_item_t item;
361 
362     MEDIA_DEBUG_LOG("ProfessionSession::SetFocusMode Focus mode: %{public}d", focusMode);
363 
364     ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_FOCUS_MODE, &item);
365     if (ret == CAM_META_ITEM_NOT_FOUND) {
366         status = changedMetadata_->addEntry(OHOS_CONTROL_FOCUS_MODE, &focus, count);
367     } else if (ret == CAM_META_SUCCESS) {
368         status = changedMetadata_->updateEntry(OHOS_CONTROL_FOCUS_MODE, &focus, count);
369     }
370     CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetFocusMode Failed to set focus mode");
371     return CameraErrorCode::SUCCESS;
372 }
373 
GetFocusMode(FocusMode & focusMode)374 int32_t ProfessionSession::GetFocusMode(FocusMode &focusMode)
375 {
376     focusMode = FOCUS_MODE_MANUAL;
377     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
378         "ProfessionSession::GetFocusMode Session is not Commited");
379     auto inputDevice = GetInputDevice();
380     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
381         "ProfessionSession::GetFocusMode camera device is null");
382     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
383     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
384         "ProfessionSession::GetFocusMode camera deviceInfo is null");
385     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
386     camera_metadata_item_t item;
387     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_FOCUS_MODE, &item);
388     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
389         "ProfessionSession::GetFocusMode Failed with return code %{public}d", ret);
390     auto itr = g_metaFocusModeMap_.find(static_cast<camera_focus_mode_enum_t>(item.data.u8[0]));
391     if (itr != g_metaFocusModeMap_.end()) {
392         focusMode = itr->second;
393         return CameraErrorCode::SUCCESS;
394     }
395     return CameraErrorCode::SUCCESS;
396 }
397 
398 // Exposure Hint
GetSupportedExposureHintModes(std::vector<ExposureHintMode> & supportedExposureHintModes)399 int32_t ProfessionSession::GetSupportedExposureHintModes(std::vector<ExposureHintMode> &supportedExposureHintModes)
400 {
401     supportedExposureHintModes.clear();
402     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
403         "ProfessionSession::GetSupportedExposureHintModes Session is not Commited");
404     auto inputDevice = GetInputDevice();
405     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
406         "ProfessionSession::GetSupportedExposureHintModes camera device is null");
407     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
408     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
409         "ProfessionSession::GetSupportedExposureHintModes camera deviceInfo is null");
410     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
411     camera_metadata_item_t item;
412     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_EXPOSURE_HINT_SUPPORTED, &item);
413     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
414         "ProfessionSession::GetSupportedExposureHintModes Failed with return code %{public}d", ret);
415     for (uint32_t i = 0; i < item.count; i++) {
416         auto itr = metaExposureHintModeMap_.find(static_cast<camera_exposure_hint_mode_enum_t>(item.data.u8[i]));
417         if (itr != metaExposureHintModeMap_.end()) {
418             supportedExposureHintModes.emplace_back(itr->second);
419         }
420     }
421     return CameraErrorCode::SUCCESS;
422 }
423 
SetExposureHintMode(ExposureHintMode mode)424 int32_t ProfessionSession::SetExposureHintMode(ExposureHintMode mode)
425 {
426     CAMERA_SYNC_TRACE;
427     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
428         "ProfessionSession::SetExposureHintMode Session is not Commited");
429     CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
430         "ProfessionSession::SetExposureHintMode Need to call LockForControl() before setting camera properties");
431     uint8_t exposureHintMode = OHOS_CAMERA_EXPOSURE_HINT_UNSUPPORTED;
432     auto itr = fwkExposureHintModeMap_.find(mode);
433     if (itr == fwkExposureHintModeMap_.end()) {
434         MEDIA_ERR_LOG("ProfessionSession::SetExposureHintMode Unknown mode");
435     } else {
436         exposureHintMode = itr->second;
437     }
438     bool status = false;
439     int32_t ret;
440     uint32_t count = 1;
441     camera_metadata_item_t item;
442     MEDIA_DEBUG_LOG("ProfessionSession::SetExposureHintMode ExposureHint mode: %{public}d", exposureHintMode);
443 
444     ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_EXPOSURE_HINT_MODE, &item);
445     if (ret == CAM_META_ITEM_NOT_FOUND) {
446         status = changedMetadata_->addEntry(OHOS_CONTROL_EXPOSURE_HINT_MODE, &exposureHintMode, count);
447     } else if (ret == CAM_META_SUCCESS) {
448         status = changedMetadata_->updateEntry(OHOS_CONTROL_EXPOSURE_HINT_MODE, &exposureHintMode, count);
449     }
450     CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetExposureHintMode Failed to set ExposureHint mode");
451     return CameraErrorCode::SUCCESS;
452 }
453 
GetExposureHintMode(ExposureHintMode & mode)454 int32_t ProfessionSession::GetExposureHintMode(ExposureHintMode &mode)
455 {
456     mode = EXPOSURE_HINT_UNSUPPORTED;
457     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
458         "ProfessionSession::GetExposureHintMode Session is not Commited");
459     auto inputDevice = GetInputDevice();
460     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
461         "ProfessionSession::GetExposureHintMode camera device is null");
462     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
463     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
464         "ProfessionSession::GetExposureHintMode camera deviceInfo is null");
465     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
466     camera_metadata_item_t item;
467     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_EXPOSURE_HINT_MODE, &item);
468     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
469         "ProfessionSession::GetExposureHintMode Failed with return code %{public}d", ret);
470     auto itr = metaExposureHintModeMap_.find(static_cast<camera_exposure_hint_mode_enum_t>(item.data.u8[0]));
471     if (itr != metaExposureHintModeMap_.end()) {
472         mode = itr->second;
473         return CameraErrorCode::SUCCESS;
474     }
475     return CameraErrorCode::SUCCESS;
476 }
477 // Focus Flash Assist
GetSupportedFocusAssistFlashModes(std::vector<FocusAssistFlashMode> & supportedFocusAssistFlashModes)478 int32_t ProfessionSession::GetSupportedFocusAssistFlashModes(
479     std::vector<FocusAssistFlashMode> &supportedFocusAssistFlashModes)
480 {
481     supportedFocusAssistFlashModes.clear();
482     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
483         "ProfessionSession::GetSupportedFocusAssistFlashModes Session is not Commited");
484     auto inputDevice = GetInputDevice();
485     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
486         "ProfessionSession::GetSupportedFocusAssistFlashModes camera device is null");
487     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
488     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
489         "ProfessionSession::GetSupportedFocusAssistFlashModes camera deviceInfo is null");
490     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
491     camera_metadata_item_t item;
492     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FOCUS_ASSIST_FLASH_SUPPORTED_MODES, &item);
493     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
494         "ProfessionSession::GetSupportedFocusAssistFlashModes Failed with return code %{public}d", ret);
495     for (uint32_t i = 0; i < item.count; i++) {
496         auto itr = metaFocusAssistFlashModeMap_.find(
497             static_cast<camera_focus_assist_flash_mode_enum_t>(item.data.u8[i]));
498         if (itr != metaFocusAssistFlashModeMap_.end()) {
499             supportedFocusAssistFlashModes.emplace_back(itr->second);
500         }
501     }
502     return CameraErrorCode::SUCCESS;
503 }
504 
IsFocusAssistFlashModeSupported(FocusAssistFlashMode mode,bool & isSupported)505 int32_t ProfessionSession::IsFocusAssistFlashModeSupported(FocusAssistFlashMode mode, bool &isSupported)
506 {
507     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
508         "ProfessionSession::IsFocusAssistFlashModeSupported Session is not Commited");
509     std::vector<FocusAssistFlashMode> vecSupportedFocusAssistFlashModeList;
510     (void)this->GetSupportedFocusAssistFlashModes(vecSupportedFocusAssistFlashModeList);
511     if (find(vecSupportedFocusAssistFlashModeList.begin(), vecSupportedFocusAssistFlashModeList.end(),
512         mode) != vecSupportedFocusAssistFlashModeList.end()) {
513         isSupported = true;
514         return CameraErrorCode::SUCCESS;
515     }
516     isSupported = false;
517     return CameraErrorCode::SUCCESS;
518 }
519 
SetFocusAssistFlashMode(FocusAssistFlashMode mode)520 int32_t ProfessionSession::SetFocusAssistFlashMode(FocusAssistFlashMode mode)
521 {
522     CAMERA_SYNC_TRACE;
523     MEDIA_DEBUG_LOG("ProfessionSession::SetFocusAssistFlashMode app mode: %{public}d", static_cast<int32_t>(mode));
524     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
525         "ProfessionSession::IsFocusAssistFlashModeSupported Session is not Commited");
526     CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
527         "ProfessionSession::IsFocusAssistFlashModeSupported Need to call LockForControl "
528         "before setting camera properties");
529     uint8_t value = OHOS_CAMERA_FOCUS_ASSIST_FLASH_MODE_DEFAULT;
530     auto itr = fwkFocusAssistFlashModeMap_.find(mode);
531     if (itr == fwkFocusAssistFlashModeMap_.end()) {
532         MEDIA_ERR_LOG("ProfessionSession::SetFocusAssistFlashMode Unknown exposure mode");
533     } else {
534         value = itr->second;
535     }
536     bool status = false;
537     int32_t ret;
538     uint32_t count = 1;
539     camera_metadata_item_t item;
540     MEDIA_DEBUG_LOG("ProfessionSession::SetFocusAssistFlashMode FocusAssistFlash mode: %{public}d", value);
541     ret = Camera::FindCameraMetadataItem(
542         changedMetadata_->get(), OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &item);
543     if (ret == CAM_META_ITEM_NOT_FOUND) {
544         status = changedMetadata_->addEntry(OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &value, count);
545     } else if (ret == CAM_META_SUCCESS) {
546         status = changedMetadata_->updateEntry(OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &value, count);
547     }
548     CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetFocusAssistFlashMode Failed to set FocusAssistFlash mode");
549     return CameraErrorCode::SUCCESS;
550 }
551 
GetFocusAssistFlashMode(FocusAssistFlashMode & mode)552 int32_t ProfessionSession::GetFocusAssistFlashMode(FocusAssistFlashMode &mode)
553 {
554     mode = FOCUS_ASSIST_FLASH_MODE_DEFAULT;
555     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
556         "ProfessionSession::GetFocusAssistFlashMode Session is not Commited");
557     auto inputDevice = GetInputDevice();
558     CHECK_ERROR_RETURN_RET_LOG(!inputDevice, CameraErrorCode::SUCCESS,
559         "ProfessionSession::GetFocusAssistFlashMode camera device is null");
560     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
561     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
562         "ProfessionSession::GetFocusAssistFlashMode camera deviceInfo is null");
563     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
564     camera_metadata_item_t item;
565     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, &item);
566     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
567         "ProfessionSession::GetFocusAssistFlashMode Failed with return code %{public}d", ret);
568     auto itr = metaFocusAssistFlashModeMap_.find(static_cast<camera_focus_assist_flash_mode_enum_t>(item.data.u8[0]));
569     if (itr != metaFocusAssistFlashModeMap_.end()) {
570         mode = itr->second;
571         return CameraErrorCode::SUCCESS;
572     }
573     return CameraErrorCode::SUCCESS;
574 }
575 
576 // flash mode
GetSupportedFlashModes(std::vector<FlashMode> & supportedFlashModes)577 int32_t ProfessionSession::GetSupportedFlashModes(std::vector<FlashMode> &supportedFlashModes)
578 {
579     supportedFlashModes.clear();
580     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
581         "ProfessionSession::GetSupportedFlashModes Session is not Commited");
582     auto inputDevice = GetInputDevice();
583     CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
584         CameraErrorCode::SUCCESS, "ProfessionSession::GetSupportedFlashModes camera device is null");
585     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
586     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
587         "ProfessionSession::GetSupportedFlashModes camera deviceInfo is null");
588     auto metadata = isRawImageDelivery_ ? GetMetadata() : inputDeviceInfo->GetMetadata();
589     camera_metadata_item_t item;
590     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_FLASH_MODES, &item);
591     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
592         "ProfessionSession::GetSupportedFlashModes Failed with return code %{public}d", ret);
593     g_transformValidData(item, g_metaFlashModeMap_, supportedFlashModes);
594     return CameraErrorCode::SUCCESS;
595 }
596 
GetFlashMode(FlashMode & flashMode)597 int32_t ProfessionSession::GetFlashMode(FlashMode &flashMode)
598 {
599     flashMode = FLASH_MODE_CLOSE;
600     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
601         "ProfessionSession::GetFlashMode Session is not Commited");
602     auto inputDevice = GetInputDevice();
603     CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
604         CameraErrorCode::SUCCESS, "ProfessionSession::GetFlashMode camera device is null");
605     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
606     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
607         "ProfessionSession::GetFlashMode camera deviceInfo is null");
608     auto metadata = isRawImageDelivery_ ? GetMetadata() : inputDeviceInfo->GetMetadata();
609     camera_metadata_item_t item;
610     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_FLASH_MODE, &item);
611     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
612         "ProfessionSession::GetFlashMode Failed with return code %{public}d", ret);
613     auto itr = g_metaFlashModeMap_.find(static_cast<camera_flash_mode_enum_t>(item.data.u8[0]));
614     if (itr != g_metaFlashModeMap_.end()) {
615         flashMode = itr->second;
616         return CameraErrorCode::SUCCESS;
617     }
618 
619     return CameraErrorCode::SUCCESS;
620 }
621 
SetFlashMode(FlashMode flashMode)622 int32_t ProfessionSession::SetFlashMode(FlashMode flashMode)
623 {
624     CAMERA_SYNC_TRACE;
625     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
626         "ProfessionSession::SetFlashMode Session is not Commited");
627     CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
628         "ProfessionSession::SetFlashMode Need to call LockForControl() before setting camera properties");
629     MEDIA_INFO_LOG("ProfessionSession::SetFlashMode flashMode:%{public}d", flashMode);
630     uint8_t flash = g_fwkFlashModeMap_.at(FLASH_MODE_CLOSE);
631     auto itr = g_fwkFlashModeMap_.find(flashMode);
632     if (itr == g_fwkFlashModeMap_.end()) {
633         MEDIA_ERR_LOG("ProfessionSession::SetFlashMode Unknown exposure mode");
634     } else {
635         flash = itr->second;
636     }
637     bool status = AddOrUpdateMetadata(changedMetadata_, OHOS_CONTROL_FLASH_MODE, &flash, 1);
638     CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetFlashMode Failed to set flash mode");
639     return CameraErrorCode::SUCCESS;
640 }
641 
IsFlashModeSupported(FlashMode flashMode,bool & isSupported)642 int32_t ProfessionSession::IsFlashModeSupported(FlashMode flashMode, bool &isSupported)
643 {
644     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
645         "ProfessionSession::IsFlashModeSupported Session is not Commited");
646     std::vector<FlashMode> vecSupportedFlashModeList;
647     (void)this->GetSupportedFlashModes(vecSupportedFlashModeList);
648     if (find(vecSupportedFlashModeList.begin(), vecSupportedFlashModeList.end(), flashMode) !=
649         vecSupportedFlashModeList.end()) {
650         isSupported = true;
651         return CameraErrorCode::SUCCESS;
652     }
653     isSupported = false;
654     return CameraErrorCode::SUCCESS;
655 }
656 
HasFlash(bool & hasFlash)657 int32_t ProfessionSession::HasFlash(bool &hasFlash)
658 {
659     hasFlash = false;
660     CHECK_ERROR_RETURN_RET_LOG(!IsSessionCommited(), CameraErrorCode::SESSION_NOT_CONFIG,
661         "ProfessionSession::HasFlash Session is not Commited");
662     std::vector<FlashMode> supportedFlashModeList;
663     GetSupportedFlashModes(supportedFlashModeList);
664     bool onlyHasCloseMode = supportedFlashModeList.size() == 1 && supportedFlashModeList[0] == FLASH_MODE_CLOSE;
665     if (!supportedFlashModeList.empty() && !onlyHasCloseMode) {
666         hasFlash = true;
667     }
668     return CameraErrorCode::SUCCESS;
669 }
670 // XMAGE
671 
GetSupportedColorEffects(std::vector<ColorEffect> & supportedColorEffects)672 int32_t ProfessionSession::GetSupportedColorEffects(std::vector<ColorEffect>& supportedColorEffects)
673 {
674     supportedColorEffects.clear();
675     CHECK_ERROR_RETURN_RET_LOG(!(IsSessionCommited() || IsSessionConfiged()), CameraErrorCode::SESSION_NOT_CONFIG,
676         "ProfessionSession::GetSupportedColorEffects Session is not Commited");
677     auto inputDevice = GetInputDevice();
678     CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
679         CameraErrorCode::SUCCESS, "ProfessionSession::GetSupportedColorEffects camera device is null");
680     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
681     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
682         "ProfessionSession::GetSupportedColorEffects camera deviceInfo is null");
683     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
684     camera_metadata_item_t item;
685     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_SUPPORTED_COLOR_MODES, &item);
686     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS, CameraErrorCode::SUCCESS,
687         "ProfessionSession::GetSupportedColorEffects Failed with return code %{public}d", ret);
688     for (uint32_t i = 0; i < item.count; i++) {
689         auto itr = g_metaColorEffectMap_.find(static_cast<camera_xmage_color_type_t>(item.data.u8[i]));
690         if (itr != g_metaColorEffectMap_.end()) {
691             supportedColorEffects.emplace_back(itr->second);
692         }
693     }
694     return CameraErrorCode::SUCCESS;
695 }
696 
GetColorEffect(ColorEffect & colorEffect)697 int32_t ProfessionSession::GetColorEffect(ColorEffect& colorEffect)
698 {
699     colorEffect = ColorEffect::COLOR_EFFECT_NORMAL;
700     CHECK_ERROR_RETURN_RET_LOG(!(IsSessionCommited() || IsSessionConfiged()), CameraErrorCode::SESSION_NOT_CONFIG,
701         "ProfessionSession::GetColorEffect Session is not Commited");
702     auto inputDevice = GetInputDevice();
703     CHECK_ERROR_RETURN_RET_LOG(!inputDevice,
704         CameraErrorCode::SUCCESS, "ProfessionSession::GetColorEffect camera device is null");
705     auto inputDeviceInfo = inputDevice->GetCameraDeviceInfo();
706     CHECK_ERROR_RETURN_RET_LOG(!inputDeviceInfo, CameraErrorCode::SUCCESS,
707         "ProfessionSession::GetColorEffect camera deviceInfo is null");
708     std::shared_ptr<Camera::CameraMetadata> metadata = inputDeviceInfo->GetMetadata();
709     camera_metadata_item_t item;
710     int ret = Camera::FindCameraMetadataItem(metadata->get(), OHOS_CONTROL_SUPPORTED_COLOR_MODES, &item);
711     CHECK_ERROR_RETURN_RET_LOG(ret != CAM_META_SUCCESS || item.count == 0, CameraErrorCode::SUCCESS,
712         "ProfessionSession::GetColorEffect Failed with return code %{public}d", ret);
713     auto itr = g_metaColorEffectMap_.find(static_cast<camera_xmage_color_type_t>(item.data.u8[0]));
714     if (itr != g_metaColorEffectMap_.end()) {
715         colorEffect = itr->second;
716     }
717     return CameraErrorCode::SUCCESS;
718 }
719 
SetColorEffect(ColorEffect colorEffect)720 int32_t ProfessionSession::SetColorEffect(ColorEffect colorEffect)
721 {
722     CAMERA_SYNC_TRACE;
723     CHECK_ERROR_RETURN_RET_LOG(!(IsSessionCommited() || IsSessionConfiged()), CameraErrorCode::SESSION_NOT_CONFIG,
724         "ProfessionSession::GetColorEffect Session is not Commited");
725     CHECK_ERROR_RETURN_RET_LOG(changedMetadata_ == nullptr, CameraErrorCode::SUCCESS,
726         "ProfessionSession::SetFlashMode Need to call LockForControl() before setting camera properties");
727     uint8_t colorEffectTemp = ColorEffect::COLOR_EFFECT_NORMAL;
728     auto itr = g_fwkColorEffectMap_.find(colorEffect);
729     if (itr == g_fwkColorEffectMap_.end()) {
730         MEDIA_ERR_LOG("ProfessionSession::SetColorEffect unknown is color effect");
731     } else {
732         colorEffectTemp = itr->second;
733     }
734     MEDIA_DEBUG_LOG("ProfessionSession::SetColorEffect: %{public}d", colorEffect);
735 
736     bool status = false;
737     int32_t ret;
738     uint32_t count = 1;
739     camera_metadata_item_t item;
740     ret = Camera::FindCameraMetadataItem(changedMetadata_->get(), OHOS_CONTROL_SUPPORTED_COLOR_MODES, &item);
741     if (ret == CAM_META_ITEM_NOT_FOUND) {
742         status = changedMetadata_->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &colorEffectTemp, count);
743     } else if (ret == CAM_META_SUCCESS) {
744         status = changedMetadata_->updateEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &colorEffectTemp, count);
745     }
746     CHECK_ERROR_PRINT_LOG(!status, "ProfessionSession::SetColorEffect Failed to set color effect");
747     return CameraErrorCode::SUCCESS;
748 }
749 
CanAddOutput(sptr<CaptureOutput> & output)750 bool ProfessionSession::CanAddOutput(sptr<CaptureOutput> &output)
751 {
752     CAMERA_SYNC_TRACE;
753     MEDIA_DEBUG_LOG("Enter Into ProfessionSession::CanAddOutput");
754     CHECK_ERROR_RETURN_RET_LOG(!IsSessionConfiged() || output == nullptr, false,
755         "ProfessionSession::CanAddOutput operation is Not allowed!");
756     return CaptureSession::CanAddOutput(output);
757 }
758 
759 //callbacks
SetExposureInfoCallback(std::shared_ptr<ExposureInfoCallback> callback)760 void ProfessionSession::SetExposureInfoCallback(std::shared_ptr<ExposureInfoCallback> callback)
761 {
762     std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
763     exposureInfoCallback_ = callback;
764 }
765 
SetIsoInfoCallback(std::shared_ptr<IsoInfoCallback> callback)766 void ProfessionSession::SetIsoInfoCallback(std::shared_ptr<IsoInfoCallback> callback)
767 {
768     std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
769     isoInfoCallback_ = callback;
770 }
771 
SetApertureInfoCallback(std::shared_ptr<ApertureInfoCallback> callback)772 void ProfessionSession::SetApertureInfoCallback(std::shared_ptr<ApertureInfoCallback> callback)
773 {
774     std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
775     apertureInfoCallback_ = callback;
776 }
777 
SetLuminationInfoCallback(std::shared_ptr<LuminationInfoCallback> callback)778 void ProfessionSession::SetLuminationInfoCallback(std::shared_ptr<LuminationInfoCallback> callback)
779 {
780     std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
781     luminationInfoCallback_ = callback;
782 }
783 
ProcessSensorExposureTimeChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)784 void ProfessionSession::ProcessSensorExposureTimeChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
785 {
786     camera_metadata_item_t item;
787     common_metadata_header_t* metadata = result->get();
788     int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_SENSOR_EXPOSURE_TIME, &item);
789     if (ret == CAM_META_SUCCESS) {
790         int32_t numerator = item.data.r->numerator;
791         int32_t denominator = item.data.r->denominator;
792         MEDIA_DEBUG_LOG("SensorExposureTime: %{public}d/%{public}d", numerator, denominator);
793         CHECK_ERROR_RETURN_LOG(denominator == 0, "ProcessSensorExposureTimeChange error! divide by zero");
794         constexpr int32_t timeUnit = 1000000;
795         uint32_t value = static_cast<uint32_t>(numerator / (denominator / timeUnit));
796         MEDIA_DEBUG_LOG("SensorExposureTime: %{public}d", value);
797         ExposureInfo info = {
798             .exposureDurationValue = value,
799         };
800         std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
801         if (exposureInfoCallback_ != nullptr && (value != exposureDurationValue_)) {
802             if (exposureDurationValue_ != 0) {
803                 exposureInfoCallback_->OnExposureInfoChanged(info);
804             }
805             exposureDurationValue_ = value;
806         }
807     }
808 }
809 
ProcessIsoChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)810 void ProfessionSession::ProcessIsoChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
811 {
812     camera_metadata_item_t item;
813     common_metadata_header_t* metadata = result->get();
814     int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_ISO_VALUE, &item);
815     if (ret == CAM_META_SUCCESS) {
816         MEDIA_DEBUG_LOG("Iso Value: %{public}d", item.data.ui32[0]);
817         IsoInfo info = {
818             .isoValue = item.data.ui32[0],
819         };
820         std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
821         if (isoInfoCallback_ != nullptr && item.data.ui32[0] != isoValue_) {
822             if (isoValue_ != 0) {
823                 isoInfoCallback_->OnIsoInfoChanged(info);
824             }
825             isoValue_ = item.data.ui32[0];
826         }
827     }
828 }
829 
ProcessApertureChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)830 void ProfessionSession::ProcessApertureChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
831 {
832     camera_metadata_item_t item;
833     common_metadata_header_t* metadata = result->get();
834     int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_CAMERA_APERTURE_VALUE, &item);
835     if (ret == CAM_META_SUCCESS) {
836         MEDIA_DEBUG_LOG("aperture Value: %{public}f", ConfusingNumber(item.data.f[0]));
837         std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
838         ApertureInfo info = {
839             .apertureValue = item.data.f[0],
840         };
841         if (apertureInfoCallback_ != nullptr && (item.data.f[0] != apertureValue_ || apertureValue_ == 0)) {
842             apertureInfoCallback_->OnApertureInfoChanged(info);
843             apertureValue_ = item.data.f[0];
844         }
845     }
846 }
847 
ProcessLuminationChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)848 void ProfessionSession::ProcessLuminationChange(const std::shared_ptr<OHOS::Camera::CameraMetadata> &result)
849 {
850     constexpr float normalizedMeanValue = 255.0;
851     camera_metadata_item_t item;
852     common_metadata_header_t* metadata = result->get();
853     int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_ALGO_MEAN_Y, &item);
854     float value = item.data.ui32[0] / normalizedMeanValue;
855     if (ret == CAM_META_SUCCESS) {
856         MEDIA_DEBUG_LOG("Lumination Value: %{public}f", value);
857         LuminationInfo info = {
858             .luminationValue = value,
859         };
860         std::lock_guard<std::mutex> lock(sessionCallbackMutex_);
861         if (luminationInfoCallback_ != nullptr && value != luminationValue_) {
862             luminationInfoCallback_->OnLuminationInfoChanged(info);
863             luminationValue_ = value;
864         }
865     }
866 }
867 
ProcessPhysicalCameraSwitch(const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)868 void ProfessionSession::ProcessPhysicalCameraSwitch(const std::shared_ptr<OHOS::Camera::CameraMetadata>& result)
869 {
870     camera_metadata_item_t item;
871     common_metadata_header_t* metadata = result->get();
872     int ret = Camera::FindCameraMetadataItem(metadata, OHOS_STATUS_PREVIEW_PHYSICAL_CAMERA_ID, &item);
873     CHECK_ERROR_RETURN(ret != CAM_META_SUCCESS);
874     if (physicalCameraId_ != item.data.u8[0]) {
875         MEDIA_DEBUG_LOG("physicalCameraId: %{public}d", item.data.u8[0]);
876         physicalCameraId_ = item.data.u8[0];
877         ExecuteAbilityChangeCallback();
878     }
879 }
880 
GetMetadata()881 std::shared_ptr<OHOS::Camera::CameraMetadata> ProfessionSession::GetMetadata()
882 {
883     std::string phyCameraId = std::to_string(physicalCameraId_.load());
884     auto physicalCameraDevice =
885         std::find_if(supportedDevices_.begin(), supportedDevices_.end(), [phyCameraId](const auto& device) -> bool {
886             std::string cameraId = device->GetID();
887             size_t delimPos = cameraId.find("/");
888             CHECK_ERROR_RETURN_RET(delimPos == std::string::npos, false);
889             string id = cameraId.substr(delimPos + 1);
890             return id.compare(phyCameraId) == 0;
891         });
892     // DELIVERY_PHOTO for default when commit
893     if (physicalCameraDevice != supportedDevices_.end()) {
894         MEDIA_DEBUG_LOG("ProfessionSession::GetMetadata physicalCameraId: device/%{public}s", phyCameraId.c_str());
895         if ((*physicalCameraDevice)->GetCameraType() == CAMERA_TYPE_WIDE_ANGLE && !isRawImageDelivery_) {
896             auto inputDevice = GetInputDevice();
897             CHECK_ERROR_RETURN_RET(inputDevice == nullptr, nullptr);
898             auto info = inputDevice->GetCameraDeviceInfo();
899             CHECK_ERROR_RETURN_RET(info == nullptr, nullptr);
900             MEDIA_DEBUG_LOG("ProfessionSession::GetMetadata using main sensor: %{public}s", info->GetID().c_str());
901             return info->GetMetadata();
902         }
903         return (*physicalCameraDevice)->GetMetadata();
904     }
905     auto inputDevice = GetInputDevice();
906     CHECK_ERROR_RETURN_RET(inputDevice == nullptr, nullptr);
907     auto cameraObj = inputDevice->GetCameraDeviceInfo();
908     CHECK_ERROR_RETURN_RET(!cameraObj,
909                            std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH));
910     MEDIA_DEBUG_LOG("ProfessionSession::GetMetadata no physicalCamera, using current camera device:%{public}s",
911         cameraObj->GetID().c_str());
912     return cameraObj->GetMetadata();
913 }
914 
ProcessCallbacks(const uint64_t timestamp,const std::shared_ptr<OHOS::Camera::CameraMetadata> & result)915 void ProfessionSession::ProfessionSessionMetadataResultProcessor::ProcessCallbacks(
916     const uint64_t timestamp, const std::shared_ptr<OHOS::Camera::CameraMetadata>& result)
917 {
918     auto session = session_.promote();
919     CHECK_ERROR_RETURN_LOG(session == nullptr,
920         "CaptureSession::ProfessionSessionMetadataResultProcessor ProcessCallbacks but session is null");
921 
922     session->ProcessAutoFocusUpdates(result);
923     session->ProcessSensorExposureTimeChange(result);
924     session->ProcessIsoChange(result);
925     session->ProcessApertureChange(result);
926     session->ProcessLuminationChange(result);
927     session->ProcessPhysicalCameraSwitch(result);
928 }
929 } // CameraStandard
930 } // OHOS
931