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