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 #include <cinttypes>
17 #include <gtest/gtest.h>
18
19 #include "common_test_utils.h"
20 #include "display_test_utils.h"
21 #include "display_manager_proxy.h"
22 #include "future.h"
23 #include "pixel_map.h"
24 #include "screenshot_listener_future.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Rosen {
31 namespace {
32 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenshotTest"};
33 }
34 using Utils = DisplayTestUtils;
35 class ScreenshotListener;
36 class ScreenshotTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 virtual void SetUp() override;
41 virtual void TearDown() override;
42 static DisplayId defaultId_;
43 static Media::Rect defaultScreen_;
44 static Media::Size defaultImage_;
45 DisplayId invalidId_ = DISPLAY_ID_INVALID;
46 Media::Rect invalidRect_ = {-1, -1, -1, -1};
47 uint32_t defaultRot_ = 0;
48 };
49
50 DisplayId ScreenshotTest::defaultId_ = DISPLAY_ID_INVALID;
51 Media::Rect ScreenshotTest::defaultScreen_ = {0, 0, 0, 0};
52 Media::Size ScreenshotTest::defaultImage_ = {0, 0};
53
SetUpTestCase()54 void ScreenshotTest::SetUpTestCase()
55 {
56 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
57 const char** perms = new const char *[1];
58 perms[0] = "ohos.permission.CAPTURE_SCREEN";
59 CommonTestUtils::SetAceessTokenPermission("ScreenshotTest", perms, 1);
60
61 auto display = DisplayManager::GetInstance().GetDefaultDisplay();
62 if (display == nullptr) {
63 WLOGFE("GetDefaultDisplay: failed!\n");
64 return;
65 }
66 WLOGI("GetDefaultDisplay: id %" PRIu64", w %d, h %d, fps %u\n", display->GetId(), display->GetWidth(),
67 display->GetHeight(), display->GetRefreshRate());
68
69 defaultId_ = display->GetId();
70 defaultScreen_ = {0, 0, display->GetWidth(), display->GetHeight()};
71 defaultImage_ = {display->GetWidth(), display->GetHeight()};
72 }
73
TearDownTestCase()74 void ScreenshotTest::TearDownTestCase()
75 {
76 }
77
SetUp()78 void ScreenshotTest::SetUp()
79 {
80 }
81
TearDown()82 void ScreenshotTest::TearDown()
83 {
84 }
85
86 namespace {
87 /**
88 * @tc.name: ScreenShotValid
89 * @tc.desc: Check if screenshot of default display's ID is valid
90 * @tc.type: FUNC
91 */
92 HWTEST_F(ScreenshotTest, ScreenShotValid01, Function | MediumTest | Level2)
93 {
94 ASSERT_NE(nullptr, DisplayManager::GetInstance().GetScreenshot(defaultId_));
95 }
96
97 /**
98 * @tc.name: ScreenShotValid
99 * @tc.desc: Check if screenshot of invalid display's ID is nullptr
100 * @tc.type: FUNC
101 */
102 HWTEST_F(ScreenshotTest, ScreenShotValid02, Function | MediumTest | Level2)
103 {
104 ASSERT_EQ(nullptr, DisplayManager::GetInstance().GetScreenshot(invalidId_));
105 }
106
107 /**
108 * @tc.name: ScreenShotValid
109 * @tc.desc: Check if screenshot of default display's ID match default display's Media::Size
110 * @tc.type: FUNC
111 */
112 HWTEST_F(ScreenshotTest, ScreenShotValid03, Function | MediumTest | Level2)
113 {
114 auto& dm = DisplayManager::GetInstance();
115 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_);
116 ASSERT_NE(nullptr, screenshot);
117
118 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
119 ASSERT_TRUE(Utils::SizeEqualToDisplay(dm.GetDefaultDisplay(), screenSize));
120 }
121
122 /**
123 * @tc.name: ScreenShotValid
124 * @tc.desc: Check if screenshot created by default parameters is valid
125 * @tc.type: FUNC
126 */
127 HWTEST_F(ScreenshotTest, ScreenShotValid04, Function | MediumTest | Level2)
128 {
129 auto& dm = DisplayManager::GetInstance();
130 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
131 defaultImage_, defaultRot_);
132 ASSERT_NE(nullptr, screenshot);
133 }
134
135 /**
136 * @tc.name: ScreenShotValid
137 * @tc.desc: Check if screenshot match default imageSize
138 * @tc.type: FUNC
139 */
140 HWTEST_F(ScreenshotTest, ScreenShotValid05, Function | MediumTest | Level2)
141 {
142 auto& dm = DisplayManager::GetInstance();
143 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
144 defaultImage_, defaultRot_);
145 ASSERT_NE(nullptr, screenshot);
146 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
147 ASSERT_TRUE(Utils::SizeEqual(defaultImage_, screenSize));
148
149 Media::Size halfDefault_ = {defaultImage_.width / 2, defaultImage_.height / 2};
150 Media::Rect halfRect = {defaultScreen_.left, defaultScreen_.top, halfDefault_.width, halfDefault_.height};
151 screenshot = dm.GetScreenshot(defaultId_, halfRect, defaultImage_, defaultRot_);
152 ASSERT_NE(nullptr, screenshot);
153 screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
154 ASSERT_TRUE(Utils::SizeEqual(defaultImage_, screenSize));
155
156 Media::Size halfSize = {halfDefault_.width, halfDefault_.height};
157 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, halfSize, defaultRot_);
158 ASSERT_NE(nullptr, screenshot);
159 screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
160 ASSERT_TRUE(Utils::SizeEqual(halfSize, screenSize));
161 }
162
163 /**
164 * @tc.name: ScreenShotValid
165 * @tc.desc: Check if screenshot created by default parameters match default display's Media::Size
166 * @tc.type: FUNC
167 */
168 HWTEST_F(ScreenshotTest, ScreenShotValid06, Function | MediumTest | Level2)
169 {
170 auto& dm = DisplayManager::GetInstance();
171 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
172 defaultImage_, defaultRot_);
173 ASSERT_NE(nullptr, screenshot);
174 Media::Size screenSize = {screenshot->GetWidth(), screenshot->GetHeight()};
175 ASSERT_TRUE(Utils::SizeEqualToDisplay(dm.GetDefaultDisplay(), screenSize));
176 }
177
178 /**
179 * @tc.name: ScreenShotValid
180 * @tc.desc: Check if screenshot created by invalid display ID is nullptr
181 * @tc.type: FUNC
182 */
183 HWTEST_F(ScreenshotTest, ScreenShot07, Function | MediumTest | Level2)
184 {
185 auto& dm = DisplayManager::GetInstance();
186 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(invalidId_, defaultScreen_,
187 defaultImage_, defaultRot_);
188 ASSERT_EQ(nullptr, screenshot);
189 }
190
191 /**
192 * @tc.name: ScreenShotValid
193 * @tc.desc: Check if screenshot created by invalid screenRect is nullptr
194 * @tc.type: FUNC
195 */
196 HWTEST_F(ScreenshotTest, ScreenShot08, Function | MediumTest | Level2)
197 {
198 auto& dm = DisplayManager::GetInstance();
199 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, invalidRect_,
200 defaultImage_, defaultRot_);
201 ASSERT_EQ(nullptr, screenshot);
202 Media::Rect invalidScreen = {invalidRect_.left, defaultScreen_.top, defaultScreen_.width, defaultScreen_.height};
203 screenshot = dm.GetScreenshot(defaultId_, invalidScreen, defaultImage_, defaultRot_);
204 ASSERT_EQ(nullptr, screenshot);
205 invalidScreen = {defaultScreen_.left, defaultScreen_.top, invalidRect_.width, defaultScreen_.height};
206 screenshot = dm.GetScreenshot(defaultId_, invalidScreen, defaultImage_, defaultRot_);
207 ASSERT_EQ(nullptr, screenshot);
208 }
209
210 /**
211 * @tc.name: ScreenShotValid
212 * @tc.desc: Check if screenshot created by invalid imageSize is nullptr
213 * @tc.type: FUNC
214 */
215 HWTEST_F(ScreenshotTest, ScreenShot09, Function | MediumTest | Level2)
216 {
217 auto& dm = DisplayManager::GetInstance();
218 Media::Size invalidSize = {invalidRect_.width, invalidRect_.height};
219 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_, defaultScreen_,
220 invalidSize, defaultRot_);
221 ASSERT_EQ(nullptr, screenshot);
222 invalidSize = {invalidRect_.width, defaultScreen_.height};
223 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, invalidSize, defaultRot_);
224 ASSERT_EQ(nullptr, screenshot);
225 invalidSize = {defaultScreen_.width, invalidRect_.height};
226 screenshot = dm.GetScreenshot(defaultId_, defaultScreen_, invalidSize, defaultRot_);
227 ASSERT_EQ(nullptr, screenshot);
228 }
229
230 /**
231 * @tc.name: ScreenShotListener01
232 * @tc.desc: Check if screenshot listener info valid
233 * @tc.type: FUNC
234 * @tc.require: issueI5G62O
235 */
236 HWTEST_F(ScreenshotTest, ScreenShotListener01, Function | MediumTest | Level2)
237 {
238 sptr<ScreenshotListenerFuture> screenShotListener = new ScreenshotListenerFuture();
239
240 auto& dm = DisplayManager::GetInstance();
241 dm.RegisterScreenshotListener(screenShotListener);
242 std::shared_ptr<Media::PixelMap> screenshot = dm.GetScreenshot(defaultId_);
243 auto info = screenShotListener->future_.GetResult(1000);
244
245 ASSERT_NE(nullptr, screenshot);
246 ASSERT_EQ(info.GetDisplayId(), defaultId_);
247 ASSERT_GT(info.GetTrigger().size(), 0UL);
248
249 dm.UnregisterScreenshotListener(screenShotListener);
250 }
251 } // namespace
252 } // namespace Rosen
253 } // namespace OHOS