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