• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <cstdint>
20 #include <memory>
21 #include <mutex>
22 #include <queue>
23 #include <unordered_map>
24 #include <unordered_set>
25 #include <future>
26 
27 #include <hdi_backend.h>
28 #include <ipc_callbacks/screen_change_callback.h>
29 #include <refbase.h>
30 #include <screen_manager/rs_screen_props.h>
31 #include <screen_manager/rs_screen_mode_info.h>
32 #include <screen_manager/rs_screen_capability.h>
33 #include <screen_manager/rs_screen_data.h>
34 #include <screen_manager/rs_screen_hdr_capability.h>
35 #include <screen_manager/screen_types.h>
36 #include <screen_manager/rs_virtual_screen_resolution.h>
37 #include <screen_manager/rs_screen_info.h>
38 #include <surface.h>
39 #include <surface_type.h>
40 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
41 #include "sensor_agent.h"
42 #include "sensor_agent_type.h"
43 #endif
44 #include "rs_screen.h"
45 
46 namespace OHOS {
47 namespace Rosen {
48 class RSScreenManager : public RefBase {
49 public:
50     RSScreenManager() = default;
51     virtual ~RSScreenManager() noexcept = default;
52 
53     virtual bool Init() noexcept = 0;
54 
55     // get default/primary screen id.
56     virtual ScreenId GetDefaultScreenId() const = 0;
57 
58     virtual std::vector<ScreenId> GetAllScreenIds() const = 0;
59 
60     virtual void SetDefaultScreenId(ScreenId id) = 0;
61 
62     virtual uint32_t GetCurrentVirtualScreenNum() = 0;
63 
64     virtual void SetScreenMirror(ScreenId id, ScreenId toMirror) = 0;
65 
66     virtual ScreenId CreateVirtualScreen(
67         const std::string &name,
68         uint32_t width,
69         uint32_t height,
70         sptr<Surface> surface,
71         ScreenId mirrorId = 0,
72         int flags = 0,
73         std::vector<uint64_t> whiteList = {}) = 0;
74 
75     virtual int32_t SetVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) = 0;
76 
77     virtual int32_t AddVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) = 0;
78 
79     virtual int32_t RemoveVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) = 0;
80 
81     virtual int32_t SetVirtualScreenSecurityExemptionList(
82         ScreenId id, const std::vector<uint64_t>& securityExemptionList) = 0;
83 
84     virtual const std::vector<uint64_t> GetVirtualScreenSecurityExemptionList(ScreenId id) const = 0;
85 
86     virtual int32_t SetScreenSecurityMask(ScreenId id,
87         std::shared_ptr<Media::PixelMap> securityMask) = 0;
88 
89     virtual std::shared_ptr<Media::PixelMap> GetScreenSecurityMask(ScreenId id) const = 0;
90 
91     virtual int32_t SetMirrorScreenVisibleRect(ScreenId id, const Rect& mainScreenRect,
92         bool supportRotation = false) = 0;
93 
94     virtual Rect GetMirrorScreenVisibleRect(ScreenId id) const = 0;
95 
96     virtual int32_t SetCastScreenEnableSkipWindow(ScreenId id, bool enable) = 0;
97 
98     virtual const std::unordered_set<uint64_t> GetVirtualScreenBlackList(ScreenId id) const = 0;
99 
100     virtual std::unordered_set<uint64_t> GetAllBlackList() const = 0;
101 
102     virtual std::unordered_set<uint64_t> GetAllWhiteList() const = 0;
103 
104     virtual int32_t SetVirtualScreenSurface(ScreenId id, sptr<Surface> surface) = 0;
105 
106     virtual bool GetAndResetVirtualSurfaceUpdateFlag(ScreenId id) const = 0;
107 
108     virtual void RemoveVirtualScreen(ScreenId id) = 0;
109 
110     virtual uint32_t SetScreenActiveMode(ScreenId id, uint32_t modeId) = 0;
111 
112     virtual uint32_t SetScreenActiveRect(ScreenId id, const GraphicIRect& activeRect) = 0;
113 
114     virtual int32_t SetRogScreenResolution(ScreenId id, uint32_t width, uint32_t height) = 0;
115 
116     virtual int32_t SetPhysicalScreenResolution(ScreenId id, uint32_t width, uint32_t height) = 0;
117 
118     virtual int32_t SetVirtualScreenResolution(ScreenId id, uint32_t width, uint32_t height) = 0;
119 
120     virtual void SetScreenPowerStatus(ScreenId id, ScreenPowerStatus status) = 0;
121 
122     virtual bool SetVirtualMirrorScreenCanvasRotation(ScreenId id, bool canvasRotation) = 0;
123 
124     virtual bool SetVirtualMirrorScreenScaleMode(ScreenId id, ScreenScaleMode ScaleMode) = 0;
125 
126     virtual int32_t SetScreenCorrection(ScreenId id, ScreenRotation screenRotation) = 0;
127 
128     virtual void GetVirtualScreenResolution(ScreenId id, RSVirtualScreenResolution& virtualScreenResolution) const = 0;
129 
130     virtual void GetScreenActiveMode(ScreenId id, RSScreenModeInfo& screenModeInfo) const = 0;
131 
132     virtual std::vector<RSScreenModeInfo> GetScreenSupportedModes(ScreenId id) const = 0;
133 
134     virtual RSScreenCapability GetScreenCapability(ScreenId id) const = 0;
135 
136     virtual ScreenPowerStatus GetScreenPowerStatus(ScreenId id) const = 0;
137 
138     virtual ScreenRotation GetScreenCorrection(ScreenId id) const = 0;
139 
140     virtual RSScreenData GetScreenData(ScreenId id) const = 0;
141 
142     virtual ScreenInfo QueryDefaultScreenInfo() const = 0;
143 
144     virtual ScreenInfo QueryScreenInfo(ScreenId id) const = 0;
145 
146     // Can only be called after QueryScreenState and the state is ScreenState::SOFTWARE_OUTPUT_ENABLE;
147     virtual sptr<Surface> GetProducerSurface(ScreenId id) const = 0;
148 
149     virtual bool GetCanvasRotation(ScreenId id) const = 0;
150 
151     virtual ScreenScaleMode GetScaleMode(ScreenId id) const = 0;
152 
153     // Can only be called after QueryScreenState and the state is ScreenState::HDI_OUTPUT_ENABLE;
154     virtual std::shared_ptr<HdiOutput> GetOutput(ScreenId id) const = 0;
155 
156     virtual int32_t AddScreenChangeCallback(const sptr<RSIScreenChangeCallback> &callback) = 0;
157 
158     virtual void RemoveScreenChangeCallback(const sptr<RSIScreenChangeCallback> &callback) = 0;
159 
160     virtual void ProcessScreenHotPlugEvents() = 0;
161 
162     virtual bool TrySimpleProcessHotPlugEvents() = 0;
163 
164     virtual void DisplayDump(std::string& dumpString) = 0;
165 
166     virtual void SurfaceDump(std::string& dumpString) = 0;
167 
168     virtual void FpsDump(std::string& dumpString, std::string& arg) = 0;
169 
170     virtual void ClearFpsDump(std::string& dumpString, std::string& arg) = 0;
171 
172     virtual void HitchsDump(std::string& dumpString, std::string& arg) = 0;
173 
174     virtual int32_t ResizeVirtualScreen(ScreenId id, uint32_t width, uint32_t height) = 0;
175 
176     virtual int32_t GetScreenBacklight(ScreenId id) const = 0;
177 
178     virtual void SetScreenBacklight(ScreenId id, uint32_t level) = 0;
179 
180     virtual int32_t GetScreenSupportedColorGamuts(ScreenId id, std::vector<ScreenColorGamut>& mode) const = 0;
181 
182     virtual int32_t GetScreenSupportedMetaDataKeys(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) const = 0;
183 
184     virtual int32_t GetScreenColorGamut(ScreenId id, ScreenColorGamut& mode) const = 0;
185 
186     virtual int32_t SetScreenColorGamut(ScreenId id, int32_t modeIdx) = 0;
187 
188     virtual int32_t SetScreenGamutMap(ScreenId id, ScreenGamutMap mode) = 0;
189 
190     virtual int32_t GetScreenGamutMap(ScreenId id, ScreenGamutMap& mode) const = 0;
191 
192     virtual int32_t GetScreenHDRCapability(ScreenId id, RSScreenHDRCapability& screenHdrCapability) const = 0;
193 
194     virtual int32_t GetScreenType(ScreenId id, RSScreenType& type) const = 0;
195 
196     virtual int32_t SetScreenSkipFrameInterval(ScreenId id, uint32_t skipFrameInterval) = 0;
197 
198     virtual int32_t GetPixelFormat(ScreenId id, GraphicPixelFormat& pixelFormat) const = 0;
199 
200     virtual int32_t SetPixelFormat(ScreenId id, GraphicPixelFormat pixelFormat) = 0;
201 
202     virtual int32_t GetScreenSupportedHDRFormats(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) const = 0;
203 
204     virtual int32_t GetScreenHDRFormat(ScreenId id, ScreenHDRFormat& hdrFormat) const = 0;
205 
206     virtual int32_t SetScreenHDRFormat(ScreenId id, int32_t modeIdx) = 0;
207 
208     virtual int32_t GetScreenSupportedColorSpaces(
209         ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const = 0;
210 
211     virtual int32_t GetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) const = 0;
212 
213     virtual uint32_t GetActualScreensNum() const = 0;
214 
215     virtual ScreenInfo GetActualScreenMaxResolution() const = 0;
216 
217     virtual int32_t SetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType colorSpace) = 0;
218 
219     virtual ScreenId GetActiveScreenId() = 0;
220 
221     virtual int32_t SetVirtualScreenRefreshRate(ScreenId id, uint32_t maxRefreshRate, uint32_t& actualRefreshRate) = 0;
222 
223     virtual void SetEqualVsyncPeriod(ScreenId id, bool isEqualVsyncPeriod) = 0;
224 
225     /* only used for mock tests */
226     virtual void MockHdiScreenConnected(std::unique_ptr<impl::RSScreen>& rsScreen) = 0;
227 
228     virtual bool IsAllScreensPowerOff() const = 0;
229 
230     // used to skip render frame or render only one frame when screen power is off.
231     virtual void MarkPowerOffNeedProcessOneFrame() = 0;
232 
233     virtual void ResetPowerOffNeedProcessOneFrame() = 0;
234 
235     virtual bool GetPowerOffNeedProcessOneFrame() const = 0;
236 
237     virtual bool IsScreenPowerOff(ScreenId id) const = 0;
238 
239     virtual void DisablePowerOffRenderControl(ScreenId id) = 0;
240 
241     virtual int GetDisableRenderControlScreensCount() const = 0;
242 
243     virtual int32_t GetDisplayIdentificationData(ScreenId id, uint8_t& outPort,
244         std::vector<uint8_t>& edidData) const = 0;
245 
246 #ifdef USE_VIDEO_PROCESSING_ENGINE
247     virtual float GetScreenBrightnessNits(ScreenId id) const = 0;
248 #endif
249 
250 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
251     virtual void HandlePostureData(const SensorEvent * const event) = 0;
252 #endif
253     virtual void PostForceRefreshTask() = 0;
254 
255     virtual void RemoveForceRefreshTask() = 0;
256 
257     virtual void ClearFrameBufferIfNeed() = 0;
258 
259     virtual int32_t SetScreenConstraint(ScreenId id, uint64_t timestamp, ScreenConstraintType type) = 0;
260 
261     virtual void GetDefaultScreenActiveMode(RSScreenModeInfo& screenModeInfo) const = 0;
262 
263     virtual bool SetVirtualScreenStatus(ScreenId id, VirtualScreenStatus screenStatus) = 0;
264     virtual VirtualScreenStatus GetVirtualScreenStatus(ScreenId id) const = 0;
265 
266     virtual bool GetDisplayPropertyForHardCursor(uint32_t screenId) = 0;
267 
268     virtual bool IsScreenPoweringOn() const = 0;
269 
270     virtual bool IsVisibleRectSupportRotation(ScreenId id) const = 0;
271 
272     virtual void SetScreenHasProtectedLayer(ScreenId id, bool hasProtectedLayer) = 0;
273 
274     virtual void SetScreenSwitchStatus(bool flag) = 0;
275 
276     virtual bool IsScreenSwitching() const = 0;
277 
278     virtual int32_t SetScreenLinearMatrix(ScreenId id, const std::vector<float>& matrix) = 0;
279 };
280 
281 sptr<RSScreenManager> CreateOrGetScreenManager();
282 
283 namespace impl {
284 struct ScreenHotPlugEvent {
285     std::shared_ptr<HdiOutput> output;
286     bool connected = false;
287 };
288 
289 enum class FoldState : uint32_t {
290     UNKNOW,
291     FOLDED,
292     EXPAND
293 };
294 
295 class RSScreenManager : public OHOS::Rosen::RSScreenManager {
296 public:
297     static sptr<OHOS::Rosen::RSScreenManager> GetInstance() noexcept;
298 
299     // noncopyable
300     RSScreenManager(const RSScreenManager &) = delete;
301     RSScreenManager &operator=(const RSScreenManager &) = delete;
302 
303     bool Init() noexcept override;
304 
305     ScreenId GetDefaultScreenId() const override;
306 
307     std::vector<ScreenId> GetAllScreenIds() const override;
308 
309     void SetDefaultScreenId(ScreenId id) override;
310 
311     void SetScreenMirror(ScreenId id, ScreenId toMirror) override;
312 
313     ScreenId CreateVirtualScreen(
314         const std::string &name,
315         uint32_t width,
316         uint32_t height,
317         sptr<Surface> surface,
318         ScreenId mirrorId,
319         int32_t flags,
320         std::vector<uint64_t> whiteList) override;
321 
322     int32_t SetVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) override;
323 
324     int32_t AddVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) override;
325 
326     int32_t RemoveVirtualScreenBlackList(ScreenId id, const std::vector<uint64_t>& blackList) override;
327 
328     int32_t SetVirtualScreenSecurityExemptionList(
329         ScreenId id, const std::vector<uint64_t>& securityExemptionList) override;
330 
331     const std::vector<uint64_t> GetVirtualScreenSecurityExemptionList(ScreenId id) const override;
332 
333     int32_t SetMirrorScreenVisibleRect(ScreenId id, const Rect& mainScreenRect, bool supportRotation = false) override;
334 
335     int32_t SetScreenSecurityMask(ScreenId id, std::shared_ptr<Media::PixelMap> securityMask) override;
336 
337     std::shared_ptr<Media::PixelMap> GetScreenSecurityMask(ScreenId id) const override;
338 
339     Rect GetMirrorScreenVisibleRect(ScreenId id) const override;
340 
341     int32_t SetCastScreenEnableSkipWindow(ScreenId id, bool enable) override;
342 
343     const std::unordered_set<uint64_t> GetVirtualScreenBlackList(ScreenId id) const override;
344 
345     std::unordered_set<uint64_t> GetAllBlackList() const override;
346 
347     std::unordered_set<uint64_t> GetAllWhiteList() const override;
348 
349     int32_t SetVirtualScreenSurface(ScreenId id, sptr<Surface> surface) override;
350 
351     bool GetAndResetVirtualSurfaceUpdateFlag(ScreenId id) const override;
352 
353     void RemoveVirtualScreen(ScreenId id) override;
354 
355     uint32_t SetScreenActiveMode(ScreenId id, uint32_t modeId) override;
356 
357     uint32_t SetScreenActiveRect(ScreenId id, const GraphicIRect& activeRect) override;
358 
359     int32_t SetRogScreenResolution(ScreenId id, uint32_t width, uint32_t height) override;
360 
361     int32_t SetPhysicalScreenResolution(ScreenId id, uint32_t width, uint32_t height) override;
362 
363     int32_t SetVirtualScreenResolution(ScreenId id, uint32_t width, uint32_t height) override;
364 
365     void SetScreenPowerStatus(ScreenId id, ScreenPowerStatus status) override;
366 
367     bool SetVirtualMirrorScreenCanvasRotation(ScreenId id, bool canvasRotation) override;
368 
369     bool SetVirtualMirrorScreenScaleMode(ScreenId id, ScreenScaleMode ScaleMode) override;
370 
371     void GetVirtualScreenResolution(ScreenId id, RSVirtualScreenResolution& virtualScreenResolution) const override;
372 
373     void GetScreenActiveMode(ScreenId id, RSScreenModeInfo& screenModeInfo) const override;
374 
375     std::vector<RSScreenModeInfo> GetScreenSupportedModes(ScreenId id) const override;
376 
377     RSScreenCapability GetScreenCapability(ScreenId id) const override;
378 
379     ScreenPowerStatus GetScreenPowerStatus(ScreenId id) const override;
380 
381     ScreenRotation GetScreenCorrection(ScreenId id) const override;
382 
383     RSScreenData GetScreenData(ScreenId id) const  override;
384 
385     ScreenInfo QueryDefaultScreenInfo() const override;
386 
387     ScreenInfo QueryScreenInfo(ScreenId id) const override;
388 
389     sptr<Surface> GetProducerSurface(ScreenId id) const override;
390 
391     bool GetCanvasRotation(ScreenId id) const override;
392 
393     ScreenScaleMode GetScaleMode(ScreenId id) const override;
394 
395     std::shared_ptr<HdiOutput> GetOutput(ScreenId id) const override;
396 
397     int32_t AddScreenChangeCallback(const sptr<RSIScreenChangeCallback> &callback) override;
398 
399     void RemoveScreenChangeCallback(const sptr<RSIScreenChangeCallback> &callback) override;
400 
401     void ProcessScreenHotPlugEvents() override;
402 
403     bool TrySimpleProcessHotPlugEvents() override;
404 
405     void DisplayDump(std::string& dumpString) override;
406 
407     void SurfaceDump(std::string& dumpString) override;
408 
409     void FpsDump(std::string& dumpString, std::string& arg) override;
410 
411     void ClearFpsDump(std::string& dumpString, std::string& arg) override;
412 
413     void HitchsDump(std::string& dumpString, std::string& arg) override;
414 
415     int32_t ResizeVirtualScreen(ScreenId id, uint32_t width, uint32_t height) override;
416 
417     int32_t GetScreenBacklight(ScreenId id) const override;
418 
419     void SetScreenBacklight(ScreenId id, uint32_t level) override;
420 
421     int32_t GetScreenSupportedColorGamuts(ScreenId id, std::vector<ScreenColorGamut>& mode) const override;
422 
423     int32_t GetScreenSupportedMetaDataKeys(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) const override;
424 
425     int32_t GetScreenColorGamut(ScreenId id, ScreenColorGamut& mode) const override;
426 
427     uint32_t GetActualScreensNum() const override;
428 
429     ScreenInfo GetActualScreenMaxResolution() const override;
430 
431     int32_t SetScreenColorGamut(ScreenId id, int32_t modeIdx) override;
432 
433     int32_t SetScreenGamutMap(ScreenId id, ScreenGamutMap mode) override;
434 
435     int32_t SetScreenCorrection(ScreenId id, ScreenRotation screenRotation) override;
436 
437     int32_t GetScreenGamutMap(ScreenId id, ScreenGamutMap& mode) const override;
438 
439     int32_t GetScreenHDRCapability(ScreenId id, RSScreenHDRCapability& screenHdrCapability) const override;
440 
441     int32_t GetScreenType(ScreenId id, RSScreenType& type) const override;
442 
443     int32_t SetScreenSkipFrameInterval(ScreenId id, uint32_t skipFrameInterval) override;
444 
445     int32_t GetPixelFormat(ScreenId id, GraphicPixelFormat& pixelFormat) const override;
446 
447     int32_t SetPixelFormat(ScreenId id, GraphicPixelFormat pixelFormat) override;
448 
449     int32_t GetScreenSupportedHDRFormats(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) const override;
450 
451     int32_t GetScreenHDRFormat(ScreenId id, ScreenHDRFormat& hdrFormat) const override;
452 
453     int32_t SetScreenHDRFormat(ScreenId id, int32_t modeIdx) override;
454 
455     int32_t GetScreenSupportedColorSpaces(
456         ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const override;
457 
458     int32_t GetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) const override;
459 
460     int32_t SetScreenColorSpace(ScreenId id, GraphicCM_ColorSpaceType colorSpace) override;
461 
462     ScreenId GetActiveScreenId() override;
463 
464     int32_t SetVirtualScreenRefreshRate(ScreenId id, uint32_t maxRefreshRate, uint32_t& actualRefreshRate) override;
465 
466     void SetEqualVsyncPeriod(ScreenId id, bool isEqualVsyncPeriod) override;
467 
468     int32_t GetDisplayIdentificationData(ScreenId id, uint8_t& outPort,
469         std::vector<uint8_t>& edidData) const override;
470 
471     /* only used for mock tests */
MockHdiScreenConnected(std::unique_ptr<impl::RSScreen> & rsScreen)472     void MockHdiScreenConnected(std::unique_ptr<impl::RSScreen>& rsScreen) override
473     {
474         if (rsScreen == nullptr) {
475             return;
476         }
477         screens_[rsScreen->Id()] = std::move(rsScreen);
478     }
479 
480     bool IsAllScreensPowerOff() const override;
481 
482     // used to skip render frame or render only one frame when screen power is off.
483     void MarkPowerOffNeedProcessOneFrame() override;
484 
485     void ResetPowerOffNeedProcessOneFrame() override;
486 
487     bool GetPowerOffNeedProcessOneFrame() const override;
488 
489     bool IsScreenPowerOff(ScreenId id) const override;
490 
491     void DisablePowerOffRenderControl(ScreenId id) override;
492 
493     int GetDisableRenderControlScreensCount() const override;
494 
495 #ifdef USE_VIDEO_PROCESSING_ENGINE
496     float GetScreenBrightnessNits(ScreenId id) const override;
497 #endif
498 
499 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
500     void HandlePostureData(const SensorEvent * const event) override;
501 #endif
502     void PostForceRefreshTask() override;
503 
504     void RemoveForceRefreshTask() override;
505 
506     void ClearFrameBufferIfNeed() override;
507 
508     int32_t SetScreenConstraint(ScreenId id, uint64_t timestamp, ScreenConstraintType type) override;
509 
510     void GetDefaultScreenActiveMode(RSScreenModeInfo& screenModeInfo) const override;
511 
512     bool SetVirtualScreenStatus(ScreenId id, VirtualScreenStatus screenStatus) override;
513     VirtualScreenStatus GetVirtualScreenStatus(ScreenId id) const override;
514 
515     static void ReleaseScreenDmaBuffer(uint64_t screenId);
516 
517     bool GetDisplayPropertyForHardCursor(uint32_t screenId) override;
518 
GetCurrentVirtualScreenNum()519     uint32_t GetCurrentVirtualScreenNum() override
520     {
521         return currentVirtualScreenNum_;
522     }
523 
IsScreenPoweringOn()524     bool IsScreenPoweringOn() const override
525     {
526         return isScreenPoweringOn_;
527     }
528 
529     void SetScreenHasProtectedLayer(ScreenId id, bool hasProtectedLayer) override;
530 
531     bool IsVisibleRectSupportRotation(ScreenId id) const override;
532 
533     void SetScreenSwitchStatus(bool flag) override;
534 
535     bool IsScreenSwitching() const override;
536 
537     int32_t SetScreenLinearMatrix(ScreenId id, const std::vector<float>& matrix) override;
538 
539 private:
540     RSScreenManager();
541     ~RSScreenManager() noexcept override;
542 
543     static void OnHotPlug(std::shared_ptr<HdiOutput> &output, bool connected, void *data);
544     void OnHotPlugEvent(std::shared_ptr<HdiOutput> &output, bool connected);
545     static void OnRefresh(ScreenId id, void *data);
546     void OnRefreshEvent(ScreenId id);
547     static void OnHwcDead(void *data);
548     void OnHwcDeadEvent();
549     static void OnScreenVBlankIdle(uint32_t devId, uint64_t ns, void *data);
550     void OnScreenVBlankIdleEvent(uint32_t devId, uint64_t ns);
551     void CleanAndReinit();
552     void ProcessScreenConnected(std::shared_ptr<HdiOutput> &output);
553     void AddScreenToHgm(std::shared_ptr<HdiOutput> &output);
554     void ProcessScreenDisConnected(std::shared_ptr<HdiOutput> &output);
555     void RemoveScreenFromHgm(std::shared_ptr<HdiOutput> &output);
556     void ProcessPendingConnections();
557     void HandleDefaultScreenDisConnected();
558     void ForceRefreshOneFrame() const;
559 
560     void GetVirtualScreenResolutionLocked(ScreenId id, RSVirtualScreenResolution& virtualScreenResolution) const;
561     RSScreenCapability GetScreenCapabilityLocked(ScreenId id) const;
562     ScreenRotation GetScreenCorrectionLocked(ScreenId id) const;
563 
564     void RemoveVirtualScreenLocked(ScreenId id);
565     ScreenId GenerateVirtualScreenIdLocked();
566     void ReuseVirtualScreenIdLocked(ScreenId id);
567 
568     int32_t GetScreenSupportedColorGamutsLocked(ScreenId id, std::vector<ScreenColorGamut>& mode) const;
569     int32_t GetScreenSupportedMetaDataKeysLocked(ScreenId id, std::vector<ScreenHDRMetadataKey>& keys) const;
570     int32_t GetScreenColorGamutLocked(ScreenId id, ScreenColorGamut& mode) const;
571     int32_t GetScreenGamutMapLocked(ScreenId id, ScreenGamutMap& mode) const;
572     int32_t GetScreenHDRCapabilityLocked(ScreenId id, RSScreenHDRCapability& screenHdrCapability) const;
573     int32_t GetScreenTypeLocked(ScreenId id, RSScreenType& type) const;
574     int32_t GetPixelFormatLocked(ScreenId id, GraphicPixelFormat& pixelFormat) const;
575     int32_t SetPixelFormatLocked(ScreenId id, GraphicPixelFormat pixelFormat);
576     int32_t GetScreenSupportedHDRFormatsLocked(ScreenId id, std::vector<ScreenHDRFormat>& hdrFormats) const;
577     int32_t GetScreenHDRFormatLocked(ScreenId id, ScreenHDRFormat& hdrFormat) const;
578     int32_t SetScreenHDRFormatLocked(ScreenId id, int32_t modeIdx);
579     int32_t GetScreenSupportedColorSpacesLocked(ScreenId id, std::vector<GraphicCM_ColorSpaceType>& colorSpaces) const;
580     int32_t GetScreenColorSpaceLocked(ScreenId id, GraphicCM_ColorSpaceType& colorSpace) const;
581     ScreenInfo QueryScreenInfoLocked(ScreenId id) const;
582     bool GetCastScreenEnableSkipWindow(ScreenId id) const;
583 
584 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
585     void RegisterSensorCallback();
586     void UnRegisterSensorCallback();
587     void HandleSensorData(float angle);
588     FoldState TransferAngleToScreenState(float angle);
589 #endif
590 
591     void RegSetScreenVsyncEnabledCallbackForMainThread(ScreenId vsyncEnabledScreenId);
592     void RegSetScreenVsyncEnabledCallbackForHardwareThread(ScreenId vsyncEnabledScreenId);
593     void UpdateVsyncEnabledScreenId(ScreenId screenId);
594 
595     void TriggerCallbacks(ScreenId id, ScreenEvent event,
596         ScreenChangeReason reason = ScreenChangeReason::DEFAULT) const;
597     std::shared_ptr<OHOS::Rosen::RSScreen> GetScreen(ScreenId id) const;
598     void UpdateFoldScreenConnectStatusLocked(ScreenId screenId, bool connected);
599     uint64_t JudgeVSyncEnabledScreenWhileHotPlug(ScreenId screenId, bool connected);
600     uint64_t JudgeVSyncEnabledScreenWhilePowerStatusChanged(ScreenId screenId, ScreenPowerStatus status);
601 
602     mutable std::mutex mutex_;
603     mutable std::mutex renderControlMutex_;
604     HdiBackend *composer_ = nullptr;
605     std::atomic<ScreenId> defaultScreenId_ = INVALID_SCREEN_ID;
606     std::map<ScreenId, std::shared_ptr<OHOS::Rosen::RSScreen>> screens_;
607     std::queue<ScreenId> freeVirtualScreenIds_;
608     uint32_t virtualScreenCount_ = 0;
609     uint32_t currentVirtualScreenNum_ = 0;
610 
611     mutable std::shared_mutex screenChangeCallbackMutex_;
612     std::vector<sptr<RSIScreenChangeCallback>> screenChangeCallbacks_;
613     std::atomic<bool> mipiCheckInFirstHotPlugEvent_ = false;
614     std::atomic<bool> isHwcDead_ = false;
615 
616     mutable std::mutex hotPlugAndConnectMutex_;
617     std::map<ScreenId, ScreenHotPlugEvent> pendingHotPlugEvents_;
618     std::vector<ScreenId> pendingConnectedIds_;
619 
620     mutable std::shared_mutex powerStatusMutex_;
621     std::unordered_map<ScreenId, uint32_t> screenPowerStatus_;
622 
623     mutable std::shared_mutex backLightAndCorrectionMutex_;
624     std::unordered_map<ScreenId, uint32_t> screenBacklight_;
625     std::unordered_map<ScreenId, ScreenRotation> screenCorrection_;
626 
627     std::unordered_set<uint64_t> castScreenBlackList_ = {};
628 
629     static std::once_flag createFlag_;
630     static sptr<OHOS::Rosen::RSScreenManager> instance_;
631 
632     uint64_t frameId_ = 0;
633     std::atomic<bool> powerOffNeedProcessOneFrame_ = false;
634     std::unordered_set<ScreenId> disableRenderControlScreens_ = {};
635     bool isScreenPoweringOn_ = false;
636     std::atomic<bool> isScreenSwitching_ = false;
637 
638 #ifdef RS_SUBSCRIBE_SENSOR_ENABLE
639     SensorUser user;
640     bool isFoldScreenFlag_ = false;
641     ScreenId innerScreenId_ = 0;
642     ScreenId externalScreenId_ = INVALID_SCREEN_ID;
643     ScreenId activeScreenId_ = 0;
644     bool isFirstTimeToGetActiveScreenId_ = true;
645     bool isPostureSensorDataHandled_ = false;
646     std::condition_variable activeScreenIdAssignedCV_;
647     mutable std::mutex activeScreenIdAssignedMutex_;
648 #endif
649     struct FoldScreenStatus {
650         bool isConnected;
651         bool isPowerOn;
652     };
653     std::unordered_map<uint64_t, FoldScreenStatus> foldScreenIds_; // screenId, FoldScreenStatus
654 };
655 } // namespace impl
656 } // namespace Rosen
657 } // namespace OHOS
658 #endif // RS_SCREEN_MANAGER
659