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