1 /*
2 * Copyright (c) 2021-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 "hcamera_host_manager.h"
17
18 #include "camera_report_uitls.h"
19 #include "camera_util.h"
20 #include "display_manager.h"
21 #include "hcamera_device.h"
22 #include "icamera_service_callback.h"
23 #include "ipc_skeleton.h"
24 #include "iproxy_broker.h"
25 #include "metadata_utils.h"
26 #include "os_account_manager.h"
27 #include "v1_2/icamera_host_callback.h"
28 #include <cstddef>
29 #include <cstdint>
30 #include <iterator>
31 #include "rotate_plugin/camera_rotate_plugin.h"
32 #include "camera_fwk_metadata_utils.h"
33 #include "camera_simple_timer.h"
34
35 namespace OHOS {
36 namespace CameraStandard {
37
38 const std::string HCameraHostManager::LOCAL_SERVICE_NAME = "camera_service";
39 const std::string HCameraHostManager::DISTRIBUTED_SERVICE_NAME = "distributed_camera_provider_service";
40 constexpr uint32_t MILLISEC_TIME = 1000;
41 constexpr int32_t MAX_SYS_UID = 10000;
42 std::shared_ptr<SimpleTimer> closeTimer_;
43
44 using namespace OHOS::HDI::Camera::V1_0;
45 struct HCameraHostManager::CameraDeviceInfo {
46 std::string cameraId;
47 std::shared_ptr<OHOS::Camera::CameraMetadata> ability;
48 std::mutex mutex;
49
CameraDeviceInfoOHOS::CameraStandard::HCameraHostManager::CameraDeviceInfo50 explicit CameraDeviceInfo(const std::string& cameraId, sptr<ICameraDevice> device = nullptr)
51 : cameraId(cameraId), ability(nullptr)
52 {
53 }
54
55 ~CameraDeviceInfo() = default;
56 };
57
58 class HCameraHostManager::CameraHostInfo : public OHOS::HDI::Camera::V1_2::ICameraHostCallback {
59 public:
60 class CameraHostDeathRecipient : public IRemoteObject::DeathRecipient {
61 public:
CameraHostDeathRecipient(const sptr<HCameraHostManager::CameraHostInfo> & hostInfo)62 explicit CameraHostDeathRecipient(const sptr<HCameraHostManager::CameraHostInfo> &hostInfo)
63 : cameraHostInfo_(hostInfo)
64 {
65 }
66 virtual ~CameraHostDeathRecipient() = default;
OnRemoteDied(const wptr<IRemoteObject> & remote)67 void OnRemoteDied(const wptr<IRemoteObject> &remote) override
68 {
69 MEDIA_ERR_LOG("Remote died, do clean works.");
70 auto cameraHostInfo = cameraHostInfo_.promote();
71 CHECK_RETURN(cameraHostInfo == nullptr);
72 cameraHostInfo->NotifyCameraHostDied();
73 cameraHostInfo->CameraHostDied();
74 }
75
76 private:
77 wptr<HCameraHostManager::CameraHostInfo> cameraHostInfo_;
78 };
79
CameraHostInfo(std::shared_ptr<StatusCallback> statusCallback,std::shared_ptr<CameraHostDeadCallback> cameraHostDeadCallback,std::string name)80 explicit CameraHostInfo(std::shared_ptr<StatusCallback> statusCallback,
81 std::shared_ptr<CameraHostDeadCallback> cameraHostDeadCallback, std::string name)
82 : statusCallback_(statusCallback), cameraHostDeadCallback_(cameraHostDeadCallback), name_(std::move(name)),
83 majorVer_(0), minorVer_(0), cameraHostProxy_(nullptr) {};
84 ~CameraHostInfo();
85 bool Init();
86 void CameraHostDied();
87 bool IsCameraSupported(const std::string& cameraId);
88 const std::string& GetName();
89 int32_t GetCameraHostVersion();
90 int32_t GetCameras(std::vector<std::string>& cameraIds);
91 int32_t GetCameraAbility(const std::string& cameraId, std::shared_ptr<OHOS::Camera::CameraMetadata>& ability);
92 int32_t OpenCamera(std::string& cameraId, const sptr<ICameraDeviceCallback>& callback,
93 sptr<OHOS::HDI::Camera::V1_0::ICameraDevice>& pDevice, bool isEnableSecCam = false);
94 int32_t SetFlashlight(const std::string& cameraId, bool isEnable);
95 int32_t SetTorchLevel(float level);
96 int32_t Prelaunch(sptr<HCameraRestoreParam> cameraRestoreParam, bool muteMode);
97 int32_t PreCameraSwitch(const std::string& cameraId);
98 bool IsNeedRestore(int32_t opMode,
99 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings, std::string& cameraId);
100 void NotifyDeviceStateChangeInfo(int notifyType, int deviceState);
101 bool CheckUserHasChanged(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings);
102
103 int32_t GetCameraResourceCost(const std::string& cameraId,
104 OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost& resourceCost);
105 void GetCameraStorageSize(const int& userId, int64_t& storageSize);
106
107 // CameraHostCallbackStub
108 int32_t OnCameraStatus(const std::string& cameraId, HDI::Camera::V1_0::CameraStatus status) override;
109 int32_t OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status) override;
110 int32_t OnFlashlightStatus_V1_2(FlashlightStatus status) override;
111 int32_t OnCameraEvent(const std::string &cameraId, CameraEvent event) override;
112
113 private:
114 std::shared_ptr<CameraDeviceInfo> FindCameraDeviceInfo(const std::string& cameraId);
115 void NotifyCameraHostDied();
116 void AddDevice(const std::string& cameraId);
117 void RemoveDevice(const std::string& cameraId);
118 void Cast2MultiVersionCameraHost();
119 void UpdateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata> setting);
120
121 std::weak_ptr<StatusCallback> statusCallback_;
122 std::weak_ptr<CameraHostDeadCallback> cameraHostDeadCallback_;
123 std::string name_;
124 uint32_t majorVer_;
125 uint32_t minorVer_;
126 sptr<OHOS::HDI::Camera::V1_0::ICameraHost> cameraHostProxy_;
127 sptr<OHOS::HDI::Camera::V1_1::ICameraHost> cameraHostProxyV1_1_;
128 sptr<OHOS::HDI::Camera::V1_2::ICameraHost> cameraHostProxyV1_2_;
129 sptr<OHOS::HDI::Camera::V1_3::ICameraHost> cameraHostProxyV1_3_;
130
131 sptr<CameraHostDeathRecipient> cameraHostDeathRecipient_ = nullptr;
132
133 std::mutex mutex_;
134 std::vector<std::string> cameraIds_;
135 std::vector<std::shared_ptr<CameraDeviceInfo>> devices_;
136 };
137
~CameraHostInfo()138 HCameraHostManager::CameraHostInfo::~CameraHostInfo()
139 {
140 std::lock_guard<std::mutex> lock(mutex_);
141 MEDIA_INFO_LOG("CameraHostInfo ~CameraHostInfo");
142 if (cameraHostProxy_ && cameraHostDeathRecipient_) {
143 const sptr<IRemoteObject>& remote = OHOS::HDI::hdi_objcast<ICameraHost>(cameraHostProxy_);
144 remote->RemoveDeathRecipient(cameraHostDeathRecipient_);
145 cameraHostDeathRecipient_ = nullptr;
146 }
147 cameraHostProxy_ = nullptr;
148 cameraHostProxyV1_1_ = nullptr;
149 cameraHostProxyV1_2_ = nullptr;
150 cameraHostProxyV1_3_ = nullptr;
151 for (unsigned i = 0; i < devices_.size(); i++) {
152 devices_.at(i) = nullptr;
153 }
154 cameraIds_.clear();
155 devices_.clear();
156 }
157
Cast2MultiVersionCameraHost()158 void HCameraHostManager::CameraHostInfo::Cast2MultiVersionCameraHost()
159 {
160 cameraHostProxy_->GetVersion(majorVer_, minorVer_);
161 MEDIA_INFO_LOG("CameraHostInfo::Init cameraHostProxy_version %{public}u _ %{public}u", majorVer_, minorVer_);
162 if (GetCameraHostVersion() > HDI_VERSION_ID_1_2) {
163 MEDIA_DEBUG_LOG("CameraHostInfo::Init ICameraHost cast to V1_3");
164 auto castResult_V1_3 = OHOS::HDI::Camera::V1_3::ICameraHost::CastFrom(cameraHostProxy_);
165 if (castResult_V1_3 != nullptr) {
166 cameraHostProxyV1_3_ = castResult_V1_3;
167 }
168 }
169 if (GetCameraHostVersion() > HDI_VERSION_ID_1_1) {
170 MEDIA_DEBUG_LOG("CameraHostInfo::Init ICameraHost cast to V1_2");
171 auto castResult_V1_2 = OHOS::HDI::Camera::V1_2::ICameraHost::CastFrom(cameraHostProxy_);
172 if (castResult_V1_2 != nullptr) {
173 cameraHostProxyV1_2_ = castResult_V1_2;
174 }
175 }
176 if (GetCameraHostVersion() > HDI_VERSION_ID_1_0) {
177 MEDIA_DEBUG_LOG("CameraHostInfo::Init ICameraHost cast to V1_1");
178 auto castResult_V1_1 = OHOS::HDI::Camera::V1_1::ICameraHost::CastFrom(cameraHostProxy_);
179 if (castResult_V1_1 != nullptr) {
180 cameraHostProxyV1_1_ = castResult_V1_1;
181 }
182 }
183 }
184
Init()185 bool HCameraHostManager::CameraHostInfo::Init()
186 {
187 CHECK_RETURN_RET_ELOG(cameraHostProxy_ != nullptr, true, "CameraHostInfo::Init, no camera host proxy");
188 cameraHostProxy_ = OHOS::HDI::Camera::V1_0::ICameraHost::Get(name_.c_str(), false);
189 CHECK_RETURN_RET_ELOG(cameraHostProxy_ == nullptr, false, "Failed to get ICameraHost");
190 Cast2MultiVersionCameraHost();
191
192 if (cameraHostProxyV1_3_ != nullptr && GetCameraHostVersion() >= HDI_VERSION_ID_1_3) {
193 MEDIA_DEBUG_LOG("CameraHostInfo::Init SetCallback ICameraHost V1_3");
194 cameraHostProxyV1_3_->SetCallback_V1_2(this);
195 // LCOV_EXCL_START
196 } else if (cameraHostProxyV1_2_ != nullptr && GetCameraHostVersion() >= HDI_VERSION_ID_1_2) {
197 MEDIA_DEBUG_LOG("CameraHostInfo::Init SetCallback ICameraHost V1_2");
198 cameraHostProxyV1_2_->SetCallback_V1_2(this);
199 } else {
200 MEDIA_DEBUG_LOG("CameraHostInfo::Init SetCallback ICameraHost V1_0");
201 cameraHostProxy_->SetCallback(this);
202 // LCOV_EXCL_STOP
203 }
204 cameraHostDeathRecipient_ = new CameraHostDeathRecipient(this);
205 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<ICameraHost>(cameraHostProxy_);
206 CHECK_PRINT_ELOG(!remote->AddDeathRecipient(cameraHostDeathRecipient_),
207 "AddDeathRecipient for CameraHost failed.");
208 std::lock_guard<std::mutex> lock(mutex_);
209 CamRetCode ret = (CamRetCode)(cameraHostProxy_->GetCameraIds(cameraIds_));
210 if (ret != HDI::Camera::V1_0::NO_ERROR) {
211 MEDIA_ERR_LOG("Init, GetCameraIds failed, ret = %{public}d", ret);
212 CameraReportUtils::ReportCameraError(
213 "CameraHostInfo::Init", ret, true, CameraReportUtils::GetCallerInfo());
214 return false;
215 }
216 for (const auto& cameraId : cameraIds_) {
217 devices_.push_back(std::make_shared<HCameraHostManager::CameraDeviceInfo>(cameraId));
218 }
219 return true;
220 }
221
CameraHostDied()222 void HCameraHostManager::CameraHostInfo::CameraHostDied()
223 {
224 auto hostDeadCallback = cameraHostDeadCallback_.lock();
225 CHECK_RETURN_ELOG(hostDeadCallback == nullptr,
226 "%{public}s CameraHostDied but hostDeadCallback is null.", name_.c_str());
227 hostDeadCallback->OnCameraHostDied(name_);
228 }
229
IsCameraSupported(const std::string & cameraId)230 bool HCameraHostManager::CameraHostInfo::IsCameraSupported(const std::string& cameraId)
231 {
232 std::lock_guard<std::mutex> lock(mutex_);
233 return std::any_of(cameraIds_.begin(), cameraIds_.end(),
234 [&cameraId](const auto& camId) { return camId == cameraId; });
235 }
236
GetName()237 const std::string& HCameraHostManager::CameraHostInfo::GetName()
238 {
239 return name_;
240 }
241
GetCameraHostVersion()242 int32_t HCameraHostManager::CameraHostInfo::GetCameraHostVersion()
243 {
244 MEDIA_DEBUG_LOG("cameraHostProxy_ GetVersion majorVer_: %{public}u, minorVer_: %{public}u", majorVer_, minorVer_);
245 return OHOS::CameraStandard::GetVersionId(majorVer_, minorVer_);
246 }
247
GetCameras(std::vector<std::string> & cameraIds)248 int32_t HCameraHostManager::CameraHostInfo::GetCameras(std::vector<std::string>& cameraIds)
249 {
250 std::lock_guard<std::mutex> lock(mutex_);
251 for (auto id : cameraIds_) {
252 MEDIA_INFO_LOG("CameraHostInfo::GetCameras, current camera %{public}s", id.c_str());
253 }
254 cameraIds.insert(cameraIds.end(), cameraIds_.begin(), cameraIds_.end());
255 return CAMERA_OK;
256 }
257
GetCameraAbility(const std::string & cameraId,std::shared_ptr<OHOS::Camera::CameraMetadata> & ability)258 int32_t HCameraHostManager::CameraHostInfo::GetCameraAbility(const std::string& cameraId,
259 std::shared_ptr<OHOS::Camera::CameraMetadata>& ability)
260 {
261 auto deviceInfo = FindCameraDeviceInfo(cameraId);
262 CHECK_RETURN_RET_ELOG(deviceInfo == nullptr, CAMERA_UNKNOWN_ERROR,
263 "CameraHostInfo::GetCameraAbility deviceInfo is null");
264 std::lock_guard<std::mutex> lock(deviceInfo->mutex);
265 if (deviceInfo->ability) {
266 ability = deviceInfo->ability;
267 } else {
268 CHECK_RETURN_RET_ELOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
269 "CameraHostInfo::GetCameraAbility cameraHostProxy_ is null");
270 if (!deviceInfo->ability) {
271 std::vector<uint8_t> cameraAbility;
272 CamRetCode rc = (CamRetCode)(cameraHostProxy_->GetCameraAbility(cameraId, cameraAbility));
273 if (rc != HDI::Camera::V1_0::NO_ERROR) {
274 MEDIA_ERR_LOG("CameraHostInfo::GetCameraAbility failed with error Code:%{public}d", rc);
275 CameraReportUtils::ReportCameraError(
276 "CameraHostInfo::GetCameraAbility", rc, true, CameraReportUtils::GetCallerInfo());
277 return HdiToServiceError(rc);
278 }
279 OHOS::Camera::MetadataUtils::ConvertVecToMetadata(cameraAbility, ability);
280 if (ability == nullptr) {
281 ability = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
282 }
283 deviceInfo->ability = ability;
284 }
285 }
286 #ifdef HOOK_CAMERA_OPERATOR
287 if (!CameraRotatePlugin::GetInstance()->HookCameraAbility(cameraId, ability)) {
288 MEDIA_DEBUG_LOG("CameraHostInfo::HookCameraAbility failed ");
289 }
290 #endif
291 return CAMERA_OK;
292 }
293
OpenCamera(std::string & cameraId,const sptr<ICameraDeviceCallback> & callback,sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> & pDevice,bool isEnableSecCam)294 int32_t HCameraHostManager::CameraHostInfo::OpenCamera(std::string& cameraId,
295 const sptr<ICameraDeviceCallback>& callback,
296 sptr<OHOS::HDI::Camera::V1_0::ICameraDevice>& pDevice,
297 bool isEnableSecCam)
298 {
299 MEDIA_INFO_LOG("CameraHostInfo::OpenCamera %{public}s", cameraId.c_str());
300 auto deviceInfo = FindCameraDeviceInfo(cameraId);
301 CHECK_RETURN_RET_ELOG(deviceInfo == nullptr, CAMERA_UNKNOWN_ERROR,
302 "CameraHostInfo::GetCameraAbility deviceInfo is null");
303 std::lock_guard<std::mutex> lock(deviceInfo->mutex);
304 CHECK_RETURN_RET_ELOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
305 "CameraHostInfo::OpenCamera cameraHostProxy_ is null");
306 CamRetCode rc;
307 // try to get higher version
308 sptr<OHOS::HDI::Camera::V1_1::ICameraDevice> hdiDevice_v1_1;
309 sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiDevice_v1_2;
310 sptr<OHOS::HDI::Camera::V1_3::ICameraDevice> hdiDevice_v1_3;
311 // LCOV_EXCL_START
312 if (cameraHostProxyV1_3_ != nullptr && GetCameraHostVersion() >= HDI_VERSION_ID_1_3) {
313 MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_3");
314 if (isEnableSecCam) {
315 MEDIA_INFO_LOG("CameraHostInfo::OpenCamera OpenSecureCamera");
316 rc = (CamRetCode)(cameraHostProxyV1_3_->OpenSecureCamera(cameraId, callback, hdiDevice_v1_3));
317 } else {
318 rc = (CamRetCode)(cameraHostProxyV1_3_->OpenCamera_V1_3(cameraId, callback, hdiDevice_v1_3));
319 }
320 pDevice = hdiDevice_v1_3.GetRefPtr();
321 } else if (cameraHostProxyV1_2_ != nullptr && GetCameraHostVersion() >= HDI_VERSION_ID_1_2) {
322 MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_2");
323 rc = (CamRetCode)(cameraHostProxyV1_2_->OpenCamera_V1_2(cameraId, callback, hdiDevice_v1_2));
324 pDevice = hdiDevice_v1_2.GetRefPtr();
325 } else if (cameraHostProxyV1_1_ != nullptr && GetCameraHostVersion() == HDI_VERSION_ID_1_1) {
326 MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_1");
327 rc = (CamRetCode)(cameraHostProxyV1_1_->OpenCamera_V1_1(cameraId, callback, hdiDevice_v1_1));
328 pDevice = hdiDevice_v1_1.GetRefPtr();
329 } else {
330 MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_0");
331 rc = (CamRetCode)(cameraHostProxy_->OpenCamera(cameraId, callback, pDevice));
332 }
333 // LCOV_EXCL_STOP
334 if (rc != HDI::Camera::V1_0::NO_ERROR) {
335 MEDIA_ERR_LOG("CameraHostInfo::OpenCamera failed with error Code:%{public}d", rc);
336 CameraReportUtils::ReportCameraError(
337 "CameraHostInfo::OpenCamera", rc, true, CameraReportUtils::GetCallerInfo());
338 pDevice = nullptr;
339 return HdiToServiceError(rc);
340 }
341 return CAMERA_OK;
342 }
343
SetFlashlight(const std::string & cameraId,bool isEnable)344 int32_t HCameraHostManager::CameraHostInfo::SetFlashlight(const std::string& cameraId, bool isEnable)
345 {
346 std::lock_guard<std::mutex> lock(mutex_);
347 CHECK_RETURN_RET_ELOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
348 "CameraHostInfo::SetFlashlight cameraHostProxy_ is null");
349 CamRetCode rc = (CamRetCode)(cameraHostProxy_->SetFlashlight(cameraId, isEnable));
350 if (rc != HDI::Camera::V1_0::NO_ERROR) {
351 MEDIA_ERR_LOG("CameraHostInfo::SetFlashlight failed with error Code:%{public}d", rc);
352 CameraReportUtils::ReportCameraError(
353 "CameraHostInfo::SetFlashlight", rc, true, CameraReportUtils::GetCallerInfo());
354 return HdiToServiceError(rc);
355 }
356 return CAMERA_OK;
357 }
358
SetTorchLevel(float level)359 int32_t HCameraHostManager::CameraHostInfo::SetTorchLevel(float level)
360 {
361 std::lock_guard<std::mutex> lock(mutex_);
362 CHECK_RETURN_RET_ELOG(cameraHostProxyV1_2_ == nullptr, CAMERA_UNKNOWN_ERROR,
363 "CameraHostInfo::SetTorchLevel cameraHostProxyV1_2_ is null");
364 HDI::Camera::V1_2::CamRetCode rc = (HDI::Camera::V1_2::CamRetCode)(cameraHostProxyV1_2_->SetFlashlight_V1_2(level));
365 if (rc != HDI::Camera::V1_2::NO_ERROR) {
366 MEDIA_ERR_LOG("CameraHostInfo::SetTorchLevel failed with error Code:%{public}d", rc);
367 CameraReportUtils::ReportCameraError(
368 "CameraHostInfo::SetTorchLevel", rc, true, CameraReportUtils::GetCallerInfo());
369 return HdiToServiceErrorV1_2(rc);
370 }
371 return CAMERA_OK;
372 }
373
UpdateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata> setting)374 void HCameraHostManager::CameraHostInfo::UpdateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata> setting)
375 {
376 MEDIA_DEBUG_LOG("CameraHostInfo::UpdateMuteSetting enter");
377 int32_t count = 1;
378 uint8_t mode = OHOS_CAMERA_MUTE_MODE_SOLID_COLOR_BLACK;
379 if (setting == nullptr) {
380 MEDIA_DEBUG_LOG("CameraHostInfo::UpdateMuteSetting setting is null");
381 constexpr int32_t DEFAULT_ITEMS = 1;
382 constexpr int32_t DEFAULT_DATA_LENGTH = 1;
383 setting = std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
384 }
385 setting->addEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
386 }
387
Prelaunch(sptr<HCameraRestoreParam> cameraRestoreParam,bool muteMode)388 int32_t HCameraHostManager::CameraHostInfo::Prelaunch(sptr<HCameraRestoreParam> cameraRestoreParam, bool muteMode)
389 {
390 CHECK_RETURN_RET_ELOG(cameraRestoreParam == nullptr, CAMERA_UNKNOWN_ERROR,
391 "CameraHostInfo::Prelaunch cameraRestoreParam is null");
392 CHECK_RETURN_RET(CheckUserHasChanged(cameraRestoreParam->GetSetting()), CAMERA_UNKNOWN_ERROR);
393 CHECK_RETURN_RET_ELOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
394 "CameraHostInfo::Prelaunch cameraHostProxy_ is null");
395 CHECK_RETURN_RET_ELOG(GetCameraHostVersion() < HDI_VERSION_ID_1_1, CAMERA_UNKNOWN_ERROR,
396 "CameraHostInfo::Prelaunch not support host V1_0!");
397 MEDIA_INFO_LOG("CameraHostInfo::prelaunch for cameraId %{public}s", (cameraRestoreParam->GetCameraId()).c_str());
398 for (auto& streamInfo : cameraRestoreParam->GetStreamInfo()) {
399 MEDIA_DEBUG_LOG("CameraHostInfo::prelaunch for stream id is:%{public}d", streamInfo.v1_0.streamId_);
400 }
401 OHOS::HDI::Camera::V1_1::PrelaunchConfig prelaunchConfig;
402 std::vector<uint8_t> settings;
403 prelaunchConfig.cameraId = cameraRestoreParam->GetCameraId();
404 prelaunchConfig.streamInfos_V1_1 = cameraRestoreParam->GetStreamInfo();
405 DumpMetadata(cameraRestoreParam->GetSetting());
406 CHECK_EXECUTE(muteMode, UpdateMuteSetting(cameraRestoreParam->GetSetting()));
407 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraRestoreParam->GetSetting(), settings);
408 prelaunchConfig.setting = settings;
409 int32_t opMode = cameraRestoreParam->GetCameraOpMode();
410 bool isNeedRestore = IsNeedRestore(opMode, cameraRestoreParam->GetSetting(), prelaunchConfig.cameraId);
411 CamRetCode rc;
412 if (cameraHostProxyV1_2_ != nullptr && GetCameraHostVersion() > HDI_VERSION_ID_1_1) {
413 if (isNeedRestore) {
414 MEDIA_INFO_LOG("CameraHostInfo::PrelaunchWithOpMode ICameraHost V1_2 %{public}d", opMode);
415 rc = (CamRetCode)(cameraHostProxyV1_2_->PrelaunchWithOpMode(prelaunchConfig, opMode));
416 } else {
417 MEDIA_INFO_LOG("CameraHostInfo::Prelaunch ICameraHost V1_2 %{public}d", opMode);
418 rc = (CamRetCode)(cameraHostProxyV1_2_->Prelaunch(prelaunchConfig));
419 }
420 // LCOV_EXCL_START
421 } else if (cameraHostProxyV1_1_ != nullptr && GetCameraHostVersion() == HDI_VERSION_ID_1_1) {
422 MEDIA_DEBUG_LOG("CameraHostInfo::Prelaunch ICameraHost V1_1");
423 rc = (CamRetCode)(cameraHostProxyV1_1_->Prelaunch(prelaunchConfig));
424 } else {
425 rc = HDI::Camera::V1_0::NO_ERROR;
426 // LCOV_EXCL_STOP
427 }
428 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
429 "CameraHostInfo::Prelaunch failed with error Code:%{public}d", rc);
430 return CAMERA_OK;
431 }
432
IsNeedRestore(int32_t opMode,std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings,std::string & cameraId)433 bool HCameraHostManager::CameraHostInfo::IsNeedRestore(int32_t opMode,
434 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings, std::string& cameraId)
435 {
436 CHECK_RETURN_RET(cameraSettings == nullptr, false);
437 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
438 int32_t ret = GetCameraAbility(cameraId, cameraAbility);
439 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK || cameraAbility == nullptr, false,
440 "CameraHostInfo::IsNeedRestore failed");
441 if (opMode == 0) { // 0 is normal mode
442 MEDIA_INFO_LOG("operationMode:%{public}d", opMode);
443 return true;
444 }
445 camera_metadata_item_t item;
446 ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility->get(), OHOS_ABILITY_CAMERA_MODES, &item);
447 if (ret != CAM_META_SUCCESS || item.count == 0) {
448 MEDIA_ERR_LOG("Failed to find stream extend configuration return code %{public}d", ret);
449 ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility->get(),
450 OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item);
451 if (ret == CAM_META_SUCCESS && item.count != 0) {
452 MEDIA_INFO_LOG("basic config no need valid mode");
453 return true;
454 }
455 return false;
456 }
457
458 for (uint32_t i = 0; i < item.count; i++) {
459 if (opMode == item.data.u8[i]) {
460 MEDIA_DEBUG_LOG("operationMode:%{public}d found in supported streams", opMode);
461 return true;
462 }
463 }
464 MEDIA_ERR_LOG("operationMode:%{public}d not found in supported streams", opMode);
465 return false;
466 }
PreCameraSwitch(const std::string & cameraId)467 int32_t HCameraHostManager::CameraHostInfo::PreCameraSwitch(const std::string& cameraId)
468 {
469 std::lock_guard<std::mutex> lock(mutex_);
470 CHECK_RETURN_RET_ELOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
471 "CameraHostInfo::PreCameraSwitch cameraHostProxy_ is null");
472 CHECK_RETURN_RET_ELOG(GetCameraHostVersion() <= HDI_VERSION_ID_1_1, CAMERA_UNKNOWN_ERROR,
473 "CameraHostInfo::PreCameraSwitch not support host V1_0 and V1_1!");
474 if (cameraHostProxyV1_2_ != nullptr) {
475 MEDIA_DEBUG_LOG("CameraHostInfo::PreCameraSwitch ICameraHost V1_2");
476 CamRetCode rc = (CamRetCode)(cameraHostProxyV1_2_->PreCameraSwitch(cameraId));
477 CHECK_RETURN_RET_ELOG(rc != HDI::Camera::V1_0::NO_ERROR, HdiToServiceError(rc),
478 "CameraHostInfo::PreCameraSwitch failed with error Code:%{public}d", rc);
479 }
480 return CAMERA_OK;
481 }
482
NotifyDeviceStateChangeInfo(int notifyType,int deviceState)483 void HCameraHostManager::CameraHostInfo::NotifyDeviceStateChangeInfo(int notifyType, int deviceState)
484 {
485 std::lock_guard<std::mutex> lock(mutex_);
486 CHECK_RETURN_ELOG(cameraHostProxy_ == nullptr, "CameraHostInfo::Prelaunch cameraHostProxy_ is null");
487 MEDIA_DEBUG_LOG("CameraHostInfo::NotifyDeviceStateChangeInfo notifyType = %{public}d, deviceState = %{public}d",
488 notifyType, deviceState);
489 if (cameraHostProxyV1_3_ != nullptr && GetCameraHostVersion() > HDI_VERSION_ID_1_1) {
490 MEDIA_DEBUG_LOG("CameraHostInfo::NotifyDeviceStateChangeInfo ICameraHost V1_2");
491 cameraHostProxyV1_3_->NotifyDeviceStateChangeInfo(notifyType, deviceState);
492 // LCOV_EXCL_START
493 } else if (cameraHostProxyV1_2_ != nullptr && GetCameraHostVersion() > HDI_VERSION_ID_1_1) {
494 MEDIA_DEBUG_LOG("CameraHostInfo::NotifyDeviceStateChangeInfo ICameraHost V1_2");
495 cameraHostProxyV1_2_->NotifyDeviceStateChangeInfo(notifyType, deviceState);
496 // LCOV_EXCL_STOP
497 }
498 }
499
GetCameraStorageSize(const int & userId,int64_t & storageSize)500 void HCameraHostManager::CameraHostInfo::GetCameraStorageSize(const int& userId, int64_t& storageSize)
501 {
502 }
503
CheckUserHasChanged(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings)504 bool HCameraHostManager::CameraHostInfo::CheckUserHasChanged(
505 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings)
506 {
507 CHECK_RETURN_RET_ELOG(cameraSettings == nullptr, false, "camera settings is nullptr.");
508 int32_t userId;
509 int32_t uid = IPCSkeleton::GetCallingUid();
510 AccountSA::OsAccountManager::GetOsAccountLocalIdFromUid(uid, userId);
511 camera_metadata_item_t item;
512 int32_t ret = OHOS::Camera::FindCameraMetadataItem(cameraSettings->get(), OHOS_CAMERA_USER_ID, &item);
513 if (ret == CAM_META_SUCCESS && userId != item.data.i32[0]) {
514 MEDIA_INFO_LOG("userId changed from %{public}d to %{public}d", item.data.i32[0], userId);
515 return true;
516 }
517 return false;
518 }
519
GetCameraResourceCost(const std::string & cameraId,OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost & resourceCost)520 int32_t HCameraHostManager::CameraHostInfo::GetCameraResourceCost(const std::string& cameraId,
521 OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost& resourceCost)
522 {
523 std::lock_guard<std::mutex> lock(mutex_);
524 if (cameraHostProxyV1_3_ != nullptr &&
525 cameraHostProxyV1_3_->GetResourceCost(cameraId, resourceCost) ==
526 HDI::Camera::V1_0::CamRetCode::NO_ERROR) {
527 return CAMERA_OK;
528 }
529 return CAMERA_UNSUPPORTED;
530 }
531
OnCameraStatus(const std::string & cameraId,HDI::Camera::V1_0::CameraStatus status)532 int32_t HCameraHostManager::CameraHostInfo::OnCameraStatus(
533 const std::string& cameraId, HDI::Camera::V1_0::CameraStatus status)
534 {
535 auto statusCallback = statusCallback_.lock();
536 if (statusCallback == nullptr) {
537 MEDIA_WARNING_LOG("CameraHostInfo::OnCameraStatus for %{public}s with status %{public}d "
538 "failed due to no callback",
539 cameraId.c_str(), status);
540 return CAMERA_UNKNOWN_ERROR;
541 }
542 CameraStatus svcStatus = CAMERA_STATUS_UNAVAILABLE;
543 switch (status) {
544 case UN_AVAILABLE: {
545 MEDIA_INFO_LOG("CameraHostInfo::OnCameraStatus, camera %{public}s unavailable", cameraId.c_str());
546 svcStatus = CAMERA_STATUS_UNAVAILABLE;
547 break;
548 }
549 case AVAILABLE: {
550 MEDIA_INFO_LOG("CameraHostInfo::OnCameraStatus, camera %{public}s available", cameraId.c_str());
551 svcStatus = CAMERA_STATUS_AVAILABLE;
552 AddDevice(cameraId);
553 break;
554 }
555 default:
556 MEDIA_ERR_LOG("Unknown camera status: %{public}d", status);
557 return CAMERA_UNKNOWN_ERROR;
558 }
559 statusCallback->OnCameraStatus(cameraId, svcStatus);
560 return CAMERA_OK;
561 }
562
NotifyCameraHostDied()563 void HCameraHostManager::CameraHostInfo::NotifyCameraHostDied()
564 {
565 auto statusCallback = statusCallback_.lock();
566 if (statusCallback == nullptr) {
567 MEDIA_WARNING_LOG("CameraHostInfo::NotifyCameraHostDied failed due to no callback!");
568 return;
569 }
570 std::vector<std::string> cameraIds;
571 if (statusCallback && this->GetCameras(cameraIds) == CAMERA_OK) {
572 for (const auto& cameraId : cameraIds) {
573 statusCallback->OnCameraStatus(cameraId, CAMERA_SERVER_UNAVAILABLE);
574 }
575 }
576 }
577
578 // LCOV_EXCL_START
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)579 int32_t HCameraHostManager::CameraHostInfo::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
580 {
581 auto statusCallback = statusCallback_.lock();
582 if (statusCallback == nullptr) {
583 MEDIA_WARNING_LOG("CameraHostInfo::OnFlashlightStatus for %{public}s with status %{public}d "
584 "failed due to no callback",
585 cameraId.c_str(), status);
586 return CAMERA_UNKNOWN_ERROR;
587 }
588 FlashStatus flashStatus = FLASH_STATUS_OFF;
589 switch (status) {
590 case FLASHLIGHT_OFF:
591 flashStatus = FLASH_STATUS_OFF;
592 MEDIA_INFO_LOG(
593 "CameraHostInfo::OnFlashlightStatus, camera %{public}s flash light is off", cameraId.c_str());
594 break;
595
596 case FLASHLIGHT_ON:
597 flashStatus = FLASH_STATUS_ON;
598 MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus, camera %{public}s flash light is on", cameraId.c_str());
599 break;
600
601 case FLASHLIGHT_UNAVAILABLE:
602 flashStatus = FLASH_STATUS_UNAVAILABLE;
603 MEDIA_INFO_LOG(
604 "CameraHostInfo::OnFlashlightStatus, camera %{public}s flash light is unavailable", cameraId.c_str());
605 break;
606
607 default:
608 MEDIA_ERR_LOG("Unknown flashlight status: %{public}d for camera %{public}s", status, cameraId.c_str());
609 return CAMERA_UNKNOWN_ERROR;
610 }
611 statusCallback->OnFlashlightStatus(cameraId, flashStatus);
612 return CAMERA_OK;
613 }
614 // LCOV_EXCL_STOP
615
OnFlashlightStatus_V1_2(FlashlightStatus status)616 int32_t HCameraHostManager::CameraHostInfo::OnFlashlightStatus_V1_2(FlashlightStatus status)
617 {
618 auto statusCallback = statusCallback_.lock();
619 if (statusCallback == nullptr) {
620 MEDIA_WARNING_LOG(
621 "CameraHostInfo::OnFlashlightStatus_V1_2 with status %{public}d failed due to no callback", status);
622 return CAMERA_UNKNOWN_ERROR;
623 }
624 TorchStatus torchStatus = TorchStatus::TORCH_STATUS_OFF;
625 switch (status) {
626 case FLASHLIGHT_OFF:
627 torchStatus = TorchStatus::TORCH_STATUS_OFF;
628 MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, torch status is off");
629 break;
630
631 case FLASHLIGHT_ON:
632 torchStatus = TorchStatus::TORCH_STATUS_ON;
633 MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, torch status is on");
634 break;
635
636 case FLASHLIGHT_UNAVAILABLE:
637 torchStatus = TorchStatus::TORCH_STATUS_UNAVAILABLE;
638 MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, torch status is unavailable");
639 break;
640
641 default:
642 MEDIA_ERR_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, Unknown flashlight status: %{public}d", status);
643 return CAMERA_UNKNOWN_ERROR;
644 }
645 statusCallback->OnTorchStatus(torchStatus);
646 return CAMERA_OK;
647 }
648
OnCameraEvent(const std::string & cameraId,CameraEvent event)649 int32_t HCameraHostManager::CameraHostInfo::OnCameraEvent(const std::string& cameraId, CameraEvent event)
650 {
651 auto statusCallback = statusCallback_.lock();
652 if (statusCallback == nullptr) {
653 MEDIA_WARNING_LOG(
654 "CameraHostInfo::OnCameraEvent for %{public}s with status %{public}d failed due to no callback",
655 cameraId.c_str(), event);
656 return CAMERA_UNKNOWN_ERROR;
657 }
658 CameraStatus svcStatus = CAMERA_STATUS_UNAVAILABLE;
659 switch (event) {
660 case CAMERA_EVENT_DEVICE_RMV: {
661 MEDIA_INFO_LOG("CameraHostInfo::OnCameraEvent, camera %{public}s unavailable", cameraId.c_str());
662 svcStatus = CAMERA_STATUS_DISAPPEAR;
663 RemoveDevice(cameraId);
664 break;
665 }
666 case CAMERA_EVENT_DEVICE_ADD: {
667 MEDIA_INFO_LOG("CameraHostInfo::OnCameraEvent camera %{public}s available", cameraId.c_str());
668 svcStatus = CAMERA_STATUS_APPEAR;
669 AddDevice(cameraId);
670 std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
671 camera_metadata_item_t item;
672 std::string camera = cameraId;
673 AddDevice(cameraId);
674 int32_t ret = GetCameraAbility(camera, cameraAbility);
675 CHECK_RETURN_RET_ELOG(ret != CAMERA_OK || cameraAbility == nullptr, CAMERA_DEVICE_ERROR,
676 "CameraHostInfo::OnCameraEvent can't get camera ability");
677 svcStatus = CAMERA_STATUS_APPEAR;
678 ret =
679 OHOS::Camera::FindCameraMetadataItem(cameraAbility->get(), OHOS_ABILITY_CAMERA_CONNECTION_TYPE, &item);
680 if (ret == CAM_META_SUCCESS) {
681 auto connectionType = item.data.u8[0];
682 if (connectionType == 1) {
683 CameraReportUtils::GetInstance().ReportUserBehaviorAddDevice(
684 "AddDevice", camera, CameraReportUtils::GetCallerInfo());
685 }
686 }
687 break;
688 }
689 default:
690 MEDIA_ERR_LOG("Unknown camera event: %{public}d", event);
691 return CAMERA_UNKNOWN_ERROR;
692 }
693 statusCallback->OnCameraStatus(cameraId, svcStatus);
694 return CAMERA_OK;
695 }
696
FindCameraDeviceInfo(const std::string & cameraId)697 std::shared_ptr<HCameraHostManager::CameraDeviceInfo> HCameraHostManager::CameraHostInfo::FindCameraDeviceInfo
698 (const std::string& cameraId)
699 {
700 std::lock_guard<std::mutex> lock(mutex_);
701 std::vector<std::shared_ptr<CameraDeviceInfo>>::iterator it = std::find_if(devices_.begin(), devices_.end(),
702 [cameraId](const auto& deviceInfo) { return deviceInfo->cameraId == cameraId; });
703 if (it != devices_.end()) {
704 MEDIA_INFO_LOG("CameraHostInfo::FindCameraDeviceInfo succeed for %{public}s", cameraId.c_str());
705 return (*it);
706 }
707 MEDIA_WARNING_LOG("CameraHostInfo::FindCameraDeviceInfo failed for %{public}s", cameraId.c_str());
708 return nullptr;
709 }
710
AddDevice(const std::string & cameraId)711 void HCameraHostManager::CameraHostInfo::AddDevice(const std::string& cameraId)
712 {
713 std::lock_guard<std::mutex> lock(mutex_);
714 if (std::none_of(devices_.begin(), devices_.end(),
715 [&cameraId](auto& devInfo) { return devInfo->cameraId == cameraId; })) {
716 cameraIds_.push_back(cameraId);
717 devices_.push_back(std::make_shared<HCameraHostManager::CameraDeviceInfo>(cameraId));
718 MEDIA_INFO_LOG("CameraHostInfo::AddDevice, camera %{public}s added", cameraId.c_str());
719 } else {
720 MEDIA_WARNING_LOG("CameraHostInfo::AddDevice, camera %{public}s already exists", cameraId.c_str());
721 }
722 }
723
RemoveDevice(const std::string & cameraId)724 void HCameraHostManager::CameraHostInfo::RemoveDevice(const std::string& cameraId)
725 {
726 std::lock_guard<std::mutex> lock(mutex_);
727 MEDIA_INFO_LOG("CameraHostInfo::RemoveDevice, camera %{public}s removed", cameraId.c_str());
728 cameraIds_.erase(std::remove(cameraIds_.begin(), cameraIds_.end(), cameraId), cameraIds_.end());
729 devices_.erase(std::remove_if(devices_.begin(), devices_.end(),
730 [&cameraId](const auto& devInfo) { return devInfo->cameraId == cameraId; }),
731 devices_.end());
732 for (auto id : cameraIds_) {
733 MEDIA_INFO_LOG("CameraHostInfo::RemoveDevice, current camera %{public}s", id.c_str());
734 }
735 }
736
HCameraHostManager(std::shared_ptr<StatusCallback> statusCallback)737 HCameraHostManager::HCameraHostManager(std::shared_ptr<StatusCallback> statusCallback)
738 : statusCallback_(statusCallback), cameraHostInfos_(), muteMode_(false)
739 {
740 MEDIA_INFO_LOG("HCameraHostManager construct called");
741 }
742
~HCameraHostManager()743 HCameraHostManager::~HCameraHostManager()
744 {
745 MEDIA_INFO_LOG("HCameraHostManager deconstruct called");
746 std::lock_guard<std::mutex> lock(deviceMutex_);
747 for (auto it = cameraDevices_.begin(); it != cameraDevices_.end(); it++) {
748 if (it->second) {
749 it->second = nullptr;
750 }
751 }
752 cameraDevices_.clear();
753
754 for (unsigned i = 0; i < cameraHostInfos_.size(); i++) {
755 cameraHostInfos_[i] = nullptr;
756 }
757 cameraHostInfos_.clear();
758 }
759
Init()760 int32_t HCameraHostManager::Init()
761 {
762 MEDIA_INFO_LOG("HCameraHostManager::Init");
763 using namespace OHOS::HDI::ServiceManager::V1_0;
764 auto svcMgr = IServiceManager::Get();
765 CHECK_RETURN_RET_ELOG(svcMgr == nullptr, CAMERA_UNKNOWN_ERROR,
766 "HCameraHostManager::Init IServiceManager failed!");
767
768 ::OHOS::sptr<IServStatListener> listener(
769 new RegisterServStatListener(RegisterServStatListener::StatusCallback([&](const ServiceStatus& status) {
770 using namespace OHOS::HDI::ServiceManager::V1_0;
771
772 switch (status.status) {
773 case SERVIE_STATUS_START:
774 AddCameraHost(status.serviceName);
775 break;
776 case SERVIE_STATUS_STOP:
777 RemoveCameraHost(status.serviceName);
778 break;
779 default:
780 MEDIA_ERR_LOG("HCameraHostManager::OnReceive unexpected service status %{public}d", status.status);
781 }
782 })
783 ));
784
785 auto rt = svcMgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_CAMERA);
786 CHECK_RETURN_RET_ELOG(rt != 0, CAMERA_UNKNOWN_ERROR,
787 "HCameraHostManager::Init RegisterServiceStatusListener failed!");
788 registerServStatListener_ = listener;
789
790 return CAMERA_OK;
791 }
792
DeInit()793 void HCameraHostManager::DeInit()
794 {
795 using namespace OHOS::HDI::ServiceManager::V1_0;
796 auto svcMgr = IServiceManager::Get();
797 CHECK_RETURN_ELOG(svcMgr == nullptr, "HCameraHostManager::DeInit(): IServiceManager failed");
798 auto rt = svcMgr->UnregisterServiceStatusListener(registerServStatListener_);
799 CHECK_PRINT_ELOG(rt != 0, "HCameraHostManager::DeInit(): UnregisterServiceStatusListener failed!");
800 registerServStatListener_ = nullptr;
801 }
802
AddCameraDevice(const std::string & cameraId,sptr<ICameraDeviceService> cameraDevice)803 void HCameraHostManager::AddCameraDevice(const std::string& cameraId, sptr<ICameraDeviceService> cameraDevice)
804 {
805 std::lock_guard<std::mutex> lock(deviceMutex_);
806 auto it = cameraDevices_.find(cameraId);
807 if (it != cameraDevices_.end()) {
808 it->second = nullptr;
809 cameraDevices_.erase(cameraId);
810 }
811 cameraDevices_[cameraId] = cameraDevice;
812 auto statusCallback = statusCallback_.lock();
813 CHECK_EXECUTE(statusCallback != nullptr,
814 statusCallback->OnCameraStatus(cameraId, CAMERA_STATUS_UNAVAILABLE, CallbackInvoker::APPLICATION));
815 }
816
RemoveCameraDevice(const std::string & cameraId)817 void HCameraHostManager::RemoveCameraDevice(const std::string& cameraId)
818 {
819 MEDIA_DEBUG_LOG("HCameraHostManager::RemoveCameraDevice start");
820 {
821 std::lock_guard<std::mutex> lock(deviceMutex_);
822 auto it = cameraDevices_.find(cameraId);
823 if (it != cameraDevices_.end()) {
824 it->second = nullptr;
825 }
826 cameraDevices_.erase(cameraId);
827 auto statusCallback = statusCallback_.lock();
828 CHECK_EXECUTE(statusCallback,
829 statusCallback->OnCameraStatus(cameraId, CAMERA_STATUS_AVAILABLE, CallbackInvoker::APPLICATION));
830 }
831 {
832 std::lock_guard<std::mutex> lock(openPrelaunchMutex_);
833 if (cameraDevices_.size() == 0) {
834 isHasOpenCamera_ = false;
835 }
836 isHasPrelaunch_ = false;
837 }
838 MEDIA_DEBUG_LOG("HCameraHostManager::RemoveCameraDevice end");
839 }
840
CloseCameraDevice(const std::string & cameraId)841 void HCameraHostManager::CloseCameraDevice(const std::string& cameraId)
842 {
843 sptr<ICameraDeviceService> deviceToDisconnect = nullptr;
844 {
845 std::lock_guard<std::mutex> lock(deviceMutex_);
846 auto iter = cameraDevices_.find(cameraId);
847 if (iter != cameraDevices_.end()) {
848 deviceToDisconnect = iter->second;
849 }
850 }
851 CHECK_RETURN(!deviceToDisconnect);
852 MEDIA_DEBUG_LOG("HCameraDevice::CloseCameraDevice should clean %{public}s device", cameraId.c_str());
853 HCameraDevice* devicePtr = static_cast<HCameraDevice*>(deviceToDisconnect.GetRefPtr());
854 devicePtr->RemoveResourceWhenHostDied();
855 }
856
GetCameras(std::vector<std::string> & cameraIds)857 int32_t HCameraHostManager::GetCameras(std::vector<std::string>& cameraIds)
858 {
859 CAMERA_SYNC_TRACE;
860 MEDIA_INFO_LOG("HCameraHostManager::GetCameras");
861 CHECK_EXECUTE(!IsCameraHostInfoAdded(LOCAL_SERVICE_NAME), AddCameraHost(LOCAL_SERVICE_NAME));
862 std::lock_guard<std::mutex> lock(mutex_);
863 cameraIds.clear();
864 for (const auto& cameraHost : cameraHostInfos_) {
865 cameraHost->GetCameras(cameraIds);
866 }
867 return CAMERA_OK;
868 }
869
GetCameraIdSortedByCameraType(std::vector<std::string> & cameraIds)870 int32_t HCameraHostManager::GetCameraIdSortedByCameraType(std::vector<std::string>& cameraIds)
871 {
872 CAMERA_SYNC_TRACE;
873 MEDIA_INFO_LOG("HCameraHostManager::GetCameraIdSortedByCameraType");
874 if (!IsCameraHostInfoAdded(LOCAL_SERVICE_NAME)) {
875 AddCameraHost(LOCAL_SERVICE_NAME);
876 }
877 {
878 std::lock_guard<std::mutex> lock(mutex_);
879 cameraIds.clear();
880 for (const auto& cameraHost : cameraHostInfos_) {
881 cameraHost->GetCameras(cameraIds);
882 }
883 }
884 std::unordered_map<std::string, int32_t>cameraTypes;
885 for (auto id : cameraIds) {
886 std::shared_ptr<OHOS::Camera::CameraMetadata> ability;
887 GetCameraAbility(id, ability);
888 int32_t cameratypenow = 0;
889 camera_metadata_item_t item;
890 int32_t ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_TYPE, &item);
891 if (item.count < 1) {
892 cameraTypes[id] = cameratypenow;
893 continue;
894 }
895 cameratypenow = (ret == CAM_META_SUCCESS) ? item.data.u8[0] : OHOS_CAMERA_TYPE_UNSPECIFIED;
896 cameraTypes[id] = cameratypenow;
897 }
898
899 std::sort(cameraIds.begin(), cameraIds.end(), [&](const std::string& first, const std::string& second) {
900 return cameraTypes[first] < cameraTypes[second];
901 });
902 return CAMERA_OK;
903 }
904
GetCameraAbility(const std::string & cameraId,std::shared_ptr<OHOS::Camera::CameraMetadata> & ability)905 int32_t HCameraHostManager::GetCameraAbility(const std::string &cameraId,
906 std::shared_ptr<OHOS::Camera::CameraMetadata> &ability)
907 {
908 auto cameraHostInfo = FindCameraHostInfo(cameraId);
909 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
910 "HCameraHostManager::GetCameraAbility failed with invalid device info.");
911 return cameraHostInfo->GetCameraAbility(cameraId, ability);
912 }
913
GetVersionByCamera(const std::string & cameraId)914 int32_t HCameraHostManager::GetVersionByCamera(const std::string& cameraId)
915 {
916 MEDIA_INFO_LOG("GetVersionByCamera camera = %{public}s", cameraId.c_str());
917 auto cameraHostInfo = FindCameraHostInfo(cameraId);
918 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, 0, "GetVersionByCamera failed with invalid device info");
919 return cameraHostInfo->GetCameraHostVersion();
920 }
921
OpenCameraDevice(std::string & cameraId,const sptr<ICameraDeviceCallback> & callback,sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> & pDevice,bool isEnableSecCam)922 int32_t HCameraHostManager::OpenCameraDevice(std::string &cameraId,
923 const sptr<ICameraDeviceCallback> &callback,
924 sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> &pDevice,
925 bool isEnableSecCam)
926 {
927 MEDIA_INFO_LOG("HCameraHostManager::OpenCameraDevice try to open camera = %{public}s", cameraId.c_str());
928 auto cameraHostInfo = FindCameraHostInfo(cameraId);
929 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
930 "HCameraHostManager::OpenCameraDevice failed with invalid device info.");
931 {
932 std::lock_guard<std::mutex> lock(openPrelaunchMutex_);
933 int32_t uid = IPCSkeleton::GetCallingUid();
934 CHECK_RETURN_RET_ELOG((isHasPrelaunch_ && uid < MAX_SYS_UID), CAMERA_INVALID_ARG,
935 "HCameraHostManager::OpenCameraDevice sys is not allowed after prelaunch.");
936 int32_t ret = cameraHostInfo->OpenCamera(cameraId, callback, pDevice, isEnableSecCam);
937 CHECK_EXECUTE(ret == 0, isHasOpenCamera_ = true);
938 CHECK_EXECUTE(closeTimer_, {closeTimer_->CancelTask(); closeTimer_ = nullptr;});
939 return ret;
940 }
941 }
942
SetTorchLevel(float level)943 int32_t HCameraHostManager::SetTorchLevel(float level)
944 {
945 CHECK_EXECUTE(!IsCameraHostInfoAdded(LOCAL_SERVICE_NAME), AddCameraHost(LOCAL_SERVICE_NAME));
946 auto cameraHostInfo = FindLocalCameraHostInfo();
947 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
948 "HCameraHostManager::SetTorchLevel failed with not exist support device info");
949 return cameraHostInfo->SetTorchLevel(level);
950 }
951
SetFlashlight(const std::string & cameraId,bool isEnable)952 int32_t HCameraHostManager::SetFlashlight(const std::string& cameraId, bool isEnable)
953 {
954 auto cameraHostInfo = FindCameraHostInfo(cameraId);
955 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
956 "HCameraHostManager::SetFlashlight failed with invalid device info");
957 return cameraHostInfo->SetFlashlight(cameraId, isEnable);
958 }
959
Prelaunch(const std::string & cameraId,std::string clientName)960 int32_t HCameraHostManager::Prelaunch(const std::string& cameraId, std::string clientName)
961 {
962 MEDIA_DEBUG_LOG("HCameraHostManager::Prelaunch start");
963 auto cameraHostInfo = FindCameraHostInfo(cameraId);
964 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
965 "HCameraHostManager::Prelaunch failed with invalid device info");
966 sptr<HCameraRestoreParam> cameraRestoreParam = GetRestoreParam(clientName, cameraId);
967 CHECK_RETURN_RET_ELOG(cameraRestoreParam == nullptr, CAMERA_INVALID_ARG,
968 "HCameraHostManager::Prelaunch cameraRestoreParam is null");
969 int foldStatus = static_cast<int>(OHOS::Rosen::DisplayManager::GetInstance().GetFoldStatus());
970 int restoreFoldStatus = cameraRestoreParam->GetFlodStatus();
971 MEDIA_DEBUG_LOG("HCameraHostManager::Prelaunch foldStatus:%{public}d, restoreFoldStatus:%{public}d",
972 foldStatus, restoreFoldStatus);
973 if (foldStatus != restoreFoldStatus && restoreFoldStatus != 0) {
974 MEDIA_DEBUG_LOG("HCameraHostManager::SaveRestoreParam %d", foldStatus);
975 return 0;
976 }
977 {
978 std::lock_guard<std::mutex> lock(openPrelaunchMutex_);
979 CHECK_RETURN_RET_ELOG(isHasOpenCamera_, CAMERA_INVALID_ARG,
980 "HCameraHostManager::Prelaunch failed that has been running");
981 int32_t ret = cameraHostInfo->Prelaunch(cameraRestoreParam, muteMode_);
982 constexpr uint32_t delayMilli = 2 * 1000; // 2S 1000 is ms
983 CHECK_EXECUTE(closeTimer_, closeTimer_->CancelTask());
984 closeTimer_ = std::make_shared<SimpleTimer>([this] {
985 this->isHasPrelaunch_ = false;
986 });
987 bool isStartSuccess = closeTimer_->StartTask(delayMilli);
988 CHECK_EXECUTE(ret == 0 && isStartSuccess, isHasPrelaunch_ = true);
989 if (ret == 0 && cameraRestoreParam->GetRestoreParamType() ==
990 RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS) {
991 return CAMERA_OK;
992 }
993 }
994 // 使用后删除存储的动态数据
995 std::lock_guard<std::mutex> lock(saveRestoreMutex_);
996 auto it = transitentParamMap_.find(clientName);
997 CHECK_EXECUTE(it != transitentParamMap_.end() && CheckCameraId(it->second, cameraId),
998 transitentParamMap_.erase(clientName));
999 return 0;
1000 }
1001
PreSwitchCamera(const std::string & cameraId)1002 int32_t HCameraHostManager::PreSwitchCamera(const std::string& cameraId)
1003 {
1004 auto cameraHostInfo = FindCameraHostInfo(cameraId);
1005 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
1006 "HCameraHostManager::PreSwitchCamera failed with invalid device info");
1007 return cameraHostInfo->PreCameraSwitch(cameraId);
1008 }
1009
NotifyDeviceStateChangeInfo(int notifyType,int deviceState)1010 void HCameraHostManager::NotifyDeviceStateChangeInfo(int notifyType, int deviceState)
1011 {
1012 auto cameraHostInfo = FindLocalCameraHostInfo();
1013 CHECK_RETURN_ELOG(cameraHostInfo == nullptr,
1014 "HCameraHostManager::NotifyDeviceStateChangeInfo failed with not exist support device info");
1015
1016 cameraHostInfo->NotifyDeviceStateChangeInfo(notifyType, deviceState);
1017 }
1018
SaveRestoreParam(sptr<HCameraRestoreParam> cameraRestoreParam)1019 void HCameraHostManager::SaveRestoreParam(sptr<HCameraRestoreParam> cameraRestoreParam)
1020 {
1021 std::lock_guard<std::mutex> lock(saveRestoreMutex_);
1022 CHECK_RETURN_ELOG(cameraRestoreParam == nullptr, "HCameraRestoreParam is nullptr");
1023 std::string clientName = cameraRestoreParam->GetClientName();
1024 if (cameraRestoreParam->GetRestoreParamType() == RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS) {
1025 DeleteRestoreParam(clientName, cameraRestoreParam->GetCameraId());
1026 (persistentParamMap_[clientName])[cameraRestoreParam->GetCameraId()] = cameraRestoreParam;
1027 MEDIA_DEBUG_LOG("HCameraHostManager::SaveRestoreParam save persistent param");
1028 } else {
1029 auto itTransitent = transitentParamMap_.find(clientName);
1030 CHECK_EXECUTE(itTransitent != transitentParamMap_.end(), transitentParamMap_.erase(clientName));
1031 transitentParamMap_[clientName] = cameraRestoreParam;
1032 MEDIA_DEBUG_LOG("HCameraHostManager::SaveRestoreParam save transist param");
1033 isHasSavedParam = true;
1034 }
1035 }
1036
UpdateRestoreParamCloseTime(const std::string & clientName,const std::string & cameraId)1037 void HCameraHostManager::UpdateRestoreParamCloseTime(const std::string& clientName, const std::string& cameraId)
1038 {
1039 MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParamCloseTime enter");
1040 timeval closeTime;
1041 gettimeofday(&closeTime, nullptr);
1042 std::lock_guard<std::mutex> lock(saveRestoreMutex_);
1043 auto itPersistent = persistentParamMap_.find(clientName);
1044 if (itPersistent != persistentParamMap_.end()) {
1045 MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParamCloseTime find persistentParam");
1046 std::map<std::string, sptr<HCameraRestoreParam>>::iterator iter = (persistentParamMap_[clientName]).begin();
1047 while (iter != (persistentParamMap_[clientName]).end()) {
1048 auto cameraRestoreParam = iter->second;
1049 if (cameraId == cameraRestoreParam->GetCameraId()) {
1050 cameraRestoreParam->SetCloseCameraTime(closeTime);
1051 MEDIA_DEBUG_LOG("HCameraHostManager::Update persistent closeTime");
1052 } else {
1053 cameraRestoreParam->SetCloseCameraTime({0, 0});
1054 }
1055 ++iter;
1056 }
1057 }
1058
1059 auto itTransitent = transitentParamMap_.find(clientName);
1060 if (!isHasSavedParam && itTransitent != transitentParamMap_.end()) {
1061 transitentParamMap_.erase(clientName);
1062 return;
1063 }
1064
1065 CHECK_RETURN(itTransitent == transitentParamMap_.end());
1066 MEDIA_INFO_LOG("HCameraHostManager::Update transient CloseTime ");
1067 transitentParamMap_[clientName]->SetCloseCameraTime(closeTime);
1068 isHasSavedParam = false;
1069 }
1070
DeleteRestoreParam(const std::string & clientName,const std::string & cameraId)1071 void HCameraHostManager::DeleteRestoreParam(const std::string& clientName, const std::string& cameraId)
1072 {
1073 MEDIA_DEBUG_LOG("HCameraHostManager::DeleteRestoreParam enter");
1074 auto itPersistent = persistentParamMap_.find(clientName);
1075 CHECK_RETURN(itPersistent == persistentParamMap_.end());
1076 auto iterParamMap = (itPersistent->second).find(cameraId);
1077 if (iterParamMap != (itPersistent->second).end()) {
1078 iterParamMap->second = nullptr;
1079 (itPersistent->second).erase(cameraId);
1080 }
1081 }
1082
GetRestoreParam(const std::string & clientName,const std::string & cameraId)1083 sptr<HCameraRestoreParam> HCameraHostManager::GetRestoreParam(const std::string& clientName,
1084 const std::string& cameraId)
1085 {
1086 MEDIA_DEBUG_LOG("HCameraHostManager::GetRestoreParam enter");
1087 std::lock_guard<std::mutex> lock(saveRestoreMutex_);
1088 std::vector<StreamInfo_V1_1> streamInfos;
1089 RestoreParamTypeOhos restoreParamType = RestoreParamTypeOhos::NO_NEED_RESTORE_PARAM_OHOS;
1090 sptr<HCameraRestoreParam> cameraRestoreParam = new HCameraRestoreParam(clientName, cameraId,
1091 streamInfos, nullptr, restoreParamType, 0);
1092 auto it = persistentParamMap_.find(clientName);
1093 if (it != persistentParamMap_.end()) {
1094 MEDIA_DEBUG_LOG("HCameraHostManager::GetRestoreParam find persistent param");
1095 UpdateRestoreParam(cameraRestoreParam);
1096 } else {
1097 cameraRestoreParam = GetTransitentParam(clientName, cameraId);
1098 MEDIA_DEBUG_LOG("HCameraHostManager::GetRestoreParam find transist param");
1099 }
1100 return cameraRestoreParam;
1101 }
1102
UpdateRestoreParam(sptr<HCameraRestoreParam> & cameraRestoreParam)1103 void HCameraHostManager::UpdateRestoreParam(sptr<HCameraRestoreParam> &cameraRestoreParam)
1104 {
1105 CHECK_RETURN_ELOG(cameraRestoreParam == nullptr, "HCameraHostManager::UpdateRestoreParam is nullptr");
1106 std::string clientName = cameraRestoreParam->GetClientName();
1107 std::string cameraId = cameraRestoreParam->GetCameraId();
1108 std::map<std::string, sptr<HCameraRestoreParam>>::iterator iter = (persistentParamMap_[clientName]).begin();
1109 while (iter != (persistentParamMap_[clientName]).end()) {
1110 auto restoreParam = iter->second;
1111 timeval closeTime = restoreParam->GetCloseCameraTime();
1112 MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParam closeTime.tv_sec");
1113 if (closeTime.tv_sec != 0 && CheckCameraId(restoreParam, cameraId)) {
1114 timeval openTime;
1115 gettimeofday(&openTime, nullptr);
1116 int64_t sec_diff = openTime.tv_sec - closeTime.tv_sec;
1117 int64_t usec_diff = openTime.tv_usec - closeTime.tv_usec;
1118 if (usec_diff < 0) {
1119 sec_diff -= 1;
1120 usec_diff += MILLISEC_TIME * MILLISEC_TIME;
1121 }
1122 int64_t timeInterval = sec_diff * MILLISEC_TIME + usec_diff / MILLISEC_TIME;
1123 if ((restoreParam->GetStartActiveTime() * 60 * MILLISEC_TIME) < timeInterval) { // 60 is 60 Seconds
1124 MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParam get persistent");
1125 cameraRestoreParam = restoreParam;
1126 } else {
1127 MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParam get transistent ");
1128 cameraRestoreParam = GetTransitentParam(clientName, cameraId);
1129 }
1130 cameraRestoreParam->UpdateExposureSetting(timeInterval);
1131 break;
1132 }
1133 ++iter;
1134 }
1135 }
1136
GetTransitentParam(const std::string & clientName,const std::string & cameraId)1137 sptr<HCameraRestoreParam> HCameraHostManager::GetTransitentParam(const std::string& clientName,
1138 const std::string& cameraId)
1139 {
1140 std::vector<StreamInfo_V1_1> streamInfos;
1141 RestoreParamTypeOhos restoreParamType = RestoreParamTypeOhos::NO_NEED_RESTORE_PARAM_OHOS;
1142 sptr<HCameraRestoreParam> cameraRestoreParam = new HCameraRestoreParam(clientName, cameraId,
1143 streamInfos, nullptr, restoreParamType, 0);
1144 auto iter = transitentParamMap_.find(clientName);
1145 if (iter != transitentParamMap_.end() && (CheckCameraId(transitentParamMap_[clientName], cameraId))) {
1146 cameraRestoreParam = transitentParamMap_[clientName];
1147 MEDIA_DEBUG_LOG("HCameraHostManager::GetTransitentParam end");
1148 }
1149 return cameraRestoreParam;
1150 }
1151
CheckCameraId(sptr<HCameraRestoreParam> cameraRestoreParam,const std::string & cameraId)1152 bool HCameraHostManager::CheckCameraId(sptr<HCameraRestoreParam> cameraRestoreParam, const std::string& cameraId)
1153 {
1154 CHECK_RETURN_RET(cameraRestoreParam == nullptr, false);
1155 CHECK_RETURN_RET(cameraRestoreParam->GetCameraId() == cameraId, true);
1156 return false;
1157 }
1158
1159
AddCameraHost(const std::string & svcName)1160 void HCameraHostManager::AddCameraHost(const std::string& svcName)
1161 {
1162 MEDIA_INFO_LOG("HCameraHostManager::AddCameraHost camera host %{public}s added", svcName.c_str());
1163 std::lock_guard<std::mutex> lock(mutex_);
1164 if (std::any_of(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1165 [&svcName](const auto& camHost) { return camHost->GetName() == svcName; })) {
1166 MEDIA_INFO_LOG("HCameraHostManager::AddCameraHost camera host %{public}s already exists", svcName.c_str());
1167 return;
1168 }
1169 if (cameraHostDeadCallback_ == nullptr) {
1170 cameraHostDeadCallback_ = std::make_shared<CameraHostDeadCallback>(this);
1171 }
1172 auto statusCallback = statusCallback_.lock();
1173 sptr<HCameraHostManager::CameraHostInfo> cameraHost =
1174 new (std::nothrow) HCameraHostManager::CameraHostInfo(statusCallback, cameraHostDeadCallback_, svcName);
1175 CHECK_RETURN_ELOG(cameraHost == nullptr, "failed to new cameraHost!");
1176 CHECK_RETURN_ELOG(!cameraHost->Init(), "HCameraHostManager::AddCameraHost failed due to init failure");
1177 cameraHostInfos_.push_back(cameraHost);
1178 std::vector<std::string> cameraIds;
1179 if (statusCallback && cameraHost->GetCameras(cameraIds) == CAMERA_OK) {
1180 for (const auto& cameraId : cameraIds) {
1181 statusCallback->OnCameraStatus(cameraId, CAMERA_STATUS_AVAILABLE);
1182 }
1183 }
1184 CHECK_EXECUTE(statusCallback && svcName == LOCAL_SERVICE_NAME,
1185 statusCallback->OnTorchStatus(TorchStatus::TORCH_STATUS_OFF));
1186 }
1187
RemoveCameraHost(const std::string & svcName)1188 void HCameraHostManager::RemoveCameraHost(const std::string& svcName)
1189 {
1190 std::lock_guard<std::mutex> lock(mutex_);
1191 MEDIA_INFO_LOG("HCameraHostManager::RemoveCameraHost camera host %{public}s removed", svcName.c_str());
1192 std::vector<sptr<CameraHostInfo>>::iterator it = std::find_if(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1193 [&svcName](const auto& camHost) { return camHost->GetName() == svcName; });
1194 if (it == cameraHostInfos_.end()) {
1195 MEDIA_WARNING_LOG("HCameraHostManager::RemoveCameraHost camera host %{public}s doesn't exist",
1196 svcName.c_str());
1197 return;
1198 }
1199 std::vector<std::string> cameraIds;
1200 if ((*it)->GetCameras(cameraIds) == CAMERA_OK) {
1201 for (const auto& cameraId : cameraIds) {
1202 (*it)->OnCameraStatus(cameraId, UN_AVAILABLE);
1203 CloseCameraDevice(cameraId);
1204 }
1205 }
1206 *it = nullptr;
1207 cameraHostInfos_.erase(it);
1208 auto statusCallback = statusCallback_.lock();
1209 CHECK_EXECUTE(statusCallback && svcName == LOCAL_SERVICE_NAME,
1210 statusCallback->OnTorchStatus(TorchStatus::TORCH_STATUS_UNAVAILABLE));
1211 }
1212
FindCameraHostInfo(const std::string & cameraId)1213 sptr<HCameraHostManager::CameraHostInfo> HCameraHostManager::FindCameraHostInfo(const std::string& cameraId)
1214 {
1215 std::lock_guard<std::mutex> lock(mutex_);
1216 for (const auto& cameraHostInfo : cameraHostInfos_) {
1217 CHECK_RETURN_RET(cameraHostInfo->IsCameraSupported(cameraId), cameraHostInfo);
1218 }
1219 return nullptr;
1220 }
1221
FindLocalCameraHostInfo()1222 sptr<HCameraHostManager::CameraHostInfo> HCameraHostManager::FindLocalCameraHostInfo()
1223 {
1224 std::lock_guard<std::mutex> lock(mutex_);
1225 std::vector<sptr<CameraHostInfo>>::iterator it = std::find_if(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1226 [](const auto& cameraHostInfo) { return cameraHostInfo->GetName() == LOCAL_SERVICE_NAME; });
1227 CHECK_RETURN_RET(it != cameraHostInfos_.end(), (*it));
1228 return nullptr;
1229 }
1230
IsCameraHostInfoAdded(const std::string & svcName)1231 bool HCameraHostManager::IsCameraHostInfoAdded(const std::string& svcName)
1232 {
1233 std::lock_guard<std::mutex> lock(mutex_);
1234 return std::any_of(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1235 [&svcName](const auto& camHost) {return camHost->GetName() == svcName; });
1236 }
1237
GetRegisterServStatListener()1238 ::OHOS::sptr<HDI::ServiceManager::V1_0::IServStatListener> HCameraHostManager::GetRegisterServStatListener()
1239 {
1240 return registerServStatListener_;
1241 }
1242
SetMuteMode(bool muteMode)1243 void HCameraHostManager::SetMuteMode(bool muteMode)
1244 {
1245 muteMode_ = muteMode;
1246 }
1247
GetCameraResourceCost(const std::string & cameraId,OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost & resourceCost)1248 int32_t HCameraHostManager::GetCameraResourceCost(const std::string& cameraId,
1249 OHOS::HDI::Camera::V1_3::CameraDeviceResourceCost& resourceCost)
1250 {
1251 auto cameraHostInfo = FindCameraHostInfo(cameraId);
1252 CHECK_RETURN_RET_ELOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
1253 "HCameraHostManager::GetCameraResourceCost failed with invalid device info");
1254 return cameraHostInfo->GetCameraResourceCost(cameraId, resourceCost);
1255 }
1256
OnReceive(const HDI::ServiceManager::V1_0::ServiceStatus & status)1257 void RegisterServStatListener::OnReceive(const HDI::ServiceManager::V1_0::ServiceStatus& status)
1258 {
1259 MEDIA_INFO_LOG("HCameraHostManager::OnReceive for camerahost %{public}s, status %{public}d, deviceClass %{public}d",
1260 status.serviceName.c_str(), status.status, status.deviceClass);
1261
1262 CHECK_RETURN_ELOG(status.deviceClass != DEVICE_CLASS_CAMERA,
1263 "HCameraHostManager::OnReceive invalid device class %{public}d", status.deviceClass);
1264 callback_(status);
1265 }
1266
GetPhysicCameraId(int32_t position,std::string & cameraid)1267 void HCameraHostManager::GetPhysicCameraId(int32_t position, std::string &cameraid)
1268 {
1269 std::vector<std::string> cameraIds;
1270 MEDIA_DEBUG_LOG("GetPhysicCameraId target position %{public}d", position);
1271 GetCameraIdSortedByCameraType(cameraIds);
1272 for (auto iterOfCameraIds : cameraIds) {
1273 std::shared_ptr<OHOS::Camera::CameraMetadata> ability;
1274 GetCameraAbility(iterOfCameraIds, ability);
1275 camera_metadata_item_t itemp;
1276 int issup = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_CONCURRENT_TYPE, &itemp);
1277 MEDIA_DEBUG_LOG("GetPhysicCameraId cameraid = %{public}s CONCURRENT_TYPE is support limted = %{public}d",
1278 iterOfCameraIds.c_str(), issup);
1279 issup = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CONCURRENT_SUPPORTED_CAMERAS, &itemp);
1280 MEDIA_DEBUG_LOG("GetPhysicCameraId cameraid = %{public}s CONCURRENT_SUPPORTED_CAMERAS"
1281 "is support limted = %{public}d",
1282 iterOfCameraIds.c_str(), issup);
1283 issup = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_LIMITED_CAPABILITIES, &itemp);
1284 MEDIA_DEBUG_LOG("GetPhysicCameraId cameraid = %{public}s LIMITED_CAPABILITIES "
1285 "is support limted = %{public}d",
1286 iterOfCameraIds.c_str(), issup);
1287
1288 int32_t positionNow;
1289 int32_t cameratypeNow;
1290 camera_metadata_item_t item;
1291 int ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_POSITION, &item);
1292 positionNow = (ret == CAM_META_SUCCESS) ? item.data.u8[0] : OHOS_CAMERA_POSITION_OTHER;
1293 ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CAMERA_TYPE, &item);
1294 cameratypeNow = (ret == CAM_META_SUCCESS) ? item.data.u8[0] : OHOS_CAMERA_TYPE_UNSPECIFIED;
1295 if (positionNow != position || cameratypeNow == OHOS_CAMERA_TYPE_UNSPECIFIED) {
1296 MEDIA_DEBUG_LOG("iter cameraId : %{public}s continue, position: %{public}d, type: %{public}d",
1297 iterOfCameraIds.c_str(), positionNow, cameratypeNow);
1298 continue;
1299 }
1300 ret = OHOS::Camera::FindCameraMetadataItem(ability->get(), OHOS_ABILITY_CONCURRENT_SUPPORTED_CAMERAS, &item);
1301 if (ret == CAM_META_SUCCESS) {
1302 cameraid = iterOfCameraIds;
1303 break;
1304 }
1305 }
1306 }
1307
GetCameraStorageSize(const int & userId,int64_t & storageSize)1308 void HCameraHostManager::GetCameraStorageSize(const int& userId, int64_t& storageSize)
1309 {
1310 auto cameraHostInfo = FindLocalCameraHostInfo();
1311 CHECK_RETURN_ELOG(cameraHostInfo == nullptr,
1312 "HCameraHostManager::GetCameraStorageSize failed with not exist support device info");
1313 cameraHostInfo->GetCameraStorageSize(userId, storageSize);
1314 }
1315 } // namespace CameraStandard
1316 } // namespace OHOS
1317