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