diff --git a/dmserver/include/abstract_display_controller.h b/dmserver/include/abstract_display_controller.h index 33ff7eea8e47e31758a16cb361e52942001f9d52..554a1e99c8295642cba564a630e5c8c8f5f6a942 100644 --- a/dmserver/include/abstract_display_controller.h +++ b/dmserver/include/abstract_display_controller.h @@ -69,6 +69,7 @@ private: Point offset = Point(0, 0)); void SetDisplayStateChangeListener(sptr abstractDisplay, DisplayStateChangeType type); DisplayId GetDefaultDisplayId(); + bool SetScreenOffsetInner(ScreenId screenId); std::recursive_mutex& mutex_; std::atomic displayCount_ { 0 }; diff --git a/dmserver/include/abstract_screen.h b/dmserver/include/abstract_screen.h index fa4e29585f789492d68a1677ecc11b23ed318b1e..de655a6a5ff9c49d36b0781d83f28bba26cc8b9d 100644 --- a/dmserver/include/abstract_screen.h +++ b/dmserver/include/abstract_screen.h @@ -59,7 +59,7 @@ public: std::shared_ptr& surfaceNode, std::shared_ptr& parentNode, bool isAdd); void InitRSDisplayNode(const RSDisplayNodeConfig& config, const Point& startPoint); void InitRSDefaultDisplayNode(const RSDisplayNodeConfig& config, const Point& startPoint); - void UpdateRSDisplayNode(Point startPoint); + void UpdateRSDisplayNode(Point startPoint, sptr absScreen); ScreenId GetScreenGroupId() const; // colorspace, gamut diff --git a/dmserver/src/abstract_display_controller.cpp b/dmserver/src/abstract_display_controller.cpp index 11c0710c49c9a923bc8a77e61fedfb76c61ab408..86d179a133105ec1e22466b439d9214e312d819f 100644 --- a/dmserver/src/abstract_display_controller.cpp +++ b/dmserver/src/abstract_display_controller.cpp @@ -251,7 +251,7 @@ DisplayId AbstractDisplayController::ProcessExpandScreenDisconnected( } else { abstractDisplay->SetOffset(0, 0); auto screenId = abstractDisplay->GetAbstractScreenId(); - abstractScreenController_->GetRSDisplayNodeByScreenId(screenId)->SetDisplayOffset(0, 0); + SetScreenOffsetInner(screenId); } } return displayId; @@ -712,4 +712,16 @@ DisplayId AbstractDisplayController::GetDefaultDisplayId() } return defaultDisplayId; } + +bool AbstractDisplayController::SetScreenOffsetInner(ScreenId screenId) +{ + sptr absScreen = abstractScreenController_->GetAbstractScreen(screenId); + if (absScreen == nullptr) { + TLOGE(WmsLogTag::DMS, "did not find screen:%{public}" PRIu64"", screenId); + return false; + } + TLOGI(WmsLogTag::DMS, "screenId = %{public}" PRIu64 " rsId = %{public}" PRIu64, screenId, absScreen->rsId_); + RSInterfaces::GetInstance().SetScreenOffset(absScreen->rsId_, 0, 0); + return true; +} } // namespace OHOS::Rosen \ No newline at end of file diff --git a/dmserver/src/abstract_screen.cpp b/dmserver/src/abstract_screen.cpp index 473fcc7196a55495ab8a8553570c5d2156e9d999..22b9b92b4b5c542265b8a90d9b58b4145cc2736a 100644 --- a/dmserver/src/abstract_screen.cpp +++ b/dmserver/src/abstract_screen.cpp @@ -172,8 +172,8 @@ void AbstractScreen::SetPropertyForDisplayNode(const std::shared_ptrSetDisplayOffset(startPoint.posX_, startPoint.posY_); + TLOGI(WmsLogTag::DMS, "SetScreenOffset: posX:%{public}d, posY:%{public}d", startPoint.posX_, startPoint.posY_); + RSInterfaces::GetInstance().SetScreenOffset(rsId_, startPoint.posX_, startPoint.posY_); uint32_t width = 0; uint32_t height = 0; sptr abstractScreenModes = GetActiveScreenMode(); @@ -187,7 +187,7 @@ void AbstractScreen::SetPropertyForDisplayNode(const std::shared_ptrSetSecurityDisplay(true); TLOGI(WmsLogTag::DMS, "virtualScreen SetSecurityDisplay success"); } - // If setDisplayOffset is not valid for SetFrame/SetBounds + // If SetScreenOffset is not valid for SetFrame/SetBounds rsDisplayNode->SetFrame(0, 0, width, height); rsDisplayNode->SetBounds(0, 0, width, height); } @@ -248,7 +248,7 @@ void AbstractScreen::InitRSDefaultDisplayNode(const RSDisplayNodeConfig& config, TLOGD(WmsLogTag::DMS, "InitRSDefaultDisplayNode success"); } -void AbstractScreen::UpdateRSDisplayNode(Point startPoint) +void AbstractScreen::UpdateRSDisplayNode(Point startPoint, sptr absScreen) { TLOGD(WmsLogTag::DMS, "update display offset from [%{public}d %{public}d] to [%{public}d %{public}d]", startPoint_.posX_, startPoint_.posY_, startPoint.posX_, startPoint.posY_); @@ -258,7 +258,11 @@ void AbstractScreen::UpdateRSDisplayNode(Point startPoint) } startPoint_ = startPoint; - rsDisplayNode_->SetDisplayOffset(startPoint.posX_, startPoint.posY_); + if (absScreen == nullptr) { + TLOGD(WmsLogTag::DMS, "absScreen is nullptr"); + return; + } + RSInterfaces::GetInstance().SetScreenOffset(absScreen->rsId_, startPoint.posX_, startPoint.posY_); } ScreenId AbstractScreen::GetScreenGroupId() const @@ -626,7 +630,7 @@ bool AbstractScreenGroup::RemoveChild(sptr& dmsScreen) dmsScreen->groupDmsId_ = SCREEN_ID_INVALID; dmsScreen->startPoint_ = Point(); if (dmsScreen->rsDisplayNode_ != nullptr) { - dmsScreen->rsDisplayNode_->SetDisplayOffset(0, 0); + RSInterfaces::GetInstance().SetScreenOffset(dmsScreen->rsId_, 0, 0); dmsScreen->rsDisplayNode_->RemoveFromTree(); RSTransactionAdapter::FlushImplicitTransaction(dmsScreen->GetRSUIContext()); dmsScreen->rsDisplayNode_ = nullptr; @@ -645,7 +649,7 @@ bool AbstractScreenGroup::RemoveDefaultScreen(const sptr& dmsScr ScreenId screenId = dmsScreen->dmsId_; dmsScreen->lastGroupDmsId_ = dmsScreen->groupDmsId_; if (dmsScreen->rsDisplayNode_ != nullptr) { - dmsScreen->rsDisplayNode_->SetDisplayOffset(0, 0); + RSInterfaces::GetInstance().SetScreenOffset(dmsScreen->rsId_, 0, 0); dmsScreen->rsDisplayNode_->RemoveFromTree(); RSTransactionAdapter::FlushImplicitTransaction(dmsScreen->GetRSUIContext()); } diff --git a/dmserver/src/abstract_screen_controller.cpp b/dmserver/src/abstract_screen_controller.cpp index f2101a82c69eed8554a0c831ebc9c1ee42886f4f..3919011a3b86362e7ea4c9b6ab4f41049cd8c948 100644 --- a/dmserver/src/abstract_screen_controller.cpp +++ b/dmserver/src/abstract_screen_controller.cpp @@ -820,7 +820,7 @@ void AbstractScreenController::UpdateScreenGroupLayout(sptr } if (screen->startPoint_.posX_ != point.posX_) { - screen->UpdateRSDisplayNode(point); + screen->UpdateRSDisplayNode(point, screen); if (abstractScreenCallback_ != nullptr) { abstractScreenCallback_->onChange_(screen, DisplayChangeEvent::DISPLAY_SIZE_CHANGED); } diff --git a/dmserver/src/display_manager_service.cpp b/dmserver/src/display_manager_service.cpp index 543f41272a80a001128031c04ae242590c935f1d..bfadf517c358752f74797efabc65c06170f327ee 100644 --- a/dmserver/src/display_manager_service.cpp +++ b/dmserver/src/display_manager_service.cpp @@ -716,11 +716,18 @@ DMError DisplayManagerService::MakeExpand(std::vector expandScreenIds, std::shared_ptr rsDisplayNode; std::vector points; for (uint32_t i = 0; i < allExpandScreenIds.size(); i++) { - rsDisplayNode = abstractScreenController_->GetRSDisplayNodeByScreenId(allExpandScreenIds[i]); - points.emplace_back(pointsMap[allExpandScreenIds[i]]); + ScreenId expandScreenId = allExpandScreenIds[i]; + if (pointsMap.find(expandScreenId) == pointsMap.end()) { + continue; + } + points.emplace_back(pointsMap[expandScreenId]); + rsDisplayNode = abstractScreenController_->GetRSDisplayNodeByScreenId(expandScreenId); if (rsDisplayNode != nullptr) { - rsDisplayNode->SetDisplayOffset(pointsMap[allExpandScreenIds[i]].posX_, - pointsMap[allExpandScreenIds[i]].posY_); + sptr absScreen = abstractScreenController_->GetAbstractScreen(expandScreenId); + if (absScreen != nullptr) { + RSInterfaces::GetInstance().SetScreenOffset(absScreen->rsId_, + pointsMap[expandScreenId].posX_, pointsMap[expandScreenId].posY_); + } } } HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "dms:MakeExpand"); diff --git a/dmserver/test/unittest/abstract_display_controller_test.cpp b/dmserver/test/unittest/abstract_display_controller_test.cpp index cb1d7651e53c2c6ff067aef078a26bef6b5ad0f8..8afc5fd1cf647218e992a83849c0761741584ea2 100644 --- a/dmserver/test/unittest/abstract_display_controller_test.cpp +++ b/dmserver/test/unittest/abstract_display_controller_test.cpp @@ -577,6 +577,21 @@ HWTEST_F(AbstractDisplayControllerTest, GetScreenSnapshot03, TestSize.Level1) auto ret = absDisplayController_->GetScreenSnapshot(screenId); ASSERT_EQ(nullptr, ret); } + +/** + * @tc.name: FeatureTest + * @tc.desc: SetScreenOffsetInner + * @tc.type: FUNC + */ +HWTEST_F(AbstractDisplayControllerTest, FeatureTest, TestSize.Level1) +{ + ScreenId screenId = 0; + auto ret = absDisplayController_->SetScreenOffsetInner(screenId); + ASSERT_TRUE(ret); + screenId = 6; + ret = absDisplayController_->SetScreenOffsetInner(screenId); + ASSERT_FALSE(ret); +} } } // namespace Rosen } // namespace OHOS diff --git a/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h b/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h index 1635eed9526bca8d4a1f90e2078ea37d3286408c..c355e310b4a44e56ccd81e835fb7ac0e66779fc9 100644 --- a/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h +++ b/window_scene/screen_session_manager/include/fold_screen_controller/secondary_display_fold_policy.h @@ -36,24 +36,33 @@ public: void SetOnBootAnimation(bool onBootAnimation) override; FoldDisplayMode GetModeMatchStatus() override; std::vector GetScreenParams() override; - Drawing::Rect GetScreenSnapshotRect() override; - void SetMainScreenRegion(DMRect& mainScreenRegion) override; + void ExitCoordination() override; void SetSecondaryDisplayModeChangeStatus(bool status) override; + void AddOrRemoveDisplayNodeToTree(ScreenId screenId, int32_t command) override; private: void ChangeSuperScreenDisplayMode(sptr screenSession, FoldDisplayMode displayMode); + void CloseCoordinationScreen(); + void ChangeScreenDisplayModeToCoordination(); + void UpdateDisplayNodeBasedOnScreenId(ScreenId screenId, std::shared_ptr displayNode); void RecoverWhenBootAnimationExit(); void ReportFoldDisplayModeChange(FoldDisplayMode displayMode); void SendPropertyChangeResult(sptr screenSession, ScreenId screenId, ScreenPropertyChangeReason reason, FoldDisplayMode displayMode); + void HandleScreenOnFullOn(sptr screenSession, ScreenId screenId, + ScreenPropertyChangeReason reason, FoldDisplayMode displayMode); + void SendCoordinationPropertyChangeResultSync(sptr screenSession, ScreenId screenId, + ScreenPropertyChangeReason reason, FoldDisplayMode displayMode); + void SetStatusConditionalActiveRectAndTpFeature(ScreenProperty &screenProperty); void SetStatusFullActiveRectAndTpFeature(); void SetStatusMainActiveRectAndTpFeature(); void SetStatusGlobalFullActiveRectAndTpFeature(); void InitScreenParams(); std::recursive_mutex& displayInfoMutex_; + std::mutex coordinationMutex_; std::shared_ptr screenPowerTaskScheduler_; std::vector screenParams_; bool isChangeScreenWhenBootCompleted = false; }; } // namespace OHOS::Rosen -#endif //OHOS_ROSEN_WINDOW_SCENE_SECONDARY_DISPLAY_FOLD_POLICY_H \ No newline at end of file +#endif //OHOS_ROSEN_WINDOW_SCENE_SECONDARY_DISPLAY_FOLD_POLICY_H diff --git a/window_scene/screen_session_manager/include/screen_session_manager.h b/window_scene/screen_session_manager/include/screen_session_manager.h index a576f3f30adf5cf9a8f460e02fb35729c6e3c64e..62d97379bca557bac5a4db46ec04094c2b3cbd9b 100644 --- a/window_scene/screen_session_manager/include/screen_session_manager.h +++ b/window_scene/screen_session_manager/include/screen_session_manager.h @@ -467,7 +467,7 @@ public: bool GetKeyboardState() override; DMError GetScreenAreaOfDisplayArea(DisplayId displayId, const DMRect& displayArea, ScreenId& screenId, DMRect& screenArea) override; - DMError SetVirtualScreenAutoRotation(ScreenId screenId, bool enable) override; + bool SetScreenOffset(ScreenId screenId, float offsetX, float offsetY); protected: ScreenSessionManager(); @@ -490,6 +490,7 @@ private: void CreateScreenProperty(ScreenId screenId, ScreenProperty& property); void InitScreenProperty(ScreenId screenId, RSScreenModeInfo& screenMode, RSScreenCapability& screenCapability, ScreenProperty& property); + RRect GetScreenBounds(ScreenId screenId, RSScreenModeInfo& screenMode); void GetInternalWidth(); void InitExtendScreenDensity(sptr session, ScreenProperty property); void InitExtendScreenProperty(ScreenId screenId, sptr session, ScreenProperty property); diff --git a/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp b/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp index d2245acdcbae2aa9815012609cfca8f0c08a4e29..d21b06e52a655b8af445e37e60b987e7f28bc8a7 100644 --- a/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp +++ b/window_scene/screen_session_manager/src/fold_screen_controller/secondary_display_fold_policy.cpp @@ -32,12 +32,18 @@ namespace OHOS::Rosen { namespace { const ScreenId SCREEN_ID_FULL = 0; +const ScreenId SCREEN_ID_MAIN = 5; +const int32_t REMOVE_DISPLAY_NODE = 0; +const int32_t ADD_DISPLAY_NODE = 1; const int32_t MAIN_STATUS_WIDTH = 0; const int32_t FULL_STATUS_WIDTH = 1; const int32_t GLOBAL_FULL_STATUS_WIDTH = 2; const int32_t SCREEN_HEIGHT = 3; const int32_t FULL_STATUS_OFFSET_X = 4; constexpr uint32_t HALF_DIVIDER = 2; +const float MAIN_DISPLAY_ROTATION_DEGREE = 180; +const float TRANSLATE_X = 612; +const float TRANSLATE_Y = -612; #ifdef TP_FEATURE_ENABLE const int32_t TP_TYPE = 12; const char* STATUS_MAIN = "version:3+main"; @@ -135,6 +141,97 @@ void SecondaryDisplayFoldPolicy::SendSensorResult(FoldStatus foldStatus) ChangeScreenDisplayMode(displayMode); } +void SecondaryDisplayFoldPolicy::CloseCoordinationScreen() +{ + std::lock_guard lock(coordinationMutex_); + if (!ScreenSessionManager::GetInstance().GetCoordinationFlag()) { + TLOGW(WmsLogTag::DMS, "CloseCoordinationScreen skipped, current coordination flag is false"); + return; + } + TLOGI(WmsLogTag::DMS, "Close Coordination Screen current mode=%{public}d", currentDisplayMode_); + + AddOrRemoveDisplayNodeToTree(SCREEN_ID_MAIN, REMOVE_DISPLAY_NODE); + + ScreenSessionManager::GetInstance().OnScreenChange(SCREEN_ID_MAIN, ScreenEvent::DISCONNECTED); + ScreenSessionManager::GetInstance().SetCoordinationFlag(false); +} + +void SecondaryDisplayFoldPolicy::ChangeScreenDisplayModeToCoordination() +{ + std::lock_guard lock(coordinationMutex_); + if (ScreenSessionManager::GetInstance().GetCoordinationFlag()) { + TLOGW(WmsLogTag::DMS, "change displaymode to coordination skipped, current coordination flag is true"); + return; + } + TLOGI(WmsLogTag::DMS, "change displaymode to coordination current mode=%{public}d", currentDisplayMode_); + + ScreenSessionManager::GetInstance().SetCoordinationFlag(true); + ScreenSessionManager::GetInstance().OnScreenChange(SCREEN_ID_MAIN, ScreenEvent::CONNECTED); + + AddOrRemoveDisplayNodeToTree(SCREEN_ID_MAIN, ADD_DISPLAY_NODE); +} + +void SecondaryDisplayFoldPolicy::AddOrRemoveDisplayNodeToTree(ScreenId screenId, int32_t command) +{ + TLOGI(WmsLogTag::DMS, "AddOrRemoveDisplayNodeToTree, screenId: %{public}" PRIu64 ", command: %{public}d", + screenId, command); + sptr screenSession = ScreenSessionManager::GetInstance().GetScreenSession(screenId); + if (screenSession == nullptr) { + TLOGE(WmsLogTag::DMS, "AddOrRemoveDisplayNodeToTree, screenSession is null"); + return; + } + std::shared_ptr displayNode = screenSession->GetDisplayNode(); + if (displayNode == nullptr) { + TLOGE(WmsLogTag::DMS, "AddOrRemoveDisplayNodeToTree, displayNode is null"); + return; + } + + UpdateDisplayNodeBasedOnScreenId(screenId, displayNode); + if (command == ADD_DISPLAY_NODE) { + displayNode->AddDisplayNodeToTree(); + } else if (command == REMOVE_DISPLAY_NODE) { + displayNode->RemoveDisplayNodeFromTree(); + } + displayNode = nullptr; + auto transactionProxy = RSTransactionProxy::GetInstance(); + if (transactionProxy != nullptr) { + TLOGI(WmsLogTag::DMS, "add or remove displayNode"); + transactionProxy->FlushImplicitTransaction(); + } +} + +void SecondaryDisplayFoldPolicy::UpdateDisplayNodeBasedOnScreenId(ScreenId screenId, + std::shared_ptr displayNode) +{ + if (screenId != SCREEN_ID_MAIN) { + return; + } + TLOGW(WmsLogTag::DMS, "UpdateDisplayNodeBasedOnScreenId: %{public}" PRIu64, screenId); + displayNode->SetScreenId(SCREEN_ID_FULL); + displayNode->SetRotation(MAIN_DISPLAY_ROTATION_DEGREE); + displayNode->SetTranslate({TRANSLATE_X, TRANSLATE_Y}); + displayNode->SetFrame(0, 0, screenParams_[MAIN_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT]); + displayNode->SetBounds(0, 0, screenParams_[MAIN_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT]); +} + +void SecondaryDisplayFoldPolicy::ExitCoordination() +{ + std::lock_guard lock(coordinationMutex_); + if (!ScreenSessionManager::GetInstance().GetCoordinationFlag()) { + TLOGW(WmsLogTag::DMS, "ExitCoordination skipped, current coordination flag is false"); + return; + } + ScreenSessionManager::GetInstance().SetKeyguardDrawnDoneFlag(false); + AddOrRemoveDisplayNodeToTree(SCREEN_ID_MAIN, REMOVE_DISPLAY_NODE); + ScreenSessionManager::GetInstance().OnScreenChange(SCREEN_ID_MAIN, ScreenEvent::DISCONNECTED); + ScreenSessionManager::GetInstance().SetCoordinationFlag(false); + FoldDisplayMode displayMode = GetModeMatchStatus(); + currentDisplayMode_ = displayMode; + lastDisplayMode_ = displayMode; + TLOGI(WmsLogTag::DMS, "Exit coordination, current display mode:%{public}d", displayMode); + ScreenSessionManager::GetInstance().NotifyDisplayModeChanged(displayMode); +} + void SecondaryDisplayFoldPolicy::SetOnBootAnimation(bool onBootAnimation) { TLOGW(WmsLogTag::DMS, "onBootAnimation: %{public}d", onBootAnimation); @@ -240,54 +337,101 @@ void SecondaryDisplayFoldPolicy::SendPropertyChangeResult(sptr sc TLOGE(WmsLogTag::DMS, "screenSession is null"); return; } + + if (displayMode == FoldDisplayMode::COORDINATION && currentDisplayMode_ == FoldDisplayMode::FULL) { + SendCoordinationPropertyChangeResultSync(screenSession, screenId, reason, displayMode); + return; + } + if (displayMode == FoldDisplayMode::MAIN) { reason = ScreenPropertyChangeReason::FOLD_SCREEN_FOLDING; } auto taskScreenOnFullOn = [this, displayMode] { - if (displayMode == FoldDisplayMode::FULL) { - SetStatusFullActiveRectAndTpFeature(); - } else if (displayMode == FoldDisplayMode::MAIN) { - SetStatusMainActiveRectAndTpFeature(); - } else if (displayMode == FoldDisplayMode::GLOBAL_FULL) { - SetStatusGlobalFullActiveRectAndTpFeature(); - } else { - TLOGW(WmsLogTag::DMS, "unKnown displayMode"); + switch (displayMode) { + case FoldDisplayMode::FULL: { + if (currentDisplayMode_ == FoldDisplayMode::COORDINATION) { + CloseCoordinationScreen(); + } + SetStatusFullActiveRectAndTpFeature(); + break; + } + case FoldDisplayMode::MAIN: { + if (currentDisplayMode_ == FoldDisplayMode::COORDINATION) { + CloseCoordinationScreen(); + } + SetStatusMainActiveRectAndTpFeature(); + break; + } + case FoldDisplayMode::GLOBAL_FULL: { + if (currentDisplayMode_ == FoldDisplayMode::COORDINATION) { + CloseCoordinationScreen(); + } + SetStatusGlobalFullActiveRectAndTpFeature(); + break; + } + default: { + TLOGW(WmsLogTag::DMS, "unKnown displayMode"); + break; + } } }; screenPowerTaskScheduler_->PostAsyncTask(std::move(taskScreenOnFullOn), __func__); - { - std::lock_guard lock_info(displayInfoMutex_); - screenProperty_ = ScreenSessionManager::GetInstance().GetPhyScreenProperty(screenId); - if (displayMode == FoldDisplayMode::FULL) { - auto fullStatusScreenBounds = RRect({ 0, screenParams_[FULL_STATUS_OFFSET_X], - screenParams_[FULL_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT] }, 0.0f, 0.0f); - screenProperty_.SetBounds(fullStatusScreenBounds); - screenSession->SetScreenAreaOffsetY(screenParams_[FULL_STATUS_OFFSET_X]); - screenSession->SetScreenAreaHeight(screenParams_[FULL_STATUS_WIDTH]); - } else if (displayMode == FoldDisplayMode::MAIN) { - auto mainStatusScreenBounds = - RRect({ 0, 0, screenParams_[MAIN_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT] }, 0.0f, 0.0f); - screenProperty_.SetBounds(mainStatusScreenBounds); - screenSession->SetScreenAreaOffsetY(0); - screenSession->SetScreenAreaHeight(screenParams_[MAIN_STATUS_WIDTH]); - } else if (displayMode == FoldDisplayMode::GLOBAL_FULL) { - auto globalFullStatusScreenBounds = - RRect({ 0, 0, screenParams_[GLOBAL_FULL_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT] }, 0.0f, 0.0f); - screenProperty_.SetBounds(globalFullStatusScreenBounds); - screenSession->SetScreenAreaOffsetY(0); - screenSession->SetScreenAreaHeight(screenParams_[GLOBAL_FULL_STATUS_WIDTH]); - } else { - TLOGW(WmsLogTag::DMS, "unKnown displayMode"); - } - screenSession->UpdatePropertyByFoldControl(screenProperty_, displayMode); - screenSession->PropertyChange(screenSession->GetScreenProperty(), reason); - if (displayMode == FoldDisplayMode::MAIN) { - screenSession->SetRotationAndScreenRotationOnly(Rotation::ROTATION_0); - } - TLOGI(WmsLogTag::DMS, "screenBounds : width= %{public}f, height= %{public}f", - screenSession->GetScreenProperty().GetBounds().rect_.width_, - screenSession->GetScreenProperty().GetBounds().rect_.height_); + HandleScreenOnFullOn(screenSession, screenId, reason, displayMode); +} + +void SecondaryDisplayFoldPolicy::HandleScreenOnFullOn(sptr screenSession, ScreenId screenId, + ScreenPropertyChangeReason reason, FoldDisplayMode displayMode) +{ + std::lock_guard lock_info(displayInfoMutex_); + screenProperty_ = ScreenSessionManager::GetInstance().GetPhyScreenProperty(screenId); + if (displayMode == FoldDisplayMode::FULL) { + auto fullStatusScreenBounds = RRect({ 0, screenParams_[FULL_STATUS_OFFSET_X], + screenParams_[FULL_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT] }, 0.0f, 0.0f); + screenProperty_.SetBounds(fullStatusScreenBounds); + screenSession->SetScreenAreaOffsetY(screenParams_[FULL_STATUS_OFFSET_X]); + screenSession->SetScreenAreaHeight(screenParams_[FULL_STATUS_WIDTH]); + } else if (displayMode == FoldDisplayMode::MAIN) { + auto mainStatusScreenBounds = + RRect({ 0, 0, screenParams_[MAIN_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT] }, 0.0f, 0.0f); + screenProperty_.SetBounds(mainStatusScreenBounds); + screenSession->SetScreenAreaOffsetY(0); + screenSession->SetScreenAreaHeight(screenParams_[MAIN_STATUS_WIDTH]); + } else if (displayMode == FoldDisplayMode::GLOBAL_FULL) { + auto globalFullStatusScreenBounds = + RRect({ 0, 0, screenParams_[GLOBAL_FULL_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT] }, 0.0f, 0.0f); + screenProperty_.SetBounds(globalFullStatusScreenBounds); + screenSession->SetScreenAreaOffsetY(0); + screenSession->SetScreenAreaHeight(screenParams_[GLOBAL_FULL_STATUS_WIDTH]); + } else { + TLOGW(WmsLogTag::DMS, "unKnown displayMode"); + } + screenSession->UpdatePropertyByFoldControl(screenProperty_, displayMode); + screenSession->PropertyChange(screenSession->GetScreenProperty(), reason); + if (displayMode == FoldDisplayMode::MAIN) { + screenSession->SetRotationAndScreenRotationOnly(Rotation::ROTATION_0); } + TLOGI(WmsLogTag::DMS, "screenBounds : width= %{public}f, height= %{public}f", + screenSession->GetScreenProperty().GetBounds().rect_.width_, + screenSession->GetScreenProperty().GetBounds().rect_.height_); +} + +void SecondaryDisplayFoldPolicy::SendCoordinationPropertyChangeResultSync(sptr screenSession, + ScreenId screenId, ScreenPropertyChangeReason reason, FoldDisplayMode displayMode) +{ + std::lock_guard lock_info(displayInfoMutex_); + screenProperty_ = ScreenSessionManager::GetInstance().GetPhyScreenProperty(screenId); + TLOGW(WmsLogTag::DMS, "COORDINATION"); + ChangeScreenDisplayModeToCoordination(); + SetStatusConditionalActiveRectAndTpFeature(screenProperty_); + + screenSession->UpdatePropertyByFoldControl(screenProperty_, displayMode); + screenSession->PropertyChange(screenSession->GetScreenProperty(), reason); + if (displayMode == FoldDisplayMode::MAIN) { + screenSession->SetRotationAndScreenRotationOnly(Rotation::ROTATION_0); + } + TLOGI(WmsLogTag::DMS, "screenBounds : width_= %{public}f, height_= %{public}f", + screenSession->GetScreenProperty().GetBounds().rect_.width_, + screenSession->GetScreenProperty().GetBounds().rect_.height_); } void SecondaryDisplayFoldPolicy::SetStatusFullActiveRectAndTpFeature() @@ -347,6 +491,28 @@ void SecondaryDisplayFoldPolicy::SetStatusGlobalFullActiveRectAndTpFeature() SetSecondaryDisplayModeChangeStatus(false); } +void SecondaryDisplayFoldPolicy::SetStatusConditionalActiveRectAndTpFeature(ScreenProperty &screenProperty) +{ + auto globalFullStatusScreenBounds = RRect({0, screenParams_[FULL_STATUS_OFFSET_X], + screenParams_[FULL_STATUS_WIDTH], screenParams_[SCREEN_HEIGHT]}, 0.0f, 0.0f); + screenProperty.SetBounds(globalFullStatusScreenBounds); + OHOS::Rect rectCur{ + .x = 0, + .y = 0, + .w = screenParams_[SCREEN_HEIGHT], + .h = screenParams_[GLOBAL_FULL_STATUS_WIDTH], + }; + if (!onBootAnimation_) { + RSInterfaces::GetInstance().NotifyScreenSwitched(); + auto response = RSInterfaces::GetInstance().SetScreenActiveRect(0, rectCur); + TLOGI(WmsLogTag::DMS, "rs response is %{public}d", static_cast(response)); + } +#ifdef TP_FEATURE_ENABLE + RSInterfaces::GetInstance().SetTpFeatureConfig(TP_TYPE, STATUS_GLOBAL_FULL, TpFeatureConfigType::AFT_TP_FEATURE); +#endif + SetSecondaryDisplayModeChangeStatus(false); +} + void SecondaryDisplayFoldPolicy::ReportFoldDisplayModeChange(FoldDisplayMode displayMode) { int32_t mode = static_cast(displayMode); @@ -395,48 +561,6 @@ std::vector SecondaryDisplayFoldPolicy::GetScreenParams() return screenParams_; } -Drawing::Rect SecondaryDisplayFoldPolicy::GetScreenSnapshotRect() -{ - Drawing::Rect snapshotRect = {0, 0, 0, 0}; - if (currentDisplayMode_ == FoldDisplayMode::MAIN) { - snapshotRect.left_ = 0; - snapshotRect.top_ = 0; - snapshotRect.right_ = screenParams_[SCREEN_HEIGHT]; - snapshotRect.bottom_ = screenParams_[MAIN_STATUS_WIDTH]; - } else if (currentDisplayMode_ == FoldDisplayMode::FULL) { - snapshotRect.left_ = 0; - snapshotRect.top_ = screenParams_[FULL_STATUS_OFFSET_X]; - snapshotRect.right_ = screenParams_[SCREEN_HEIGHT]; - snapshotRect.bottom_ = screenParams_[GLOBAL_FULL_STATUS_WIDTH]; - } else if (currentDisplayMode_ == FoldDisplayMode::GLOBAL_FULL) { - snapshotRect.left_ = 0; - snapshotRect.top_ = 0; - snapshotRect.right_ = screenParams_[SCREEN_HEIGHT]; - snapshotRect.bottom_ = screenParams_[GLOBAL_FULL_STATUS_WIDTH]; - } - return snapshotRect; -} - -void SecondaryDisplayFoldPolicy::SetMainScreenRegion(DMRect& mainScreenRegion) -{ - if (currentDisplayMode_ == FoldDisplayMode::MAIN) { - mainScreenRegion.posX_ = 0; - mainScreenRegion.posY_ = 0; - mainScreenRegion.width_ = screenParams_[SCREEN_HEIGHT]; - mainScreenRegion.height_ = screenParams_[MAIN_STATUS_WIDTH]; - } else if (currentDisplayMode_ == FoldDisplayMode::FULL) { - mainScreenRegion.posX_ = 0; - mainScreenRegion.posY_ = static_cast(screenParams_[FULL_STATUS_OFFSET_X]); - mainScreenRegion.width_ = screenParams_[SCREEN_HEIGHT]; - mainScreenRegion.height_ = screenParams_[FULL_STATUS_WIDTH]; - } else if (currentDisplayMode_ == FoldDisplayMode::GLOBAL_FULL) { - mainScreenRegion.posX_ = 0; - mainScreenRegion.posY_ = 0; - mainScreenRegion.width_ = screenParams_[SCREEN_HEIGHT]; - mainScreenRegion.height_ = screenParams_[GLOBAL_FULL_STATUS_WIDTH]; - } -} - void SecondaryDisplayFoldPolicy::SetSecondaryDisplayModeChangeStatus(bool status) { if (status) { @@ -456,4 +580,4 @@ void SecondaryDisplayFoldPolicy::SetSecondaryDisplayModeChangeStatus(bool status } } -} // namespace OHOS::Rosen \ No newline at end of file +} // namespace OHOS::Rosen diff --git a/window_scene/screen_session_manager/src/multi_screen_change_utils.cpp b/window_scene/screen_session_manager/src/multi_screen_change_utils.cpp index 5415bc6fc4687e6d10c1dc7e1281d66bdbf78d95..febe60689bb3b52e2e7ddfc49ef326f9385a6941 100644 --- a/window_scene/screen_session_manager/src/multi_screen_change_utils.cpp +++ b/window_scene/screen_session_manager/src/multi_screen_change_utils.cpp @@ -77,9 +77,11 @@ void MultiScreenChangeUtils::ScreenExtendPositionChange(sptr& inn std::shared_ptr innerNode = innerScreen->GetDisplayNode(); std::shared_ptr externalNode = externalScreen->GetDisplayNode(); if (innerNode && externalNode) { - innerNode->SetDisplayOffset(innerScreen->GetScreenProperty().GetStartX(), + ScreenSessionManager::GetInstance().SetScreenOffset(innerScreen->GetScreenId(), + innerScreen->GetScreenProperty().GetStartX(), innerScreen->GetScreenProperty().GetStartY()); - externalNode->SetDisplayOffset(externalScreen->GetScreenProperty().GetStartX(), + ScreenSessionManager::GetInstance().SetScreenOffset(externalScreen->GetScreenId(), + externalScreen->GetScreenProperty().GetStartX(), externalScreen->GetScreenProperty().GetStartY()); } else { TLOGW(WmsLogTag::DMS, "DisplayNode is null"); @@ -126,8 +128,8 @@ void MultiScreenChangeUtils::ScreenMainPositionChange(sptr& inner std::shared_ptr innerNode = innerScreen->GetDisplayNode(); std::shared_ptr externalNode = externalScreen->GetDisplayNode(); if (innerNode && externalNode) { - innerNode->SetDisplayOffset(0, 0); - externalNode->SetDisplayOffset(0, 0); + ScreenSessionManager::GetInstance().SetScreenOffset(innerScreen->GetScreenId(), 0, 0); + ScreenSessionManager::GetInstance().SetScreenOffset(externalScreen->GetScreenId(), 0, 0); } else { TLOGW(WmsLogTag::DMS, "DisplayNode is null"); } diff --git a/window_scene/screen_session_manager/src/multi_screen_power_change_manager.cpp b/window_scene/screen_session_manager/src/multi_screen_power_change_manager.cpp index 6b4e432a65be82d04c3045d17d91f18729d5a3ea..2b938056eb7b12070282e0b430b3d911ea98c320 100644 --- a/window_scene/screen_session_manager/src/multi_screen_power_change_manager.cpp +++ b/window_scene/screen_session_manager/src/multi_screen_power_change_manager.cpp @@ -195,7 +195,7 @@ void MultiScreenPowerChangeManager::ScreenDisplayNodeRemove(sptr& TLOGW(WmsLogTag::DMS, "removeNode screenId=%{public}" PRIu64, screenScreen->GetScreenId()); std::shared_ptr displayNode = screenScreen->GetDisplayNode(); if (displayNode != nullptr) { - displayNode->SetDisplayOffset(0, 0); + ScreenSessionManager::GetInstance().SetScreenOffset(screenScreen->GetScreenId(), 0, 0); displayNode->RemoveFromTree(); screenScreen->ReleaseDisplayNode(); } diff --git a/window_scene/screen_session_manager/src/screen_session_manager.cpp b/window_scene/screen_session_manager/src/screen_session_manager.cpp index 605ac0285092d469919c25f1865bcd855236ffa9..1217cdc9e33aa5a109dbbc4a8d07f81c57e1dbd1 100644 --- a/window_scene/screen_session_manager/src/screen_session_manager.cpp +++ b/window_scene/screen_session_manager/src/screen_session_manager.cpp @@ -177,6 +177,9 @@ const bool IS_SUPPORT_PC_MODE = system::GetBoolParameter("const.window.support_w const ScreenId SCREEN_GROUP_ID_DEFAULT = 1; const std::set INDIVIDUAL_SCREEN_GROUP_SET = {"CeliaView", "DevEcoViewer"}; +constexpr uint32_t MAIN_STATUS_WIDTH = 1008; +constexpr uint32_t SCREEN_HEIGHT = 2232; + // based on the bundle_util inline int32_t GetUserIdByCallingUid() { @@ -1361,7 +1364,9 @@ void ScreenSessionManager::HandleScreenConnectEvent(sptr screenSe SetMultiScreenDefaultRelativePosition(); ReportHandleScreenEvent(ScreenEvent::CONNECTED, ScreenCombination::SCREEN_EXTEND); } - if (screenSession->GetScreenId() != screenSession->GetRSScreenId()) { + sptr newInternalSession = GetInternalScreenSession(); + if (newInternalSession != nullptr && internalSession != nullptr && + internalSession->GetScreenId() != newInternalSession->GetScreenId()) { TLOGW(WmsLogTag::DMS, "main screen changed, reset screenSession."); screenSession = internalSession; } @@ -1551,11 +1556,11 @@ void ScreenSessionManager::ResetInternalScreenSession(sptr& inner ScreenId externalRSId = externalScreen->GetRSScreenId(); if (mainNode != nullptr) { mainNode->SetScreenId(externalRSId); - mainNode->SetDisplayOffset(0, 0); + RSInterfaces::GetInstance().SetScreenOffset(externalRSId, 0, 0); } if (extendNode != nullptr) { extendNode->SetScreenId(innerRSId); - extendNode->SetDisplayOffset(0, 0); + RSInterfaces::GetInstance().SetScreenOffset(innerRSId, 0, 0); } RSTransactionAdapter::FlushImplicitTransaction( {innerScreen->GetRSUIContext(), externalScreen->GetRSUIContext()}); @@ -2457,13 +2462,17 @@ void ScreenSessionManager::CreateScreenProperty(ScreenId screenId, ScreenPropert int id = HiviewDFX::XCollie::GetInstance().SetTimer("CreateScreenPropertyCallRS", XCOLLIE_TIMEOUT_10S, nullptr, nullptr, HiviewDFX::XCOLLIE_FLAG_LOG); TLOGW(WmsLogTag::DMS, "Call rsInterface_ GetScreenActiveMode ScreenId: %{public}" PRIu64, screenId); - auto screenMode = rsInterface_.GetScreenActiveMode(screenId); + ScreenId getScreenId = screenId; + if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice() && screenId == SCREEN_ID_MAIN) { + getScreenId = SCREEN_ID_FULL; + } + auto screenMode = rsInterface_.GetScreenActiveMode(getScreenId); TLOGW(WmsLogTag::DMS, "get screenWidth: %{public}d, screenHeight: %{public}d", static_cast(screenMode.GetScreenWidth()), static_cast(screenMode.GetScreenHeight())); - auto screenBounds = RRect({ 0, 0, screenMode.GetScreenWidth(), screenMode.GetScreenHeight() }, 0.0f, 0.0f); + auto screenBounds = GetScreenBounds(screenId, screenMode); auto screenRefreshRate = screenMode.GetScreenRefreshRate(); - TLOGW(WmsLogTag::DMS, "Call rsInterface_ GetScreenCapability ScreenId: %{public}" PRIu64, screenId); - auto screenCapability = rsInterface_.GetScreenCapability(screenId); + TLOGW(WmsLogTag::DMS, "Call rsInterface_ GetScreenCapability ScreenId: %{public}" PRIu64, getScreenId); + auto screenCapability = rsInterface_.GetScreenCapability(getScreenId); HiviewDFX::XCollie::GetInstance().CancelTimer(id); TLOGW(WmsLogTag::DMS, "Call RS interface end, create ScreenProperty begin"); InitScreenProperty(screenId, screenMode, screenCapability, property); @@ -2512,7 +2521,7 @@ void ScreenSessionManager::CreateScreenProperty(ScreenId screenId, ScreenPropert void ScreenSessionManager::InitScreenProperty(ScreenId screenId, RSScreenModeInfo& screenMode, RSScreenCapability& screenCapability, ScreenProperty& property) { - auto screenBounds = RRect({ 0, 0, screenMode.GetScreenWidth(), screenMode.GetScreenHeight() }, 0.0f, 0.0f); + auto screenBounds = GetScreenBounds(screenId, screenMode); property.SetRotation(0.0f); property.SetPhyWidth(screenCapability.GetPhyWidth()); property.SetPhyHeight(screenCapability.GetPhyHeight()); @@ -2535,6 +2544,14 @@ void ScreenSessionManager::InitScreenProperty(ScreenId screenId, RSScreenModeInf property.SetScreenAreaHeight(property.GetPhyBounds().rect_.GetHeight()); } +RRect ScreenSessionManager::GetScreenBounds(ScreenId screenId, RSScreenModeInfo& screenMode) +{ + if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice() && screenId == SCREEN_ID_MAIN) { + return RRect({ 0, 0, MAIN_STATUS_WIDTH, SCREEN_HEIGHT }, 0.0f, 0.0f); + } + return RRect({ 0, 0, screenMode.GetScreenWidth(), screenMode.GetScreenHeight() }, 0.0f, 0.0f); +} + void ScreenSessionManager::GetInternalWidth() { ScreenId screenId = GetInternalScreenId(); @@ -5389,11 +5406,15 @@ DMError ScreenSessionManager::MakeExpand(std::vector screenId, std::shared_ptr rsDisplayNode; std::vector points; for (uint32_t i = 0; i < allExpandScreenIds.size(); i++) { - rsDisplayNode = GetRSDisplayNodeByScreenId(allExpandScreenIds[i]); - points.emplace_back(pointsMap[allExpandScreenIds[i]]); + ScreenId expandScreenId = allExpandScreenIds[i]; + if (pointsMap.find(expandScreenId) == pointsMap.end()) { + continue; + } + points.emplace_back(pointsMap[expandScreenId]); + rsDisplayNode = GetRSDisplayNodeByScreenId(expandScreenId); if (rsDisplayNode != nullptr) { - rsDisplayNode->SetDisplayOffset(pointsMap[allExpandScreenIds[i]].posX_, - pointsMap[allExpandScreenIds[i]].posY_); + SetScreenOffset(expandScreenId, pointsMap[expandScreenId].posX_, pointsMap[expandScreenId].posY_); + } } HITRACE_METER_FMT(HITRACE_TAG_WINDOW_MANAGER, "dms:MakeExpand"); @@ -6066,9 +6087,6 @@ std::shared_ptr ScreenSessionManager::GetScreenSnapshot(Display config.useDma = isUseDma; TLOGW(WmsLogTag::DMS, "dma=%{public}d", isUseDma); #ifdef FOLD_ABILITY_ENABLE - if (foldScreenController_ != nullptr && FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { - config.mainScreenRect = foldScreenController_->GetScreenSnapshotRect(); - } if (FoldScreenStateInternel::IsSuperFoldDisplayDevice() && SuperFoldPolicy::GetInstance().IsNeedSetSnapshotRect(displayId)) { config.mainScreenRect = SuperFoldPolicy::GetInstance().GetSnapshotRect(displayId, isCaptureFullOfScreen); @@ -6819,8 +6837,9 @@ DMError ScreenSessionManager::SetFoldDisplayModeInner(const FoldDisplayMode disp (displayMode == FoldDisplayMode::FULL || displayMode == FoldDisplayMode::COORDINATION)) { TLOGW(WmsLogTag::DMS, "in TentMode, SetFoldDisplayMode to %{public}d failed", displayMode); return DMError::DM_ERROR_INVALID_MODE_ID; - } else if (FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice() && - IsScreenCasting() && displayMode == FoldDisplayMode::COORDINATION) { + } else if ((FoldScreenStateInternel::IsSingleDisplayPocketFoldDevice() || + FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) && IsScreenCasting() && + displayMode == FoldDisplayMode::COORDINATION) { TLOGW(WmsLogTag::DMS, "is phone casting, SetFoldDisplayMode to %{public}d is not allowed", displayMode); return DMError::DM_ERROR_INVALID_MODE_ID; } @@ -9312,8 +9331,8 @@ void ScreenSessionManager::SetMultiScreenRelativePositionInner(sptr firstDisplayNode = firstScreenSession->GetDisplayNode(); std::shared_ptr secondDisplayNode = secondScreenSession->GetDisplayNode(); if (firstDisplayNode && secondDisplayNode) { - firstDisplayNode->SetDisplayOffset(mainScreenOptions.startX_, mainScreenOptions.startY_); - secondDisplayNode->SetDisplayOffset(secondScreenOption.startX_, secondScreenOption.startY_); + SetScreenOffset(firstScreenSession->GetScreenId(), mainScreenOptions.startX_, mainScreenOptions.startY_); + SetScreenOffset(secondScreenSession->GetScreenId(), secondScreenOption.startX_, secondScreenOption.startY_); } else { TLOGW(WmsLogTag::DMS, "DisplayNode is null"); } @@ -9339,7 +9358,8 @@ void ScreenSessionManager::SetRelativePositionForDisconnect(MultiScreenPositionO ScreenPropertyChangeReason::RELATIVE_POSITION_CHANGE); std::shared_ptr defaultDisplayNode = defaultScreenSession->GetDisplayNode(); if (defaultDisplayNode) { - defaultDisplayNode->SetDisplayOffset(defaultScreenOptions.startX_, defaultScreenOptions.startY_); + SetScreenOffset(defaultScreenSession->GetScreenId(), + defaultScreenOptions.startX_, defaultScreenOptions.startY_); } else { TLOGW(WmsLogTag::DMS, "DisplayNode is null"); } @@ -10370,27 +10390,17 @@ DMError ScreenSessionManager::SetPrimaryDisplaySystemDpi(float virtualPixelRatio return DMError::DM_OK; } -DMError ScreenSessionManager::SetVirtualScreenAutoRotation(ScreenId screenId, bool enable) +bool ScreenSessionManager::SetScreenOffset(ScreenId screenId, float offsetX, float offsetY) { - TLOGI(WmsLogTag::DMS, "enter"); - if (!SessionPermission::IsSystemCalling()) { - TLOGE(WmsLogTag::DMS, "permission denied!"); - return DMError::DM_ERROR_INVALID_PERMISSION; - } - - ScreenId rsScreenId = SCREEN_ID_INVALID; - bool res = ConvertScreenIdToRsScreenId(screenId, rsScreenId); - if (!res) { - TLOGE(WmsLogTag::DMS, "convert screenId to rsScreenId failed"); - return DMError::DM_ERROR_INVALID_PARAM; - } - TLOGI(WmsLogTag::DMS, "unique screenId: %{public}" PRIu64 " rsScreenId: %{public}" PRIu64, screenId, rsScreenId); - - auto ret = rsInterface_.SetVirtualScreenAutoRotation(rsScreenId, enable); - if (ret != StatusCode::SUCCESS) { - TLOGE(WmsLogTag::DMS, "rsInterface error: %{public}d", ret); - return DMError::DM_ERROR_INVALID_PARAM; + sptr screenSession = GetScreenSession(screenId); + if (screenSession == nullptr) { + TLOGE(WmsLogTag::DMS, "screenSession is null."); + return false; } - return DMError::DM_OK; + TLOGI(WmsLogTag::DMS, "screenId:%{public}" PRIu64 " rsId_:%{public}" PRIu64 \ + " GetRSScreenId:%{public}" PRIu64 " offsetX:%{public}f, offsetY:%{public}f", + screenId, screenSession->rsId_, screenSession->GetRSScreenId(), offsetX, offsetY); + RSInterfaces::GetInstance().SetScreenOffset(screenSession->rsId_, offsetX, offsetY); + return true; } } // namespace OHOS::Rosen diff --git a/window_scene/session/screen/include/screen_session.h b/window_scene/session/screen/include/screen_session.h index c91de2513c20722c33d08ca2bd801cb5dc0c2bab..f7e7888207feab6337c4786a39a7b08ed2135d47 100644 --- a/window_scene/session/screen/include/screen_session.h +++ b/window_scene/session/screen/include/screen_session.h @@ -159,7 +159,8 @@ public: DisplayOrientation CalcDisplayOrientation(Rotation rotation, FoldDisplayMode foldDisplayMode) const; DisplayOrientation CalcDeviceOrientation(Rotation rotation, FoldDisplayMode foldDisplayMode) const; void FillScreenInfo(sptr info) const; - void InitRSDisplayNode(RSDisplayNodeConfig& config, Point& startPoint, bool isExtend = false); + void InitRSDisplayNode(RSDisplayNodeConfig& config, Point& startPoint, bool isExtend = false, + float positionX = 0, float positionY = 0); DMError GetScreenSupportedColorGamuts(std::vector& colorGamuts); DMError GetScreenColorGamut(ScreenColorGamut& colorGamut); diff --git a/window_scene/session/screen/src/screen_session.cpp b/window_scene/session/screen/src/screen_session.cpp index 1f8cbf945ca7d7c2ef318d3196f96e9d457f0515..106aeedd52bbe660cfc0432c14f3295a92c06320 100644 --- a/window_scene/session/screen/src/screen_session.cpp +++ b/window_scene/session/screen/src/screen_session.cpp @@ -1750,7 +1750,8 @@ void ScreenSession::SetPrivateSessionForeground(bool hasPrivate) hasPrivateWindowForeground_ = hasPrivate; } -void ScreenSession::InitRSDisplayNode(RSDisplayNodeConfig& config, Point& startPoint, bool isExtend) +void ScreenSession::InitRSDisplayNode(RSDisplayNodeConfig& config, Point& startPoint, bool isExtend, + float positionX, float positionY) { std::unique_lock displayNodeLock(displayNodeMutex_); if (displayNode_ != nullptr) { @@ -1770,8 +1771,12 @@ void ScreenSession::InitRSDisplayNode(RSDisplayNodeConfig& config, Point& startP TLOGD(WmsLogTag::WMS_RS_CLI_MULTI_INST, "Create RSDisplayNode: %{public}s", RSAdapterUtil::RSNodeToStr(displayNode_).c_str()); } - TLOGI(WmsLogTag::DMS, "SetDisplayOffset: posX:%{public}d, posY:%{public}d", startPoint.posX_, startPoint.posY_); - displayNode_->SetDisplayOffset(startPoint.posX_, startPoint.posY_); + if (startPoint.posX_ < 0 || startPoint.posY_ < 0) { + TLOGE(WmsLogTag::DMS, "startPoint invalid!"); + return; + } + TLOGI(WmsLogTag::DMS, "posX:%{public}d, posY:%{public}d", startPoint.posX_, startPoint.posY_); + RSInterfaces::GetInstance().SetScreenOffset(config.screenId, startPoint.posX_, startPoint.posY_); uint32_t width = 0; uint32_t height = 0; if (isExtend) { @@ -1791,11 +1796,12 @@ void ScreenSession::InitRSDisplayNode(RSDisplayNodeConfig& config, Point& startP displayNode_->SetSecurityDisplay(isSecurity_); TLOGI(WmsLogTag::DMS, "virtualScreen SetSecurityDisplay success, isSecurity:%{public}d", isSecurity_); } - // If setDisplayOffset is not valid for SetFrame/SetBounds - TLOGI(WmsLogTag::DMS, "InitRSDisplayNode screenId:%{public}" PRIu64" width:%{public}u height:%{public}u", - screenId_, width, height); - displayNode_->SetFrame(0, 0, static_cast(width), static_cast(height)); - displayNode_->SetBounds(0, 0, static_cast(width), static_cast(height)); + // If SetScreenOffset is not valid for SetFrame/SetBounds + TLOGI(WmsLogTag::DMS, "InitRSDisplayNode screenId:%{public}" PRIu64" \ + width:%{public}u height:%{public}u positionX:%{public}f positionY:%{public}f", + screenId_, width, height, positionX, positionY); + displayNode_->SetFrame(positionX, positionY, static_cast(width), static_cast(height)); + displayNode_->SetBounds(positionX, positionY, static_cast(width), static_cast(height)); if (config.isMirrored) { EnableMirrorScreenRegion(); } @@ -1909,7 +1915,7 @@ bool ScreenSessionGroup::RemoveChild(sptr& smsScreen) smsScreen->groupSmsId_ = SCREEN_ID_INVALID; std::shared_ptr displayNode = smsScreen->GetDisplayNode(); if (displayNode != nullptr) { - displayNode->SetDisplayOffset(0, 0); + RSInterfaces::GetInstance().SetScreenOffset(smsScreen->rsId_, 0, 0); displayNode->RemoveFromTree(); smsScreen->ReleaseDisplayNode(); } @@ -2014,15 +2020,7 @@ void ScreenSession::Resize(uint32_t width, uint32_t height, bool isFreshBoundsSy void ScreenSession::SetFrameGravity(Gravity gravity) { - { - std::unique_lock displayNodeLock(displayNodeMutex_); - if (displayNode_ == nullptr) { - TLOGE(WmsLogTag::DMS, "displayNode_ is null, setFrameGravity failed"); - return; - } - displayNode_->SetFrameGravity(gravity); - } - RSTransactionAdapter::FlushImplicitTransaction(GetRSUIContext()); + RSInterfaces::GetInstance().SetScreenFrameGravity(rsId_, static_cast(gravity)); } bool ScreenSession::UpdateAvailableArea(DMRect area) diff --git a/window_scene/test/dms_unittest/screen_session_manager_test.cpp b/window_scene/test/dms_unittest/screen_session_manager_test.cpp index 4df9a5577d0b4b2bbc3c12ac22c2ac37877d292f..8a94e4cfe1f8bc2d1f6606176e4e7065235954df 100644 --- a/window_scene/test/dms_unittest/screen_session_manager_test.cpp +++ b/window_scene/test/dms_unittest/screen_session_manager_test.cpp @@ -7108,6 +7108,21 @@ HWTEST_F(ScreenSessionManagerTest, SwitchExternalScreenToMirror, TestSize.Level1 ssm_->DestroyVirtualScreen(screenId); ssm_->DestroyVirtualScreen(virtualScreenId); } + +/** + * @tc.name: SetScreenOffsetFeatureTest + * @tc.desc: SetScreenOffsetInner + * @tc.type: FUNC + */ +HWTEST_F(ScreenSessionManagerTest, SetScreenOffsetFeatureTest, Function | SmallTest | Level3) +{ + ScreenId screenId = 0; + EXPECT_TRUE(ssm_->SetScreenOffset(screenId, 0.0F, 0.0F)); + EXPECT_TRUE(ssm_->SetScreenOffset(screenId, 100.0F, 100.0F)); + screenId = -1; + EXPECT_FALSE(ssm_->SetScreenOffset(screenId, 0.0F, 0.0F)); + EXPECT_FALSE(ssm_->SetScreenOffset(screenId, 100.0F, 100.0F)); +} } } // namespace Rosen } // namespace OHOS diff --git a/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp b/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp index 646630c5dfba508e38c6eb2eb3bbcdd46d7e4458..56f0dac8d948cc73b8d068421669eafac2f142ef 100644 --- a/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp +++ b/window_scene/test/dms_unittest/secondary_display_fold_policy_test.cpp @@ -285,6 +285,7 @@ HWTEST_F(SecondaryDisplayFoldPolicyTest, SendPropertyChangeResult01, TestSize.Le std::vector secondaryDisplayParams = policy.GetScreenParams(); EXPECT_EQ(secondaryDisplayParams.size(), SECONDARY_INIT_PARAM_SIZE); + ScreenSessionManager::GetInstance().SetCoordinationFlag(true); FoldDisplayMode displayMode = FoldDisplayMode::MAIN; policy.SendPropertyChangeResult(screenSession, 0, ScreenPropertyChangeReason::UNDEFINED, displayMode); ScreenProperty screenProperty = screenSession->GetScreenProperty(); @@ -310,6 +311,7 @@ HWTEST_F(SecondaryDisplayFoldPolicyTest, SendPropertyChangeResult02, TestSize.Le std::vector secondaryDisplayParams = policy.GetScreenParams(); EXPECT_EQ(secondaryDisplayParams.size(), SECONDARY_INIT_PARAM_SIZE); + ScreenSessionManager::GetInstance().SetCoordinationFlag(true); FoldDisplayMode displayMode = FoldDisplayMode::FULL; policy.SendPropertyChangeResult(screenSession, 0, ScreenPropertyChangeReason::UNDEFINED, displayMode); ScreenProperty screenProperty = screenSession->GetScreenProperty(); @@ -335,6 +337,7 @@ HWTEST_F(SecondaryDisplayFoldPolicyTest, SendPropertyChangeResult03, TestSize.Le std::vector secondaryDisplayParams = policy.GetScreenParams(); EXPECT_EQ(secondaryDisplayParams.size(), SECONDARY_INIT_PARAM_SIZE); + ScreenSessionManager::GetInstance().SetCoordinationFlag(true); FoldDisplayMode displayMode = FoldDisplayMode::GLOBAL_FULL; policy.SendPropertyChangeResult(screenSession, 0, ScreenPropertyChangeReason::UNDEFINED, displayMode); ScreenProperty screenProperty = screenSession->GetScreenProperty(); @@ -618,6 +621,141 @@ HWTEST_F(SecondaryDisplayFoldPolicyTest, SetMainScreenRegion, TestSize.Level1) policy.SetMainScreenRegion(mainScreenRegion); EXPECT_EQ(mainScreenRegion, targetMainScreenRegion); } + +/** + * @tc.name: ChangeScreenDisplayModeToCoordinationFeatureTest + * @tc.desc: ChangeScreenDisplayModeToCoordinationFeatureTest + * @tc.type: FUNC + */ +HWTEST_F(SecondaryDisplayFoldPolicyTest, ChangeScreenDisplayModeToCoordinationFeatureTest, TestSize.Level1) +{ + if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { + GTEST_SKIP(); + } + std::recursive_mutex displayInfoMutex; + std::shared_ptr screenPowerTaskScheduler = nullptr; + SecondaryDisplayFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler); + + policy.screenPowerTaskScheduler_ = std::make_shared("Test"); + policy.ChangeScreenDisplayModeToCoordination(); + EXPECT_EQ(ScreenSessionManager::GetInstance().isCoordinationFlag_, true); +} + +/** + * @tc.name: CloseCoordinationScreenFeatureTest + * @tc.desc: CloseCoordinationScreenFeatureTest + * @tc.type: FUNC + */ +HWTEST_F(SecondaryDisplayFoldPolicyTest, CloseCoordinationScreenFeatureTest, TestSize.Level1) +{ + if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { + std::recursive_mutex displayInfoMutex; + std::shared_ptr screenPowerTaskScheduler = nullptr; + SecondaryDisplayFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler); + + policy.screenPowerTaskScheduler_ = std::make_shared("Test"); + policy.ChangeScreenDisplayModeToCoordination(); + policy.CloseCoordinationScreen(); + EXPECT_EQ(ScreenSessionManager::GetInstance().isCoordinationFlag_, false); + } +} + +/** + * @tc.name: AddOrRemoveDisplayNodeToTreeFeatureTest + * @tc.desc: AddOrRemoveDisplayNodeToTreeFeatureTest + * @tc.type: FUNC + */ +HWTEST_F(SecondaryDisplayFoldPolicyTest, AddOrRemoveDisplayNodeToTreeFeatureTest, TestSize.Level1) +{ + if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { + GTEST_SKIP(); + } + std::recursive_mutex displayInfoMutex; + std::shared_ptr screenPowerTaskScheduler = nullptr; + SecondaryDisplayFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler); + // test invalid screen + ScreenId screenId = -1; + int32_t command = 1; + policy.AddOrRemoveDisplayNodeToTree(screenId, command); + EXPECT_EQ(ScreenSessionManager::GetInstance().isCoordinationFlag_, false); + + // add to tree + screenId = 0; + command = 1; + policy.AddOrRemoveDisplayNodeToTree(screenId, command); + EXPECT_EQ(ScreenSessionManager::GetInstance().GetScreenSession(screenId), nullptr); + + // move from tree + screenId = 0; + command = 0; + policy.AddOrRemoveDisplayNodeToTree(screenId, command); + EXPECT_EQ(ScreenSessionManager::GetInstance().GetScreenSession(screenId), nullptr); +} + +/** + * @tc.name: ExitCoordinationFeatureTest + * @tc.desc: ExitCoordinationFeatureTest + * @tc.type: FUNC + */ +HWTEST_F(SecondaryDisplayFoldPolicyTest, ExitCoordinationFeatureTest, TestSize.Level1) +{ + if (FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { + std::recursive_mutex displayInfoMutex; + std::shared_ptr screenPowerTaskScheduler = nullptr; + SecondaryDisplayFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler); + + policy.currentFoldStatus_ = FoldStatus::EXPAND; + policy.ChangeScreenDisplayModeToCoordination(); + policy.ExitCoordination(); + EXPECT_FALSE(ScreenSessionManager::GetInstance().GetCoordinationFlag()); + } +} + +/** + * @tc.name: SetStatusConditionalActiveRectAndTpFeature + * @tc.desc: test function : SetStatusGlobalFullActiveRectAndTpFeature + * @tc.type: FUNC + */ +HWTEST_F(SecondaryDisplayFoldPolicyTest, SetStatusConditionalActiveRectAndTpFeature, TestSize.Level1) +{ + if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { + GTEST_SKIP(); + } + std::recursive_mutex displayInfoMutex; + std::shared_ptr screenPowerTaskScheduler = nullptr; + SecondaryDisplayFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler); + ScreenProperty property = policy.screenProperty_; + + policy.SetStatusConditionalActiveRectAndTpFeature(property); + EXPECT_FALSE(policy.onBootAnimation_); +} + +/** + * @tc.name: SendCoordinationPropertyChangeResultSync + * @tc.desc: test function : SendCoordinationPropertyChangeResultSync + * @tc.type: FUNC + */ +HWTEST_F(SecondaryDisplayFoldPolicyTest, SendCoordinationPropertyChangeResultSync, TestSize.Level1) +{ + if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) { + GTEST_SKIP(); + } + std::recursive_mutex displayInfoMutex; + std::shared_ptr screenPowerTaskScheduler = std::make_shared("test"); + SecondaryDisplayFoldPolicy policy(displayInfoMutex, screenPowerTaskScheduler); + sptr screenSession = new ScreenSession; + std::vector secondaryDisplayParams = policy.GetScreenParams(); + EXPECT_EQ(secondaryDisplayParams.size(), SECONDARY_INIT_PARAM_SIZE); + + ScreenSessionManager::GetInstance().SetCoordinationFlag(false); + FoldDisplayMode displayMode = FoldDisplayMode::COORDINATION; + policy.SendPropertyChangeResult(screenSession, 0, ScreenPropertyChangeReason::UNDEFINED, displayMode); + ScreenProperty screenProperty = screenSession->GetScreenProperty(); + uint32_t currentWidth = screenProperty.GetBounds().rect_.GetWidth(); + uint32_t currentHeight = screenProperty.GetBounds().rect_.GetHeight(); + EXPECT_EQ(currentWidth, secondaryDisplayParams[0]); + EXPECT_EQ(currentHeight, secondaryDisplayParams[INDEX_THREE]); +} } } // namespace Rosen -} // namespace OHOS \ No newline at end of file +} // namespace OHOS