1 /* 2 * Copyright (c) 2025 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 #include "gtest/gtest.h" 17 #define private public 18 #define protected public 19 20 #include "ability_context_impl.h" 21 #include "adapter/ohos/entrance/rs_adapter.h" 22 #include "base/utils/system_properties.h" 23 #include "command/rs_base_node_command.h" 24 #include "core/components_ng/render/adapter/rosen_window.h" 25 #include "core/pipeline/pipeline_base.h" 26 #include "render_service_client/core/ui/rs_node.h" 27 #include "render_service_client/core/ui/rs_root_node.h" 28 #include "render_service_client/core/ui/rs_surface_node.h" 29 #include "render_service_client/core/ui/rs_ui_context.h" 30 #include "render_service_client/core/ui/rs_ui_director.h" 31 #include "wm/window.h" 32 33 34 using namespace testing; 35 using namespace testing::ext; 36 37 namespace OHOS::Ace::NG { 38 class RsAdapterTest : public testing::Test { 39 public: 40 static bool multiInstanceEnabledSaved_; 41 SetUpTestSuite()42 static void SetUpTestSuite() 43 { 44 RsAdapterTest::multiInstanceEnabledSaved_ = SystemProperties::GetMultiInstanceEnabled(); 45 } TearDownTestSuite()46 static void TearDownTestSuite() 47 { 48 SystemProperties::SetMultiInstanceEnabled(RsAdapterTest::multiInstanceEnabledSaved_); 49 } SetUp()50 void SetUp() {}; TearDown()51 void TearDown() {}; 52 }; 53 54 bool RsAdapterTest::multiInstanceEnabledSaved_ = false; 55 56 /** 57 * @tc.name: RsUIDirectorInit001 58 * @tc.desc: Test RsAdapterTest 59 * @tc.type: FUNC 60 */ 61 HWTEST_F(RsAdapterTest, RsUIDirectorInit001, TestSize.Level1) 62 { 63 #ifdef ENABLE_ROSEN_BACKEND 64 std::shared_ptr<OHOS::Rosen::RSUIDirector> rsUiDirector; 65 OHOS::sptr<OHOS::Rosen::WindowOption> windowOption = new OHOS::Rosen::WindowOption(); 66 windowOption->SetWindowType(Rosen::WindowType::WINDOW_TYPE_TRANSPARENT_VIEW); 67 auto context = std::make_shared<AbilityRuntime::AbilityContextImpl>(); 68 sptr<OHOS::Rosen::Window> window = OHOS::Rosen::Window::Create("test", windowOption, context); 69 70 EXPECT_NE(window, nullptr); 71 72 SystemProperties::SetMultiInstanceEnabled(false); 73 RsAdapter::RsUIDirectorInit(rsUiDirector, window, ""); 74 75 EXPECT_NE(rsUiDirector, nullptr); 76 EXPECT_EQ(rsUiDirector->GetRSUIContext(), nullptr); 77 78 EXPECT_EQ(OHOS::Rosen::WMError::WM_OK, window->Destroy()); 79 #endif 80 } 81 82 /** 83 * @tc.name: RsUIDirectorInit002 84 * @tc.desc: Test RsAdapterTest 85 * @tc.type: FUNC 86 */ 87 HWTEST_F(RsAdapterTest, RsUIDirectorInit002, TestSize.Level1) 88 { 89 #ifdef ENABLE_ROSEN_BACKEND 90 std::shared_ptr<OHOS::Rosen::RSUIDirector> rsUiDirector; 91 OHOS::sptr<OHOS::Rosen::WindowOption> windowOption = new OHOS::Rosen::WindowOption(); 92 windowOption->SetWindowType(Rosen::WindowType::WINDOW_TYPE_TRANSPARENT_VIEW); 93 auto context = std::make_shared<AbilityRuntime::AbilityContextImpl>(); 94 sptr<OHOS::Rosen::Window> window = OHOS::Rosen::Window::Create("test", windowOption, context); 95 96 EXPECT_NE(window, nullptr); 97 98 SystemProperties::SetMultiInstanceEnabled(true); 99 RsAdapter::RsUIDirectorInit(rsUiDirector, window, ""); 100 101 EXPECT_NE(rsUiDirector, nullptr); 102 103 EXPECT_EQ(OHOS::Rosen::WMError::WM_OK, window->Destroy()); 104 #endif 105 } 106 107 /** 108 * @tc.name: RsFlushImplicitTransaction001 109 * @tc.desc: Test RsAdapterTest 110 * @tc.type: FUNC 111 */ 112 HWTEST_F(RsAdapterTest, RsFlushImplicitTransaction001, TestSize.Level1) 113 { 114 #ifdef ENABLE_ROSEN_BACKEND 115 // Prerequisite 1 116 auto transactionProxy = Rosen::RSTransactionProxy::GetInstance(); 117 std::unique_ptr<Rosen::RSCommand> command = std::make_unique<Rosen::RSBaseNodeDestroy>(0); 118 if (transactionProxy != nullptr) { 119 auto renderThreadClient = Rosen::RSIRenderClient::CreateRenderThreadClient(); 120 transactionProxy->SetRenderThreadClient(renderThreadClient); 121 transactionProxy->AddCommonCommand(command); 122 transactionProxy->implicitCommonTransactionData_->abilityName_ = "test_ability"; 123 } 124 125 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, "test_ability"); 126 127 std::shared_ptr<OHOS::Rosen::RSUIDirector> rsUiDirector; 128 OHOS::sptr<OHOS::Rosen::WindowOption> windowOption = new OHOS::Rosen::WindowOption(); 129 windowOption->SetWindowType(Rosen::WindowType::WINDOW_TYPE_TRANSPARENT_VIEW); 130 sptr<OHOS::Rosen::Window> window = OHOS::Rosen::Window::Create("test", windowOption); 131 132 EXPECT_NE(window, nullptr); 133 134 SystemProperties::SetMultiInstanceEnabled(false); 135 auto surfaceNode = window->GetSurfaceNode(); 136 RsAdapter::RsFlushImplicitTransaction(rsUiDirector, window, surfaceNode); 137 138 EXPECT_NE(rsUiDirector, nullptr); 139 EXPECT_EQ(rsUiDirector->GetRSUIContext(), nullptr); 140 EXPECT_NE(rsUiDirector->GetRSSurfaceNode(), nullptr); 141 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, ""); 142 143 EXPECT_EQ(OHOS::Rosen::WMError::WM_OK, window->Destroy()); 144 #endif 145 } 146 147 /** 148 * @tc.name: RsFlushImplicitTransaction002 149 * @tc.desc: Test RsAdapterTest 150 * @tc.type: FUNC 151 */ 152 HWTEST_F(RsAdapterTest, RsFlushImplicitTransaction002, TestSize.Level1) 153 { 154 #ifdef ENABLE_ROSEN_BACKEND 155 // Prerequisite 1 156 auto transactionProxy = Rosen::RSTransactionProxy::GetInstance(); 157 std::unique_ptr<Rosen::RSCommand> command = std::make_unique<Rosen::RSBaseNodeDestroy>(0); 158 if (transactionProxy != nullptr) { 159 auto renderThreadClient = Rosen::RSIRenderClient::CreateRenderThreadClient(); 160 transactionProxy->SetRenderThreadClient(renderThreadClient); 161 transactionProxy->AddCommonCommand(command); 162 transactionProxy->implicitCommonTransactionData_->abilityName_ = "test_ability"; 163 } 164 165 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, "test_ability"); 166 167 std::shared_ptr<OHOS::Rosen::RSUIDirector> rsUiDirector; 168 OHOS::sptr<OHOS::Rosen::WindowOption> windowOption = new OHOS::Rosen::WindowOption(); 169 windowOption->SetWindowType(Rosen::WindowType::WINDOW_TYPE_TRANSPARENT_VIEW); 170 auto context = std::make_shared<AbilityRuntime::AbilityContextImpl>(); 171 sptr<OHOS::Rosen::Window> window = OHOS::Rosen::Window::Create("test", windowOption, context); 172 173 EXPECT_NE(window, nullptr); 174 175 SystemProperties::SetMultiInstanceEnabled(true); 176 std::shared_ptr<OHOS::Rosen::RSSurfaceNode> surfaceNode; 177 RsAdapter::RsFlushImplicitTransaction(rsUiDirector, window, surfaceNode); 178 179 EXPECT_NE(rsUiDirector, nullptr); 180 EXPECT_EQ(rsUiDirector->GetRSSurfaceNode(), nullptr); 181 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, ""); 182 183 EXPECT_EQ(OHOS::Rosen::WMError::WM_OK, window->Destroy()); 184 #endif 185 } 186 187 /** 188 * @tc.name: RsFlushImplicitTransactionWithRoot001 189 * @tc.desc: Test RsAdapterTest 190 * @tc.type: FUNC 191 */ 192 HWTEST_F(RsAdapterTest, RsFlushImplicitTransactionWithRoot001, TestSize.Level1) 193 { 194 #ifdef ENABLE_ROSEN_BACKEND 195 // Prerequisite 1 196 auto transactionProxy = Rosen::RSTransactionProxy::GetInstance(); 197 std::unique_ptr<Rosen::RSCommand> command = std::make_unique<Rosen::RSBaseNodeDestroy>(0); 198 if (transactionProxy != nullptr) { 199 auto renderThreadClient = Rosen::RSIRenderClient::CreateRenderThreadClient(); 200 transactionProxy->SetRenderThreadClient(renderThreadClient); 201 transactionProxy->AddCommonCommand(command); 202 transactionProxy->implicitCommonTransactionData_->abilityName_ = "test_ability"; 203 } 204 205 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, "test_ability"); 206 207 std::shared_ptr<OHOS::Rosen::RSUIDirector> rsUiDirector; 208 OHOS::sptr<OHOS::Rosen::WindowOption> windowOption = new OHOS::Rosen::WindowOption(); 209 windowOption->SetWindowType(Rosen::WindowType::WINDOW_TYPE_TRANSPARENT_VIEW); 210 auto context = std::make_shared<AbilityRuntime::AbilityContextImpl>(); 211 sptr<OHOS::Rosen::Window> window = OHOS::Rosen::Window::Create("test", windowOption, context); 212 213 EXPECT_NE(window, nullptr); 214 215 SystemProperties::SetMultiInstanceEnabled(false); 216 auto surfaceNode = window->GetSurfaceNode(); 217 std::shared_ptr<OHOS::Rosen::RSNode> rootNode; 218 RsAdapter::RsFlushImplicitTransactionWithRoot(rsUiDirector, window, surfaceNode, rootNode); 219 220 EXPECT_NE(rsUiDirector, nullptr); 221 EXPECT_EQ(rsUiDirector->GetRSUIContext(), nullptr); 222 EXPECT_NE(rsUiDirector->GetRSSurfaceNode(), nullptr); 223 EXPECT_NE(rootNode, nullptr); 224 EXPECT_EQ(rootNode->GetRSUIContext(), nullptr); 225 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, ""); 226 227 EXPECT_EQ(OHOS::Rosen::WMError::WM_OK, window->Destroy()); 228 #endif 229 } 230 231 /** 232 * @tc.name: RsFlushImplicitTransactionWithRoot002 233 * @tc.desc: Test RsAdapterTest 234 * @tc.type: FUNC 235 */ 236 HWTEST_F(RsAdapterTest, RsFlushImplicitTransactionWithRoot002, TestSize.Level1) 237 { 238 #ifdef ENABLE_ROSEN_BACKEND 239 // Prerequisite 1 240 auto transactionProxy = Rosen::RSTransactionProxy::GetInstance(); 241 std::unique_ptr<Rosen::RSCommand> command = std::make_unique<Rosen::RSBaseNodeDestroy>(0); 242 if (transactionProxy != nullptr) { 243 auto renderThreadClient = Rosen::RSIRenderClient::CreateRenderThreadClient(); 244 transactionProxy->SetRenderThreadClient(renderThreadClient); 245 transactionProxy->AddCommonCommand(command); 246 transactionProxy->implicitCommonTransactionData_->abilityName_ = "test_ability"; 247 } 248 249 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, "test_ability"); 250 251 std::shared_ptr<OHOS::Rosen::RSUIDirector> rsUiDirector; 252 OHOS::sptr<OHOS::Rosen::WindowOption> windowOption = new OHOS::Rosen::WindowOption(); 253 windowOption->SetWindowType(Rosen::WindowType::WINDOW_TYPE_TRANSPARENT_VIEW); 254 auto context = std::make_shared<AbilityRuntime::AbilityContextImpl>(); 255 sptr<OHOS::Rosen::Window> window = OHOS::Rosen::Window::Create("test", windowOption, context); 256 257 EXPECT_NE(window, nullptr); 258 259 SystemProperties::SetMultiInstanceEnabled(true); 260 auto surfaceNode = window->GetSurfaceNode(); 261 std::shared_ptr<OHOS::Rosen::RSNode> rootNode; 262 RsAdapter::RsFlushImplicitTransactionWithRoot(rsUiDirector, window, surfaceNode, rootNode); 263 264 EXPECT_NE(rsUiDirector, nullptr); 265 EXPECT_NE(rsUiDirector->GetRSSurfaceNode(), nullptr); 266 EXPECT_NE(rootNode, nullptr); 267 EXPECT_EQ(rootNode->GetRSUIContext(), nullptr); 268 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, ""); 269 270 EXPECT_EQ(OHOS::Rosen::WMError::WM_OK, window->Destroy()); 271 #endif 272 } 273 274 /** 275 * @tc.name: FlushImplicitTransaction001 276 * @tc.desc: Test RsAdapterTest 277 * @tc.type: FUNC 278 */ 279 HWTEST_F(RsAdapterTest, FlushImplicitTransaction001, TestSize.Level1) 280 { 281 #ifdef ENABLE_ROSEN_BACKEND 282 // Prerequisite 1 283 auto transactionProxy = Rosen::RSTransactionProxy::GetInstance(); 284 std::unique_ptr<Rosen::RSCommand> command = std::make_unique<Rosen::RSBaseNodeDestroy>(0); 285 if (transactionProxy != nullptr) { 286 auto renderThreadClient = Rosen::RSIRenderClient::CreateRenderThreadClient(); 287 transactionProxy->SetRenderThreadClient(renderThreadClient); 288 transactionProxy->AddCommonCommand(command); 289 transactionProxy->implicitCommonTransactionData_->abilityName_ = "test_ability"; 290 } 291 292 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, "test_ability"); 293 294 RsAdapter::FlushImplicitTransaction(); 295 296 EXPECT_EQ(transactionProxy->implicitCommonTransactionData_->abilityName_, ""); 297 #endif 298 } 299 300 } // namespace OHOS::Ace::NG