1 /*
2 * Copyright (C) 2024 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 <unistd.h>
17 #include <sys/stat.h>
18 #include "screen_capture_server_function_unittest.h"
19 #include "ui_extension_ability_connection.h"
20 #include "image_source.h"
21 #include "image_type.h"
22 #include "pixel_map.h"
23 #include "media_log.h"
24 #include "media_errors.h"
25 #include "media_utils.h"
26 #include "uri_helper.h"
27 #include "media_dfx.h"
28 #include "scope_guard.h"
29 #include "param_wrapper.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::Media::ScreenCaptureTestParam;
33 using namespace OHOS::Media;
34
35 namespace {
36 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_SCREENCAPTURE, "ScreenCaptureServerFunctionTest"};
37 constexpr int32_t FLIE_CREATE_FLAGS = 0777;
38 static const std::string BUTTON_NAME_MIC = "mic";
39 static const std::string BUTTON_NAME_STOP = "stop";
40 }
41
42 namespace OHOS {
43 namespace Media {
44
SetHapPermission()45 void ScreenCaptureServerFunctionTest::SetHapPermission()
46 {
47 Security::AccessToken::AccessTokenIDEx tokenIdEx = {0};
48 tokenIdEx = Security::AccessToken::AccessTokenKit::AllocHapToken(info_, policy_);
49 int ret = SetSelfTokenID(tokenIdEx.tokenIDEx);
50 if (ret != 0) {
51 MEDIA_LOGE("Set hap token failed, err: %{public}d", ret);
52 }
53 }
54
SetUp()55 void ScreenCaptureServerFunctionTest::SetUp()
56 {
57 SetHapPermission();
58 std::shared_ptr<IScreenCaptureService> tempServer_ = ScreenCaptureServer::Create();
59 screenCaptureServer_ = std::static_pointer_cast<ScreenCaptureServer>(tempServer_);
60 sptr<IStandardScreenCaptureListener> listener = new(std::nothrow) StandardScreenCaptureServerUnittestCallback();
61 screenCaptureServer_->screenCaptureCb_ = std::make_shared<ScreenCaptureListenerCallback>(listener);
62 ASSERT_NE(screenCaptureServer_, nullptr);
63 }
64
TearDown()65 void ScreenCaptureServerFunctionTest::TearDown()
66 {
67 if (screenCaptureServer_) {
68 screenCaptureServer_->Release();
69 screenCaptureServer_ = nullptr;
70 }
71 }
72
SetInvalidConfig()73 int32_t ScreenCaptureServerFunctionTest::SetInvalidConfig()
74 {
75 AudioCaptureInfo micCapinfo = {
76 .audioSampleRate = 0,
77 .audioChannels = 0,
78 .audioSource = SOURCE_DEFAULT
79 };
80
81 AudioCaptureInfo innerCapInfo = {
82 .audioSampleRate = 0,
83 .audioChannels = 0,
84 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT,
85 };
86
87 VideoCaptureInfo videocapinfo = {
88 .videoFrameWidth = 720,
89 .videoFrameHeight = 1280,
90 .videoSource = VIDEO_SOURCE_SURFACE_RGBA
91 };
92
93 VideoEncInfo videoEncInfo = {
94 .videoCodec = VideoCodecFormat::H264,
95 .videoBitrate = 2000000,
96 .videoFrameRate = 30
97 };
98
99 AudioInfo audioInfo = {
100 .micCapInfo = micCapinfo,
101 .innerCapInfo = innerCapInfo,
102 };
103
104 VideoInfo videoInfo = {
105 .videoCapInfo = videocapinfo,
106 .videoEncInfo = videoEncInfo
107 };
108
109 config_ = {
110 .captureMode = CAPTURE_HOME_SCREEN,
111 .dataType = ORIGINAL_STREAM,
112 .audioInfo = audioInfo,
113 .videoInfo = videoInfo
114 };
115 return MSERR_OK;
116 }
117
SetValidConfig()118 int32_t ScreenCaptureServerFunctionTest::SetValidConfig()
119 {
120 AudioCaptureInfo micCapinfo = {
121 .audioSampleRate = 16000,
122 .audioChannels = 2,
123 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
124 };
125
126 AudioCaptureInfo innerCapInfo = {
127 .audioSampleRate = 16000,
128 .audioChannels = 2,
129 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK,
130 };
131
132 VideoCaptureInfo videocapinfo = {
133 .videoFrameWidth = 720,
134 .videoFrameHeight = 1280,
135 .videoSource = VIDEO_SOURCE_SURFACE_RGBA
136 };
137
138 VideoEncInfo videoEncInfo = {
139 .videoCodec = VideoCodecFormat::H264,
140 .videoBitrate = 2000000,
141 .videoFrameRate = 30
142 };
143
144 AudioInfo audioInfo = {
145 .micCapInfo = micCapinfo,
146 .innerCapInfo = innerCapInfo,
147 };
148
149 VideoInfo videoInfo = {
150 .videoCapInfo = videocapinfo,
151 .videoEncInfo = videoEncInfo
152 };
153
154 config_ = {
155 .captureMode = CAPTURE_HOME_SCREEN,
156 .dataType = ORIGINAL_STREAM,
157 .audioInfo = audioInfo,
158 .videoInfo = videoInfo
159 };
160 return MSERR_OK;
161 }
162
SetInvalidConfigFile(RecorderInfo & recorderInfo)163 int32_t ScreenCaptureServerFunctionTest::SetInvalidConfigFile(RecorderInfo &recorderInfo)
164 {
165 AudioEncInfo audioEncInfo = {
166 .audioBitrate = 48000,
167 .audioCodecformat = AudioCodecFormat::AAC_LC
168 };
169
170 VideoCaptureInfo videoCapInfo = {
171 .videoFrameWidth = 720,
172 .videoFrameHeight = 1080,
173 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
174 };
175
176 VideoEncInfo videoEncInfo = {
177 .videoCodec = VideoCodecFormat::H264,
178 .videoBitrate = 2000000,
179 .videoFrameRate = 30
180 };
181
182 AudioCaptureInfo innerCapInfo = {
183 .audioSampleRate = 0,
184 .audioChannels = 0,
185 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT,
186 };
187
188 AudioCaptureInfo micCapinfo = {
189 .audioSampleRate = 0,
190 .audioChannels = 0,
191 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT,
192 };
193
194 AudioInfo audioInfo = {
195 .micCapInfo = micCapinfo,
196 .innerCapInfo = innerCapInfo,
197 .audioEncInfo = audioEncInfo
198 };
199
200 VideoInfo videoInfo = {
201 .videoCapInfo = videoCapInfo,
202 .videoEncInfo = videoEncInfo
203 };
204
205 config_ = {
206 .captureMode = CaptureMode::CAPTURE_HOME_SCREEN,
207 .dataType = DataType::CAPTURE_FILE,
208 .audioInfo = audioInfo,
209 .videoInfo = videoInfo,
210 .recorderInfo = recorderInfo
211 };
212 return MSERR_OK;
213 }
214
SetValidConfigFile(RecorderInfo & recorderInfo)215 int32_t ScreenCaptureServerFunctionTest::SetValidConfigFile(RecorderInfo &recorderInfo)
216 {
217 AudioEncInfo audioEncInfo = {
218 .audioBitrate = 48000,
219 .audioCodecformat = AudioCodecFormat::AAC_LC
220 };
221
222 VideoCaptureInfo videoCapInfo = {
223 .videoFrameWidth = 720,
224 .videoFrameHeight = 1080,
225 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
226 };
227
228 VideoEncInfo videoEncInfo = {
229 .videoCodec = VideoCodecFormat::H264,
230 .videoBitrate = 2000000,
231 .videoFrameRate = 30
232 };
233
234 AudioCaptureInfo micCapinfo = {
235 .audioSampleRate = 16000,
236 .audioChannels = 2,
237 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
238 };
239
240 AudioCaptureInfo innerCapInfo = {
241 .audioSampleRate = 16000,
242 .audioChannels = 2,
243 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK,
244 };
245
246 AudioInfo audioInfo = {
247 .micCapInfo = micCapinfo,
248 .innerCapInfo = innerCapInfo,
249 .audioEncInfo = audioEncInfo
250 };
251
252 VideoInfo videoInfo = {
253 .videoCapInfo = videoCapInfo,
254 .videoEncInfo = videoEncInfo
255 };
256
257 config_ = {
258 .captureMode = CaptureMode::CAPTURE_HOME_SCREEN,
259 .dataType = DataType::CAPTURE_FILE,
260 .audioInfo = audioInfo,
261 .videoInfo = videoInfo,
262 .recorderInfo = recorderInfo
263 };
264 return MSERR_OK;
265 }
266
SetRecorderInfo(std::string name,RecorderInfo & recorderInfo)267 int32_t ScreenCaptureServerFunctionTest::SetRecorderInfo(std::string name,
268 RecorderInfo &recorderInfo)
269 {
270 OpenFileFd(name);
271 recorderInfo.url = "fd://" + std::to_string(outputFd_);
272 recorderInfo.fileFormat = "mp4";
273 return MSERR_OK;
274 }
275
276 static const std::string SCREEN_CAPTURE_ROOT_DIR = "/data/test/media/";
277
OpenFileFd(std::string name)278 void ScreenCaptureServerFunctionTest::OpenFileFd(std::string name)
279 {
280 if (outputFd_ != -1) {
281 (void)::close(outputFd_);
282 outputFd_ = -1;
283 }
284 outputFd_ = open((SCREEN_CAPTURE_ROOT_DIR + name).c_str(), O_RDWR | O_CREAT, FLIE_CREATE_FLAGS);
285 }
286
InitFileScreenCaptureServer()287 int32_t ScreenCaptureServerFunctionTest::InitFileScreenCaptureServer()
288 {
289 int32_t ret = screenCaptureServer_->SetCaptureMode(config_.captureMode);
290 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetCaptureMode failed");
291 ret = screenCaptureServer_->SetDataType(config_.dataType);
292 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetDataType failed");
293 ret = screenCaptureServer_->SetRecorderInfo(config_.recorderInfo);
294 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetRecorderInfo failed");
295 const std::string fdHead = "fd://";
296 CHECK_AND_RETURN_RET_LOG(config_.recorderInfo.url.find(fdHead) != std::string::npos, MSERR_INVALID_VAL,
297 "check url failed");
298 int32_t outputFd = -1;
299 std::string inputFd = config_.recorderInfo.url.substr(fdHead.size());
300 CHECK_AND_RETURN_RET_LOG(StrToInt(inputFd, outputFd) == true && outputFd >= 0, MSERR_INVALID_VAL,
301 "open file failed");
302 ret = screenCaptureServer_->SetOutputFile(outputFd);
303 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetOutputFile failed");
304 ret = screenCaptureServer_->InitAudioEncInfo(config_.audioInfo.audioEncInfo);
305 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitAudioEncInfo failed");
306 ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.micCapInfo);
307 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init micAudioCap failed");
308 ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.innerCapInfo);
309 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init innerCapInfo failed, innerCapInfo should be valid");
310
311 ret = screenCaptureServer_->InitVideoEncInfo(config_.videoInfo.videoEncInfo);
312 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitVideoEncInfo failed");
313 ret = screenCaptureServer_->InitVideoCap(config_.videoInfo.videoCapInfo);
314 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitVideoCap failed");
315 return MSERR_OK;
316 }
317
InitStreamScreenCaptureServer()318 int32_t ScreenCaptureServerFunctionTest::InitStreamScreenCaptureServer()
319 {
320 int32_t ret = screenCaptureServer_->SetCaptureMode(config_.captureMode);
321 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetCaptureMode failed");
322 ret = screenCaptureServer_->SetDataType(config_.dataType);
323 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "SetDataType failed");
324 ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.micCapInfo);
325 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init micAudioCap failed");
326 ret = screenCaptureServer_->InitAudioCap(config_.audioInfo.innerCapInfo);
327 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "init innerCapInfo failed, innerCapInfo should be valid");
328 ret = screenCaptureServer_->InitVideoCap(config_.videoInfo.videoCapInfo);
329 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "InitVideoCap failed");
330 return MSERR_OK;
331 }
332
StartFileAudioCapture(AVScreenCaptureMixMode mixMode)333 int32_t ScreenCaptureServerFunctionTest::StartFileAudioCapture(AVScreenCaptureMixMode mixMode)
334 {
335 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(mixMode, screenCaptureServer_.get());
336 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
337 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
338 MEDIA_LOGI("StartFileAudioCapture start");
339 int32_t ret = screenCaptureServer_->StartFileInnerAudioCapture();
340 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "StartFileInnerAudioCapture failed, ret:%{public}d,"
341 "dataType:%{public}d", ret, screenCaptureServer_->captureConfig_.dataType);
342 ret = screenCaptureServer_->StartFileMicAudioCapture();
343 if (ret != MSERR_OK) {
344 MEDIA_LOGE("StartFileMicAudioCapture failed");
345 }
346 return ret;
347 }
348
StartStreamAudioCapture()349 int32_t ScreenCaptureServerFunctionTest::StartStreamAudioCapture()
350 {
351 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
352 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
353 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
354 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
355 MEDIA_LOGI("StartStreamAudioCapture start");
356 int32_t ret = screenCaptureServer_->StartStreamInnerAudioCapture();
357 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "StartStreamInnerAudioCapture failed, ret:%{public}d,"
358 "dataType:%{public}d", ret, screenCaptureServer_->captureConfig_.dataType);
359 ret = screenCaptureServer_->StartStreamMicAudioCapture();
360 if (ret != MSERR_OK) {
361 MEDIA_LOGE("StartFileMicAudioCapture failed");
362 }
363 MEDIA_LOGI("StartStreamAudioCapture end");
364 return ret;
365 }
366
SetSCInnerAudioCaptureAndPushData(std::shared_ptr<AudioBuffer> innerAudioBuffer)367 void ScreenCaptureServerFunctionTest::SetSCInnerAudioCaptureAndPushData(std::shared_ptr<AudioBuffer> innerAudioBuffer)
368 {
369 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>(
370 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_,
371 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_);
372 screenCaptureServer_->innerAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RECORDING;
373 screenCaptureServer_->innerAudioCapture_->availBuffers_.push_back(innerAudioBuffer);
374 }
375
SetSCMicAudioCaptureAndPushData(std::shared_ptr<AudioBuffer> micAudioBuffer)376 void ScreenCaptureServerFunctionTest::SetSCMicAudioCaptureAndPushData(std::shared_ptr<AudioBuffer> micAudioBuffer)
377 {
378 screenCaptureServer_->micAudioCapture_ = std::make_shared<AudioCapturerWrapper>(
379 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo, screenCaptureServer_->screenCaptureCb_,
380 std::string("OS_MicAudioCapture"), screenCaptureServer_->contentFilter_);
381 screenCaptureServer_->micAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RECORDING;
382 screenCaptureServer_->micAudioCapture_->availBuffers_.push_back(micAudioBuffer);
383 }
384
385 // videoCapInfo and innerCapInfo IGNORE
386 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_001, TestSize.Level2)
387 {
388 SetInvalidConfig();
389 config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
390 config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
391 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
392 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
393 }
394
395 // audioSampleRate INVALID
396 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_002, TestSize.Level2)
397 {
398 SetInvalidConfig();
399 config_.audioInfo.micCapInfo.audioSampleRate = 12345;
400 config_.audioInfo.micCapInfo.audioChannels = 2;
401 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
402 config_.audioInfo.innerCapInfo.audioSampleRate = 54321;
403 config_.audioInfo.innerCapInfo.audioChannels = 2;
404 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
405 ASSERT_NE(InitStreamScreenCaptureServer(), MSERR_OK);
406 }
407
408 // videoCapInfo INVALID
409 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_003, TestSize.Level2)
410 {
411 SetInvalidConfig();
412 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
413 config_.audioInfo.micCapInfo.audioChannels = 2;
414 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
415 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
416 config_.audioInfo.innerCapInfo.audioChannels = 2;
417 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
418 config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
419 config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
420 ASSERT_NE(InitStreamScreenCaptureServer(), MSERR_OK);
421 }
422
423 // dataType INVALID
424 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_004, TestSize.Level2)
425 {
426 SetInvalidConfig();
427 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
428 config_.audioInfo.micCapInfo.audioChannels = 2;
429 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
430 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
431 config_.audioInfo.innerCapInfo.audioChannels = 2;
432 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
433 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
434 screenCaptureServer_->captureConfig_.dataType = DataType::INVAILD;
435 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
436 }
437
438 // surface_ is nullptr
439 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_005, TestSize.Level2)
440 {
441 SetInvalidConfig();
442 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
443 config_.audioInfo.micCapInfo.audioChannels = 2;
444 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
445 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
446 config_.audioInfo.innerCapInfo.audioChannels = 2;
447 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
448 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
449 screenCaptureServer_->isSurfaceMode_ = true;
450 screenCaptureServer_->surface_ = nullptr;
451 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
452 }
453
454 // audioSampleRate INVALID
455 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_006, TestSize.Level2)
456 {
457 SetInvalidConfig();
458 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
459 config_.audioInfo.micCapInfo.audioChannels = 2;
460 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
461 config_.audioInfo.innerCapInfo.audioSampleRate = 1;
462 config_.audioInfo.innerCapInfo.audioChannels = 2;
463 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
464 screenCaptureServer_->captureConfig_ = config_;
465 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
466 }
467
468 // videoFrameWidth and videoFrameHeight INVALID
469 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_001, TestSize.Level2)
470 {
471 RecorderInfo recorderInfo;
472 SetRecorderInfo("capture_file_params_invalid_001.mp4", recorderInfo);
473 SetInvalidConfigFile(recorderInfo);
474 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
475 config_.audioInfo.micCapInfo.audioChannels = 2;
476 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
477 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
478 config_.audioInfo.innerCapInfo.audioChannels = 2;
479 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
480 config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
481 config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
482 ASSERT_NE(InitFileScreenCaptureServer(), MSERR_OK);
483 }
484
485 // audioSampleRate INVALID
486 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_002, TestSize.Level2)
487 {
488 RecorderInfo recorderInfo;
489 SetRecorderInfo("capture_file_params_invalid_002.mp4", recorderInfo);
490 SetInvalidConfigFile(recorderInfo);
491 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
492 config_.audioInfo.micCapInfo.audioChannels = 2;
493 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
494 config_.audioInfo.innerCapInfo.audioSampleRate = 1;
495 config_.audioInfo.innerCapInfo.audioChannels = 2;
496 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
497 ASSERT_NE(InitFileScreenCaptureServer(), MSERR_OK);
498 }
499
500 // audioSampleRate and audioSampleRate are not equal
501 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_003, TestSize.Level2)
502 {
503 RecorderInfo recorderInfo;
504 SetRecorderInfo("capture_file_params_invalid_003.mp4", recorderInfo);
505 SetInvalidConfigFile(recorderInfo);
506 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
507 config_.audioInfo.micCapInfo.audioChannels = 2;
508 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
509 config_.audioInfo.innerCapInfo.audioSampleRate = 8000;
510 config_.audioInfo.innerCapInfo.audioChannels = 2;
511 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
512 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
513 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
514 }
515
516 // videoCapInfo Ignored, is valid
517 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_004, TestSize.Level2)
518 {
519 RecorderInfo recorderInfo;
520 SetRecorderInfo("capture_file_params_invalid_004.mp4", recorderInfo);
521 SetInvalidConfigFile(recorderInfo);
522 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
523 config_.audioInfo.micCapInfo.audioChannels = 2;
524 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
525 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
526 config_.audioInfo.innerCapInfo.audioChannels = 2;
527 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
528 config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
529 config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
530 screenCaptureServer_->captureConfig_ = config_;
531 ASSERT_EQ(screenCaptureServer_->CheckAllParams(), MSERR_OK);
532 }
533
534 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_005, TestSize.Level2)
535 {
536 RecorderInfo recorderInfo;
537 SetRecorderInfo("capture_file_params_invalid_005.mp4", recorderInfo);
538 SetInvalidConfigFile(recorderInfo);
539 config_.audioInfo.micCapInfo.audioSampleRate = -1;
540 config_.audioInfo.micCapInfo.audioChannels = 2;
541 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
542 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
543 config_.audioInfo.innerCapInfo.audioChannels = 2;
544 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
545 screenCaptureServer_->captureConfig_ = config_;
546 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
547 }
548
549 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_006, TestSize.Level2)
550 {
551 RecorderInfo recorderInfo;
552 SetRecorderInfo("capture_file_params_invalid_006.mp4", recorderInfo);
553 SetInvalidConfigFile(recorderInfo);
554 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
555 config_.audioInfo.micCapInfo.audioChannels = 2;
556 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
557 config_.audioInfo.innerCapInfo.audioSampleRate = -1;
558 config_.audioInfo.innerCapInfo.audioChannels = 2;
559 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
560 screenCaptureServer_->captureConfig_ = config_;
561 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
562 }
563
564 // micCapInfo Ignored, is valid
565 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_007, TestSize.Level2)
566 {
567 RecorderInfo recorderInfo;
568 SetRecorderInfo("capture_file_params_invalid_007.mp4", recorderInfo);
569 SetInvalidConfigFile(recorderInfo);
570 config_.audioInfo.micCapInfo.audioSampleRate = 0;
571 config_.audioInfo.micCapInfo.audioChannels = 0;
572 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
573 config_.audioInfo.innerCapInfo.audioChannels = 2;
574 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
575 screenCaptureServer_->captureConfig_ = config_;
576 ASSERT_EQ(screenCaptureServer_->CheckAllParams(), MSERR_OK);
577 }
578
579 // audioChannels is different
580 HWTEST_F(ScreenCaptureServerFunctionTest, capture_file_params_invalid_008, TestSize.Level2)
581 {
582 RecorderInfo recorderInfo;
583 SetRecorderInfo("capture_file_params_invalid_008.mp4", recorderInfo);
584 SetInvalidConfigFile(recorderInfo);
585 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
586 config_.audioInfo.micCapInfo.audioChannels = 1;
587 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
588 config_.audioInfo.innerCapInfo.audioChannels = 2;
589 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
590 screenCaptureServer_->captureConfig_ = config_;
591 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
592 }
593
594 HWTEST_F(ScreenCaptureServerFunctionTest, GetMissionIds_001, TestSize.Level2)
595 {
596 SetInvalidConfig();
597 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
598 config_.audioInfo.micCapInfo.audioChannels = 2;
599 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
600 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
601 config_.audioInfo.innerCapInfo.audioChannels = 2;
602 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
603 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
604 ASSERT_EQ(screenCaptureServer_->GetMissionIds(screenCaptureServer_->missionIds_), MSERR_OK);
605 }
606
607 HWTEST_F(ScreenCaptureServerFunctionTest, GetMissionIds_002, TestSize.Level2)
608 {
609 SetInvalidConfig();
610 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
611 config_.audioInfo.micCapInfo.audioChannels = 2;
612 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
613 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
614 config_.audioInfo.innerCapInfo.audioChannels = 2;
615 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
616 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
617 screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.push_back(1);
618 screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.push_back(2);
619 ASSERT_EQ(screenCaptureServer_->GetMissionIds(screenCaptureServer_->missionIds_), MSERR_OK);
620 }
621
622 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_001, TestSize.Level2)
623 {
624 SetInvalidConfig();
625 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
626 config_.audioInfo.micCapInfo.audioChannels = 2;
627 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
628 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
629 config_.audioInfo.innerCapInfo.audioChannels = 2;
630 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
631 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
632 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
633 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
634 screenCaptureServer_->captureCallback_->OnRendererStateChange(audioRendererChangeInfos);
635 screenCaptureServer_->audioSource_->VoIPStateUpdate(audioRendererChangeInfos);
636 screenCaptureServer_->audioSource_->isInVoIPCall_ = true;
637 screenCaptureServer_->audioSource_->VoIPStateUpdate(audioRendererChangeInfos);
638 sleep(RECORDER_TIME);
639 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
640 }
641
642 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_002, TestSize.Level2)
643 {
644 SetInvalidConfig();
645 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
646 config_.audioInfo.micCapInfo.audioChannels = 2;
647 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
648 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
649 config_.audioInfo.innerCapInfo.audioChannels = 2;
650 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
651 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
652 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
653 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
654 screenCaptureServer_->audioSource_->SpeakerStateUpdate(audioRendererChangeInfos);
655 ASSERT_EQ(screenCaptureServer_->audioSource_->HasSpeakerStream(audioRendererChangeInfos), false);
656 sleep(RECORDER_TIME);
657 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
658 }
659
660 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_003, TestSize.Level2)
661 {
662 SetValidConfig();
663 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
664 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
665 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
666 for (int i = 0; i < 7; ++i) {
667 std::shared_ptr<AudioRendererChangeInfo> changeInfo = std::make_shared<AudioRendererChangeInfo>();
668 audioRendererChangeInfos.push_back(changeInfo);
669 }
670 audioRendererChangeInfos.push_back(nullptr);
671 audioRendererChangeInfos[0]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_WIRED_HEADSET;
672 audioRendererChangeInfos[1]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_WIRED_HEADPHONES;
673 audioRendererChangeInfos[2]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
674 audioRendererChangeInfos[3]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
675 audioRendererChangeInfos[4]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET;
676 audioRendererChangeInfos[5]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
677 audioRendererChangeInfos[6]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
678 screenCaptureServer_->audioSource_->HasSpeakerStream(audioRendererChangeInfos);
679 ASSERT_EQ(screenCaptureServer_->audioSource_->HasSpeakerStream(audioRendererChangeInfos), true);
680 sleep(RECORDER_TIME);
681 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
682 }
683
684 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_004, TestSize.Level2)
685 {
686 SetValidConfig();
687 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
688 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
689 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
690 audioRendererChangeInfos.push_back(nullptr);
691 for (int i = 0; i < 3; ++i) {
692 std::shared_ptr<AudioRendererChangeInfo> changeInfo = std::make_shared<AudioRendererChangeInfo>();
693 audioRendererChangeInfos.push_back(changeInfo);
694 }
695 audioRendererChangeInfos[1]->rendererState = RendererState::RENDERER_STOPPED;
696 audioRendererChangeInfos[2]->rendererState = RendererState::RENDERER_RUNNING;
697 audioRendererChangeInfos[2]->rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MEDIA;
698 audioRendererChangeInfos[3]->rendererState = RendererState::RENDERER_RUNNING;
699 audioRendererChangeInfos[3]->rendererInfo.streamUsage =
700 AudioStandard::StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
701 screenCaptureServer_->audioSource_->HasVoIPStream(audioRendererChangeInfos);
702 sleep(RECORDER_TIME);
703 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
704 }
705
706 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_005, TestSize.Level2)
707 {
708 SetInvalidConfig();
709 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
710 config_.audioInfo.micCapInfo.audioChannels = 2;
711 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
712 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
713 config_.audioInfo.innerCapInfo.audioChannels = 2;
714 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
715 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
716 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
717 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
718 screenCaptureServer_->audioSource_->speakerAliveStatus_ = true;
719 screenCaptureServer_->audioSource_->SpeakerStateUpdate(audioRendererChangeInfos);
720 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
721 screenCaptureServer_->audioSource_->SpeakerStateUpdate(audioRendererChangeInfos);
722 sleep(RECORDER_TIME);
723 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
724 }
725
726 HWTEST_F(ScreenCaptureServerFunctionTest, CheckScreenCapturePermission_001, TestSize.Level2)
727 {
728 SetInvalidConfig();
729 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
730 config_.audioInfo.micCapInfo.audioChannels = 2;
731 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
732 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
733 config_.audioInfo.innerCapInfo.audioChannels = 2;
734 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
735 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
736 ASSERT_EQ(screenCaptureServer_->CheckScreenCapturePermission(), true);
737 }
738
739 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_001, TestSize.Level2)
740 {
741 SetInvalidConfig();
742 config_.videoInfo.videoEncInfo.videoCodec = VIDEO_CODEC_FORMAT_BUTT;
743 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
744 }
745
746 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_002, TestSize.Level2)
747 {
748 SetInvalidConfig();
749 config_.videoInfo.videoEncInfo.videoBitrate = screenCaptureServer_->VIDEO_BITRATE_MIN - 1;
750 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
751 }
752
753 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_003, TestSize.Level2)
754 {
755 SetInvalidConfig();
756 config_.videoInfo.videoEncInfo.videoBitrate = screenCaptureServer_->VIDEO_BITRATE_MAX + 1;
757 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
758 }
759
760 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_004, TestSize.Level2)
761 {
762 SetInvalidConfig();
763 config_.videoInfo.videoEncInfo.videoFrameRate = screenCaptureServer_->VIDEO_FRAME_RATE_MIN - 1;
764 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
765 }
766
767 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_005, TestSize.Level2)
768 {
769 SetInvalidConfig();
770 config_.videoInfo.videoEncInfo.videoFrameRate = screenCaptureServer_->VIDEO_FRAME_RATE_MAX + 1;
771 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
772 }
773
774 HWTEST_F(ScreenCaptureServerFunctionTest, SetOutputFile_001, TestSize.Level2)
775 {
776 ASSERT_NE(screenCaptureServer_->SetOutputFile(-1), MSERR_OK);
777 }
778
779 HWTEST_F(ScreenCaptureServerFunctionTest, OnStartScreenCapture_001, TestSize.Level2)
780 {
781 SetInvalidConfig();
782 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
783 config_.audioInfo.micCapInfo.audioChannels = 2;
784 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
785 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
786 config_.audioInfo.innerCapInfo.audioChannels = 2;
787 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
788 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
789 ASSERT_EQ(screenCaptureServer_->OnStartScreenCapture(), MSERR_OK);
790 }
791
792 HWTEST_F(ScreenCaptureServerFunctionTest, OnStartScreenCapture_002, TestSize.Level2)
793 {
794 RecorderInfo recorderInfo;
795 SetRecorderInfo("on_start_screen_capture_unittest_002.mp4", recorderInfo);
796 SetInvalidConfigFile(recorderInfo);
797 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
798 config_.audioInfo.micCapInfo.audioChannels = 2;
799 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
800 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
801 config_.audioInfo.innerCapInfo.audioChannels = 2;
802 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
803 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
804 ASSERT_NE(screenCaptureServer_->OnStartScreenCapture(), MSERR_OK);
805 }
806
807 HWTEST_F(ScreenCaptureServerFunctionTest, SetScreenScaleMode_001, TestSize.Level2)
808 {
809 ASSERT_NE(screenCaptureServer_->SetScreenScaleMode(), MSERR_OK);
810 }
811
812 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_001, TestSize.Level2)
813 {
814 ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(false), MSERR_OK);
815 }
816
817 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_002, TestSize.Level2)
818 {
819 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
820 ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(false), MSERR_OK);
821 }
822
823 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_003, TestSize.Level2)
824 {
825 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
826 ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(true), MSERR_OK);
827 }
828
829 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_004, TestSize.Level2)
830 {
831 screenCaptureServer_->screenCaptureCb_ = nullptr;
832 ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(false), MSERR_OK);
833 }
834
835 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatStartAudioCapture_001, TestSize.Level2)
836 {
837 SetInvalidConfig();
838 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
839 config_.audioInfo.micCapInfo.audioChannels = 2;
840 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
841 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
842 config_.audioInfo.innerCapInfo.audioChannels = 2;
843 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
844 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
845 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
846 ASSERT_NE(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK);
847 }
848
849 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatResumeAudioCapture_001, TestSize.Level2)
850 {
851 SetInvalidConfig();
852 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
853 config_.audioInfo.micCapInfo.audioChannels = 2;
854 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
855 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
856 config_.audioInfo.innerCapInfo.audioChannels = 2;
857 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
858 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
859 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
860 }
861
862 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatPauseAudioCapture_001, TestSize.Level2)
863 {
864 SetInvalidConfig();
865 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
866 config_.audioInfo.micCapInfo.audioChannels = 2;
867 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
868 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
869 config_.audioInfo.innerCapInfo.audioChannels = 2;
870 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
871 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
872 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
873 }
874
875 HWTEST_F(ScreenCaptureServerFunctionTest, UpdatePrivacyUsingPermissionState_001, TestSize.Level2)
876 {
877 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID;
878 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(START_VIDEO), true);
879 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(STOP_VIDEO), true);
880 }
881
882 HWTEST_F(ScreenCaptureServerFunctionTest, UpdatePrivacyUsingPermissionState_002, TestSize.Level2)
883 {
884 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID + 1;
885 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(START_VIDEO), false);
886 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(STOP_VIDEO), false);
887 }
888
889 HWTEST_F(ScreenCaptureServerFunctionTest, StartScreenCaptureWithSurface_001, TestSize.Level2)
890 {
891 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
892 ASSERT_NE(screenCaptureServer_->StartScreenCaptureWithSurface(nullptr, true), MSERR_OK);
893 }
894
895 HWTEST_F(ScreenCaptureServerFunctionTest, MixAudio_001, TestSize.Level2)
896 {
897 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
898 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
899 const int channels = 2;
900 const int bufferSize = 10;
901 const char minChar = (char)-128;
902 char innerBuffer[bufferSize] = {minChar, minChar, minChar, minChar, minChar, minChar, minChar, minChar,
903 minChar, minChar};
904 char micBuffer[bufferSize] = {minChar, minChar, minChar, minChar, minChar, minChar, minChar, minChar,
905 minChar, minChar};
906 char* srcData[channels] = {nullptr};
907 srcData[0] = innerBuffer;
908 srcData[1] = micBuffer;
909 char mixData[bufferSize] = {0};
910 screenCaptureServer_->audioSource_->MixAudio(srcData, mixData, channels, bufferSize);
911 ASSERT_EQ(mixData[0], 0);
912 }
913
914 HWTEST_F(ScreenCaptureServerFunctionTest, MixAudio_002, TestSize.Level2)
915 {
916 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
917 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
918 const int channels = 2;
919 const int bufferSize = 10;
920 const char maxChar = (char)127;
921 char innerBuffer[bufferSize] = {maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar,
922 maxChar, maxChar};
923 char micBuffer[bufferSize] = {maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar,
924 maxChar, maxChar};
925 char* srcData[channels] = {nullptr};
926 srcData[0] = innerBuffer;
927 srcData[1] = micBuffer;
928 char mixData[bufferSize] = {0};
929 screenCaptureServer_->audioSource_->MixAudio(srcData, mixData, channels, bufferSize);
930 ASSERT_EQ(mixData[1], maxChar);
931 }
932
933 // MixAudio input channels param is 0
934 HWTEST_F(ScreenCaptureServerFunctionTest, MixAudio_003, TestSize.Level2)
935 {
936 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
937 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
938 const int channels = 2;
939 const int bufferSize = 10;
940 const char maxChar = (char)127;
941 char innerBuffer[bufferSize] = {maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar,
942 maxChar, maxChar};
943 char micBuffer[bufferSize] = {maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar, maxChar,
944 maxChar, maxChar};
945 char* srcData[channels] = {nullptr};
946 srcData[0] = innerBuffer;
947 srcData[1] = micBuffer;
948 char mixData[bufferSize] = {0};
949 screenCaptureServer_->audioSource_->MixAudio(srcData, mixData, 0, bufferSize);
950 ASSERT_EQ(mixData[0], 0);
951 }
952
953 HWTEST_F(ScreenCaptureServerFunctionTest, ScreenConnectListenerInScreenCapture_001, TestSize.Level2)
954 {
955 screenCaptureServer_->displayScreenId_ = 1; // 1 display screen id
956 screenCaptureServer_->RegisterScreenConnectListener();
957 uint64_t screenId = 1; // 1 disconnect screen id
958 screenCaptureServer_->screenConnectListener_->OnConnect(screenId);
959 screenCaptureServer_->screenConnectListener_->OnDisconnect(screenId);
960 screenCaptureServer_->screenConnectListener_->OnChange(screenId);
961 ASSERT_NE(screenCaptureServer_->screenConnectListener_, nullptr);
962 }
963
964 HWTEST_F(ScreenCaptureServerFunctionTest, ScreenConnectListenerInScreenCapture_002, TestSize.Level2)
965 {
966 screenCaptureServer_->displayScreenId_ = 2; // 2 display screen id
967 screenCaptureServer_->RegisterScreenConnectListener();
968 uint64_t screenId = 1; // 1 disconnect screen id
969 screenCaptureServer_->screenConnectListener_->OnConnect(screenId);
970 screenCaptureServer_->screenConnectListener_->OnDisconnect(screenId);
971 screenCaptureServer_->screenConnectListener_->OnChange(screenId);
972 ASSERT_NE(screenCaptureServer_->screenConnectListener_, nullptr);
973 }
974
975 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_001, TestSize.Level2)
976 {
977 auto notificationSubscriber = NotificationSubscriber();
978 notificationSubscriber.OnConnected();
979 notificationSubscriber.OnDisconnected();
980 notificationSubscriber.OnDied();
981 ASSERT_NE(¬ificationSubscriber, nullptr);
982 }
983
984 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_002, TestSize.Level2)
985 {
986 std::shared_ptr<ScreenCaptureServer> screenCaptureServerInner;
987 std::shared_ptr<IScreenCaptureService> tempServer = ScreenCaptureServer::Create();
988 screenCaptureServerInner = std::static_pointer_cast<ScreenCaptureServer>(tempServer);
989 RecorderInfo recorderInfo{};
990 SetValidConfigFile(recorderInfo);
991 config_.dataType = DataType::ORIGINAL_STREAM;
992 sptr<IStandardScreenCaptureListener> listener = new(std::nothrow) StandardScreenCaptureServerUnittestCallback();
993 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb =
994 std::make_shared<ScreenCaptureServerUnittestCallbackMock>(listener);
995 screenCaptureServerInner->SetScreenCaptureCallback(screenCaptureCb);
996 screenCaptureServerInner->SetCaptureMode(config_.captureMode);
997 screenCaptureServerInner->SetDataType(config_.dataType);
998 screenCaptureServerInner->InitAudioCap(config_.audioInfo.innerCapInfo);
999 screenCaptureServerInner->InitVideoCap(config_.videoInfo.videoCapInfo);
1000 screenCaptureServerInner->InitAudioCap(config_.audioInfo.micCapInfo);
1001 int32_t ret = screenCaptureServerInner->StartScreenCapture(false);
1002 ASSERT_EQ(ret, MSERR_OK);
1003 sleep(RECORDER_TIME);
1004
1005 auto notificationSubscriber = NotificationSubscriber();
1006 if (screenCaptureServerInner->serverMap_.begin() != screenCaptureServerInner->serverMap_.end()) {
1007 int32_t notificationId = screenCaptureServerInner->serverMap_.begin()->first;
1008 OHOS::sptr<OHOS::Notification::NotificationButtonOption> buttonOption =
1009 new(std::nothrow) OHOS::Notification::NotificationButtonOption();
1010 buttonOption->SetButtonName(BUTTON_NAME_STOP);
1011 notificationSubscriber.OnResponse(notificationId, buttonOption);
1012 }
1013 ASSERT_NE(¬ificationSubscriber, nullptr);
1014
1015 screenCaptureServerInner->Release();
1016 }
1017
1018 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_003, TestSize.Level2)
1019 {
1020 std::shared_ptr<ScreenCaptureServer> screenCaptureServerInner;
1021 std::shared_ptr<IScreenCaptureService> tempServer = ScreenCaptureServer::Create();
1022 screenCaptureServerInner = std::static_pointer_cast<ScreenCaptureServer>(tempServer);
1023 RecorderInfo recorderInfo{};
1024 SetValidConfigFile(recorderInfo);
1025 config_.dataType = DataType::ORIGINAL_STREAM;
1026 sptr<IStandardScreenCaptureListener> listener = new(std::nothrow) StandardScreenCaptureServerUnittestCallback();
1027 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb =
1028 std::make_shared<ScreenCaptureServerUnittestCallbackMock>(listener);
1029 screenCaptureServerInner->SetScreenCaptureCallback(screenCaptureCb);
1030 screenCaptureServerInner->SetCaptureMode(config_.captureMode);
1031 screenCaptureServerInner->SetDataType(config_.dataType);
1032 screenCaptureServerInner->InitAudioCap(config_.audioInfo.innerCapInfo);
1033 screenCaptureServerInner->InitVideoCap(config_.videoInfo.videoCapInfo);
1034 screenCaptureServerInner->InitAudioCap(config_.audioInfo.micCapInfo);
1035 int32_t ret = screenCaptureServerInner->StartScreenCapture(false);
1036 ASSERT_EQ(ret, MSERR_OK);
1037 sleep(RECORDER_TIME);
1038
1039 auto notificationSubscriber = NotificationSubscriber();
1040 if (screenCaptureServerInner->serverMap_.begin() != screenCaptureServerInner->serverMap_.end()) {
1041 int32_t notificationId = screenCaptureServerInner->serverMap_.begin()->first;
1042 OHOS::sptr<OHOS::Notification::NotificationButtonOption> buttonOption =
1043 new(std::nothrow) OHOS::Notification::NotificationButtonOption();
1044 buttonOption->SetButtonName("null");
1045 notificationSubscriber.OnResponse(notificationId, buttonOption);
1046 }
1047
1048 sleep(RECORDER_TIME);
1049 ASSERT_NE(¬ificationSubscriber, nullptr);
1050 screenCaptureServerInner->StopScreenCapture();
1051 screenCaptureServerInner->Release();
1052 }
1053
1054 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_004, TestSize.Level2)
1055 {
1056 std::shared_ptr<ScreenCaptureServer> screenCaptureServerInner;
1057 std::shared_ptr<IScreenCaptureService> tempServer = ScreenCaptureServer::Create();
1058 screenCaptureServerInner = std::static_pointer_cast<ScreenCaptureServer>(tempServer);
1059 RecorderInfo recorderInfo{};
1060 SetValidConfigFile(recorderInfo);
1061 config_.dataType = DataType::ORIGINAL_STREAM;
1062 sptr<IStandardScreenCaptureListener> listener = new(std::nothrow) StandardScreenCaptureServerUnittestCallback();
1063 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb =
1064 std::make_shared<ScreenCaptureServerUnittestCallbackMock>(listener);
1065 screenCaptureServerInner->SetScreenCaptureCallback(screenCaptureCb);
1066 screenCaptureServerInner->SetCaptureMode(config_.captureMode);
1067 screenCaptureServerInner->SetDataType(config_.dataType);
1068 screenCaptureServerInner->InitAudioCap(config_.audioInfo.innerCapInfo);
1069 screenCaptureServerInner->InitVideoCap(config_.videoInfo.videoCapInfo);
1070 screenCaptureServerInner->InitAudioCap(config_.audioInfo.micCapInfo);
1071 int32_t ret = screenCaptureServerInner->StartScreenCapture(false);
1072 ASSERT_EQ(ret, MSERR_OK);
1073 sleep(RECORDER_TIME);
1074
1075 auto notificationSubscriber = NotificationSubscriber();
1076 int32_t invalidNotificationId = ScreenCaptureServer::maxSessionId_ + 1;
1077 OHOS::sptr<OHOS::Notification::NotificationButtonOption> buttonOption =
1078 new(std::nothrow) OHOS::Notification::NotificationButtonOption();
1079 buttonOption->SetButtonName("null");
1080 notificationSubscriber.OnResponse(invalidNotificationId, buttonOption);
1081
1082 sleep(RECORDER_TIME);
1083 ASSERT_NE(¬ificationSubscriber, nullptr);
1084 screenCaptureServerInner->StopScreenCapture();
1085 screenCaptureServerInner->Release();
1086 }
1087
1088 HWTEST_F(ScreenCaptureServerFunctionTest, SetDisplayId_001, TestSize.Level2)
1089 {
1090 uint64_t displayId = 0;
1091 screenCaptureServer_->SetDisplayId(displayId);
1092 ASSERT_EQ(screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.displayId, displayId);
1093 }
1094
1095 HWTEST_F(ScreenCaptureServerFunctionTest, SetMissionId_001, TestSize.Level2)
1096 {
1097 uint64_t missionId = 0;
1098 screenCaptureServer_->SetMissionId(missionId);
1099 ASSERT_EQ(screenCaptureServer_->missionIds_.back(), missionId);
1100 }
1101
1102 HWTEST_F(ScreenCaptureServerFunctionTest, StartScreenCaptureInner_001, TestSize.Level2)
1103 {
1104 SetValidConfig();
1105 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1106 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID + 1;
1107 ASSERT_NE(screenCaptureServer_->StartScreenCaptureInner(true), MSERR_OK);
1108 }
1109
1110 HWTEST_F(ScreenCaptureServerFunctionTest, IsTelInCallSkipList_001, TestSize.Level2)
1111 {
1112 screenCaptureServer_->isCalledBySystemApp_ = true;
1113 screenCaptureServer_->appName_ = HiviewCareBundleName;
1114 ASSERT_EQ(screenCaptureServer_->IsTelInCallSkipList(), true);
1115 }
1116
1117 HWTEST_F(ScreenCaptureServerFunctionTest, IsTelInCallSkipList_002, TestSize.Level2)
1118 {
1119 screenCaptureServer_->isCalledBySystemApp_ = true;
1120 screenCaptureServer_->appName_ = "";
1121 ASSERT_EQ(screenCaptureServer_->IsTelInCallSkipList(), false);
1122 }
1123
1124 HWTEST_F(ScreenCaptureServerFunctionTest, IsTelInCallSkipList_003, TestSize.Level2)
1125 {
1126 screenCaptureServer_->isCalledBySystemApp_ = false;
1127 screenCaptureServer_->appName_ = "";
1128 ASSERT_EQ(screenCaptureServer_->IsTelInCallSkipList(), false);
1129 }
1130
1131 HWTEST_F(ScreenCaptureServerFunctionTest, GetStringByResourceName_001, TestSize.Level2)
1132 {
1133 screenCaptureServer_->InitResourceManager();
1134 std::string liveViewText = ScreenCaptureServer::QUOTATION_MARKS_STRING;
1135 liveViewText += screenCaptureServer_->GetStringByResourceName(
1136 ScreenCaptureServer::NOTIFICATION_SCREEN_RECORDING_TITLE_ID).c_str();
1137 MEDIA_LOGI("GetStringByResourceName liveViewText: %{public}s", liveViewText.c_str());
1138 ASSERT_EQ(screenCaptureServer_->GetStringByResourceName(
1139 ScreenCaptureServer::NOTIFICATION_SCREEN_RECORDING_TITLE_ID).size() > 0, true);
1140 ASSERT_EQ(screenCaptureServer_->GetStringByResourceName("NOT_EXITS_ID").size() == 0, true);
1141 screenCaptureServer_->resourceManager_ = nullptr;
1142 ASSERT_EQ(screenCaptureServer_->GetStringByResourceName(
1143 ScreenCaptureServer::NOTIFICATION_SCREEN_RECORDING_TITLE_ID).size() > 0, false);
1144 }
1145
1146 HWTEST_F(ScreenCaptureServerFunctionTest, SetCaptureConfig_001, TestSize.Level2)
1147 {
1148 screenCaptureServer_->SetCaptureConfig(CAPTURE_INVAILD, -1);
1149 screenCaptureServer_->SetCaptureConfig(CAPTURE_INVAILD, 0);
1150 ASSERT_EQ(screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.back(), 0);
1151 }
1152
1153 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION
1154 HWTEST_F(ScreenCaptureServerFunctionTest, TryNotificationOnPostStartScreenCapture_001, TestSize.Level2)
1155 {
1156 int32_t ret = screenCaptureServer_->TryNotificationOnPostStartScreenCapture();
1157 ASSERT_NE(ret, MSERR_OK);
1158 }
1159 #endif
1160
1161 HWTEST_F(ScreenCaptureServerFunctionTest, ReadAtMix_001, TestSize.Level2)
1162 {
1163 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
1164 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1165 screenCaptureServer_->GetSCServerCaptureState();
1166 screenCaptureServer_->IsMicrophoneSwitchTurnOn();
1167 screenCaptureServer_->IsSCRecorderFileWithVideo();
1168 screenCaptureServer_->GetInnerAudioCapture();
1169 screenCaptureServer_->GetMicAudioCapture();
1170 screenCaptureServer_->IsStopAcquireAudioBufferFlag();
1171 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1172 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1173 screenCaptureServer_->audioSource_->IsInWaitMicSyncState();
1174 screenCaptureServer_->audioSource_->SetVideoFirstFramePts(0);
1175 screenCaptureServer_->audioSource_->SetAudioFirstFramePts(0);
1176 const int bufferSize = 10;
1177 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1178 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1179 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1180 SOURCE_DEFAULT);
1181 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1182 SOURCE_DEFAULT);
1183 std::shared_ptr<AVBuffer> buffer;
1184 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->ReadAt(buffer, bufferSize);
1185 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::SKIP_WITHOUT_LOG);
1186 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1187 screenCaptureServer_->audioSource_->type_ = AVScreenCaptureMixMode::INVALID_MODE;
1188 ret = screenCaptureServer_->audioSource_->ReadAt(buffer, bufferSize);
1189 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1190 screenCaptureServer_->audioSource_->screenCaptureServer_ = nullptr;
1191 ret = screenCaptureServer_->audioSource_->ReadAt(buffer, bufferSize);
1192 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1193 }
1194
1195 HWTEST_F(ScreenCaptureServerFunctionTest, ReadAtMix_002, TestSize.Level2)
1196 {
1197 RecorderInfo recorderInfo;
1198 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1199 SetValidConfigFile(recorderInfo);
1200 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1201 screenCaptureServer_->SetMicrophoneEnabled(true);
1202 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1203 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1204 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1205 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1206 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1207 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1208 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1209 screenCaptureServer_->StartFileInnerAudioCapture();
1210 screenCaptureServer_->StartFileMicAudioCapture();
1211 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1212 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1213 int64_t size = 0;
1214 screenCaptureServer_->audioSource_->GetSize(size);
1215 screenCaptureServer_->SetInnerAudioCapture(nullptr);
1216 screenCaptureServer_->audioSource_->GetSize(size);
1217 const int bufferSize = 10;
1218 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1219 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1220 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1221 SOURCE_DEFAULT);
1222 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1223 SOURCE_DEFAULT);
1224 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1225 screenCaptureServer_->audioSource_->ReadAt(buffer, bufferSize);
1226 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1227 }
1228
1229 HWTEST_F(ScreenCaptureServerFunctionTest, ReadAtMicMode_001, TestSize.Level2)
1230 {
1231 RecorderInfo recorderInfo;
1232 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1233 SetValidConfigFile(recorderInfo);
1234 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1235 screenCaptureServer_->SetMicrophoneEnabled(true);
1236 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1237 AVScreenCaptureMixMode::MIC_MODE, screenCaptureServer_.get());
1238 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1239 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1240 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1241 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1242 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1243 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1244 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIC_MODE;
1245 const int bufferSize = 10;
1246 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1247 screenCaptureServer_->micAudioCapture_ = std::make_shared<MicAudioCapturerWrapper>(
1248 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo, screenCaptureServer_->screenCaptureCb_,
1249 std::string("OS_MicAudioCapture"), screenCaptureServer_->contentFilter_);
1250 screenCaptureServer_->micAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RECORDING;
1251 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->ReadAtMicMode(buffer, bufferSize);
1252 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP); // AcquireAudioBuffer failed
1253 MEDIA_LOGI("ReadAtMicMode ret: %{public}d", static_cast<int32_t>(ret));
1254 screenCaptureServer_->micAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_UNKNOWN;
1255 ret = screenCaptureServer_->audioSource_->ReadAtMicMode(buffer, bufferSize);
1256 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1257 screenCaptureServer_->micAudioCapture_ = nullptr;
1258 ret = screenCaptureServer_->audioSource_->ReadAtMicMode(buffer, bufferSize);
1259 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::INVALID);
1260 }
1261
1262 HWTEST_F(ScreenCaptureServerFunctionTest, ReadAtMicMode_002, TestSize.Level2)
1263 {
1264 RecorderInfo recorderInfo;
1265 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1266 SetValidConfigFile(recorderInfo);
1267 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1268 screenCaptureServer_->SetMicrophoneEnabled(true);
1269 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1270 AVScreenCaptureMixMode::MIC_MODE, screenCaptureServer_.get());
1271 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1272 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1273 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1274 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1275 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1276 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1277 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIC_MODE;
1278 const int bufferSize = 10;
1279 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1280 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1281 SOURCE_DEFAULT);
1282 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1283 screenCaptureServer_->micAudioCapture_ = std::make_shared<MicAudioCapturerWrapper>(
1284 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo, screenCaptureServer_->screenCaptureCb_,
1285 std::string("OS_MicAudioCapture"), screenCaptureServer_->contentFilter_);
1286 screenCaptureServer_->micAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RECORDING;
1287 screenCaptureServer_->micAudioCapture_->availBuffers_.push_back(micAudioBuffer);
1288 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->ReadAtMicMode(buffer, bufferSize);
1289 MEDIA_LOGI("ReadAtMicMode ret: %{public}d", static_cast<int32_t>(ret));
1290 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1291 uint8_t data[bufferSize];
1292 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1293 buffer->memory_ = bufferMem;
1294 ret = screenCaptureServer_->audioSource_->ReadAtMicMode(buffer, bufferSize);
1295 MEDIA_LOGI("ReadAtMicMode 2 ret: %{public}d", static_cast<int32_t>(ret));
1296 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1297 }
1298
1299 HWTEST_F(ScreenCaptureServerFunctionTest, ReadAtInnerMode_001, TestSize.Level2)
1300 {
1301 RecorderInfo recorderInfo;
1302 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1303 SetValidConfigFile(recorderInfo);
1304 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1305 screenCaptureServer_->SetMicrophoneEnabled(false);
1306 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1307 AVScreenCaptureMixMode::INNER_MODE, screenCaptureServer_.get());
1308 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1309 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1310 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1311 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1312 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1313 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1314 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::INNER_MODE;
1315 const int bufferSize = 10;
1316 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1317 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>(
1318 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_,
1319 std::string("OS_innerAudioCapture"), screenCaptureServer_->contentFilter_);
1320 screenCaptureServer_->innerAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RECORDING;
1321 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->ReadAtInnerMode(buffer, bufferSize);
1322 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1323 MEDIA_LOGI("ReadAtInnerMode ret: %{public}d", static_cast<int32_t>(ret));
1324 screenCaptureServer_->innerAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_UNKNOWN;
1325 ret = screenCaptureServer_->audioSource_->ReadAtInnerMode(buffer, bufferSize);
1326 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1327 screenCaptureServer_->innerAudioCapture_ = nullptr;
1328 ret = screenCaptureServer_->audioSource_->ReadAtInnerMode(buffer, bufferSize);
1329 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::INVALID);
1330 }
1331
1332 HWTEST_F(ScreenCaptureServerFunctionTest, ReadAtInnerMode_002, TestSize.Level2)
1333 {
1334 RecorderInfo recorderInfo;
1335 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1336 SetValidConfigFile(recorderInfo);
1337 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1338 screenCaptureServer_->SetMicrophoneEnabled(false);
1339 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1340 AVScreenCaptureMixMode::INNER_MODE, screenCaptureServer_.get());
1341 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1342 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1343 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1344 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1345 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1346 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1347 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::INNER_MODE;
1348 const int bufferSize = 10;
1349 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1350 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1351 SOURCE_DEFAULT);
1352 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1353 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1354 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->ReadAtInnerMode(buffer, bufferSize);
1355 MEDIA_LOGI("ReadAtInnerMode ret: %{public}d", static_cast<int32_t>(ret));
1356 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1357 uint8_t data[bufferSize];
1358 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1359 buffer->memory_ = bufferMem;
1360 ret = screenCaptureServer_->audioSource_->ReadAtInnerMode(buffer, bufferSize);
1361 MEDIA_LOGI("ReadAtInnerMode 2 ret: %{public}d", static_cast<int32_t>(ret));
1362 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1363 }
1364
1365 HWTEST_F(ScreenCaptureServerFunctionTest, ReadAtMixMode_001, TestSize.Level2)
1366 {
1367 RecorderInfo recorderInfo;
1368 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1369 SetValidConfigFile(recorderInfo);
1370 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1371 screenCaptureServer_->SetMicrophoneEnabled(true);
1372 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1373 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1374 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1375 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1376 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1377 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1378 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1379 screenCaptureServer_->StartFileInnerAudioCapture();
1380 screenCaptureServer_->StartFileMicAudioCapture();
1381 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1382 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1383 const int bufferSize = 10;
1384 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1385 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1386 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1387 SOURCE_DEFAULT);
1388 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1389 SOURCE_DEFAULT);
1390 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1391 screenCaptureServer_->audioSource_->ReadAtMixMode(buffer, bufferSize);
1392 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1393 }
1394
1395 HWTEST_F(ScreenCaptureServerFunctionTest, ReadWriteAudioBufferMix_001, TestSize.Level2)
1396 {
1397 RecorderInfo recorderInfo;
1398 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1399 SetValidConfigFile(recorderInfo);
1400 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1401 screenCaptureServer_->SetMicrophoneEnabled(true);
1402 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1403 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1404 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1405 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1406 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1407 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1408 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1409 screenCaptureServer_->StartFileInnerAudioCapture();
1410 screenCaptureServer_->StartFileMicAudioCapture();
1411 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1412 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1413 const int bufferSize = 10;
1414 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1415 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1416 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1417 SOURCE_DEFAULT);
1418 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1419 SOURCE_DEFAULT);
1420 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1421 screenCaptureServer_->audioSource_->ReadWriteAudioBufferMix(buffer, bufferSize, innerAudioBuffer, micAudioBuffer);
1422 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1423 }
1424
1425 HWTEST_F(ScreenCaptureServerFunctionTest, ReadWriteAudioBufferMix_002, TestSize.Level2)
1426 {
1427 RecorderInfo recorderInfo;
1428 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1429 SetValidConfigFile(recorderInfo);
1430 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1431 screenCaptureServer_->SetMicrophoneEnabled(true);
1432 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1433 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1434 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1435 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1436 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1437 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1438 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1439 screenCaptureServer_->StartFileInnerAudioCapture();
1440 screenCaptureServer_->StartFileMicAudioCapture();
1441 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1442 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1443 screenCaptureServer_->recorderFileWithVideo_ = true;
1444 const int bufferSize = 10;
1445 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1446 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1447 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1448 SOURCE_DEFAULT);
1449 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1450 SOURCE_DEFAULT);
1451 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1452 screenCaptureServer_->audioSource_->ReadWriteAudioBufferMix(buffer, bufferSize, innerAudioBuffer, micAudioBuffer);
1453 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1454 }
1455
1456 HWTEST_F(ScreenCaptureServerFunctionTest, ReadWriteAudioBufferMixCore_001, TestSize.Level2)
1457 {
1458 RecorderInfo recorderInfo;
1459 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1460 SetValidConfigFile(recorderInfo);
1461 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1462 screenCaptureServer_->SetMicrophoneEnabled(true);
1463 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1464 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1465 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1466 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1467 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1468 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1469 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1470 screenCaptureServer_->StartFileInnerAudioCapture();
1471 screenCaptureServer_->StartFileMicAudioCapture();
1472 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1473 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1474 const int bufferSize = 10;
1475 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1476 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1477 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1478 SOURCE_DEFAULT);
1479 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1480 SOURCE_DEFAULT);
1481 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1482 screenCaptureServer_->audioSource_->ReadWriteAudioBufferMixCore(buffer, bufferSize, innerAudioBuffer,
1483 micAudioBuffer);
1484 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1485 }
1486
1487 HWTEST_F(ScreenCaptureServerFunctionTest, GetFirstAudioTime_001, TestSize.Level2)
1488 {
1489 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1490 AVScreenCaptureMixMode::MIC_MODE, screenCaptureServer_.get());
1491 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1492 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1493 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1494 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1495 const int bufferSize = 10;
1496 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1497 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1498 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1499 SOURCE_DEFAULT);
1500 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1501 SOURCE_DEFAULT);
1502 innerAudioBuffer->timestamp = 2;
1503 micAudioBuffer->timestamp = 1;
1504 int64_t resTime = screenCaptureServer_->audioSource_->GetFirstAudioTime(innerAudioBuffer, micAudioBuffer);
1505 ASSERT_EQ(resTime, micAudioBuffer->timestamp);
1506 innerAudioBuffer->timestamp = 1;
1507 micAudioBuffer->timestamp = 2;
1508 resTime = screenCaptureServer_->audioSource_->GetFirstAudioTime(innerAudioBuffer, micAudioBuffer);
1509 ASSERT_EQ(resTime, innerAudioBuffer->timestamp);
1510 innerAudioBuffer = nullptr;
1511 resTime = screenCaptureServer_->audioSource_->GetFirstAudioTime(innerAudioBuffer, micAudioBuffer);
1512 ASSERT_EQ(resTime, micAudioBuffer->timestamp);
1513 uint8_t *innerBufferNew = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1514 innerAudioBuffer = std::make_shared<AudioBuffer>(innerBufferNew, bufferSize, 0,
1515 SOURCE_DEFAULT);
1516 innerAudioBuffer->timestamp = 1;
1517 micAudioBuffer = nullptr;
1518 resTime = screenCaptureServer_->audioSource_->GetFirstAudioTime(innerAudioBuffer, micAudioBuffer);
1519 ASSERT_EQ(resTime, innerAudioBuffer->timestamp);
1520 innerAudioBuffer = nullptr;
1521 micAudioBuffer = nullptr;
1522 resTime = screenCaptureServer_->audioSource_->GetFirstAudioTime(innerAudioBuffer, micAudioBuffer);
1523 ASSERT_EQ(resTime, -1);
1524 }
1525
1526 HWTEST_F(ScreenCaptureServerFunctionTest, WriteInnerAudio_001, TestSize.Level2)
1527 {
1528 RecorderInfo recorderInfo;
1529 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1530 SetValidConfigFile(recorderInfo);
1531 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1532 screenCaptureServer_->SetMicrophoneEnabled(true);
1533 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1534 AVScreenCaptureMixMode::INNER_MODE, screenCaptureServer_.get());
1535 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1536 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1537 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1538 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1539 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1540 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::INNER_MODE;
1541 const int bufferSize = 10;
1542 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1543 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1544 SOURCE_DEFAULT);
1545 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1546 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1547 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->WriteInnerAudio(buffer, bufferSize,
1548 innerAudioBuffer);
1549 MEDIA_LOGI("WriteInnerAudio_001 ret: %{public}d", static_cast<int32_t>(ret));
1550 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1551 uint8_t data[bufferSize];
1552 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1553 buffer->memory_ = bufferMem;
1554 screenCaptureServer_->audioSource_->firstAudioFramePts_.store(-1);
1555 ret = screenCaptureServer_->audioSource_->WriteInnerAudio(buffer, bufferSize, innerAudioBuffer);
1556 MEDIA_LOGI("WriteInnerAudio_001 1 ret: %{public}d", static_cast<int32_t>(ret));
1557 screenCaptureServer_->audioSource_->firstAudioFramePts_.store(10);
1558 ret = screenCaptureServer_->audioSource_->WriteInnerAudio(buffer, bufferSize, innerAudioBuffer);
1559 MEDIA_LOGI("WriteInnerAudio_001 2 ret: %{public}d", static_cast<int32_t>(ret));
1560 }
1561
1562 HWTEST_F(ScreenCaptureServerFunctionTest, WriteMicAudio_001, TestSize.Level2)
1563 {
1564 RecorderInfo recorderInfo;
1565 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1566 SetValidConfigFile(recorderInfo);
1567 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1568 screenCaptureServer_->SetMicrophoneEnabled(true);
1569 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1570 AVScreenCaptureMixMode::MIC_MODE, screenCaptureServer_.get());
1571 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1572 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1573 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1574 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1575 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1576 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIC_MODE;
1577 const int bufferSize = 10;
1578 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1579 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1580 SOURCE_DEFAULT);
1581 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1582 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1583 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->WriteMicAudio(buffer, bufferSize,
1584 micAudioBuffer);
1585 MEDIA_LOGI("WriteMicAudio_001 ret: %{public}d", static_cast<int32_t>(ret));
1586 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1587 uint8_t data[bufferSize];
1588 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1589 buffer->memory_ = bufferMem;
1590 screenCaptureServer_->audioSource_->firstAudioFramePts_.store(-1);
1591 ret = screenCaptureServer_->audioSource_->WriteMicAudio(buffer, bufferSize, micAudioBuffer);
1592 MEDIA_LOGI("WriteMicAudio_001 1 ret: %{public}d", static_cast<int32_t>(ret));
1593 screenCaptureServer_->audioSource_->firstAudioFramePts_.store(10);
1594 ret = screenCaptureServer_->audioSource_->WriteMicAudio(buffer, bufferSize, micAudioBuffer);
1595 MEDIA_LOGI("WriteMicAudio_001 2 ret: %{public}d", static_cast<int32_t>(ret));
1596 }
1597
1598 HWTEST_F(ScreenCaptureServerFunctionTest, WriteMixAudio_001, TestSize.Level2)
1599 {
1600 RecorderInfo recorderInfo;
1601 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1602 SetValidConfigFile(recorderInfo);
1603 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1604 screenCaptureServer_->SetMicrophoneEnabled(true);
1605 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1606 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1607 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1608 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1609 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1610 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1611 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1612 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1613 const int bufferSize = 10;
1614 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1615 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1616 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1617 SOURCE_DEFAULT);
1618 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1619 SOURCE_DEFAULT);
1620 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1621 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1622 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1623 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->WriteMixAudio(buffer, bufferSize,
1624 innerAudioBuffer, micAudioBuffer);
1625 MEDIA_LOGI("WriteMixAudio_001 ret: %{public}d", static_cast<int32_t>(ret));
1626 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
1627 uint8_t data[bufferSize];
1628 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1629 buffer->memory_ = bufferMem;
1630 screenCaptureServer_->audioSource_->firstAudioFramePts_.store(-1);
1631 ret = screenCaptureServer_->audioSource_->WriteMixAudio(buffer, bufferSize, innerAudioBuffer, micAudioBuffer);
1632 MEDIA_LOGI("WriteMixAudio_001 1 ret: %{public}d", static_cast<int32_t>(ret));
1633 screenCaptureServer_->audioSource_->firstAudioFramePts_.store(10);
1634 ret = screenCaptureServer_->audioSource_->WriteMixAudio(buffer, bufferSize, innerAudioBuffer, micAudioBuffer);
1635 MEDIA_LOGI("WriteMixAudio_001 2 ret: %{public}d", static_cast<int32_t>(ret));
1636 }
1637
1638 HWTEST_F(ScreenCaptureServerFunctionTest, InnerMicAudioSync_001, TestSize.Level2)
1639 {
1640 RecorderInfo recorderInfo;
1641 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1642 SetValidConfigFile(recorderInfo);
1643 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1644 screenCaptureServer_->SetMicrophoneEnabled(true);
1645 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1646 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1647 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1648 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1649 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1650 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1651 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1652 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1653 screenCaptureServer_->StartFileInnerAudioCapture();
1654 screenCaptureServer_->StartFileMicAudioCapture();
1655 const int bufferSize = 10;
1656 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1657 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1658 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1659 SOURCE_DEFAULT);
1660 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1661 SOURCE_DEFAULT);
1662 micAudioBuffer->timestamp = 1;
1663 innerAudioBuffer->timestamp = 31333334;
1664 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1665 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1666 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1667 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->InnerMicAudioSync(buffer, bufferSize,
1668 innerAudioBuffer, micAudioBuffer);
1669 MEDIA_LOGI("InnerMicAudioSync_001 ret: %{public}d", static_cast<int32_t>(ret));
1670 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1671 }
1672
1673 HWTEST_F(ScreenCaptureServerFunctionTest, InnerMicAudioSync_002, TestSize.Level2)
1674 {
1675 RecorderInfo recorderInfo;
1676 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1677 SetValidConfigFile(recorderInfo);
1678 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1679 screenCaptureServer_->SetMicrophoneEnabled(true);
1680 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1681 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1682 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1683 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1684 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1685 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1686 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1687 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1688 screenCaptureServer_->StartFileInnerAudioCapture();
1689 screenCaptureServer_->StartFileMicAudioCapture();
1690 const int bufferSize = 10;
1691 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1692 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1693 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1694 SOURCE_DEFAULT);
1695 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1696 SOURCE_DEFAULT);
1697 micAudioBuffer->timestamp = 21333334;
1698 innerAudioBuffer->timestamp = 31333334;
1699 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1700 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1701 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1702 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->InnerMicAudioSync(buffer, bufferSize,
1703 innerAudioBuffer, micAudioBuffer);
1704 MEDIA_LOGI("InnerMicAudioSync_001 ret: %{public}d", static_cast<int32_t>(ret));
1705 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1706 }
1707
1708 HWTEST_F(ScreenCaptureServerFunctionTest, InnerMicAudioSync_003, TestSize.Level2)
1709 {
1710 RecorderInfo recorderInfo;
1711 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1712 SetValidConfigFile(recorderInfo);
1713 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1714 screenCaptureServer_->SetMicrophoneEnabled(true);
1715 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1716 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1717 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1718 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1719 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1720 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1721 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1722 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1723 screenCaptureServer_->StartFileInnerAudioCapture();
1724 screenCaptureServer_->StartFileMicAudioCapture();
1725 const int bufferSize = 10;
1726 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1727 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1728 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1729 SOURCE_DEFAULT);
1730 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1731 SOURCE_DEFAULT);
1732 micAudioBuffer->timestamp = 31333334;
1733 innerAudioBuffer->timestamp = 1;
1734 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1735 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1736 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1737 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->InnerMicAudioSync(buffer, bufferSize,
1738 innerAudioBuffer, micAudioBuffer);
1739 MEDIA_LOGI("InnerMicAudioSync_001 ret: %{public}d", static_cast<int32_t>(ret));
1740 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1741 }
1742
1743 HWTEST_F(ScreenCaptureServerFunctionTest, HandleMicBeforeInnerSync_001, TestSize.Level2)
1744 {
1745 RecorderInfo recorderInfo;
1746 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1747 SetValidConfigFile(recorderInfo);
1748 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1749 screenCaptureServer_->SetMicrophoneEnabled(true);
1750 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1751 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1752 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1753 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1754 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1755 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1756 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1757 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1758 screenCaptureServer_->StartFileInnerAudioCapture();
1759 screenCaptureServer_->StartFileMicAudioCapture();
1760 const int bufferSize = 10;
1761 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1762 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1763 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1764 SOURCE_DEFAULT);
1765 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1766 SOURCE_DEFAULT);
1767 micAudioBuffer->timestamp = 1;
1768 innerAudioBuffer->timestamp = 3000000000;
1769 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1770 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1771 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1772 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->HandleMicBeforeInnerSync(buffer,
1773 bufferSize, innerAudioBuffer, micAudioBuffer);
1774 MEDIA_LOGI("HandleMicBeforeInnerSync_001 ret: %{public}d", static_cast<int32_t>(ret));
1775 ASSERT_NE(ret, AudioDataSourceReadAtActionState::OK);
1776 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1777 }
1778
1779 HWTEST_F(ScreenCaptureServerFunctionTest, HandleMicBeforeInnerSync_002, TestSize.Level2)
1780 {
1781 RecorderInfo recorderInfo;
1782 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1783 SetValidConfigFile(recorderInfo);
1784 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1785 screenCaptureServer_->SetMicrophoneEnabled(true);
1786 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1787 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1788 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1789 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1790 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1791 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1792 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1793 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1794 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1795 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1796 screenCaptureServer_->StartFileInnerAudioCapture();
1797 screenCaptureServer_->StartFileMicAudioCapture();
1798 const int bufferSize = 10;
1799 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1800 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1801 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1802 SOURCE_DEFAULT);
1803 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1804 SOURCE_DEFAULT);
1805 micAudioBuffer->timestamp = 1;
1806 innerAudioBuffer->timestamp = 3000000000;
1807 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1808 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1809 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1810 screenCaptureServer_->micAudioCapture_ = nullptr;
1811 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->HandleMicBeforeInnerSync(buffer,
1812 bufferSize, innerAudioBuffer, micAudioBuffer);
1813 MEDIA_LOGI("HandleMicBeforeInnerSync_002 ret: %{public}d", static_cast<int32_t>(ret));
1814 ASSERT_NE(ret, AudioDataSourceReadAtActionState::OK);
1815 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1816 }
1817
1818 HWTEST_F(ScreenCaptureServerFunctionTest, HandleMicBeforeInnerSync_003, TestSize.Level2)
1819 {
1820 RecorderInfo recorderInfo;
1821 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1822 SetValidConfigFile(recorderInfo);
1823 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1824 screenCaptureServer_->SetMicrophoneEnabled(true);
1825 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1826 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1827 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1828 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1829 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1830 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1831 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1832 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1833 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1834 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1835 screenCaptureServer_->StartFileInnerAudioCapture();
1836 screenCaptureServer_->StartFileMicAudioCapture();
1837 const int bufferSize = 10;
1838 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1839 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1840 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1841 SOURCE_DEFAULT);
1842 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1843 SOURCE_DEFAULT);
1844 micAudioBuffer->timestamp = 2;
1845 innerAudioBuffer->timestamp = 3;
1846 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1847 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1848 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1849 uint8_t data[bufferSize];
1850 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1851 buffer->memory_ = bufferMem;
1852 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->HandleMicBeforeInnerSync(buffer,
1853 bufferSize, innerAudioBuffer, micAudioBuffer);
1854 MEDIA_LOGI("HandleMicBeforeInnerSync_003 ret: %{public}d", static_cast<int32_t>(ret));
1855 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1856 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1857 }
1858
1859 HWTEST_F(ScreenCaptureServerFunctionTest, VideoAudioSyncMixMode_001, TestSize.Level2)
1860 {
1861 RecorderInfo recorderInfo;
1862 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1863 SetValidConfigFile(recorderInfo);
1864 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1865 screenCaptureServer_->SetMicrophoneEnabled(true);
1866 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1867 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1868 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1869 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1870 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo.state =
1871 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1872 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1873 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1874 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1875 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::MIX_MODE;
1876 screenCaptureServer_->StartFileInnerAudioCapture();
1877 screenCaptureServer_->StartFileMicAudioCapture();
1878 const int bufferSize = 10;
1879 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1880 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1881 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1882 SOURCE_DEFAULT);
1883 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1884 SOURCE_DEFAULT);
1885 SetSCMicAudioCaptureAndPushData(micAudioBuffer);
1886 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1887 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1888 uint8_t data[bufferSize];
1889 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1890 buffer->memory_ = bufferMem;
1891 int64_t timeWindow = -31333334;
1892 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->VideoAudioSyncMixMode(buffer,
1893 bufferSize, timeWindow, innerAudioBuffer, micAudioBuffer);
1894 MEDIA_LOGI("VideoAudioSyncMixMode_001 ret: %{public}d", static_cast<int32_t>(ret));
1895 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::SKIP_WITHOUT_LOG);
1896 timeWindow = 31333334;
1897 ret = screenCaptureServer_->audioSource_->VideoAudioSyncMixMode(buffer,
1898 bufferSize, timeWindow, innerAudioBuffer, micAudioBuffer);
1899 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::SKIP_WITHOUT_LOG);
1900 timeWindow = 1;
1901 ret = screenCaptureServer_->audioSource_->VideoAudioSyncMixMode(buffer,
1902 bufferSize, timeWindow, innerAudioBuffer, micAudioBuffer);
1903 MEDIA_LOGI("VideoAudioSyncMixMode_001 ret: %{public}d", static_cast<int32_t>(ret));
1904 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1905 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1906 }
1907
1908 HWTEST_F(ScreenCaptureServerFunctionTest, VideoAudioSyncInnerMode_001, TestSize.Level2)
1909 {
1910 RecorderInfo recorderInfo;
1911 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1912 SetValidConfigFile(recorderInfo);
1913 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1914 screenCaptureServer_->SetMicrophoneEnabled(false);
1915 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1916 AVScreenCaptureMixMode::INNER_MODE, screenCaptureServer_.get());
1917 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1918 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1919 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1920 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1921 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1922 screenCaptureServer_->recorderFileAudioType_ = AVScreenCaptureMixMode::INNER_MODE;
1923 screenCaptureServer_->StartFileInnerAudioCapture();
1924 const int bufferSize = 10;
1925 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1926 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1927 SOURCE_DEFAULT);
1928 SetSCInnerAudioCaptureAndPushData(innerAudioBuffer);
1929 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer();
1930 uint8_t data[bufferSize];
1931 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1932 buffer->memory_ = bufferMem;
1933 int64_t timeWindow = -31333334;
1934 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->VideoAudioSyncInnerMode(buffer,
1935 bufferSize, timeWindow, innerAudioBuffer);
1936 MEDIA_LOGI("VideoAudioSyncInnerMode_001 ret: %{public}d", static_cast<int32_t>(ret));
1937 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::SKIP_WITHOUT_LOG);
1938 timeWindow = 31333334;
1939 ret = screenCaptureServer_->audioSource_->VideoAudioSyncInnerMode(buffer,
1940 bufferSize, timeWindow, innerAudioBuffer);
1941 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::SKIP_WITHOUT_LOG);
1942 timeWindow = 1;
1943 ret = screenCaptureServer_->audioSource_->VideoAudioSyncInnerMode(buffer,
1944 bufferSize, timeWindow, innerAudioBuffer);
1945 MEDIA_LOGI("VideoAudioSyncInnerMode_001 ret: %{public}d", static_cast<int32_t>(ret));
1946 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1947 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1948 }
1949
1950 HWTEST_F(ScreenCaptureServerFunctionTest, MixModeBufferWrite_001, TestSize.Level2)
1951 {
1952 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1953 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1954 const int bufferSize = 10;
1955 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1956 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1957 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1958 SOURCE_DEFAULT);
1959 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1960 SOURCE_DEFAULT);
1961 uint8_t data[bufferSize];
1962 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1963 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->MixModeBufferWrite(
1964 innerAudioBuffer, micAudioBuffer, bufferMem);
1965 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1966 }
1967
1968 HWTEST_F(ScreenCaptureServerFunctionTest, MixModeBufferWrite_002, TestSize.Level2)
1969 {
1970 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1971 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1972 const int bufferSize = 10;
1973 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1974 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1975 SOURCE_DEFAULT);
1976 std::shared_ptr<AudioBuffer> micAudioBuffer;
1977 uint8_t data[bufferSize];
1978 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1979 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->MixModeBufferWrite(innerAudioBuffer,
1980 micAudioBuffer, bufferMem);
1981 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1982 }
1983
1984 HWTEST_F(ScreenCaptureServerFunctionTest, MixModeBufferWrite_003, TestSize.Level2)
1985 {
1986 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1987 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1988 const int bufferSize = 10;
1989 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1990 std::shared_ptr<AudioBuffer> innerAudioBuffer;
1991 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1992 SOURCE_DEFAULT);
1993 uint8_t data[bufferSize];
1994 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1995 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->MixModeBufferWrite(innerAudioBuffer,
1996 micAudioBuffer, bufferMem);
1997 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::OK);
1998 }
1999
2000 HWTEST_F(ScreenCaptureServerFunctionTest, MixModeBufferWrite_004, TestSize.Level2)
2001 {
2002 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
2003 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
2004 const int bufferSize = 10;
2005 std::shared_ptr<AudioBuffer> innerAudioBuffer;
2006 std::shared_ptr<AudioBuffer> micAudioBuffer;
2007 uint8_t data[bufferSize];
2008 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
2009 AudioDataSourceReadAtActionState ret = screenCaptureServer_->audioSource_->MixModeBufferWrite(innerAudioBuffer,
2010 micAudioBuffer, bufferMem);
2011 ASSERT_EQ(ret, AudioDataSourceReadAtActionState::RETRY_SKIP);
2012 }
2013
2014 HWTEST_F(ScreenCaptureServerFunctionTest, GetChoiceFromJson_001, TestSize.Level2)
2015 {
2016 Json::Value root;
2017 std::string content = "ghgh%^&%^$*^(}{^af&**)";
2018 std::string value;
2019 screenCaptureServer_->GetChoiceFromJson(root, content, "choice", value);
2020 ASSERT_NE(screenCaptureServer_, nullptr);
2021 }
2022
2023 HWTEST_F(ScreenCaptureServerFunctionTest, GetChoiceFromJson_002, TestSize.Level2)
2024 {
2025 Json::Value root;
2026 std::string content = "{\"choice\": \"true\"}";
2027 std::string value;
2028 screenCaptureServer_->GetChoiceFromJson(root, content, "choice", value);
2029 ASSERT_NE(screenCaptureServer_, nullptr);
2030 }
2031
2032 HWTEST_F(ScreenCaptureServerFunctionTest, StartFileInnerAudioCapture_001, TestSize.Level2)
2033 {
2034 RecorderInfo recorderInfo;
2035 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
2036 SetValidConfigFile(recorderInfo);
2037 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
2038 screenCaptureServer_->SetMicrophoneEnabled(true);
2039 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
2040 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
2041 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
2042 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
2043 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
2044 AVScreenCaptureParamValidationState::VALIDATION_VALID;
2045 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
2046 screenCaptureServer_->StartFileInnerAudioCapture();
2047 screenCaptureServer_->StartFileMicAudioCapture();
2048 sleep(RECORDER_TIME / 2);
2049 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2050 }
2051
2052 HWTEST_F(ScreenCaptureServerFunctionTest, StartFileInnerAudioCapture_002, TestSize.Level2)
2053 {
2054 RecorderInfo recorderInfo;
2055 SetRecorderInfo("start_file_inner_audio_capture_002.mp4", recorderInfo);
2056 SetValidConfigFile(recorderInfo);
2057 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
2058 screenCaptureServer_->SetMicrophoneEnabled(true);
2059 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
2060 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
2061 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
2062 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
2063 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
2064 AVScreenCaptureParamValidationState::VALIDATION_VALID;
2065 screenCaptureServer_->audioSource_->isInVoIPCall_ = true;
2066 screenCaptureServer_->StartFileInnerAudioCapture();
2067 screenCaptureServer_->StartFileMicAudioCapture();
2068 sleep(RECORDER_TIME / 2);
2069 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2070 }
2071
2072 #ifdef SUPPORT_CALL
2073 HWTEST_F(ScreenCaptureServerFunctionTest, StopAndRelease_001, TestSize.Level2)
2074 {
2075 ScreenCaptureObserverCallBack* obcb = new ScreenCaptureObserverCallBack(screenCaptureServer_);
2076 if (obcb) {
2077 ASSERT_EQ(obcb->StopAndRelease(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER), true);
2078 }
2079 }
2080
2081 HWTEST_F(ScreenCaptureServerFunctionTest, StopAndRelease_002, TestSize.Level2)
2082 {
2083 ScreenCaptureObserverCallBack* obcb = new ScreenCaptureObserverCallBack(screenCaptureServer_);
2084 if (obcb) {
2085 screenCaptureServer_->Release();
2086 screenCaptureServer_ = nullptr;
2087 ASSERT_EQ(obcb->StopAndRelease(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER), true);
2088 }
2089 }
2090
2091 HWTEST_F(ScreenCaptureServerFunctionTest, TelCallStateUpdated_001, TestSize.Level2)
2092 {
2093 ScreenCaptureObserverCallBack* obcb = new ScreenCaptureObserverCallBack(screenCaptureServer_);
2094 if (obcb) {
2095 ASSERT_EQ(obcb->TelCallStateUpdated(false), true);
2096 }
2097 }
2098
2099 HWTEST_F(ScreenCaptureServerFunctionTest, TelCallStateUpdated_002, TestSize.Level2)
2100 {
2101 screenCaptureServer_->appName_ = HiviewCareBundleName;
2102 ScreenCaptureObserverCallBack* obcb = new ScreenCaptureObserverCallBack(screenCaptureServer_);
2103 if (obcb) {
2104 ASSERT_EQ(obcb->TelCallStateUpdated(false), true);
2105 }
2106 }
2107
2108 HWTEST_F(ScreenCaptureServerFunctionTest, TelCallStateUpdated_003, TestSize.Level2)
2109 {
2110 ScreenCaptureObserverCallBack* obcb = new ScreenCaptureObserverCallBack(screenCaptureServer_);
2111 if (obcb) {
2112 screenCaptureServer_->Release();
2113 screenCaptureServer_ = nullptr;
2114 ASSERT_EQ(obcb->TelCallStateUpdated(false), true);
2115 }
2116 }
2117
2118 /**
2119 * @tc.name: OnTelCallStateChanged_001
2120 * @tc.desc: in call with tel skip
2121 * @tc.type: FUNC
2122 */
2123 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_001, TestSize.Level2)
2124 {
2125 RecorderInfo recorderInfo;
2126 SetRecorderInfo("screen_capture_tel_001.mp4", recorderInfo);
2127 SetValidConfigFile(recorderInfo);
2128 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
2129 screenCaptureServer_->SetMicrophoneEnabled(true);
2130 ASSERT_EQ(StartFileAudioCapture(AVScreenCaptureMixMode::MIX_MODE), MSERR_OK);
2131 screenCaptureServer_->appName_ = HiviewCareBundleName;
2132 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
2133 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
2134 sleep(RECORDER_TIME);
2135 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2136 }
2137
2138 /**
2139 * @tc.name: OnTelCallStateChanged_002
2140 * @tc.desc: in call and out call with mic on, CAPTURE_FILE
2141 * @tc.type: FUNC
2142 */
2143 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_002, TestSize.Level2)
2144 {
2145 RecorderInfo recorderInfo;
2146 SetRecorderInfo("screen_capture_tel_002.mp4", recorderInfo);
2147 SetValidConfigFile(recorderInfo);
2148 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
2149 screenCaptureServer_->SetMicrophoneEnabled(true);
2150 ASSERT_EQ(StartFileAudioCapture(AVScreenCaptureMixMode::MIX_MODE), MSERR_OK);
2151 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
2152 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
2153 sleep(RECORDER_TIME);
2154 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
2155 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
2156 sleep(RECORDER_TIME);
2157 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2158 }
2159
2160 /**
2161 * @tc.name: OnTelCallStateChanged_003
2162 * @tc.desc: in call and out call with mic off, CAPTURE_FILE
2163 * @tc.type: FUNC
2164 */
2165 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_003, TestSize.Level2)
2166 {
2167 RecorderInfo recorderInfo;
2168 SetRecorderInfo("screen_capture_tel_003.mp4", recorderInfo);
2169 SetValidConfigFile(recorderInfo);
2170 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
2171 screenCaptureServer_->SetMicrophoneEnabled(false);
2172 ASSERT_EQ(StartFileAudioCapture(AVScreenCaptureMixMode::MIX_MODE), MSERR_OK);
2173 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
2174 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
2175 sleep(RECORDER_TIME);
2176 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
2177 // stop call and microphone not on
2178 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
2179 sleep(RECORDER_TIME);
2180 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2181 }
2182
2183 /**
2184 * @tc.name: OnTelCallStateChanged_004
2185 * @tc.desc: in call and out call with mic on, ORIGINAL_STREAM
2186 * @tc.type: FUNC
2187 */
2188 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_004, TestSize.Level2)
2189 {
2190 SetValidConfig();
2191 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
2192 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
2193 sleep(RECORDER_TIME);
2194 screenCaptureServer_->SetMicrophoneEnabled(true);
2195 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
2196 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
2197 sleep(RECORDER_TIME);
2198 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
2199 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
2200 sleep(RECORDER_TIME);
2201 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2202 }
2203
2204 /**
2205 * @tc.name: OnTelCallStateChanged_005
2206 * @tc.desc: out call and out call with mic on, ORIGINAL_STREAM (invalid state)
2207 * @tc.type: FUNC
2208 */
2209 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_005, TestSize.Level2)
2210 {
2211 SetValidConfig();
2212 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
2213 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
2214 sleep(RECORDER_TIME);
2215 screenCaptureServer_->SetMicrophoneEnabled(true);
2216 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
2217 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
2218 sleep(RECORDER_TIME);
2219 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
2220 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
2221 sleep(RECORDER_TIME);
2222 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2223 }
2224
2225 /**
2226 * @tc.name: OnTelCallStateChanged_006
2227 * @tc.desc: in call and in call with mic on, ORIGINAL_STREAM (invalid state)
2228 * @tc.type: FUNC
2229 */
2230 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_006, TestSize.Level2)
2231 {
2232 SetValidConfig();
2233 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
2234 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
2235 sleep(RECORDER_TIME);
2236 screenCaptureServer_->SetMicrophoneEnabled(true);
2237 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
2238 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
2239 sleep(RECORDER_TIME);
2240 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
2241 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
2242 sleep(RECORDER_TIME);
2243 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
2244 }
2245 #endif
2246
2247 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursor_001, TestSize.Level2)
2248 {
2249 screenCaptureServer_->showCursor_ = true;
2250 int ret = screenCaptureServer_->ShowCursor(true);
2251 ASSERT_EQ(ret, MSERR_OK);
2252 }
2253
2254 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursor_002, TestSize.Level2)
2255 {
2256 screenCaptureServer_->showCursor_ = false;
2257 int ret = screenCaptureServer_->ShowCursor(true);
2258 ASSERT_EQ(ret, MSERR_OK);
2259 }
2260
2261 HWTEST_F(ScreenCaptureServerFunctionTest, PostStartScreenCaptureSuccessAction_001, TestSize.Level2)
2262 {
2263 screenCaptureServer_->showCursor_ = false;
2264 screenCaptureServer_->PostStartScreenCaptureSuccessAction();
2265 ASSERT_EQ(screenCaptureServer_->showCursor_ == false, true);
2266 }
2267
2268 HWTEST_F(ScreenCaptureServerFunctionTest, PostStartScreenCaptureSuccessAction_002, TestSize.Level2)
2269 {
2270 screenCaptureServer_->showCursor_ = true;
2271 screenCaptureServer_->PostStartScreenCaptureSuccessAction();
2272 ASSERT_EQ(screenCaptureServer_->showCursor_ == true, true);
2273 }
2274
2275 HWTEST_F(ScreenCaptureServerFunctionTest, SetCanvasRotation_001, TestSize.Level2)
2276 {
2277 int ret = screenCaptureServer_->SetCanvasRotation(true);
2278 ASSERT_EQ(ret, MSERR_OK);
2279 }
2280
2281 HWTEST_F(ScreenCaptureServerFunctionTest, SetCanvasRotation_002, TestSize.Level2)
2282 {
2283 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
2284 int ret = screenCaptureServer_->SetCanvasRotation(true);
2285 ASSERT_EQ(ret, MSERR_OK);
2286 }
2287
2288 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_001, TestSize.Level2)
2289 {
2290 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
2291 screenCaptureServer_->virtualScreenId_ = 0;
2292 int ret = screenCaptureServer_->ResizeCanvas(580, 1280);
2293 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
2294 }
2295
2296 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_002, TestSize.Level2)
2297 {
2298 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2299 int ret = screenCaptureServer_->ResizeCanvas(580, 1280);
2300 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
2301 }
2302
2303 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_003, TestSize.Level2)
2304 {
2305 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2306 int ret = screenCaptureServer_->ResizeCanvas(-580, 1280);
2307 ASSERT_EQ(ret, MSERR_INVALID_VAL);
2308 }
2309
2310 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_004, TestSize.Level2)
2311 {
2312 screenCaptureServer_->virtualScreenId_ = 0;
2313 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2314 int ret = screenCaptureServer_->ResizeCanvas(10241, 1280);
2315 ASSERT_EQ(ret, MSERR_INVALID_VAL);
2316 }
2317
2318 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_005, TestSize.Level2)
2319 {
2320 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2321 int ret = screenCaptureServer_->ResizeCanvas(580, -1280);
2322 ASSERT_EQ(ret, MSERR_INVALID_VAL);
2323 }
2324
2325 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_006, TestSize.Level2)
2326 {
2327 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2328 screenCaptureServer_->virtualScreenId_ = SCREEN_ID_INVALID;
2329 screenCaptureServer_->captureConfig_.dataType = DataType::ORIGINAL_STREAM;
2330 screenCaptureServer_->ResizeCanvas(580, 1280);
2331 screenCaptureServer_->virtualScreenId_ = 0;
2332 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2333 screenCaptureServer_->captureConfig_.dataType = DataType::INVAILD;
2334 int ret = screenCaptureServer_->ResizeCanvas(580, 4321);
2335 ASSERT_EQ(ret, MSERR_INVALID_VAL);
2336 }
2337
2338 HWTEST_F(ScreenCaptureServerFunctionTest, UpdateSurface_001, TestSize.Level2)
2339 {
2340 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
2341 int ret = screenCaptureServer_->UpdateSurface(nullptr);
2342 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
2343 }
2344
2345 HWTEST_F(ScreenCaptureServerFunctionTest, UpdateSurface_002, TestSize.Level2)
2346 {
2347 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
2348 screenCaptureServer_->isSurfaceMode_ = true;
2349 int ret = screenCaptureServer_->UpdateSurface(nullptr);
2350 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
2351 }
2352
2353 HWTEST_F(ScreenCaptureServerFunctionTest, UpdateSurface_003, TestSize.Level2)
2354 {
2355 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2356 screenCaptureServer_->isSurfaceMode_ = true;
2357 int ret = screenCaptureServer_->UpdateSurface(nullptr);
2358 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
2359 }
2360
2361 HWTEST_F(ScreenCaptureServerFunctionTest, StopScreenCaptureByEvent_002, TestSize.Level2)
2362 {
2363 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2364 int ret = screenCaptureServer_->StopScreenCaptureByEvent(AVScreenCaptureStateCode::
2365 SCREEN_CAPTURE_STATE_STOPPED_BY_USER);
2366 ASSERT_EQ(ret, MSERR_OK);
2367 }
2368
2369 HWTEST_F(ScreenCaptureServerFunctionTest, StopScreenCaptureByEvent_003, TestSize.Level2)
2370 {
2371 screenCaptureServer_->captureState_ = AVScreenCaptureState::STOPPED;
2372 int ret = screenCaptureServer_->StopScreenCaptureByEvent(AVScreenCaptureStateCode::
2373 SCREEN_CAPTURE_STATE_STOPPED_BY_USER);
2374 ASSERT_EQ(ret, MSERR_OK);
2375 }
2376
2377 HWTEST_F(ScreenCaptureServerFunctionTest, SkipPrivacyMode_001, TestSize.Level2)
2378 {
2379 std::vector<uint64_t> windowIDsVec;
2380 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
2381 int ret = screenCaptureServer_->SkipPrivacyMode(windowIDsVec);
2382 ASSERT_EQ(ret, MSERR_OK);
2383 }
2384
2385 HWTEST_F(ScreenCaptureServerFunctionTest, SetMaxVideoFrameRate_001, TestSize.Level2)
2386 {
2387 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2388 int ret = screenCaptureServer_->SetMaxVideoFrameRate(-1);
2389 ASSERT_EQ(ret, MSERR_INVALID_VAL);
2390 }
2391
2392 HWTEST_F(ScreenCaptureServerFunctionTest, SetMaxVideoFrameRate_002, TestSize.Level2)
2393 {
2394 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2395 screenCaptureServer_->SetMaxVideoFrameRate(5);
2396 screenCaptureServer_->virtualScreenId_ = 0;
2397 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
2398 int ret = screenCaptureServer_->SetMaxVideoFrameRate(5);
2399 ASSERT_NE(ret, MSERR_OK);
2400 }
2401
2402 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneOn_001, TestSize.Level2)
2403 {
2404 screenCaptureServer_->captureConfig_.dataType = DataType::ORIGINAL_STREAM;
2405 int ret = screenCaptureServer_->SetMicrophoneOn();
2406 ASSERT_EQ(ret, MSERR_OK);
2407 }
2408
2409 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneOn_002, TestSize.Level2)
2410 {
2411 screenCaptureServer_->captureConfig_.dataType = DataType::CAPTURE_FILE;
2412 int ret = screenCaptureServer_->SetMicrophoneOn();
2413 ASSERT_EQ(ret, MSERR_OK);
2414 }
2415
2416 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneOff_001, TestSize.Level2)
2417 {
2418 int ret = screenCaptureServer_->SetMicrophoneOff();
2419 ASSERT_EQ(ret, MSERR_OK);
2420 }
2421
2422 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneEnabled_001, TestSize.Level2)
2423 {
2424 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2425 int ret = screenCaptureServer_->SetMicrophoneEnabled(true);
2426 ASSERT_EQ(ret, MSERR_OK);
2427 }
2428
2429 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneEnabled_002, TestSize.Level2)
2430 {
2431 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2432 int ret = screenCaptureServer_->SetMicrophoneEnabled(false);
2433 ASSERT_EQ(ret, MSERR_OK);
2434 }
2435
2436 HWTEST_F(ScreenCaptureServerFunctionTest, SetSystemScreenRecorderStatus_001, TestSize.Level2)
2437 {
2438 screenCaptureServer_->appName_ =
2439 GetScreenCaptureSystemParam()["const.multimedia.screencapture.dialogconnectionbundlename"];
2440 screenCaptureServer_->SetSystemScreenRecorderStatus(false);
2441 ASSERT_EQ(ScreenCaptureServer::systemScreenRecorderPid_, -1);
2442 }
2443
2444 HWTEST_F(ScreenCaptureServerFunctionTest, SetSystemScreenRecorderStatus_002, TestSize.Level2)
2445 {
2446 screenCaptureServer_->appName_ =
2447 GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"];
2448 screenCaptureServer_->appInfo_.appPid = 15000;
2449 screenCaptureServer_->SetSystemScreenRecorderStatus(true);
2450 ASSERT_EQ(ScreenCaptureServer::systemScreenRecorderPid_, 15000);
2451 }
2452
2453 HWTEST_F(ScreenCaptureServerFunctionTest, SetSystemScreenRecorderStatus_003, TestSize.Level2)
2454 {
2455 ScreenCaptureServer::systemScreenRecorderPid_ = -1;
2456 screenCaptureServer_->appName_ =
2457 GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"];
2458 screenCaptureServer_->appInfo_.appPid = 15000;
2459 screenCaptureServer_->SetSystemScreenRecorderStatus(false);
2460 ASSERT_EQ(ScreenCaptureServer::systemScreenRecorderPid_, -1);
2461 }
2462
2463 HWTEST_F(ScreenCaptureServerFunctionTest, IsSystemScreenRecorder_001, TestSize.Level2)
2464 {
2465 ScreenCaptureServer::systemScreenRecorderPid_ = -1;
2466 bool ret = ScreenCaptureMonitor::GetInstance()->IsSystemScreenRecorder(15000);
2467 ASSERT_EQ(ret, false);
2468 }
2469
2470 HWTEST_F(ScreenCaptureServerFunctionTest, IsSystemScreenRecorder_002, TestSize.Level2)
2471 {
2472 screenCaptureServer_->SetSystemScreenRecorderStatus(false);
2473 ScreenCaptureMonitor::GetInstance()->IsSystemScreenRecorderWorking();
2474 ScreenCaptureServer::systemScreenRecorderPid_ = -1;
2475 bool ret = ScreenCaptureMonitor::GetInstance()->IsSystemScreenRecorder(-1);
2476 ASSERT_EQ(ret, false);
2477 }
2478
2479 HWTEST_F(ScreenCaptureServerFunctionTest, StartStreamHomeVideoCapture_001, TestSize.Level2)
2480 {
2481 SetValidConfig();
2482 screenCaptureServer_->isSurfaceMode_ = false;
2483 ASSERT_EQ(screenCaptureServer_->StartStreamHomeVideoCapture(), MSERR_OK);
2484 }
2485
2486 HWTEST_F(ScreenCaptureServerFunctionTest, CheckDataType_001, TestSize.Level2)
2487 {
2488 ASSERT_NE(screenCaptureServer_->CheckDataType(DataType::ENCODED_STREAM), MSERR_OK);
2489 }
2490
2491 HWTEST_F(ScreenCaptureServerFunctionTest, CheckAudioCapParam_001, TestSize.Level2)
2492 {
2493 AudioCaptureInfo micCapinfo = {
2494 .audioSampleRate = 16000,
2495 .audioChannels = 2,
2496 .audioSource = AudioCaptureSourceType::SOURCE_INVALID
2497 };
2498 ASSERT_NE(screenCaptureServer_->CheckAudioCapParam(micCapinfo), MSERR_OK);
2499 }
2500
2501 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoCapParam_001, TestSize.Level2)
2502 {
2503 VideoCaptureInfo videoCapInfo_1 = {
2504 .videoFrameWidth = -1,
2505 .videoFrameHeight = 1080,
2506 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
2507 };
2508 ASSERT_NE(screenCaptureServer_->CheckVideoCapParam(videoCapInfo_1), MSERR_OK);
2509 VideoCaptureInfo videoCapInfo_2 = {
2510 .videoFrameWidth = 720,
2511 .videoFrameHeight = -1,
2512 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
2513 };
2514 ASSERT_NE(screenCaptureServer_->CheckVideoCapParam(videoCapInfo_2), MSERR_OK);
2515 VideoCaptureInfo videoCapInfo_3 = {
2516 .videoFrameWidth = screenCaptureServer_->VIDEO_FRAME_WIDTH_MAX + 1,
2517 .videoFrameHeight = 1080,
2518 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
2519 };
2520 ASSERT_NE(screenCaptureServer_->CheckVideoCapParam(videoCapInfo_3), MSERR_OK);
2521 VideoCaptureInfo videoCapInfo_4 = {
2522 .videoFrameWidth = 720,
2523 .videoFrameHeight = screenCaptureServer_->VIDEO_FRAME_HEIGHT_MAX + 1,
2524 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
2525 };
2526 ASSERT_NE(screenCaptureServer_->CheckVideoCapParam(videoCapInfo_4), MSERR_OK);
2527 VideoCaptureInfo videoCapInfo_5 = {
2528 .videoFrameWidth = 720,
2529 .videoFrameHeight = 1080,
2530 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_YUV
2531 };
2532 ASSERT_NE(screenCaptureServer_->CheckVideoCapParam(videoCapInfo_5), MSERR_OK);
2533 }
2534
2535 HWTEST_F(ScreenCaptureServerFunctionTest, CheckAudioEncParam_001, TestSize.Level2)
2536 {
2537 AudioEncInfo audioEncInfo_1 = {
2538 .audioBitrate = 48000,
2539 .audioCodecformat = AudioCodecFormat::AUDIO_CODEC_FORMAT_BUTT
2540 };
2541 ASSERT_NE(screenCaptureServer_->CheckAudioEncParam(audioEncInfo_1), MSERR_OK);
2542 AudioEncInfo audioEncInfo_2 = {
2543 .audioBitrate = screenCaptureServer_->AUDIO_BITRATE_MIN - 1,
2544 .audioCodecformat = AudioCodecFormat::AUDIO_DEFAULT
2545 };
2546 ASSERT_NE(screenCaptureServer_->CheckAudioEncParam(audioEncInfo_2), MSERR_OK);
2547 AudioEncInfo audioEncInfo_3 = {
2548 .audioBitrate = screenCaptureServer_->AUDIO_BITRATE_MAX + 1,
2549 .audioCodecformat = AudioCodecFormat::AUDIO_DEFAULT
2550 };
2551 ASSERT_NE(screenCaptureServer_->CheckAudioEncParam(audioEncInfo_3), MSERR_OK);
2552 AudioEncInfo audioEncInfo_4 = {
2553 .audioBitrate = screenCaptureServer_->AUDIO_BITRATE_MAX + 1,
2554 .audioCodecformat = static_cast<AudioCodecFormat>(AudioCodecFormat::AUDIO_DEFAULT - 1)
2555 };
2556 ASSERT_NE(screenCaptureServer_->CheckAudioEncParam(audioEncInfo_4), MSERR_OK);
2557 }
2558
2559 HWTEST_F(ScreenCaptureServerFunctionTest, RefreshResConfig_001, TestSize.Level2)
2560 {
2561 screenCaptureServer_->RefreshResConfig();
2562 screenCaptureServer_->resConfig_ = Global::Resource::CreateResConfig();
2563 screenCaptureServer_->RefreshResConfig();
2564 ASSERT_NE(screenCaptureServer_->resConfig_, nullptr);
2565 }
2566
2567 HWTEST_F(ScreenCaptureServerFunctionTest, StopAudioCapture_001, TestSize.Level2)
2568 {
2569 ASSERT_EQ(screenCaptureServer_->StopAudioCapture(), MSERR_OK);
2570 }
2571
2572 HWTEST_F(ScreenCaptureServerFunctionTest, ExcludeContent_001, TestSize.Level2)
2573 {
2574 ScreenCaptureContentFilter contentFilter;
2575 EXPECT_EQ(screenCaptureServer_->ExcludeContent(contentFilter), MSERR_OK);
2576 }
2577
2578 HWTEST_F(ScreenCaptureServerFunctionTest, StartMicAudioCapture_001, TestSize.Level2)
2579 {
2580 EXPECT_EQ(screenCaptureServer_->StartMicAudioCapture(), MSERR_OK);
2581 }
2582
2583 HWTEST_F(ScreenCaptureServerFunctionTest, StopInnerAudioCapture_001, TestSize.Level2)
2584 {
2585 EXPECT_EQ(screenCaptureServer_->StopInnerAudioCapture(), MSERR_OK);
2586 }
2587
2588 HWTEST_F(ScreenCaptureServerFunctionTest, StartAudioCapture_001, TestSize.Level2)
2589 {
2590 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
2591 AVScreenCaptureParamValidationState::VALIDATION_IGNORE;
2592 screenCaptureServer_->screenCaptureCb_ = nullptr;
2593 screenCaptureServer_->NotifyStateChange(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_MIC_UNAVAILABLE);
2594 screenCaptureServer_->NotifyDisplaySelected(0);
2595 EXPECT_EQ(screenCaptureServer_->StartStreamInnerAudioCapture(), MSERR_OK);
2596 EXPECT_EQ(screenCaptureServer_->StartFileInnerAudioCapture(), MSERR_OK);
2597 }
2598
2599 HWTEST_F(ScreenCaptureServerFunctionTest, SetCaptureArea_001, TestSize.Level2)
2600 {
2601 OHOS::Rect area;
2602 area.x = 0;
2603 area.y = 0;
2604 area.w = 5;
2605 area.h = 5;
2606 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2607 int32_t ret = screenCaptureServer_->SetCaptureArea(0, area);
2608 EXPECT_NE(ret, MSERR_OK);
2609 }
2610
2611 HWTEST_F(ScreenCaptureServerFunctionTest, SetCaptureArea_002, TestSize.Level2)
2612 {
2613 OHOS::Rect area;
2614 area.x = 0;
2615 area.y = 0;
2616 area.w = 5;
2617 area.h = 5;
2618 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
2619 int32_t ret = screenCaptureServer_->SetCaptureArea(0, area);
2620 EXPECT_EQ(ret, MSERR_OK);
2621 }
2622
2623 HWTEST_F(ScreenCaptureServerFunctionTest, SetCaptureArea_003, TestSize.Level2)
2624 {
2625 OHOS::Rect area;
2626 area.x = 2147483647;
2627 area.y = 2147483647;
2628 area.w = 720;
2629 area.h = 1280;
2630 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
2631 int32_t ret = screenCaptureServer_->SetCaptureArea(0, area);
2632 EXPECT_EQ(ret, MSERR_INVALID_VAL);
2633 }
2634
2635 HWTEST_F(ScreenCaptureServerFunctionTest, SetCaptureAreaInner_001, TestSize.Level2)
2636 {
2637 OHOS::Rect area;
2638 area.x = 0;
2639 area.y = 0;
2640 area.w = 5;
2641 area.h = 5;
2642 screenCaptureServer_->virtualScreenId_ = SCREEN_ID_INVALID;
2643 int32_t ret = screenCaptureServer_->SetCaptureAreaInner(0, area);
2644 EXPECT_NE(ret, MSERR_OK);
2645 }
2646
2647 HWTEST_F(ScreenCaptureServerFunctionTest, UserSelected_001, TestSize.Level2)
2648 {
2649 ScreenCaptureUserSelectionInfo selectionInfo;
2650 selectionInfo.selectType = 0;
2651 selectionInfo.displayId = 0;
2652 screenCaptureServer_->NotifyUserSelected(selectionInfo);
2653 screenCaptureServer_->displayScreenId_ = 0;
2654 screenCaptureServer_->captureConfig_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
2655 screenCaptureServer_->PostStartScreenCaptureSuccessAction();
2656 EXPECT_EQ(screenCaptureServer_->captureState_, AVScreenCaptureState::STARTED);
2657 }
2658
2659 HWTEST_F(ScreenCaptureServerFunctionTest, SetVirtualScreenAutoRotation_001, TestSize.Level2)
2660 {
2661 screenCaptureServer_->displayScreenId_ = 0;
2662 screenCaptureServer_->captureConfig_.dataType = DataType::CAPTURE_FILE;
2663 EXPECT_NE(screenCaptureServer_->SetVirtualScreenAutoRotation(), MSERR_OK);
2664 screenCaptureServer_->captureConfig_.dataType = DataType::ORIGINAL_STREAM;
2665 EXPECT_EQ(screenCaptureServer_->SetVirtualScreenAutoRotation(), MSERR_OK);
2666 }
2667
2668 HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_001, TestSize.Level2)
2669 {
2670 Json::Value root;
2671 std::string content = R"({"isEnable": "true"})";
2672 std::string key = "isEnable";
2673 bool value = false;
2674 screenCaptureServer_->GetValueFromJson(root, content, key, value);
2675 EXPECT_EQ(value, true);
2676 }
2677
2678 HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_002, TestSize.Level2)
2679 {
2680 Json::Value root;
2681 std::string content = R"({"isEnable": "true"})";
2682 std::string key = "Enable";
2683 bool value = true;
2684 screenCaptureServer_->GetValueFromJson(root, content, key, value);
2685 EXPECT_EQ(value, false);
2686 }
2687
2688 HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_003, TestSize.Level2)
2689 {
2690 Json::Value root;
2691 std::string content = "";
2692 std::string key = "Enable";
2693 bool value = true;
2694 screenCaptureServer_->GetValueFromJson(root, content, key, value);
2695 EXPECT_EQ(value, false);
2696 }
2697
2698 HWTEST_F(ScreenCaptureServerFunctionTest, GetValueFromJson_004, TestSize.Level2)
2699 {
2700 Json::Value root;
2701 std::string content = R"({"isEnable": "true"})";
2702 std::string key = "isEnable";
2703 bool value = false;
2704 screenCaptureServer_->GetValueFromJson(root, content, key, value);
2705 EXPECT_EQ(value, true);
2706 }
2707
2708 HWTEST_F(ScreenCaptureServerFunctionTest, SystemPrivacyProtected_001, TestSize.Level2)
2709 {
2710 ScreenId virtualScreenId = 1;
2711 bool systemPrivacyProtectionSwitch = true;
2712 screenCaptureServer_->SystemPrivacyProtected(virtualScreenId, systemPrivacyProtectionSwitch);
2713 EXPECT_EQ(screenCaptureServer_->captureState_, AVScreenCaptureState::CREATED);
2714 }
2715
2716 HWTEST_F(ScreenCaptureServerFunctionTest, GetLocalLiveViewContent_001, TestSize.Level2)
2717 {
2718 std::string callingLabel_ = "TestApp";
2719 screenCaptureServer_->callingLabel_ = callingLabel_;
2720 auto result = screenCaptureServer_->GetLocalLiveViewContent();
2721 std::string expectedTitle = "\"TestApp\" 正在使用屏幕";
2722 EXPECT_EQ(result->GetText(), expectedTitle);
2723 }
2724
2725 HWTEST_F(ScreenCaptureServerFunctionTest, GetLocalLiveViewContent_002, TestSize.Level2)
2726 {
2727 std::string callingLabel_ = "TestApp";
2728 screenCaptureServer_->callingLabel_ = callingLabel_;
2729 screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM);
2730 auto result = screenCaptureServer_->GetLocalLiveViewContent();
2731 std::string expectedTitle = "\"TestApp\" 正在使用屏幕";
2732 EXPECT_EQ(result->GetTitle(), expectedTitle);
2733 }
2734
2735 HWTEST_F(ScreenCaptureServerFunctionTest, GetLocalLiveViewContent_003, TestSize.Level2)
2736 {
2737 std::string callingLabel_ = "TestApp";
2738 screenCaptureServer_->callingLabel_ = callingLabel_;
2739 screenCaptureServer_->systemPrivacyProtectionSwitch_ = true;
2740 screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM);
2741 auto result = screenCaptureServer_->GetLocalLiveViewContent();
2742 std::string expectedTitle = "\"TestApp\" 正在使用屏幕";
2743 EXPECT_EQ(result->GetTitle(), expectedTitle);
2744 }
2745
2746 HWTEST_F(ScreenCaptureServerFunctionTest, GetLocalLiveViewContent_004, TestSize.Level2)
2747 {
2748 std::string callingLabel_ = "TestApp";
2749 screenCaptureServer_->callingLabel_ = callingLabel_;
2750 screenCaptureServer_->systemPrivacyProtectionSwitch_ = false;
2751 screenCaptureServer_->appPrivacyProtectionSwitch_ = false;
2752 screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM);
2753 auto result = screenCaptureServer_->GetLocalLiveViewContent();
2754 std::string expectedTitle = "\"TestApp\" 正在使用屏幕";
2755 EXPECT_EQ(result->GetTitle(), expectedTitle);
2756 }
2757
2758 HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_001, TestSize.Level2)
2759 {
2760 Json::Value root;
2761 std::string content = R"(
2762 {
2763 "stopRecording": "true",
2764 "appPrivacyProtectionSwitch": "true",
2765 "systemPrivacyProtectionSwitch": "true"
2766 }
2767 )";
2768 int32_t result = screenCaptureServer_->HandleStreamDataCase(root, content);
2769 EXPECT_EQ(result, MSERR_OK);
2770 }
2771
2772 HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_002, TestSize.Level2)
2773 {
2774 Json::Value root;
2775 std::string content = R"(
2776 {
2777 "stopRecording": "false",
2778 "appPrivacyProtectionSwitch": "true",
2779 "systemPrivacyProtectionSwitch": "true"
2780 }
2781 )";
2782 screenCaptureServer_->HandleStreamDataCase(root, content);
2783 EXPECT_EQ(screenCaptureServer_->systemPrivacyProtectionSwitch_, true);
2784 }
2785
2786 HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_003, TestSize.Level2)
2787 {
2788 Json::Value root;
2789 std::string content = R"(
2790 {
2791 "stopRecording": "false",
2792 "appPrivacyProtectionSwitch": "true",
2793 "systemPrivacyProtectionSwitch": "false"
2794 }
2795 )";
2796 screenCaptureServer_->HandleStreamDataCase(root, content);
2797 EXPECT_EQ(screenCaptureServer_->systemPrivacyProtectionSwitch_, false);
2798 }
2799
2800 HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_004, TestSize.Level2)
2801 {
2802 Json::Value root;
2803 std::string content = R"(
2804 {
2805 "stopRecording": "false",
2806 "appPrivacyProtectionSwitch": "false",
2807 "systemPrivacyProtectionSwitch": "true"
2808 }
2809 )";
2810 screenCaptureServer_->HandleStreamDataCase(root, content);
2811 EXPECT_EQ(screenCaptureServer_->systemPrivacyProtectionSwitch_, true);
2812 }
2813
2814 HWTEST_F(ScreenCaptureServerFunctionTest, HandleStreamDataCase_005, TestSize.Level2)
2815 {
2816 Json::Value root;
2817 std::string content = R"(
2818 {
2819 "stopRecording": "false",
2820 "appPrivacyProtectionSwitch": "false",
2821 "systemPrivacyProtectionSwitch": "false"
2822 }
2823 )";
2824 screenCaptureServer_->HandleStreamDataCase(root, content);
2825 EXPECT_EQ(screenCaptureServer_->systemPrivacyProtectionSwitch_, false);
2826 }
2827
2828 HWTEST_F(ScreenCaptureServerFunctionTest, UpdateMicrophoneEnabled_001, TestSize.Level2)
2829 {
2830 screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM);
2831 screenCaptureServer_->StartNotification();
2832 screenCaptureServer_->isSystemUI2_ = true;
2833 screenCaptureServer_->UpdateMicrophoneEnabled();
2834 EXPECT_EQ(screenCaptureServer_->isSystemUI2_, true);
2835 }
2836
2837 HWTEST_F(ScreenCaptureServerFunctionTest, UpdateMicrophoneEnabled_002, TestSize.Level2)
2838 {
2839 screenCaptureServer_->SetDataType(DataType::ORIGINAL_STREAM);
2840 screenCaptureServer_->StartNotification();
2841 screenCaptureServer_->isSystemUI2_ = false;
2842 screenCaptureServer_->UpdateMicrophoneEnabled();
2843 EXPECT_EQ(screenCaptureServer_->isSystemUI2_, false);
2844 }
2845
2846 HWTEST_F(ScreenCaptureServerFunctionTest, UpdateMicrophoneEnabled_003, TestSize.Level2)
2847 {
2848 screenCaptureServer_->SetDataType(DataType::CAPTURE_FILE);
2849 screenCaptureServer_->StartNotification();
2850 screenCaptureServer_->isSystemUI2_ = false;
2851 screenCaptureServer_->UpdateMicrophoneEnabled();
2852 EXPECT_EQ(screenCaptureServer_->isSystemUI2_, false);
2853 }
2854
2855 HWTEST_F(ScreenCaptureServerFunctionTest, HandleOriginalStreamPrivacy_001, TestSize.Level2)
2856 {
2857 screenCaptureServer_->captureConfig_.dataType = DataType::INVAILD;
2858 screenCaptureServer_->HandleOriginalStreamPrivacy();
2859 EXPECT_EQ(screenCaptureServer_->checkBoxSelected_, false);
2860 }
2861
2862 HWTEST_F(ScreenCaptureServerFunctionTest, HandleOriginalStreamPrivacy_002, TestSize.Level2)
2863 {
2864 screenCaptureServer_->captureConfig_.dataType = DataType::ORIGINAL_STREAM;
2865 screenCaptureServer_->checkBoxSelected_ = true;
2866 screenCaptureServer_->HandleOriginalStreamPrivacy();
2867 EXPECT_EQ(screenCaptureServer_->checkBoxSelected_, true);
2868 }
2869
2870 HWTEST_F(ScreenCaptureServerFunctionTest, HandleOriginalStreamPrivacy_003, TestSize.Level2)
2871 {
2872 screenCaptureServer_->captureConfig_.dataType = DataType::ORIGINAL_STREAM;
2873 screenCaptureServer_->checkBoxSelected_ = false;
2874 screenCaptureServer_->HandleOriginalStreamPrivacy();
2875 EXPECT_EQ(screenCaptureServer_->checkBoxSelected_, false);
2876 }
2877
2878 HWTEST_F(ScreenCaptureServerFunctionTest, RegisterLanguageSwitchListener_001, TestSize.Level2)
2879 {
2880 screenCaptureServer_->RegisterLanguageSwitchListener();
2881 screenCaptureServer_->UnRegisterLanguageSwitchListener();
2882 EXPECT_NE(screenCaptureServer_->subscriber_, nullptr);
2883 }
2884 } // Media
2885 } // OHOS