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_METHOD1(Init, int32_t(AVScreenCaptureConfig));
45 MOCK_METHOD1(Init, int32_t(OHOS::AudioStandard::AppInfo&));
46 MOCK_METHOD1(SetMicrophoneEnabled, int32_t(bool));
47 MOCK_METHOD1(SetCanvasRotation, int32_t(bool));
48 MOCK_METHOD1(ShowCursor, int32_t(bool));
49 MOCK_METHOD2(ResizeCanvas, int32_t(int32_t, int32_t));
50 MOCK_METHOD1(SkipPrivacyMode, int32_t(std::vector<uint64_t>&));
51 MOCK_METHOD1(SetMaxVideoFrameRate, int32_t(int32_t));
52 MOCK_METHOD0(StartScreenCapture, int32_t());
53 MOCK_METHOD1(StartScreenCaptureWithSurface, int32_t(sptr<Surface>));
54 MOCK_METHOD0(StopScreenCapture, int32_t());
55 MOCK_METHOD0(StartScreenRecording, int32_t());
56 MOCK_METHOD0(StopScreenRecording, int32_t());
57 MOCK_METHOD2(AcquireAudioBuffer, int32_t(std::shared_ptr<AudioBuffer>&, AudioCaptureSourceType));
58 MOCK_METHOD3(AcquireVideoBuffer, sptr<OHOS::SurfaceBuffer>(int32_t&, int64_t&, OHOS::Rect&));
59 MOCK_METHOD1(ReleaseAudioBuffer, int32_t(AudioCaptureSourceType));
60 MOCK_METHOD0(ReleaseVideoBuffer, int32_t());
61 MOCK_METHOD0(Release, int32_t());
62 MOCK_METHOD1(SetScreenCaptureCallback, int32_t(const std::shared_ptr<ScreenCaptureCallBack>&));
63 MOCK_METHOD1(ExcludeContent, int32_t(ScreenCaptureContentFilter&));
64 MOCK_METHOD0(SetPrivacyAuthorityEnabled, int32_t());
65 };
66 } // namespace Media
67 namespace NWeb {
68
69 class MockAudioCaptureInfoAdapter : public AudioCaptureInfoAdapter {
70 public:
71 MockAudioCaptureInfoAdapter() = default;
72
GetAudioSampleRate()73 int32_t GetAudioSampleRate() override
74 {
75 return audioSampleRate;
76 }
77
GetAudioChannels()78 int32_t GetAudioChannels() override
79 {
80 return audioChannels;
81 }
82
GetAudioSource()83 AudioCaptureSourceTypeAdapter GetAudioSource() override
84 {
85 return audioSource;
86 }
87
88 int32_t audioSampleRate;
89 int32_t audioChannels;
90 AudioCaptureSourceTypeAdapter audioSource = AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT;
91 };
92
93 class MockAudioEncInfoAdapter : public AudioEncInfoAdapter {
94 public:
95 MockAudioEncInfoAdapter() = default;
96
GetAudioBitrate()97 int32_t GetAudioBitrate() override
98 {
99 return audioBitrate;
100 }
101
GetAudioCodecformat()102 AudioCodecFormatAdapter GetAudioCodecformat() override
103 {
104 return audioCodecformat;
105 }
106
107 int32_t audioBitrate = 0;
108 AudioCodecFormatAdapter audioCodecformat = AudioCodecFormatAdapter::AUDIO_DEFAULT;
109 };
110
111 class MockAudioInfoAdapter : public AudioInfoAdapter {
112 public:
113 MockAudioInfoAdapter() = default;
114
GetMicCapInfo()115 std::shared_ptr<AudioCaptureInfoAdapter> GetMicCapInfo() override
116 {
117 return micCapInfo;
118 }
119
GetInnerCapInfo()120 std::shared_ptr<AudioCaptureInfoAdapter> GetInnerCapInfo() override
121 {
122 return innerCapInfo;
123 }
124
GetAudioEncInfo()125 std::shared_ptr<AudioEncInfoAdapter> GetAudioEncInfo() override
126 {
127 return audioEncInfo;
128 }
129
130 std::shared_ptr<MockAudioCaptureInfoAdapter> micCapInfo = nullptr;
131 std::shared_ptr<MockAudioCaptureInfoAdapter> innerCapInfo = nullptr;
132 std::shared_ptr<MockAudioEncInfoAdapter> audioEncInfo = nullptr;
133 };
134
135 class MockVideoCaptureInfoAdapter : public VideoCaptureInfoAdapter {
136 public:
137 MockVideoCaptureInfoAdapter() = default;
138
GetDisplayId()139 uint64_t GetDisplayId() override
140 {
141 return displayId;
142 }
143
GetTaskIDs()144 std::list<int32_t> GetTaskIDs() override
145 {
146 return taskIDs;
147 }
148
GetVideoFrameWidth()149 int32_t GetVideoFrameWidth() override
150 {
151 return videoFrameWidth;
152 }
153
GetVideoFrameHeight()154 int32_t GetVideoFrameHeight() override
155 {
156 return videoFrameHeight;
157 }
158
GetVideoSourceType()159 VideoSourceTypeAdapter GetVideoSourceType() override
160 {
161 return videoSource;
162 }
163
164 uint64_t displayId = 0;
165 std::list<int32_t> taskIDs;
166 int32_t videoFrameWidth = 0;
167 int32_t videoFrameHeight = 0;
168 VideoSourceTypeAdapter videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_RGBA;
169 };
170
171 class MockVideoEncInfoAdapter : public VideoEncInfoAdapter {
172 public:
173 MockVideoEncInfoAdapter() = default;
174
GetVideoCodecFormat()175 VideoCodecFormatAdapter GetVideoCodecFormat() override
176 {
177 return videoCodec;
178 }
179
GetVideoBitrate()180 int32_t GetVideoBitrate() override
181 {
182 return videoBitrate;
183 }
184
GetVideoFrameRate()185 int32_t GetVideoFrameRate() override
186 {
187 return videoFrameRate;
188 }
189
190 VideoCodecFormatAdapter videoCodec = VideoCodecFormatAdapter::VIDEO_DEFAULT;
191 int32_t videoBitrate = 0;
192 int32_t videoFrameRate = 0;
193 };
194
195 class MockVideoInfoAdapter : public VideoInfoAdapter {
196 public:
197 MockVideoInfoAdapter() = default;
198
GetVideoCapInfo()199 std::shared_ptr<VideoCaptureInfoAdapter> GetVideoCapInfo()
200 {
201 return videoCapInfo;
202 }
203
GetVideoEncInfo()204 std::shared_ptr<VideoEncInfoAdapter> GetVideoEncInfo()
205 {
206 return videoEncInfo;
207 }
208
209 std::shared_ptr<MockVideoCaptureInfoAdapter> videoCapInfo = nullptr;
210 std::shared_ptr<MockVideoEncInfoAdapter> videoEncInfo = nullptr;
211 };
212
213 class MockRecorderInfoAdapter : public RecorderInfoAdapter {
214 public:
215 MockRecorderInfoAdapter() = default;
216
GetUrl()217 std::string GetUrl() override
218 {
219 return url;
220 }
221
GetFileFormat()222 ContainerFormatTypeAdapter GetFileFormat() override
223 {
224 return fileFormat;
225 }
226
227 std::string url = "";
228 ContainerFormatTypeAdapter fileFormat = ContainerFormatTypeAdapter::CFT_MPEG_4A_TYPE;
229 };
230
231 class MockScreenCaptureConfigAdapter : public ScreenCaptureConfigAdapter {
232 public:
233 MockScreenCaptureConfigAdapter() = default;
234
GetCaptureMode()235 CaptureModeAdapter GetCaptureMode() override
236 {
237 return captureMode;
238 }
239
GetDataType()240 DataTypeAdapter GetDataType() override
241 {
242 return dataType;
243 }
244
GetAudioInfo()245 std::shared_ptr<AudioInfoAdapter> GetAudioInfo()
246 {
247 return audioInfo;
248 }
249
GetVideoInfo()250 std::shared_ptr<VideoInfoAdapter> GetVideoInfo()
251 {
252 return videoInfo;
253 }
254
GetRecorderInfo()255 std::shared_ptr<RecorderInfoAdapter> GetRecorderInfo()
256 {
257 return recorderInfo;
258 }
259
260 CaptureModeAdapter captureMode = CaptureModeAdapter::CAPTURE_INVAILD;
261 DataTypeAdapter dataType = DataTypeAdapter::INVAILD_DATA_TYPE;
262 std::shared_ptr<MockAudioInfoAdapter> audioInfo = nullptr;
263 std::shared_ptr<MockVideoInfoAdapter> videoInfo = nullptr;
264 std::shared_ptr<MockRecorderInfoAdapter> recorderInfo = nullptr;
265 };
266
267 class MockAudioBufferAdapter : public AudioBufferAdapter {
268 public:
269 MockAudioBufferAdapter() = default;
270
GetBuffer()271 uint8_t* GetBuffer() override
272 {
273 return m_buffer;
274 }
275
GetLength()276 int32_t GetLength() override
277 {
278 return m_length;
279 }
280
GetTimestamp()281 int64_t GetTimestamp() override
282 {
283 return m_timestamp;
284 }
285
GetSourcetype()286 AudioCaptureSourceTypeAdapter GetSourcetype() override
287 {
288 return m_sourcetype;
289 }
290
SetBuffer(uint8_t * buffer)291 void SetBuffer(uint8_t* buffer) override
292 {
293 m_buffer = buffer;
294 }
295
SetLength(int32_t length)296 void SetLength(int32_t length) override
297 {
298 m_length = length;
299 }
300
SetTimestamp(int64_t timestamp)301 void SetTimestamp(int64_t timestamp) override
302 {
303 m_timestamp = timestamp;
304 }
305
SetSourcetype(AudioCaptureSourceTypeAdapter sourcetype)306 void SetSourcetype(AudioCaptureSourceTypeAdapter sourcetype) override
307 {
308 m_sourcetype = sourcetype;
309 }
310
311 uint8_t* m_buffer = nullptr;
312 int32_t m_length = 0;
313 int64_t m_timestamp = 0;
314 AudioCaptureSourceTypeAdapter m_sourcetype = AudioCaptureSourceTypeAdapter::SOURCE_INVALID;
315 };
316
GetScreenCaptureStateCodeAdapter(const OHOS::Media::AVScreenCaptureStateCode & stateCode)317 ScreenCaptureStateCodeAdapter GetScreenCaptureStateCodeAdapter(const OHOS::Media::AVScreenCaptureStateCode& stateCode)
318 {
319 switch (stateCode) {
320 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED:
321 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STARTED;
322 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_CANCELED:
323 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_CANCELED;
324 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER:
325 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STOPPED_BY_USER;
326 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER:
327 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER;
328 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL:
329 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL;
330 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE:
331 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE;
332 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_MUTED_BY_USER:
333 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_MUTED_BY_USER;
334 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNMUTED_BY_USER:
335 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_UNMUTED_BY_USER;
336 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_ENTER_PRIVATE_SCENE:
337 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_ENTER_PRIVATE_SCENE;
338 case OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_EXIT_PRIVATE_SCENE:
339 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_EXIT_PRIVATE_SCENE;
340 default:
341 return ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_INVLID;
342 }
343 }
344
ConvertAudioCaptureSourceType(const AudioCaptureSourceTypeAdapter & type)345 OHOS::Media::AudioCaptureSourceType ConvertAudioCaptureSourceType(const AudioCaptureSourceTypeAdapter& type)
346 {
347 switch (type) {
348 case AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT:
349 return OHOS::Media::AudioCaptureSourceType::SOURCE_DEFAULT;
350 case AudioCaptureSourceTypeAdapter::MIC:
351 return OHOS::Media::AudioCaptureSourceType::MIC;
352 case AudioCaptureSourceTypeAdapter::ALL_PLAYBACK:
353 return OHOS::Media::AudioCaptureSourceType::ALL_PLAYBACK;
354 case AudioCaptureSourceTypeAdapter::APP_PLAYBACK:
355 return OHOS::Media::AudioCaptureSourceType::APP_PLAYBACK;
356 default:
357 return OHOS::Media::AudioCaptureSourceType::SOURCE_INVALID;
358 }
359 }
360
361 namespace {
362 constexpr int32_t AUDIO_SAMPLE_RATE = 16000;
363 constexpr int32_t AUDIO_CHANNELS = 2;
364 constexpr int32_t SCREEN_WIDTH = 1080;
365 constexpr int32_t SCREEN_HEIGHT = 720;
366 std::shared_ptr<ScreenCaptureAdapterImpl> g_screenCapture = nullptr;
367 std::shared_ptr<MockAudioCaptureInfoAdapter> g_micCapInfo = nullptr;
368 std::shared_ptr<MockAudioCaptureInfoAdapter> g_innerCapInfo = nullptr;
369 std::shared_ptr<MockAudioEncInfoAdapter> g_audioEncInfo = nullptr;
370 std::shared_ptr<MockAudioInfoAdapter> g_audioInfo = nullptr;
371 std::shared_ptr<MockVideoCaptureInfoAdapter> g_videoCaptureInfo = nullptr;
372 std::shared_ptr<MockVideoEncInfoAdapter> g_videoEncInfo = nullptr;
373 std::shared_ptr<MockVideoInfoAdapter> g_videoInfo = nullptr;
374 std::shared_ptr<MockRecorderInfoAdapter> g_recorderInfo = nullptr;
375 std::shared_ptr<MockScreenCaptureConfigAdapter> g_screenCaptureConfig = nullptr;
376 std::shared_ptr<MockAudioBufferAdapter> g_audioBufferAdapter = nullptr;
377
378 class ScreenCaptureCallbackAdapterTest : public ScreenCaptureCallbackAdapter {
379 public:
380 ScreenCaptureCallbackAdapterTest() = default;
381 ~ScreenCaptureCallbackAdapterTest() override = default;
382
OnError(int32_t errorCode)383 void OnError(int32_t errorCode) override
384 {
385 (void)errorCode;
386 }
387
OnAudioBufferAvailable(bool isReady,AudioCaptureSourceTypeAdapter type)388 void OnAudioBufferAvailable(bool isReady, AudioCaptureSourceTypeAdapter type) override
389 {
390 (void)isReady;
391 (void)type;
392 }
393
OnVideoBufferAvailable(bool isReady)394 void OnVideoBufferAvailable(bool isReady) override
395 {
396 if (!isReady || !g_screenCapture) {
397 return;
398 }
399 std::shared_ptr<SurfaceBufferAdapter> buffer = g_screenCapture->AcquireVideoBuffer();
400 if (buffer) {
401 g_screenCapture->ReleaseVideoBuffer();
402 }
403 }
404 };
405 } // namespace
406
407 class ScreenCaptureAdapterImplTest : public testing::Test {
408 public:
409 static void SetUpTestCase(void);
410 static void TearDownTestCase(void);
411 void SetUp();
412 void TearDown();
413 };
414
SetUpTestCase(void)415 void ScreenCaptureAdapterImplTest::SetUpTestCase(void)
416 {
417 // set native token
418 uint64_t tokenId;
419 const char* perms[2];
420 perms[0] = "ohos.permission.CAPTURE_SCREEN";
421 perms[1] = "ohos.permission.MICROPHONE";
422 NativeTokenInfoParams infoInstance = {
423 .dcapsNum = 0,
424 .permsNum = 1,
425 .aclsNum = 0,
426 .dcaps = NULL,
427 .perms = perms,
428 .acls = NULL,
429 .processName = "web_screen_capture_tdd",
430 .aplStr = "system_basic",
431 };
432 tokenId = GetAccessTokenId(&infoInstance);
433 SetSelfTokenID(tokenId);
434 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
435
436 g_screenCapture = std::make_shared<ScreenCaptureAdapterImpl>();
437 g_micCapInfo = std::make_shared<MockAudioCaptureInfoAdapter>();
438 g_innerCapInfo = std::make_shared<MockAudioCaptureInfoAdapter>();
439 g_audioEncInfo = std::make_shared<MockAudioEncInfoAdapter>();
440 g_audioInfo = std::make_shared<MockAudioInfoAdapter>();
441 g_videoCaptureInfo = std::make_shared<MockVideoCaptureInfoAdapter>();
442 g_videoEncInfo = std::make_shared<MockVideoEncInfoAdapter>();
443 g_videoInfo = std::make_shared<MockVideoInfoAdapter>();
444 g_recorderInfo = std::make_shared<MockRecorderInfoAdapter>();
445 g_screenCaptureConfig = std::make_shared<MockScreenCaptureConfigAdapter>();
446 g_audioBufferAdapter = std::make_shared<MockAudioBufferAdapter>();
447
448 EXPECT_NE(g_screenCapture, nullptr);
449 EXPECT_NE(g_micCapInfo, nullptr);
450 EXPECT_NE(g_innerCapInfo, nullptr);
451 EXPECT_NE(g_audioEncInfo, nullptr);
452 EXPECT_NE(g_audioInfo, nullptr);
453 EXPECT_NE(g_videoCaptureInfo, nullptr);
454 EXPECT_NE(g_videoEncInfo, nullptr);
455 EXPECT_NE(g_videoInfo, nullptr);
456 EXPECT_NE(g_recorderInfo, nullptr);
457 EXPECT_NE(g_screenCaptureConfig, nullptr);
458 EXPECT_NE(g_audioBufferAdapter, nullptr);
459 int32_t result = g_screenCapture->Init(nullptr);
460 EXPECT_EQ(result, -1);
461
462 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_HOME_SCREEN;
463 g_screenCaptureConfig->dataType = DataTypeAdapter::ORIGINAL_STREAM_DATA_TYPE;
464 g_micCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
465 g_micCapInfo->audioChannels = AUDIO_CHANNELS;
466 g_innerCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
467 g_innerCapInfo->audioChannels = AUDIO_CHANNELS;
468 g_audioInfo->micCapInfo = g_micCapInfo;
469 g_audioInfo->innerCapInfo = g_innerCapInfo;
470 g_audioInfo->audioEncInfo = g_audioEncInfo;
471 g_videoCaptureInfo->videoFrameWidth = SCREEN_WIDTH;
472 g_videoCaptureInfo->videoFrameHeight = SCREEN_HEIGHT;
473 g_videoInfo->videoCapInfo = g_videoCaptureInfo;
474 g_videoInfo->videoEncInfo = g_videoEncInfo;
475 result = g_screenCapture->Init(g_screenCaptureConfig);
476 EXPECT_EQ(result, 0);
477 g_screenCaptureConfig->audioInfo = g_audioInfo;
478 result = g_screenCapture->Init(g_screenCaptureConfig);
479 EXPECT_EQ(result, 0);
480 g_screenCaptureConfig->videoInfo = g_videoInfo;
481 result = g_screenCapture->Init(g_screenCaptureConfig);
482 EXPECT_EQ(result, 0);
483 g_screenCaptureConfig->recorderInfo = g_recorderInfo;
484 result = g_screenCapture->Init(g_screenCaptureConfig);
485 EXPECT_EQ(result, 0);
486 }
487
TearDownTestCase(void)488 void ScreenCaptureAdapterImplTest::TearDownTestCase(void) {}
489
SetUp(void)490 void ScreenCaptureAdapterImplTest::SetUp(void) {}
491
TearDown(void)492 void ScreenCaptureAdapterImplTest::TearDown(void) {}
493
494 /**
495 * @tc.name: ScreenCaptureAdapterImplTest_Init_001
496 * @tc.desc: Init.
497 * @tc.type: FUNC
498 * @tc.require: AR000I7I57
499 */
500 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_Init_001, TestSize.Level1)
501 {
502 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
503 EXPECT_NE(adapterImpl, nullptr);
504 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_INVAILD;
505 g_screenCaptureConfig->dataType = DataTypeAdapter::INVAILD_DATA_TYPE;
506 g_screenCaptureConfig->audioInfo->micCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
507 g_screenCaptureConfig->audioInfo->micCapInfo->audioChannels = AUDIO_CHANNELS;
508 g_screenCaptureConfig->audioInfo->innerCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
509 g_screenCaptureConfig->audioInfo->innerCapInfo->audioChannels = AUDIO_CHANNELS;
510 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameWidth = SCREEN_WIDTH;
511 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameHeight = SCREEN_HEIGHT;
512 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::SOURCE_INVALID;
513 g_screenCaptureConfig->audioInfo->audioEncInfo->audioCodecformat = AudioCodecFormatAdapter::AUDIO_DEFAULT;
514 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_YUV;
515 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VIDEO_DEFAULT;
516 int32_t result = adapterImpl->Init(g_screenCaptureConfig);
517 EXPECT_EQ(result, -1);
518 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_HOME_SCREEN;
519 g_screenCaptureConfig->dataType = DataTypeAdapter::ENCODED_STREAM_DATA_TYPE;
520 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT;
521 g_screenCaptureConfig->audioInfo->audioEncInfo->audioCodecformat = AudioCodecFormatAdapter::AAC_LC;
522 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_ES;
523 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::H264;
524 result = adapterImpl->Init(g_screenCaptureConfig);
525 EXPECT_EQ(result, -1);
526 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_SPECIFIED_SCREEN;
527 g_screenCaptureConfig->dataType = DataTypeAdapter::CAPTURE_FILE_DATA_TYPE;
528 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::MIC;
529 g_screenCaptureConfig->audioInfo->audioEncInfo->audioCodecformat = AudioCodecFormatAdapter::AUDIO_CODEC_FORMAT_BUTT;
530 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_SURFACE_RGBA;
531 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::H265;
532 result = adapterImpl->Init(g_screenCaptureConfig);
533 EXPECT_EQ(result, -1);
534 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_SPECIFIED_WINDOW;
535 g_screenCaptureConfig->dataType = DataTypeAdapter::ORIGINAL_STREAM_DATA_TYPE;
536 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::ALL_PLAYBACK;
537 g_screenCaptureConfig->videoInfo->videoCapInfo->videoSource = VideoSourceTypeAdapter::VIDEO_SOURCE_BUTT;
538 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::MPEG4;
539 result = adapterImpl->Init(g_screenCaptureConfig);
540 EXPECT_EQ(result, -1);
541 g_screenCaptureConfig->audioInfo->micCapInfo->audioSource = AudioCaptureSourceTypeAdapter::APP_PLAYBACK;
542 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VP8;
543 result = adapterImpl->Init(g_screenCaptureConfig);
544 EXPECT_EQ(result, -1);
545 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VP9;
546 result = adapterImpl->Init(g_screenCaptureConfig);
547 EXPECT_EQ(result, -1);
548 }
549
550 /**
551 * @tc.name: ScreenCaptureAdapterImplTest_SetMicrophoneEnable_002
552 * @tc.desc: SetMicrophoneEnable.
553 * @tc.type: FUNC
554 * @tc.require: AR000I7I57
555 */
556 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_SetMicrophoneEnable_002, TestSize.Level1)
557 {
558 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
559 EXPECT_NE(adapterImpl, nullptr);
560 int32_t result = adapterImpl->SetMicrophoneEnable(false);
561 EXPECT_EQ(result, -1);
562 result = g_screenCapture->SetMicrophoneEnable(false);
563 EXPECT_EQ(result, 0);
564 result = g_screenCapture->SetMicrophoneEnable(true);
565 EXPECT_EQ(result, 0);
566 }
567
568 /**
569 * @tc.name: ScreenCaptureAdapterImplTest_AcquireVideoBuffer_003
570 * @tc.desc: AcquireVideoBuffer.
571 * @tc.type: FUNC
572 * @tc.require: AR000I7I57
573 */
574 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_AcquireVideoBuffer_003, TestSize.Level1)
575 {
576 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
577 EXPECT_NE(adapterImpl, nullptr);
578 std::shared_ptr<SurfaceBufferAdapter> buffer = adapterImpl->AcquireVideoBuffer();
579 EXPECT_EQ(buffer, nullptr);
580 int32_t result = adapterImpl->ReleaseVideoBuffer();
581 EXPECT_EQ(result, -1);
582 g_screenCapture->AcquireVideoBuffer();
583 g_screenCapture->ReleaseVideoBuffer();
584 }
585
586 /**
587 * @tc.name: ScreenCaptureAdapterImplTest_Capture_004
588 * @tc.desc: Capture.
589 * @tc.type: FUNC
590 * @tc.require: AR000I7I57
591 */
592 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_Capture_004, TestSize.Level1)
593 {
594 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
595 EXPECT_NE(adapterImpl, nullptr);
596 int32_t result = adapterImpl->StartCapture();
597 EXPECT_EQ(result, -1);
598 result = adapterImpl->StopCapture();
599 EXPECT_EQ(result, -1);
600 ScreenCaptureImplMock* mock = new ScreenCaptureImplMock();
601 EXPECT_NE(mock, nullptr);
602 adapterImpl->screenCapture_.reset(mock);
603 EXPECT_CALL(*mock, StartScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_OK));
604 EXPECT_CALL(*mock, StopScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_OK));
605 EXPECT_CALL(*mock, SetMicrophoneEnabled(::testing::_))
606 .Times(1)
607 .WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
608 result = adapterImpl->StartCapture();
609 EXPECT_EQ(result, 0);
610 adapterImpl->SetMicrophoneEnable(true);
611 result = adapterImpl->StopCapture();
612 EXPECT_EQ(result, 0);
613 EXPECT_CALL(*mock, StartScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
614 EXPECT_CALL(*mock, StopScreenCapture()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
615 result = adapterImpl->StartCapture();
616 EXPECT_EQ(result, -1);
617 result = adapterImpl->StopCapture();
618 EXPECT_EQ(result, -1);
619 auto callbackAdapter = std::make_shared<ScreenCaptureCallbackAdapterTest>();
620 EXPECT_NE(callbackAdapter, nullptr);
621 result = g_screenCapture->SetCaptureCallback(callbackAdapter);
622 EXPECT_EQ(result, 0);
623 EXPECT_CALL(*mock, SetScreenCaptureCallback(::testing::_))
624 .Times(1)
625 .WillRepeatedly(::testing::Return(Media::MSERR_NO_MEMORY));
626 adapterImpl->SetCaptureCallback(callbackAdapter);
627 result = g_screenCapture->SetCaptureCallback(nullptr);
628 EXPECT_EQ(result, -1);
629 g_screenCapture->screenCapture_ = nullptr;
630 result = g_screenCapture->SetCaptureCallback(callbackAdapter);
631 EXPECT_EQ(result, -1);
632 }
633
634 /**
635 * @tc.name: ScreenCaptureAdapterImplTest_OHScreenCaptureCallback_005
636 * @tc.desc: OHScreenCaptureCallback.
637 * @tc.type: FUNC
638 * @tc.require: AR000I7I57
639 */
640 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_OHScreenCaptureCallback_005, TestSize.Level1)
641 {
642 auto callbackMock = std::make_shared<ScreenCaptureCallbackAdapterTest>();
643 EXPECT_NE(callbackMock, nullptr);
644 auto callback = std::make_shared<OHScreenCaptureCallback>(callbackMock);
645 EXPECT_NE(callback, nullptr);
646 EXPECT_NE(callback->callback_, nullptr);
647 callback->OnError(ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_EXTEND_START, 0);
648 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::SOURCE_DEFAULT);
649 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::MIC);
650 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::ALL_PLAYBACK);
651 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::APP_PLAYBACK);
652 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::SOURCE_INVALID);
653 callback->OnVideoBufferAvailable(true);
654 callback->callback_ = nullptr;
655 callback->OnError(ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_EXTEND_START, 0);
656 callback->OnAudioBufferAvailable(true, AudioCaptureSourceType::SOURCE_DEFAULT);
657 callback->OnVideoBufferAvailable(true);
658 }
659
660 /**
661 * @tc.name: ScreenCaptureAdapterImplTest_Init_006
662 * @tc.desc: Init.
663 * @tc.type: FUNC
664 * @tc.require: AR000I7I57
665 */
666 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_Init_006, TestSize.Level1)
667 {
668 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
669 EXPECT_NE(adapterImpl, nullptr);
670 g_screenCaptureConfig->captureMode = CaptureModeAdapter::CAPTURE_HOME_SCREEN;
671 g_screenCaptureConfig->dataType = DataTypeAdapter::ENCODED_STREAM_DATA_TYPE;
672 int32_t result = adapterImpl->Init(g_screenCaptureConfig);
673 EXPECT_EQ(result, -1);
674 g_screenCaptureConfig->dataType = DataTypeAdapter::CAPTURE_FILE_DATA_TYPE;
675 g_screenCaptureConfig->audioInfo->micCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
676 g_screenCaptureConfig->audioInfo->micCapInfo->audioChannels = AUDIO_CHANNELS;
677 g_screenCaptureConfig->audioInfo->innerCapInfo->audioSampleRate = AUDIO_SAMPLE_RATE;
678 g_screenCaptureConfig->audioInfo->innerCapInfo->audioChannels = AUDIO_CHANNELS;
679 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameWidth = SCREEN_WIDTH;
680 g_screenCaptureConfig->videoInfo->videoCapInfo->videoFrameHeight = SCREEN_HEIGHT;
681 g_screenCaptureConfig->videoInfo->videoEncInfo->videoCodec = VideoCodecFormatAdapter::VIDEO_CODEC_FORMAT_BUTT;
682 g_screenCaptureConfig->recorderInfo->fileFormat = ContainerFormatTypeAdapter::CFT_MPEG_4A_TYPE;
683 result = adapterImpl->Init(g_screenCaptureConfig);
684 EXPECT_EQ(result, -1);
685 g_screenCaptureConfig->recorderInfo->fileFormat = ContainerFormatTypeAdapter::CFT_MPEG_4_TYPE;
686 result = adapterImpl->Init(g_screenCaptureConfig);
687 EXPECT_EQ(result, -1);
688 adapterImpl->screenCapture_ = OHOS::Media::ScreenCaptureFactory::CreateScreenCapture();
689 result = adapterImpl->Init(g_screenCaptureConfig);
690 EXPECT_EQ(result, 0);
691 }
692
693 /**
694 * @tc.name: ScreenCaptureAdapterImplTest_AcquireVideoBuffer_007
695 * @tc.desc: AcquireVideoBuffer.
696 * @tc.type: FUNC
697 * @tc.require:
698 */
699 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_AcquireVideoBuffer_007, TestSize.Level1)
700 {
701 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
702 EXPECT_NE(adapterImpl, nullptr);
703 ScreenCaptureImplMock* mock = new ScreenCaptureImplMock();
704 EXPECT_NE(mock, nullptr);
705 sptr<OHOS::SurfaceBuffer> surfacebuffer = new SurfaceBufferImpl(0);
706 EXPECT_NE(surfacebuffer, nullptr);
707 adapterImpl->screenCapture_.reset(mock);
708 EXPECT_CALL(*mock, AcquireVideoBuffer(::testing::_, ::testing::_, ::testing::_))
709 .Times(1)
710 .WillRepeatedly(::testing::Return(surfacebuffer));
711
712 EXPECT_CALL(*mock, ReleaseVideoBuffer()).Times(1).WillRepeatedly(::testing::Return(Media::MSERR_OK));
713 std::shared_ptr<SurfaceBufferAdapter> buffer = adapterImpl->AcquireVideoBuffer();
714 EXPECT_NE(buffer, nullptr);
715 int32_t result = adapterImpl->ReleaseVideoBuffer();
716 EXPECT_EQ(result, 0);
717 adapterImpl->screenCapture_.reset();
718 }
719
720 /**
721 * @tc.name: ScreenCaptureAdapterImplTest_AcquireAudioBuffer_008
722 * @tc.desc: AcquireAudioBuffer.
723 * @tc.type: FUNC
724 * @tc.require:
725 */
726 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_AcquireAudioBuffer_008, TestSize.Level1)
727 {
728 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
729 EXPECT_NE(adapterImpl, nullptr);
730 ScreenCaptureImplMock* mock = new ScreenCaptureImplMock();
731 EXPECT_NE(mock, nullptr);
732 std::shared_ptr<MockAudioBufferAdapter> audiobuffer = nullptr;
733 EXPECT_EQ(audiobuffer, nullptr);
734 adapterImpl->screenCapture_.reset(mock);
735
736 EXPECT_CALL(*mock, ReleaseAudioBuffer(::testing::_)).Times(1).WillRepeatedly(::testing::Return(0));
737 AudioCaptureSourceTypeAdapter type = AudioCaptureSourceTypeAdapter::MIC;
738 int32_t ret = adapterImpl->AcquireAudioBuffer(audiobuffer, type);
739 EXPECT_EQ(ret, -1);
740 int32_t result = adapterImpl->ReleaseAudioBuffer(type);
741 EXPECT_EQ(result, 0);
742 adapterImpl->screenCapture_.reset();
743 }
744
745 /**
746 * @tc.name: ScreenCaptureAdapterImplTest_AcquireAudioBuffer_009
747 * @tc.desc: AcquireAudioBuffer.
748 * @tc.type: FUNC
749 * @tc.require:
750 */
751 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_AcquireAudioBuffer_009, TestSize.Level1)
752 {
753 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
754 EXPECT_NE(adapterImpl, nullptr);
755 ScreenCaptureImplMock* mock = new ScreenCaptureImplMock();
756 EXPECT_NE(mock, nullptr);
757 adapterImpl->screenCapture_.reset(mock);
758 EXPECT_CALL(*mock, AcquireAudioBuffer(::testing::_, ::testing::_))
759 .Times(1)
760 .WillRepeatedly(::testing::Return(-1));
761
762 EXPECT_CALL(*mock, ReleaseAudioBuffer(::testing::_)).Times(1).WillRepeatedly(::testing::Return(-1));
763 AudioCaptureSourceTypeAdapter type = AudioCaptureSourceTypeAdapter::ALL_PLAYBACK;
764 int32_t ret = adapterImpl->AcquireAudioBuffer(g_audioBufferAdapter, type);
765 EXPECT_EQ(ret, -1);
766 int32_t result = adapterImpl->ReleaseAudioBuffer(type);
767 EXPECT_EQ(result, -1);
768 adapterImpl->screenCapture_.reset();
769 }
770
771 /**
772 * @tc.name: ScreenCaptureAdapterImplTest_ConvertAudioCaptureSourceType_010
773 * @tc.desc: ConvertAudioCaptureSourceType.
774 * @tc.type: FUNC
775 * @tc.require:
776 */
777 HWTEST_F(ScreenCaptureAdapterImplTest, ScreenCaptureAdapterImplTest_ConvertAudioCaptureSourceType_010, TestSize.Level1)
778 {
779 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
780 EXPECT_NE(adapterImpl, nullptr);
781 AudioCaptureSourceTypeAdapter type;
782 OHOS::Media::AudioCaptureSourceType result;
783
784 type = AudioCaptureSourceTypeAdapter::SOURCE_DEFAULT;
785 result = ConvertAudioCaptureSourceType(type);
786 EXPECT_EQ(result, OHOS::Media::AudioCaptureSourceType::SOURCE_DEFAULT);
787
788 type = AudioCaptureSourceTypeAdapter::MIC;
789 result = ConvertAudioCaptureSourceType(type);
790 EXPECT_EQ(result, OHOS::Media::AudioCaptureSourceType::MIC);
791
792 type = AudioCaptureSourceTypeAdapter::ALL_PLAYBACK;
793 result = ConvertAudioCaptureSourceType(type);
794 EXPECT_EQ(result, OHOS::Media::AudioCaptureSourceType::ALL_PLAYBACK);
795
796 type = AudioCaptureSourceTypeAdapter::APP_PLAYBACK;
797 result = ConvertAudioCaptureSourceType(type);
798 EXPECT_EQ(result, OHOS::Media::AudioCaptureSourceType::APP_PLAYBACK);
799
800 type = static_cast<AudioCaptureSourceTypeAdapter>(999); // Invalid source
801 result = ConvertAudioCaptureSourceType(type);
802 EXPECT_EQ(result, OHOS::Media::AudioCaptureSourceType::SOURCE_INVALID);
803 }
804
805 /**
806 * @tc.name: ScreenCaptureAdapterImplTest_GetScreenCaptureStateCodeAdapter_011
807 * @tc.desc: GetScreenCaptureStateCodeAdapter.
808 * @tc.type: FUNC
809 * @tc.require:
810 */
811 HWTEST_F(ScreenCaptureAdapterImplTest,
812 ScreenCaptureAdapterImplTest_GetScreenCaptureStateCodeAdapter_011, TestSize.Level1)
813 {
814 auto adapterImpl = std::make_shared<ScreenCaptureAdapterImpl>();
815 EXPECT_NE(adapterImpl, nullptr);
816 OHOS::Media::AVScreenCaptureStateCode stateCode;
817 ScreenCaptureStateCodeAdapter result;
818
819 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED;
820 result = GetScreenCaptureStateCodeAdapter(stateCode);
821 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STARTED);
822
823 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_CANCELED;
824 result = GetScreenCaptureStateCodeAdapter(stateCode);
825 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_CANCELED);
826
827 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER;
828 result = GetScreenCaptureStateCodeAdapter(stateCode);
829 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STOPPED_BY_USER);
830
831 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER;
832 result = GetScreenCaptureStateCodeAdapter(stateCode);
833 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_INTERRUPTED_BY_OTHER);
834
835 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL;
836 result = GetScreenCaptureStateCodeAdapter(stateCode);
837 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_STOPPED_BY_CALL);
838
839 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE;
840 result = GetScreenCaptureStateCodeAdapter(stateCode);
841 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE);
842
843 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_MUTED_BY_USER;
844 result = GetScreenCaptureStateCodeAdapter(stateCode);
845 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_MUTED_BY_USER);
846
847 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNMUTED_BY_USER;
848 result = GetScreenCaptureStateCodeAdapter(stateCode);
849 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_MIC_UNMUTED_BY_USER);
850
851 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_ENTER_PRIVATE_SCENE;
852 result = GetScreenCaptureStateCodeAdapter(stateCode);
853 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_ENTER_PRIVATE_SCENE);
854
855 stateCode = OHOS::Media::AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_EXIT_PRIVATE_SCENE;
856 result = GetScreenCaptureStateCodeAdapter(stateCode);
857 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_EXIT_PRIVATE_SCENE);
858
859 stateCode = static_cast<OHOS::Media::AVScreenCaptureStateCode>(999);;
860 result = GetScreenCaptureStateCodeAdapter(stateCode);
861 EXPECT_EQ(result, ScreenCaptureStateCodeAdapter::SCREEN_CAPTURE_STATE_INVLID);
862 }
863 } // namespace NWeb
864 } // namespace OHOS
865