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; CameraMetaInfoCameraMetaInfo65 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<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 int32_t RequireMemorySize(int32_t memSize) override; 160 protected: 161 explicit HCameraService(sptr<HCameraHostManager> cameraHostManager); 162 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 163 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 164 165 private: 166 int32_t GetMuteModeFromDataShareHelper(bool &muteMode); 167 int32_t SetMuteModeByDataShareHelper(bool muteMode); 168 int32_t MuteCameraFunc(bool muteMode); 169 #ifdef DEVICE_MANAGER 170 class DeviceInitCallBack; 171 #endif 172 private: 173 class ServiceHostStatus : public StatusCallback { 174 public: ServiceHostStatus(wptr<HCameraService> cameraService)175 explicit ServiceHostStatus(wptr<HCameraService> cameraService) : cameraService_(cameraService) {}; 176 virtual ~ServiceHostStatus() = default; OnCameraStatus(const std::string & cameraId,CameraStatus status,CallbackInvoker invoker)177 void OnCameraStatus(const std::string& cameraId, CameraStatus status, CallbackInvoker invoker) override 178 { 179 auto cameraService = cameraService_.promote(); 180 if (cameraService != nullptr) { 181 cameraService->OnCameraStatus(cameraId, status, invoker); 182 } 183 } OnFlashlightStatus(const std::string & cameraId,FlashStatus status)184 void OnFlashlightStatus(const std::string& cameraId, FlashStatus status) override 185 { 186 auto cameraService = cameraService_.promote(); 187 if (cameraService != nullptr) { 188 cameraService->OnFlashlightStatus(cameraId, status); 189 } 190 } OnTorchStatus(TorchStatus status)191 void OnTorchStatus(TorchStatus status) override 192 { 193 auto cameraService = cameraService_.promote(); 194 if (cameraService != nullptr) { 195 cameraService->OnTorchStatus(status); 196 } 197 } 198 199 private: 200 wptr<HCameraService> cameraService_; 201 }; 202 203 class CameraDataShareHelper { 204 public: 205 CameraDataShareHelper() = default; 206 ~CameraDataShareHelper() = default; 207 int32_t QueryOnce(const std::string key, std::string &value); 208 int32_t UpdateOnce(const std::string key, std::string value); 209 private: 210 std::shared_ptr<DataShare::DataShareHelper> CreateCameraDataShareHelper(); 211 }; 212 213 void FillCameras(vector<shared_ptr<CameraMetaInfo>>& cameraInfos, 214 vector<string>& cameraIds, vector<shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList); 215 shared_ptr<CameraMetaInfo>GetCameraMetaInfo(std::string &cameraId, 216 shared_ptr<OHOS::Camera::CameraMetadata>cameraAbility); 217 void OnMute(bool muteMode); 218 void ExecutePidSetCallback(sptr<ICameraServiceCallback>& callback, std::vector<std::string> &cameraIds); 219 220 void DumpCameraSummary(vector<string> cameraIds, CameraInfoDumper& infoDumper); 221 void DumpCameraInfo(CameraInfoDumper& infoDumper, std::vector<std::string>& cameraIds, 222 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList); 223 void DumpCameraAbility(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 224 void DumpCameraStreamInfo(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 225 void DumpCameraZoom(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 226 void DumpCameraFlash(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 227 void DumpCameraAF(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 228 void DumpCameraQualityPrioritization(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 229 void DumpCameraAE(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 230 void DumpCameraSensorInfo(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 231 void DumpCameraVideoStabilization(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 232 void DumpCameraVideoFrameRateRange(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 233 void DumpCameraPrelaunch(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 234 void DumpCameraThumbnail(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 235 236 vector<shared_ptr<CameraMetaInfo>> ChooseDeFaultCameras(vector<shared_ptr<CameraMetaInfo>> cameraInfos); 237 vector<shared_ptr<CameraMetaInfo>> ChoosePhysicalCameras(const vector<shared_ptr<CameraMetaInfo>>& cameraInfos, 238 const vector<shared_ptr<CameraMetaInfo>>& choosedCameras); 239 bool IsCameraMuteSupported(string cameraId); 240 bool IsPrelaunchSupported(string cameraId); 241 int32_t UpdateMuteSetting(sptr<HCameraDevice> cameraDevice, bool muteMode); 242 std::shared_ptr<OHOS::Camera::CameraMetadata> CreateDefaultSettingForRestore(sptr<HCameraDevice> activeDevice); 243 int32_t UpdateSkinSmoothSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, int skinSmoothValue); 244 int32_t UpdateFaceSlenderSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, 245 int faceSlenderValue); 246 int32_t UpdateSkinToneSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, int skinToneValue); 247 int32_t UnSetCameraCallback(pid_t pid); 248 int32_t UnSetMuteCallback(pid_t pid); 249 int32_t UnSetTorchCallback(pid_t pid); 250 #ifdef CAMERA_USE_SENSOR 251 void RegisterSensorCallback(); 252 void UnRegisterSensorCallback(); 253 static void DropDetectionDataCallbackImpl(SensorEvent *event); 254 #endif 255 int32_t SaveCurrentParamForRestore(string cameraId, RestoreParamTypeOhos restoreParamType, int activeTime, 256 EffectParam effectParam, sptr<HCaptureSession> captureSession); 257 mutex mutex_; 258 mutex cameraCbMutex_; 259 mutex muteCbMutex_; 260 mutex serviceStatusMutex_; 261 recursive_mutex torchCbMutex_; 262 recursive_mutex foldCbMutex_; 263 TorchStatus torchStatus_ = TorchStatus::TORCH_STATUS_UNAVAILABLE; 264 FoldStatus preFoldStatus_ = FoldStatus::UNKNOWN_FOLD; 265 sptr<HCameraHostManager> cameraHostManager_; 266 std::shared_ptr<StatusCallback> statusCallback_; 267 map<uint32_t, sptr<ITorchServiceCallback>> torchServiceCallbacks_; 268 map<uint32_t, sptr<IFoldServiceCallback>> foldServiceCallbacks_; 269 map<uint32_t, sptr<ICameraMuteServiceCallback>> cameraMuteServiceCallbacks_; 270 map<uint32_t, sptr<ICameraServiceCallback>> cameraServiceCallbacks_; 271 map<string, CameraStatusCallbacksInfo> cameraStatusCallbacks_; 272 bool muteModeStored_; 273 bool isFoldable = false; 274 bool isFoldableInit = false; 275 string preCameraId_; 276 string preCameraClient_; 277 bool isRegisterSensorSuccess; 278 std::shared_ptr<CameraDataShareHelper> cameraDataShareHelper_; 279 CameraServiceStatus serviceStatus_; 280 sptr<ICameraBroker> peerCallback_; 281 bool isFoldRegister = false; 282 sptr<IFoldServiceCallback> innerFoldCallback_; 283 #ifdef CAMERA_USE_SENSOR 284 SensorUser user; 285 #endif 286 SafeMap<uint32_t, sptr<HCaptureSession>> captureSessionsManager_; 287 std::mutex freezedPidListMutex_; 288 std::set<int32_t> freezedPidList_; 289 std::map<uint32_t, std::function<void()>> delayCbtaskMap; 290 std::map<uint32_t, std::function<void()>> delayFoldStatusCbTaskMap; 291 }; 292 } // namespace CameraStandard 293 } // namespace OHOS 294 #endif // OHOS_CAMERA_H_CAMERA_SERVICE_H 295