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 
32 namespace OHOS::Rosen {
33 class DisplayManager {
34 WM_DECLARE_SINGLE_INSTANCE_BASE(DisplayManager);
35 friend class DMSDeathRecipient;
36 public:
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          */
OnScreenshot([[maybe_unused]]const ScreenshotInfo info)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          */
OnPrivateWindow([[maybe_unused]]bool hasPrivate)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          */
OnPrivateWindowListChange([[maybe_unused]]DisplayId displayId, [[maybe_unused]]std::vector<std::string> privacyWindowList)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          */
setCallback([[maybe_unused]]std::function<void(std::vector<std::string>)> callback)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          */
OnFoldStatusChanged([[maybe_unused]]FoldStatus foldStatus)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          */
OnFoldAngleChanged([[maybe_unused]]std::vector<float> foldAngles)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          */
OnCaptureStatusChanged([[maybe_unused]]bool isCapture)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          */
OnDisplayUpdate([[maybe_unused]]const sptr<DisplayChangeInfo>& info)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          */
OnDisplayModeChanged([[maybe_unused]]FoldDisplayMode displayMode)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          */
OnAvailableAreaChanged(DMRect area)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 
702 private:
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