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 22 #include "common/include/task_scheduler.h" 23 #include "dm_common.h" 24 #include "session/screen/include/screen_session.h" 25 #include "zidl/screen_session_manager_stub.h" 26 #include "client_agent_container.h" 27 #include "session_display_power_controller.h" 28 #include "wm_single_instance.h" 29 30 #include "agent_death_recipient.h" 31 #include "screen.h" 32 #include "screen_cutout_controller.h" 33 #include "fold_screen_controller/fold_screen_controller.h" 34 35 namespace OHOS::Rosen { 36 class RSInterfaces; 37 38 class ScreenSessionManager : public SystemAbility, public ScreenSessionManagerStub, public IScreenChangeListener { 39 DECLARE_SYSTEM_ABILITY(ScreenSessionManager) 40 WM_DECLARE_SINGLE_INSTANCE_BASE(ScreenSessionManager) 41 42 public: 43 sptr<ScreenSession> GetScreenSession(ScreenId screenId) const; 44 sptr<ScreenSession> GetDefaultScreenSession(); 45 std::vector<ScreenId> GetAllScreenIds(); 46 47 sptr<DisplayInfo> GetDefaultDisplayInfo() override; 48 DMError SetScreenActiveMode(ScreenId screenId, uint32_t modeId) override; 49 DMError SetVirtualPixelRatio(ScreenId screenId, float virtualPixelRatio) override; 50 DMError SetResolution(ScreenId screenId, uint32_t width, uint32_t height, float virtualPixelRatio) override; 51 DMError GetDensityInCurResolution(ScreenId screenId, float& virtualPixelRatio) override; 52 void NotifyScreenChanged(sptr<ScreenInfo> screenInfo, ScreenChangeEvent event); 53 54 DMError GetScreenColorGamut(ScreenId screenId, ScreenColorGamut& colorGamut) override; 55 DMError SetScreenColorGamut(ScreenId screenId, int32_t colorGamutIdx) override; 56 DMError GetScreenGamutMap(ScreenId screenId, ScreenGamutMap& gamutMap) override; 57 DMError SetScreenGamutMap(ScreenId screenId, ScreenGamutMap gamutMap) override; 58 DMError SetScreenColorTransform(ScreenId screenId) override; 59 60 DMError GetPixelFormat(ScreenId screenId, GraphicPixelFormat& pixelFormat) override; 61 DMError SetPixelFormat(ScreenId screenId, GraphicPixelFormat pixelFormat) override; 62 DMError GetSupportedHDRFormats(ScreenId screenId, std::vector<ScreenHDRFormat>& hdrFormats) override; 63 DMError GetScreenHDRFormat(ScreenId screenId, ScreenHDRFormat& hdrFormat) override; 64 DMError SetScreenHDRFormat(ScreenId screenId, int32_t modeIdx) override; 65 DMError GetSupportedColorSpaces(ScreenId screenId, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) override; 66 DMError GetScreenColorSpace(ScreenId screenId, GraphicCM_ColorSpaceType& colorSpace) override; 67 DMError SetScreenColorSpace(ScreenId screenId, GraphicCM_ColorSpaceType colorSpace) override; 68 69 void DumpAllScreensInfo(std::string& dumpInfo) override; 70 void DumpSpecialScreenInfo(ScreenId id, std::string& dumpInfo) override; 71 72 virtual DMError RegisterDisplayManagerAgent(const sptr<IDisplayManagerAgent>& displayManagerAgent, 73 DisplayManagerAgentType type) override; 74 virtual DMError UnregisterDisplayManagerAgent(const sptr<IDisplayManagerAgent>& displayManagerAgent, 75 DisplayManagerAgentType type) override; 76 77 bool WakeUpBegin(PowerStateChangeReason reason) override; 78 bool WakeUpEnd() override; 79 bool SuspendBegin(PowerStateChangeReason reason) override; 80 bool SuspendEnd() override; 81 bool SetDisplayState(DisplayState state) override; 82 DisplayState GetDisplayState(DisplayId displayId) override; 83 bool SetSpecifiedScreenPower(ScreenId screenId, ScreenPowerState state, PowerStateChangeReason reason) override; 84 bool SetScreenPowerForAll(ScreenPowerState state, PowerStateChangeReason reason) override; 85 ScreenPowerState GetScreenPower(ScreenId screenId) override; 86 void NotifyDisplayEvent(DisplayEvent event) override; 87 88 void RegisterDisplayChangeListener(sptr<IDisplayChangeListener> listener); 89 bool NotifyDisplayPowerEvent(DisplayPowerEvent event, EventStatus status, PowerStateChangeReason reason); 90 bool NotifyDisplayStateChanged(DisplayId id, DisplayState state); 91 void NotifyScreenshot(DisplayId displayId); 92 virtual ScreenId CreateVirtualScreen(VirtualScreenOption option, 93 const sptr<IRemoteObject>& displayManagerAgent) override; 94 virtual DMError SetVirtualScreenSurface(ScreenId screenId, sptr<IBufferProducer> surface) override; 95 virtual DMError SetVirtualMirrorScreenCanvasRotation(ScreenId screenId, bool autoRotate) override; 96 virtual DMError DestroyVirtualScreen(ScreenId screenId) override; 97 DMError ResizeVirtualScreen(ScreenId screenId, uint32_t width, uint32_t height) override; 98 virtual DMError MakeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenIds, 99 ScreenId& screenGroupId) override; 100 virtual DMError StopMirror(const std::vector<ScreenId>& mirrorScreenIds) override; 101 DMError DisableMirror(bool disableOrNot) override; 102 virtual DMError MakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint, 103 ScreenId& screenGroupId) override; 104 virtual DMError StopExpand(const std::vector<ScreenId>& expandScreenIds) override; 105 DMError MakeUniqueScreen(const std::vector<ScreenId>& screenIds) override; 106 virtual sptr<ScreenGroupInfo> GetScreenGroupInfoById(ScreenId screenId) override; 107 virtual void RemoveVirtualScreenFromGroup(std::vector<ScreenId> screens) override; 108 virtual std::shared_ptr<Media::PixelMap> GetDisplaySnapshot(DisplayId displayId, DmErrorCode* errorCode) override; 109 virtual sptr<DisplayInfo> GetDisplayInfoById(DisplayId displayId) override; 110 sptr<DisplayInfo> GetDisplayInfoByScreen(ScreenId screenId) override; 111 std::vector<DisplayId> GetAllDisplayIds() override; 112 virtual sptr<ScreenInfo> GetScreenInfoById(ScreenId screenId) override; 113 virtual DMError GetAllScreenInfos(std::vector<sptr<ScreenInfo>>& screenInfos) override; 114 virtual DMError GetScreenSupportedColorGamuts(ScreenId screenId, 115 std::vector<ScreenColorGamut>& colorGamuts) override; 116 DMError IsScreenRotationLocked(bool& isLocked) override; 117 DMError SetScreenRotationLocked(bool isLocked) override; 118 DMError SetOrientation(ScreenId screenId, Orientation orientation) override; 119 DMError SetOrientationFromWindow(DisplayId displayId, Orientation orientation); 120 DMError SetOrientationController(ScreenId screenId, Orientation newOrientation, bool isFromWindow); 121 bool SetRotation(ScreenId screenId, Rotation rotationAfter, bool isFromWindow); 122 void SetSensorSubscriptionEnabled(); 123 bool SetRotationFromWindow(Rotation targetRotation); 124 sptr<SupportedScreenModes> GetScreenModesByDisplayId(DisplayId displayId); 125 sptr<ScreenInfo> GetScreenInfoByDisplayId(DisplayId displayId); 126 void NotifyDisplayCreate(sptr<DisplayInfo> displayInfo); 127 void NotifyDisplayDestroy(DisplayId displayId); 128 void NotifyDisplayChanged(sptr<DisplayInfo> displayInfo, DisplayChangeEvent event); 129 130 std::vector<ScreenId> GetAllScreenIds() const; 131 const std::shared_ptr<RSDisplayNode> GetRSDisplayNodeByScreenId(ScreenId smsScreenId) const; 132 std::shared_ptr<Media::PixelMap> GetScreenSnapshot(DisplayId displayId); 133 134 sptr<ScreenSession> InitVirtualScreen(ScreenId smsScreenId, ScreenId rsId, VirtualScreenOption option); 135 sptr<ScreenSession> InitAndGetScreen(ScreenId rsScreenId); 136 bool InitAbstractScreenModesInfo(sptr<ScreenSession>& absScreen); 137 std::vector<ScreenId> GetAllValidScreenIds(const std::vector<ScreenId>& screenIds) const; 138 139 sptr<ScreenSessionGroup> AddToGroupLocked(sptr<ScreenSession> newScreen); 140 sptr<ScreenSessionGroup> AddAsFirstScreenLocked(sptr<ScreenSession> newScreen); 141 sptr<ScreenSessionGroup> AddAsSuccedentScreenLocked(sptr<ScreenSession> newScreen); 142 sptr<ScreenSessionGroup> RemoveFromGroupLocked(sptr<ScreenSession> screen); 143 sptr<ScreenSessionGroup> GetAbstractScreenGroup(ScreenId smsScreenId); 144 145 void ChangeScreenGroup(sptr<ScreenSessionGroup> group, const std::vector<ScreenId>& screens, 146 const std::vector<Point>& startPoints, bool filterScreen, ScreenCombination combination); 147 148 bool RemoveChildFromGroup(sptr<ScreenSession> screen, sptr<ScreenSessionGroup> screenGroup); 149 150 void AddScreenToGroup(sptr<ScreenSessionGroup> group, 151 const std::vector<ScreenId>& addScreens, const std::vector<Point>& addChildPos, 152 std::map<ScreenId, bool>& removeChildResMap); 153 bool CheckScreenInScreenGroup(sptr<ScreenSession> screen) const; 154 155 DMError SetMirror(ScreenId screenId, std::vector<ScreenId> screens); 156 DMError StopScreens(const std::vector<ScreenId>& screenIds, ScreenCombination stopCombination); 157 158 void NotifyScreenConnected(sptr<ScreenInfo> screenInfo); 159 void NotifyScreenDisconnected(ScreenId screenId); 160 void NotifyScreenGroupChanged(const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent event); 161 void NotifyScreenGroupChanged(const std::vector<sptr<ScreenInfo>>& screenInfo, ScreenGroupChangeEvent event); 162 163 void NotifyPrivateSessionStateChanged(bool hasPrivate); 164 DMError HasPrivateWindow(DisplayId id, bool& hasPrivateWindow) override; 165 bool ConvertScreenIdToRsScreenId(ScreenId screenId, ScreenId& rsScreenId) override; 166 167 void OnScreenConnect(const sptr<ScreenInfo> screenInfo); 168 void OnScreenDisconnect(ScreenId screenId); 169 void OnScreenGroupChange(const std::string& trigger, 170 const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent groupEvent); 171 void OnScreenGroupChange(const std::string& trigger, 172 const std::vector<sptr<ScreenInfo>>& screenInfos, ScreenGroupChangeEvent groupEvent); 173 void OnScreenshot(sptr<ScreenshotInfo> info); 174 bool IsMultiScreenCollaboration(); 175 sptr<CutoutInfo> GetCutoutInfo(DisplayId displayId) override; 176 DMError HasImmersiveWindow(bool& immersive) override; 177 void SetDisplayBoundary(const sptr<ScreenSession> screenSession); 178 179 //Fold Screen 180 void SetFoldDisplayMode(const FoldDisplayMode displayMode) override; 181 void SetDisplayNodeScreenId(ScreenId screenId, ScreenId displayNodeScreenId); 182 183 void SetFoldStatusLocked(bool locked) override; 184 185 FoldDisplayMode GetFoldDisplayMode() override; 186 187 bool IsFoldable() override; 188 189 FoldStatus GetFoldStatus() override; 190 191 bool SetScreenPower(ScreenPowerStatus status, PowerStateChangeReason reason); 192 193 void SetKeyguardDrawnDoneFlag(bool flag); 194 195 sptr<FoldCreaseRegion> GetCurrentFoldCreaseRegion() override; 196 197 void NotifyFoldStatusChanged(FoldStatus foldStatus); 198 void NotifyDisplayModeChanged(FoldDisplayMode displayMode); 199 void NotifyDisplayChangeInfoChanged(const sptr<DisplayChangeInfo>& info) override; 200 void RegisterSettingDpiObserver(); 201 OnConnect(ScreenId screenId)202 void OnConnect(ScreenId screenId) override {} OnDisconnect(ScreenId screenId)203 void OnDisconnect(ScreenId screenId) override {} 204 void OnPropertyChange(const ScreenProperty& newProperty, ScreenPropertyChangeReason reason, 205 ScreenId screenId) override; 206 void OnPowerStatusChange(DisplayPowerEvent event, EventStatus status, 207 PowerStateChangeReason reason) override; 208 void OnSensorRotationChange(float sensorRotation, ScreenId screenId) override; 209 void OnScreenOrientationChange(float screenOrientation, ScreenId screenId) override; 210 void OnScreenRotationLockedChange(bool isLocked, ScreenId screenId) override; 211 212 void SetHdrFormats(ScreenId screenId, sptr<ScreenSession>& session); 213 void SetColorSpaces(ScreenId screenId, sptr<ScreenSession>& session); 214 215 void SetClient(const sptr<IScreenSessionManagerClient>& client, int32_t userId) override; 216 ScreenProperty GetScreenProperty(ScreenId screenId) override; 217 std::shared_ptr<RSDisplayNode> GetDisplayNode(ScreenId screenId) override; 218 void UpdateScreenRotationProperty(ScreenId screenId, const RRect& bounds, float rotation) override; 219 uint32_t GetCurvedCompressionArea() override; 220 ScreenProperty GetPhyScreenProperty(ScreenId screenId) override; 221 void SetScreenPrivacyState(bool hasPrivate) override; 222 void UpdateAvailableArea(ScreenId screenId, DMRect area) override; 223 DMError GetAvailableArea(DisplayId displayId, DMRect& area) override; 224 void NotifyAvailableAreaChanged(DMRect area); 225 void NotifyFoldToExpandCompletion(bool foldToExpand) override; 226 227 protected: 228 ScreenSessionManager(); 229 virtual ~ScreenSessionManager() = default; 230 231 private: 232 void OnStart() override; 233 void Init(); 234 void LoadScreenSceneXml(); 235 void ConfigureScreenScene(); 236 void ConfigureWaterfallDisplayCompressionParams(); 237 void RegisterScreenChangeListener(); 238 void OnScreenChange(ScreenId screenId, ScreenEvent screenEvent); 239 void RegisterRefreshRateModeChangeListener(); 240 void OnHgmRefreshRateModeChange(int32_t refreshRateMode); 241 sptr<ScreenSession> GetOrCreateScreenSession(ScreenId screenId); 242 sptr<ScreenSession> GetScreenSessionInner(ScreenId screenId, ScreenProperty property); 243 void FreeDisplayMirrorNodeInner(const sptr<ScreenSession> mirrorSession); 244 245 ScreenId GetDefaultScreenId(); 246 247 void NotifyDisplayStateChange(DisplayId defaultDisplayId, sptr<DisplayInfo> displayInfo, 248 const std::map<DisplayId, sptr<DisplayInfo>>& displayInfoMap, DisplayStateChangeType type); 249 bool OnMakeExpand(std::vector<ScreenId> screenId, std::vector<Point> startPoint); 250 bool OnRemoteDied(const sptr<IRemoteObject>& agent); 251 std::string TransferTypeToString(ScreenType type) const; 252 void CheckAndSendHiSysEvent(const std::string& eventName, const std::string& bundleName) const; 253 void HandlerSensor(ScreenPowerStatus status); 254 255 // notify scb virtual screen change 256 void OnVirtualScreenChange(ScreenId screenId, ScreenEvent screenEvent); 257 258 int Dump(int fd, const std::vector<std::u16string>& args) override; 259 void ShowHelpInfo(std::string& dumpInfo); 260 void ShowIllegalArgsInfo(std::string& dumpInfo); 261 int DumpScreenInfo(const std::vector<std::string>& args, std::string& dumpInfo); 262 int DumpAllScreenInfo(std::string& dumpInfo); 263 int DumpSpecifiedScreenInfo(ScreenId screenId, std::string& dumpInfo); 264 bool IsValidDigitString(const std::string& idStr) const; 265 int SetFoldDisplayMode(const std::string& modeParam); 266 int SetFoldStatusLocked(const std::string& lockParam); 267 268 class ScreenIdManager { 269 friend class ScreenSessionGroup; 270 public: 271 ScreenIdManager() = default; 272 ~ScreenIdManager() = default; 273 WM_DISALLOW_COPY_AND_MOVE(ScreenIdManager); 274 ScreenId CreateAndGetNewScreenId(ScreenId rsScreenId); 275 void UpdateScreenId(ScreenId rsScreenId, ScreenId smsScreenId); 276 bool DeleteScreenId(ScreenId smsScreenId); 277 bool HasRsScreenId(ScreenId smsScreenId) const; 278 bool ConvertToRsScreenId(ScreenId, ScreenId&) const; 279 ScreenId ConvertToRsScreenId(ScreenId) const; 280 bool ConvertToSmsScreenId(ScreenId, ScreenId&) const; 281 ScreenId ConvertToSmsScreenId(ScreenId) const; 282 283 private: 284 std::atomic<ScreenId> smsScreenCount_ {2}; 285 std::map<ScreenId, ScreenId> rs2SmsScreenIdMap_; 286 std::map<ScreenId, ScreenId> sms2RsScreenIdMap_; 287 mutable std::shared_mutex screenIdMapMutex_; 288 }; 289 290 RSInterfaces& rsInterface_; 291 std::shared_ptr<TaskScheduler> taskScheduler_; 292 std::shared_ptr<TaskScheduler> screenPowerTaskScheduler_; 293 sptr<IScreenSessionManagerClient> clientProxy_; 294 ClientAgentContainer<IDisplayManagerAgent, DisplayManagerAgentType> dmAgentContainer_; 295 296 mutable std::recursive_mutex screenSessionMapMutex_; 297 std::map<ScreenId, sptr<ScreenSession>> screenSessionMap_; 298 std::recursive_mutex mutex_; 299 std::recursive_mutex displayInfoMutex_; 300 301 ScreenId defaultScreenId_ = SCREEN_ID_INVALID; 302 ScreenIdManager screenIdManager_; 303 304 std::atomic<ScreenId> defaultRsScreenId_ { SCREEN_ID_INVALID }; 305 std::map<sptr<IRemoteObject>, std::vector<ScreenId>> screenAgentMap_; 306 std::map<ScreenId, sptr<ScreenSessionGroup>> smsScreenGroupMap_; 307 308 bool isAutoRotationOpen_ = false; 309 bool isExpandCombination_ = false; 310 sptr<AgentDeathRecipient> deathRecipient_ { nullptr }; 311 312 sptr<SessionDisplayPowerController> sessionDisplayPowerController_; 313 sptr<ScreenCutoutController> screenCutoutController_; 314 sptr<FoldScreenController> foldScreenController_; 315 316 bool isDensityDpiLoad_ = false; 317 float densityDpi_ { 1.0f }; 318 std::atomic<uint32_t> cachedSettingDpi_ {0}; 319 uint32_t defaultDpi {0}; 320 321 bool isMultiScreenCollaboration_ = false; 322 bool screenPrivacyStates = false; 323 bool keyguardDrawnDone_ = true; 324 bool needScreenOnWhenKeyguardNotify_ = false; 325 bool blockScreenPowerChange_ = false; 326 327 //Fold Screen 328 std::map<ScreenId, ScreenProperty> phyScreenPropMap_; 329 mutable std::recursive_mutex phyScreenPropMapMutex_; 330 static void BootFinishedCallback(const char *key, const char *value, void *context); 331 std::function<void()> foldScreenPowerInit_ = nullptr; 332 void SetFoldScreenPowerInit(std::function<void()> foldScreenPowerInit); 333 void SetDpiFromSettingData(); 334 }; 335 } // namespace OHOS::Rosen 336 337 #endif // OHOS_ROSEN_WINDOW_SCENE_SCREEN_SESSION_MANAGER_H 338