1 /* 2 * Copyright (c) 2021-2025 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 #include <atomic> 19 #include <cstdint> 20 #include <mutex> 21 #include <stdint.h> 22 #include "camera_metadata_info.h" 23 #include "icontrol_center_status_callback.h" 24 #include "task_manager.h" 25 #define EXPORT_API __attribute__((visibility("default"))) 26 27 #include <iostream> 28 #include <memory> 29 #include <nlohmann/json.hpp> 30 #include <set> 31 #include <shared_mutex> 32 #include <vector> 33 34 #include "camera_datashare_helper.h" 35 #include "camera_rotate_strategy_parser.h" 36 #include "camera_util.h" 37 #include "common_event_support.h" 38 #include "common_event_manager.h" 39 #include "display_manager.h" 40 #include "hcamera_device.h" 41 #include "hcamera_host_manager.h" 42 #include "camera_service_stub.h" 43 #include "hcapture_session.h" 44 #include "hmech_session.h" 45 #include "hstream_capture.h" 46 #include "hstream_operator.h" 47 #include "hstream_depth_data.h" 48 #include "hstream_metadata.h" 49 #include "hstream_repeat.h" 50 #include "datashare_helper.h" 51 #include "icamera_service_callback.h" 52 #include "imech_session_callback.h" 53 #include "iremote_stub.h" 54 #include "privacy_kit.h" 55 #include "refbase.h" 56 #include "system_ability.h" 57 #include "ideferred_photo_processing_session_callback.h" 58 #include "ideferred_photo_processing_session.h" 59 #include "input/i_standard_camera_listener.h" 60 61 namespace OHOS { 62 namespace CameraStandard { 63 using namespace std; 64 using namespace OHOS::HDI::Camera::V1_0; 65 using namespace DeferredProcessing; 66 struct CameraMetaInfo { 67 string cameraId; 68 uint8_t cameraType; 69 uint8_t position; 70 uint8_t connectionType; 71 uint8_t foldStatus; 72 std::vector<uint8_t> supportModes; 73 shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility; CameraMetaInfoCameraMetaInfo74 CameraMetaInfo(string cameraId, uint8_t cameraType, uint8_t position, uint8_t connectionType, uint8_t foldStatus, 75 std::vector<uint8_t> supportModes, shared_ptr<OHOS::Camera::CameraMetadata> cameraAbility) 76 : cameraId(cameraId), cameraType(cameraType), position(position), connectionType(connectionType), 77 foldStatus(foldStatus), supportModes(supportModes), cameraAbility(cameraAbility) {} 78 }; 79 80 struct CameraStatusCallbacksInfo { 81 CameraStatus status; 82 string bundleName; 83 }; 84 85 enum class CameraServiceStatus : int32_t { 86 SERVICE_READY = 0, 87 SERVICE_NOT_READY, 88 }; 89 90 enum TemperPressure { 91 TEMPER_PRESSURE_COOL = 0, 92 TEMPER_PRESSURE_NORMAL, 93 TEMPER_PRESSURE_WARM, 94 TEMPER_PRESSURE_HOT, 95 TEMPER_PRESSURE_OVERHEATED, 96 TEMPER_PRESSURE_WARNING, 97 TEMPER_PRESSURE_EMERGENCY, 98 TEMPER_PRESSURE_ESCAPE 99 }; 100 101 class CameraInfoDumper; 102 103 class EXPORT_API HCameraService 104 : public SystemAbility, public CameraServiceStub, public HCameraHostManager::StatusCallback, 105 public OHOS::Rosen::DisplayManager::IFoldStatusListener { 106 DECLARE_SYSTEM_ABILITY(HCameraService); 107 108 public: 109 DISALLOW_COPY_AND_MOVE(HCameraService); 110 111 explicit HCameraService(int32_t systemAbilityId, bool runOnCreate = true); 112 ~HCameraService() override; 113 void CreateAndSaveTask(const string& cameraId, CameraStatus status, uint32_t pid); 114 int32_t GetCameras(vector<string>& cameraIds, 115 vector<shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList) override; 116 int32_t GetCameraIds(std::vector<std::string>& cameraIds) override; 117 int32_t GetCameraAbility(const std::string& cameraId, 118 std::shared_ptr<OHOS::Camera::CameraMetadata>& cameraAbility) override; 119 int32_t CreateCameraDevice(const string& cameraId, sptr<ICameraDeviceService>& device) override; 120 int32_t CreateCaptureSession(sptr<ICaptureSession>& session, int32_t opMode) override; 121 int32_t GetVideoSessionForControlCenter(sptr<ICaptureSession>& session) override; 122 int32_t CreateDeferredPhotoProcessingSession(int32_t userId, 123 const sptr<DeferredProcessing::IDeferredPhotoProcessingSessionCallback>& callback, 124 sptr<DeferredProcessing::IDeferredPhotoProcessingSession>& session) override; 125 int32_t CreateDeferredVideoProcessingSession(int32_t userId, 126 const sptr<DeferredProcessing::IDeferredVideoProcessingSessionCallback>& callback, 127 sptr<DeferredProcessing::IDeferredVideoProcessingSession>& session) override; 128 int32_t CreateMechSession(int32_t userId, sptr<IMechSession>& session) override; 129 int32_t IsMechSupported(bool &isMechSupported) override; 130 int32_t CreatePhotoOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 131 int32_t height, sptr<IStreamCapture>& photoOutput) override; 132 int32_t CreatePhotoOutput( 133 int32_t format, int32_t width, int32_t height, sptr<IStreamCapture> &photoOutput) override; 134 int32_t CreateDeferredPreviewOutput( 135 int32_t format, int32_t width, int32_t height, sptr<IStreamRepeat>& previewOutput) override; 136 int32_t CreatePreviewOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 137 int32_t height, sptr<IStreamRepeat>& previewOutput) override; 138 int32_t CreateDepthDataOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 139 int32_t height, sptr<IStreamDepthData>& depthDataOutput) override; 140 int32_t CreateMetadataOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, 141 const std::vector<int32_t>& metadataTypes, sptr<IStreamMetadata>& metadataOutput) override; 142 int32_t CreateVideoOutput(const sptr<OHOS::IBufferProducer>& producer, int32_t format, int32_t width, 143 int32_t height, sptr<IStreamRepeat>& videoOutput) override; 144 int32_t UnSetAllCallback(pid_t pid); 145 int32_t CloseCameraForDestory(pid_t pid); 146 int32_t SetCameraCallback(const sptr<ICameraServiceCallback>& callback) override; 147 int32_t UnSetCameraCallback() override; 148 int32_t SetMuteCallback(const sptr<ICameraMuteServiceCallback>& callback) override; 149 int32_t UnSetMuteCallback() override; 150 int32_t SetTorchCallback(const sptr<ITorchServiceCallback>& callback) override; 151 int32_t UnSetTorchCallback() override; 152 int32_t SetFoldStatusCallback(const sptr<IFoldServiceCallback>& callback, bool isInnerCallback) override; 153 int32_t UnSetFoldStatusCallback() override; 154 int32_t MuteCamera(bool muteMode) override; 155 int32_t SetControlCenterCallback(const sptr<IControlCenterStatusCallback>& callback) override; 156 int32_t UnSetControlCenterStatusCallback() override; 157 int32_t EnableControlCenter(bool status, bool needPersistEnable) override; 158 int32_t SetControlCenterPrecondition(bool condition) override; 159 int32_t SetDeviceControlCenterAbility(bool ability) override; 160 int32_t GetControlCenterStatus(bool& status) override; 161 int32_t CheckControlCenterPermission() override; 162 int32_t MuteCameraPersist(PolicyType policyType, bool isMute) override; 163 int32_t PrelaunchCamera(int32_t flag) override; 164 int32_t ResetRssPriority() override; 165 int32_t PreSwitchCamera(const std::string& cameraId) override; 166 int32_t SetPrelaunchConfig(const string& cameraId, RestoreParamTypeOhos restoreParamType, int activeTime, 167 const EffectParam& effectParam) override; 168 int32_t IsTorchSupported(bool &isTorchSupported) override; 169 int32_t IsCameraMuteSupported(bool& isCameraMuteSupported) override; 170 int32_t IsCameraMuted(bool& muteMode) override; 171 int32_t GetTorchStatus(int32_t &status) override; 172 int32_t SetTorchLevel(float level) override; 173 int32_t AllowOpenByOHSide(const std::string& cameraId, int32_t state, bool &canOpenCamera) override; 174 int32_t NotifyCameraState(const std::string& cameraId, int32_t state) override; 175 int32_t SetPeerCallback(const sptr<ICameraBroker>& callback) override; 176 int32_t UnsetPeerCallback() override; 177 void OnDump() override; 178 void OnStart() override; 179 void OnStop() override; 180 int32_t Dump(int fd, const vector<u16string>& args) override; 181 int DestroyStubObj() override; 182 int SetListenerObject(const sptr<IRemoteObject>& object) override; 183 184 CameraServiceStatus GetServiceStatus(); 185 void SetServiceStatus(CameraServiceStatus); 186 // HCameraHostManager::StatusCallback 187 void OnCameraStatus(const string& cameraId, CameraStatus status, 188 CallbackInvoker invoker) override; 189 void OnFlashlightStatus(const string& cameraId, FlashStatus status) override; 190 void OnTorchStatus(TorchStatus status) override; 191 // for resource proxy 192 int32_t ProxyForFreeze(const std::set<int32_t>& pidList, bool isProxy) override; 193 int32_t ResetAllFreezeStatus() override; 194 int32_t GetDmDeviceInfo(std::vector<std::string> &deviceInfos) override; 195 int32_t GetCameraOutputStatus(int32_t pid, int32_t &status) override; 196 bool ShouldSkipStatusUpdates(pid_t pid); 197 void OnFoldStatusChanged(OHOS::Rosen::FoldStatus foldStatus) override; 198 int32_t UnSetFoldStatusCallback(pid_t pid); 199 int32_t UnSetControlCenterStatusCallback(pid_t pid); 200 void RegisterFoldStatusListener(); 201 void UnregisterFoldStatusListener(); 202 int32_t RequireMemorySize(int32_t memSize) override; 203 int32_t GetIdforCameraConcurrentType(int32_t cameraPosition, std::string &cameraId) override; 204 int32_t GetConcurrentCameraAbility(const std::string& cameraId, 205 std::shared_ptr<OHOS::Camera::CameraMetadata>& cameraAbility) override; 206 int32_t CheckWhiteList(bool &isInWhiteList) override; 207 int32_t GetCameraStorageSize(int64_t& size) override; 208 int32_t CallbackEnter([[maybe_unused]] uint32_t code) override; 209 int32_t CallbackExit([[maybe_unused]] uint32_t code, [[maybe_unused]] int32_t result) override; 210 protected: 211 explicit HCameraService(sptr<HCameraHostManager> cameraHostManager); 212 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 213 void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 214 215 private: 216 int32_t GetMuteModeFromDataShareHelper(bool &muteMode); 217 bool SetMuteModeFromDataShareHelper(); 218 void OnReceiveEvent(const EventFwk::CommonEventData &data); 219 int32_t SetMuteModeByDataShareHelper(bool muteMode); 220 int32_t MuteCameraFunc(bool muteMode); 221 int32_t GetControlCenterStatusFromDataShareHelper(bool &status); 222 void UpdateControlCenterStatus(bool isStart); 223 int32_t UpdateDataShareAndTag(bool status, bool needPersistEnable); 224 int32_t CreateControlCenterDataShare(std::map<std::string, 225 std::array<float, CONTROL_CENTER_DATA_SIZE>> controlCenterMap, std::string bundleName, bool status); 226 int8_t ChooseFisrtBootFoldCamIdx( 227 FoldStatus curFoldStatus, std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>> cameraAbilityList); 228 PressureStatus TransferTemperToPressure(int32_t temperLevel); 229 void ClearCameraListenerByPid(pid_t pid); 230 int DestroyStubForPid(pid_t pid); 231 void ClientDied(pid_t pid); 232 sptr<HCaptureSession> videoSessionForControlCenter_; 233 #ifdef NOTIFICATION_ENABLE 234 int32_t SetBeauty(int32_t beautyStatus); 235 #endif 236 237 #ifdef MEMMGR_OVERRID 238 void PrelaunchRequireMemory(int32_t flag); 239 #endif 240 241 #ifdef DEVICE_MANAGER 242 class DeviceInitCallBack; 243 #endif 244 private: 245 class ServiceHostStatus : public StatusCallback { 246 public: ServiceHostStatus(wptr<HCameraService> cameraService)247 explicit ServiceHostStatus(wptr<HCameraService> cameraService) : cameraService_(cameraService) {}; 248 virtual ~ServiceHostStatus() = default; OnCameraStatus(const std::string & cameraId,CameraStatus status,CallbackInvoker invoker)249 void OnCameraStatus(const std::string& cameraId, CameraStatus status, CallbackInvoker invoker) override 250 { 251 auto cameraService = cameraService_.promote(); 252 if (cameraService != nullptr) { 253 cameraService->OnCameraStatus(cameraId, status, invoker); 254 } 255 } OnFlashlightStatus(const std::string & cameraId,FlashStatus status)256 void OnFlashlightStatus(const std::string& cameraId, FlashStatus status) override 257 { 258 auto cameraService = cameraService_.promote(); 259 if (cameraService != nullptr) { 260 cameraService->OnFlashlightStatus(cameraId, status); 261 } 262 } OnTorchStatus(TorchStatus status)263 void OnTorchStatus(TorchStatus status) override 264 { 265 auto cameraService = cameraService_.promote(); 266 if (cameraService != nullptr) { 267 cameraService->OnTorchStatus(status); 268 } 269 } 270 271 private: 272 wptr<HCameraService> cameraService_; 273 }; 274 275 void FillCameras(vector<shared_ptr<CameraMetaInfo>>& cameraInfos, 276 vector<string>& cameraIds, vector<shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList); 277 shared_ptr<CameraMetaInfo>GetCameraMetaInfo(std::string &cameraId, 278 shared_ptr<OHOS::Camera::CameraMetadata>cameraAbility); 279 void OnMute(bool muteMode); 280 void ExecutePidSetCallback(const sptr<ICameraServiceCallback>& callback, std::vector<std::string> &cameraIds); 281 282 void DumpCameraSummary(vector<string> cameraIds, CameraInfoDumper& infoDumper); 283 void DumpCameraInfo(CameraInfoDumper& infoDumper, std::vector<std::string>& cameraIds, 284 std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList); 285 void DumpCameraAbility(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 286 void DumpCameraStreamInfo(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 287 void DumpCameraZoom(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 288 void DumpCameraFlash(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 289 void DumpCameraCompensation(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 290 void DumpCameraColorSpace(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 291 void DumpCameraAF(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 292 void DumpCameraQualityPrioritization(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 293 void DumpCameraAE(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 294 void DumpCameraSensorInfo(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 295 void DumpCameraVideoStabilization(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 296 void DumpCameraVideoFrameRateRange(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 297 void DumpCameraPrelaunch(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 298 void DumpCameraThumbnail(common_metadata_header_t* metadataEntry, CameraInfoDumper& infoDumper); 299 void DumpCameraConcurrency( 300 CameraInfoDumper& infoDumper, std::vector<std::shared_ptr<OHOS::Camera::CameraMetadata>>& cameraAbilityList); 301 302 vector<shared_ptr<CameraMetaInfo>> ChooseDeFaultCameras(vector<shared_ptr<CameraMetaInfo>> cameraInfos); 303 vector<shared_ptr<CameraMetaInfo>> ChoosePhysicalCameras(const vector<shared_ptr<CameraMetaInfo>>& cameraInfos, 304 const vector<shared_ptr<CameraMetaInfo>>& choosedCameras); 305 bool IsCameraMuteSupported(string cameraId); 306 bool IsPrelaunchSupported(string cameraId); 307 int32_t UpdateMuteSetting(sptr<HCameraDevice> cameraDevice, bool muteMode); 308 std::shared_ptr<OHOS::Camera::CameraMetadata> CreateDefaultSettingForRestore(sptr<HCameraDevice> activeDevice); 309 int32_t UpdateSkinSmoothSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, int skinSmoothValue); 310 int32_t UpdateFaceSlenderSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, 311 int faceSlenderValue); 312 int32_t UpdateSkinToneSetting(shared_ptr<OHOS::Camera::CameraMetadata> changedMetadata, int skinToneValue); 313 int32_t UnSetCameraCallback(pid_t pid); 314 int32_t UnSetMuteCallback(pid_t pid); 315 int32_t UnSetTorchCallback(pid_t pid); 316 int32_t SaveCurrentParamForRestore(string cameraId, RestoreParamTypeOhos restoreParamType, int activeTime, 317 EffectParam effectParam, sptr<HCaptureSession> captureSession); 318 319 mutex mutex_; 320 mutex cameraCbMutex_; 321 mutex muteCbMutex_; 322 mutex serviceStatusMutex_; 323 mutex controlCenterStatusMutex_; 324 recursive_mutex torchCbMutex_; 325 recursive_mutex foldCbMutex_; 326 TorchStatus torchStatus_ = TorchStatus::TORCH_STATUS_UNAVAILABLE; 327 FoldStatus preFoldStatus_ = FoldStatus::UNKNOWN_FOLD; 328 sptr<HCameraHostManager> cameraHostManager_; 329 std::shared_ptr<StatusCallback> statusCallback_; 330 map<uint32_t, sptr<ITorchServiceCallback>> torchServiceCallbacks_; 331 map<uint32_t, sptr<IFoldServiceCallback>> foldServiceCallbacks_; 332 map<uint32_t, sptr<ICameraMuteServiceCallback>> cameraMuteServiceCallbacks_; 333 map<uint32_t, sptr<ICameraServiceCallback>> cameraServiceCallbacks_; 334 map<uint32_t, sptr<IControlCenterStatusCallback>> controlcenterCallbacks_; 335 SafeMap<pid_t, sptr<IStandardCameraListener>> cameraListenerMap_; 336 337 void CacheCameraStatus(const string& cameraId, std::shared_ptr<CameraStatusCallbacksInfo> info); 338 std::shared_ptr<CameraStatusCallbacksInfo> GetCachedCameraStatus(const string& cameraId); 339 std::mutex cameraStatusCallbacksMutex_; 340 map<string, std::shared_ptr<CameraStatusCallbacksInfo>> cameraStatusCallbacks_; 341 342 void CacheFlashStatus(const string& cameraId, FlashStatus flashStatus); 343 FlashStatus GetCachedFlashStatus(const string& cameraId); 344 std::mutex flashStatusCallbacksMutex_; 345 map<string, FlashStatus> flashStatusCallbacks_; 346 347 bool muteModeStored_; 348 bool isFoldable = false; 349 bool isFoldableInit = false; 350 bool isControlCenterEnabled_ = false; 351 bool controlCenterPrecondition = true; 352 bool deviceControlCenterAbility = false; 353 string preCameraId_; 354 string preCameraClient_; 355 std::shared_ptr<CameraDataShareHelper> cameraDataShareHelper_; 356 CameraServiceStatus serviceStatus_ = CameraServiceStatus::SERVICE_READY; 357 358 std::mutex peerCallbackMutex_; 359 sptr<ICameraBroker> peerCallback_; 360 361 bool isFoldRegister = false; 362 sptr<IFoldServiceCallback> innerFoldCallback_; 363 std::vector<CameraRotateStrategyInfo> cameraRotateStrategyInfos_; 364 pid_t pressurePid_; 365 std::mutex freezedPidListMutex_; 366 std::set<int32_t> freezedPidList_; 367 std::map<uint32_t, std::map<string, std::function<void()>>> delayCbtaskMap_; 368 std::map<uint32_t, std::function<void()>> delayFoldStatusCbTaskMap; 369 }; 370 } // namespace CameraStandard 371 } // namespace OHOS 372 #endif // OHOS_CAMERA_H_CAMERA_SERVICE_H 373