1/*
2 * Copyright (c) 2021-2022 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 FOUNDATION_DM_DISPLAY_MANAGER_H
17#define FOUNDATION_DM_DISPLAY_MANAGER_H
18
19#include <vector>
20#include <mutex>
21#include <ipc_skeleton.h>
22#include <pixel_map.h>
23#include <set>
24
25#include "display.h"
26#include "dm_common.h"
27#include "fold_screen_info.h"
28#include "wm_single_instance.h"
29#include "screenshot_info.h"
30#include "display_change_info.h"
31
32namespace OHOS::Rosen {
33class DisplayManager {
34WM_DECLARE_SINGLE_INSTANCE_BASE(DisplayManager);
35friend class DMSDeathRecipient;
36public:
37    class IDisplayListener : public virtual RefBase {
38    public:
39        /**
40         * @brief Notify when a new display is created.
41         */
42        virtual void OnCreate(DisplayId) = 0;
43
44        /**
45         * @brief Notify when the display is destroyed.
46         */
47        virtual void OnDestroy(DisplayId) = 0;
48
49        /**
50         * @brief Notify when the state of a display changes
51         */
52        virtual void OnChange(DisplayId) = 0;
53    };
54
55    class IScreenshotListener : public virtual RefBase {
56    public:
57        /**
58         * @brief Notify when a screenshot event occurs.
59         *
60         * @param info Screenshot info.
61         */
62        virtual void OnScreenshot([[maybe_unused]]const ScreenshotInfo info) {}
63    };
64
65    class IPrivateWindowListener : public virtual RefBase {
66    public:
67        /**
68         * @brief Monitor whether the existence of privacy window has changed.
69         *
70         * @param hasPrivate True means the display has private window, false means the opposite.
71         */
72        virtual void OnPrivateWindow([[maybe_unused]]bool hasPrivate) {}
73    };
74
75    class IPrivateWindowListChangeListener : public virtual RefBase {
76    public:
77        /**
78         * @brief Monitor whether the existence of privacy window list has changed.
79         *
80         * @param displayId Id of the target display.
81         *
82         * @param privacyWindowList privacywindow bundlename list of the target display.
83         */
84        virtual void OnPrivateWindowListChange([[maybe_unused]]DisplayId displayId,
85            [[maybe_unused]]std::vector<std::string> privacyWindowList) {}
86
87        /**
88         * @brief only for UT to compare privacy window list.
89         *
90         * @param callback callback.
91         */
92        virtual void setCallback([[maybe_unused]]std::function<void(std::vector<std::string>)> callback) {}
93    private:
94        std::function<void(std::vector<std::string>)> callback_;
95    };
96
97    class IFoldStatusListener : public virtual RefBase {
98    public:
99        /**
100         * @brief Notify listeners when screen fold status changed.
101         *
102         * @param foldStatus Screen foldStatus.
103         */
104        virtual void OnFoldStatusChanged([[maybe_unused]]FoldStatus foldStatus) {}
105    };
106
107    class IFoldAngleListener : public virtual RefBase {
108    public:
109        /**
110         * @brief Notify listeners when screen fold angles changed.
111         *
112         * @param foldAngles Screen fold angles array.
113         */
114        virtual void OnFoldAngleChanged([[maybe_unused]]std::vector<float> foldAngles) {}
115    };
116
117    class ICaptureStatusListener : public virtual RefBase {
118    public:
119        /**
120         * @brief Notify listeners when screen capture status changed.
121         *
122         * @param isCapture Screen capture status.
123         */
124        virtual void OnCaptureStatusChanged([[maybe_unused]]bool isCapture) {}
125    };
126
127    class IDisplayUpdateListener : public virtual RefBase {
128    public:
129        /**
130         * @brief Notify listeners when session change display.
131         *
132         * @param infos DisplayChangeInfo.
133         */
134        virtual void OnDisplayUpdate([[maybe_unused]]const sptr<DisplayChangeInfo>& info) {}
135    };
136
137    class IDisplayModeListener : public virtual RefBase {
138    public:
139        /**
140         * @brief Notify listeners when display mode changed.
141         *
142         * @param displayMode DisplayMode.
143         */
144        virtual void OnDisplayModeChanged([[maybe_unused]]FoldDisplayMode displayMode) {}
145    };
146
147    class IAvailableAreaListener : public virtual RefBase {
148    public:
149        /**
150         * @brief Notify listeners when available area changed.
151         *
152         * @param DMRect area.
153         */
154        virtual void OnAvailableAreaChanged(DMRect area) {}
155    };
156
157    /**
158     * @brief Obtain all displays.
159     *
160     * @return All displays.
161     */
162    std::vector<sptr<Display>> GetAllDisplays();
163
164    /**
165     * @brief Obtain the id of the default display.
166     *
167     * @return Default display id.
168     */
169    DisplayId GetDefaultDisplayId();
170
171    /**
172     * @brief Get the default display object.
173     *
174     * @return Default display object.
175     */
176    sptr<Display> GetDefaultDisplay();
177
178    /**
179     * @brief Get the default display object by means of sync.
180     *
181     * @return Default display id.
182     */
183    sptr<Display> GetDefaultDisplaySync(bool isFromNapi = false);
184
185    /**
186     * @brief Get the display object by id.
187     *
188     * @param displayId Id of the target display.
189     * @return Default display object.
190     */
191    sptr<Display> GetDisplayById(DisplayId displayId);
192
193    /**
194     * @brief Get the display object by corresponding screenId.
195     *
196     * @param screenId The id of the target screen.
197     * @return Display object.
198     */
199    sptr<Display> GetDisplayByScreen(ScreenId screenId);
200
201    /**
202     * @brief Get IDs of all displays.
203     *
204     * @return All display IDs.
205     */
206    std::vector<DisplayId> GetAllDisplayIds();
207
208    /**
209     * @brief Get whether the target display contains privacy windows.
210     *
211     * @param displayId Display id.
212     * @param hasPrivateWindow True means display has private window, false means the opposite.
213     * @return DM_OK means query privacy success, others means query failed.
214     */
215    DMError HasPrivateWindow(DisplayId displayId, bool& hasPrivateWindow);
216
217    /**
218     * @brief Get screenshot of the target display.
219     *
220     * @param displayId Display id.
221     * @param errorCode error code.
222     * @return PixelMap object of screenshot.
223     */
224    std::shared_ptr<Media::PixelMap> GetScreenshot(DisplayId displayId, DmErrorCode* errorCode = nullptr);
225
226    /**
227     * @brief Get screenshot by user select area.
228     *
229     * @param rect user select area.
230     * @param errorCode error code.
231     * @return PixelMap object of screenshot.
232     */
233    std::shared_ptr<Media::PixelMap> GetSnapshotByPicker(Media::Rect &rect, DmErrorCode* errorCode = nullptr);
234
235    /**
236     * @brief Get screenshot of the target display.
237     *
238     * @param displayId Display id.
239     * @param rect Rect of screenshot.
240     * @param size Size of screenshot.
241     * @param rotation Parameter of rotation.
242     * @param errorCode error code.
243     * @return PixelMap object of screenshot.
244     */
245    std::shared_ptr<Media::PixelMap> GetScreenshot(DisplayId displayId, const Media::Rect &rect,
246        const Media::Size &size, int rotation, DmErrorCode* errorCode = nullptr);
247
248    /**
249     * @brief Begin to wake up screen.
250     *
251     * @param reason Reason for power state change.
252     * @return True means begin success, false means begin failed.
253     */
254    bool WakeUpBegin(PowerStateChangeReason reason);
255
256    /**
257     * @brief Wake up screen end.
258     *
259     * @return True means end success, false means end failed.
260     */
261    bool WakeUpEnd();
262
263    /**
264     * @brief Begin to suspend the screen.
265     *
266     * @param reason Reason for power state change.
267     * @return True means begin success, false means begin failed.
268     */
269    bool SuspendBegin(PowerStateChangeReason reason);
270
271    /**
272     * @brief Suspend screen end.
273     *
274     * @return True means suspend screen end success.
275     * @return False means suspend screen end failed.
276     */
277    bool SuspendEnd();
278
279    /**
280     * @brief Get id of internal screen.
281     *
282     * @return Internal screen id.
283     */
284    ScreenId GetInternalScreenId();
285
286    /**
287     * @brief Set the screen power state by screen id.
288     *
289     * @param screenId Screen id.
290     * @param state Screen power state.
291     * @param reason Reason for power state change.
292     * @return True means set success, false means set failed.
293     */
294    bool SetScreenPowerById(ScreenId screenId, ScreenPowerState state, PowerStateChangeReason reason);
295
296    /**
297     * @brief Set the Display State object
298     *
299     * @param state State of display.
300     * @param callback Callback for display state.
301     * @return True means set success, false means set failed.
302     */
303    bool SetDisplayState(DisplayState state, DisplayStateCallback callback);
304
305    /**
306     * @brief Get the state of the target display.
307     *
308     * @param displayId Display id.
309     * @return State of display.
310     */
311    DisplayState GetDisplayState(DisplayId displayId);
312
313    /**
314     * @brief Try to cancel screenoff action before display power off.
315     *
316     * @return True means cancel screenoff action success.
317     * @return False means cancel screenoff action failed.
318     */
319    bool TryToCancelScreenOff();
320
321    /**
322     * @brief Set the brightness level of the target screen.
323     *
324     * @param screenId Target screen.
325     * @param level Brightness level.
326     */
327    bool SetScreenBrightness(uint64_t screenId, uint32_t level);
328
329    /**
330     * @brief Get the brightness level of the target screen.
331     *
332     * @param screenId Screen id.
333     * @return Brightness value of screen.
334     */
335    uint32_t GetScreenBrightness(uint64_t screenId) const;
336
337    /**
338     * @brief Notify when events of certain types occur.
339     *
340     * @param event Enumerate value of DisplayEvent.
341     */
342    void NotifyDisplayEvent(DisplayEvent event);
343
344    /**
345     * @brief Freeze target displays.
346     *
347     * @param displayIds Display id needed to freeze.
348     * @return True means freeze success, false means freeze failed.
349     */
350    bool Freeze(std::vector<DisplayId> displayIds);
351
352    /**
353     * @brief Unfreeze target displays.
354     *
355     * @param displayIds Display id needed to unfreeze.
356     * @return True means unfreeze success, false means unfreeze failed.
357     */
358    bool Unfreeze(std::vector<DisplayId> displayIds);
359
360    /**
361     * @brief Register a display listener.
362     *
363     * @param listener IDisplayListener.
364     * @return DM_OK means register success, others means register failed.
365     */
366    DMError RegisterDisplayListener(sptr<IDisplayListener> listener);
367
368    /**
369     * @brief Unregister an existed display listener.
370     *
371     * @param listener IDisplayListener.
372     * @return DM_OK means unregister success, others means unregister failed.
373     */
374    DMError UnregisterDisplayListener(sptr<IDisplayListener> listener);
375
376    /**
377     * @brief Register a listener for display power events.
378     *
379     * @param listener IDisplayPowerEventListener.
380     * @return DM_OK means register success, others means register failed.
381     */
382    DMError RegisterDisplayPowerEventListener(sptr<IDisplayPowerEventListener> listener);
383
384    /**
385     * @brief Unregister an existed listener for display power events.
386     *
387     * @param listener IDisplayPowerEventListener.
388     * @return DM_OK means unregister success, others means unregister failed.
389     */
390    DMError UnregisterDisplayPowerEventListener(sptr<IDisplayPowerEventListener> listener);
391
392    /**
393     * @brief Register a listener for screenshot event.
394     *
395     * @param listener IScreenshotListener.
396     * @return DM_OK means register success, others means register failed.
397     */
398    DMError RegisterScreenshotListener(sptr<IScreenshotListener> listener);
399
400    /**
401     * @brief Unregister an existed listener for screenshot event.
402     *
403     * @param listener IScreenshotListener.
404     * @return DM_OK means unregister success, others means unregister failed.
405     */
406    DMError UnregisterScreenshotListener(sptr<IScreenshotListener> listener);
407
408    /**
409     * @brief Register a listener for the event of private window.
410     *
411     * @param listener IPrivateWindowListener.
412     * @return DM_OK means register success, others means register failed.
413     */
414    DMError RegisterPrivateWindowListener(sptr<IPrivateWindowListener> listener);
415
416    /**
417     * @brief Unregister an existed listener for the event of private window.
418     *
419     * @param listener IPrivateWindowListener.
420     * @return DM_OK means unregister success, others means unregister failed.
421     */
422    DMError UnregisterPrivateWindowListener(sptr<IPrivateWindowListener> listener);
423
424    /**
425     * @brief Register a listener for the event of private window.
426     *
427     * @param listener IPrivateWindowListChangeListener.
428     * @return DM_OK means register success, others means register failed.
429     */
430    DMError RegisterPrivateWindowListChangeListener(sptr<IPrivateWindowListChangeListener> listener);
431
432    /**
433     * @brief Unregister an existed listener for the event of private window.
434     *
435     * @param listener IPrivateWindowListChangeListener.
436     * @return DM_OK means unregister success, others means unregister failed.
437     */
438    DMError UnregisterPrivateWindowListChangeListener(sptr<IPrivateWindowListChangeListener> listener);
439
440    /**
441     * @brief Register a listener for the event of screen fold status changed.
442     *
443     * @param listener IFoldStatusListener.
444     * @return DM_OK means register success, others means register failed.
445     */
446    DMError RegisterFoldStatusListener(sptr<IFoldStatusListener> listener);
447
448    /**
449     * @brief Unregister an existed listener for the event of screen fold status changed.
450     *
451     * @param listener IFoldStatusListener.
452     * @return DM_OK means unregister success, others means unregister failed.
453     */
454    DMError UnregisterFoldStatusListener(sptr<IFoldStatusListener> listener);
455
456    /**
457     * @brief Register a listener for the event of screen fold angle changed.
458     *
459     * @param listener IFoldAngleListener.
460     * @return DM_OK means register success, others means register failed.
461     */
462    DMError RegisterFoldAngleListener(sptr<IFoldAngleListener> listener);
463
464    /**
465     * @brief Unregister an existed listener for the event of screen fold angle changed.
466     *
467     * @param listener IFoldAngleListener.
468     * @return DM_OK means unregister success, others means unregister failed.
469     */
470    DMError UnregisterFoldAngleListener(sptr<IFoldAngleListener> listener);
471
472    /**
473     * @brief Register a listener for the event of screen capture status changed.
474     *
475     * @param listener ICaptureStatusListener.
476     * @return DM_OK means register success, others means register failed.
477     */
478    DMError RegisterCaptureStatusListener(sptr<ICaptureStatusListener> listener);
479
480    /**
481     * @brief Unregister an existed listener for the event of screen capture status changed.
482     *
483     * @param listener ICaptureStatusListener.
484     * @return DM_OK means unregister success, others means unregister failed.
485     */
486    DMError UnregisterCaptureStatusListener(sptr<ICaptureStatusListener> listener);
487
488    /**
489     * @brief Register an listener when session changed.
490     *
491     * @param listener IDisplayUpdateListener.
492     * @return DM_OK means register success, others means unregister failed.
493     */
494    DMError RegisterDisplayUpdateListener(sptr<IDisplayUpdateListener> listener);
495
496    /**
497     * @brief Unregister an listener when session changed.
498     *
499     * @param listener IDisplayUpdateListener.
500     * @return DM_OK means unregister success, others means unregister failed.
501     */
502    DMError UnregisterDisplayUpdateListener(sptr<IDisplayUpdateListener> listener);
503
504    /**
505     * @brief Register a listener for the event of display mode changed.
506     *
507     * @param listener IDisplayModeListener.
508     * @return DM_OK means register success, others means register failed.
509     */
510    DMError RegisterDisplayModeListener(sptr<IDisplayModeListener> listener);
511
512    /**
513     * @brief Unregister an existed listener for the event of display mode changed.
514     *
515     * @param listener IDisplayModeListener.
516     * @return DM_OK means unregister success, others means unregister failed.
517     */
518    DMError UnregisterDisplayModeListener(sptr<IDisplayModeListener> listener);
519
520    /**
521     * @brief Register a listener for the event of available  area changed.
522     *
523     * @param listener IAvailableAreaListener.
524     * @return DM_OK means unregister success, others means unregister failed.
525     */
526    DMError RegisterAvailableAreaListener(sptr<IAvailableAreaListener> listener);
527
528    /**
529     * @brief UnRegister a listener for the event of available  area changed.
530     *
531     * @param listener IAvailableAreaListener.
532     * @return DM_OK means unregister success, others means unregister failed.
533     */
534    DMError UnregisterAvailableAreaListener(sptr<IAvailableAreaListener> listener);
535
536    /**
537     * @brief Add a surface node to the target display.
538     *
539     * @param displayId Target display.
540     * @param surfaceNode SurfaceNode object.
541     * @return DM_OK means add success, others means add failed.
542     */
543    DMError AddSurfaceNodeToDisplay(DisplayId displayId, std::shared_ptr<class RSSurfaceNode>& surfaceNode);
544
545    /**
546     * @brief Remove a surface node from the target display.
547     *
548     * @param displayId Target display.
549     * @param surfaceNode SurfaceNode object.
550     * @return DM_OK means remove success, others means remove failed.
551     */
552    DMError RemoveSurfaceNodeFromDisplay(DisplayId displayId, std::shared_ptr<class RSSurfaceNode>& surfaceNode);
553
554    /**
555     * @brief Check whether the device is foldable.
556     *
557     * @return true means the device is foldable.
558     */
559    bool IsFoldable();
560
561    /**
562     * @brief Check whether the device is capture.
563     *
564     * @return true means the device is capture.
565     */
566    bool IsCaptured();
567
568    /**
569     * @brief Get the current fold status of the foldable device.
570     *
571     * @return fold status of device.
572     */
573    FoldStatus GetFoldStatus();
574
575    /**
576     * @brief Get the display mode of the foldable device.
577     *
578     * @return display mode of the foldable device.
579     */
580    FoldDisplayMode GetFoldDisplayMode();
581
582    /**
583     * @brief Change the display mode of the foldable device.
584     *
585     * @param mode target display mode to change.
586     */
587    void SetFoldDisplayMode(const FoldDisplayMode mode);
588
589    /**
590     * @brief Change the display mode of the foldable device from js.
591     *
592     * @param mode target display mode to change.
593     * @return DM_OK means set success, others means set failed.
594     */
595    DMError SetFoldDisplayModeFromJs(const FoldDisplayMode mode);
596
597    /**
598     * @brief Set display scale.
599     *
600     * @param screenId screenId used in DisplayManager.
601     * @param scaleX screen scale in x axis.
602     * @param scaleY screen scale in y axis.
603     * @param pivotX screen scale pivot in x axis.
604     * @param pivotY screen scale pivot in y axis.
605     */
606    void SetDisplayScale(ScreenId screenId, float scaleX, float scaleY, float pivotX, float pivotY);
607
608    /**
609     * @brief Locked fold status.
610     *
611     * @param mode locked fold status is locked.
612     */
613    void SetFoldStatusLocked(bool locked);
614
615    /**
616     * @brief Locked fold status from js.
617     *
618     * @param locked locked fold status is locked.
619     * @return DM_OK means set success, others means set failed.
620     */
621    DMError SetFoldStatusLockedFromJs(bool locked);
622
623    /**
624     * @brief Get the fold crease region in the current display mode.
625     *
626     * @return fold crease region in the current display mode.
627     */
628    sptr<FoldCreaseRegion> GetCurrentFoldCreaseRegion();
629
630    /**
631     * @brief convert screenId to RsScreenId.
632     *
633     * @param screenId screenId used in DisplayManager.
634     * @param rsScreenId screenId used in RenderService.
635     *
636     * @return convert success or not.
637     */
638    bool ConvertScreenIdToRsScreenId(ScreenId screenId, ScreenId& rsScreenId);
639
640    /**
641     * @brief Set virtual screen black list to RS.
642     *
643     * @param screenId ScreenId used in virtual screen.
644     * @param windowIdList The windowId list to shield on cast screen.
645    */
646    void SetVirtualScreenBlackList(ScreenId screenId, std::vector<uint64_t>& windowIdList);
647
648    /**
649     * @brief When casting the screen, the display not be skipped after the physical screen is turned off.
650     *
651     * @param screenId ScreenId used in virtual screen.
652    */
653    void DisablePowerOffRenderControl(ScreenId screenId);
654
655    /**
656     * @brief get to freeze status with specified pid list
657     *
658     * @param pidList Indicates the calling pid
659     * @param isProxy value is true indicates process status is freeze
660     * @param DM_OK means process status update success, others means update failed.
661    */
662    DMError ProxyForFreeze(std::set<int32_t> pidList, bool isProxy);
663
664    /**
665     * @brief reset all process freeze status
666     *
667     * @param DM_OK means process status update success, others means update failed.
668    */
669    DMError ResetAllFreezeStatus();
670
671    /**
672     * @brief get all display physical resolution
673     *
674     * @return all physical resolution
675     */
676    std::vector<DisplayPhysicalResolution> GetAllDisplayPhysicalResolution();
677
678    /**
679     * @brief set virtual screen security exemption
680     *
681     * @param DM_OK means set exemption is success.
682    */
683    DMError SetVirtualScreenSecurityExemption(ScreenId screenId, uint32_t pid, std::vector<uint64_t>& windowIdList);
684
685    constexpr static int32_t MAX_RESOLUTION_SIZE_SCREENSHOT = 3840; // max resolution, 4K
686
687    /**
688     * @brief Add displayId for current ability through Ability Management.
689     *
690     * @param displayId Identifier of the current display.
691     * @param abilityToken Token of the ability.
692     */
693    void AddDisplayIdFromAms(DisplayId displayId, const wptr<IRemoteObject>& abilityToken);
694
695    /**
696     * @brief Removes the display identifier through the Ability Management.
697     *
698     * @param abilityToken Token of ability.
699     */
700    void RemoveDisplayIdFromAms(const wptr<IRemoteObject>& abilityToken);
701
702private:
703    DisplayManager();
704    ~DisplayManager();
705    void OnRemoteDied();
706
707    void ShowDisplayIdList(bool isShowLog = false);
708    std::mutex displayOperateMutex_;
709    DisplayId GetCallingAbilityDisplayId();
710    std::vector<std::pair<wptr<IRemoteObject>, DisplayId>> displayIdList_ {};
711
712    class Impl;
713    std::recursive_mutex mutex_;
714    sptr<Impl> pImpl_;
715};
716} // namespace OHOS::Rosen
717
718#endif // FOUNDATION_DM_DISPLAY_MANAGER_H