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