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 97 void RegisterDisplayChangeListener(sptr<IDisplayChangeListener> listener); 98 bool NotifyDisplayPowerEvent(DisplayPowerEvent event, EventStatus status, PowerStateChangeReason reason); 99 bool NotifyDisplayStateChanged(DisplayId id, DisplayState state); 100 void NotifyScreenshot(DisplayId displayId); 101 virtual ScreenId CreateVirtualScreen(VirtualScreenOption option, 102 const sptr<IRemoteObject>& displayManagerAgent) override; 103 virtual DMError SetVirtualScreenSurface(ScreenId screenId, sptr<IBufferProducer> surface) override; 104 virtual DMError SetVirtualMirrorScreenCanvasRotation(ScreenId screenId, bool autoRotate) override; 105 virtual DMError SetVirtualMirrorScreenScaleMode(ScreenId screenId, ScreenScaleMode scaleMode) override; 106 virtual DMError DestroyVirtualScreen(ScreenId screenId) override; 107 DMError ResizeVirtualScreen(ScreenId screenId, uint32_t width, uint32_t height) override; 108 virtual DMError MakeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenIds, 109 ScreenId& screenGroupId) override; 110 virtual DMError StopMirror(const std::vector<ScreenId>& mirrorScreenIds) override; 111 DMError DisableMirror(bool disableOrNot) override; 112 virtual DMError MakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint, 113 ScreenId& screenGroupId) override; 114 virtual DMError StopExpand(const std::vector<ScreenId>& expandScreenIds) override; 115 DMError MakeUniqueScreen(const std::vector<ScreenId>& screenIds) override; 116 virtual sptr<ScreenGroupInfo> GetScreenGroupInfoById(ScreenId screenId) override; 117 virtual void RemoveVirtualScreenFromGroup(std::vector<ScreenId> screens) override; 118 virtual std::shared_ptr<Media::PixelMap> GetDisplaySnapshot(DisplayId displayId, DmErrorCode* errorCode) override; 119 virtual std::shared_ptr<Media::PixelMap> GetSnapshotByPicker(Media::Rect &rect, DmErrorCode* errorCode) override; 120 virtual sptr<DisplayInfo> GetDisplayInfoById(DisplayId displayId) override; 121 sptr<DisplayInfo> GetDisplayInfoByScreen(ScreenId screenId) override; 122 std::vector<DisplayId> GetAllDisplayIds() override; 123 virtual sptr<ScreenInfo> GetScreenInfoById(ScreenId screenId) override; 124 virtual DMError GetAllScreenInfos(std::vector<sptr<ScreenInfo>>& screenInfos) override; 125 virtual DMError GetScreenSupportedColorGamuts(ScreenId screenId, 126 std::vector<ScreenColorGamut>& colorGamuts) override; 127 DMError IsScreenRotationLocked(bool& isLocked) override; 128 DMError SetScreenRotationLocked(bool isLocked) override; 129 DMError SetScreenRotationLockedFromJs(bool isLocked) override; 130 DMError SetOrientation(ScreenId screenId, Orientation orientation) override; 131 bool SetRotation(ScreenId screenId, Rotation rotationAfter, bool isFromWindow); 132 void SetSensorSubscriptionEnabled(); 133 bool SetRotationFromWindow(Rotation targetRotation); 134 sptr<SupportedScreenModes> GetScreenModesByDisplayId(DisplayId displayId); 135 sptr<ScreenInfo> GetScreenInfoByDisplayId(DisplayId displayId); 136 void NotifyDisplayCreate(sptr<DisplayInfo> displayInfo); 137 void NotifyDisplayDestroy(DisplayId displayId); 138 void NotifyAndPublishEvent(sptr<DisplayInfo> displayInfo, ScreenId screenId, sptr<ScreenSession> screenSession); 139 void NotifyDisplayChanged(sptr<DisplayInfo> displayInfo, DisplayChangeEvent event); 140 141 std::vector<ScreenId> GetAllScreenIds() const; 142 const std::shared_ptr<RSDisplayNode> GetRSDisplayNodeByScreenId(ScreenId smsScreenId) const; 143 std::shared_ptr<Media::PixelMap> GetScreenSnapshot(DisplayId displayId); 144 145 sptr<ScreenSession> InitVirtualScreen(ScreenId smsScreenId, ScreenId rsId, VirtualScreenOption option); 146 sptr<ScreenSession> InitAndGetScreen(ScreenId rsScreenId); 147 bool InitAbstractScreenModesInfo(sptr<ScreenSession>& absScreen); 148 std::vector<ScreenId> GetAllValidScreenIds(const std::vector<ScreenId>& screenIds) const; 149 150 sptr<ScreenSessionGroup> AddToGroupLocked(sptr<ScreenSession> newScreen, bool isUnique = false); 151 sptr<ScreenSessionGroup> AddAsFirstScreenLocked(sptr<ScreenSession> newScreen, bool isUnique = false); 152 sptr<ScreenSessionGroup> AddAsSuccedentScreenLocked(sptr<ScreenSession> newScreen); 153 sptr<ScreenSessionGroup> RemoveFromGroupLocked(sptr<ScreenSession> screen); 154 sptr<ScreenSessionGroup> GetAbstractScreenGroup(ScreenId smsScreenId); 155 156 void ChangeScreenGroup(sptr<ScreenSessionGroup> group, const std::vector<ScreenId>& screens, 157 const std::vector<Point>& startPoints, bool filterScreen, ScreenCombination combination); 158 159 bool RemoveChildFromGroup(sptr<ScreenSession> screen, sptr<ScreenSessionGroup> screenGroup); 160 161 void AddScreenToGroup(sptr<ScreenSessionGroup> group, 162 const std::vector<ScreenId>& addScreens, const std::vector<Point>& addChildPos, 163 std::map<ScreenId, bool>& removeChildResMap); 164 bool CheckScreenInScreenGroup(sptr<ScreenSession> screen) const; 165 166 DMError SetMirror(ScreenId screenId, std::vector<ScreenId> screens); 167 DMError StopScreens(const std::vector<ScreenId>& screenIds, ScreenCombination stopCombination); 168 169 void NotifyScreenConnected(sptr<ScreenInfo> screenInfo); 170 void NotifyScreenDisconnected(ScreenId screenId); 171 void NotifyScreenGroupChanged(const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent event); 172 void NotifyScreenGroupChanged(const std::vector<sptr<ScreenInfo>>& screenInfo, ScreenGroupChangeEvent event); 173 174 void NotifyPrivateSessionStateChanged(bool hasPrivate); 175 void NotifyPrivateWindowListChanged(DisplayId id, std::vector<std::string> privacyWindowList); 176 DMError HasPrivateWindow(DisplayId id, bool& hasPrivateWindow) override; 177 bool ConvertScreenIdToRsScreenId(ScreenId screenId, ScreenId& rsScreenId) override; 178 void UpdateDisplayHookInfo(int32_t uid, bool enable, const DMHookInfo& hookInfo) override; 179 180 void OnScreenConnect(const sptr<ScreenInfo> screenInfo); 181 void OnScreenDisconnect(ScreenId screenId); 182 void OnScreenGroupChange(const std::string& trigger, 183 const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent groupEvent); 184 void OnScreenGroupChange(const std::string& trigger, 185 const std::vector<sptr<ScreenInfo>>& screenInfos, ScreenGroupChangeEvent groupEvent); 186 void OnScreenshot(sptr<ScreenshotInfo> info); 187 bool IsMultiScreenCollaboration(); 188 sptr<CutoutInfo> GetCutoutInfo(DisplayId displayId) override; 189 DMError HasImmersiveWindow(bool& immersive) override; 190 void SetDisplayBoundary(const sptr<ScreenSession> screenSession); 191 192 void BlockScreenOnByCV(void); 193 void BlockScreenOffByCV(void); 194 bool BlockSetDisplayState(void); 195 bool IsScreenLockSuspend(void); 196 bool IsPreBrightAuthFail(void); 197 void ScreenOffCVNotify(void); 198 void DisablePowerOffRenderControl(ScreenId screenId) override; 199 200 // Fold Screen 201 void SetFoldDisplayMode(const FoldDisplayMode displayMode) override; 202 DMError SetFoldDisplayModeFromJs(const FoldDisplayMode displayMode) override; 203 void SetDisplayNodeScreenId(ScreenId screenId, ScreenId displayNodeScreenId); 204 205 void SetDisplayScale(ScreenId screenId, float scaleX, float scaleY, 206 float pivotX, float pivotY) override; 207 208 void SetFoldStatusLocked(bool locked) override; 209 DMError SetFoldStatusLockedFromJs(bool locked) override; 210 211 FoldDisplayMode GetFoldDisplayMode() override; 212 213 bool IsFoldable() override; 214 bool IsCaptured() override; 215 216 FoldStatus GetFoldStatus() override; 217 218 bool SetScreenPower(ScreenPowerStatus status, PowerStateChangeReason reason); 219 void SetScreenPowerForFold(ScreenPowerStatus status); 220 void SetScreenPowerForFold(ScreenId screenId, ScreenPowerStatus status); 221 void TriggerDisplayModeUpdate(FoldDisplayMode targetDisplayMode); 222 void CallRsSetScreenPowerStatusSync(ScreenId screenId, ScreenPowerStatus status); 223 void CallRsSetScreenPowerStatusSyncForFold(ScreenPowerStatus status); 224 void TryToRecoverFoldDisplayMode(ScreenPowerStatus status); 225 226 void SetKeyguardDrawnDoneFlag(bool flag); 227 228 sptr<FoldCreaseRegion> GetCurrentFoldCreaseRegion() override; 229 230 void NotifyFoldStatusChanged(FoldStatus foldStatus); 231 void NotifyFoldAngleChanged(std::vector<float> foldAngles); 232 int NotifyFoldStatusChanged(const std::string& statusParam); 233 void NotifyDisplayModeChanged(FoldDisplayMode displayMode); 234 void NotifyDisplayChangeInfoChanged(const sptr<DisplayChangeInfo>& info) override; 235 void RegisterSettingDpiObserver(); 236 void RegisterSettingRotationObserver(); 237 OnConnect(ScreenId screenId)238 void OnConnect(ScreenId screenId) override {} OnDisconnect(ScreenId screenId)239 void OnDisconnect(ScreenId screenId) override {} 240 void OnPropertyChange(const ScreenProperty& newProperty, ScreenPropertyChangeReason reason, 241 ScreenId screenId) override; 242 void OnPowerStatusChange(DisplayPowerEvent event, EventStatus status, 243 PowerStateChangeReason reason) override; 244 void OnSensorRotationChange(float sensorRotation, ScreenId screenId) override; 245 void OnScreenOrientationChange(float screenOrientation, ScreenId screenId) override; 246 void OnScreenRotationLockedChange(bool isLocked, ScreenId screenId) override; 247 248 void SetHdrFormats(ScreenId screenId, sptr<ScreenSession>& session); 249 void SetColorSpaces(ScreenId screenId, sptr<ScreenSession>& session); 250 void SetClient(const sptr<IScreenSessionManagerClient>& client) override; 251 ScreenProperty GetScreenProperty(ScreenId screenId) override; 252 std::shared_ptr<RSDisplayNode> GetDisplayNode(ScreenId screenId) override; 253 void UpdateScreenRotationProperty(ScreenId screenId, const RRect& bounds, float rotation, 254 ScreenPropertyChangeType screenPropertyChangeType) override; 255 uint32_t GetCurvedCompressionArea() override; 256 ScreenProperty GetPhyScreenProperty(ScreenId screenId) override; 257 void SetScreenPrivacyState(bool hasPrivate) override; 258 void SetPrivacyStateByDisplayId(DisplayId id, bool hasPrivate) override; 259 void SetScreenPrivacyWindowList(DisplayId id, std::vector<std::string> privacyWindowList) override; 260 void UpdateAvailableArea(ScreenId screenId, DMRect area) override; 261 int32_t SetScreenOffDelayTime(int32_t delay) override; 262 DMError GetAvailableArea(DisplayId displayId, DMRect& area) override; 263 void NotifyAvailableAreaChanged(DMRect area); 264 void NotifyFoldToExpandCompletion(bool foldToExpand) override; 265 bool GetSnapshotArea(Media::Rect &rect, DmErrorCode* errorCode, ScreenId &screenId); 266 267 VirtualScreenFlag GetVirtualScreenFlag(ScreenId screenId) override; 268 DMError SetVirtualScreenFlag(ScreenId screenId, VirtualScreenFlag screenFlag) override; 269 DMError SetVirtualScreenRefreshRate(ScreenId screenId, uint32_t refreshInterval) override; 270 271 DeviceScreenConfig GetDeviceScreenConfig() override; 272 273 // notify scb virtual screen change 274 void OnVirtualScreenChange(ScreenId screenId, ScreenEvent screenEvent); 275 DMError VirtualScreenUniqueSwitch(const std::vector<ScreenId>& screenIds); 276 void FixPowerStatus(); 277 void FoldScreenPowerInit(); 278 DMError ProxyForFreeze(const std::set<int32_t>& pidList, bool isProxy) override; 279 DMError ResetAllFreezeStatus() override; 280 281 void SetVirtualScreenBlackList(ScreenId screenId, std::vector<uint64_t>& windowIdList) override; 282 283 void ReportFoldStatusToScb(std::vector<std::string>& screenFoldInfo); 284 std::vector<DisplayPhysicalResolution> GetAllDisplayPhysicalResolution() override; 285 void NotifyCastWhenScreenConnectChange(bool isConnected); 286 287 /* 288 * multi user 289 */ 290 void SwitchUser() override; 291 void SwitchScbNodeHandle(int32_t userId, int32_t newScbPid, bool coldBoot); 292 void AddScbClientDeathRecipient(const sptr<IScreenSessionManagerClient>& scbClient, int32_t scbPid); 293 void ScbClientDeathCallback(int32_t deathScbPid); 294 void ScbStatusRecoveryWhenSwitchUser(std::vector<int32_t> oldScbPids, int32_t newScbPid); 295 296 protected: 297 ScreenSessionManager(); 298 virtual ~ScreenSessionManager() = default; 299 300 private: 301 void OnStart() override; 302 void Init(); 303 void LoadScreenSceneXml(); 304 void ConfigureScreenScene(); 305 void ConfigureDpi(); 306 void ConfigureCastParams(); 307 void ConfigureWaterfallDisplayCompressionParams(); 308 void ConfigureScreenSnapshotParams(); 309 void RegisterScreenChangeListener(); 310 void OnScreenChange(ScreenId screenId, ScreenEvent screenEvent); 311 void RegisterRefreshRateChangeListener(); 312 void OnHgmRefreshRateChange(uint32_t refreshRate); 313 sptr<ScreenSession> GetOrCreateScreenSession(ScreenId screenId); 314 void CreateScreenProperty(ScreenId screenId, ScreenProperty& property); 315 sptr<ScreenSession> GetScreenSessionInner(ScreenId screenId, ScreenProperty property); 316 sptr<ScreenSession> CreatePhysicalMirrorSessionInner(ScreenId screenId, ScreenId defaultScreenId, 317 ScreenProperty property); 318 void FreeDisplayMirrorNodeInner(const sptr<ScreenSession> mirrorSession); 319 void MirrorSwitchNotify(ScreenId screenId); 320 ScreenId GetDefaultScreenId(); 321 void AddVirtualScreenDeathRecipient(const sptr<IRemoteObject>& displayManagerAgent, ScreenId smsScreenId); 322 void SendCastEvent(const bool &isPlugIn); 323 void PhyMirrorConnectWakeupScreen(); 324 void HandleScreenEvent(sptr<ScreenSession> screenSession, ScreenId screenId, ScreenEvent screenEvent); 325 void SetClientInner(); 326 void GetCurrentScreenPhyBounds(float& phyWidth, float& phyHeight, bool& isReset, const ScreenId& screenid); 327 328 void NotifyDisplayStateChange(DisplayId defaultDisplayId, sptr<DisplayInfo> displayInfo, 329 const std::map<DisplayId, sptr<DisplayInfo>>& displayInfoMap, DisplayStateChangeType type); 330 void NotifyCaptureStatusChanged(); 331 bool OnMakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint); 332 bool OnRemoteDied(const sptr<IRemoteObject>& agent); 333 std::string TransferTypeToString(ScreenType type) const; 334 std::string TransferPropertyChangeTypeToString(ScreenPropertyChangeType type) const; 335 void CheckAndSendHiSysEvent(const std::string& eventName, const std::string& bundleName) const; 336 bool GetPowerStatus(ScreenPowerState state, PowerStateChangeReason reason, ScreenPowerStatus& status); 337 338 int Dump(int fd, const std::vector<std::u16string>& args) override; 339 sptr<DisplayInfo> HookDisplayInfoByUid(sptr<DisplayInfo> displayInfo, const sptr<ScreenSession>& screenSession); 340 DMError SetVirtualScreenSecurityExemption(ScreenId screenId, uint32_t pid, 341 std::vector<uint64_t>& windowIdList) override; 342 #ifdef DEVICE_STATUS_ENABLE 343 void SetDragWindowScreenId(ScreenId screenId, ScreenId displayNodeScreenId); 344 #endif // DEVICE_STATUS_ENABLE 345 bool IsFreezed(const int32_t& agentPid, const DisplayManagerAgentType& agentType); 346 void NotifyUnfreezed(const std::set<int32_t>& unfreezedPidList, const sptr<ScreenSession>& screenSession); 347 void NotifyUnfreezedAgents(const int32_t& pid, const std::set<int32_t>& unfreezedPidList, 348 const std::set<DisplayManagerAgentType>& pidAgentTypes, const sptr<ScreenSession>& screenSession); 349 int NotifyPowerEventForDualDisplay(DisplayPowerEvent event, EventStatus status, 350 PowerStateChangeReason reason); 351 class ScreenIdManager { 352 friend class ScreenSessionGroup; 353 public: 354 ScreenIdManager() = default; 355 ~ScreenIdManager() = default; 356 WM_DISALLOW_COPY_AND_MOVE(ScreenIdManager); 357 ScreenId CreateAndGetNewScreenId(ScreenId rsScreenId); 358 void UpdateScreenId(ScreenId rsScreenId, ScreenId smsScreenId); 359 bool DeleteScreenId(ScreenId smsScreenId); 360 bool HasRsScreenId(ScreenId smsScreenId) const; 361 bool ConvertToRsScreenId(ScreenId, ScreenId&) const; 362 ScreenId ConvertToRsScreenId(ScreenId) const; 363 bool ConvertToSmsScreenId(ScreenId, ScreenId&) const; 364 ScreenId ConvertToSmsScreenId(ScreenId) const; 365 366 private: 367 std::atomic<ScreenId> smsScreenCount_ { 1000 }; 368 std::map<ScreenId, ScreenId> rs2SmsScreenIdMap_; 369 std::map<ScreenId, ScreenId> sms2RsScreenIdMap_; 370 mutable std::shared_mutex screenIdMapMutex_; 371 }; 372 373 EventTracker screenEventTracker_; 374 RSInterfaces& rsInterface_; 375 std::shared_ptr<TaskScheduler> taskScheduler_; 376 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler_; 377 378 /* 379 * multi user 380 */ 381 std::mutex oldScbPidsMutex_; 382 std::condition_variable scbSwitchCV_; 383 int32_t currentUserId_ { 0 }; 384 int32_t currentScbPId_ { -1 }; 385 std::vector<int32_t> oldScbPids_ {}; 386 std::map<int32_t, sptr<IScreenSessionManagerClient>> clientProxyMap_; 387 FoldDisplayMode oldScbDisplayMode_ = FoldDisplayMode::UNKNOWN; 388 389 sptr<IScreenSessionManagerClient> clientProxy_; 390 ClientAgentContainer<IDisplayManagerAgent, DisplayManagerAgentType> dmAgentContainer_; 391 DeviceScreenConfig deviceScreenConfig_; 392 std::vector<DisplayPhysicalResolution> allDisplayPhysicalResolution_ {}; 393 std::map<int32_t, std::set<DisplayManagerAgentType>> pidAgentTypeMap_; 394 std::vector<float> lastFoldAngles_ {}; 395 sptr<DisplayChangeInfo> lastDisplayChangeInfo_; 396 ScreenChangeEvent lastScreenChangeEvent_ = ScreenChangeEvent::UNKNOWN; 397 std::mutex lastStatusUpdateMutex_; 398 399 mutable std::recursive_mutex screenSessionMapMutex_; 400 std::map<ScreenId, sptr<ScreenSession>> screenSessionMap_; 401 std::recursive_mutex mutex_; 402 std::recursive_mutex displayInfoMutex_; 403 std::shared_mutex hookInfoMutex_; 404 405 ScreenId defaultScreenId_ = SCREEN_ID_INVALID; 406 ScreenIdManager screenIdManager_; 407 408 std::atomic<ScreenId> defaultRsScreenId_ { SCREEN_ID_INVALID }; 409 std::map<sptr<IRemoteObject>, std::vector<ScreenId>> screenAgentMap_; 410 std::map<ScreenId, sptr<ScreenSessionGroup>> smsScreenGroupMap_; 411 std::map<uint32_t, DMHookInfo> displayHookMap_; 412 413 bool isAutoRotationOpen_ = false; 414 bool isExpandCombination_ = false; 415 bool isScreenShot_ = false; 416 uint32_t hdmiScreenCount_ = 0; 417 uint32_t virtualScreenCount_ = 0; 418 sptr<AgentDeathRecipient> deathRecipient_ { nullptr }; 419 420 sptr<SessionDisplayPowerController> sessionDisplayPowerController_; 421 sptr<ScreenCutoutController> screenCutoutController_; 422 sptr<FoldScreenController> foldScreenController_; 423 424 bool isDensityDpiLoad_ = false; 425 float densityDpi_ { 1.0f }; 426 float subDensityDpi_ { 1.0f }; 427 std::atomic<uint32_t> cachedSettingDpi_ {0}; 428 429 uint32_t defaultDpi {0}; 430 uint32_t defaultDeviceRotationOffset_ { 0 }; 431 432 bool isMultiScreenCollaboration_ = false; 433 bool screenPrivacyStates = false; 434 bool keyguardDrawnDone_ = true; 435 bool needScreenOnWhenKeyguardNotify_ = false; 436 bool gotScreenOffNotify_ = false; 437 bool needScreenOffNotify_ = false; 438 439 std::mutex scbBufferAvailableMutex_; 440 std::condition_variable scbBufferAvailableCV_; 441 void BlockScbByAvailabelBuffer(void); 442 443 std::mutex screenOnMutex_; 444 std::condition_variable screenOnCV_; 445 std::mutex screenOffMutex_; 446 std::condition_variable screenOffCV_; 447 int32_t screenOffDelay_ {0}; 448 std::vector<ScreenId> mirrorScreenIds_; 449 std::mutex snapBypickerMutex_; 450 451 std::mutex freezedPidListMutex_; 452 std::set<int32_t> freezedPidList_; 453 454 std::atomic<PowerStateChangeReason> prePowerStateChangeReason_ = 455 PowerStateChangeReason::STATE_CHANGE_REASON_UNKNOWN; 456 std::atomic<PowerStateChangeReason> lastWakeUpReason_ = PowerStateChangeReason::STATE_CHANGE_REASON_INIT; 457 std::atomic<PowerStateChangeReason> currentWakeUpReason_ = PowerStateChangeReason::STATE_CHANGE_REASON_INIT; 458 std::atomic<bool> isScreenLockSuspend_ = false; 459 std::atomic<bool> gotScreenlockFingerprint_ = false; 460 std::atomic<bool> isPhyScreenConnected_ = false; 461 462 // Fold Screen 463 std::map<ScreenId, ScreenProperty> phyScreenPropMap_; 464 mutable std::recursive_mutex phyScreenPropMapMutex_; 465 static void BootFinishedCallback(const char *key, const char *value, void *context); 466 std::function<void()> foldScreenPowerInit_ = nullptr; 467 void HandleFoldScreenPowerInit(); 468 void SetFoldScreenPowerInit(std::function<void()> foldScreenPowerInit); 469 void SetDpiFromSettingData(); 470 void SetRotateLockedFromSettingData(); 471 void NotifyClientProxyUpdateFoldDisplayMode(FoldDisplayMode displayMode); 472 void UpdateDisplayScaleState(ScreenId screenId); 473 void SetDisplayScaleInner(ScreenId screenId, const float& scaleX, const float& scaleY, const float& pivotX, 474 const float& pivotY); 475 void CalcDisplayNodeTranslateOnFoldableRotation(sptr<ScreenSession>& session, const float& scaleX, 476 const float& scaleY, const float& pivotX, const float& pivotY, 477 float& translateX, float& translateY); 478 void CalcDisplayNodeTranslateOnRotation(sptr<ScreenSession>& session, const float& scaleX, const float& scaleY, 479 const float& pivotX, const float& pivotY, float& translateX, 480 float& translateY); 481 void RegisterApplicationStateObserver(); 482 void SetPostureAndHallSensorEnabled(); 483 bool IsDefaultMirrorMode(ScreenId screenId); 484 void SetCastFromSettingData(); 485 void RegisterCastObserver(std::vector<ScreenId>& mirrorScreenIds); 486 void UnRegisterCastObserver(std::vector<ScreenId>& mirrorScreenIds); 487 void ExitCoordination(const std::string& reason); 488 void UpdateDisplayState(std::vector<ScreenId> screenIds, DisplayState state); 489 DisplayState lastDisplayState_ { DisplayState::UNKNOWN }; 490 491 private: 492 class ScbClientListenerDeathRecipient : public IRemoteObject::DeathRecipient { 493 public: ScbClientListenerDeathRecipient(int32_t scbPid)494 explicit ScbClientListenerDeathRecipient(int32_t scbPid) 495 : scbPid_(scbPid) 496 {} 497 OnRemoteDied(const wptr<IRemoteObject> & wptrDeath)498 void OnRemoteDied(const wptr<IRemoteObject>& wptrDeath) override 499 { 500 ScreenSessionManager::GetInstance().ScbClientDeathCallback(scbPid_); 501 } 502 503 private: 504 int32_t scbPid_; 505 }; 506 }; 507 } // namespace OHOS::Rosen 508 509 #endif // OHOS_ROSEN_WINDOW_SCENE_SCREEN_SESSION_MANAGER_H 510