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