1 /*
2 * Copyright (c) 2023 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 <cstdint>
17 #include <cstring>
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20 #include <securec.h>
21 #include <thread>
22
23 #include "accesstoken_kit.h"
24 #include "foundation/graphic/graphic_surface/surface/include/surface_buffer_impl.h"
25 #include "nativetoken_kit.h"
26 #include "nweb_adapter_helper.h"
27 #include "screen_capture.h"
28 #include "token_setproc.h"
29
30 #define private public
31 #include "screen_capture_adapter_impl.h"
32 #undef private
33 #include "foundation/multimedia/player_framework/interfaces/inner_api/native/media_errors.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37 using namespace OHOS::Rosen;
38 using namespace OHOS::Media;
39
40 namespace OHOS {
41 namespace Media {
42 class ScreenCaptureImplMock : public ScreenCapture {
43 public:
44 MOCK_METHOD0(Init, int32_t());
45 MOCK_METHOD1(Init, int32_t(AVScreenCaptureConfig));
46 MOCK_METHOD1(SetMicrophoneEnabled, int32_t(bool));
47 MOCK_METHOD1(SetCanvasRotation, int32_t(bool));
48 MOCK_METHOD2(ResizeCanvas, int32_t(int32_t, int32_t));
49 MOCK_METHOD1(SkipPrivacyMode, int32_t(std::vector<uint64_t>&));
50 MOCK_METHOD0(StartScreenCapture, int32_t());
51 MOCK_METHOD1(StartScreenCaptureWithSurface, int32_t(sptr<Surface>));
52 MOCK_METHOD0(StopScreenCapture, int32_t());
53 MOCK_METHOD0(StartScreenRecording, int32_t());
54 MOCK_METHOD0(StopScreenRecording, int32_t());
55 MOCK_METHOD2(AcquireAudioBuffer, int32_t(std::shared_ptr<AudioBuffer>&, AudioCaptureSourceType));
56 MOCK_METHOD3(AcquireVideoBuffer, sptr<OHOS::SurfaceBuffer>(int32_t&, int64_t&, OHOS::Rect&));
57 MOCK_METHOD1(ReleaseAudioBuffer, int32_t(AudioCaptureSourceType));
58 MOCK_METHOD0(ReleaseVideoBuffer, int32_t());
59 MOCK_METHOD0(Release, int32_t());
60 MOCK_METHOD1(SetScreenCaptureCallback, int32_t(const std::shared_ptr<ScreenCaptureCallBack>&));
61 MOCK_METHOD1(ExcludeContent, int32_t(ScreenCaptureContentFilter&));
62 MOCK_METHOD0(SetPrivacyAuthorityEnabled, int32_t());
63 };
64 } // namespace Media
65 namespace NWeb {
66
67 class MockAudioCaptureInfoAdapter : public AudioCaptureInfoAdapter {
68 public:
69 MockAudioCaptureInfoAdapter() = default;
70
GetAudioSampleRate()71 int32_t GetAudioSampleRate() override
72 {
73 return audioSampleRate;
74 }
75
GetAudioChannels()76 int32_t GetAudioChannels() override
77 {
78 return audioChannels;
79 }
80
GetAudioSource()81 AudioCaptureSourceTypeAdapter GetAudioSource() override
82 {
83 return audioSource;
84 }
85
86 int32_t audioSampleRate;
87 int32_t audioChannels;
88 AudioCaptureSourceTypeAdapter audioSource = AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT;
89 };
90
91 class MockAudioEncInfoAdapter : public AudioEncInfoAdapter {
92 public:
93 MockAudioEncInfoAdapter() = default;
94
GetAudioBitrate()95 int32_t GetAudioBitrate() override
96 {
97 return audioBitrate;
98 }
99
GetAudioCodecformat()100 AudioCodecFormatAdapter GetAudioCodecformat() override
101 {
102 return audioCodecformat;
103 }
104
105 int32_t audioBitrate = 0;
106 AudioCodecFormatAdapter audioCodecformat = AudioCodecFormatAdapter::AUDIO_DEFAULT;
107 };
108
109 class MockAudioInfoAdapter : public AudioInfoAdapter {
110 public:
111 MockAudioInfoAdapter() = default;
112
GetMicCapInfo()113 std::shared_ptr<AudioCaptureInfoAdapter> GetMicCapInfo() override
114 {
115 return micCapInfo;
116 }
117
GetInnerCapInfo()118 std::shared_ptr<AudioCaptureInfoAdapter> GetInnerCapInfo() override
119 {
120 return innerCapInfo;
121 }
122
GetAudioEncInfo()123 std::shared_ptr<AudioEncInfoAdapter> GetAudioEncInfo() override
124 {
125 return audioEncInfo;
126 }
127
128 std::shared_ptr<MockAudioCaptureInfoAdapter> micCapInfo = nullptr;
129 std::shared_ptr<MockAudioCaptureInfoAdapter> innerCapInfo = nullptr;
130 std::shared_ptr<MockAudioEncInfoAdapter> audioEncInfo = nullptr;
131 };
132
133 class MockVideoCaptureInfoAdapter : public VideoCaptureInfoAdapter {
134 public:
135 MockVideoCaptureInfoAdapter() = default;
136
GetDisplayId()137 uint64_t GetDisplayId() override
138 {
139 return displayId;
140 }
141
GetTaskIDs()142 std::list<int32_t> GetTaskIDs() override
143 {
144 return taskIDs;
145 }
146
GetVideoFrameWidth()147 int32_t GetVideoFrameWidth() override
148 {
149 return videoFrameWidth;
150 }
151
GetVideoFrameHeight()152 int32_t GetVideoFrameHeight() override
153 {
154 return videoFrameHeight;
155 }
156
GetVideoSourceType()157 VideoSourceTypeAdapter GetVideoSourceType() override
158 {
159 return videoSource;
160 }
161
162 uint64_t displayId = 0;
163 std::list<int32_t> taskIDs;
164 int32_t videoFrameWidth = 0;
165 int32_t videoFrameHeight = 0;
166 VideoSourceTypeAdapter videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_RGBA;
167 };
168
169 class MockVideoEncInfoAdapter : public VideoEncInfoAdapter {
170 public:
171 MockVideoEncInfoAdapter() = default;
172
GetVideoCodecFormat()173 VideoCodecFormatAdapter GetVideoCodecFormat() override
174 {
175 return videoCodec;
176 }
177
GetVideoBitrate()178 int32_t GetVideoBitrate() override
179 {
180 return videoBitrate;
181 }
182
GetVideoFrameRate()183 int32_t GetVideoFrameRate() override
184 {
185 return videoFrameRate;
186 }
187
188 VideoCodecFormatAdapter videoCodec = VideoCodecFormatAdapter::VIDEO_DEFAULT;
189 int32_t videoBitrate = 0;
190 int32_t videoFrameRate = 0;
191 };
192
193 class MockVideoInfoAdapter : public VideoInfoAdapter {
194 public:
195 MockVideoInfoAdapter() = default;
196
GetVideoCapInfo()197 std::shared_ptr<VideoCaptureInfoAdapter> GetVideoCapInfo()
198 {
199 return videoCapInfo;
200 }
201
GetVideoEncInfo()202 std::shared_ptr<VideoEncInfoAdapter> GetVideoEncInfo()
203 {
204 return videoEncInfo;
205 }
206
207 std::shared_ptr<MockVideoCaptureInfoAdapter> videoCapInfo = nullptr;
208 std::shared_ptr<MockVideoEncInfoAdapter> videoEncInfo = nullptr;
209 };
210
211 class MockRecorderInfoAdapter : public RecorderInfoAdapter {
212 public:
213 MockRecorderInfoAdapter() = default;
214
GetUrl()215 std::string GetUrl() override
216 {
217 return url;
218 }
219
GetFileFormat()220 ContainerFormatTypeAdapter GetFileFormat() override
221 {
222 return fileFormat;
223 }
224
225 std::string url = "";
226 ContainerFormatTypeAdapter fileFormat = ContainerFormatTypeAdapter::CFT_MPEG_4A_TYPE;
227 };
228
229 class MockScreenCaptureConfigAdapter : public ScreenCaptureConfigAdapter {
230 public:
231 MockScreenCaptureConfigAdapter() = default;
232
GetCaptureMode()233 CaptureModeAdapter GetCaptureMode() override
234 {
235 return captureMode;
236 }
237
GetDataType()238 DataTypeAdapter GetDataType() override
239 {
240 return dataType;
241 }
242
GetAudioInfo()243 std::shared_ptr<AudioInfoAdapter> GetAudioInfo()
244 {
245 return audioInfo;
246 }
247
GetVideoInfo()248 std::shared_ptr<VideoInfoAdapter> GetVideoInfo()
249 {
250 return videoInfo;
251 }
252
GetRecorderInfo()253 std::shared_ptr<RecorderInfoAdapter> GetRecorderInfo()
254 {
255 return recorderInfo;
256 }
257
258 CaptureModeAdapter captureMode = CaptureModeAdapter::CAPTURE_INVAILD;
259 DataTypeAdapter dataType = DataTypeAdapter::INVAILD_DATA_TYPE;
260 std::shared_ptr<MockAudioInfoAdapter> audioInfo = nullptr;
261 std::shared_ptr<MockVideoInfoAdapter> videoInfo = nullptr;
262 std::shared_ptr<MockRecorderInfoAdapter> recorderInfo = nullptr;
263 };
264
265 namespace {
266 constexpr int32_t AUDIO_SAMPLE_RATE = 16000;
267 constexpr int32_t AUDIO_CHANNELS = 2;
268 constexpr int32_t SCREEN_WIDTH = 1080;
269 constexpr int32_t SCREEN_HEIGHT = 720;
270 std::shared_ptr<ScreenCaptureAdapterImpl> g_screenCapture = nullptr;
271 std::shared_ptr<MockAudioCaptureInfoAdapter> g_micCapInfo = nullptr;
272 std::shared_ptr<MockAudioCaptureInfoAdapter> g_innerCapInfo = nullptr;
273 std::shared_ptr<MockAudioEncInfoAdapter> g_audioEncInfo = nullptr;
274 std::shared_ptr<MockAudioInfoAdapter> g_audioInfo = nullptr;
275 std::shared_ptr<MockVideoCaptureInfoAdapter> g_videoCaptureInfo = nullptr;
276 std::shared_ptr<MockVideoEncInfoAdapter> g_videoEncInfo = nullptr;
277 std::shared_ptr<MockVideoInfoAdapter> g_videoInfo = nullptr;
278 std::shared_ptr<MockRecorderInfoAdapter> g_recorderInfo = nullptr;
279 std::shared_ptr<MockScreenCaptureConfigAdapter> g_screenCaptureConfig = nullptr;
280
281 class ScreenCaptureCallbackAdapterTest : public ScreenCaptureCallbackAdapter {
282 public:
283 ScreenCaptureCallbackAdapterTest() = default;
284 ~ScreenCaptureCallbackAdapterTest() override = default;
285
OnError(int32_t errorCode)286 void OnError(int32_t errorCode) override
287 {
288 (void)errorCode;
289 }
290
OnAudioBufferAvailable(bool isReady,AudioCaptureSourceTypeAdapter type)291 void OnAudioBufferAvailable(bool isReady, AudioCaptureSourceTypeAdapter type) override
292 {
293 (void)isReady;
294 (void)type;
295 }
296
OnVideoBufferAvailable(bool isReady)297 void OnVideoBufferAvailable(bool isReady) override
298 {
299 if (!isReady || !g_screenCapture) {
300 return;
301 }
302 std::shared_ptr<SurfaceBufferAdapter> buffer = g_screenCapture->AcquireVideoBuffer();
303 if (buffer) {
304 g_screenCapture->ReleaseVideoBuffer();
305 }
306 }
307 };
308 } // namespace
309
310 class ScreenCaptureAdapterImplTest : public testing::Test {
311 public:
312 static void SetUpTestCase(void);
313 static void TearDownTestCase(void);
314 void SetUp();
315 void TearDown();
316 };
317
SetUpTestCase(void)318 void ScreenCaptureAdapterImplTest::SetUpTestCase(void)
319 {
320 // set native token
321 uint64_t tokenId;
322 const char* perms[2];
323 perms[0] = "ohos.permission.CAPTURE_SCREEN";
324 perms[1] = "ohos.permission.MICROPHONE";
325 NativeTokenInfoParams infoInstance = {
326 .dcapsNum = 0,
327 .permsNum = 1,
328 .aclsNum = 0,
329 .dcaps = NULL,
330 .perms = perms,
331 .acls = NULL,
332 .processName = "web_screen_capture_tdd",
333 .aplStr = "system_basic",
334 };
335 tokenId = GetAccessTokenId(&infoInstance);
336 SetSelfTokenID(tokenId);
337 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
338
339 g_screenCapture = std::make_shared<ScreenCaptureAdapterImpl>();
340 g_micCapInfo = std::make_shared<MockAudioCaptureInfoAdapter>();
341 g_innerCapInfo = std::make_shared<MockAudioCaptureInfoAdapter>();
342 g_audioEncInfo = std::make_shared<MockAudioEncInfoAdapter>();
343 g_audioInfo = std::make_shared<MockAudioInfoAdapter>();
344 g_videoCaptureInfo = std::make_shared<MockVideoCaptureInfoAdapter>();
345 g_videoEncInfo = std::make_shared<MockVideoEncInfoAdapter>();
346 g_videoInfo = std::make_shared<MockVideoInfoAdapter>();
347 g_recorderInfo = std::make_shared<MockRecorderInfoAdapter>();
348 g_screenCaptureConfig = std::make_shared<MockScreenCaptureConfigAdapter>();
349
350 EXPECT_NE(g_screenCapture, nullptr);
351 EXPECT_NE(g_micCapInfo, nullptr);
352 EXPECT_NE(g_innerCapInfo, nullptr);
353 EXPECT_NE(g_audioEncInfo, nullptr);
354 EXPECT_NE(g_audioInfo, nullptr);
355 EXPECT_NE(g_videoCaptureInfo, nullptr);
356 EXPECT_NE(g_videoEncInfo, nullptr);
357 EXPECT_NE(g_videoInfo, nullptr);
358 EXPECT_NE(g_recorderInfo, nullptr);
359 EXPECT_NE(g_screenCaptureConfig, nullptr);
360 int32_t result = g_screenCapture->Init(nullptr);
361 EXPECT_EQ(result, -1);
362
363 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_HOME_SCREEN;
364 g_screenCaptureConfig->dataType = DataTypeAdapter::ORIGINAL_STREAM_DATA_TYPE;
365 g_micCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
366 g_micCapInfo->audioChannels = AUDIO_CHANNELS;
367 g_innerCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
368 g_innerCapInfo->audioChannels = AUDIO_CHANNELS;
369 g_audioInfo->micCapInfo = g_micCapInfo;
370 g_audioInfo->innerCapInfo = g_innerCapInfo;
371 g_audioInfo->audioEncInfo = g_audioEncInfo;
372 g_videoCaptureInfo->videoFrameWidth = SCREEN_WIDTH;
373 g_videoCaptureInfo->videoFrameHeight = SCREEN_HEIGHT;
374 g_videoInfo->videoCapInfo = g_videoCaptureInfo;
375 g_videoInfo->videoEncInfo = g_videoEncInfo;
376 result = g_screenCapture->Init(g_screenCaptureConfig);
377 EXPECT_EQ(result, 0);
378 g_screenCaptureConfig->audioInfo = g_audioInfo;
379 result = g_screenCapture->Init(g_screenCaptureConfig);
380 EXPECT_EQ(result, 0);
381 g_screenCaptureConfig->videoInfo = g_videoInfo;
382 result = g_screenCapture->Init(g_screenCaptureConfig);
383 EXPECT_EQ(result, 0);
384 g_screenCaptureConfig->recorderInfo = g_recorderInfo;
385 result = g_screenCapture->Init(g_screenCaptureConfig);
386 EXPECT_EQ(result, 0);
387 }
388
TearDownTestCase(void)389 void ScreenCaptureAdapterImplTest::TearDownTestCase(void) {}
390
SetUp(void)391 void ScreenCaptureAdapterImplTest::SetUp(void) {}
392
TearDown(void)393 void ScreenCaptureAdapterImplTest::TearDown(void) {}
394
395 /**
396 * @tc.name: ScreenCaptureAdapterImplTest_Init_001
397 * @tc.desc: Init.
398 * @tc.type: FUNC
399 * @tc.require: AR000I7I57
400 */
401 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_Init_001, TestSize.Level1)
402 {
403 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
404 EXPECT_NE(adapterImpl, nullptr);
405 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_INVAILD;
406 g_screenCaptureConfig->dataType = DataTypeAdapter::INVAILD_DATA_TYPE;
407 g_screenCaptureConfig->audioInfo->micCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
408 g_screenCaptureConfig->audioInfo->micCapInfo->audioChannels = AUDIO_CHANNELS;
409 g_screenCaptureConfig->audioInfo->innerCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
410 g_screenCaptureConfig->audioInfo->innerCapInfo->audioChannels = AUDIO_CHANNELS;
411 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameWidth = SCREEN_WIDTH;
412 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameHeight = SCREEN_HEIGHT;
413 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::SOURCE_INVALID;
414 g_screenCaptureConfig->audioInfo->audioEncInfo->audioCodecformat = AudioCodecFormatAdapter::AUDIO_DEFAULT;
415 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_YUV;
416 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VIDEO_DEFAULT;
417 int32_t result = adapterImpl->Init(g_screenCaptureConfig);
418 EXPECT_EQ(result, -1);
419 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_HOME_SCREEN;
420 g_screenCaptureConfig->dataType = DataTypeAdapter::ENCODED_STREAM_DATA_TYPE;
421 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT;
422 g_screenCaptureConfig->audioInfo->audioEncInfo->audioCodecformat = AudioCodecFormatAdapter::AAC_LC;
423 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_ES;
424 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::H264;
425 result = adapterImpl->Init(g_screenCaptureConfig);
426 EXPECT_EQ(result, -1);
427 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_SPECIFIED_SCREEN;
428 g_screenCaptureConfig->dataType = DataTypeAdapter::CAPTURE_FILE_DATA_TYPE;
429 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::MIC;
430 g_screenCaptureConfig->audioInfo->audioEncInfo->audioCodecformat = AudioCodecFormatAdapter::AUDIO_CODEC_FORMAT_BUTT;
431 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_RGBA;
432 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::H265;
433 result = adapterImpl->Init(g_screenCaptureConfig);
434 EXPECT_EQ(result, -1);
435 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_SPECIFIED_WINDOW;
436 g_screenCaptureConfig->dataType = DataTypeAdapter::ORIGINAL_STREAM_DATA_TYPE;
437 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::ALL_PLAYBACK;
438 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_BUTT;
439 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::MPEG4;
440 result = adapterImpl->Init(g_screenCaptureConfig);
441 EXPECT_EQ(result, -1);
442 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::APP_PLAYBACK;
443 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VP8;
444 result = adapterImpl->Init(g_screenCaptureConfig);
445 EXPECT_EQ(result, -1);
446 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VP9;
447 result = adapterImpl->Init(g_screenCaptureConfig);
448 EXPECT_EQ(result, -1);
449 }
450
451 /**
452 * @tc.name: ScreenCaptureAdapterImplTest_SetMicrophoneEnable_002
453 * @tc.desc: SetMicrophoneEnable.
454 * @tc.type: FUNC
455 * @tc.require: AR000I7I57
456 */
457 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_SetMicrophoneEnable_002, TestSize.Level1)
458 {
459 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
460 EXPECT_NE(adapterImpl, nullptr);
461 int32_t result = adapterImpl->SetMicrophoneEnable(false);
462 EXPECT_EQ(result, -1);
463 result = g_screenCapture->SetMicrophoneEnable(false);
464 EXPECT_EQ(result, 0);
465 result = g_screenCapture->SetMicrophoneEnable(true);
466 EXPECT_EQ(result, 0);
467 }
468
469 /**
470 * @tc.name: ScreenCaptureAdapterImplTest_AcquireVideoBuffer_003
471 * @tc.desc: AcquireVideoBuffer.
472 * @tc.type: FUNC
473 * @tc.require: AR000I7I57
474 */
475 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_AcquireVideoBuffer_003, TestSize.Level1)
476 {
477 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
478 EXPECT_NE(adapterImpl, nullptr);
479 std::shared_ptr<SurfaceBufferAdapter> buffer = adapterImpl->AcquireVideoBuffer();
480 EXPECT_EQ(buffer, nullptr);
481 int32_t result = adapterImpl->ReleaseVideoBuffer();
482 EXPECT_EQ(result, -1);
483 g_screenCapture->AcquireVideoBuffer();
484 g_screenCapture->ReleaseVideoBuffer();
485 }
486
487 /**
488 * @tc.name: ScreenCaptureAdapterImplTest_Capture_004
489 * @tc.desc: Capture.
490 * @tc.type: FUNC
491 * @tc.require: AR000I7I57
492 */
493 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_Capture_004, TestSize.Level1)
494 {
495 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
496 EXPECT_NE(adapterImpl, nullptr);
497 int32_t result = adapterImpl->StartCapture();
498 EXPECT_EQ(result, -1);
499 result = adapterImpl->StopCapture();
500 EXPECT_EQ(result, -1);
501 ScreenCaptureImplMock* mock = new ScreenCaptureImplMock();
502 EXPECT_NE(mock, nullptr);
503 adapterImpl->screenCapture_.reset(mock);
504 EXPECT_CALL(*mock, StartScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_OK));
505 EXPECT_CALL(*mock, StopScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_OK));
506 EXPECT_CALL(*mock, SetMicrophoneEnabled(::testing::_))
507 .Times(1)
508 .WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
509 result = adapterImpl->StartCapture();
510 EXPECT_EQ(result, 0);
511 adapterImpl->SetMicrophoneEnable(true);
512 result = adapterImpl->StopCapture();
513 EXPECT_EQ(result, 0);
514 EXPECT_CALL(*mock, StartScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
515 EXPECT_CALL(*mock, StopScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
516 result = adapterImpl->StartCapture();
517 EXPECT_EQ(result, -1);
518 result = adapterImpl->StopCapture();
519 EXPECT_EQ(result, -1);
520 auto callbackAdapter = std::make_shared<ScreenCaptureCallbackAdapterTest>();
521 EXPECT_NE(callbackAdapter, nullptr);
522 result = g_screenCapture->SetCaptureCallback(callbackAdapter);
523 EXPECT_EQ(result, 0);
524 EXPECT_CALL(*mock, SetScreenCaptureCallback(::testing::_))
525 .Times(1)
526 .WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
527 adapterImpl->SetCaptureCallback(callbackAdapter);
528 result = g_screenCapture->SetCaptureCallback(nullptr);
529 EXPECT_EQ(result, -1);
530 g_screenCapture->screenCapture_ = nullptr;
531 result = g_screenCapture->SetCaptureCallback(callbackAdapter);
532 EXPECT_EQ(result, -1);
533 }
534
535 /**
536 * @tc.name: ScreenCaptureAdapterImplTest_OHScreenCaptureCallback_005
537 * @tc.desc: OHScreenCaptureCallback.
538 * @tc.type: FUNC
539 * @tc.require: AR000I7I57
540 */
541 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_OHScreenCaptureCallback_005, TestSize.Level1)
542 {
543 auto callbackMock = std::make_shared<ScreenCaptureCallbackAdapterTest>();
544 EXPECT_NE(callbackMock, nullptr);
545 auto callback = std::make_shared<OHScreenCaptureCallback>(callbackMock);
546 EXPECT_NE(callback, nullptr);
547 EXPECT_NE(callback->callback_, nullptr);
548 callback->OnError(ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_EXTEND_START, 0);
549 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::SOURCE_DEFAULT);
550 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::MIC);
551 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::ALL_PLAYBACK);
552 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::APP_PLAYBACK);
553 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::SOURCE_INVALID);
554 callback->OnVideoBufferAvailable(true);
555 callback->callback_ = nullptr;
556 callback->OnError(ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_EXTEND_START, 0);
557 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::SOURCE_DEFAULT);
558 callback->OnVideoBufferAvailable(true);
559 }
560
561 /**
562 * @tc.name: ScreenCaptureAdapterImplTest_Init_006
563 * @tc.desc: Init.
564 * @tc.type: FUNC
565 * @tc.require: AR000I7I57
566 */
567 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_Init_006, TestSize.Level1)
568 {
569 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
570 EXPECT_NE(adapterImpl, nullptr);
571 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_HOME_SCREEN;
572 g_screenCaptureConfig->dataType = DataTypeAdapter::ENCODED_STREAM_DATA_TYPE;
573 int32_t result = adapterImpl->Init(g_screenCaptureConfig);
574 EXPECT_EQ(result, -1);
575 g_screenCaptureConfig->dataType = DataTypeAdapter::CAPTURE_FILE_DATA_TYPE;
576 g_screenCaptureConfig->audioInfo->micCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
577 g_screenCaptureConfig->audioInfo->micCapInfo->audioChannels = AUDIO_CHANNELS;
578 g_screenCaptureConfig->audioInfo->innerCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
579 g_screenCaptureConfig->audioInfo->innerCapInfo->audioChannels = AUDIO_CHANNELS;
580 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameWidth = SCREEN_WIDTH;
581 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameHeight = SCREEN_HEIGHT;
582 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VIDEO_CODEC_FORMAT_BUTT;
583 g_screenCaptureConfig->recorderInfo->fileFormat = ContainerFormatTypeAdapter::CFT_MPEG_4A_TYPE;
584 result = adapterImpl->Init(g_screenCaptureConfig);
585 EXPECT_EQ(result, -1);
586 g_screenCaptureConfig->recorderInfo->fileFormat = ContainerFormatTypeAdapter::CFT_MPEG_4_TYPE;
587 result = adapterImpl->Init(g_screenCaptureConfig);
588 EXPECT_EQ(result, -1);
589 adapterImpl->screenCapture_ = OHOS::Media::ScreenCaptureFactory::CreateScreenCapture();
590 result = adapterImpl->Init(g_screenCaptureConfig);
591 EXPECT_EQ(result, 0);
592 }
593
594 /**
595 * @tc.name: ScreenCaptureAdapterImplTest_AcquireVideoBuffer_007
596 * @tc.desc: AcquireVideoBuffer.
597 * @tc.type: FUNC
598 * @tc.require:
599 */
600 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_AcquireVideoBuffer_007, TestSize.Level1)
601 {
602 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
603 EXPECT_NE(adapterImpl, nullptr);
604 ScreenCaptureImplMock* mock = new ScreenCaptureImplMock();
605 EXPECT_NE(mock, nullptr);
606 sptr<OHOS::SurfaceBuffer> surfacebuffer = new SurfaceBufferImpl(0);
607 EXPECT_NE(surfacebuffer, nullptr);
608 adapterImpl->screenCapture_.reset(mock);
609 EXPECT_CALL(*mock, AcquireVideoBuffer(::testing::_, ::testing::_, ::testing::_))
610 .Times(1)
611 .WillRepeatedly(::testing::Return(surfacebuffer));
612
613 EXPECT_CALL(*mock, ReleaseVideoBuffer()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_OK));
614 std::shared_ptr<SurfaceBufferAdapter> buffer = adapterImpl->AcquireVideoBuffer();
615 EXPECT_NE(buffer, nullptr);
616 int32_t result = adapterImpl->ReleaseVideoBuffer();
617 EXPECT_EQ(result, 0);
618 adapterImpl->screenCapture_.reset();
619 }
620 } // namespace NWeb
621 } // namespace OHOS
622