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