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             if (ability == nullptr) {
270                 ability = std::make_shared<OHOS::Camera::CameraMetadata>(0, 0);
271             }
272             deviceInfo->ability = ability;
273         }
274     }
275     return CAMERA_OK;
276 }
277 
OpenCamera(std::string & cameraId,const sptr<ICameraDeviceCallback> & callback,sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> & pDevice,bool isEnableSecCam)278 int32_t HCameraHostManager::CameraHostInfo::OpenCamera(std::string& cameraId,
279     const sptr<ICameraDeviceCallback>& callback,
280     sptr<OHOS::HDI::Camera::V1_0::ICameraDevice>& pDevice,
281     bool isEnableSecCam)
282 {
283     MEDIA_INFO_LOG("CameraHostInfo::OpenCamera %{public}s", cameraId.c_str());
284     auto deviceInfo = FindCameraDeviceInfo(cameraId);
285     CHECK_ERROR_RETURN_RET_LOG(deviceInfo == nullptr, CAMERA_UNKNOWN_ERROR,
286         "CameraHostInfo::GetCameraAbility deviceInfo is null");
287     std::lock_guard<std::mutex> lock(deviceInfo->mutex);
288     CHECK_ERROR_RETURN_RET_LOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
289         "CameraHostInfo::OpenCamera cameraHostProxy_ is null");
290     CamRetCode rc;
291     // try to get higher version
292     sptr<OHOS::HDI::Camera::V1_1::ICameraDevice> hdiDevice_v1_1;
293     sptr<OHOS::HDI::Camera::V1_2::ICameraDevice> hdiDevice_v1_2;
294     sptr<OHOS::HDI::Camera::V1_3::ICameraDevice> hdiDevice_v1_3;
295     if (cameraHostProxyV1_3_ != nullptr && GetCameraHostVersion() >= GetVersionId(HDI_VERSION_1, HDI_VERSION_3)) {
296         MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_3");
297         if (isEnableSecCam) {
298             MEDIA_INFO_LOG("CameraHostInfo::OpenCamera OpenSecureCamera");
299             rc = (CamRetCode)(cameraHostProxyV1_3_->OpenSecureCamera(cameraId, callback, hdiDevice_v1_3));
300         } else {
301             rc = (CamRetCode)(cameraHostProxyV1_3_->OpenCamera_V1_3(cameraId, callback, hdiDevice_v1_3));
302         }
303         pDevice = hdiDevice_v1_3.GetRefPtr();
304     } else if (cameraHostProxyV1_2_ != nullptr && GetCameraHostVersion() >=
305         GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) {
306         MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_2");
307         rc = (CamRetCode)(cameraHostProxyV1_2_->OpenCamera_V1_2(cameraId, callback, hdiDevice_v1_2));
308         pDevice = hdiDevice_v1_2.GetRefPtr();
309     } else if (cameraHostProxyV1_1_ != nullptr
310         && GetCameraHostVersion() == GetVersionId(HDI_VERSION_1, HDI_VERSION_1)) {
311         MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_1");
312         rc = (CamRetCode)(cameraHostProxyV1_1_->OpenCamera_V1_1(cameraId, callback, hdiDevice_v1_1));
313         pDevice = hdiDevice_v1_1.GetRefPtr();
314     } else {
315         MEDIA_DEBUG_LOG("CameraHostInfo::OpenCamera ICameraDevice V1_0");
316         rc = (CamRetCode)(cameraHostProxy_->OpenCamera(cameraId, callback, pDevice));
317     }
318     if (rc != HDI::Camera::V1_0::NO_ERROR) {
319         MEDIA_ERR_LOG("CameraHostInfo::OpenCamera failed with error Code:%{public}d", rc);
320         CameraReportUtils::ReportCameraError(
321             "CameraHostInfo::OpenCamera", rc, true, CameraReportUtils::GetCallerInfo());
322         pDevice = nullptr;
323         return HdiToServiceError(rc);
324     }
325     return CAMERA_OK;
326 }
327 
SetFlashlight(const std::string & cameraId,bool isEnable)328 int32_t HCameraHostManager::CameraHostInfo::SetFlashlight(const std::string& cameraId, bool isEnable)
329 {
330     std::lock_guard<std::mutex> lock(mutex_);
331     CHECK_ERROR_RETURN_RET_LOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
332         "CameraHostInfo::SetFlashlight cameraHostProxy_ is null");
333     CamRetCode rc = (CamRetCode)(cameraHostProxy_->SetFlashlight(cameraId, isEnable));
334     if (rc != HDI::Camera::V1_0::NO_ERROR) {
335         MEDIA_ERR_LOG("CameraHostInfo::SetFlashlight failed with error Code:%{public}d", rc);
336         CameraReportUtils::ReportCameraError(
337             "CameraHostInfo::SetFlashlight", rc, true, CameraReportUtils::GetCallerInfo());
338         return HdiToServiceError(rc);
339     }
340     return CAMERA_OK;
341 }
342 
SetTorchLevel(float level)343 int32_t HCameraHostManager::CameraHostInfo::SetTorchLevel(float level)
344 {
345     std::lock_guard<std::mutex> lock(mutex_);
346     CHECK_ERROR_RETURN_RET_LOG(cameraHostProxyV1_2_ == nullptr, CAMERA_UNKNOWN_ERROR,
347         "CameraHostInfo::SetTorchLevel cameraHostProxyV1_2_ is null");
348     HDI::Camera::V1_2::CamRetCode rc = (HDI::Camera::V1_2::CamRetCode)(cameraHostProxyV1_2_->SetFlashlight_V1_2(level));
349     if (rc != HDI::Camera::V1_2::NO_ERROR) {
350         MEDIA_ERR_LOG("CameraHostInfo::SetTorchLevel failed with error Code:%{public}d", rc);
351         CameraReportUtils::ReportCameraError(
352             "CameraHostInfo::SetTorchLevel", rc, true, CameraReportUtils::GetCallerInfo());
353         return HdiToServiceErrorV1_2(rc);
354     }
355     return CAMERA_OK;
356 }
357 
UpdateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata> setting)358 void HCameraHostManager::CameraHostInfo::UpdateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata> setting)
359 {
360     MEDIA_DEBUG_LOG("CameraHostInfo::UpdateMuteSetting enter");
361     int32_t count = 1;
362     uint8_t mode = OHOS_CAMERA_MUTE_MODE_SOLID_COLOR_BLACK;
363     if (setting == nullptr) {
364         MEDIA_DEBUG_LOG("CameraHostInfo::UpdateMuteSetting setting is null");
365         constexpr int32_t DEFAULT_ITEMS = 1;
366         constexpr int32_t DEFAULT_DATA_LENGTH = 1;
367         setting = std::make_shared<OHOS::Camera::CameraMetadata>(DEFAULT_ITEMS, DEFAULT_DATA_LENGTH);
368     }
369     setting->addEntry(OHOS_CONTROL_MUTE_MODE, &mode, count);
370 }
371 
Prelaunch(sptr<HCameraRestoreParam> cameraRestoreParam,bool muteMode)372 int32_t HCameraHostManager::CameraHostInfo::Prelaunch(sptr<HCameraRestoreParam> cameraRestoreParam, bool muteMode)
373 {
374     CHECK_ERROR_RETURN_RET_LOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
375         "CameraHostInfo::Prelaunch cameraHostProxy_ is null");
376     CHECK_ERROR_RETURN_RET_LOG(GetCameraHostVersion() < GetVersionId(1, 1), CAMERA_UNKNOWN_ERROR,
377         "CameraHostInfo::Prelaunch not support host V1_0!");
378     MEDIA_INFO_LOG("CameraHostInfo::prelaunch for cameraId %{public}s", (cameraRestoreParam->GetCameraId()).c_str());
379     for (auto& streamInfo : cameraRestoreParam->GetStreamInfo()) {
380         MEDIA_DEBUG_LOG("CameraHostInfo::prelaunch for stream id is:%{public}d", streamInfo.v1_0.streamId_);
381     }
382     OHOS::HDI::Camera::V1_1::PrelaunchConfig prelaunchConfig;
383     std::vector<uint8_t> settings;
384     prelaunchConfig.cameraId = cameraRestoreParam->GetCameraId();
385     prelaunchConfig.streamInfos_V1_1 = cameraRestoreParam->GetStreamInfo();
386     DumpMetadata(cameraRestoreParam->GetSetting());
387     if (muteMode) {
388         UpdateMuteSetting(cameraRestoreParam->GetSetting());
389     }
390     OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraRestoreParam->GetSetting(), settings);
391     prelaunchConfig.setting = settings;
392     int32_t opMode = cameraRestoreParam->GetCameraOpMode();
393     bool isNeedRestore = IsNeedRestore(opMode, cameraRestoreParam->GetSetting(), prelaunchConfig.cameraId);
394     CamRetCode rc;
395     if (cameraHostProxyV1_2_ != nullptr && GetCameraHostVersion() > GetVersionId(1, 1)) {
396         if (isNeedRestore) {
397             MEDIA_INFO_LOG("CameraHostInfo::PrelaunchWithOpMode ICameraHost V1_2 %{public}d", opMode);
398             rc = (CamRetCode)(cameraHostProxyV1_2_->PrelaunchWithOpMode(prelaunchConfig, opMode));
399         } else {
400             MEDIA_INFO_LOG("CameraHostInfo::Prelaunch ICameraHost V1_2 %{public}d", opMode);
401             rc = (CamRetCode)(cameraHostProxyV1_2_->Prelaunch(prelaunchConfig));
402         }
403     } else if (cameraHostProxyV1_1_ != nullptr && GetCameraHostVersion() == GetVersionId(1, 1)) {
404         MEDIA_DEBUG_LOG("CameraHostInfo::Prelaunch ICameraHost V1_1");
405         rc = (CamRetCode)(cameraHostProxyV1_1_->Prelaunch(prelaunchConfig));
406     } else {
407         rc = HDI::Camera::V1_0::NO_ERROR;
408     }
409     if (rc != HDI::Camera::V1_0::NO_ERROR) {
410         MEDIA_ERR_LOG("CameraHostInfo::Prelaunch failed with error Code:%{public}d", rc);
411         return HdiToServiceError(rc);
412     }
413     return CAMERA_OK;
414 }
415 
IsNeedRestore(int32_t opMode,std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings,std::string & cameraId)416 bool HCameraHostManager::CameraHostInfo::IsNeedRestore(int32_t opMode,
417     std::shared_ptr<OHOS::Camera::CameraMetadata> cameraSettings, std::string& cameraId)
418 {
419     if (cameraSettings == nullptr) {
420         return false;
421     }
422     std::shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility;
423     int32_t ret = GetCameraAbility(cameraId, cameraAbility);
424     CHECK_ERROR_RETURN_RET_LOG(ret != CAMERA_OK || cameraAbility == nullptr, false,
425         "CameraHostInfo::IsNeedRestore failed");
426     if (opMode == 0) { // 0 is normal mode
427         MEDIA_INFO_LOG("operationMode:%{public}d", opMode);
428         return true;
429     }
430     camera_metadata_item_t item;
431     ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility->get(), OHOS_ABILITY_CAMERA_MODES, &item);
432     if (ret != CAM_META_SUCCESS || item.count == 0) {
433         MEDIA_ERR_LOG("Failed to find stream extend configuration return code %{public}d", ret);
434         ret = OHOS::Camera::FindCameraMetadataItem(cameraAbility->get(),
435             OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item);
436         if (ret == CAM_META_SUCCESS && item.count != 0) {
437             MEDIA_INFO_LOG("basic config no need valid mode");
438             return true;
439         }
440         return false;
441     }
442 
443     for (uint32_t i = 0; i < item.count; i++) {
444         if (opMode == item.data.u8[i]) {
445             MEDIA_DEBUG_LOG("operationMode:%{public}d found in supported streams", opMode);
446             return true;
447         }
448     }
449     MEDIA_ERR_LOG("operationMode:%{public}d not found in supported streams", opMode);
450     return false;
451 }
PreCameraSwitch(const std::string & cameraId)452 int32_t HCameraHostManager::CameraHostInfo::PreCameraSwitch(const std::string& cameraId)
453 {
454     std::lock_guard<std::mutex> lock(mutex_);
455     CHECK_ERROR_RETURN_RET_LOG(cameraHostProxy_ == nullptr, CAMERA_UNKNOWN_ERROR,
456         "CameraHostInfo::PreCameraSwitch cameraHostProxy_ is null");
457     CHECK_ERROR_RETURN_RET_LOG(GetCameraHostVersion() <= GetVersionId(1, 1), CAMERA_UNKNOWN_ERROR,
458         "CameraHostInfo::PreCameraSwitch not support host V1_0 and V1_1!");
459     if (cameraHostProxyV1_2_ != nullptr) {
460         MEDIA_DEBUG_LOG("CameraHostInfo::PreCameraSwitch ICameraHost V1_2");
461         CamRetCode rc = (CamRetCode)(cameraHostProxyV1_2_->PreCameraSwitch(cameraId));
462         if (rc != HDI::Camera::V1_0::NO_ERROR) {
463             MEDIA_ERR_LOG("CameraHostInfo::PreCameraSwitch failed with error Code:%{public}d", rc);
464             return HdiToServiceError(rc);
465         }
466     }
467     return CAMERA_OK;
468 }
469 
NotifyDeviceStateChangeInfo(int notifyType,int deviceState)470 void HCameraHostManager::CameraHostInfo::NotifyDeviceStateChangeInfo(int notifyType, int deviceState)
471 {
472     std::lock_guard<std::mutex> lock(mutex_);
473     CHECK_ERROR_RETURN_LOG(cameraHostProxy_ == nullptr, "CameraHostInfo::Prelaunch cameraHostProxy_ is null");
474     MEDIA_DEBUG_LOG("CameraHostInfo::NotifyDeviceStateChangeInfo notifyType = %{public}d, deviceState = %{public}d",
475         notifyType, deviceState);
476     if (cameraHostProxyV1_3_ != nullptr && GetCameraHostVersion() > GetVersionId(1, 1)) {
477         MEDIA_DEBUG_LOG("CameraHostInfo::NotifyDeviceStateChangeInfo ICameraHost V1_2");
478         cameraHostProxyV1_3_->NotifyDeviceStateChangeInfo(notifyType, deviceState);
479     } else if (cameraHostProxyV1_2_ != nullptr && GetCameraHostVersion() > GetVersionId(1, 1)) {
480         MEDIA_DEBUG_LOG("CameraHostInfo::NotifyDeviceStateChangeInfo ICameraHost V1_2");
481         cameraHostProxyV1_2_->NotifyDeviceStateChangeInfo(notifyType, deviceState);
482     }
483 }
484 
OnCameraStatus(const std::string & cameraId,HDI::Camera::V1_0::CameraStatus status)485 int32_t HCameraHostManager::CameraHostInfo::OnCameraStatus(
486     const std::string& cameraId, HDI::Camera::V1_0::CameraStatus status)
487 {
488     auto statusCallback = statusCallback_.lock();
489     if (statusCallback == nullptr) {
490         MEDIA_WARNING_LOG("CameraHostInfo::OnCameraStatus for %{public}s with status %{public}d "
491                           "failed due to no callback",
492             cameraId.c_str(), status);
493         return CAMERA_UNKNOWN_ERROR;
494     }
495     CameraStatus svcStatus = CAMERA_STATUS_UNAVAILABLE;
496     switch (status) {
497         case UN_AVAILABLE: {
498             MEDIA_INFO_LOG("CameraHostInfo::OnCameraStatus, camera %{public}s unavailable", cameraId.c_str());
499             svcStatus = CAMERA_STATUS_UNAVAILABLE;
500             break;
501         }
502         case AVAILABLE: {
503             MEDIA_INFO_LOG("CameraHostInfo::OnCameraStatus, camera %{public}s available", cameraId.c_str());
504             svcStatus = CAMERA_STATUS_AVAILABLE;
505             AddDevice(cameraId);
506             break;
507         }
508         default:
509             MEDIA_ERR_LOG("Unknown camera status: %{public}d", status);
510             return CAMERA_UNKNOWN_ERROR;
511     }
512     statusCallback->OnCameraStatus(cameraId, svcStatus);
513     return CAMERA_OK;
514 }
515 
NotifyCameraHostDied()516 void HCameraHostManager::CameraHostInfo::NotifyCameraHostDied()
517 {
518     auto statusCallback = statusCallback_.lock();
519     if (statusCallback == nullptr) {
520         MEDIA_WARNING_LOG("CameraHostInfo::NotifyCameraHostDied failed due to no callback!");
521         return;
522     }
523     std::vector<std::string> cameraIds;
524     if (statusCallback && this->GetCameras(cameraIds) == CAMERA_OK) {
525         for (const auto& cameraId : cameraIds) {
526             statusCallback->OnCameraStatus(cameraId, CAMERA_SERVER_UNAVAILABLE);
527         }
528     }
529 }
530 
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)531 int32_t HCameraHostManager::CameraHostInfo::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
532 {
533     auto statusCallback = statusCallback_.lock();
534     if (statusCallback == nullptr) {
535         MEDIA_WARNING_LOG("CameraHostInfo::OnFlashlightStatus for %{public}s with status %{public}d "
536                           "failed due to no callback",
537             cameraId.c_str(), status);
538         return CAMERA_UNKNOWN_ERROR;
539     }
540     FlashStatus flashStatus = FLASH_STATUS_OFF;
541     switch (status) {
542         case FLASHLIGHT_OFF:
543             flashStatus = FLASH_STATUS_OFF;
544             MEDIA_INFO_LOG(
545                 "CameraHostInfo::OnFlashlightStatus, camera %{public}s flash light is off", cameraId.c_str());
546             break;
547 
548         case FLASHLIGHT_ON:
549             flashStatus = FLASH_STATUS_ON;
550             MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus, camera %{public}s flash light is on", cameraId.c_str());
551             break;
552 
553         case FLASHLIGHT_UNAVAILABLE:
554             flashStatus = FLASH_STATUS_UNAVAILABLE;
555             MEDIA_INFO_LOG(
556                 "CameraHostInfo::OnFlashlightStatus, camera %{public}s flash light is unavailable", cameraId.c_str());
557             break;
558 
559         default:
560             MEDIA_ERR_LOG("Unknown flashlight status: %{public}d for camera %{public}s", status, cameraId.c_str());
561             return CAMERA_UNKNOWN_ERROR;
562     }
563     statusCallback->OnFlashlightStatus(cameraId, flashStatus);
564     return CAMERA_OK;
565 }
566 
OnFlashlightStatus_V1_2(FlashlightStatus status)567 int32_t HCameraHostManager::CameraHostInfo::OnFlashlightStatus_V1_2(FlashlightStatus status)
568 {
569     auto statusCallback = statusCallback_.lock();
570     if (statusCallback == nullptr) {
571         MEDIA_WARNING_LOG(
572             "CameraHostInfo::OnFlashlightStatus_V1_2 with status %{public}d failed due to no callback", status);
573         return CAMERA_UNKNOWN_ERROR;
574     }
575     TorchStatus torchStatus = TORCH_STATUS_OFF;
576     switch (status) {
577         case FLASHLIGHT_OFF:
578             torchStatus = TORCH_STATUS_OFF;
579             MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, torch status is off");
580             break;
581 
582         case FLASHLIGHT_ON:
583             torchStatus = TORCH_STATUS_ON;
584             MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, torch status is on");
585             break;
586 
587         case FLASHLIGHT_UNAVAILABLE:
588             torchStatus = TORCH_STATUS_UNAVAILABLE;
589             MEDIA_INFO_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, torch status is unavailable");
590             break;
591 
592         default:
593             MEDIA_ERR_LOG("CameraHostInfo::OnFlashlightStatus_V1_2, Unknown flashlight status: %{public}d", status);
594             return CAMERA_UNKNOWN_ERROR;
595     }
596     statusCallback->OnTorchStatus(torchStatus);
597     return CAMERA_OK;
598 }
599 
OnCameraEvent(const std::string & cameraId,CameraEvent event)600 int32_t HCameraHostManager::CameraHostInfo::OnCameraEvent(const std::string& cameraId, CameraEvent event)
601 {
602     auto statusCallback = statusCallback_.lock();
603     if (statusCallback == nullptr) {
604         MEDIA_WARNING_LOG(
605             "CameraHostInfo::OnCameraEvent for %{public}s with status %{public}d failed due to no callback",
606             cameraId.c_str(), event);
607         return CAMERA_UNKNOWN_ERROR;
608     }
609     CameraStatus svcStatus = CAMERA_STATUS_UNAVAILABLE;
610     switch (event) {
611         case CAMERA_EVENT_DEVICE_RMV: {
612             MEDIA_INFO_LOG("CameraHostInfo::OnCameraEvent, camera %{public}s unavailable", cameraId.c_str());
613             svcStatus = CAMERA_STATUS_DISAPPEAR;
614             RemoveDevice(cameraId);
615             break;
616         }
617         case CAMERA_EVENT_DEVICE_ADD: {
618             MEDIA_INFO_LOG("CameraHostInfo::OnCameraEvent camera %{public}s available", cameraId.c_str());
619             svcStatus = CAMERA_STATUS_APPEAR;
620             AddDevice(cameraId);
621             break;
622         }
623         default:
624             MEDIA_ERR_LOG("Unknown camera event: %{public}d", event);
625             return CAMERA_UNKNOWN_ERROR;
626     }
627     statusCallback->OnCameraStatus(cameraId, svcStatus);
628     return CAMERA_OK;
629 }
630 
FindCameraDeviceInfo(const std::string & cameraId)631 std::shared_ptr<HCameraHostManager::CameraDeviceInfo> HCameraHostManager::CameraHostInfo::FindCameraDeviceInfo
632    (const std::string& cameraId)
633 {
634     std::lock_guard<std::mutex> lock(mutex_);
635     std::vector<std::shared_ptr<CameraDeviceInfo>>::iterator it = std::find_if(devices_.begin(), devices_.end(),
636         [cameraId](const auto& deviceInfo) { return deviceInfo->cameraId == cameraId; });
637     if (it != devices_.end()) {
638         MEDIA_INFO_LOG("CameraHostInfo::FindCameraDeviceInfo succeed for %{public}s", cameraId.c_str());
639         return (*it);
640     }
641     MEDIA_WARNING_LOG("CameraHostInfo::FindCameraDeviceInfo failed for %{public}s", cameraId.c_str());
642     return nullptr;
643 }
644 
AddDevice(const std::string & cameraId)645 void HCameraHostManager::CameraHostInfo::AddDevice(const std::string& cameraId)
646 {
647     std::lock_guard<std::mutex> lock(mutex_);
648     if (std::none_of(devices_.begin(), devices_.end(),
649                      [&cameraId](auto& devInfo) { return devInfo->cameraId == cameraId; })) {
650         cameraIds_.push_back(cameraId);
651         devices_.push_back(std::make_shared<HCameraHostManager::CameraDeviceInfo>(cameraId));
652         MEDIA_INFO_LOG("CameraHostInfo::AddDevice, camera %{public}s added", cameraId.c_str());
653     } else {
654         MEDIA_WARNING_LOG("CameraHostInfo::AddDevice, camera %{public}s already exists", cameraId.c_str());
655     }
656 }
657 
RemoveDevice(const std::string & cameraId)658 void HCameraHostManager::CameraHostInfo::RemoveDevice(const std::string& cameraId)
659 {
660     std::lock_guard<std::mutex> lock(mutex_);
661     cameraIds_.erase(std::remove(cameraIds_.begin(), cameraIds_.end(), cameraId), cameraIds_.end());
662     devices_.erase(std::remove_if(devices_.begin(), devices_.end(),
663         [&cameraId](const auto& devInfo) { return devInfo->cameraId == cameraId; }),
664         devices_.end());
665 }
666 
HCameraHostManager(std::shared_ptr<StatusCallback> statusCallback)667 HCameraHostManager::HCameraHostManager(std::shared_ptr<StatusCallback> statusCallback)
668     : statusCallback_(statusCallback), cameraHostInfos_(), muteMode_(false)
669 {
670     MEDIA_INFO_LOG("HCameraHostManager construct called");
671 }
672 
~HCameraHostManager()673 HCameraHostManager::~HCameraHostManager()
674 {
675     MEDIA_INFO_LOG("HCameraHostManager deconstruct called");
676     std::lock_guard<std::mutex> lock(deviceMutex_);
677     for (auto it = cameraDevices_.begin(); it != cameraDevices_.end(); it++) {
678         if (it->second) {
679             it->second = nullptr;
680         }
681     }
682     cameraDevices_.clear();
683 
684     for (unsigned i = 0; i < cameraHostInfos_.size(); i++) {
685         cameraHostInfos_[i] = nullptr;
686     }
687     cameraHostInfos_.clear();
688 }
689 
Init()690 int32_t HCameraHostManager::Init()
691 {
692     MEDIA_INFO_LOG("HCameraHostManager::Init");
693     using namespace OHOS::HDI::ServiceManager::V1_0;
694     auto svcMgr = IServiceManager::Get();
695     CHECK_ERROR_RETURN_RET_LOG(svcMgr == nullptr, CAMERA_UNKNOWN_ERROR,
696         "HCameraHostManager::Init IServiceManager failed!");
697 
698     ::OHOS::sptr<IServStatListener> listener(
699         new RegisterServStatListener(RegisterServStatListener::StatusCallback([&](const ServiceStatus& status) {
700             using namespace OHOS::HDI::ServiceManager::V1_0;
701 
702             switch (status.status) {
703                 case SERVIE_STATUS_START:
704                     if (status.serviceName == DISTRIBUTED_SERVICE_NAME) {
705                         MEDIA_ERR_LOG("HCameraHostManager::service no need to add");
706                         return;
707                     }
708                     AddCameraHost(status.serviceName);
709                     break;
710                 case SERVIE_STATUS_STOP:
711                     RemoveCameraHost(status.serviceName);
712                     break;
713                 default:
714                     MEDIA_ERR_LOG("HCameraHostManager::OnReceive unexpected service status %{public}d", status.status);
715             }
716         })
717     ));
718 
719     auto rt = svcMgr->RegisterServiceStatusListener(listener, DEVICE_CLASS_CAMERA);
720     CHECK_ERROR_RETURN_RET_LOG(rt != 0, CAMERA_UNKNOWN_ERROR,
721         "HCameraHostManager::Init RegisterServiceStatusListener failed!");
722     registerServStatListener_ = listener;
723 
724     return CAMERA_OK;
725 }
726 
DeInit()727 void HCameraHostManager::DeInit()
728 {
729     using namespace OHOS::HDI::ServiceManager::V1_0;
730     auto svcMgr = IServiceManager::Get();
731     CHECK_ERROR_RETURN_LOG(svcMgr == nullptr, "HCameraHostManager::DeInit(): IServiceManager failed");
732     auto rt = svcMgr->UnregisterServiceStatusListener(registerServStatListener_);
733     CHECK_ERROR_PRINT_LOG(rt != 0, "HCameraHostManager::DeInit(): UnregisterServiceStatusListener failed!");
734     registerServStatListener_ = nullptr;
735 }
736 
AddCameraDevice(const std::string & cameraId,sptr<ICameraDeviceService> cameraDevice)737 void HCameraHostManager::AddCameraDevice(const std::string& cameraId, sptr<ICameraDeviceService> cameraDevice)
738 {
739     std::lock_guard<std::mutex> lock(deviceMutex_);
740     auto it = cameraDevices_.find(cameraId);
741     if (it != cameraDevices_.end()) {
742         it->second = nullptr;
743         cameraDevices_.erase(cameraId);
744     }
745     cameraDevices_[cameraId] = cameraDevice;
746     auto statusCallback = statusCallback_.lock();
747     if (statusCallback != nullptr) {
748         statusCallback->OnCameraStatus(cameraId, CAMERA_STATUS_UNAVAILABLE, CallbackInvoker::APPLICATION);
749     }
750 }
751 
RemoveCameraDevice(const std::string & cameraId)752 void HCameraHostManager::RemoveCameraDevice(const std::string& cameraId)
753 {
754     MEDIA_DEBUG_LOG("HCameraHostManager::RemoveCameraDevice start");
755     std::lock_guard<std::mutex> lock(deviceMutex_);
756     auto it = cameraDevices_.find(cameraId);
757     if (it != cameraDevices_.end()) {
758         it->second = nullptr;
759     }
760     cameraDevices_.erase(cameraId);
761     auto statusCallback = statusCallback_.lock();
762     if (statusCallback) {
763         statusCallback->OnCameraStatus(cameraId, CAMERA_STATUS_AVAILABLE, CallbackInvoker::APPLICATION);
764     }
765     MEDIA_DEBUG_LOG("HCameraHostManager::RemoveCameraDevice end");
766 }
767 
CloseCameraDevice(const std::string & cameraId)768 void HCameraHostManager::CloseCameraDevice(const std::string& cameraId)
769 {
770     sptr<ICameraDeviceService> deviceToDisconnect = nullptr;
771     {
772         std::lock_guard<std::mutex> lock(deviceMutex_);
773         auto iter = cameraDevices_.find(cameraId);
774         if (iter != cameraDevices_.end()) {
775             deviceToDisconnect = iter->second;
776         }
777     }
778     if (deviceToDisconnect) {
779         MEDIA_DEBUG_LOG("HCameraDevice::CloseCameraDevice should clean %{public}s device", cameraId.c_str());
780         HCameraDevice* devicePtr = static_cast<HCameraDevice*>(deviceToDisconnect.GetRefPtr());
781         devicePtr->RemoveResourceWhenHostDied();
782     }
783 }
784 
GetCameras(std::vector<std::string> & cameraIds)785 int32_t HCameraHostManager::GetCameras(std::vector<std::string>& cameraIds)
786 {
787     CAMERA_SYNC_TRACE;
788     MEDIA_INFO_LOG("HCameraHostManager::GetCameras");
789     if (!IsCameraHostInfoAdded(LOCAL_SERVICE_NAME)) {
790         AddCameraHost(LOCAL_SERVICE_NAME);
791     }
792     std::lock_guard<std::mutex> lock(mutex_);
793     cameraIds.clear();
794     for (const auto& cameraHost : cameraHostInfos_) {
795         cameraHost->GetCameras(cameraIds);
796     }
797     return CAMERA_OK;
798 }
799 
GetCameraAbility(std::string & cameraId,std::shared_ptr<OHOS::Camera::CameraMetadata> & ability)800 int32_t HCameraHostManager::GetCameraAbility(std::string &cameraId,
801                                              std::shared_ptr<OHOS::Camera::CameraMetadata> &ability)
802 {
803     auto cameraHostInfo = FindCameraHostInfo(cameraId);
804     CHECK_ERROR_RETURN_RET_LOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
805         "HCameraHostManager::GetCameraAbility failed with invalid device info.");
806     return cameraHostInfo->GetCameraAbility(cameraId, ability);
807 }
808 
GetVersionByCamera(const std::string & cameraId)809 int32_t HCameraHostManager::GetVersionByCamera(const std::string& cameraId)
810 {
811     MEDIA_INFO_LOG("GetVersionByCamera camera = %{public}s", cameraId.c_str());
812     auto cameraHostInfo = FindCameraHostInfo(cameraId);
813     CHECK_ERROR_RETURN_RET_LOG(cameraHostInfo == nullptr, 0, "GetVersionByCamera failed with invalid device info");
814     return cameraHostInfo->GetCameraHostVersion();
815 }
816 
OpenCameraDevice(std::string & cameraId,const sptr<ICameraDeviceCallback> & callback,sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> & pDevice,bool isEnableSecCam)817 int32_t HCameraHostManager::OpenCameraDevice(std::string &cameraId,
818     const sptr<ICameraDeviceCallback> &callback,
819     sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> &pDevice,
820     bool isEnableSecCam)
821 {
822     MEDIA_INFO_LOG("HCameraHostManager::OpenCameraDevice try to open camera = %{public}s", cameraId.c_str());
823     auto cameraHostInfo = FindCameraHostInfo(cameraId);
824     CHECK_ERROR_RETURN_RET_LOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
825         "HCameraHostManager::OpenCameraDevice failed with invalid device info.");
826     return cameraHostInfo->OpenCamera(cameraId, callback, pDevice, isEnableSecCam);
827 }
828 
SetTorchLevel(float level)829 int32_t HCameraHostManager::SetTorchLevel(float level)
830 {
831     if (!IsCameraHostInfoAdded(LOCAL_SERVICE_NAME)) {
832         AddCameraHost(LOCAL_SERVICE_NAME);
833     }
834     auto cameraHostInfo = FindLocalCameraHostInfo();
835     CHECK_ERROR_RETURN_RET_LOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
836         "HCameraHostManager::SetTorchLevel failed with not exist support device info");
837     return cameraHostInfo->SetTorchLevel(level);
838 }
839 
SetFlashlight(const std::string & cameraId,bool isEnable)840 int32_t HCameraHostManager::SetFlashlight(const std::string& cameraId, bool isEnable)
841 {
842     auto cameraHostInfo = FindCameraHostInfo(cameraId);
843     CHECK_ERROR_RETURN_RET_LOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
844         "HCameraHostManager::SetFlashlight failed with invalid device info");
845     return cameraHostInfo->SetFlashlight(cameraId, isEnable);
846 }
847 
Prelaunch(const std::string & cameraId,std::string clientName)848 int32_t HCameraHostManager::Prelaunch(const std::string& cameraId, std::string clientName)
849 {
850     auto cameraHostInfo = FindCameraHostInfo(cameraId);
851     CHECK_ERROR_RETURN_RET_LOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
852         "HCameraHostManager::Prelaunch failed with invalid device info");
853     sptr<HCameraRestoreParam> cameraRestoreParam = GetRestoreParam(clientName, cameraId);
854     int foldStatus = static_cast<int>(OHOS::Rosen::DisplayManager::GetInstance().GetFoldStatus());
855     if (foldStatus != cameraRestoreParam->GetFlodStatus()) {
856         MEDIA_DEBUG_LOG("HCameraHostManager::SaveRestoreParam %d", foldStatus);
857         return 0;
858     }
859     int32_t res = cameraHostInfo->Prelaunch(cameraRestoreParam, muteMode_);
860     if (res == 0 && cameraRestoreParam->GetRestoreParamType() ==
861         RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS) {
862         return CAMERA_OK;
863     }
864     // 使用后删除存储的动态数据
865     std::lock_guard<std::mutex> lock(saveRestoreMutex_);
866     auto it = transitentParamMap_.find(clientName);
867     if (it != transitentParamMap_.end() && CheckCameraId(it->second, cameraId)) {
868         transitentParamMap_.erase(clientName);
869     }
870     return 0;
871 }
872 
PreSwitchCamera(const std::string & cameraId)873 int32_t HCameraHostManager::PreSwitchCamera(const std::string& cameraId)
874 {
875     auto cameraHostInfo = FindCameraHostInfo(cameraId);
876     CHECK_ERROR_RETURN_RET_LOG(cameraHostInfo == nullptr, CAMERA_INVALID_ARG,
877         "HCameraHostManager::PreSwitchCamera failed with invalid device info");
878     return cameraHostInfo->PreCameraSwitch(cameraId);
879 }
880 
NotifyDeviceStateChangeInfo(int notifyType,int deviceState)881 void HCameraHostManager::NotifyDeviceStateChangeInfo(int notifyType, int deviceState)
882 {
883     auto cameraHostInfo = FindLocalCameraHostInfo();
884     if (cameraHostInfo == nullptr) {
885         MEDIA_ERR_LOG("HCameraHostManager::NotifyDeviceStateChangeInfo failed with not exist support device info");
886         return;
887     }
888 
889     cameraHostInfo->NotifyDeviceStateChangeInfo(notifyType, deviceState);
890 }
891 
SaveRestoreParam(sptr<HCameraRestoreParam> cameraRestoreParam)892 void HCameraHostManager::SaveRestoreParam(sptr<HCameraRestoreParam> cameraRestoreParam)
893 {
894     std::lock_guard<std::mutex> lock(saveRestoreMutex_);
895     CHECK_ERROR_RETURN_LOG(cameraRestoreParam == nullptr, "HCameraRestoreParam is nullptr");
896     std::string clientName = cameraRestoreParam->GetClientName();
897     if (cameraRestoreParam->GetRestoreParamType() == RestoreParamTypeOhos::PERSISTENT_DEFAULT_PARAM_OHOS) {
898         DeleteRestoreParam(clientName, cameraRestoreParam->GetCameraId());
899         (persistentParamMap_[clientName])[cameraRestoreParam->GetCameraId()] = cameraRestoreParam;
900         MEDIA_DEBUG_LOG("HCameraHostManager::SaveRestoreParam save persistent param");
901     } else {
902         auto itTransitent = transitentParamMap_.find(clientName);
903         if (itTransitent != transitentParamMap_.end()) {
904             transitentParamMap_.erase(clientName);
905         }
906         transitentParamMap_[clientName] = cameraRestoreParam;
907         MEDIA_DEBUG_LOG("HCameraHostManager::SaveRestoreParam save transist param");
908         isHasSavedParam = true;
909     }
910 }
911 
UpdateRestoreParamCloseTime(const std::string & clientName,const std::string & cameraId)912 void HCameraHostManager::UpdateRestoreParamCloseTime(const std::string& clientName, const std::string& cameraId)
913 {
914     MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParamCloseTime enter");
915     timeval closeTime;
916     gettimeofday(&closeTime, nullptr);
917     std::lock_guard<std::mutex> lock(saveRestoreMutex_);
918     auto itPersistent = persistentParamMap_.find(clientName);
919     if (itPersistent != persistentParamMap_.end()) {
920         MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParamCloseTime find persistentParam");
921         std::map<std::string, sptr<HCameraRestoreParam>>::iterator iter = (persistentParamMap_[clientName]).begin();
922         while (iter != (persistentParamMap_[clientName]).end()) {
923             auto cameraRestoreParam = iter->second;
924             if (cameraId == cameraRestoreParam->GetCameraId()) {
925                 cameraRestoreParam->SetCloseCameraTime(closeTime);
926                 MEDIA_DEBUG_LOG("HCameraHostManager::Update persistent closeTime");
927             } else {
928                 cameraRestoreParam->SetCloseCameraTime({0, 0});
929             }
930             ++iter;
931         }
932     }
933 
934     auto itTransitent = transitentParamMap_.find(clientName);
935     if (!isHasSavedParam && itTransitent != transitentParamMap_.end()) {
936         transitentParamMap_.erase(clientName);
937         return;
938     }
939 
940     if (itTransitent != transitentParamMap_.end()) {
941         MEDIA_INFO_LOG("HCameraHostManager::Update transient CloseTime ");
942         transitentParamMap_[clientName]->SetCloseCameraTime(closeTime);
943         isHasSavedParam = false;
944     }
945 }
946 
DeleteRestoreParam(const std::string & clientName,const std::string & cameraId)947 void HCameraHostManager::DeleteRestoreParam(const std::string& clientName, const std::string& cameraId)
948 {
949     MEDIA_DEBUG_LOG("HCameraHostManager::DeleteRestoreParam enter");
950     auto itPersistent = persistentParamMap_.find(clientName);
951     if (itPersistent != persistentParamMap_.end()) {
952         auto iterParamMap = (itPersistent->second).find(cameraId);
953         if (iterParamMap != (itPersistent->second).end()) {
954             iterParamMap->second = nullptr;
955             (itPersistent->second).erase(cameraId);
956         }
957     }
958 }
959 
GetRestoreParam(const std::string & clientName,const std::string & cameraId)960 sptr<HCameraRestoreParam> HCameraHostManager::GetRestoreParam(const std::string& clientName,
961     const std::string& cameraId)
962 {
963     MEDIA_DEBUG_LOG("HCameraHostManager::GetRestoreParam enter");
964     std::lock_guard<std::mutex> lock(saveRestoreMutex_);
965     std::vector<StreamInfo_V1_1> streamInfos;
966     RestoreParamTypeOhos restoreParamType = RestoreParamTypeOhos::NO_NEED_RESTORE_PARAM_OHOS;
967     sptr<HCameraRestoreParam> cameraRestoreParam = new HCameraRestoreParam(clientName, cameraId,
968         streamInfos, nullptr, restoreParamType, 0);
969     auto it = persistentParamMap_.find(clientName);
970     if (it != persistentParamMap_.end()) {
971         MEDIA_DEBUG_LOG("HCameraHostManager::GetRestoreParam find persistent param");
972         UpdateRestoreParam(cameraRestoreParam);
973     } else {
974         cameraRestoreParam = GetTransitentParam(clientName, cameraId);
975         MEDIA_DEBUG_LOG("HCameraHostManager::GetRestoreParam find transist param");
976     }
977     return cameraRestoreParam;
978 }
979 
UpdateRestoreParam(sptr<HCameraRestoreParam> & cameraRestoreParam)980 void HCameraHostManager::UpdateRestoreParam(sptr<HCameraRestoreParam> &cameraRestoreParam)
981 {
982     CHECK_ERROR_RETURN_LOG(cameraRestoreParam == nullptr, "HCameraHostManager::UpdateRestoreParam is nullptr");
983     std::string clientName = cameraRestoreParam->GetClientName();
984     std::string cameraId = cameraRestoreParam->GetCameraId();
985     std::map<std::string, sptr<HCameraRestoreParam>>::iterator iter = (persistentParamMap_[clientName]).begin();
986     while (iter != (persistentParamMap_[clientName]).end()) {
987         auto restoreParam = iter->second;
988         timeval closeTime = restoreParam->GetCloseCameraTime();
989         MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParam closeTime.tv_sec");
990         if (closeTime.tv_sec != 0 && CheckCameraId(restoreParam, cameraId)) {
991             timeval openTime;
992             gettimeofday(&openTime, nullptr);
993             long timeInterval = (openTime.tv_sec - closeTime.tv_sec)+
994                 (openTime.tv_usec - closeTime.tv_usec) / 1000; // 1000 is Convert milliseconds to seconds
995             if ((long)(restoreParam->GetStartActiveTime() * 60) < timeInterval) { // 60 is 60 Seconds
996                 MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParam get persistent");
997                 cameraRestoreParam = restoreParam;
998             } else {
999                 MEDIA_DEBUG_LOG("HCameraHostManager::UpdateRestoreParam get transistent ");
1000                 cameraRestoreParam = GetTransitentParam(clientName, cameraId);
1001             }
1002             break;
1003         }
1004         ++iter;
1005     }
1006 }
1007 
GetTransitentParam(const std::string & clientName,const std::string & cameraId)1008 sptr<HCameraRestoreParam> HCameraHostManager::GetTransitentParam(const std::string& clientName,
1009     const std::string& cameraId)
1010 {
1011     std::vector<StreamInfo_V1_1> streamInfos;
1012     RestoreParamTypeOhos restoreParamType = RestoreParamTypeOhos::NO_NEED_RESTORE_PARAM_OHOS;
1013     sptr<HCameraRestoreParam> cameraRestoreParam = new HCameraRestoreParam(clientName, cameraId,
1014         streamInfos, nullptr, restoreParamType, 0);
1015     auto iter = transitentParamMap_.find(clientName);
1016     if (iter != transitentParamMap_.end() && (CheckCameraId(transitentParamMap_[clientName], cameraId))) {
1017         cameraRestoreParam = transitentParamMap_[clientName];
1018         MEDIA_DEBUG_LOG("HCameraHostManager::GetTransitentParam end");
1019     }
1020     return cameraRestoreParam;
1021 }
1022 
CheckCameraId(sptr<HCameraRestoreParam> cameraRestoreParam,const std::string & cameraId)1023 bool HCameraHostManager::CheckCameraId(sptr<HCameraRestoreParam> cameraRestoreParam, const std::string& cameraId)
1024 {
1025     CHECK_ERROR_RETURN_RET(cameraRestoreParam == nullptr, false);
1026     CHECK_ERROR_RETURN_RET(cameraRestoreParam->GetCameraId() == cameraId, true);
1027     return false;
1028 }
1029 
1030 
AddCameraHost(const std::string & svcName)1031 void HCameraHostManager::AddCameraHost(const std::string& svcName)
1032 {
1033     MEDIA_INFO_LOG("HCameraHostManager::AddCameraHost camera host %{public}s added", svcName.c_str());
1034     std::lock_guard<std::mutex> lock(mutex_);
1035     if (std::any_of(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1036                     [&svcName](const auto& camHost) { return camHost->GetName() == svcName; })) {
1037         MEDIA_INFO_LOG("HCameraHostManager::AddCameraHost camera host  %{public}s already exists", svcName.c_str());
1038         return;
1039     }
1040     if (cameraHostDeadCallback_ == nullptr) {
1041         cameraHostDeadCallback_ = std::make_shared<CameraHostDeadCallback>(this);
1042     }
1043     auto statusCallback = statusCallback_.lock();
1044     sptr<HCameraHostManager::CameraHostInfo> cameraHost =
1045         new (std::nothrow) HCameraHostManager::CameraHostInfo(statusCallback, cameraHostDeadCallback_, svcName);
1046     CHECK_ERROR_RETURN_LOG(cameraHost == nullptr, "failed to new cameraHost!");
1047     CHECK_ERROR_RETURN_LOG(!cameraHost->Init(), "HCameraHostManager::AddCameraHost failed due to init failure");
1048     cameraHostInfos_.push_back(cameraHost);
1049     std::vector<std::string> cameraIds;
1050     if (statusCallback && cameraHost->GetCameras(cameraIds) == CAMERA_OK) {
1051         for (const auto& cameraId : cameraIds) {
1052             statusCallback->OnCameraStatus(cameraId, CAMERA_STATUS_AVAILABLE);
1053         }
1054     }
1055     if (statusCallback && svcName == LOCAL_SERVICE_NAME) {
1056         statusCallback->OnTorchStatus(TORCH_STATUS_OFF);
1057     }
1058 }
1059 
RemoveCameraHost(const std::string & svcName)1060 void HCameraHostManager::RemoveCameraHost(const std::string& svcName)
1061 {
1062     std::lock_guard<std::mutex> lock(mutex_);
1063     MEDIA_INFO_LOG("HCameraHostManager::RemoveCameraHost camera host %{public}s removed", svcName.c_str());
1064     std::vector<sptr<CameraHostInfo>>::iterator it = std::find_if(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1065         [&svcName](const auto& camHost) { return camHost->GetName() == svcName; });
1066     if (it == cameraHostInfos_.end()) {
1067         MEDIA_WARNING_LOG("HCameraHostManager::RemoveCameraHost camera host %{public}s doesn't exist",
1068             svcName.c_str());
1069         return;
1070     }
1071     std::vector<std::string> cameraIds;
1072     if ((*it)->GetCameras(cameraIds) == CAMERA_OK) {
1073         for (const auto& cameraId : cameraIds) {
1074             (*it)->OnCameraStatus(cameraId, UN_AVAILABLE);
1075             CloseCameraDevice(cameraId);
1076         }
1077     }
1078     *it = nullptr;
1079     cameraHostInfos_.erase(it);
1080     auto statusCallback = statusCallback_.lock();
1081     if (statusCallback && svcName == LOCAL_SERVICE_NAME) {
1082         statusCallback->OnTorchStatus(TORCH_STATUS_UNAVAILABLE);
1083     }
1084 }
1085 
FindCameraHostInfo(const std::string & cameraId)1086 sptr<HCameraHostManager::CameraHostInfo> HCameraHostManager::FindCameraHostInfo(const std::string& cameraId)
1087 {
1088     std::lock_guard<std::mutex> lock(mutex_);
1089     for (const auto& cameraHostInfo : cameraHostInfos_) {
1090         if (cameraHostInfo->IsCameraSupported(cameraId)) {
1091             return cameraHostInfo;
1092         }
1093     }
1094     return nullptr;
1095 }
1096 
FindLocalCameraHostInfo()1097 sptr<HCameraHostManager::CameraHostInfo> HCameraHostManager::FindLocalCameraHostInfo()
1098 {
1099     std::lock_guard<std::mutex> lock(mutex_);
1100     std::vector<sptr<CameraHostInfo>>::iterator it = std::find_if(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1101         [](const auto& cameraHostInfo) { return cameraHostInfo->GetName() == LOCAL_SERVICE_NAME; });
1102     if (it != cameraHostInfos_.end()) {
1103         return (*it);
1104     }
1105     return nullptr;
1106 }
1107 
IsCameraHostInfoAdded(const std::string & svcName)1108 bool HCameraHostManager::IsCameraHostInfoAdded(const std::string& svcName)
1109 {
1110     std::lock_guard<std::mutex> lock(mutex_);
1111     return std::any_of(cameraHostInfos_.begin(), cameraHostInfos_.end(),
1112                        [&svcName](const auto& camHost) {return camHost->GetName() == svcName; });
1113 }
1114 
GetRegisterServStatListener()1115 ::OHOS::sptr<HDI::ServiceManager::V1_0::IServStatListener> HCameraHostManager::GetRegisterServStatListener()
1116 {
1117     return registerServStatListener_;
1118 }
1119 
SetMuteMode(bool muteMode)1120 void HCameraHostManager::SetMuteMode(bool muteMode)
1121 {
1122     muteMode_ = muteMode;
1123 }
1124 
OnReceive(const HDI::ServiceManager::V1_0::ServiceStatus & status)1125 void RegisterServStatListener::OnReceive(const HDI::ServiceManager::V1_0::ServiceStatus& status)
1126 {
1127     MEDIA_INFO_LOG("HCameraHostManager::OnReceive for camerahost %{public}s, status %{public}d, deviceClass %{public}d",
1128         status.serviceName.c_str(), status.status, status.deviceClass);
1129 
1130     if (status.deviceClass != DEVICE_CLASS_CAMERA) {
1131         MEDIA_ERR_LOG("HCameraHostManager::OnReceive invalid device class %{public}d", status.deviceClass);
1132         return;
1133     }
1134     callback_(status);
1135 }
1136 } // namespace CameraStandard
1137 } // namespace OHOS
1138