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(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(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(DisplayId displayId,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(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(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(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(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(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(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 Set the Display State object 281 * 282 * @param state State of display. 283 * @param callback Callback for display state. 284 * @return True means set success, false means set failed. 285 */ 286 bool SetDisplayState(DisplayState state, DisplayStateCallback callback); 287 288 /** 289 * @brief Get the state of the target display. 290 * 291 * @param displayId Display id. 292 * @return State of display. 293 */ 294 DisplayState GetDisplayState(DisplayId displayId); 295 296 /** 297 * @brief Try to cancel screenoff action before display power off. 298 * 299 * @return True means cancel screenoff action success. 300 * @return False means cancel screenoff action failed. 301 */ 302 bool TryToCancelScreenOff(); 303 304 /** 305 * @brief Set the brightness level of the target screen. 306 * 307 * @param screenId Target screen. 308 * @param level Brightness level. 309 */ 310 bool SetScreenBrightness(uint64_t screenId, uint32_t level); 311 312 /** 313 * @brief Get the brightness level of the target screen. 314 * 315 * @param screenId Screen id. 316 * @return Brightness value of screen. 317 */ 318 uint32_t GetScreenBrightness(uint64_t screenId) const; 319 320 /** 321 * @brief Notify when events of certain types occur. 322 * 323 * @param event Enumerate value of DisplayEvent. 324 */ 325 void NotifyDisplayEvent(DisplayEvent event); 326 327 /** 328 * @brief Freeze target displays. 329 * 330 * @param displayIds Display id needed to freeze. 331 * @return True means freeze success, false means freeze failed. 332 */ 333 bool Freeze(std::vector<DisplayId> displayIds); 334 335 /** 336 * @brief Unfreeze target displays. 337 * 338 * @param displayIds Display id needed to unfreeze. 339 * @return True means unfreeze success, false means unfreeze failed. 340 */ 341 bool Unfreeze(std::vector<DisplayId> displayIds); 342 343 /** 344 * @brief Register a display listener. 345 * 346 * @param listener IDisplayListener. 347 * @return DM_OK means register success, others means register failed. 348 */ 349 DMError RegisterDisplayListener(sptr<IDisplayListener> listener); 350 351 /** 352 * @brief Unregister an existed display listener. 353 * 354 * @param listener IDisplayListener. 355 * @return DM_OK means unregister success, others means unregister failed. 356 */ 357 DMError UnregisterDisplayListener(sptr<IDisplayListener> listener); 358 359 /** 360 * @brief Register a listener for display power events. 361 * 362 * @param listener IDisplayPowerEventListener. 363 * @return DM_OK means register success, others means register failed. 364 */ 365 DMError RegisterDisplayPowerEventListener(sptr<IDisplayPowerEventListener> listener); 366 367 /** 368 * @brief Unregister an existed listener for display power events. 369 * 370 * @param listener IDisplayPowerEventListener. 371 * @return DM_OK means unregister success, others means unregister failed. 372 */ 373 DMError UnregisterDisplayPowerEventListener(sptr<IDisplayPowerEventListener> listener); 374 375 /** 376 * @brief Register a listener for screenshot event. 377 * 378 * @param listener IScreenshotListener. 379 * @return DM_OK means register success, others means register failed. 380 */ 381 DMError RegisterScreenshotListener(sptr<IScreenshotListener> listener); 382 383 /** 384 * @brief Unregister an existed listener for screenshot event. 385 * 386 * @param listener IScreenshotListener. 387 * @return DM_OK means unregister success, others means unregister failed. 388 */ 389 DMError UnregisterScreenshotListener(sptr<IScreenshotListener> listener); 390 391 /** 392 * @brief Register a listener for the event of private window. 393 * 394 * @param listener IPrivateWindowListener. 395 * @return DM_OK means register success, others means register failed. 396 */ 397 DMError RegisterPrivateWindowListener(sptr<IPrivateWindowListener> listener); 398 399 /** 400 * @brief Unregister an existed listener for the event of private window. 401 * 402 * @param listener IPrivateWindowListener. 403 * @return DM_OK means unregister success, others means unregister failed. 404 */ 405 DMError UnregisterPrivateWindowListener(sptr<IPrivateWindowListener> listener); 406 407 /** 408 * @brief Register a listener for the event of private window. 409 * 410 * @param listener IPrivateWindowListChangeListener. 411 * @return DM_OK means register success, others means register failed. 412 */ 413 DMError RegisterPrivateWindowListChangeListener(sptr<IPrivateWindowListChangeListener> listener); 414 415 /** 416 * @brief Unregister an existed listener for the event of private window. 417 * 418 * @param listener IPrivateWindowListChangeListener. 419 * @return DM_OK means unregister success, others means unregister failed. 420 */ 421 DMError UnregisterPrivateWindowListChangeListener(sptr<IPrivateWindowListChangeListener> listener); 422 423 /** 424 * @brief Register a listener for the event of screen fold status changed. 425 * 426 * @param listener IFoldStatusListener. 427 * @return DM_OK means register success, others means register failed. 428 */ 429 DMError RegisterFoldStatusListener(sptr<IFoldStatusListener> listener); 430 431 /** 432 * @brief Unregister an existed listener for the event of screen fold status changed. 433 * 434 * @param listener IFoldStatusListener. 435 * @return DM_OK means unregister success, others means unregister failed. 436 */ 437 DMError UnregisterFoldStatusListener(sptr<IFoldStatusListener> listener); 438 439 /** 440 * @brief Register a listener for the event of screen fold angle changed. 441 * 442 * @param listener IFoldAngleListener. 443 * @return DM_OK means register success, others means register failed. 444 */ 445 DMError RegisterFoldAngleListener(sptr<IFoldAngleListener> listener); 446 447 /** 448 * @brief Unregister an existed listener for the event of screen fold angle changed. 449 * 450 * @param listener IFoldAngleListener. 451 * @return DM_OK means unregister success, others means unregister failed. 452 */ 453 DMError UnregisterFoldAngleListener(sptr<IFoldAngleListener> listener); 454 455 /** 456 * @brief Register a listener for the event of screen capture status changed. 457 * 458 * @param listener ICaptureStatusListener. 459 * @return DM_OK means register success, others means register failed. 460 */ 461 DMError RegisterCaptureStatusListener(sptr<ICaptureStatusListener> listener); 462 463 /** 464 * @brief Unregister an existed listener for the event of screen capture status changed. 465 * 466 * @param listener ICaptureStatusListener. 467 * @return DM_OK means unregister success, others means unregister failed. 468 */ 469 DMError UnregisterCaptureStatusListener(sptr<ICaptureStatusListener> listener); 470 471 /** 472 * @brief Register an listener when session changed. 473 * 474 * @param listener IDisplayUpdateListener. 475 * @return DM_OK means register success, others means unregister failed. 476 */ 477 DMError RegisterDisplayUpdateListener(sptr<IDisplayUpdateListener> listener); 478 479 /** 480 * @brief Unregister an listener when session changed. 481 * 482 * @param listener IDisplayUpdateListener. 483 * @return DM_OK means unregister success, others means unregister failed. 484 */ 485 DMError UnregisterDisplayUpdateListener(sptr<IDisplayUpdateListener> listener); 486 487 /** 488 * @brief Register a listener for the event of display mode changed. 489 * 490 * @param listener IDisplayModeListener. 491 * @return DM_OK means register success, others means register failed. 492 */ 493 DMError RegisterDisplayModeListener(sptr<IDisplayModeListener> listener); 494 495 /** 496 * @brief Unregister an existed listener for the event of display mode changed. 497 * 498 * @param listener IDisplayModeListener. 499 * @return DM_OK means unregister success, others means unregister failed. 500 */ 501 DMError UnregisterDisplayModeListener(sptr<IDisplayModeListener> listener); 502 503 /** 504 * @brief Register a listener for the event of available area changed. 505 * 506 * @param listener IAvailableAreaListener. 507 * @return DM_OK means unregister success, others means unregister failed. 508 */ 509 DMError RegisterAvailableAreaListener(sptr<IAvailableAreaListener> listener); 510 511 /** 512 * @brief UnRegister a listener for the event of available area changed. 513 * 514 * @param listener IAvailableAreaListener. 515 * @return DM_OK means unregister success, others means unregister failed. 516 */ 517 DMError UnregisterAvailableAreaListener(sptr<IAvailableAreaListener> listener); 518 519 /** 520 * @brief Add a surface node to the target display. 521 * 522 * @param displayId Target display. 523 * @param surfaceNode SurfaceNode object. 524 * @return DM_OK means add success, others means add failed. 525 */ 526 DMError AddSurfaceNodeToDisplay(DisplayId displayId, std::shared_ptr<class RSSurfaceNode>& surfaceNode); 527 528 /** 529 * @brief Remove a surface node from the target display. 530 * 531 * @param displayId Target display. 532 * @param surfaceNode SurfaceNode object. 533 * @return DM_OK means remove success, others means remove failed. 534 */ 535 DMError RemoveSurfaceNodeFromDisplay(DisplayId displayId, std::shared_ptr<class RSSurfaceNode>& surfaceNode); 536 537 /** 538 * @brief Check whether the device is foldable. 539 * 540 * @return true means the device is foldable. 541 */ 542 bool IsFoldable(); 543 544 /** 545 * @brief Check whether the device is capture. 546 * 547 * @return true means the device is capture. 548 */ 549 bool IsCaptured(); 550 551 /** 552 * @brief Get the current fold status of the foldable device. 553 * 554 * @return fold status of device. 555 */ 556 FoldStatus GetFoldStatus(); 557 558 /** 559 * @brief Get the display mode of the foldable device. 560 * 561 * @return display mode of the foldable device. 562 */ 563 FoldDisplayMode GetFoldDisplayMode(); 564 565 /** 566 * @brief Change the display mode of the foldable device. 567 * 568 * @param mode target display mode to change. 569 */ 570 void SetFoldDisplayMode(const FoldDisplayMode mode); 571 572 /** 573 * @brief Change the display mode of the foldable device from js. 574 * 575 * @param mode target display mode to change. 576 * @return DM_OK means set success, others means set failed. 577 */ 578 DMError SetFoldDisplayModeFromJs(const FoldDisplayMode mode); 579 580 /** 581 * @brief Set display scale. 582 * 583 * @param screenId screenId used in DisplayManager. 584 * @param scaleX screen scale in x axis. 585 * @param scaleY screen scale in y axis. 586 * @param pivotX screen scale pivot in x axis. 587 * @param pivotY screen scale pivot in y axis. 588 */ 589 void SetDisplayScale(ScreenId screenId, float scaleX, float scaleY, float pivotX, float pivotY); 590 591 /** 592 * @brief Locked fold status. 593 * 594 * @param mode locked fold status is locked. 595 */ 596 void SetFoldStatusLocked(bool locked); 597 598 /** 599 * @brief Locked fold status from js. 600 * 601 * @param locked locked fold status is locked. 602 * @return DM_OK means set success, others means set failed. 603 */ 604 DMError SetFoldStatusLockedFromJs(bool locked); 605 606 /** 607 * @brief Get the fold crease region in the current display mode. 608 * 609 * @return fold crease region in the current display mode. 610 */ 611 sptr<FoldCreaseRegion> GetCurrentFoldCreaseRegion(); 612 613 /** 614 * @brief convert screenId to RsScreenId. 615 * 616 * @param screenId screenId used in DisplayManager. 617 * @param rsScreenId screenId used in RenderService. 618 * 619 * @return convert success or not. 620 */ 621 bool ConvertScreenIdToRsScreenId(ScreenId screenId, ScreenId& rsScreenId); 622 623 /** 624 * @brief get to freeze status with specified pid list 625 * 626 * @param pidList Indicates the calling pid 627 * @param isProxy value is true indicates process status is freeze 628 * @param DM_OK means process status update success, others means update failed. 629 */ 630 DMError ProxyForFreeze(std::set<int32_t> pidList, bool isProxy); 631 632 /** 633 * @brief reset all process freeze status 634 * 635 * @param DM_OK means process status update success, others means update failed. 636 */ 637 DMError ResetAllFreezeStatus(); 638 639 /** 640 * @brief Set virtual screen black list to RS. 641 * 642 * @param screenId ScreenId used in virtual screen. 643 * @param windowIdList The windowId list to shield on cast screen. 644 */ 645 void SetVirtualScreenBlackList(ScreenId screenId, std::vector<uint64_t>& windowIdList); 646 647 /** 648 * @brief When casting the screen, the display not be skipped after the physical screen is turned off. 649 * 650 * @param screenId ScreenId used in virtual screen. 651 */ 652 void DisablePowerOffRenderControl(ScreenId screenId); 653 654 /** 655 * @brief get all display physical resolution 656 * 657 * @return all physical resolution 658 */ 659 std::vector<DisplayPhysicalResolution> GetAllDisplayPhysicalResolution(); 660 661 /** 662 * @brief set virtual screen security exemption 663 * 664 * @param DM_OK means set exemption is success. 665 */ 666 DMError SetVirtualScreenSecurityExemption(ScreenId screenId, uint32_t pid, std::vector<uint64_t>& windowIdList); 667 668 constexpr static int32_t MAX_RESOLUTION_SIZE_SCREENSHOT = 3840; // max resolution, 4K 669 670 /** 671 * @brief Add displayId for current ability through Ability Management. 672 * 673 * @param displayId Identifier of the current display. 674 * @param abilityToken Token of the ability. 675 */ 676 void AddDisplayIdFromAms(DisplayId displayId, const wptr<IRemoteObject>& abilityToken); 677 678 /** 679 * @brief Removes the display identifier through the Ability Management. 680 * 681 * @param abilityToken Token of ability. 682 */ 683 void RemoveDisplayIdFromAms(const wptr<IRemoteObject>& abilityToken); 684 685 private: 686 DisplayManager(); 687 ~DisplayManager(); 688 void OnRemoteDied(); 689 690 void ShowDisplayIdList(bool isShowLog = false); 691 std::mutex displayOperateMutex_; 692 DisplayId GetCallingAbilityDisplayId(); 693 std::vector<std::pair<wptr<IRemoteObject>, DisplayId>> displayIdList_ {}; 694 695 class Impl; 696 std::recursive_mutex mutex_; 697 sptr<Impl> pImpl_; 698 }; 699 } // namespace OHOS::Rosen 700 701 #endif // FOUNDATION_DM_DISPLAY_MANAGER_H