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