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