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_DEVICE_H
17 #define OHOS_CAMERA_H_CAMERA_DEVICE_H
18 #define EXPORT_API __attribute__((visibility("default")))
19 
20 #include <cstdint>
21 #include <functional>
22 #include <iostream>
23 #include <atomic>
24 #include <mutex>
25 
26 #include "camera_privacy.h"
27 #include "v1_0/icamera_device_callback.h"
28 #include "camera_metadata_info.h"
29 #include "camera_util.h"
30 #include "hcamera_device_stub.h"
31 #include "hcamera_host_manager.h"
32 #include "v1_0/icamera_device.h"
33 #include "v1_1/icamera_device.h"
34 #include "v1_2/icamera_device.h"
35 #include "v1_3/icamera_device.h"
36 #include "v1_0/icamera_host.h"
37 
38 namespace OHOS {
39 namespace CameraStandard {
40 constexpr int32_t HDI_STREAM_ID_INIT = 1;
41 using OHOS::HDI::Camera::V1_0::CaptureEndedInfo;
42 using OHOS::HDI::Camera::V1_0::CaptureErrorInfo;
43 using OHOS::HDI::Camera::V1_0::ICameraDeviceCallback;
44 using OHOS::HDI::Camera::V1_3::IStreamOperatorCallback;
45 class EXPORT_API HCameraDevice
46     : public HCameraDeviceStub, public ICameraDeviceCallback, public IStreamOperatorCallback {
47 public:
48     explicit HCameraDevice(
49         sptr<HCameraHostManager>& cameraHostManager, std::string cameraID, const uint32_t callingTokenId);
50     ~HCameraDevice();
51 
52     int32_t Open() override;
53     int32_t OpenSecureCamera(uint64_t* secureSeqId) override;
54     int32_t Close() override;
55     int32_t Release() override;
56     int32_t UpdateSetting(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings) override;
57     int32_t SetUsedAsPosition(uint8_t value) override;
58     int32_t UpdateSettingOnce(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings);
59     int32_t GetStatus(std::shared_ptr<OHOS::Camera::CameraMetadata> &metaIn,
60             std::shared_ptr<OHOS::Camera::CameraMetadata> &metaOut) override;
61     int32_t GetEnabledResults(std::vector<int32_t>& results) override;
62     int32_t EnableResult(std::vector<int32_t>& results) override;
63     int32_t DisableResult(std::vector<int32_t>& results) override;
64     int32_t ReleaseStreams(std::vector<int32_t>& releaseStreamIds);
65     sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> GetStreamOperator();
66     int32_t SetCallback(sptr<ICameraDeviceServiceCallback>& callback) override;
67     int32_t OnError(OHOS::HDI::Camera::V1_0::ErrorType type, int32_t errorCode) override;
68     int32_t OnResult(uint64_t timestamp, const std::vector<uint8_t>& result) override;
69     int32_t OnResult(int32_t streamId, const std::vector<uint8_t>& result) override;
70     std::shared_ptr<OHOS::Camera::CameraMetadata> GetDeviceAbility();
71     std::shared_ptr<OHOS::Camera::CameraMetadata> CloneCachedSettings();
72     std::string GetCameraId();
73     int32_t GetCameraType();
74     bool IsOpenedCameraDevice();
75     int32_t GetCallerToken();
76     int32_t CreateAndCommitStreams(std::vector<HDI::Camera::V1_1::StreamInfo_V1_1>& streamInfos,
77         std::shared_ptr<OHOS::Camera::CameraMetadata>& deviceSettings, int32_t operationMode);
78     int32_t UpdateStreams(std::vector<StreamInfo_V1_1>& streamInfos);
79 
80     int32_t OperatePermissionCheck(uint32_t interfaceCode) override;
81 
82     int32_t OnCaptureStarted(int32_t captureId, const std::vector<int32_t>& streamIds) override;
83     int32_t OnCaptureStarted_V1_2(
84         int32_t captureId, const std::vector<OHOS::HDI::Camera::V1_2::CaptureStartedInfo>& infos) override;
85     int32_t OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo>& infos) override;
86     int32_t OnCaptureEndedExt(
87         int32_t captureId, const std::vector<OHOS::HDI::Camera::V1_3::CaptureEndedInfoExt>& infos) override;
88     int32_t OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo>& infos) override;
89     int32_t OnFrameShutter(int32_t captureId, const std::vector<int32_t>& streamIds, uint64_t timestamp) override;
90     int32_t OnFrameShutterEnd(int32_t captureId, const std::vector<int32_t>& streamIds, uint64_t timestamp) override;
91     int32_t OnCaptureReady(int32_t captureId, const std::vector<int32_t>& streamIds, uint64_t timestamp) override;
92     int32_t ResetDeviceSettings();
93     int32_t DispatchDefaultSettingToHdi();
94     void SetDeviceMuteMode(bool muteMode);
95     uint8_t GetUsedAsPosition();
96     bool GetDeviceMuteMode();
97     void EnableMovingPhoto(bool isMovingPhotoEnabled);
98 
SetStreamOperatorCallback(wptr<IStreamOperatorCallback> operatorCallback)99     inline void SetStreamOperatorCallback(wptr<IStreamOperatorCallback> operatorCallback)
100     {
101         std::lock_guard<std::mutex> lock(proxyStreamOperatorCallbackMutex_);
102         proxyStreamOperatorCallback_ = operatorCallback;
103     }
104 
GetStreamOperatorCallback()105     inline sptr<IStreamOperatorCallback> GetStreamOperatorCallback()
106     {
107         std::lock_guard<std::mutex> lock(proxyStreamOperatorCallbackMutex_);
108         return proxyStreamOperatorCallback_.promote();
109     }
110 
SetCameraPrivacy(sptr<CameraPrivacy> cameraPrivacy)111     inline void SetCameraPrivacy(sptr<CameraPrivacy> cameraPrivacy)
112     {
113         std::lock_guard<std::mutex> lock(cameraPrivacyMutex_);
114         cameraPrivacy_ = cameraPrivacy;
115     }
116 
GetCameraPrivacy()117     inline sptr<CameraPrivacy> GetCameraPrivacy()
118     {
119         std::lock_guard<std::mutex> lock(cameraPrivacyMutex_);
120         return cameraPrivacy_;
121     }
122 
GenerateHdiStreamId()123     inline int32_t GenerateHdiStreamId()
124     {
125         return hdiStreamIdGenerator_.fetch_add(1);
126     }
127 
ResetHdiStreamId()128     inline void ResetHdiStreamId()
129     {
130         hdiStreamIdGenerator_ = HDI_STREAM_ID_INIT;
131     }
132 
133     void NotifyCameraSessionStatus(bool running);
134 
135     void RemoveResourceWhenHostDied();
136 
137     int64_t GetSecureCameraSeq(uint64_t* secureSeqId);
138 
139     bool CheckMovingPhotoSupported(int32_t mode);
140 
141     void NotifyCameraStatus(int32_t type);
142 
143     int32_t CloseDevice();
144 
145     void SetMovingPhotoStartTimeCallback(std::function<void(int64_t, int64_t)> callback);
146 
147     void SetMovingPhotoEndTimeCallback(std::function<void(int64_t, int64_t)> callback);
148 
149 private:
150     class FoldScreenListener;
151     static const std::vector<std::tuple<uint32_t, std::string, std::string>> reportTagInfos_;
152 
153     std::mutex opMutex_; // Lock the operations updateSettings_, streamOperator_, and hdiCameraDevice_.
154     std::shared_ptr<OHOS::Camera::CameraMetadata> updateSettings_;
155     sptr<OHOS::HDI::Camera::V1_0::IStreamOperator> streamOperator_;
156     sptr<OHOS::HDI::Camera::V1_0::ICameraDevice> hdiCameraDevice_;
157     std::shared_ptr<OHOS::Camera::CameraMetadata> cachedSettings_;
158 
159     sptr<HCameraHostManager> cameraHostManager_;
160     std::string cameraID_;
161     std::atomic<bool> isOpenedCameraDevice_;
162     std::mutex deviceSvcCbMutex_;
163     std::mutex cachedSettingsMutex_;
164     static std::mutex g_deviceOpenCloseMutex_;
165     sptr<ICameraDeviceServiceCallback> deviceSvcCallback_;
166     std::map<int32_t, wptr<ICameraServiceCallback>> statusSvcCallbacks_;
167 
168     uint32_t callerToken_;
169     std::mutex cameraPrivacyMutex_;
170     sptr<CameraPrivacy> cameraPrivacy_;
171     std::mutex proxyStreamOperatorCallbackMutex_;
172     wptr<IStreamOperatorCallback> proxyStreamOperatorCallback_;
173 
174     std::mutex deviceAbilityMutex_;
175     std::shared_ptr<OHOS::Camera::CameraMetadata> deviceAbility_;
176 
177     std::mutex deviceOpenLifeCycleMutex_;
178     std::shared_ptr<OHOS::Camera::CameraMetadata> deviceOpenLifeCycleSettings_;
179 
180     std::string clientName_;
181     int clientUserId_;
182     uint8_t usedAsPosition_ = OHOS_CAMERA_POSITION_OTHER;
183     std::mutex unPrepareZoomMutex_;
184     uint32_t zoomTimerId_;
185     std::atomic<bool> inPrepareZoom_;
186     std::atomic<bool> deviceMuteMode_;
187     bool isHasOpenSecure = false;
188     uint64_t mSecureCameraSeqId = 0L;
189 
190     std::atomic<int32_t> hdiStreamIdGenerator_ = HDI_STREAM_ID_INIT;
191     void UpdateDeviceOpenLifeCycleSettings(std::shared_ptr<OHOS::Camera::CameraMetadata> changedSettings);
192     void ResetDeviceOpenLifeCycleSettings();
193 
194     sptr<ICameraDeviceServiceCallback> GetDeviceServiceCallback();
195     void ResetCachedSettings();
196     int32_t InitStreamOperator();
197     void ReportMetadataDebugLog(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings);
198     void RegisterFoldStatusListener();
199     void UnRegisterFoldStatusListener();
200     void CheckOnResultData(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult);
201     int32_t CreateStreams(std::vector<HDI::Camera::V1_1::StreamInfo_V1_1>& streamInfos);
202     int32_t CommitStreams(std::shared_ptr<OHOS::Camera::CameraMetadata>& deviceSettings, int32_t operationMode);
203     bool CanOpenCamera();
204     void ResetZoomTimer();
205     void CheckZoomChange(const std::shared_ptr<OHOS::Camera::CameraMetadata>& settings);
206     void UnPrepareZoom();
207     int32_t OpenDevice(bool isEnableSecCam = false);
208     void HandleFoldableDevice();
209     int32_t CheckPermissionBeforeOpenDevice();
210     bool HandlePrivacyBeforeOpenDevice();
211     void HandlePrivacyWhenOpenDeviceFail();
212     void HandlePrivacyAfterCloseDevice();
213     void DebugLogForSmoothZoom(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag);
214     void DebugLogForAfRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag);
215     void DebugLogForAeRegions(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings, uint32_t tag);
216     void DebugLogTag(const std::shared_ptr<OHOS::Camera::CameraMetadata> &settings,
217                      uint32_t tag, std::string tagName, std::string dfxUbStr);
218     void CreateMuteSetting(std::shared_ptr<OHOS::Camera::CameraMetadata>& settings);
219     int32_t UpdateDeviceSetting();
220 #ifdef MEMMGR_OVERRID
221     int32_t RequireMemory(const std::string& reason);
222 #endif
223     void GetMovingPhotoStartAndEndTime(std::shared_ptr<OHOS::Camera::CameraMetadata> cameraResult);
224     bool isMovingPhotoEnabled_ = false;
225     std::mutex movingPhotoStartTimeCallbackLock_;
226     std::mutex movingPhotoEndTimeCallbackLock_;
227     std::function<void(int32_t, int64_t)> movingPhotoStartTimeCallback_;
228     std::function<void(int32_t, int64_t)> movingPhotoEndTimeCallback_;
229 };
230 } // namespace CameraStandard
231 } // namespace OHOS
232 #endif // OHOS_CAMERA_H_CAMERA_DEVICE_H
233