1 /* 2 * Copyright (c) 2021-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 RS_SCREEN_MANAGER 17 #define RS_SCREEN_MANAGER 18 19 #include <condition_variable> 20 #include <cstdint> 21 #include <future> 22 #include <memory> 23 #include <mutex> 24 #include <queue> 25 #include <shared_mutex> 26 #include <unordered_map> 27 #include <unordered_set> 28 29 #include <hdi_backend.h> 30 #include <ipc_callbacks/screen_change_callback.h> 31 #include <ipc_callbacks/screen_switching_notify_callback.h> 32 #include <refbase.h> 33 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE 34 #include <sensor_agent.h> 35 #include <sensor_agent_type.h> 36 #endif 37 #include <surface.h> 38 #include <surface_type.h> 39 40 #include <screen_manager/rs_screen_props.h> 41 #include <screen_manager/rs_screen_mode_info.h> 42 #include <screen_manager/rs_screen_capability.h> 43 #include <screen_manager/rs_screen_data.h> 44 #include <screen_manager/rs_screen_hdr_capability.h> 45 #include <screen_manager/screen_types.h> 46 #include <screen_manager/rs_virtual_screen_resolution.h> 47 #include <screen_manager/rs_screen_info.h> 48 49 namespace OHOS { 50 namespace Rosen { 51 class RSScreen; 52 class RSIScreenNodeListener; 53 class RSScreenManager : public RefBase { 54 public: 55 RSScreenManager() = default; 56 virtual ~RSScreenManager() noexcept = default; 57 58 virtual bool Init() noexcept = 0; 59 virtual void ProcessScreenHotPlugEvents() = 0; 60 virtual bool TrySimpleProcessHotPlugEvents() = 0; 61 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE 62 virtual void HandlePostureData(const SensorEvent* const event) = 0; 63 #endif 64 65 virtual void SetDefaultScreenId(ScreenId id) = 0; 66 virtual ScreenId GetDefaultScreenId() const = 0; 67 virtual ScreenId GetActiveScreenId() = 0; 68 virtual std::vector<ScreenId> GetAllScreenIds() const = 0; 69 70 virtual ScreenInfo QueryScreenInfo(ScreenId id) const = 0; 71 virtual ScreenInfo QueryDefaultScreenInfo() const = 0; 72 73 virtual int32_t GetScreenType(ScreenId id, RSScreenType& type) const = 0; 74 virtual ScreenInfo GetActualScreenMaxResolution() const = 0; 75 76 virtual int32_t AddScreenChangeCallback(const sptr<RSIScreenChangeCallback>& callback) = 0; 77 virtual void RemoveScreenChangeCallback(const sptr<RSIScreenChangeCallback>& callback) = 0; 78 virtual int32_t SetScreenSwitchingNotifyCallback(const sptr<RSIScreenSwitchingNotifyCallback>& callback) = 0; 79 virtual void RegisterScreenNodeListener(std::shared_ptr<RSIScreenNodeListener> listener) = 0; 80 81 virtual void DisplayDump(std::string& dumpString) = 0; 82 virtual void SurfaceDump(std::string& dumpString) = 0; 83 virtual void DumpCurrentFrameLayers() = 0; 84 virtual void FpsDump(std::string& dumpString, std::string& arg) = 0; 85 virtual void ClearFpsDump(std::string& dumpString, std::string& arg) = 0; 86 virtual void HitchsDump(std::string& dumpString, std::string& arg) = 0; 87 88 virtual int32_t SetScreenSkipFrameInterval(ScreenId id, uint32_t skipFrameInterval) = 0; 89 virtual void SetEqualVsyncPeriod(ScreenId id, bool isEqualVsyncPeriod) = 0; 90 virtual void PostForceRefreshTask() = 0; 91 virtual void RemoveForceRefreshTask() = 0; 92 93 virtual void ClearFrameBufferIfNeed() = 0; 94 virtual void ReleaseScreenDmaBuffer(ScreenId id) = 0; 95 96 /* only used for mock tests */ 97 virtual void MockHdiScreenConnected(std::shared_ptr<RSScreen> rsScreen) = 0; 98 99 // physical screen 100 virtual std::shared_ptr<HdiOutput> GetOutput(ScreenId id) const = 0; 101 102 virtual uint32_t SetScreenActiveMode(ScreenId id, uint32_t modeId) = 0; 103 virtual void GetScreenActiveMode(ScreenId id, RSScreenModeInfo& screenModeInfo) const = 0; 104 virtual void GetDefaultScreenActiveMode(RSScreenModeInfo& screenModeInfo) const = 0; 105 virtual std::vector<RSScreenModeInfo> GetScreenSupportedModes(ScreenId id) const = 0; 106 107 virtual RSScreenCapability GetScreenCapability(ScreenId id) const = 0; 108 virtual RSScreenData GetScreenData(ScreenId id) const = 0; 109 virtual int32_t GetDisplayIdentificationData( 110 ScreenId id, uint8_t& outPort, std::vector<uint8_t>& edidData) const = 0; 111 112 virtual int32_t SetScreenCorrection(ScreenId id, ScreenRotation screenRotation) = 0; 113 virtual ScreenRotation GetScreenCorrection(ScreenId id) const = 0; 114 115 virtual int32_t SetRogScreenResolution(ScreenId id, uint32_t width, uint32_t height) = 0; 116 virtual int32_t SetPhysicalScreenResolution(ScreenId id, uint32_t width, uint32_t height) = 0; 117 118 virtual void SetScreenPowerStatus(ScreenId id, ScreenPowerStatus status) = 0; 119 virtual ScreenPowerStatus GetScreenPowerStatus(ScreenId id) const = 0; 120 virtual void WaitScreenPowerStatusTask() = 0; 121 virtual bool IsScreenPoweringOn() const = 0; 122 virtual bool IsScreenPoweringOff(ScreenId id) const = 0; 123 virtual bool IsScreenPowerOff(ScreenId id) const = 0; 124 virtual bool IsAllScreensPowerOff() const = 0; 125 virtual void DisablePowerOffRenderControl(ScreenId id) = 0; 126 virtual int GetDisableRenderControlScreensCount() const = 0; 127 // used to skip render frame or render only one frame when screen power is off. 128 virtual void MarkPowerOffNeedProcessOneFrame() = 0; 129 virtual void ResetPowerOffNeedProcessOneFrame() = 0; 130 virtual bool GetPowerOffNeedProcessOneFrame() const = 0; 131 132 virtual void SetScreenBacklight(ScreenId id, uint32_t level) = 0; 133 virtual int32_t GetScreenBacklight(ScreenId id) const = 0; 134 virtual int32_t SetScreenConstraint(ScreenId id, uint64_t timestamp, ScreenConstraintType type) = 0; 135 136 virtual int32_t SetPixelFormat(ScreenId id, GraphicPixelFormat pixelFormat) = 0; 137 virtual int32_t GetPixelFormat(ScreenId id, GraphicPixelFormat& pixelFormat) const = 0; 138 139 virtual int32_t SetScreenColorGamut(ScreenId id, int32_t modeIdx) = 0; 140 virtual int32_t GetScreenColorGamut(ScreenId id, ScreenColorGamut& mode) const = 0; 141 virtual int32_t GetScreenSupportedColorGamuts(ScreenId id, std::vector<ScreenColorGamut>& mode) const = 0; 142 virtual int32_t SetScreenGamutMap(ScreenId id, ScreenGamutMap mode) = 0; 143 virtual int32_t GetScreenGamutMap(ScreenId id, ScreenGamutMap& mode) const = 0; 144 145 virtual int32_t SetScreenHDRFormat(ScreenId id, int32_t modeIdx) = 0; 146 virtual int32_t GetScreenHDRFormat(ScreenId id, ScreenHDRFormat& hdrFormat) const = 0; 147 virtual int32_t GetScreenSupportedHDRFormats(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) const = 0; 148 virtual int32_t GetScreenHDRCapability(ScreenId id, RSScreenHDRCapability& screenHdrCapability) const = 0; 149 virtual int32_t GetScreenSupportedMetaDataKeys(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) const = 0; 150 151 virtual int32_t SetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType colorSpace) = 0; 152 virtual int32_t GetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) const = 0; 153 virtual int32_t GetScreenSupportedColorSpaces( 154 ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const = 0; 155 156 virtual void SetScreenSwitchStatus(bool flag) = 0; 157 virtual bool IsScreenSwitching() const = 0; 158 159 virtual uint32_t SetScreenActiveRect(ScreenId id, const GraphicIRect& activeRect) = 0; 160 virtual void SetScreenHasProtectedLayer(ScreenId id, bool hasProtectedLayer) = 0; 161 virtual int32_t SetScreenLinearMatrix(ScreenId id, const std::vector<float>& matrix) = 0; 162 virtual bool GetDisplayPropertyForHardCursor(uint32_t screenId) = 0; 163 164 // virtual screen 165 virtual ScreenId CreateVirtualScreen(const std::string& name, uint32_t width, uint32_t height, 166 sptr<Surface> surface, ScreenId mirrorId = 0, int32_t flags = 0, std::vector<uint64_t> whiteList = {}) = 0; 167 virtual void RemoveVirtualScreen(ScreenId id) = 0; 168 virtual uint32_t GetCurrentVirtualScreenNum() = 0; 169 170 virtual int32_t SetVirtualScreenSurface(ScreenId id, sptr<Surface> surface) = 0; 171 virtual sptr<Surface> GetProducerSurface(ScreenId id) const = 0; 172 virtual bool GetAndResetVirtualSurfaceUpdateFlag(ScreenId id) const = 0; 173 174 virtual int32_t ResizeVirtualScreen(ScreenId id, uint32_t width, uint32_t height) = 0; 175 virtual int32_t SetVirtualScreenResolution(ScreenId id, uint32_t width, uint32_t height) = 0; 176 virtual void GetVirtualScreenResolution(ScreenId id, RSVirtualScreenResolution& virtualScreenResolution) const = 0; 177 178 virtual bool SetVirtualMirrorScreenCanvasRotation(ScreenId id, bool canvasRotation) = 0; 179 virtual bool GetCanvasRotation(ScreenId id) const = 0; 180 181 virtual int32_t SetVirtualScreenAutoRotation(ScreenId id, bool isAutoRotation) = 0; 182 virtual bool GetVirtualScreenAutoRotation(ScreenId id) const = 0; 183 184 virtual bool SetVirtualMirrorScreenScaleMode(ScreenId id, ScreenScaleMode ScaleMode) = 0; 185 virtual ScreenScaleMode GetScaleMode(ScreenId id) const = 0; 186 187 virtual bool SetVirtualScreenStatus(ScreenId id, VirtualScreenStatus screenStatus) = 0; 188 virtual VirtualScreenStatus GetVirtualScreenStatus(ScreenId id) const = 0; 189 190 virtual int32_t SetCastScreenEnableSkipWindow(ScreenId id, bool enable) = 0; 191 virtual int32_t SetVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) = 0; 192 virtual int32_t SetVirtualScreenTypeBlackList(ScreenId id, const std::vector<uint8_t>& typeBlackList) = 0; 193 virtual int32_t AddVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) = 0; 194 virtual int32_t RemoveVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) = 0; 195 virtual const std::unordered_set<uint64_t> GetVirtualScreenBlackList(ScreenId id) const = 0; 196 virtual const std::unordered_set<uint8_t> GetVirtualScreenTypeBlackList(ScreenId id) const = 0; 197 virtual std::unordered_set<uint64_t> GetAllBlackList() const = 0; 198 virtual std::unordered_set<uint64_t> GetAllWhiteList() = 0; 199 virtual std::unordered_set<uint64_t> GetBlackListVirtualScreenByNode(uint64_t nodeId) = 0; 200 201 virtual int32_t SetVirtualScreenSecurityExemptionList( 202 ScreenId id, const std::vector<uint64_t>& securityExemptionList) = 0; 203 virtual const std::vector<uint64_t> GetVirtualScreenSecurityExemptionList(ScreenId id) const = 0; 204 205 virtual int32_t SetScreenSecurityMask(ScreenId id, std::shared_ptr<Media::PixelMap> securityMask) = 0; 206 virtual std::shared_ptr<Media::PixelMap> GetScreenSecurityMask(ScreenId id) const = 0; 207 208 virtual int32_t SetMirrorScreenVisibleRect( 209 ScreenId id, const Rect& mainScreenRect, bool supportRotation = false) = 0; 210 virtual Rect GetMirrorScreenVisibleRect(ScreenId id) const = 0; 211 virtual bool IsVisibleRectSupportRotation(ScreenId id) = 0; 212 virtual int32_t GetVirtualScreenSecLayerOption(ScreenId id) const = 0; 213 214 virtual int32_t SetVirtualScreenRefreshRate(ScreenId id, uint32_t maxRefreshRate, uint32_t& actualRefreshRate) = 0; 215 216 virtual std::unordered_map<ScreenId, std::unordered_set<uint64_t>> GetScreenWhiteList() const = 0; 217 218 virtual void SetScreenOffset(ScreenId id, int32_t offsetX, int32_t offsetY) = 0; 219 220 virtual bool CheckPSurfaceChanged(ScreenId id) = 0; 221 }; 222 223 sptr<RSScreenManager> CreateOrGetScreenManager(); 224 225 namespace impl { 226 struct ScreenHotPlugEvent { 227 std::shared_ptr<HdiOutput> output; 228 bool connected = false; 229 }; 230 231 enum class FoldState : uint32_t { 232 UNKNOW, 233 FOLDED, 234 EXPAND 235 }; 236 237 class RSScreenManager : public OHOS::Rosen::RSScreenManager { 238 public: 239 static sptr<OHOS::Rosen::RSScreenManager> GetInstance() noexcept; 240 241 bool Init() noexcept override; 242 void ProcessScreenHotPlugEvents() override; 243 bool TrySimpleProcessHotPlugEvents() override; 244 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE 245 void HandlePostureData(const SensorEvent* const event) override; 246 #endif 247 248 void SetDefaultScreenId(ScreenId id) override; 249 ScreenId GetDefaultScreenId() const override; 250 ScreenId GetActiveScreenId() override; 251 std::vector<ScreenId> GetAllScreenIds() const override; 252 253 ScreenInfo QueryScreenInfo(ScreenId id) const override; 254 ScreenInfo QueryDefaultScreenInfo() const override; 255 256 int32_t GetScreenType(ScreenId id, RSScreenType& type) const override; 257 ScreenInfo GetActualScreenMaxResolution() const override; 258 259 int32_t AddScreenChangeCallback(const sptr<RSIScreenChangeCallback>& callback) override; 260 void RemoveScreenChangeCallback(const sptr<RSIScreenChangeCallback>& callback) override; 261 int32_t SetScreenSwitchingNotifyCallback(const sptr<RSIScreenSwitchingNotifyCallback>& callback) override; 262 void RegisterScreenNodeListener(std::shared_ptr<RSIScreenNodeListener> listener) override; 263 264 void DisplayDump(std::string& dumpString) override; 265 void SurfaceDump(std::string& dumpString) override; 266 void DumpCurrentFrameLayers() override; 267 void FpsDump(std::string& dumpString, std::string& arg) override; 268 void ClearFpsDump(std::string& dumpString, std::string& arg) override; 269 void HitchsDump(std::string& dumpString, std::string& arg) override; 270 271 int32_t SetScreenSkipFrameInterval(ScreenId id, uint32_t skipFrameInterval) override; 272 void SetEqualVsyncPeriod(ScreenId id, bool isEqualVsyncPeriod) override; 273 void PostForceRefreshTask() override; 274 void RemoveForceRefreshTask() override; 275 276 void ClearFrameBufferIfNeed() override; 277 void ReleaseScreenDmaBuffer(ScreenId screenId) override; 278 279 /* only used for mock tests */ 280 void MockHdiScreenConnected(std::shared_ptr<OHOS::Rosen::RSScreen> rsScreen) override; 281 282 // physical screen 283 std::shared_ptr<HdiOutput> GetOutput(ScreenId id) const override; 284 285 uint32_t SetScreenActiveMode(ScreenId id, uint32_t modeId) override; 286 void GetScreenActiveMode(ScreenId id, RSScreenModeInfo& screenModeInfo) const override; 287 void GetDefaultScreenActiveMode(RSScreenModeInfo& screenModeInfo) const override; 288 std::vector<RSScreenModeInfo> GetScreenSupportedModes(ScreenId id) const override; 289 290 RSScreenCapability GetScreenCapability(ScreenId id) const override; 291 RSScreenData GetScreenData(ScreenId id) const override; 292 int32_t GetDisplayIdentificationData(ScreenId id, uint8_t& outPort, std::vector<uint8_t>& edidData) const override; 293 294 int32_t SetScreenCorrection(ScreenId id, ScreenRotation screenRotation) override; 295 ScreenRotation GetScreenCorrection(ScreenId id) const override; 296 297 int32_t SetRogScreenResolution(ScreenId id, uint32_t width, uint32_t height) override; 298 int32_t SetPhysicalScreenResolution(ScreenId id, uint32_t width, uint32_t height) override; 299 300 void SetScreenPowerStatus(ScreenId id, ScreenPowerStatus status) override; 301 ScreenPowerStatus GetScreenPowerStatus(ScreenId id) const override; 302 void WaitScreenPowerStatusTask() override; 303 bool IsScreenPoweringOn() const override; 304 bool IsScreenPoweringOff(ScreenId id) const override; 305 bool IsScreenPowerOff(ScreenId id) const override; 306 bool IsAllScreensPowerOff() const override; 307 void DisablePowerOffRenderControl(ScreenId id) override; 308 int GetDisableRenderControlScreensCount() const override; 309 // used to skip render frame or render only one frame when screen power is off. 310 void MarkPowerOffNeedProcessOneFrame() override; 311 void ResetPowerOffNeedProcessOneFrame() override; 312 bool GetPowerOffNeedProcessOneFrame() const override; 313 314 void SetScreenBacklight(ScreenId id, uint32_t level) override; 315 int32_t GetScreenBacklight(ScreenId id) const override; 316 int32_t SetScreenConstraint(ScreenId id, uint64_t timestamp, ScreenConstraintType type) override; 317 318 int32_t SetPixelFormat(ScreenId id, GraphicPixelFormat pixelFormat) override; 319 int32_t GetPixelFormat(ScreenId id, GraphicPixelFormat& pixelFormat) const override; 320 321 int32_t SetScreenColorGamut(ScreenId id, int32_t modeIdx) override; 322 int32_t GetScreenColorGamut(ScreenId id, ScreenColorGamut& mode) const override; 323 int32_t GetScreenSupportedColorGamuts(ScreenId id, std::vector<ScreenColorGamut>& mode) const override; 324 int32_t SetScreenGamutMap(ScreenId id, ScreenGamutMap mode) override; 325 int32_t GetScreenGamutMap(ScreenId id, ScreenGamutMap& mode) const override; 326 327 int32_t SetScreenHDRFormat(ScreenId id, int32_t modeIdx) override; 328 int32_t GetScreenHDRFormat(ScreenId id, ScreenHDRFormat& hdrFormat) const override; 329 int32_t GetScreenSupportedHDRFormats(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) const override; 330 int32_t GetScreenHDRCapability(ScreenId id, RSScreenHDRCapability& screenHdrCapability) const override; 331 int32_t GetScreenSupportedMetaDataKeys(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) const override; 332 333 int32_t SetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType colorSpace) override; 334 int32_t GetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) const override; 335 int32_t GetScreenSupportedColorSpaces( 336 ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const override; 337 338 void SetScreenSwitchStatus(bool flag) override; 339 bool IsScreenSwitching() const override; 340 341 uint32_t SetScreenActiveRect(ScreenId id, const GraphicIRect& activeRect) override; 342 void SetScreenHasProtectedLayer(ScreenId id, bool hasProtectedLayer) override; 343 int32_t SetScreenLinearMatrix(ScreenId id, const std::vector<float>& matrix) override; 344 bool GetDisplayPropertyForHardCursor(uint32_t screenId) override; 345 346 // virtual screen 347 ScreenId CreateVirtualScreen(const std::string& name, uint32_t width, uint32_t height, sptr<Surface> surface, 348 ScreenId mirrorId, int32_t flags, std::vector<uint64_t> whiteList) override; 349 void RemoveVirtualScreen(ScreenId id) override; 350 uint32_t GetCurrentVirtualScreenNum() override; 351 352 int32_t SetVirtualScreenSurface(ScreenId id, sptr<Surface> surface) override; 353 sptr<Surface> GetProducerSurface(ScreenId id) const override; 354 bool GetAndResetVirtualSurfaceUpdateFlag(ScreenId id) const override; 355 356 int32_t ResizeVirtualScreen(ScreenId id, uint32_t width, uint32_t height) override; 357 int32_t SetVirtualScreenResolution(ScreenId id, uint32_t width, uint32_t height) override; 358 void GetVirtualScreenResolution(ScreenId id, RSVirtualScreenResolution& virtualScreenResolution) const override; 359 360 bool SetVirtualMirrorScreenCanvasRotation(ScreenId id, bool canvasRotation) override; 361 bool GetCanvasRotation(ScreenId id) const override; 362 363 int32_t SetVirtualScreenAutoRotation(ScreenId id, bool isAutoRotation) override; 364 bool GetVirtualScreenAutoRotation(ScreenId id) const override; 365 366 bool SetVirtualMirrorScreenScaleMode(ScreenId id, ScreenScaleMode ScaleMode) override; 367 ScreenScaleMode GetScaleMode(ScreenId id) const override; 368 369 bool SetVirtualScreenStatus(ScreenId id, VirtualScreenStatus screenStatus) override; 370 VirtualScreenStatus GetVirtualScreenStatus(ScreenId id) const override; 371 372 int32_t SetCastScreenEnableSkipWindow(ScreenId id, bool enable) override; 373 int32_t SetVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) override; 374 int32_t SetVirtualScreenTypeBlackList(ScreenId id, const std::vector<uint8_t>& typeBlackList) override; 375 int32_t AddVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) override; 376 int32_t RemoveVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) override; 377 const std::unordered_set<uint64_t> GetVirtualScreenBlackList(ScreenId id) const override; 378 const std::unordered_set<uint8_t> GetVirtualScreenTypeBlackList(ScreenId id) const override; 379 std::unordered_set<uint64_t> GetAllBlackList() const override; 380 std::unordered_set<uint64_t> GetAllWhiteList() override; 381 std::unordered_set<uint64_t> GetBlackListVirtualScreenByNode(uint64_t nodeId) override; 382 383 int32_t SetVirtualScreenSecurityExemptionList( 384 ScreenId id, const std::vector<uint64_t>& securityExemptionList) override; 385 const std::vector<uint64_t> GetVirtualScreenSecurityExemptionList(ScreenId id) const override; 386 387 int32_t SetScreenSecurityMask(ScreenId id, std::shared_ptr<Media::PixelMap> securityMask) override; 388 std::shared_ptr<Media::PixelMap> GetScreenSecurityMask(ScreenId id) const override; 389 390 int32_t SetMirrorScreenVisibleRect(ScreenId id, const Rect& mainScreenRect, bool supportRotation = false) override; 391 Rect GetMirrorScreenVisibleRect(ScreenId id) const override; 392 bool IsVisibleRectSupportRotation(ScreenId id) override; 393 int32_t GetVirtualScreenSecLayerOption(ScreenId id) const override; 394 395 int32_t SetVirtualScreenRefreshRate(ScreenId id, uint32_t maxRefreshRate, uint32_t& actualRefreshRate) override; 396 // Get all whiteList and their screenId 397 std::unordered_map<ScreenId, std::unordered_set<uint64_t>> GetScreenWhiteList() const override; 398 399 void SetScreenOffset(ScreenId id, int32_t offsetX, int32_t offsetY) override; 400 bool CheckPSurfaceChanged(ScreenId id) override; 401 private: 402 RSScreenManager() = default; 403 ~RSScreenManager() override = default; 404 RSScreenManager(const RSScreenManager&) = delete; 405 RSScreenManager& operator=(const RSScreenManager&) = delete; 406 407 static void OnHotPlug(std::shared_ptr<HdiOutput>& output, bool connected, void *data); 408 void OnHotPlugEvent(std::shared_ptr<HdiOutput>& output, bool connected); 409 410 static void OnRefresh(ScreenId id, void *data); 411 void OnRefreshEvent(ScreenId id); 412 413 static void OnHwcDead(void *data); 414 void OnHwcDeadEvent(); 415 void CleanAndReinit(); 416 417 static void OnScreenVBlankIdle(uint32_t devId, uint64_t ns, void *data); 418 void OnScreenVBlankIdleEvent(uint32_t devId, uint64_t ns); 419 420 // physical screen 421 void ProcessScreenConnected(std::shared_ptr<HdiOutput>& output); 422 void ProcessPendingConnections(); 423 void ProcessScreenDisConnected(std::shared_ptr<HdiOutput>& output); 424 void HandleDefaultScreenDisConnected(); 425 426 void UpdateScreenPowerStatus(ScreenId id, ScreenPowerStatus status); 427 void ResetScreenPowerStatusTask(); 428 429 void RegSetScreenVsyncEnabledCallbackForMainThread(ScreenId vsyncEnabledScreenId); 430 void RegSetScreenVsyncEnabledCallbackForHardwareThread(ScreenId vsyncEnabledScreenId); 431 void UpdateVsyncEnabledScreenId(ScreenId screenId); 432 void UpdateFoldScreenConnectStatusLocked(ScreenId screenId, bool connected); 433 uint64_t JudgeVSyncEnabledScreenWhileHotPlug(ScreenId screenId, bool connected); 434 uint64_t JudgeVSyncEnabledScreenWhilePowerStatusChanged(ScreenId screenId, ScreenPowerStatus status); 435 void ProcessVSyncScreenIdWhilePowerStatusChanged(ScreenId id, ScreenPowerStatus status); 436 437 void AddScreenToHgm(std::shared_ptr<HdiOutput>& output); 438 void RemoveScreenFromHgm(std::shared_ptr<HdiOutput>& output); 439 440 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE 441 void RegisterSensorCallback(); 442 void UnRegisterSensorCallback(); 443 void HandleSensorData(float angle); 444 FoldState TransferAngleToScreenState(float angle); 445 #endif 446 447 std::shared_ptr<OHOS::Rosen::RSScreen> GetScreen(ScreenId id) const; 448 void TriggerCallbacks(ScreenId id, ScreenEvent event, 449 ScreenChangeReason reason = ScreenChangeReason::DEFAULT) const; 450 void NotifyScreenNodeChange(ScreenId id, bool connected) const; 451 void NotifySwitchingCallback(bool status) const; 452 453 // virtual screen 454 ScreenId GenerateVirtualScreenId(); 455 void ForceRefreshOneFrame() const; 456 457 mutable std::mutex screenMapMutex_; 458 std::map<ScreenId, std::shared_ptr<OHOS::Rosen::RSScreen>> screens_; 459 using ScreenNode = decltype(screens_)::value_type; 460 bool AnyScreenFits(std::function<bool(const ScreenNode&)> func) const; 461 462 HdiBackend *composer_ = nullptr; 463 std::atomic<ScreenId> defaultScreenId_ = INVALID_SCREEN_ID; 464 465 std::mutex virtualScreenIdMutex_; 466 std::queue<ScreenId> freeVirtualScreenIds_; 467 std::atomic<uint32_t> virtualScreenCount_ = 0; 468 std::atomic<uint32_t> currentVirtualScreenNum_ = 0; 469 470 mutable std::shared_mutex screenChangeCallbackMutex_; 471 std::vector<sptr<RSIScreenChangeCallback>> screenChangeCallbacks_; 472 mutable std::shared_mutex screenSwitchingNotifyCallbackMutex_; 473 sptr<RSIScreenSwitchingNotifyCallback> screenSwitchingNotifyCallback_; 474 std::shared_ptr<RSIScreenNodeListener> screenNodeListener_; 475 476 std::atomic<bool> mipiCheckInFirstHotPlugEvent_ = false; 477 std::atomic<bool> isHwcDead_ = false; 478 479 mutable std::mutex hotPlugAndConnectMutex_; 480 std::map<ScreenId, ScreenHotPlugEvent> pendingHotPlugEvents_; 481 std::vector<ScreenId> pendingConnectedIds_; 482 483 mutable std::shared_mutex powerStatusMutex_; 484 std::unordered_map<ScreenId, uint32_t> screenPowerStatus_; 485 std::unordered_set<ScreenId> isScreenPoweringOff_; 486 487 std::mutex syncTaskMutex_; 488 std::condition_variable statusTaskCV_; 489 bool statusTaskEndFlag_ = false; 490 491 mutable std::shared_mutex backLightAndCorrectionMutex_; 492 std::unordered_map<ScreenId, uint32_t> screenBacklight_; 493 std::unordered_map<ScreenId, ScreenRotation> screenCorrection_; 494 495 mutable std::mutex blackListMutex_; 496 std::unordered_set<uint64_t> castScreenBlackList_ = {}; 497 // a blacklist node may exist in multiple virtual screens 498 std::unordered_map<uint64_t, std::unordered_set<ScreenId>> blackListInVirtualScreen_ = {}; 499 500 mutable std::mutex typeBlackListMutex_; 501 std::unordered_set<uint8_t> castScreenTypeBlackList_ = {}; 502 503 uint64_t frameId_ = 0; // only used by SetScreenConstraint, called in hardware thread per frame 504 505 static std::once_flag createFlag_; 506 static sptr<OHOS::Rosen::RSScreenManager> instance_; 507 508 std::atomic<bool> powerOffNeedProcessOneFrame_ = false; 509 510 mutable std::mutex renderControlMutex_; 511 std::unordered_set<ScreenId> disableRenderControlScreens_ = {}; 512 513 bool isScreenPoweringOn_ = false; 514 std::atomic<bool> isScreenSwitching_ = false; 515 516 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE 517 SensorUser user; 518 bool isFoldScreenFlag_ = false; 519 ScreenId innerScreenId_ = 0; 520 ScreenId externalScreenId_ = INVALID_SCREEN_ID; 521 ScreenId activeScreenId_ = 0; 522 bool isFirstTimeToGetActiveScreenId_ = true; 523 bool isPostureSensorDataHandled_ = false; 524 std::condition_variable activeScreenIdAssignedCV_; 525 mutable std::mutex activeScreenIdAssignedMutex_; 526 #endif 527 struct FoldScreenStatus { 528 bool isConnected; 529 bool isPowerOn; 530 }; 531 std::unordered_map<uint64_t, FoldScreenStatus> foldScreenIds_; // screenId, FoldScreenStatus 532 533 mutable std::mutex whiteListMutex_; 534 std::unordered_map<ScreenId, std::unordered_set<uint64_t>> screenWhiteList_; 535 }; 536 } // namespace impl 537 } // namespace Rosen 538 } // namespace OHOS 539 540 #endif // RS_SCREEN_MANAGER 541