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_SERVICE_H 17 #define OHOS_CAMERA_H_CAMERA_SERVICE_H 18 #define EXPORT_API __attribute__((visibility("default"))) 19 20 #include <iostream> 21 #include <memory> 22 #include <nlohmann/json.hpp> 23 #include <set> 24 #include <shared_mutex> 25 #include <vector> 26 27 #include "camera_datashare_helper.h" 28 #include "camera_sensor_plugin.h" 29 #include "camera_util.h" 30 #include "common_event_support.h" 31 #include "common_event_manager.h" 32 #include "display_manager.h" 33 #include "hcamera_device.h" 34 #include "hcamera_host_manager.h" 35 #include "hcamera_service_stub.h" 36 #include "hcapture_session.h" 37 #include "hstream_capture.h" 38 #include "hstream_depth_data.h" 39 #include "hstream_metadata.h" 40 #include "hstream_repeat.h" 41 #include "icamera_service_callback.h" 42 #include "iremote_stub.h" 43 #include "privacy_kit.h" 44 #include "refbase.h" 45 #include "system_ability.h" 46 #include "ideferred_photo_processing_session_callback.h" 47 #include "ideferred_photo_processing_session.h" 48 49 namespace OHOS { 50 namespace CameraStandard { 51 using namespace std; 52 using namespace OHOS::HDI::Camera::V1_0; 53 using namespace DeferredProcessing; 54 struct CameraMetaInfo { 55 string cameraId; 56 uint8_t cameraType; 57 uint8_t position; 58 uint8_t connectionType; 59 uint8_t foldStatus; 60 std::vector<uint8_t> supportModes; 61 shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility; CameraMetaInfoCameraMetaInfo62 CameraMetaInfo(string cameraId, uint8_t cameraType, uint8_t position, uint8_t connectionType, uint8_t foldStatus, 63 std::vector<uint8_t> supportModes, shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility) 64 : cameraId(cameraId), cameraType(cameraType), position(position), connectionType(connectionType), 65 foldStatus(foldStatus), supportModes(supportModes), cameraAbility(cameraAbility) {} 66 }; 67 68 struct CameraStatusCallbacksInfo { 69 CameraStatus status; 70 string bundleName; 71 }; 72 73 enum class CameraServiceStatus : int32_t { 74 SERVICE_READY = 0, 75 SERVICE_NOT_READY, 76 }; 77 78 class CameraInfoDumper; 79 80 class EXPORT_API HCameraService 81 : public SystemAbility, public HCameraServiceStub, public HCameraHostManager::StatusCallback, 82 public OHOS::Rosen::DisplayManager::IFoldStatusListener { 83 DECLARE_SYSTEM_ABILITY(HCameraService); 84 85 public: 86 DISALLOW_COPY_AND_MOVE(HCameraService); 87 88 explicit HCameraService(int32_t systemAbilityId, bool runOnCreate = true); 89 ~HCameraService() override; 90 int32_t GetCameras(vector<string>& cameraIds, 91 vector<shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList) override; 92 int32_t GetCameraIds(std::vector<string>& cameraIds) override; 93 int32_t GetCameraAbility(std::string& cameraId, 94 std::shared_ptr<OHOS::Camera::CameraMetadata>& cameraAbility) override; 95 int32_t CreateCameraDevice(string cameraId, sptr<ICameraDeviceService>& device) override; 96 int32_t CreateCaptureSession(sptr<ICaptureSession>& session, int32_t opMode) override; 97 int32_t CreateDeferredPhotoProcessingSession(int32_t userId, 98 sptr<DeferredProcessing::IDeferredPhotoProcessingSessionCallback>& callback, 99 sptr<DeferredProcessing::IDeferredPhotoProcessingSession>& session) override; 100 int32_t CreateDeferredVideoProcessingSession(int32_t userId, 101 sptr<DeferredProcessing::IDeferredVideoProcessingSessionCallback>& callback, 102 sptr<DeferredProcessing::IDeferredVideoProcessingSession>& session) override; 103 int32_t CreatePhotoOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 104 int32_t height, sptr<IStreamCapture>& photoOutput) override; 105 int32_t CreateDeferredPreviewOutput( 106 int32_t format, int32_t width, int32_t height, sptr<IStreamRepeat>& previewOutput) override; 107 int32_t CreatePreviewOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 108 int32_t height, sptr<IStreamRepeat>& previewOutput) override; 109 int32_t CreateDepthDataOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 110 int32_t height, sptr<IStreamDepthData>& depthDataOutput) override; 111 int32_t CreateMetadataOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, 112 std::vector<int32_t> metadataTypes, sptr<IStreamMetadata>& metadataOutput) override; 113 int32_t CreateVideoOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 114 int32_t height, sptr<IStreamRepeat>& videoOutput) override; 115 int32_t UnSetAllCallback(pid_t pid) override; 116 int32_t CloseCameraForDestory(pid_t pid) override; 117 int32_t SetCameraCallback(sptr<ICameraServiceCallback>& callback) override; 118 int32_t SetMuteCallback(sptr<ICameraMuteServiceCallback>& callback) override; 119 int32_t SetTorchCallback(sptr<ITorchServiceCallback>& callback) override; 120 int32_t SetFoldStatusCallback(sptr<IFoldServiceCallback>& callback, bool isInnerCallback = false) override; 121 int32_t MuteCamera(bool muteMode) override; 122 int32_t MuteCameraPersist(PolicyType policyType, bool isMute) override; 123 int32_t PrelaunchCamera() override; 124 int32_t PreSwitchCamera(const std::string cameraId) override; 125 int32_t SetPrelaunchConfig(string cameraId, RestoreParamTypeOhos restoreParamType, int activeTime, 126 EffectParam effectParam) override; 127 // std::string GetClientBundle(int uid); 128 int32_t IsCameraMuted(bool& muteMode) override; 129 int32_t SetTorchLevel(float level) override; 130 int32_t AllowOpenByOHSide(std::string cameraId, int32_t state, bool &canOpenCamera) override; 131 int32_t NotifyCameraState(std::string cameraId, int32_t state) override; 132 int32_t SetPeerCallback(sptr<ICameraBroker>& callback) override; 133 int32_t UnsetPeerCallback() override; 134 void OnDump() override; 135 void OnStart() override; 136 void OnStop() override; 137 int32_t Dump(int fd, const vector<u16string>& args) override; 138 139 CameraServiceStatus GetServiceStatus(); 140 void SetServiceStatus(CameraServiceStatus); 141 // HCameraHostManager::StatusCallback 142 void OnCameraStatus(const string& cameraId, CameraStatus status, 143 CallbackInvoker invoker) override; 144 void OnFlashlightStatus(const string& cameraId, FlashStatus status) override; 145 void OnTorchStatus(TorchStatus status) override; 146 // for resource proxy 147 int32_t ProxyForFreeze(const std::set<int32_t>& pidList, bool isProxy) override; 148 int32_t ResetAllFreezeStatus() override; 149 int32_t GetDmDeviceInfo(std::vector<std::string> &deviceInfos) override; 150 int32_t GetCameraOutputStatus(int32_t pid, int32_t &status) override; 151 bool ShouldSkipStatusUpdates(pid_t pid); 152 void OnFoldStatusChanged(OHOS::Rosen::FoldStatus foldStatus) override; 153 int32_t UnSetFoldStatusCallback(pid_t pid); 154 void RegisterFoldStatusListener(); 155 void UnRegisterFoldStatusListener(); 156 int32_t RequireMemorySize(int32_t memSize) override; 157 int32_t SetDeviceRetryTime() override; 158 protected: 159 explicit HCameraService(sptr<HCameraHostManager> cameraHostManager); 160 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 161 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 162 163 private: 164 int32_t GetMuteModeFromDataShareHelper(bool &muteMode); 165 bool SetMuteModeFromDataShareHelper(); 166 void OnReceiveEvent(const EventFwk::CommonEventData &data); 167 int32_t SetMuteModeByDataShareHelper(bool muteMode); 168 int32_t MuteCameraFunc(bool muteMode); 169 #ifdef NOTIFICATION_ENABLE 170 int32_t SetBeauty(int32_t beautyStatus); 171 #endif 172 #ifdef DEVICE_MANAGER 173 class DeviceInitCallBack; 174 #endif 175 private: 176 class ServiceHostStatus : public StatusCallback { 177 public: ServiceHostStatus(wptr<HCameraService> cameraService)178 explicit ServiceHostStatus(wptr<HCameraService> cameraService) : cameraService_(cameraService) {}; 179 virtual ~ServiceHostStatus() = default; OnCameraStatus(const std::string & cameraId,CameraStatus status,CallbackInvoker invoker)180 void OnCameraStatus(const std::string& cameraId, CameraStatus status, CallbackInvoker invoker) override 181 { 182 auto cameraService = cameraService_.promote(); 183 if (cameraService != nullptr) { 184 cameraService->OnCameraStatus(cameraId, status, invoker); 185 } 186 } OnFlashlightStatus(const std::string & cameraId,FlashStatus status)187 void OnFlashlightStatus(const std::string& cameraId, FlashStatus status) override 188 { 189 auto cameraService = cameraService_.promote(); 190 if (cameraService != nullptr) { 191 cameraService->OnFlashlightStatus(cameraId, status); 192 } 193 } OnTorchStatus(TorchStatus status)194 void OnTorchStatus(TorchStatus status) override 195 { 196 auto cameraService = cameraService_.promote(); 197 if (cameraService != nullptr) { 198 cameraService->OnTorchStatus(status); 199 } 200 } 201 202 private: 203 wptr<HCameraService> cameraService_; 204 }; 205 206 void FillCameras(vector<shared_ptr<CameraMetaInfo>>& cameraInfos, 207 vector<string>& cameraIds, vector<shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList); 208 shared_ptr<CameraMetaInfo>GetCameraMetaInfo(std::string &cameraId, 209 shared_ptr<OHOS::Camera::CameraMetadata>cameraAbility); 210 void OnMute(bool muteMode); 211 void ExecutePidSetCallback(sptr<ICameraServiceCallback>& callback, std::vector<std::string> &cameraIds); 212 213 void DumpCameraSummary(vector<string> cameraIds, CameraInfoDumper& infoDumper); 214 void DumpCameraInfo(CameraInfoDumper& infoDumper, std::vector<std::string>& cameraIds, 215 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList); 216 void DumpCameraAbility(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 217 void DumpCameraStreamInfo(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 218 void DumpCameraZoom(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 219 void DumpCameraFlash(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 220 void DumpCameraAF(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 221 void DumpCameraQualityPrioritization(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 222 void DumpCameraAE(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 223 void DumpCameraSensorInfo(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 224 void DumpCameraVideoStabilization(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 225 void DumpCameraVideoFrameRateRange(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 226 void DumpCameraPrelaunch(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 227 void DumpCameraThumbnail(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 228 229 vector<shared_ptr<CameraMetaInfo>> ChooseDeFaultCameras(vector<shared_ptr<CameraMetaInfo>> cameraInfos); 230 vector<shared_ptr<CameraMetaInfo>> ChoosePhysicalCameras(const vector<shared_ptr<CameraMetaInfo>>& cameraInfos, 231 const vector<shared_ptr<CameraMetaInfo>>& choosedCameras); 232 bool IsCameraMuteSupported(string cameraId); 233 bool IsPrelaunchSupported(string cameraId); 234 int32_t UpdateMuteSetting(sptr<HCameraDevice> cameraDevice, bool muteMode); 235 std::shared_ptr<OHOS::Camera::CameraMetadata> CreateDefaultSettingForRestore(sptr<HCameraDevice> activeDevice); 236 int32_t UpdateSkinSmoothSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, int skinSmoothValue); 237 int32_t UpdateFaceSlenderSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, 238 int faceSlenderValue); 239 int32_t UpdateSkinToneSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, int skinToneValue); 240 int32_t UnSetCameraCallback(pid_t pid); 241 int32_t UnSetMuteCallback(pid_t pid); 242 int32_t UnSetTorchCallback(pid_t pid); 243 #ifdef CAMERA_USE_SENSOR 244 void RegisterSensorCallback(); 245 void UnRegisterSensorCallback(); 246 static void DropDetectionDataCallbackImpl(const OHOS::Rosen::MotionSensorEvent &motionData); 247 #endif 248 int32_t SaveCurrentParamForRestore(string cameraId, RestoreParamTypeOhos restoreParamType, int activeTime, 249 EffectParam effectParam, sptr<HCaptureSession> captureSession); 250 mutex mutex_; 251 mutex cameraCbMutex_; 252 mutex muteCbMutex_; 253 mutex serviceStatusMutex_; 254 recursive_mutex torchCbMutex_; 255 recursive_mutex foldCbMutex_; 256 TorchStatus torchStatus_ = TorchStatus::TORCH_STATUS_UNAVAILABLE; 257 FoldStatus preFoldStatus_ = FoldStatus::UNKNOWN_FOLD; 258 sptr<HCameraHostManager> cameraHostManager_; 259 std::shared_ptr<StatusCallback> statusCallback_; 260 map<uint32_t, sptr<ITorchServiceCallback>> torchServiceCallbacks_; 261 map<uint32_t, sptr<IFoldServiceCallback>> foldServiceCallbacks_; 262 map<uint32_t, sptr<ICameraMuteServiceCallback>> cameraMuteServiceCallbacks_; 263 map<uint32_t, sptr<ICameraServiceCallback>> cameraServiceCallbacks_; 264 map<string, CameraStatusCallbacksInfo> cameraStatusCallbacks_; 265 bool muteModeStored_; 266 bool isFoldable = false; 267 bool isFoldableInit = false; 268 string preCameraId_; 269 string preCameraClient_; 270 bool isRegisterSensorSuccess; 271 std::shared_ptr<CameraDataShareHelper> cameraDataShareHelper_; 272 CameraServiceStatus serviceStatus_; 273 sptr<ICameraBroker> peerCallback_; 274 bool isFoldRegister = false; 275 sptr<IFoldServiceCallback> innerFoldCallback_; 276 SafeMap<uint32_t, sptr<HCaptureSession>> captureSessionsManager_; 277 std::mutex freezedPidListMutex_; 278 std::set<int32_t> freezedPidList_; 279 std::map<uint32_t, std::function<void()>> delayCbtaskMap; 280 std::map<uint32_t, std::function<void()>> delayFoldStatusCbTaskMap; 281 }; 282 } // namespace CameraStandard 283 } // namespace OHOS 284 #endif // OHOS_CAMERA_H_CAMERA_SERVICE_H 285