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