1 /* 2 * Copyright (c) 2021-2022 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 #ifndef OHOS_CAMERA_H_CAMERA_HOST_MANAGER_H 17 #define OHOS_CAMERA_H_CAMERA_HOST_MANAGER_H 18 19 #include <refbase.h> 20 #include <iostream> 21 #include <map> 22 #include <utility> 23 #include <memory> 24 #include <mutex> 25 #include <string> 26 #include <vector> 27 #include "camera_log.h" 28 #include "camera_metadata_info.h" 29 #include "v1_0/icamera_device.h" 30 #include "v1_1/icamera_device.h" 31 #include "v1_2/icamera_device.h" 32 #include "v1_0/icamera_host.h" 33 #include "v1_1/icamera_host.h" 34 #include "v1_2/icamera_host.h" 35 #include "icamera_device_service.h" 36 #include "icamera_service_callback.h" 37 #include "iservmgr_hdi.h" 38 #include "iservstat_listener_hdi.h" 39 #include "hcamera_restore_param.h" 40 41 namespace OHOS { 42 namespace CameraStandard { 43 using OHOS::HDI::Camera::V1_0::ICameraDeviceCallback; 44 class HCameraHostManager : public RefBase { 45 public: 46 class StatusCallback { 47 public: 48 virtual ~StatusCallback() = default; 49 virtual void OnCameraStatus(const std::string& cameraId, CameraStatus status) = 0; 50 virtual void OnFlashlightStatus(const std::string& cameraId, FlashStatus status) = 0; 51 virtual void OnTorchStatus(TorchStatus status) = 0; 52 }; 53 class CameraHostDeadCallback { 54 public: CameraHostDeadCallback(wptr<HCameraHostManager> hostManager)55 explicit CameraHostDeadCallback(wptr<HCameraHostManager> hostManager) : hostManager_(hostManager) {}; 56 virtual ~CameraHostDeadCallback() = default; OnCameraHostDied(const std::string & hostName)57 virtual void OnCameraHostDied(const std::string& hostName) 58 { 59 auto hostManager = hostManager_.promote(); 60 if (hostManager == nullptr) { 61 MEDIA_ERR_LOG("HCameraHostManager OnCameraHostDied, but manager is nullptr"); 62 } 63 hostManager->RemoveCameraHost(hostName); 64 }; 65 66 private: 67 wptr<HCameraHostManager> hostManager_; 68 }; 69 70 explicit HCameraHostManager(std::shared_ptr<StatusCallback> statusCallback); 71 ~HCameraHostManager() override; 72 73 int32_t Init(void); 74 void DeInit(void); 75 void AddCameraDevice(const std::string& cameraId, sptr<ICameraDeviceService> cameraDevice); 76 virtual int32_t GetVersionByCamera(const std::string& cameraId); 77 void RemoveCameraDevice(const std::string& cameraId); 78 void CloseCameraDevice(const std::string& cameraId); 79 80 virtual int32_t GetCameras(std::vector<std::string> &cameraIds); 81 virtual int32_t GetCameraAbility(std::string &cameraId, std::shared_ptr<OHOS::Camera::CameraMetadata> &ability); 82 virtual int32_t OpenCameraDevice(std::string &cameraId, 83 const sptr<ICameraDeviceCallback> &callback, 84 sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> &pDevice); 85 virtual int32_t SetFlashlight(const std::string& cameraId, bool isEnable); 86 virtual int32_t Prelaunch(const std::string& cameraId, std::string clientName); 87 virtual int32_t PreSwitchCamera(const std::string& cameraId); 88 virtual int32_t SetTorchLevel(float level); 89 void NotifyDeviceStateChangeInfo(int notifyType, int deviceState); 90 91 void SaveRestoreParam(sptr<HCameraRestoreParam> cameraRestoreParam); 92 93 void UpdateRestoreParamCloseTime(const std::string& clientName, const std::string& cameraId); 94 95 sptr<HCameraRestoreParam> GetRestoreParam(const std::string& clientName, const std::string& cameraId); 96 97 sptr<HCameraRestoreParam> GetTransitentParam(const std::string& clientName, const std::string& cameraId); 98 99 void UpdateRestoreParam(sptr<HCameraRestoreParam> &cameraRestoreParam); 100 101 void DeleteRestoreParam(const std::string& clientName, const std::string& cameraId); 102 103 bool CheckCameraId(sptr<HCameraRestoreParam> cameraRestoreParam, const std::string& cameraId); 104 105 void AddCameraHost(const std::string& svcName); 106 107 void RemoveCameraHost(const std::string& svcName); 108 109 ::OHOS::sptr<HDI::ServiceManager::V1_0::IServStatListener> GetRegisterServStatListener(); 110 111 static const std::string LOCAL_SERVICE_NAME; 112 113 private: 114 struct CameraDeviceInfo; 115 class CameraHostInfo; 116 117 sptr<CameraHostInfo> FindCameraHostInfo(const std::string& cameraId); 118 sptr<CameraHostInfo> FindLocalCameraHostInfo(); 119 bool IsCameraHostInfoAdded(const std::string& svcName); 120 121 std::mutex mutex_; 122 std::mutex deviceMutex_; 123 std::mutex saveRestoreMutex_; 124 std::weak_ptr<StatusCallback> statusCallback_; 125 std::shared_ptr<CameraHostDeadCallback> cameraHostDeadCallback_; 126 std::vector<sptr<CameraHostInfo>> cameraHostInfos_; 127 std::map<std::string, sptr<ICameraDeviceService>> cameraDevices_; 128 std::map<std::string, std::map<std::string, sptr<HCameraRestoreParam>>> persistentParamMap_; 129 std::map<std::string, sptr<HCameraRestoreParam>> transitentParamMap_; 130 ::OHOS::sptr<HDI::ServiceManager::V1_0::IServStatListener> registerServStatListener_; 131 }; 132 133 class RegisterServStatListener : public HDI::ServiceManager::V1_0::ServStatListenerStub { 134 public: 135 using StatusCallback = std::function<void(const HDI::ServiceManager::V1_0::ServiceStatus&)>; 136 RegisterServStatListener(StatusCallback callback)137 explicit RegisterServStatListener(StatusCallback callback) : callback_(std::move(callback)) { 138 } 139 140 ~RegisterServStatListener() override = default; 141 142 void OnReceive(const HDI::ServiceManager::V1_0::ServiceStatus& status) override; 143 144 private: 145 StatusCallback callback_; 146 }; 147 } // namespace CameraStandard 148 } // namespace OHOS 149 #endif // OHOS_CAMERA_H_CAMERA_HOST_MANAGER_H 150