1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "camera_manager_impl.h"
17 #include "camera_log.h"
18 #include "camera_util.h"
19 #include "surface_utils.h"
20 #include "image_receiver.h"
21
22 using namespace std;
23 using namespace OHOS;
24 using namespace OHOS::CameraStandard;
25 const char* DEFAULT_SURFACEID = "photoOutput";
26 thread_local OHOS::sptr<OHOS::Surface> Camera_Manager::photoSurface_ = nullptr;
27 const std::unordered_map<SceneMode, Camera_SceneMode> g_fwModeToNdk_ = {
28 {SceneMode::CAPTURE, Camera_SceneMode::NORMAL_PHOTO},
29 {SceneMode::VIDEO, Camera_SceneMode::NORMAL_VIDEO},
30 {SceneMode::SECURE, Camera_SceneMode::SECURE_PHOTO},
31 };
32 const std::unordered_map<Camera_SceneMode, SceneMode> g_ndkToFwMode_ = {
33 {Camera_SceneMode::NORMAL_PHOTO, SceneMode::CAPTURE},
34 {Camera_SceneMode::NORMAL_VIDEO, SceneMode::VIDEO},
35 {Camera_SceneMode::SECURE_PHOTO, SceneMode::SECURE},
36 };
37 const std::unordered_map<CameraPosition, Camera_Position> g_FwkCameraPositionToNdk_ = {
38 {CameraPosition::CAMERA_POSITION_UNSPECIFIED, Camera_Position::CAMERA_POSITION_UNSPECIFIED},
39 {CameraPosition::CAMERA_POSITION_BACK, Camera_Position::CAMERA_POSITION_BACK},
40 {CameraPosition::CAMERA_POSITION_FRONT, Camera_Position::CAMERA_POSITION_FRONT},
41 };
42 const std::unordered_map<Camera_Position, CameraPosition> g_NdkCameraPositionToFwk_ = {
43 {Camera_Position::CAMERA_POSITION_UNSPECIFIED, CameraPosition::CAMERA_POSITION_UNSPECIFIED},
44 {Camera_Position::CAMERA_POSITION_BACK, CameraPosition::CAMERA_POSITION_BACK},
45 {Camera_Position::CAMERA_POSITION_FRONT, CameraPosition::CAMERA_POSITION_FRONT},
46 };
47 const std::unordered_map<Camera_TorchMode, TorchMode> g_ndkToFwTorchMode_ = {
48 {Camera_TorchMode::OFF, TorchMode::TORCH_MODE_OFF},
49 {Camera_TorchMode::ON, TorchMode::TORCH_MODE_ON},
50 {Camera_TorchMode::AUTO, TorchMode::TORCH_MODE_AUTO}
51 };
52
53 class InnerCameraManagerCallback : public CameraManagerCallback {
54 public:
InnerCameraManagerCallback(Camera_Manager * cameraManager,CameraManager_Callbacks * callback)55 InnerCameraManagerCallback(Camera_Manager* cameraManager, CameraManager_Callbacks* callback)
56 : cameraManager_(cameraManager), callback_(*callback) {}
~InnerCameraManagerCallback()57 ~InnerCameraManagerCallback() {}
58
OnCameraStatusChanged(const CameraStatusInfo & cameraStatusInfo) const59 void OnCameraStatusChanged(const CameraStatusInfo &cameraStatusInfo) const override
60 {
61 MEDIA_DEBUG_LOG("OnCameraStatusChanged is called!");
62 Camera_StatusInfo statusInfo;
63 Camera_Device cameraDevice;
64 statusInfo.camera = &cameraDevice;
65 string cameraId = cameraStatusInfo.cameraDevice->GetID();
66 statusInfo.camera->cameraId = cameraId.data();
67 MEDIA_INFO_LOG("cameraId is %{public}s", statusInfo.camera->cameraId);
68 statusInfo.camera->cameraPosition = static_cast<Camera_Position>(cameraStatusInfo.cameraDevice->GetPosition());
69 statusInfo.camera->cameraType = static_cast<Camera_Type>(cameraStatusInfo.cameraDevice->GetCameraType());
70 statusInfo.camera->connectionType =
71 static_cast<Camera_Connection>(cameraStatusInfo.cameraDevice->GetConnectionType());
72 statusInfo.status = static_cast<Camera_Status>(cameraStatusInfo.cameraStatus);
73 if (cameraManager_ != nullptr && callback_.onCameraStatus != nullptr) {
74 callback_.onCameraStatus(cameraManager_, &statusInfo);
75 }
76 }
77
OnFlashlightStatusChanged(const std::string & cameraID,const FlashStatus flashStatus) const78 void OnFlashlightStatusChanged(const std::string &cameraID, const FlashStatus flashStatus) const override
79 {
80 MEDIA_DEBUG_LOG("OnFlashlightStatusChanged is called!");
81 (void)cameraID;
82 (void)flashStatus;
83 }
84
85 private:
86 Camera_Manager* cameraManager_;
87 CameraManager_Callbacks callback_;
88 };
89
90 class InnerCameraManagerTorchStatusCallback : public TorchListener {
91 public:
InnerCameraManagerTorchStatusCallback(Camera_Manager * cameraManager,OH_CameraManager_TorchStatusCallback torchStatusCallback)92 InnerCameraManagerTorchStatusCallback(Camera_Manager* cameraManager,
93 OH_CameraManager_TorchStatusCallback torchStatusCallback)
94 : cameraManager_(cameraManager), torchStatusCallback_(torchStatusCallback) {};
95 ~InnerCameraManagerTorchStatusCallback() = default;
96
OnTorchStatusChange(const TorchStatusInfo & torchStatusInfo) const97 void OnTorchStatusChange(const TorchStatusInfo &torchStatusInfo) const override
98 {
99 MEDIA_DEBUG_LOG("OnTorchStatusChange is called!");
100 if (cameraManager_ != nullptr && torchStatusCallback_ != nullptr) {
101 Camera_TorchStatusInfo statusInfo;
102 statusInfo.isTorchAvailable = torchStatusInfo.isTorchAvailable;
103 statusInfo.isTorchActive = torchStatusInfo.isTorchActive;
104 statusInfo.torchLevel = torchStatusInfo.torchLevel;
105 torchStatusCallback_(cameraManager_, &statusInfo);
106 }
107 }
108 private:
109 Camera_Manager* cameraManager_;
110 OH_CameraManager_TorchStatusCallback torchStatusCallback_ = nullptr;
111 };
112
113 class InnerCameraManagerFoldStatusCallback : public FoldListener {
114 public:
InnerCameraManagerFoldStatusCallback(Camera_Manager * cameraManager,OH_CameraManager_OnFoldStatusInfoChange foldStatusCallback)115 InnerCameraManagerFoldStatusCallback(Camera_Manager* cameraManager,
116 OH_CameraManager_OnFoldStatusInfoChange foldStatusCallback)
117 : cameraManager_(cameraManager), foldStatusCallback_(foldStatusCallback) {};
118 ~InnerCameraManagerFoldStatusCallback() = default;
119
OnFoldStatusChanged(const FoldStatusInfo & foldStatusInfo) const120 void OnFoldStatusChanged(const FoldStatusInfo &foldStatusInfo) const override
121 {
122 MEDIA_DEBUG_LOG("OnFoldStatusChanged is called!");
123 if (cameraManager_ != nullptr && (foldStatusCallback_ != nullptr)) {
124 Camera_FoldStatusInfo statusInfo;
125 auto cameraSize = foldStatusInfo.supportedCameras.size();
126 if (cameraSize <= 0) {
127 MEDIA_ERR_LOG("Invalid size.");
128 return;
129 }
130 Camera_Device supportedCameras[cameraSize];
131 Camera_Device* supportedCamerasPtr[cameraSize];
132 uint32_t outSize = 0;
133 string cameraIds[cameraSize];
134 for (size_t index = 0; index < cameraSize; index++) {
135 Camera_Device* cameraDevice = &supportedCameras[outSize];
136 cameraDevice->cameraPosition =
137 static_cast<Camera_Position>(foldStatusInfo.supportedCameras[index]->GetPosition());
138 cameraIds[outSize] = foldStatusInfo.supportedCameras[index]->GetID();
139 cameraDevice->cameraId = cameraIds[outSize].data();
140 cameraDevice->cameraType =
141 static_cast<Camera_Type>(foldStatusInfo.supportedCameras[index]->GetCameraType());
142 cameraDevice->connectionType =
143 static_cast<Camera_Connection>(foldStatusInfo.supportedCameras[index]->GetConnectionType());
144 supportedCamerasPtr[outSize] = cameraDevice;
145 outSize++;
146 }
147 statusInfo.supportedCameras = supportedCamerasPtr;
148 statusInfo.cameraSize = outSize;
149 statusInfo.foldStatus = (Camera_FoldStatus)foldStatusInfo.foldStatus;
150 foldStatusCallback_(cameraManager_, &statusInfo);
151 }
152 }
153 private:
154 Camera_Manager* cameraManager_;
155 OH_CameraManager_OnFoldStatusInfoChange foldStatusCallback_ = nullptr;
156 };
157
Camera_Manager()158 Camera_Manager::Camera_Manager()
159 {
160 MEDIA_DEBUG_LOG("Camera_Manager Constructor is called");
161 cameraManager_ = CameraManager::GetInstance();
162 }
163
~Camera_Manager()164 Camera_Manager::~Camera_Manager()
165 {
166 MEDIA_DEBUG_LOG("~Camera_Manager is called");
167 if (cameraManager_) {
168 cameraManager_ = nullptr;
169 }
170 }
171
RegisterCallback(CameraManager_Callbacks * callback)172 Camera_ErrorCode Camera_Manager::RegisterCallback(CameraManager_Callbacks* callback)
173 {
174 shared_ptr<InnerCameraManagerCallback> innerCallback =
175 make_shared<InnerCameraManagerCallback>(this, callback);
176 cameraManager_->SetCallback(innerCallback);
177 return CAMERA_OK;
178 }
179
UnregisterCallback(CameraManager_Callbacks * callback)180 Camera_ErrorCode Camera_Manager::UnregisterCallback(CameraManager_Callbacks* callback)
181 {
182 cameraManager_->SetCallback(nullptr);
183 return CAMERA_OK;
184 }
185
RegisterTorchStatusCallback(OH_CameraManager_TorchStatusCallback torchStatusCallback)186 Camera_ErrorCode Camera_Manager::RegisterTorchStatusCallback(OH_CameraManager_TorchStatusCallback torchStatusCallback)
187 {
188 shared_ptr<InnerCameraManagerTorchStatusCallback> innerTorchStatusCallback =
189 make_shared<InnerCameraManagerTorchStatusCallback>(this, torchStatusCallback);
190 CHECK_AND_RETURN_RET_LOG(innerTorchStatusCallback != nullptr, CAMERA_SERVICE_FATAL_ERROR,
191 "create innerTorchStatusCallback failed!");
192 cameraManager_->RegisterTorchListener(innerTorchStatusCallback);
193 return CAMERA_OK;
194 }
195
UnregisterTorchStatusCallback(OH_CameraManager_TorchStatusCallback torchStatusCallback)196 Camera_ErrorCode Camera_Manager::UnregisterTorchStatusCallback(OH_CameraManager_TorchStatusCallback torchStatusCallback)
197 {
198 cameraManager_->RegisterTorchListener(nullptr);
199 return CAMERA_OK;
200 }
201
GetSupportedCameras(Camera_Device ** cameras,uint32_t * size)202 Camera_ErrorCode Camera_Manager::GetSupportedCameras(Camera_Device** cameras, uint32_t* size)
203 {
204 std::vector<sptr<CameraDevice>> cameraObjList = CameraManager::GetInstance()->GetSupportedCameras();
205 uint32_t cameraSize = cameraObjList.size();
206 uint32_t cameraMaxSize = 32;
207 CHECK_ERROR_RETURN_RET_LOG(cameraSize == 0 || cameraSize > cameraMaxSize, CAMERA_INVALID_ARGUMENT,
208 "Invalid camera size.");
209 Camera_Device* outCameras = new Camera_Device[cameraSize];
210 for (size_t index = 0; index < cameraSize; index++) {
211 const string cameraGetID = cameraObjList[index]->GetID();
212 const char* src = cameraGetID.c_str();
213 size_t dstSize = strlen(src) + 1;
214 char* dst = new char[dstSize];
215 if (!dst) {
216 MEDIA_ERR_LOG("Allocate memory for cameraId Failed!");
217 delete[] outCameras;
218 return CAMERA_SERVICE_FATAL_ERROR;
219 }
220 strlcpy(dst, src, dstSize);
221 outCameras[index].cameraId = dst;
222 outCameras[index].cameraPosition = static_cast<Camera_Position>(cameraObjList[index]->GetPosition());
223 outCameras[index].cameraType = static_cast<Camera_Type>(cameraObjList[index]->GetCameraType());
224 outCameras[index].connectionType = static_cast<Camera_Connection>(cameraObjList[index]->GetConnectionType());
225 }
226 *size = cameraSize;
227 *cameras = outCameras;
228 return CAMERA_OK;
229 }
230
DeleteSupportedCameras(Camera_Device * cameras,uint32_t size)231 Camera_ErrorCode Camera_Manager::DeleteSupportedCameras(Camera_Device* cameras, uint32_t size)
232 {
233 if (cameras != nullptr) {
234 for (size_t index = 0; index < size; index++) {
235 if (&cameras[index] != nullptr) {
236 delete[] cameras[index].cameraId;
237 }
238 }
239 delete[] cameras;
240 }
241 return CAMERA_OK;
242 }
243
GetSupportedCameraOutputCapability(const Camera_Device * camera,Camera_OutputCapability ** cameraOutputCapability)244 Camera_ErrorCode Camera_Manager::GetSupportedCameraOutputCapability(const Camera_Device* camera,
245 Camera_OutputCapability** cameraOutputCapability)
246 {
247 sptr<CameraDevice> cameraDevice = CameraManager::GetInstance()->GetCameraDeviceFromId(camera->cameraId);
248 CHECK_AND_RETURN_RET_LOG(cameraDevice != nullptr, CAMERA_INVALID_ARGUMENT,
249 "Camera_Manager::GetSupportedCameraOutputCapability get cameraDevice fail!");
250 Camera_OutputCapability* outCapability = new Camera_OutputCapability;
251 CHECK_AND_RETURN_RET_LOG(outCapability != nullptr, CAMERA_SERVICE_FATAL_ERROR,
252 "Camera_Manager::GetSupportedCameraOutputCapability failed to allocate memory for outCapability!");
253 sptr<CameraOutputCapability> innerCameraOutputCapability =
254 CameraManager::GetInstance()->GetSupportedOutputCapability(cameraDevice);
255 if (innerCameraOutputCapability == nullptr) {
256 MEDIA_ERR_LOG("Camera_Manager::GetSupportedCameraOutputCapability innerCameraOutputCapability is null!");
257 delete outCapability;
258 return CAMERA_INVALID_ARGUMENT;
259 }
260 std::vector<Profile> previewProfiles = innerCameraOutputCapability->GetPreviewProfiles();
261 std::vector<Profile> photoProfiles = innerCameraOutputCapability->GetPhotoProfiles();
262 std::vector<VideoProfile> videoProfiles = innerCameraOutputCapability->GetVideoProfiles();
263
264 std::vector<MetadataObjectType> metadataTypeList =
265 innerCameraOutputCapability->GetSupportedMetadataObjectType();
266 std::vector<Profile> uniquePreviewProfiles;
267 for (const auto& profile : previewProfiles) {
268 if (std::find(uniquePreviewProfiles.begin(), uniquePreviewProfiles.end(),
269 profile) == uniquePreviewProfiles.end()) {
270 uniquePreviewProfiles.push_back(profile);
271 }
272 }
273 GetSupportedPreviewProfiles(outCapability, uniquePreviewProfiles);
274 GetSupportedPhotoProfiles(outCapability, photoProfiles);
275 GetSupportedVideoProfiles(outCapability, videoProfiles);
276 GetSupportedMetadataTypeList(outCapability, metadataTypeList);
277
278 *cameraOutputCapability = outCapability;
279 MEDIA_INFO_LOG("GetSupportedCameraOutputCapability success.");
280 return CAMERA_OK;
281 }
282
GetSupportedPreviewProfiles(Camera_OutputCapability * outCapability,std::vector<Profile> & previewProfiles)283 Camera_ErrorCode Camera_Manager::GetSupportedPreviewProfiles(Camera_OutputCapability* outCapability,
284 std::vector<Profile> &previewProfiles)
285 {
286 if (previewProfiles.size() == 0) {
287 MEDIA_ERR_LOG("Invalid preview profiles size.");
288 outCapability->previewProfiles = nullptr;
289 return CAMERA_INVALID_ARGUMENT;
290 }
291 outCapability->previewProfilesSize = previewProfiles.size();
292 outCapability->previewProfiles = new Camera_Profile* [previewProfiles.size()];
293 CHECK_ERROR_PRINT_LOG(!outCapability->previewProfiles, "Failed to allocate memory for preview profiles");
294 MEDIA_DEBUG_LOG("GetSupportedCameraOutputCapability previewOutput size enter");
295 for (size_t index = 0; index < previewProfiles.size(); index++) {
296 Camera_Profile* outPreviewProfile = new Camera_Profile;
297 if (!outPreviewProfile) {
298 MEDIA_ERR_LOG("Failed to allocate memory for PreviewProfile");
299 }
300 outPreviewProfile->format = static_cast<Camera_Format>(previewProfiles[index].GetCameraFormat());
301 outPreviewProfile->size.width = previewProfiles[index].GetSize().width;
302 outPreviewProfile->size.height = previewProfiles[index].GetSize().height;
303 outCapability->previewProfiles[index] = outPreviewProfile;
304 }
305 MEDIA_DEBUG_LOG("GetSupportedCameraOutputCapability previewOutput size exit");
306 return CAMERA_OK;
307 }
308
GetSupportedPhotoProfiles(Camera_OutputCapability * outCapability,std::vector<Profile> & photoProfiles)309 Camera_ErrorCode Camera_Manager::GetSupportedPhotoProfiles(Camera_OutputCapability* outCapability,
310 std::vector<Profile> &photoProfiles)
311 {
312 if (photoProfiles.size() == 0) {
313 MEDIA_ERR_LOG("Invalid photo profiles size.");
314 outCapability->photoProfiles = nullptr;
315 return CAMERA_INVALID_ARGUMENT;
316 }
317 outCapability->photoProfilesSize = photoProfiles.size();
318 outCapability->photoProfiles = new Camera_Profile* [photoProfiles.size()];
319 CHECK_ERROR_PRINT_LOG(!outCapability->photoProfiles, "Failed to allocate memory for photo profiles");
320 for (size_t index = 0; index < photoProfiles.size(); index++) {
321 Camera_Profile* outPhotoProfile = new Camera_Profile;
322 if (!outPhotoProfile) {
323 MEDIA_ERR_LOG("Failed to allocate memory for PhotoProfile");
324 }
325 outPhotoProfile->format = static_cast<Camera_Format>(photoProfiles[index].GetCameraFormat());
326 outPhotoProfile->size.width = photoProfiles[index].GetSize().width;
327 outPhotoProfile->size.height = photoProfiles[index].GetSize().height;
328 outCapability->photoProfiles[index] = outPhotoProfile;
329 }
330 return CAMERA_OK;
331 }
332
GetSupportedVideoProfiles(Camera_OutputCapability * outCapability,std::vector<VideoProfile> & videoProfiles)333 Camera_ErrorCode Camera_Manager::GetSupportedVideoProfiles(Camera_OutputCapability* outCapability,
334 std::vector<VideoProfile> &videoProfiles)
335 {
336 if (videoProfiles.size() == 0) {
337 MEDIA_ERR_LOG("Invalid video profiles size.");
338 outCapability->videoProfiles = nullptr;
339 return CAMERA_INVALID_ARGUMENT;
340 }
341 outCapability->videoProfilesSize = videoProfiles.size();
342 outCapability->videoProfiles = new Camera_VideoProfile* [videoProfiles.size()];
343 CHECK_ERROR_PRINT_LOG(!outCapability->videoProfiles, "Failed to allocate memory for video profiles");
344 for (size_t index = 0; index < videoProfiles.size(); index++) {
345 Camera_VideoProfile* outVideoProfile = new Camera_VideoProfile;
346 if (!outVideoProfile) {
347 MEDIA_ERR_LOG("Failed to allocate memory for VideoProfile");
348 }
349 outVideoProfile->format = static_cast<Camera_Format>(videoProfiles[index].GetCameraFormat());
350 outVideoProfile->size.width = videoProfiles[index].GetSize().width;
351 outVideoProfile->size.height = videoProfiles[index].GetSize().height;
352 outVideoProfile->range.min = static_cast<uint32_t>(videoProfiles[index].framerates_[0]);
353 outVideoProfile->range.max = static_cast<uint32_t>(videoProfiles[index].framerates_[1]);
354 outCapability->videoProfiles[index] = outVideoProfile;
355 }
356 return CAMERA_OK;
357 }
358
GetSupportedMetadataTypeList(Camera_OutputCapability * outCapability,std::vector<MetadataObjectType> & metadataTypeList)359 Camera_ErrorCode Camera_Manager::GetSupportedMetadataTypeList(Camera_OutputCapability* outCapability,
360 std::vector<MetadataObjectType> &metadataTypeList)
361 {
362 if (metadataTypeList.size() == 0) {
363 MEDIA_ERR_LOG("Invalid metadata type size.");
364 outCapability->supportedMetadataObjectTypes = nullptr;
365 return CAMERA_INVALID_ARGUMENT;
366 }
367 outCapability->metadataProfilesSize = metadataTypeList.size();
368 outCapability->supportedMetadataObjectTypes = new Camera_MetadataObjectType* [metadataTypeList.size()];
369 CHECK_ERROR_PRINT_LOG(!outCapability->supportedMetadataObjectTypes,
370 "Failed to allocate memory for supportedMetadataObjectTypes");
371 for (size_t index = 0; index < metadataTypeList.size(); index++) {
372 Camera_MetadataObjectType outmetadataObject = static_cast<Camera_MetadataObjectType>(metadataTypeList[index]);
373 outCapability->supportedMetadataObjectTypes[index] = &outmetadataObject;
374 }
375 return CAMERA_OK;
376 }
377
GetSupportedCameraOutputCapabilityWithSceneMode(const Camera_Device * camera,Camera_SceneMode sceneMode,Camera_OutputCapability ** cameraOutputCapability)378 Camera_ErrorCode Camera_Manager::GetSupportedCameraOutputCapabilityWithSceneMode(const Camera_Device* camera,
379 Camera_SceneMode sceneMode, Camera_OutputCapability** cameraOutputCapability)
380 {
381 sptr<CameraDevice> cameraDevice = CameraManager::GetInstance()->GetCameraDeviceFromId(camera->cameraId);
382 CHECK_AND_RETURN_RET_LOG(cameraDevice != nullptr, CAMERA_INVALID_ARGUMENT,
383 "Camera_Manager::GetSupportedCameraOutputCapabilityWithSceneMode get cameraDevice fail!");
384
385 auto itr = g_ndkToFwMode_.find(static_cast<Camera_SceneMode>(sceneMode));
386 CHECK_AND_RETURN_RET_LOG(itr != g_ndkToFwMode_.end(), CAMERA_INVALID_ARGUMENT,
387 "Camera_Manager::GetSupportedCameraOutputCapabilityWithSceneMode "
388 "sceneMode = %{public}d not supported!", sceneMode);
389
390 SceneMode innerSceneMode = static_cast<SceneMode>(itr->second);
391 sptr<CameraOutputCapability> innerCameraOutputCapability =
392 CameraManager::GetInstance()->GetSupportedOutputCapability(cameraDevice, innerSceneMode);
393 CHECK_AND_RETURN_RET_LOG(innerCameraOutputCapability != nullptr, CAMERA_INVALID_ARGUMENT,
394 "Camera_Manager::GetSupportedCameraOutputCapabilityWithSceneMode innerCameraOutputCapability is null!");
395
396 Camera_OutputCapability* outCapability = new Camera_OutputCapability;
397 CHECK_AND_RETURN_RET_LOG(outCapability != nullptr, CAMERA_SERVICE_FATAL_ERROR,
398 "Camera_Manager::GetSupportedCameraOutputCapabilityWithSceneMode failed to allocate memory for outCapability!");
399 std::vector<Profile> previewProfiles = innerCameraOutputCapability->GetPreviewProfiles();
400 std::vector<Profile> uniquePreviewProfiles;
401 for (const auto& profile : previewProfiles) {
402 if (std::find(uniquePreviewProfiles.begin(), uniquePreviewProfiles.end(),
403 profile) == uniquePreviewProfiles.end()) {
404 uniquePreviewProfiles.push_back(profile);
405 }
406 }
407 std::vector<Profile> photoProfiles = innerCameraOutputCapability->GetPhotoProfiles();
408 std::vector<VideoProfile> videoProfiles = innerCameraOutputCapability->GetVideoProfiles();
409 std::vector<MetadataObjectType> metadataTypeList =
410 innerCameraOutputCapability->GetSupportedMetadataObjectType();
411 GetSupportedPreviewProfiles(outCapability, uniquePreviewProfiles);
412 GetSupportedPhotoProfiles(outCapability, photoProfiles);
413 GetSupportedVideoProfiles(outCapability, videoProfiles);
414 GetSupportedMetadataTypeList(outCapability, metadataTypeList);
415 *cameraOutputCapability = outCapability;
416 return CAMERA_OK;
417 }
418
DeleteSupportedCameraOutputCapability(Camera_OutputCapability * cameraOutputCapability)419 Camera_ErrorCode Camera_Manager::DeleteSupportedCameraOutputCapability(Camera_OutputCapability* cameraOutputCapability)
420 {
421 if (cameraOutputCapability != nullptr) {
422 if (cameraOutputCapability->previewProfiles != nullptr) {
423 for (size_t index = 0; index < cameraOutputCapability->previewProfilesSize; index++) {
424 if (cameraOutputCapability->previewProfiles[index] != nullptr) {
425 delete cameraOutputCapability->previewProfiles[index];
426 }
427 }
428 delete[] cameraOutputCapability->previewProfiles;
429 }
430
431 if (cameraOutputCapability->photoProfiles != nullptr) {
432 for (size_t index = 0; index < cameraOutputCapability->photoProfilesSize; index++) {
433 if (cameraOutputCapability->photoProfiles[index] != nullptr) {
434 delete cameraOutputCapability->photoProfiles[index];
435 }
436 }
437 delete[] cameraOutputCapability->photoProfiles;
438 }
439
440 if (cameraOutputCapability->videoProfiles != nullptr) {
441 for (size_t index = 0; index < cameraOutputCapability->videoProfilesSize; index++) {
442 if (cameraOutputCapability->videoProfiles[index] != nullptr) {
443 delete cameraOutputCapability->videoProfiles[index];
444 }
445 }
446 delete[] cameraOutputCapability->videoProfiles;
447 }
448
449 if (cameraOutputCapability->supportedMetadataObjectTypes != nullptr) {
450 delete[] cameraOutputCapability->supportedMetadataObjectTypes;
451 }
452
453 delete cameraOutputCapability;
454 }
455 return CAMERA_OK;
456 }
IsCameraMuted(bool * isCameraMuted)457 Camera_ErrorCode Camera_Manager::IsCameraMuted(bool* isCameraMuted)
458 {
459 MEDIA_ERR_LOG("Camera_Manager IsCameraMuted is called");
460 *isCameraMuted = CameraManager::GetInstance()->IsCameraMuted();
461 MEDIA_ERR_LOG("IsCameraMuted is %{public}d", *isCameraMuted);
462 return CAMERA_OK;
463 }
464
CreateCaptureSession(Camera_CaptureSession ** captureSession)465 Camera_ErrorCode Camera_Manager::CreateCaptureSession(Camera_CaptureSession** captureSession)
466 {
467 sptr<CaptureSession> innerCaptureSession = CameraManager::GetInstance()->CreateCaptureSession(SceneMode::NORMAL);
468 CHECK_AND_RETURN_RET_LOG(innerCaptureSession != nullptr, CAMERA_SERVICE_FATAL_ERROR,
469 "Camera_Manager::CreateCaptureSession create innerCaptureSession fail!");
470 Camera_CaptureSession* outSession = new Camera_CaptureSession(innerCaptureSession);
471 *captureSession = outSession;
472 return CAMERA_OK;
473 }
474
CreateCameraInput(const Camera_Device * camera,Camera_Input ** cameraInput)475 Camera_ErrorCode Camera_Manager::CreateCameraInput(const Camera_Device* camera, Camera_Input** cameraInput)
476 {
477 MEDIA_INFO_LOG("CameraId is: %{public}s", camera->cameraId);
478 sptr<CameraDevice> cameraDevice = CameraManager::GetInstance()->GetCameraDeviceFromId(camera->cameraId);
479 CHECK_AND_RETURN_RET_LOG(cameraDevice != nullptr, CAMERA_INVALID_ARGUMENT,
480 "Camera_Manager::CreateCameraInput get cameraDevice fail!");
481
482 sptr<CameraInput> innerCameraInput = nullptr;
483 int32_t retCode = CameraManager::GetInstance()->CreateCameraInput(cameraDevice, &innerCameraInput);
484 if (retCode != CameraErrorCode::SUCCESS) {
485 return CAMERA_SERVICE_FATAL_ERROR;
486 }
487 Camera_Input* outInput = new Camera_Input(innerCameraInput);
488 *cameraInput = outInput;
489 return CAMERA_OK;
490 }
491
CreateCameraInputWithPositionAndType(Camera_Position position,Camera_Type type,Camera_Input ** cameraInput)492 Camera_ErrorCode Camera_Manager::CreateCameraInputWithPositionAndType(Camera_Position position, Camera_Type type,
493 Camera_Input** cameraInput)
494 {
495 MEDIA_ERR_LOG("Camera_Manager CreateCameraInputWithPositionAndType is called");
496 sptr<CameraInput> innerCameraInput = nullptr;
497 CameraPosition innerPosition = CameraPosition::CAMERA_POSITION_UNSPECIFIED;
498 auto itr = g_NdkCameraPositionToFwk_.find(position);
499 if (itr != g_NdkCameraPositionToFwk_.end()) {
500 innerPosition = itr->second;
501 } else {
502 MEDIA_ERR_LOG("Camera_Manager::CreateCameraInputWithPositionAndType innerPosition not found!");
503 return CAMERA_INVALID_ARGUMENT;
504 }
505 CameraType innerType = static_cast<CameraType>(type);
506
507 innerCameraInput = CameraManager::GetInstance()->CreateCameraInput(innerPosition, innerType);
508 CHECK_ERROR_RETURN_RET_LOG(innerCameraInput == nullptr, CAMERA_SERVICE_FATAL_ERROR,
509 "Failed to CreateCameraInputWithPositionAndType");
510 Camera_Input* outInput = new Camera_Input(innerCameraInput);
511 *cameraInput = outInput;
512 return CAMERA_OK;
513 }
514
CreatePreviewOutput(const Camera_Profile * profile,const char * surfaceId,Camera_PreviewOutput ** previewOutput)515 Camera_ErrorCode Camera_Manager::CreatePreviewOutput(const Camera_Profile* profile,
516 const char* surfaceId, Camera_PreviewOutput** previewOutput)
517 {
518 sptr<PreviewOutput> innerPreviewOutput = nullptr;
519 Size size;
520 size.width = profile->size.width;
521 size.height = profile->size.height;
522 Profile innerProfile(static_cast<CameraFormat>(profile->format), size);
523
524 uint64_t iSurfaceId;
525 std::istringstream iss(surfaceId);
526 iss >> iSurfaceId;
527 sptr<Surface> surface = SurfaceUtils::GetInstance()->GetSurface(iSurfaceId);
528 if (!surface) {
529 surface = Media::ImageReceiver::getSurfaceById(surfaceId);
530 }
531 CHECK_ERROR_RETURN_RET_LOG(surface == nullptr, CAMERA_SERVICE_FATAL_ERROR, "Failed to get previewOutput surface");
532 surface->SetUserData(CameraManager::surfaceFormat, std::to_string(innerProfile.GetCameraFormat()));
533 int32_t retCode = CameraManager::GetInstance()->CreatePreviewOutput(innerProfile, surface, &innerPreviewOutput);
534 CHECK_ERROR_RETURN_RET(retCode != CameraErrorCode::SUCCESS, CAMERA_SERVICE_FATAL_ERROR);
535 Camera_PreviewOutput* out = new Camera_PreviewOutput(innerPreviewOutput);
536 *previewOutput = out;
537 MEDIA_ERR_LOG("Camera_Manager::CreatePreviewOutput");
538 return CAMERA_OK;
539 }
540
CreatePreviewOutputUsedInPreconfig(const char * surfaceId,Camera_PreviewOutput ** previewOutput)541 Camera_ErrorCode Camera_Manager::CreatePreviewOutputUsedInPreconfig(const char* surfaceId,
542 Camera_PreviewOutput** previewOutput)
543 {
544 sptr<PreviewOutput> innerPreviewOutput = nullptr;
545 uint64_t iSurfaceId;
546 std::istringstream iss(surfaceId);
547 iss >> iSurfaceId;
548 sptr<Surface> surface = SurfaceUtils::GetInstance()->GetSurface(iSurfaceId);
549 if (!surface) {
550 surface = Media::ImageReceiver::getSurfaceById(surfaceId);
551 }
552 CHECK_AND_RETURN_RET_LOG(surface != nullptr, CAMERA_INVALID_ARGUMENT,
553 "Camera_Manager::CreatePreviewOutputUsedInPreconfig get previewOutput surface fail!");
554 int32_t retCode = CameraManager::GetInstance()->CreatePreviewOutputWithoutProfile(surface, &innerPreviewOutput);
555 CHECK_AND_RETURN_RET_LOG(retCode == CameraErrorCode::SUCCESS, CAMERA_SERVICE_FATAL_ERROR,
556 "Camera_Manager::CreatePreviewOutputUsedInPreconfig create innerPreviewOutput fail!");
557 CHECK_AND_RETURN_RET_LOG(innerPreviewOutput != nullptr, CAMERA_SERVICE_FATAL_ERROR,
558 "Camera_Manager::CreatePreviewOutputUsedInPreconfig create innerPreviewOutput fail!");
559 Camera_PreviewOutput* out = new Camera_PreviewOutput(innerPreviewOutput);
560 *previewOutput = out;
561 return CAMERA_OK;
562 }
563
CreatePhotoOutput(const Camera_Profile * profile,const char * surfaceId,Camera_PhotoOutput ** photoOutput)564 Camera_ErrorCode Camera_Manager::CreatePhotoOutput(const Camera_Profile* profile,
565 const char* surfaceId, Camera_PhotoOutput** photoOutput)
566 {
567 MEDIA_ERR_LOG("Camera_Manager CreatePhotoOutput is called");
568 sptr<PhotoOutput> innerPhotoOutput = nullptr;
569 Size size;
570 size.width = profile->size.width;
571 size.height = profile->size.height;
572 Profile innerProfile(static_cast<CameraFormat>(profile->format), size);
573
574 sptr<Surface> surface = Media::ImageReceiver::getSurfaceById(surfaceId);
575 CHECK_ERROR_RETURN_RET_LOG(surface == nullptr, CAMERA_INVALID_ARGUMENT, "Failed to get photoOutput surface");
576 surface->SetUserData(CameraManager::surfaceFormat, std::to_string(innerProfile.GetCameraFormat()));
577 sptr<IBufferProducer> surfaceProducer = surface->GetProducer();
578 int32_t retCode = CameraManager::GetInstance()->CreatePhotoOutput(innerProfile, surfaceProducer, &innerPhotoOutput);
579 CHECK_ERROR_RETURN_RET(retCode != CameraErrorCode::SUCCESS, CAMERA_SERVICE_FATAL_ERROR);
580 Camera_PhotoOutput* out = new Camera_PhotoOutput(innerPhotoOutput);
581 *photoOutput = out;
582 return CAMERA_OK;
583 }
584
CreatePhotoOutputUsedInPreconfig(const char * surfaceId,Camera_PhotoOutput ** photoOutput)585 Camera_ErrorCode Camera_Manager::CreatePhotoOutputUsedInPreconfig(const char* surfaceId,
586 Camera_PhotoOutput** photoOutput)
587 {
588 sptr<PhotoOutput> innerPhotoOutput = nullptr;
589 sptr<Surface> surface = nullptr;
590 if (strcmp(surfaceId, "")) {
591 surface = Media::ImageReceiver::getSurfaceById(surfaceId);
592 } else {
593 surface = Surface::CreateSurfaceAsConsumer("photoOutput");
594 }
595 CHECK_AND_RETURN_RET_LOG(surface != nullptr, CAMERA_INVALID_ARGUMENT,
596 "Camera_Manager::CreatePhotoOutputUsedInPreconfig get photoOutput surface fail!");
597 sptr<IBufferProducer> surfaceProducer = surface->GetProducer();
598 CHECK_AND_RETURN_RET_LOG(surfaceProducer != nullptr, CAMERA_INVALID_ARGUMENT,
599 "Camera_Manager::CreatePhotoOutputUsedInPreconfig get surfaceProducer fail!");
600 int32_t retCode =
601 CameraManager::GetInstance()->CreatePhotoOutputWithoutProfile(surfaceProducer, &innerPhotoOutput);
602 CHECK_AND_RETURN_RET_LOG(retCode == CameraErrorCode::SUCCESS, CAMERA_SERVICE_FATAL_ERROR,
603 "Camera_Manager::CreatePhotoOutputUsedInPreconfig create innerPhotoOutput fail!");
604 CHECK_AND_RETURN_RET_LOG(innerPhotoOutput != nullptr, CAMERA_SERVICE_FATAL_ERROR,
605 "Camera_Manager::CreatePhotoOutputUsedInPreconfig create innerPhotoOutput fail!");
606 Camera_PhotoOutput* out = new Camera_PhotoOutput(innerPhotoOutput);
607 *photoOutput = out;
608 return CAMERA_OK;
609 }
610
CreatePhotoOutputWithoutSurface(const Camera_Profile * profile,Camera_PhotoOutput ** photoOutput)611 Camera_ErrorCode Camera_Manager::CreatePhotoOutputWithoutSurface(const Camera_Profile* profile,
612 Camera_PhotoOutput** photoOutput)
613 {
614 MEDIA_ERR_LOG("Camera_Manager CreatePhotoOutputWithoutSurface is called");
615 sptr<PhotoOutput> innerPhotoOutput = nullptr;
616 Size size;
617 size.width = profile->size.width;
618 size.height = profile->size.height;
619 Profile innerProfile(static_cast<CameraFormat>(profile->format), size);
620
621 sptr<Surface> surface = Surface::CreateSurfaceAsConsumer(DEFAULT_SURFACEID);
622 CHECK_AND_RETURN_RET_LOG(surface != nullptr, CAMERA_INVALID_ARGUMENT,
623 "Failed to get photoOutput surface");
624
625 photoSurface_ = surface;
626 surface->SetUserData(CameraManager::surfaceFormat, std::to_string(innerProfile.GetCameraFormat()));
627 sptr<IBufferProducer> surfaceProducer = surface->GetProducer();
628 CHECK_AND_RETURN_RET_LOG(surfaceProducer != nullptr, CAMERA_SERVICE_FATAL_ERROR, "Get producer failed");
629
630 int32_t retCode = CameraManager::GetInstance()->CreatePhotoOutput(innerProfile,
631 surfaceProducer, &innerPhotoOutput);
632 CHECK_AND_RETURN_RET_LOG((retCode == CameraErrorCode::SUCCESS && innerPhotoOutput != nullptr),
633 CAMERA_SERVICE_FATAL_ERROR, "Create photo output failed");
634
635 innerPhotoOutput->SetNativeSurface(true);
636 Camera_PhotoOutput* out = new Camera_PhotoOutput(innerPhotoOutput);
637 CHECK_AND_RETURN_RET_LOG(out != nullptr, CAMERA_SERVICE_FATAL_ERROR, "Create Camera_PhotoOutput failed");
638 out->SetPhotoSurface(surface);
639 *photoOutput = out;
640 return CAMERA_OK;
641 }
642
CreateVideoOutput(const Camera_VideoProfile * profile,const char * surfaceId,Camera_VideoOutput ** videoOutput)643 Camera_ErrorCode Camera_Manager::CreateVideoOutput(const Camera_VideoProfile* profile,
644 const char* surfaceId, Camera_VideoOutput** videoOutput)
645 {
646 sptr<VideoOutput> innerVideoOutput = nullptr;
647 Size size;
648 size.width = profile->size.width;
649 size.height = profile->size.height;
650 std::vector<int32_t> framerates = {profile->range.min, profile->range.max};
651 VideoProfile innerProfile(static_cast<CameraFormat>(profile->format), size, framerates);
652
653 uint64_t iSurfaceId;
654 std::istringstream iss(surfaceId);
655 iss >> iSurfaceId;
656 sptr<Surface> surface = SurfaceUtils::GetInstance()->GetSurface(iSurfaceId);
657 if (!surface) {
658 surface = Media::ImageReceiver::getSurfaceById(surfaceId);
659 }
660 CHECK_ERROR_RETURN_RET_LOG(surface == nullptr, CAMERA_INVALID_ARGUMENT, "Failed to get videoOutput surface");
661 surface->SetUserData(CameraManager::surfaceFormat, std::to_string(innerProfile.GetCameraFormat()));
662 int32_t retCode = CameraManager::GetInstance()->CreateVideoOutput(innerProfile, surface, &innerVideoOutput);
663 CHECK_ERROR_RETURN_RET(retCode != CameraErrorCode::SUCCESS, CAMERA_SERVICE_FATAL_ERROR);
664 Camera_VideoOutput* out = new Camera_VideoOutput(innerVideoOutput);
665 *videoOutput = out;
666 return CAMERA_OK;
667 }
668
CreateVideoOutputUsedInPreconfig(const char * surfaceId,Camera_VideoOutput ** videoOutput)669 Camera_ErrorCode Camera_Manager::CreateVideoOutputUsedInPreconfig(const char* surfaceId,
670 Camera_VideoOutput** videoOutput)
671 {
672 sptr<VideoOutput> innerVideoOutput = nullptr;
673 uint64_t iSurfaceId;
674 std::istringstream iss(surfaceId);
675 iss >> iSurfaceId;
676 sptr<Surface> surface = SurfaceUtils::GetInstance()->GetSurface(iSurfaceId);
677 CHECK_AND_RETURN_RET_LOG(surface != nullptr, CAMERA_INVALID_ARGUMENT,
678 "Camera_Manager::CreateVideoOutputUsedInPreconfig get videoOutput surface fail!");
679 int32_t retCode = CameraManager::GetInstance()->CreateVideoOutputWithoutProfile(surface, &innerVideoOutput);
680 CHECK_AND_RETURN_RET_LOG(retCode == CameraErrorCode::SUCCESS, CAMERA_SERVICE_FATAL_ERROR,
681 "Camera_Manager::CreateVideoOutputUsedInPreconfig create innerVideoOutput fail!");
682 CHECK_AND_RETURN_RET_LOG(innerVideoOutput != nullptr, CAMERA_SERVICE_FATAL_ERROR,
683 "Camera_Manager::CreateVideoOutputUsedInPreconfig create innerVideoOutput fail!");
684 Camera_VideoOutput* out = new Camera_VideoOutput(innerVideoOutput);
685 *videoOutput = out;
686 return CAMERA_OK;
687 }
688
CreateMetadataOutput(const Camera_MetadataObjectType * type,Camera_MetadataOutput ** metadataOutput)689 Camera_ErrorCode Camera_Manager::CreateMetadataOutput(const Camera_MetadataObjectType* type,
690 Camera_MetadataOutput** metadataOutput)
691 {
692 MEDIA_ERR_LOG("Camera_Manager CreateMetadataOutput is called");
693 sptr<MetadataOutput> innerMetadataOutput = nullptr;
694
695 int32_t retCode = CameraManager::GetInstance()->CreateMetadataOutput(innerMetadataOutput);
696 CHECK_ERROR_RETURN_RET(retCode != CameraErrorCode::SUCCESS, CAMERA_SERVICE_FATAL_ERROR);
697 Camera_MetadataOutput* out = new Camera_MetadataOutput(innerMetadataOutput);
698 *metadataOutput = out;
699 return CAMERA_OK;
700 }
701
GetCameraOrientation(Camera_Device * camera,uint32_t * orientation)702 Camera_ErrorCode Camera_Manager::GetCameraOrientation(Camera_Device* camera, uint32_t* orientation)
703 {
704 sptr<CameraDevice> cameraDevice = nullptr;
705 std::vector<sptr<CameraDevice>> cameraObjList = CameraManager::GetInstance()->GetSupportedCameras();
706 MEDIA_DEBUG_LOG("the cameraObjList size is %{public}zu",
707 cameraObjList.size());
708 for (size_t index = 0; index < cameraObjList.size(); index++) {
709 sptr<CameraDevice> innerCameraDevice = cameraObjList[index];
710 if (innerCameraDevice == nullptr) {
711 continue;
712 }
713 if (innerCameraDevice->GetID() == camera->cameraId) {
714 cameraDevice = innerCameraDevice;
715 break;
716 }
717 }
718
719 if (cameraDevice == nullptr) {
720 return CAMERA_SERVICE_FATAL_ERROR;
721 } else {
722 *orientation = cameraDevice->GetCameraOrientation();
723 return CAMERA_OK;
724 }
725 }
726
GetSupportedSceneModes(Camera_Device * camera,Camera_SceneMode ** sceneModes,uint32_t * size)727 Camera_ErrorCode Camera_Manager::GetSupportedSceneModes(Camera_Device* camera,
728 Camera_SceneMode** sceneModes, uint32_t* size)
729 {
730 sptr<CameraDevice> cameraDevice = CameraManager::GetInstance()->GetCameraDeviceFromId(camera->cameraId);
731 CHECK_AND_RETURN_RET_LOG(cameraDevice != nullptr, CAMERA_INVALID_ARGUMENT,
732 "Camera_Manager::GetSupportedSceneModes get cameraDevice fail!");
733
734 std::vector<SceneMode> innerSceneMode = CameraManager::GetInstance()->GetSupportedModes(cameraDevice);
735 for (auto it = innerSceneMode.begin(); it != innerSceneMode.end(); it++) {
736 if (*it == SCAN) {
737 innerSceneMode.erase(it);
738 break;
739 }
740 }
741 if (innerSceneMode.empty()) {
742 innerSceneMode.emplace_back(CAPTURE);
743 innerSceneMode.emplace_back(VIDEO);
744 }
745 MEDIA_INFO_LOG("Camera_Manager::GetSupportedSceneModes size = [%{public}zu]", innerSceneMode.size());
746
747 std::vector<Camera_SceneMode> cameraSceneMode;
748 for (size_t index = 0; index < innerSceneMode.size(); index++) {
749 auto itr = g_fwModeToNdk_.find(static_cast<SceneMode>(innerSceneMode[index]));
750 if (itr != g_fwModeToNdk_.end()) {
751 cameraSceneMode.push_back(static_cast<Camera_SceneMode>(itr->second));
752 }
753 }
754
755 Camera_SceneMode* sceneMode = new Camera_SceneMode[cameraSceneMode.size()];
756 CHECK_AND_RETURN_RET_LOG(sceneMode != nullptr, CAMERA_SERVICE_FATAL_ERROR,
757 "Camera_Manager::GetSupportedSceneModes allocate memory for sceneMode fail!");
758 for (size_t index = 0; index < cameraSceneMode.size(); index++) {
759 sceneMode[index] = cameraSceneMode[index];
760 }
761
762 *sceneModes = sceneMode;
763 *size = cameraSceneMode.size();
764 return CAMERA_OK;
765 }
766
DeleteSceneModes(Camera_SceneMode * sceneModes)767 Camera_ErrorCode Camera_Manager::DeleteSceneModes(Camera_SceneMode* sceneModes)
768 {
769 if (sceneModes != nullptr) {
770 delete[] sceneModes;
771 }
772
773 return CAMERA_OK;
774 }
775
IsTorchSupported(bool * isTorchSupported)776 Camera_ErrorCode Camera_Manager::IsTorchSupported(bool* isTorchSupported)
777 {
778 MEDIA_DEBUG_LOG("Camera_Manager::IsTorchSupported is called");
779
780 *isTorchSupported = CameraManager::GetInstance()->IsTorchSupported();
781 MEDIA_DEBUG_LOG("IsTorchSupported[%{public}d]", *isTorchSupported);
782 return CAMERA_OK;
783 }
784
IsTorchSupportedByTorchMode(Camera_TorchMode torchMode,bool * isTorchSupported)785 Camera_ErrorCode Camera_Manager::IsTorchSupportedByTorchMode(Camera_TorchMode torchMode, bool* isTorchSupported)
786 {
787 MEDIA_DEBUG_LOG("Camera_Manager::IsTorchSupportedByTorchMode is called");
788
789 auto itr = g_ndkToFwTorchMode_.find(torchMode);
790 if (itr == g_ndkToFwTorchMode_.end()) {
791 MEDIA_ERR_LOG("torchMode[%{public}d] is invalid", torchMode);
792 return CAMERA_INVALID_ARGUMENT;
793 }
794 *isTorchSupported = CameraManager::GetInstance()->IsTorchModeSupported(itr->second);
795 MEDIA_DEBUG_LOG("IsTorchSupportedByTorchMode[%{public}d]", *isTorchSupported);
796 return CAMERA_OK;
797 }
798
SetTorchMode(Camera_TorchMode torchMode)799 Camera_ErrorCode Camera_Manager::SetTorchMode(Camera_TorchMode torchMode)
800 {
801 MEDIA_DEBUG_LOG("Camera_Manager::SetTorchMode is called");
802
803 auto itr = g_ndkToFwTorchMode_.find(torchMode);
804 if (itr == g_ndkToFwTorchMode_.end()) {
805 MEDIA_ERR_LOG("torchMode[%{public}d] is invalid", torchMode);
806 return CAMERA_INVALID_ARGUMENT;
807 }
808 int32_t ret = CameraManager::GetInstance()->SetTorchMode(itr->second);
809 return FrameworkToNdkCameraError(ret);
810 }
811
RegisterFoldStatusCallback(OH_CameraManager_OnFoldStatusInfoChange foldStatusCallback)812 Camera_ErrorCode Camera_Manager::RegisterFoldStatusCallback(OH_CameraManager_OnFoldStatusInfoChange foldStatusCallback)
813 {
814 shared_ptr<InnerCameraManagerFoldStatusCallback> innerFoldStatusCallback =
815 make_shared<InnerCameraManagerFoldStatusCallback>(this, foldStatusCallback);
816 CHECK_AND_RETURN_RET_LOG(innerFoldStatusCallback != nullptr, CAMERA_SERVICE_FATAL_ERROR,
817 "create innerFoldStatusCallback failed!");
818 cameraManager_->RegisterFoldListener(innerFoldStatusCallback);
819 return CAMERA_OK;
820 }
821
UnregisterFoldStatusCallback(OH_CameraManager_OnFoldStatusInfoChange foldStatusCallback)822 Camera_ErrorCode Camera_Manager::UnregisterFoldStatusCallback(
823 OH_CameraManager_OnFoldStatusInfoChange foldStatusCallback)
824 {
825 cameraManager_->RegisterFoldListener(nullptr);
826 return CAMERA_OK;
827 }
828