1 /* 2 * Copyright (c) 2023 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_ROSEN_WINDOW_SCENE_SCREEN_SESSION_MANAGER_H 17 #define OHOS_ROSEN_WINDOW_SCENE_SCREEN_SESSION_MANAGER_H 18 19 #include <shared_mutex> 20 #include <system_ability.h> 21 #include <mutex> 22 #include <condition_variable> 23 24 #include "common/include/task_scheduler.h" 25 #include "dm_common.h" 26 #include "event_tracker.h" 27 #include "session/screen/include/screen_session.h" 28 #include "zidl/screen_session_manager_stub.h" 29 #include "client_agent_container.h" 30 #include "session_display_power_controller.h" 31 #include "wm_single_instance.h" 32 33 #include "agent_death_recipient.h" 34 #include "screen.h" 35 #include "screen_cutout_controller.h" 36 #include "fold_screen_controller/fold_screen_controller.h" 37 #include "fold_screen_controller/fold_screen_sensor_manager.h" 38 39 namespace OHOS::Rosen { 40 class RSInterfaces; 41 42 class ScreenSessionManager : public SystemAbility, public ScreenSessionManagerStub, public IScreenChangeListener { 43 DECLARE_SYSTEM_ABILITY(ScreenSessionManager) 44 WM_DECLARE_SINGLE_INSTANCE_BASE(ScreenSessionManager) 45 46 public: 47 sptr<ScreenSession> GetScreenSession(ScreenId screenId) const; 48 sptr<ScreenSession> GetDefaultScreenSession(); 49 std::vector<ScreenId> GetAllScreenIds(); 50 51 sptr<DisplayInfo> GetDefaultDisplayInfo() override; 52 DMError SetScreenActiveMode(ScreenId screenId, uint32_t modeId) override; 53 DMError SetVirtualPixelRatio(ScreenId screenId, float virtualPixelRatio) override; 54 DMError SetVirtualPixelRatioSystem(ScreenId screenId, float virtualPixelRatio) override; 55 DMError SetResolution(ScreenId screenId, uint32_t width, uint32_t height, float virtualPixelRatio) override; 56 DMError GetDensityInCurResolution(ScreenId screenId, float& virtualPixelRatio) override; 57 void NotifyScreenChanged(sptr<ScreenInfo> screenInfo, ScreenChangeEvent event); 58 59 DMError GetScreenColorGamut(ScreenId screenId, ScreenColorGamut& colorGamut) override; 60 DMError SetScreenColorGamut(ScreenId screenId, int32_t colorGamutIdx) override; 61 DMError GetScreenGamutMap(ScreenId screenId, ScreenGamutMap& gamutMap) override; 62 DMError SetScreenGamutMap(ScreenId screenId, ScreenGamutMap gamutMap) override; 63 DMError SetScreenColorTransform(ScreenId screenId) override; 64 65 DMError GetPixelFormat(ScreenId screenId, GraphicPixelFormat& pixelFormat) override; 66 DMError SetPixelFormat(ScreenId screenId, GraphicPixelFormat pixelFormat) override; 67 DMError GetSupportedHDRFormats(ScreenId screenId, std::vector<ScreenHDRFormat>& hdrFormats) override; 68 DMError GetScreenHDRFormat(ScreenId screenId, ScreenHDRFormat& hdrFormat) override; 69 DMError SetScreenHDRFormat(ScreenId screenId, int32_t modeIdx) override; 70 DMError GetSupportedColorSpaces(ScreenId screenId, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) override; 71 DMError GetScreenColorSpace(ScreenId screenId, GraphicCM_ColorSpaceType& colorSpace) override; 72 DMError SetScreenColorSpace(ScreenId screenId, GraphicCM_ColorSpaceType colorSpace) override; 73 74 void DumpAllScreensInfo(std::string& dumpInfo) override; 75 void DumpSpecialScreenInfo(ScreenId id, std::string& dumpInfo) override; 76 77 virtual DMError RegisterDisplayManagerAgent(const sptr<IDisplayManagerAgent>& displayManagerAgent, 78 DisplayManagerAgentType type) override; 79 virtual DMError UnregisterDisplayManagerAgent(const sptr<IDisplayManagerAgent>& displayManagerAgent, 80 DisplayManagerAgentType type) override; 81 82 bool WakeUpBegin(PowerStateChangeReason reason) override; 83 bool WakeUpEnd() override; 84 bool SuspendBegin(PowerStateChangeReason reason) override; 85 bool SuspendEnd() override; 86 bool SetDisplayState(DisplayState state) override; 87 DisplayState GetDisplayState(DisplayId displayId) override; 88 bool SetScreenBrightness(uint64_t screenId, uint32_t level) override; 89 uint32_t GetScreenBrightness(uint64_t screenId) override; 90 bool SetSpecifiedScreenPower(ScreenId screenId, ScreenPowerState state, PowerStateChangeReason reason) override; 91 bool SetScreenPowerForAll(ScreenPowerState state, PowerStateChangeReason reason) override; 92 ScreenPowerState GetScreenPower(ScreenId screenId) override; 93 void NotifyDisplayEvent(DisplayEvent event) override; 94 void HandlerSensor(ScreenPowerStatus status, PowerStateChangeReason reason); 95 bool TryToCancelScreenOff() override; 96 void ForceSkipScreenOffAnimation(); 97 ScreenPowerState GetScreenPower() override; 98 99 void RegisterDisplayChangeListener(sptr<IDisplayChangeListener> listener); 100 bool NotifyDisplayPowerEvent(DisplayPowerEvent event, EventStatus status, PowerStateChangeReason reason); 101 bool NotifyDisplayStateChanged(DisplayId id, DisplayState state); 102 void NotifyScreenshot(DisplayId displayId); 103 virtual ScreenId CreateVirtualScreen(VirtualScreenOption option, 104 const sptr<IRemoteObject>& displayManagerAgent) override; 105 virtual DMError SetVirtualScreenSurface(ScreenId screenId, sptr<IBufferProducer> surface) override; 106 virtual DMError SetVirtualMirrorScreenCanvasRotation(ScreenId screenId, bool autoRotate) override; 107 virtual DMError SetVirtualMirrorScreenScaleMode(ScreenId screenId, ScreenScaleMode scaleMode) override; 108 virtual DMError DestroyVirtualScreen(ScreenId screenId) override; 109 DMError ResizeVirtualScreen(ScreenId screenId, uint32_t width, uint32_t height) override; 110 virtual DMError MakeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenIds, 111 ScreenId& screenGroupId) override; 112 virtual DMError MakeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenIds, 113 DMRect mainScreenRegion, ScreenId& screenGroupId) override; 114 virtual DMError StopMirror(const std::vector<ScreenId>& mirrorScreenIds) override; 115 DMError DisableMirror(bool disableOrNot) override; 116 virtual DMError MakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint, 117 ScreenId& screenGroupId) override; 118 virtual DMError StopExpand(const std::vector<ScreenId>& expandScreenIds) override; 119 DMError MakeUniqueScreen(const std::vector<ScreenId>& screenIds) override; 120 virtual sptr<ScreenGroupInfo> GetScreenGroupInfoById(ScreenId screenId) override; 121 virtual void RemoveVirtualScreenFromGroup(std::vector<ScreenId> screens) override; 122 virtual std::shared_ptr<Media::PixelMap> GetDisplaySnapshot(DisplayId displayId, 123 DmErrorCode* errorCode, bool isUseDma) override; 124 virtual std::shared_ptr<Media::PixelMap> GetSnapshotByPicker(Media::Rect &rect, DmErrorCode* errorCode) override; 125 virtual sptr<DisplayInfo> GetDisplayInfoById(DisplayId displayId) override; 126 sptr<DisplayInfo> GetDisplayInfoByScreen(ScreenId screenId) override; 127 std::vector<DisplayId> GetAllDisplayIds() override; 128 virtual sptr<ScreenInfo> GetScreenInfoById(ScreenId screenId) override; 129 virtual DMError GetAllScreenInfos(std::vector<sptr<ScreenInfo>>& screenInfos) override; 130 virtual DMError GetScreenSupportedColorGamuts(ScreenId screenId, 131 std::vector<ScreenColorGamut>& colorGamuts) override; 132 DMError IsScreenRotationLocked(bool& isLocked) override; 133 DMError SetScreenRotationLocked(bool isLocked) override; 134 DMError SetScreenRotationLockedFromJs(bool isLocked) override; 135 DMError SetOrientation(ScreenId screenId, Orientation orientation) override; 136 bool SetRotation(ScreenId screenId, Rotation rotationAfter, bool isFromWindow); 137 void SetSensorSubscriptionEnabled(); 138 bool SetRotationFromWindow(Rotation targetRotation); 139 sptr<SupportedScreenModes> GetScreenModesByDisplayId(DisplayId displayId); 140 sptr<ScreenInfo> GetScreenInfoByDisplayId(DisplayId displayId); 141 void NotifyDisplayCreate(sptr<DisplayInfo> displayInfo); 142 void NotifyDisplayDestroy(DisplayId displayId); 143 void NotifyAndPublishEvent(sptr<DisplayInfo> displayInfo, ScreenId screenId, sptr<ScreenSession> screenSession); 144 void NotifyDisplayChanged(sptr<DisplayInfo> displayInfo, DisplayChangeEvent event); 145 146 std::vector<ScreenId> GetAllScreenIds() const; 147 const std::shared_ptr<RSDisplayNode> GetRSDisplayNodeByScreenId(ScreenId smsScreenId) const; 148 std::shared_ptr<Media::PixelMap> GetScreenSnapshot(DisplayId displayId, bool isUseDma = false); 149 150 sptr<ScreenSession> InitVirtualScreen(ScreenId smsScreenId, ScreenId rsId, VirtualScreenOption option); 151 sptr<ScreenSession> InitAndGetScreen(ScreenId rsScreenId); 152 bool InitAbstractScreenModesInfo(sptr<ScreenSession>& absScreen); 153 std::vector<ScreenId> GetAllValidScreenIds(const std::vector<ScreenId>& screenIds) const; 154 155 sptr<ScreenSessionGroup> AddToGroupLocked(sptr<ScreenSession> newScreen, bool isUnique = false); 156 sptr<ScreenSessionGroup> AddAsFirstScreenLocked(sptr<ScreenSession> newScreen, bool isUnique = false); 157 sptr<ScreenSessionGroup> AddAsSuccedentScreenLocked(sptr<ScreenSession> newScreen); 158 sptr<ScreenSessionGroup> RemoveFromGroupLocked(sptr<ScreenSession> screen); 159 sptr<ScreenSessionGroup> GetAbstractScreenGroup(ScreenId smsScreenId); 160 161 bool HandleFoldScreenSessionCreate(ScreenId screenId); 162 163 void ChangeScreenGroup(sptr<ScreenSessionGroup> group, const std::vector<ScreenId>& screens, 164 const std::vector<Point>& startPoints, bool filterScreen, ScreenCombination combination, 165 DMRect mainScreenRegion = DMRect::NONE()); 166 167 bool RemoveChildFromGroup(sptr<ScreenSession> screen, sptr<ScreenSessionGroup> screenGroup); 168 169 void AddScreenToGroup(sptr<ScreenSessionGroup> group, 170 const std::vector<ScreenId>& addScreens, const std::vector<Point>& addChildPos, 171 std::map<ScreenId, bool>& removeChildResMap); 172 bool CheckScreenInScreenGroup(sptr<ScreenSession> screen) const; 173 174 DMError SetMirror(ScreenId screenId, std::vector<ScreenId> screens, DMRect mainScreenRegion); 175 DMError StopScreens(const std::vector<ScreenId>& screenIds, ScreenCombination stopCombination); 176 177 void NotifyScreenConnected(sptr<ScreenInfo> screenInfo); 178 void NotifyScreenDisconnected(ScreenId screenId); 179 void NotifyScreenGroupChanged(const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent event); 180 void NotifyScreenGroupChanged(const std::vector<sptr<ScreenInfo>>& screenInfo, ScreenGroupChangeEvent event); 181 182 void NotifyPrivateSessionStateChanged(bool hasPrivate); 183 void NotifyPrivateWindowListChanged(DisplayId id, std::vector<std::string> privacyWindowList); 184 DMError HasPrivateWindow(DisplayId id, bool& hasPrivateWindow) override; 185 bool ConvertScreenIdToRsScreenId(ScreenId screenId, ScreenId& rsScreenId) override; 186 void UpdateDisplayHookInfo(int32_t uid, bool enable, const DMHookInfo& hookInfo) override; 187 188 void OnScreenConnect(const sptr<ScreenInfo> screenInfo); 189 void OnScreenDisconnect(ScreenId screenId); 190 void OnScreenGroupChange(const std::string& trigger, 191 const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent groupEvent); 192 void OnScreenGroupChange(const std::string& trigger, 193 const std::vector<sptr<ScreenInfo>>& screenInfos, ScreenGroupChangeEvent groupEvent); 194 void OnScreenshot(sptr<ScreenshotInfo> info); 195 bool IsMultiScreenCollaboration(); 196 sptr<CutoutInfo> GetCutoutInfo(DisplayId displayId) override; 197 DMError HasImmersiveWindow(bool& immersive) override; 198 void SetDisplayBoundary(const sptr<ScreenSession> screenSession); 199 200 void BlockScreenOnByCV(void); 201 void BlockScreenOffByCV(void); 202 bool BlockSetDisplayState(void); 203 bool IsScreenLockSuspend(void); 204 bool IsPreBrightAuthFail(void); 205 void ScreenOffCVNotify(void); 206 void DisablePowerOffRenderControl(ScreenId screenId) override; 207 208 // Fold Screen 209 void SetFoldDisplayMode(const FoldDisplayMode displayMode) override; 210 DMError SetFoldDisplayModeInner(const FoldDisplayMode displayMode, std::string reason = ""); 211 DMError SetFoldDisplayModeFromJs(const FoldDisplayMode displayMode, std::string reason = "") override; 212 void SetDisplayNodeScreenId(ScreenId screenId, ScreenId displayNodeScreenId); 213 214 void SetDisplayScale(ScreenId screenId, float scaleX, float scaleY, 215 float pivotX, float pivotY) override; 216 217 void SetFoldStatusLocked(bool locked) override; 218 DMError SetFoldStatusLockedFromJs(bool locked) override; 219 220 FoldDisplayMode GetFoldDisplayMode() override; 221 222 bool IsFoldable() override; 223 bool IsCaptured() override; 224 225 FoldStatus GetFoldStatus() override; 226 bool GetTentMode(); 227 228 bool SetScreenPower(ScreenPowerStatus status, PowerStateChangeReason reason); 229 void SetScreenPowerForFold(ScreenPowerStatus status); 230 void SetScreenPowerForFold(ScreenId screenId, ScreenPowerStatus status); 231 void TriggerDisplayModeUpdate(FoldDisplayMode targetDisplayMode); 232 void CallRsSetScreenPowerStatusSync(ScreenId screenId, ScreenPowerStatus status); 233 void CallRsSetScreenPowerStatusSyncForFold(ScreenPowerStatus status); 234 void TryToRecoverFoldDisplayMode(ScreenPowerStatus status); 235 236 void SetKeyguardDrawnDoneFlag(bool flag); 237 238 sptr<FoldCreaseRegion> GetCurrentFoldCreaseRegion() override; 239 240 void TriggerFoldStatusChange(FoldStatus foldStatus); 241 void NotifyFoldStatusChanged(FoldStatus foldStatus); 242 void NotifyFoldAngleChanged(std::vector<float> foldAngles); 243 int NotifyFoldStatusChanged(const std::string& statusParam); 244 void NotifyDisplayModeChanged(FoldDisplayMode displayMode); 245 void NotifyDisplayChangeInfoChanged(const sptr<DisplayChangeInfo>& info) override; 246 void OnTentModeChanged(bool isTentMode, int32_t hall = -1); 247 void RegisterSettingDpiObserver(); 248 void RegisterSettingRotationObserver(); 249 void RegisterSettingscreenSkipProtectedWindowObserver(); 250 OnConnect(ScreenId screenId)251 void OnConnect(ScreenId screenId) override {} OnDisconnect(ScreenId screenId)252 void OnDisconnect(ScreenId screenId) override {} 253 void OnPropertyChange(const ScreenProperty& newProperty, ScreenPropertyChangeReason reason, 254 ScreenId screenId) override; 255 void OnPowerStatusChange(DisplayPowerEvent event, EventStatus status, 256 PowerStateChangeReason reason) override; 257 void OnSensorRotationChange(float sensorRotation, ScreenId screenId) override; 258 void OnHoverStatusChange(int32_t hoverStatus, bool needRotate, ScreenId screenId) override; 259 void OnScreenOrientationChange(float screenOrientation, ScreenId screenId) override; 260 void OnScreenRotationLockedChange(bool isLocked, ScreenId screenId) override; 261 void OnCameraBackSelfieChange(bool isCameraBackSelfie, ScreenId screenId) override; 262 263 void SetHdrFormats(ScreenId screenId, sptr<ScreenSession>& session); 264 void SetColorSpaces(ScreenId screenId, sptr<ScreenSession>& session); 265 void SetClient(const sptr<IScreenSessionManagerClient>& client) override; 266 ScreenProperty GetScreenProperty(ScreenId screenId) override; 267 std::shared_ptr<RSDisplayNode> GetDisplayNode(ScreenId screenId) override; 268 void UpdateScreenRotationProperty(ScreenId screenId, const RRect& bounds, float rotation, 269 ScreenPropertyChangeType screenPropertyChangeType) override; 270 void UpdateScreenDirectionInfo(ScreenId screenId, float screenComponentRotation, float rotation, 271 float phyRotation, ScreenPropertyChangeType screenPropertyChangeType) override; 272 uint32_t GetCurvedCompressionArea() override; 273 ScreenProperty GetPhyScreenProperty(ScreenId screenId) override; 274 void SetScreenPrivacyState(bool hasPrivate) override; 275 void SetPrivacyStateByDisplayId(DisplayId id, bool hasPrivate) override; 276 void SetScreenPrivacyWindowList(DisplayId id, std::vector<std::string> privacyWindowList) override; 277 void UpdateAvailableArea(ScreenId screenId, DMRect area) override; 278 int32_t SetScreenOffDelayTime(int32_t delay) override; 279 DMError GetAvailableArea(DisplayId displayId, DMRect& area) override; 280 void NotifyAvailableAreaChanged(DMRect area); 281 void NotifyFoldToExpandCompletion(bool foldToExpand) override; 282 void RecordEventFromScb(std::string description, bool needRecordEvent) override; 283 void SetCameraStatus(int32_t cameraStatus, int32_t cameraPosition) override; 284 bool GetSnapshotArea(Media::Rect &rect, DmErrorCode* errorCode, ScreenId &screenId); 285 int32_t GetCameraStatus(); 286 int32_t GetCameraPosition(); IsCameraBackSelfie()287 bool IsCameraBackSelfie() { return isCameraBackSelfie_; }; 288 void UpdateCameraBackSelfie(bool isCameraBackSelfie); 289 void SetScreenCorrection(); 290 291 VirtualScreenFlag GetVirtualScreenFlag(ScreenId screenId) override; 292 DMError SetVirtualScreenFlag(ScreenId screenId, VirtualScreenFlag screenFlag) override; 293 DMError SetVirtualScreenRefreshRate(ScreenId screenId, uint32_t refreshInterval) override; 294 295 DeviceScreenConfig GetDeviceScreenConfig() override; 296 297 // notify scb virtual screen change 298 void OnVirtualScreenChange(ScreenId screenId, ScreenEvent screenEvent); 299 DMError VirtualScreenUniqueSwitch(const std::vector<ScreenId>& screenIds); 300 void FixPowerStatus(); 301 void FoldScreenPowerInit(); 302 DMError ProxyForFreeze(const std::set<int32_t>& pidList, bool isProxy) override; 303 DMError ResetAllFreezeStatus() override; 304 305 void SetVirtualScreenBlackList(ScreenId screenId, std::vector<uint64_t>& windowIdList, 306 std::vector<uint64_t> surfaceIdList = {}) override; 307 308 void ReportFoldStatusToScb(std::vector<std::string>& screenFoldInfo); 309 std::vector<DisplayPhysicalResolution> GetAllDisplayPhysicalResolution() override; 310 void OnSecondaryReflexionChange(ScreenId screenId, bool isSecondaryReflexion) override; 311 std::string GetDisplayCapability() override; 312 nlohmann::ordered_json GetCapabilityJson(FoldStatus foldStatus, FoldDisplayMode displayMode, 313 std::vector<std::string> rotation, std::vector<std::string> orientation); 314 std::string GetSecondaryDisplayCapability(); 315 std::string GetFoldableDeviceCapability(); 316 std::string GetSuperFoldCapability(); 317 318 void NotifyCastWhenScreenConnectChange(bool isConnected); 319 void SwitchScrollParam(FoldDisplayMode displayMode); 320 void OnScreenChange(ScreenId screenId, ScreenEvent screenEvent); 321 void SetCoordinationFlag(bool isCoordinationFlag); 322 DMError SetVirtualScreenMaxRefreshRate(ScreenId id, uint32_t refreshRate, 323 uint32_t& actualRefreshRate) override; 324 325 /* 326 * multi user 327 */ 328 void SwitchUser() override; 329 void SwitchScbNodeHandle(int32_t userId, int32_t newScbPid, bool coldBoot); 330 void AddScbClientDeathRecipient(const sptr<IScreenSessionManagerClient>& scbClient, int32_t scbPid); 331 void ScbClientDeathCallback(int32_t deathScbPid); 332 void ScbStatusRecoveryWhenSwitchUser(std::vector<int32_t> oldScbPids, int32_t newScbPid); 333 int32_t GetCurrentUserId(); 334 335 std::shared_ptr<Media::PixelMap> GetScreenCapture(const CaptureOption& captureOption, 336 DmErrorCode* errorCode = nullptr) override; 337 void OnScreenCaptureNotify(ScreenId mainScreenId, int32_t uid, const std::string& clientName) override; 338 sptr<DisplayInfo> GetPrimaryDisplayInfo() override; 339 std::shared_ptr<Media::PixelMap> GetDisplaySnapshotWithOption(const CaptureOption& captureOption, 340 DmErrorCode* errorCode) override; 341 ScreenCombination GetScreenCombination(ScreenId screenId) override; 342 DMError SetScreenSkipProtectedWindow(const std::vector<ScreenId>& screenIds, bool isEnable) override; 343 344 protected: 345 ScreenSessionManager(); 346 virtual ~ScreenSessionManager() = default; 347 348 private: 349 void OnStart() override; 350 void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override; 351 void Init(); 352 void LoadScreenSceneXml(); 353 void ConfigureScreenScene(); 354 void ConfigureDpi(); 355 void ConfigureCastParams(); 356 void ConfigureWaterfallDisplayCompressionParams(); 357 void ConfigureScreenSnapshotParams(); 358 void RegisterScreenChangeListener(); 359 void RegisterRefreshRateChangeListener(); 360 void OnHgmRefreshRateChange(uint32_t refreshRate); 361 sptr<ScreenSession> GetOrCreateScreenSession(ScreenId screenId); 362 void CreateScreenProperty(ScreenId screenId, ScreenProperty& property); 363 sptr<ScreenSession> GetScreenSessionInner(ScreenId screenId, ScreenProperty property); 364 sptr<ScreenSession> CreatePhysicalMirrorSessionInner(ScreenId screenId, ScreenId defaultScreenId, 365 ScreenProperty property); 366 sptr<ScreenSession> GetPhysicalScreenSession(ScreenId screenId, ScreenId defScreenId, ScreenProperty property); 367 void FreeDisplayMirrorNodeInner(const sptr<ScreenSession> mirrorSession); 368 void MirrorSwitchNotify(ScreenId screenId); 369 ScreenId GetDefaultScreenId(); 370 void AddVirtualScreenDeathRecipient(const sptr<IRemoteObject>& displayManagerAgent, ScreenId smsScreenId); 371 void SendCastEvent(const bool &isPlugIn); 372 void PhyMirrorConnectWakeupScreen(); 373 void HandleScreenEvent(sptr<ScreenSession> screenSession, ScreenId screenId, ScreenEvent screenEvent); 374 void HandleScreenDisconnectEvent(sptr<ScreenSession> screenSession, ScreenId screenId, ScreenEvent screenEvent); 375 ScreenRotation ConvertOffsetToCorrectRotation(int32_t phyOffset); 376 void SetClientInner(); 377 void GetCurrentScreenPhyBounds(float& phyWidth, float& phyHeight, bool& isReset, const ScreenId& screenid); 378 379 void NotifyDisplayStateChange(DisplayId defaultDisplayId, sptr<DisplayInfo> displayInfo, 380 const std::map<DisplayId, sptr<DisplayInfo>>& displayInfoMap, DisplayStateChangeType type); 381 void NotifyCaptureStatusChanged(); 382 DMError DoMakeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenIds, 383 DMRect mainScreenRegion, ScreenId& screenGroupId); 384 bool OnMakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint); 385 bool OnRemoteDied(const sptr<IRemoteObject>& agent); 386 std::string TransferTypeToString(ScreenType type) const; 387 std::string TransferPropertyChangeTypeToString(ScreenPropertyChangeType type) const; 388 void CheckAndSendHiSysEvent(const std::string& eventName, const std::string& bundleName) const; 389 bool GetPowerStatus(ScreenPowerState state, PowerStateChangeReason reason, ScreenPowerStatus& status); 390 391 int Dump(int fd, const std::vector<std::u16string>& args) override; 392 sptr<DisplayInfo> HookDisplayInfoByUid(sptr<DisplayInfo> displayInfo, const sptr<ScreenSession>& screenSession); 393 DMError SetVirtualScreenSecurityExemption(ScreenId screenId, uint32_t pid, 394 std::vector<uint64_t>& windowIdList) override; 395 void AddPermissionUsedRecord(const std::string& permission, int32_t successCount, int32_t failCount); 396 std::shared_ptr<RSDisplayNode> GetDisplayNodeByDisplayId(DisplayId displayId); 397 void RefreshMirrorScreenRegion(ScreenId screenId); 398 #ifdef DEVICE_STATUS_ENABLE 399 void SetDragWindowScreenId(ScreenId screenId, ScreenId displayNodeScreenId); 400 #endif // DEVICE_STATUS_ENABLE 401 bool IsFreezed(const int32_t& agentPid, const DisplayManagerAgentType& agentType); 402 void NotifyUnfreezed(const std::set<int32_t>& unfreezedPidList, const sptr<ScreenSession>& screenSession); 403 void NotifyUnfreezedAgents(const int32_t& pid, const std::set<int32_t>& unfreezedPidList, 404 const std::set<DisplayManagerAgentType>& pidAgentTypes, const sptr<ScreenSession>& screenSession); 405 int NotifyPowerEventForDualDisplay(DisplayPowerEvent event, EventStatus status, 406 PowerStateChangeReason reason); 407 bool IsScreenCasting(); 408 void SetScreenSkipProtectedWindowInner(); 409 class ScreenIdManager { 410 friend class ScreenSessionGroup; 411 public: 412 ScreenIdManager() = default; 413 ~ScreenIdManager() = default; 414 WM_DISALLOW_COPY_AND_MOVE(ScreenIdManager); 415 ScreenId CreateAndGetNewScreenId(ScreenId rsScreenId); 416 void UpdateScreenId(ScreenId rsScreenId, ScreenId smsScreenId); 417 bool DeleteScreenId(ScreenId smsScreenId); 418 bool HasRsScreenId(ScreenId smsScreenId) const; 419 bool ConvertToRsScreenId(ScreenId, ScreenId&) const; 420 ScreenId ConvertToRsScreenId(ScreenId) const; 421 bool ConvertToSmsScreenId(ScreenId, ScreenId&) const; 422 ScreenId ConvertToSmsScreenId(ScreenId) const; 423 424 private: 425 std::atomic<ScreenId> smsScreenCount_ { 1000 }; 426 std::map<ScreenId, ScreenId> rs2SmsScreenIdMap_; 427 std::map<ScreenId, ScreenId> sms2RsScreenIdMap_; 428 mutable std::shared_mutex screenIdMapMutex_; 429 }; 430 431 EventTracker screenEventTracker_; 432 RSInterfaces& rsInterface_; 433 std::shared_ptr<TaskScheduler> taskScheduler_; 434 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler_; 435 436 /* 437 * multi user 438 */ 439 std::mutex oldScbPidsMutex_; 440 std::condition_variable scbSwitchCV_; 441 int32_t currentUserId_ { 0 }; 442 int32_t currentScbPId_ { -1 }; 443 std::vector<int32_t> oldScbPids_ {}; 444 std::map<int32_t, sptr<IScreenSessionManagerClient>> clientProxyMap_; 445 FoldDisplayMode oldScbDisplayMode_ = FoldDisplayMode::UNKNOWN; 446 447 sptr<IScreenSessionManagerClient> clientProxy_; 448 ClientAgentContainer<IDisplayManagerAgent, DisplayManagerAgentType> dmAgentContainer_; 449 DeviceScreenConfig deviceScreenConfig_; 450 std::vector<DisplayPhysicalResolution> allDisplayPhysicalResolution_ {}; 451 std::map<int32_t, std::set<DisplayManagerAgentType>> pidAgentTypeMap_; 452 std::vector<float> lastFoldAngles_ {}; 453 sptr<DisplayChangeInfo> lastDisplayChangeInfo_; 454 ScreenChangeEvent lastScreenChangeEvent_ = ScreenChangeEvent::UNKNOWN; 455 std::mutex lastStatusUpdateMutex_; 456 457 mutable std::recursive_mutex screenSessionMapMutex_; 458 std::map<ScreenId, sptr<ScreenSession>> screenSessionMap_; 459 std::recursive_mutex mutex_; 460 std::recursive_mutex displayInfoMutex_; 461 std::shared_mutex hookInfoMutex_; 462 std::mutex shareProtectMutex_; 463 464 ScreenId defaultScreenId_ = SCREEN_ID_INVALID; 465 ScreenIdManager screenIdManager_; 466 467 std::atomic<ScreenId> defaultRsScreenId_ { SCREEN_ID_INVALID }; 468 std::map<sptr<IRemoteObject>, std::vector<ScreenId>> screenAgentMap_; 469 std::map<ScreenId, sptr<ScreenSessionGroup>> smsScreenGroupMap_; 470 std::map<uint32_t, DMHookInfo> displayHookMap_; 471 472 bool isAutoRotationOpen_ = false; 473 bool isExpandCombination_ = false; 474 bool isScreenShot_ = false; 475 bool isCoordinationFlag_ = false; 476 bool isFoldScreenOuterScreenReady_ = false; 477 bool isCameraBackSelfie_ = false; 478 uint32_t hdmiScreenCount_ = 0; 479 uint32_t virtualScreenCount_ = 0; 480 sptr<AgentDeathRecipient> deathRecipient_ { nullptr }; 481 482 sptr<SessionDisplayPowerController> sessionDisplayPowerController_; 483 sptr<ScreenCutoutController> screenCutoutController_; 484 sptr<FoldScreenController> foldScreenController_; 485 486 bool isDensityDpiLoad_ = false; 487 float densityDpi_ { 1.0f }; 488 float subDensityDpi_ { 1.0f }; 489 std::atomic<uint32_t> cachedSettingDpi_ {0}; 490 491 uint32_t defaultDpi {0}; 492 uint32_t defaultDeviceRotationOffset_ { 0 }; 493 494 bool isMultiScreenCollaboration_ = false; 495 bool screenPrivacyStates = false; 496 bool keyguardDrawnDone_ = true; 497 bool needScreenOnWhenKeyguardNotify_ = false; 498 bool gotScreenOffNotify_ = false; 499 bool needScreenOffNotify_ = false; 500 501 std::mutex scbBufferAvailableMutex_; 502 std::condition_variable scbBufferAvailableCV_; 503 void BlockScbByAvailabelBuffer(void); 504 505 std::mutex screenOnMutex_; 506 std::condition_variable screenOnCV_; 507 std::mutex screenOffMutex_; 508 std::condition_variable screenOffCV_; 509 int32_t screenOffDelay_ {0}; 510 std::vector<ScreenId> mirrorScreenIds_; 511 std::mutex snapBypickerMutex_; 512 513 std::mutex freezedPidListMutex_; 514 std::set<int32_t> freezedPidList_; 515 516 std::atomic<PowerStateChangeReason> prePowerStateChangeReason_ = 517 PowerStateChangeReason::STATE_CHANGE_REASON_UNKNOWN; 518 std::atomic<PowerStateChangeReason> lastWakeUpReason_ = PowerStateChangeReason::STATE_CHANGE_REASON_INIT; 519 std::atomic<PowerStateChangeReason> currentWakeUpReason_ = PowerStateChangeReason::STATE_CHANGE_REASON_INIT; 520 std::atomic<bool> isScreenLockSuspend_ = false; 521 std::atomic<bool> gotScreenlockFingerprint_ = false; 522 std::atomic<bool> isPhyScreenConnected_ = false; 523 int32_t cameraStatus_ = {0}; 524 int32_t cameraPosition_ = {0}; 525 526 // Fold Screen 527 std::map<ScreenId, ScreenProperty> phyScreenPropMap_; 528 mutable std::recursive_mutex phyScreenPropMapMutex_; 529 static void BootFinishedCallback(const char *key, const char *value, void *context); 530 std::function<void()> foldScreenPowerInit_ = nullptr; 531 void HandleFoldScreenPowerInit(); 532 void SetFoldScreenPowerInit(std::function<void()> foldScreenPowerInit); 533 void SetDpiFromSettingData(); 534 void SetRotateLockedFromSettingData(); 535 void NotifyClientProxyUpdateFoldDisplayMode(FoldDisplayMode displayMode); 536 void UpdateDisplayScaleState(ScreenId screenId); 537 void SetDisplayScaleInner(ScreenId screenId, const float& scaleX, const float& scaleY, const float& pivotX, 538 const float& pivotY); 539 void CalcDisplayNodeTranslateOnFoldableRotation(sptr<ScreenSession>& session, const float& scaleX, 540 const float& scaleY, const float& pivotX, const float& pivotY, 541 float& translateX, float& translateY); 542 void CalcDisplayNodeTranslateOnPocketFoldRotation(sptr<ScreenSession>& session, const float& scaleX, 543 const float& scaleY, const float& pivotX, const float& pivotY, 544 float& translateX, float& translateY); 545 void CalcDisplayNodeTranslateOnRotation(sptr<ScreenSession>& session, const float& scaleX, const float& scaleY, 546 const float& pivotX, const float& pivotY, float& translateX, 547 float& translateY); 548 void RegisterApplicationStateObserver(); 549 void SetPostureAndHallSensorEnabled(); 550 bool IsDefaultMirrorMode(ScreenId screenId); 551 void SetCastFromSettingData(); 552 void RegisterCastObserver(std::vector<ScreenId>& mirrorScreenIds); 553 void UnRegisterCastObserver(std::vector<ScreenId>& mirrorScreenIds); 554 void ExitCoordination(const std::string& reason); 555 void UpdateDisplayState(std::vector<ScreenId> screenIds, DisplayState state); 556 void CallRsSetScreenPowerStatusSyncForExtend(const std::vector<ScreenId>& screenIds, ScreenPowerStatus status); 557 DisplayState lastDisplayState_ { DisplayState::UNKNOWN }; 558 559 private: 560 class ScbClientListenerDeathRecipient : public IRemoteObject::DeathRecipient { 561 public: ScbClientListenerDeathRecipient(int32_t scbPid)562 explicit ScbClientListenerDeathRecipient(int32_t scbPid) 563 : scbPid_(scbPid) 564 {} 565 OnRemoteDied(const wptr<IRemoteObject> & wptrDeath)566 void OnRemoteDied(const wptr<IRemoteObject>& wptrDeath) override 567 { 568 ScreenSessionManager::GetInstance().ScbClientDeathCallback(scbPid_); 569 } 570 571 private: 572 int32_t scbPid_; 573 }; 574 }; 575 } // namespace OHOS::Rosen 576 577 #endif // OHOS_ROSEN_WINDOW_SCENE_SCREEN_SESSION_MANAGER_H 578