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 "common/include/task_scheduler.h" 21 #include "session/screen/include/screen_session.h" 22 #include "zidl/screen_session_manager_stub.h" 23 #include "client_agent_container.h" 24 #include "display_change_listener.h" 25 #include "session_display_power_controller.h" 26 #include "wm_single_instance.h" 27 28 #include "agent_death_recipient.h" 29 #include "screen.h" 30 #include "screen_cutout_controller.h" 31 32 namespace OHOS::Rosen { 33 class IScreenConnectionListener : public RefBase { 34 public: 35 IScreenConnectionListener() = default; 36 virtual ~IScreenConnectionListener() = default; 37 38 virtual void OnScreenConnect(sptr<ScreenSession>&) = 0; 39 virtual void OnScreenDisconnect(sptr<ScreenSession>&) = 0; 40 }; 41 42 class RSInterfaces; 43 44 class ScreenSessionManager : public ScreenSessionManagerStub { 45 WM_DECLARE_SINGLE_INSTANCE_BASE(ScreenSessionManager) 46 public: 47 sptr<ScreenSession> GetScreenSession(ScreenId screenId) const; 48 std::vector<ScreenId> GetAllScreenIds(); 49 50 sptr<DisplayInfo> GetDefaultDisplayInfo() override; 51 DMError SetScreenActiveMode(ScreenId screenId, uint32_t modeId) override; 52 DMError SetVirtualPixelRatio(ScreenId screenId, float virtualPixelRatio) override; 53 void NotifyScreenChanged(sptr<ScreenInfo> screenInfo, ScreenChangeEvent event); 54 55 DMError GetScreenColorGamut(ScreenId screenId, ScreenColorGamut& colorGamut) override; 56 DMError SetScreenColorGamut(ScreenId screenId, int32_t colorGamutIdx) override; 57 DMError GetScreenGamutMap(ScreenId screenId, ScreenGamutMap& gamutMap) override; 58 DMError SetScreenGamutMap(ScreenId screenId, ScreenGamutMap gamutMap) override; 59 DMError SetScreenColorTransform(ScreenId screenId) override; 60 61 void DumpAllScreensInfo(std::string& dumpInfo) override; 62 void DumpSpecialScreenInfo(ScreenId id, std::string& dumpInfo) override; 63 64 void RegisterScreenConnectionListener(sptr<IScreenConnectionListener>& screenConnectionListener); 65 void UnregisterScreenConnectionListener(sptr<IScreenConnectionListener>& screenConnectionListener); 66 67 virtual DMError RegisterDisplayManagerAgent(const sptr<IDisplayManagerAgent>& displayManagerAgent, 68 DisplayManagerAgentType type) override; 69 virtual DMError UnregisterDisplayManagerAgent(const sptr<IDisplayManagerAgent>& displayManagerAgent, 70 DisplayManagerAgentType type) override; 71 72 bool WakeUpBegin(PowerStateChangeReason reason) override; 73 bool WakeUpEnd() override; 74 bool SuspendBegin(PowerStateChangeReason reason) override; 75 bool SuspendEnd() override; 76 bool SetDisplayState(DisplayState state) override; 77 DisplayState GetDisplayState(DisplayId displayId) override; 78 bool SetScreenPowerForAll(ScreenPowerState state, PowerStateChangeReason reason) override; 79 ScreenPowerState GetScreenPower(ScreenId screenId) override; 80 void NotifyDisplayEvent(DisplayEvent event) override; 81 82 void RegisterDisplayChangeListener(sptr<IDisplayChangeListener> listener); 83 bool NotifyDisplayPowerEvent(DisplayPowerEvent event, EventStatus status); 84 bool NotifyDisplayStateChanged(DisplayId id, DisplayState state); 85 void NotifyScreenshot(DisplayId displayId); 86 virtual ScreenId CreateVirtualScreen(VirtualScreenOption option, 87 const sptr<IRemoteObject>& displayManagerAgent) override; 88 virtual DMError SetVirtualScreenSurface(ScreenId screenId, sptr<IBufferProducer> surface) override; 89 virtual DMError DestroyVirtualScreen(ScreenId screenId) override; 90 virtual DMError MakeMirror(ScreenId mainScreenId, std::vector<ScreenId> mirrorScreenIds, 91 ScreenId& screenGroupId) override; 92 virtual sptr<ScreenGroupInfo> GetScreenGroupInfoById(ScreenId screenId) override; 93 virtual void RemoveVirtualScreenFromGroup(std::vector<ScreenId> screens) override; 94 virtual std::shared_ptr<Media::PixelMap> GetDisplaySnapshot(DisplayId displayId, DmErrorCode* errorCode) override; 95 virtual sptr<DisplayInfo> GetDisplayInfoById(DisplayId displayId) override; 96 sptr<DisplayInfo> GetDisplayInfoByScreen(ScreenId screenId) override; 97 std::vector<DisplayId> GetAllDisplayIds() override; 98 virtual sptr<ScreenInfo> GetScreenInfoById(ScreenId screenId) override; 99 virtual DMError GetAllScreenInfos(std::vector<sptr<ScreenInfo>>& screenInfos) override; 100 virtual DMError GetScreenSupportedColorGamuts(ScreenId screenId, 101 std::vector<ScreenColorGamut>& colorGamuts) override; 102 DMError IsScreenRotationLocked(bool& isLocked) override; 103 DMError SetScreenRotationLocked(bool isLocked) override; 104 DMError SetOrientation(ScreenId screenId, Orientation orientation) override; 105 DMError SetOrientationFromWindow(DisplayId displayId, Orientation orientation); 106 DMError SetOrientationController(ScreenId screenId, Orientation newOrientation, bool isFromWindow); 107 bool SetRotation(ScreenId screenId, Rotation rotationAfter, bool isFromWindow); 108 void SetSensorSubscriptionEnabled(); 109 bool SetRotationFromWindow(Rotation targetRotation); 110 sptr<SupportedScreenModes> GetScreenModesByDisplayId(DisplayId displayId); 111 sptr<ScreenInfo> GetScreenInfoByDisplayId(DisplayId displayId); 112 void UpdateScreenRotationProperty(ScreenId screenId, RRect bounds, int rotation); 113 void NotifyDisplayChanged(sptr<DisplayInfo> displayInfo, DisplayChangeEvent event); 114 115 std::vector<ScreenId> GetAllScreenIds() const; 116 const std::shared_ptr<RSDisplayNode> GetRSDisplayNodeByScreenId(ScreenId smsScreenId) const; 117 std::shared_ptr<Media::PixelMap> GetScreenSnapshot(DisplayId displayId); 118 119 sptr<ScreenSession> InitVirtualScreen(ScreenId smsScreenId, ScreenId rsId, VirtualScreenOption option); 120 ScreenId GetDefaultAbstractScreenId(); 121 sptr<ScreenSession> InitAndGetScreen(ScreenId rsScreenId); 122 bool InitAbstractScreenModesInfo(sptr<ScreenSession>& absScreen); 123 std::vector<ScreenId> GetAllValidScreenIds(const std::vector<ScreenId>& screenIds) const; 124 125 sptr<ScreenSessionGroup> AddToGroupLocked(sptr<ScreenSession> newScreen); 126 sptr<ScreenSessionGroup> AddAsFirstScreenLocked(sptr<ScreenSession> newScreen); 127 sptr<ScreenSessionGroup> AddAsSuccedentScreenLocked(sptr<ScreenSession> newScreen); 128 sptr<ScreenSessionGroup> RemoveFromGroupLocked(sptr<ScreenSession> screen); 129 sptr<ScreenSessionGroup> GetAbstractScreenGroup(ScreenId smsScreenId); 130 131 void ChangeScreenGroup(sptr<ScreenSessionGroup> group, const std::vector<ScreenId>& screens, 132 const std::vector<Point>& startPoints, bool filterScreen, ScreenCombination combination); 133 134 bool RemoveChildFromGroup(sptr<ScreenSession> screen, sptr<ScreenSessionGroup> screenGroup); 135 136 void AddScreenToGroup(sptr<ScreenSessionGroup> group, 137 const std::vector<ScreenId>& addScreens, const std::vector<Point>& addChildPos, 138 std::map<ScreenId, bool>& removeChildResMap); 139 140 DMError SetMirror(ScreenId screenId, std::vector<ScreenId> screens); 141 142 void NotifyScreenConnected(sptr<ScreenInfo> screenInfo); 143 void NotifyScreenDisconnected(ScreenId screenId); 144 void NotifyScreenGroupChanged(const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent event); 145 void NotifyScreenGroupChanged(const std::vector<sptr<ScreenInfo>>& screenInfo, ScreenGroupChangeEvent event); 146 147 void NotifyPrivateSessionStateChanged(bool hasPrivate); 148 void UpdatePrivateStateAndNotify(sptr<ScreenSession>& screenSession, bool isAddingPrivateSession); 149 DMError HasPrivateWindow(DisplayId id, bool& hasPrivateWindow) override; 150 151 void OnScreenConnect(const sptr<ScreenInfo> screenInfo); 152 void OnScreenDisconnect(ScreenId screenId); 153 void OnScreenGroupChange(const std::string& trigger, 154 const sptr<ScreenInfo>& screenInfo, ScreenGroupChangeEvent groupEvent); 155 void OnScreenGroupChange(const std::string& trigger, 156 const std::vector<sptr<ScreenInfo>>& screenInfos, ScreenGroupChangeEvent groupEvent); 157 void OnScreenshot(sptr<ScreenshotInfo> info); 158 sptr<CutoutInfo> GetCutoutInfo(DisplayId displayId) override; 159 void SetDisplayBoundary(const sptr<ScreenSession> screenSession); 160 161 //Fold Screen 162 void SetFoldDisplayMode(const FoldDisplayMode displayMode) override; 163 164 FoldDisplayMode GetFoldDisplayMode() override; 165 166 bool IsFoldable() override; 167 168 FoldStatus GetFoldStatus() override; 169 170 sptr<FoldCreaseRegion> GetCurrentFoldCreaseRegion() override; 171 172 ScreenProperty GetPhyScreenProperty(ScreenId screenId); 173 uint32_t GetCurvedCompressionArea() const; 174 175 void NotifyFoldStatusChanged(FoldStatus foldStatus); 176 void NotifyDisplayModeChanged(FoldDisplayMode displayMode); 177 178 protected: 179 ScreenSessionManager(); 180 virtual ~ScreenSessionManager() = default; 181 182 private: 183 void Init(); 184 void LoadScreenSceneXml(); 185 void ConfigureScreenScene(); 186 void ConfigureWaterfallDisplayCompressionParams(); 187 void RegisterScreenChangeListener(); 188 void OnScreenChange(ScreenId screenId, ScreenEvent screenEvent); 189 sptr<ScreenSession> GetOrCreateScreenSession(ScreenId screenId); 190 191 ScreenId GetDefaultScreenId(); 192 193 void NotifyDisplayStateChange(DisplayId defaultDisplayId, sptr<DisplayInfo> displayInfo, 194 const std::map<DisplayId, sptr<DisplayInfo>>& displayInfoMap, DisplayStateChangeType type); 195 196 bool OnRemoteDied(const sptr<IRemoteObject>& agent); 197 198 std::string TransferTypeToString(ScreenType type) const; 199 200 class ScreenIdManager { 201 friend class ScreenSessionGroup; 202 public: 203 ScreenIdManager() = default; 204 ~ScreenIdManager() = default; 205 WM_DISALLOW_COPY_AND_MOVE(ScreenIdManager); 206 ScreenId CreateAndGetNewScreenId(ScreenId rsScreenId); 207 void UpdateScreenId(ScreenId rsScreenId, ScreenId smsScreenId); 208 bool DeleteScreenId(ScreenId smsScreenId); 209 bool HasRsScreenId(ScreenId smsScreenId) const; 210 bool ConvertToRsScreenId(ScreenId, ScreenId&) const; 211 ScreenId ConvertToRsScreenId(ScreenId) const; 212 bool ConvertToSmsScreenId(ScreenId, ScreenId&) const; 213 ScreenId ConvertToSmsScreenId(ScreenId) const; 214 215 private: 216 std::atomic<ScreenId> smsScreenCount_ {2}; 217 std::map<ScreenId, ScreenId> rs2SmsScreenIdMap_; 218 std::map<ScreenId, ScreenId> sms2RsScreenIdMap_; 219 mutable std::shared_mutex screenIdMapMutex_; 220 }; 221 222 RSInterfaces& rsInterface_; 223 std::shared_ptr<TaskScheduler> taskScheduler_; 224 ClientAgentContainer<IDisplayManagerAgent, DisplayManagerAgentType> dmAgentContainer_; 225 226 mutable std::recursive_mutex screenSessionMapMutex_; 227 std::map<ScreenId, sptr<ScreenSession>> screenSessionMap_; 228 229 ScreenId defaultScreenId_ = SCREEN_ID_INVALID; 230 ScreenIdManager screenIdManager_; 231 232 std::atomic<ScreenId> defaultRsScreenId_ { SCREEN_ID_INVALID }; 233 std::map<sptr<IRemoteObject>, std::vector<ScreenId>> screenAgentMap_; 234 std::map<ScreenId, sptr<ScreenSessionGroup>> smsScreenGroupMap_; 235 236 bool isAutoRotationOpen_ = false; 237 bool isExpandCombination_ = false; 238 sptr<AgentDeathRecipient> deathRecipient_ { nullptr }; 239 240 std::vector<sptr<IScreenConnectionListener>> screenConnectionListenerList_; 241 sptr<IDisplayChangeListener> displayChangeListener_; 242 sptr<SessionDisplayPowerController> sessionDisplayPowerController_; 243 sptr<ScreenCutoutController> screenCutoutController_; 244 245 bool isDensityDpiLoad_ = false; 246 float densityDpi_ { 1.0f }; 247 }; 248 } // namespace OHOS::Rosen 249 250 #endif // OHOS_ROSEN_WINDOW_SCENE_SCREEN_SESSION_MANAGER_H 251