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
367 // videoCapInfo and innerCapInfo IGNORE
368 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_001, TestSize.Level2)
369 {
370 SetInvalidConfig();
371 config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
372 config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
373 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
374 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
375 }
376
377 // audioSampleRate INVALID
378 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_002, TestSize.Level2)
379 {
380 SetInvalidConfig();
381 config_.audioInfo.micCapInfo.audioSampleRate = 12345;
382 config_.audioInfo.micCapInfo.audioChannels = 2;
383 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
384 config_.audioInfo.innerCapInfo.audioSampleRate = 54321;
385 config_.audioInfo.innerCapInfo.audioChannels = 2;
386 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
387 ASSERT_NE(InitStreamScreenCaptureServer(), MSERR_OK);
388 }
389
390 // videoCapInfo INVALID
391 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_003, TestSize.Level2)
392 {
393 SetInvalidConfig();
394 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
395 config_.audioInfo.micCapInfo.audioChannels = 2;
396 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
397 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
398 config_.audioInfo.innerCapInfo.audioChannels = 2;
399 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
400 config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
401 config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
402 ASSERT_NE(InitStreamScreenCaptureServer(), MSERR_OK);
403 }
404
405 // dataType INVALID
406 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_004, TestSize.Level2)
407 {
408 SetInvalidConfig();
409 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
410 config_.audioInfo.micCapInfo.audioChannels = 2;
411 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
412 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
413 config_.audioInfo.innerCapInfo.audioChannels = 2;
414 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
415 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
416 screenCaptureServer_->captureConfig_.dataType = DataType::INVAILD;
417 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
418 }
419
420 // surface_ is nullptr
421 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_005, TestSize.Level2)
422 {
423 SetInvalidConfig();
424 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
425 config_.audioInfo.micCapInfo.audioChannels = 2;
426 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
427 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
428 config_.audioInfo.innerCapInfo.audioChannels = 2;
429 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
430 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
431 screenCaptureServer_->isSurfaceMode_ = true;
432 screenCaptureServer_->surface_ = nullptr;
433 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
434 }
435
436 // audioSampleRate INVALID
437 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureStreamParamsInvalid_006, TestSize.Level2)
438 {
439 SetInvalidConfig();
440 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
441 config_.audioInfo.micCapInfo.audioChannels = 2;
442 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
443 config_.audioInfo.innerCapInfo.audioSampleRate = 1;
444 config_.audioInfo.innerCapInfo.audioChannels = 2;
445 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
446 screenCaptureServer_->captureConfig_ = config_;
447 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
448 }
449
450 // videoFrameWidth and videoFrameHeight INVALID
451 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_001, TestSize.Level2)
452 {
453 RecorderInfo recorderInfo;
454 SetRecorderInfo("capture_file_params_invalid_001.mp4", recorderInfo);
455 SetInvalidConfigFile(recorderInfo);
456 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
457 config_.audioInfo.micCapInfo.audioChannels = 2;
458 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
459 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
460 config_.audioInfo.innerCapInfo.audioChannels = 2;
461 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
462 config_.videoInfo.videoCapInfo.videoFrameWidth = -1;
463 config_.videoInfo.videoCapInfo.videoFrameHeight = -1;
464 ASSERT_NE(InitFileScreenCaptureServer(), MSERR_OK);
465 }
466
467 // audioSampleRate INVALID
468 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_002, TestSize.Level2)
469 {
470 RecorderInfo recorderInfo;
471 SetRecorderInfo("capture_file_params_invalid_002.mp4", recorderInfo);
472 SetInvalidConfigFile(recorderInfo);
473 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
474 config_.audioInfo.micCapInfo.audioChannels = 2;
475 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
476 config_.audioInfo.innerCapInfo.audioSampleRate = 1;
477 config_.audioInfo.innerCapInfo.audioChannels = 2;
478 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
479 ASSERT_NE(InitFileScreenCaptureServer(), MSERR_OK);
480 }
481
482 // audioSampleRate and audioSampleRate are not equal
483 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_003, TestSize.Level2)
484 {
485 RecorderInfo recorderInfo;
486 SetRecorderInfo("capture_file_params_invalid_003.mp4", recorderInfo);
487 SetInvalidConfigFile(recorderInfo);
488 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
489 config_.audioInfo.micCapInfo.audioChannels = 2;
490 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
491 config_.audioInfo.innerCapInfo.audioSampleRate = 8000;
492 config_.audioInfo.innerCapInfo.audioChannels = 2;
493 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
494 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
495 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
496 }
497
498 // videoCapInfo Ignored, is valid
499 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_004, TestSize.Level2)
500 {
501 RecorderInfo recorderInfo;
502 SetRecorderInfo("capture_file_params_invalid_004.mp4", recorderInfo);
503 SetInvalidConfigFile(recorderInfo);
504 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
505 config_.audioInfo.micCapInfo.audioChannels = 2;
506 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
507 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
508 config_.audioInfo.innerCapInfo.audioChannels = 2;
509 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
510 config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
511 config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
512 screenCaptureServer_->captureConfig_ = config_;
513 ASSERT_EQ(screenCaptureServer_->CheckAllParams(), MSERR_OK);
514 }
515
516 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_005, TestSize.Level2)
517 {
518 RecorderInfo recorderInfo;
519 SetRecorderInfo("capture_file_params_invalid_005.mp4", recorderInfo);
520 SetInvalidConfigFile(recorderInfo);
521 config_.audioInfo.micCapInfo.audioSampleRate = -1;
522 config_.audioInfo.micCapInfo.audioChannels = 2;
523 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
524 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
525 config_.audioInfo.innerCapInfo.audioChannels = 2;
526 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
527 screenCaptureServer_->captureConfig_ = config_;
528 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
529 }
530
531 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_006, TestSize.Level2)
532 {
533 RecorderInfo recorderInfo;
534 SetRecorderInfo("capture_file_params_invalid_006.mp4", recorderInfo);
535 SetInvalidConfigFile(recorderInfo);
536 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
537 config_.audioInfo.micCapInfo.audioChannels = 2;
538 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
539 config_.audioInfo.innerCapInfo.audioSampleRate = -1;
540 config_.audioInfo.innerCapInfo.audioChannels = 2;
541 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
542 screenCaptureServer_->captureConfig_ = config_;
543 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
544 }
545
546 // micCapInfo Ignored, is valid
547 HWTEST_F(ScreenCaptureServerFunctionTest, CaptureFileParamsInvalid_007, TestSize.Level2)
548 {
549 RecorderInfo recorderInfo;
550 SetRecorderInfo("capture_file_params_invalid_007.mp4", recorderInfo);
551 SetInvalidConfigFile(recorderInfo);
552 config_.audioInfo.micCapInfo.audioSampleRate = 0;
553 config_.audioInfo.micCapInfo.audioChannels = 0;
554 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
555 config_.audioInfo.innerCapInfo.audioChannels = 2;
556 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
557 screenCaptureServer_->captureConfig_ = config_;
558 ASSERT_EQ(screenCaptureServer_->CheckAllParams(), MSERR_OK);
559 }
560
561 // audioChannels is different
562 HWTEST_F(ScreenCaptureServerFunctionTest, capture_file_params_invalid_008, TestSize.Level2)
563 {
564 RecorderInfo recorderInfo;
565 SetRecorderInfo("capture_file_params_invalid_008.mp4", recorderInfo);
566 SetInvalidConfigFile(recorderInfo);
567 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
568 config_.audioInfo.micCapInfo.audioChannels = 1;
569 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
570 config_.audioInfo.innerCapInfo.audioChannels = 2;
571 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
572 screenCaptureServer_->captureConfig_ = config_;
573 ASSERT_NE(screenCaptureServer_->CheckAllParams(), MSERR_OK);
574 }
575
576 HWTEST_F(ScreenCaptureServerFunctionTest, StartPrivacyWindow_001, TestSize.Level2)
577 {
578 ASSERT_NE(screenCaptureServer_->StartPrivacyWindow(), MSERR_OK);
579 }
580
581 HWTEST_F(ScreenCaptureServerFunctionTest, GetMissionIds_001, TestSize.Level2)
582 {
583 SetInvalidConfig();
584 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
585 config_.audioInfo.micCapInfo.audioChannels = 2;
586 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
587 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
588 config_.audioInfo.innerCapInfo.audioChannels = 2;
589 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
590 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
591 ASSERT_EQ(screenCaptureServer_->GetMissionIds(screenCaptureServer_->missionIds_), MSERR_OK);
592 }
593
594 HWTEST_F(ScreenCaptureServerFunctionTest, GetMissionIds_002, 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 screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.push_back(1);
605 screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.push_back(2);
606 ASSERT_EQ(screenCaptureServer_->GetMissionIds(screenCaptureServer_->missionIds_), MSERR_OK);
607 }
608
609 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_001, TestSize.Level2)
610 {
611 SetInvalidConfig();
612 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
613 config_.audioInfo.micCapInfo.audioChannels = 2;
614 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
615 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
616 config_.audioInfo.innerCapInfo.audioChannels = 2;
617 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
618 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
619 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
620 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
621 screenCaptureServer_->captureCallback_->OnRendererStateChange(audioRendererChangeInfos);
622 screenCaptureServer_->audioSource_->VoIPStateUpdate(audioRendererChangeInfos);
623 screenCaptureServer_->audioSource_->isInVoIPCall_ = true;
624 screenCaptureServer_->audioSource_->VoIPStateUpdate(audioRendererChangeInfos);
625 sleep(RECORDER_TIME);
626 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
627 }
628
629 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_002, TestSize.Level2)
630 {
631 SetInvalidConfig();
632 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
633 config_.audioInfo.micCapInfo.audioChannels = 2;
634 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
635 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
636 config_.audioInfo.innerCapInfo.audioChannels = 2;
637 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
638 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
639 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
640 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
641 screenCaptureServer_->audioSource_->SpeakerStateUpdate(audioRendererChangeInfos);
642 ASSERT_EQ(screenCaptureServer_->audioSource_->HasSpeakerStream(audioRendererChangeInfos), false);
643 sleep(RECORDER_TIME);
644 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
645 }
646
647 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_003, TestSize.Level2)
648 {
649 SetValidConfig();
650 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
651 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
652 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
653 for (int i = 0; i < 7; ++i) {
654 std::shared_ptr<AudioRendererChangeInfo> changeInfo = std::make_shared<AudioRendererChangeInfo>();
655 audioRendererChangeInfos.push_back(changeInfo);
656 }
657 audioRendererChangeInfos.push_back(nullptr);
658 audioRendererChangeInfos[0]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_WIRED_HEADSET;
659 audioRendererChangeInfos[1]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_WIRED_HEADPHONES;
660 audioRendererChangeInfos[2]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_BLUETOOTH_SCO;
661 audioRendererChangeInfos[3]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
662 audioRendererChangeInfos[4]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET;
663 audioRendererChangeInfos[5]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
664 audioRendererChangeInfos[6]->outputDeviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
665 screenCaptureServer_->audioSource_->HasSpeakerStream(audioRendererChangeInfos);
666 ASSERT_EQ(screenCaptureServer_->audioSource_->HasSpeakerStream(audioRendererChangeInfos), true);
667 sleep(RECORDER_TIME);
668 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
669 }
670
671 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_004, TestSize.Level2)
672 {
673 SetValidConfig();
674 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
675 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
676 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
677 audioRendererChangeInfos.push_back(nullptr);
678 for (int i = 0; i < 3; ++i) {
679 std::shared_ptr<AudioRendererChangeInfo> changeInfo = std::make_shared<AudioRendererChangeInfo>();
680 audioRendererChangeInfos.push_back(changeInfo);
681 }
682 audioRendererChangeInfos[1]->rendererState = RendererState::RENDERER_STOPPED;
683 audioRendererChangeInfos[2]->rendererState = RendererState::RENDERER_RUNNING;
684 audioRendererChangeInfos[2]->rendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_MEDIA;
685 audioRendererChangeInfos[3]->rendererState = RendererState::RENDERER_RUNNING;
686 audioRendererChangeInfos[3]->rendererInfo.streamUsage =
687 AudioStandard::StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
688 screenCaptureServer_->audioSource_->HasVoIPStream(audioRendererChangeInfos);
689 sleep(RECORDER_TIME);
690 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
691 }
692
693 HWTEST_F(ScreenCaptureServerFunctionTest, AudioDataSource_005, TestSize.Level2)
694 {
695 SetInvalidConfig();
696 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
697 config_.audioInfo.micCapInfo.audioChannels = 2;
698 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
699 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
700 config_.audioInfo.innerCapInfo.audioChannels = 2;
701 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
702 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
703 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
704 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
705 screenCaptureServer_->audioSource_->speakerAliveStatus_ = true;
706 screenCaptureServer_->audioSource_->SpeakerStateUpdate(audioRendererChangeInfos);
707 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
708 screenCaptureServer_->audioSource_->SpeakerStateUpdate(audioRendererChangeInfos);
709 sleep(RECORDER_TIME);
710 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
711 }
712
713 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_001, TestSize.Level2)
714 {
715 SetInvalidConfig();
716 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
717 config_.audioInfo.micCapInfo.audioChannels = 2;
718 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
719 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
720 config_.audioInfo.innerCapInfo.audioChannels = 2;
721 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
722 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
723 int32_t sessionId = 1;
724 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
725 std::string choice = "{\"choice\": \"false\", \"displayId\": -1, \"missionId\": -1}";
726 ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
727 }
728
729 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_002, TestSize.Level2)
730 {
731 SetInvalidConfig();
732 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
733 config_.audioInfo.micCapInfo.audioChannels = 2;
734 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
735 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
736 config_.audioInfo.innerCapInfo.audioChannels = 2;
737 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
738 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
739 int32_t sessionId = 1;
740 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
741 std::string choice = "{\"choice\": \"true\", \"displayId\": -1, \"missionId\": -1}";
742 ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
743 }
744
745 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_003, TestSize.Level2)
746 {
747 SetInvalidConfig();
748 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
749 config_.audioInfo.micCapInfo.audioChannels = 2;
750 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
751 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
752 config_.audioInfo.innerCapInfo.audioChannels = 2;
753 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
754 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
755 int32_t sessionId = -1;
756 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
757 std::string choice = "{\"choice\": \"true\", \"displayId\": -1, \"missionId\": -1}";
758 ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
759 }
760
761 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_004, TestSize.Level2)
762 {
763 SetInvalidConfig();
764 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
765 config_.audioInfo.micCapInfo.audioChannels = 2;
766 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
767 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
768 config_.audioInfo.innerCapInfo.audioChannels = 2;
769 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
770 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
771 int32_t sessionId = 1;
772 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
773 std::string choice = "{\"choice\": \"12345\", \"displayId\": -1, \"missionId\": -1}";
774 ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
775 }
776
777 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_005, TestSize.Level2)
778 {
779 SetInvalidConfig();
780 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
781 config_.audioInfo.micCapInfo.audioChannels = 2;
782 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
783 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
784 config_.audioInfo.innerCapInfo.audioChannels = 2;
785 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
786 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
787 int32_t sessionId = screenCaptureServer_->sessionId_;
788 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
789 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
790 std::string choice = "{\"choice\": \"true\", \"displayId\": -1, \"missionId\": -1}";
791 ASSERT_EQ(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
792 }
793
794 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_006, TestSize.Level2)
795 {
796 SetInvalidConfig();
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 int32_t sessionId = 10086;
805 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
806 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
807 std::string choice = "{\"choice\": \"true\", \"displayId\": -1, \"missionId\": -1}";
808 ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
809 }
810
811 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_007, TestSize.Level2)
812 {
813 SetInvalidConfig();
814 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
815 config_.audioInfo.micCapInfo.audioChannels = 2;
816 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
817 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
818 config_.audioInfo.innerCapInfo.audioChannels = 2;
819 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
820 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
821 int32_t sessionId = 1;
822 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
823 std::string choice = "{\"choice\": \"true\", \"displayId\": 0, \"missionId\": 0}";
824 ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
825 }
826
827 HWTEST_F(ScreenCaptureServerFunctionTest, ReportAVScreenCaptureUserChoice_008, TestSize.Level2)
828 {
829 SetInvalidConfig();
830 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
831 config_.audioInfo.micCapInfo.audioChannels = 2;
832 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
833 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
834 config_.audioInfo.innerCapInfo.audioChannels = 2;
835 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
836 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
837 int32_t sessionId = 1;
838 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
839 std::string choice = "{\"choice\": \"true\"}";
840 ASSERT_NE(screenCaptureServer_->ReportAVScreenCaptureUserChoice(sessionId, choice), MSERR_OK);
841 }
842
843 HWTEST_F(ScreenCaptureServerFunctionTest, CheckScreenCapturePermission_001, TestSize.Level2)
844 {
845 SetInvalidConfig();
846 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
847 config_.audioInfo.micCapInfo.audioChannels = 2;
848 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
849 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
850 config_.audioInfo.innerCapInfo.audioChannels = 2;
851 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
852 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
853 ASSERT_EQ(screenCaptureServer_->CheckScreenCapturePermission(), true);
854 }
855
856 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_001, TestSize.Level2)
857 {
858 SetInvalidConfig();
859 config_.videoInfo.videoEncInfo.videoCodec = VIDEO_CODEC_FORMAT_BUTT;
860 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
861 }
862
863 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_002, TestSize.Level2)
864 {
865 SetInvalidConfig();
866 config_.videoInfo.videoEncInfo.videoBitrate = screenCaptureServer_->VIDEO_BITRATE_MIN - 1;
867 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
868 }
869
870 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_003, TestSize.Level2)
871 {
872 SetInvalidConfig();
873 config_.videoInfo.videoEncInfo.videoBitrate = screenCaptureServer_->VIDEO_BITRATE_MAX + 1;
874 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
875 }
876
877 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_004, TestSize.Level2)
878 {
879 SetInvalidConfig();
880 config_.videoInfo.videoEncInfo.videoFrameRate = screenCaptureServer_->VIDEO_FRAME_RATE_MIN - 1;
881 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
882 }
883
884 HWTEST_F(ScreenCaptureServerFunctionTest, CheckVideoEncParam_005, TestSize.Level2)
885 {
886 SetInvalidConfig();
887 config_.videoInfo.videoEncInfo.videoFrameRate = screenCaptureServer_->VIDEO_FRAME_RATE_MAX + 1;
888 ASSERT_NE(screenCaptureServer_->CheckVideoEncParam(config_.videoInfo.videoEncInfo), MSERR_OK);
889 }
890
891 HWTEST_F(ScreenCaptureServerFunctionTest, SetOutputFile_001, TestSize.Level2)
892 {
893 ASSERT_NE(screenCaptureServer_->SetOutputFile(-1), MSERR_OK);
894 }
895
896 HWTEST_F(ScreenCaptureServerFunctionTest, OnStartScreenCapture_001, TestSize.Level2)
897 {
898 SetInvalidConfig();
899 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
900 config_.audioInfo.micCapInfo.audioChannels = 2;
901 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
902 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
903 config_.audioInfo.innerCapInfo.audioChannels = 2;
904 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
905 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
906 ASSERT_EQ(screenCaptureServer_->OnStartScreenCapture(), MSERR_OK);
907 }
908
909 HWTEST_F(ScreenCaptureServerFunctionTest, OnStartScreenCapture_002, TestSize.Level2)
910 {
911 RecorderInfo recorderInfo;
912 SetRecorderInfo("on_start_screen_capture_unittest_002.mp4", recorderInfo);
913 SetInvalidConfigFile(recorderInfo);
914 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
915 config_.audioInfo.micCapInfo.audioChannels = 2;
916 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
917 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
918 config_.audioInfo.innerCapInfo.audioChannels = 2;
919 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
920 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
921 ASSERT_NE(screenCaptureServer_->OnStartScreenCapture(), MSERR_OK);
922 }
923
924 HWTEST_F(ScreenCaptureServerFunctionTest, SetScreenScaleMode_001, TestSize.Level2)
925 {
926 ASSERT_NE(screenCaptureServer_->SetScreenScaleMode(), MSERR_OK);
927 }
928
929 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION
930 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_001, TestSize.Level2)
931 {
932 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID;
933 screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
934 ASSERT_NE(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
935 }
936
937 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_002, TestSize.Level2)
938 {
939 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID;
940 screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
941 screenCaptureServer_->appName_ = ScreenRecorderBundleName;
942 ASSERT_EQ(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
943 }
944
945 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_003, TestSize.Level2)
946 {
947 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID + 1;
948 screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
949 ASSERT_NE(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
950 }
951
952 HWTEST_F(ScreenCaptureServerFunctionTest, RequestUserPrivacyAuthority_004, TestSize.Level2)
953 {
954 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID + 1;
955 screenCaptureServer_->isPrivacyAuthorityEnabled_ = true;
956 screenCaptureServer_->appName_ = ScreenRecorderBundleName;
957 ASSERT_EQ(screenCaptureServer_->RequestUserPrivacyAuthority(), MSERR_OK);
958 }
959 #endif
960
961 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_001, TestSize.Level2)
962 {
963 ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(false), MSERR_OK);
964 }
965
966 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_002, TestSize.Level2)
967 {
968 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
969 ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(false), MSERR_OK);
970 }
971
972 HWTEST_F(ScreenCaptureServerFunctionTest, OnReceiveUserPrivacyAuthority_003, TestSize.Level2)
973 {
974 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
975 ASSERT_NE(screenCaptureServer_->OnReceiveUserPrivacyAuthority(true), MSERR_OK);
976 }
977
978 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatStartAudioCapture_001, TestSize.Level2)
979 {
980 SetInvalidConfig();
981 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
982 config_.audioInfo.micCapInfo.audioChannels = 2;
983 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
984 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
985 config_.audioInfo.innerCapInfo.audioChannels = 2;
986 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
987 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
988 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
989 ASSERT_NE(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK);
990 }
991
992 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatResumeAudioCapture_001, TestSize.Level2)
993 {
994 SetInvalidConfig();
995 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
996 config_.audioInfo.micCapInfo.audioChannels = 2;
997 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
998 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
999 config_.audioInfo.innerCapInfo.audioChannels = 2;
1000 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1001 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1002 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
1003 ASSERT_NE(screenCaptureServer_->innerAudioCapture_->Resume(), MSERR_OK);
1004 }
1005
1006 HWTEST_F(ScreenCaptureServerFunctionTest, RepeatPauseAudioCapture_001, TestSize.Level2)
1007 {
1008 SetInvalidConfig();
1009 config_.audioInfo.micCapInfo.audioSampleRate = 16000;
1010 config_.audioInfo.micCapInfo.audioChannels = 2;
1011 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1012 config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1013 config_.audioInfo.innerCapInfo.audioChannels = 2;
1014 config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1015 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1016 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
1017 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Pause(), MSERR_OK);
1018 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Pause(), MSERR_OK);
1019 }
1020
1021 HWTEST_F(ScreenCaptureServerFunctionTest, UpdatePrivacyUsingPermissionState_001, TestSize.Level2)
1022 {
1023 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID;
1024 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(START_VIDEO), true);
1025 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(STOP_VIDEO), true);
1026 }
1027
1028 HWTEST_F(ScreenCaptureServerFunctionTest, UpdatePrivacyUsingPermissionState_002, TestSize.Level2)
1029 {
1030 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID + 1;
1031 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(START_VIDEO), false);
1032 ASSERT_EQ(screenCaptureServer_->UpdatePrivacyUsingPermissionState(STOP_VIDEO), false);
1033 }
1034
1035 HWTEST_F(ScreenCaptureServerFunctionTest, StartScreenCaptureWithSurface_001, TestSize.Level2)
1036 {
1037 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
1038 ASSERT_NE(screenCaptureServer_->StartScreenCaptureWithSurface(nullptr, true), MSERR_OK);
1039 }
1040
1041 HWTEST_F(ScreenCaptureServerFunctionTest, MixAudio_001, TestSize.Level2)
1042 {
1043 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1044 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1045 const int channels = 2;
1046 const int bufferSize = 10;
1047 const char zeroChar = (char)0;
1048 const char minChar = (char)127;
1049 const char maxChar = (char)-128;
1050 char innerBuffer[bufferSize] = {zeroChar, maxChar, minChar, zeroChar, maxChar, minChar, zeroChar, maxChar,
1051 minChar, zeroChar};
1052 char micBuffer[bufferSize] = {maxChar, minChar, zeroChar, maxChar, minChar, zeroChar, maxChar, minChar,
1053 zeroChar, maxChar};
1054 char* srcData[channels] = {nullptr};
1055 srcData[0] = innerBuffer;
1056 srcData[1] = micBuffer;
1057 char mixData[bufferSize];
1058 screenCaptureServer_->audioSource_->MixAudio(srcData, mixData, channels, bufferSize);
1059 ASSERT_EQ(mixData[0], maxChar);
1060 ASSERT_EQ(mixData[bufferSize - 1], maxChar);
1061 }
1062
1063 // MixAudio input channels param is 0
1064 HWTEST_F(ScreenCaptureServerFunctionTest, MixAudio_002, TestSize.Level2)
1065 {
1066 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1067 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1068 const int channels = 2;
1069 const int bufferSize = 10;
1070 const char zeroChar = (char)0;
1071 const char minChar = (char)127;
1072 const char maxChar = (char)-128;
1073 char innerBuffer[bufferSize] = {zeroChar, maxChar, minChar, zeroChar, maxChar, minChar, zeroChar, maxChar,
1074 minChar, zeroChar};
1075 char micBuffer[bufferSize] = {maxChar, minChar, zeroChar, maxChar, minChar, zeroChar, maxChar, minChar,
1076 zeroChar, maxChar};
1077 char* srcData[channels] = {nullptr};
1078 srcData[0] = innerBuffer;
1079 srcData[1] = micBuffer;
1080 char mixData[bufferSize] = {zeroChar};
1081 screenCaptureServer_->audioSource_->MixAudio(srcData, mixData, 0, bufferSize);
1082 ASSERT_EQ(mixData[0], zeroChar);
1083 }
1084
1085 HWTEST_F(ScreenCaptureServerFunctionTest, PrivateWindowListenerInScreenCapture_001, TestSize.Level2)
1086 {
1087 screenCaptureServer_->RegisterPrivateWindowListener();
1088 screenCaptureServer_->displayListener_->OnPrivateWindow(true);
1089 ASSERT_NE(screenCaptureServer_->displayListener_, nullptr);
1090 }
1091
1092 HWTEST_F(ScreenCaptureServerFunctionTest, PrivateWindowListenerInScreenCapture_002, TestSize.Level2)
1093 {
1094 screenCaptureServer_->RegisterPrivateWindowListener();
1095 screenCaptureServer_->displayListener_->OnPrivateWindow(false);
1096 ASSERT_NE(screenCaptureServer_->displayListener_, nullptr);
1097 }
1098
1099 HWTEST_F(ScreenCaptureServerFunctionTest, ScreenConnectListenerInScreenCapture_001, TestSize.Level2)
1100 {
1101 screenCaptureServer_->displayScreenId_ = 1; // 1 display screen id
1102 screenCaptureServer_->RegisterScreenConnectListener();
1103 uint64_t screenId = 1; // 1 disconnect screen id
1104 screenCaptureServer_->screenConnectListener_->OnConnect(screenId);
1105 screenCaptureServer_->screenConnectListener_->OnDisconnect(screenId);
1106 screenCaptureServer_->screenConnectListener_->OnChange(screenId);
1107 ASSERT_NE(screenCaptureServer_->screenConnectListener_, nullptr);
1108 }
1109
1110 HWTEST_F(ScreenCaptureServerFunctionTest, ScreenConnectListenerInScreenCapture_002, TestSize.Level2)
1111 {
1112 screenCaptureServer_->displayScreenId_ = 2; // 2 display screen id
1113 screenCaptureServer_->RegisterScreenConnectListener();
1114 uint64_t screenId = 1; // 1 disconnect screen id
1115 screenCaptureServer_->screenConnectListener_->OnConnect(screenId);
1116 screenCaptureServer_->screenConnectListener_->OnDisconnect(screenId);
1117 screenCaptureServer_->screenConnectListener_->OnChange(screenId);
1118 ASSERT_NE(screenCaptureServer_->screenConnectListener_, nullptr);
1119 }
1120
1121 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_001, TestSize.Level2)
1122 {
1123 auto notificationSubscriber = NotificationSubscriber();
1124 notificationSubscriber.OnConnected();
1125 notificationSubscriber.OnDisconnected();
1126 notificationSubscriber.OnDied();
1127 ASSERT_NE(¬ificationSubscriber, nullptr);
1128 }
1129
1130 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_002, TestSize.Level2)
1131 {
1132 std::shared_ptr<ScreenCaptureServer> screenCaptureServerInner;
1133 std::shared_ptr<IScreenCaptureService> tempServer = ScreenCaptureServer::Create();
1134 screenCaptureServerInner = std::static_pointer_cast<ScreenCaptureServer>(tempServer);
1135 RecorderInfo recorderInfo{};
1136 SetValidConfigFile(recorderInfo);
1137 config_.dataType = DataType::ORIGINAL_STREAM;
1138 sptr<IStandardScreenCaptureListener> listener = new(std::nothrow) StandardScreenCaptureServerUnittestCallback();
1139 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb =
1140 std::make_shared<ScreenCaptureServerUnittestCallbackMock>(listener);
1141 screenCaptureServerInner->SetScreenCaptureCallback(screenCaptureCb);
1142 screenCaptureServerInner->SetCaptureMode(config_.captureMode);
1143 screenCaptureServerInner->SetDataType(config_.dataType);
1144 screenCaptureServerInner->InitAudioCap(config_.audioInfo.innerCapInfo);
1145 screenCaptureServerInner->InitVideoCap(config_.videoInfo.videoCapInfo);
1146 screenCaptureServerInner->InitAudioCap(config_.audioInfo.micCapInfo);
1147 int32_t ret = screenCaptureServerInner->StartScreenCapture(false);
1148 ASSERT_EQ(ret, MSERR_OK);
1149 sleep(RECORDER_TIME);
1150
1151 auto notificationSubscriber = NotificationSubscriber();
1152 if (screenCaptureServerInner->serverMap_.begin() != screenCaptureServerInner->serverMap_.end()) {
1153 int32_t notificationId = screenCaptureServerInner->serverMap_.begin()->first;
1154 OHOS::sptr<OHOS::Notification::NotificationButtonOption> buttonOption =
1155 new(std::nothrow) OHOS::Notification::NotificationButtonOption();
1156 buttonOption->SetButtonName(BUTTON_NAME_STOP);
1157 notificationSubscriber.OnResponse(notificationId, buttonOption);
1158 }
1159 ASSERT_NE(¬ificationSubscriber, nullptr);
1160
1161 screenCaptureServerInner->Release();
1162 }
1163
1164 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_003, TestSize.Level2)
1165 {
1166 std::shared_ptr<ScreenCaptureServer> screenCaptureServerInner;
1167 std::shared_ptr<IScreenCaptureService> tempServer = ScreenCaptureServer::Create();
1168 screenCaptureServerInner = std::static_pointer_cast<ScreenCaptureServer>(tempServer);
1169 RecorderInfo recorderInfo{};
1170 SetValidConfigFile(recorderInfo);
1171 config_.dataType = DataType::ORIGINAL_STREAM;
1172 sptr<IStandardScreenCaptureListener> listener = new(std::nothrow) StandardScreenCaptureServerUnittestCallback();
1173 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb =
1174 std::make_shared<ScreenCaptureServerUnittestCallbackMock>(listener);
1175 screenCaptureServerInner->SetScreenCaptureCallback(screenCaptureCb);
1176 screenCaptureServerInner->SetCaptureMode(config_.captureMode);
1177 screenCaptureServerInner->SetDataType(config_.dataType);
1178 screenCaptureServerInner->InitAudioCap(config_.audioInfo.innerCapInfo);
1179 screenCaptureServerInner->InitVideoCap(config_.videoInfo.videoCapInfo);
1180 screenCaptureServerInner->InitAudioCap(config_.audioInfo.micCapInfo);
1181 int32_t ret = screenCaptureServerInner->StartScreenCapture(false);
1182 ASSERT_EQ(ret, MSERR_OK);
1183 sleep(RECORDER_TIME);
1184
1185 auto notificationSubscriber = NotificationSubscriber();
1186 if (screenCaptureServerInner->serverMap_.begin() != screenCaptureServerInner->serverMap_.end()) {
1187 int32_t notificationId = screenCaptureServerInner->serverMap_.begin()->first;
1188 OHOS::sptr<OHOS::Notification::NotificationButtonOption> buttonOption =
1189 new(std::nothrow) OHOS::Notification::NotificationButtonOption();
1190 buttonOption->SetButtonName("null");
1191 notificationSubscriber.OnResponse(notificationId, buttonOption);
1192 }
1193
1194 sleep(RECORDER_TIME);
1195 ASSERT_NE(¬ificationSubscriber, nullptr);
1196 screenCaptureServerInner->StopScreenCapture();
1197 screenCaptureServerInner->Release();
1198 }
1199
1200 HWTEST_F(ScreenCaptureServerFunctionTest, NotificationSubscriber_004, TestSize.Level2)
1201 {
1202 std::shared_ptr<ScreenCaptureServer> screenCaptureServerInner;
1203 std::shared_ptr<IScreenCaptureService> tempServer = ScreenCaptureServer::Create();
1204 screenCaptureServerInner = std::static_pointer_cast<ScreenCaptureServer>(tempServer);
1205 RecorderInfo recorderInfo{};
1206 SetValidConfigFile(recorderInfo);
1207 config_.dataType = DataType::ORIGINAL_STREAM;
1208 sptr<IStandardScreenCaptureListener> listener = new(std::nothrow) StandardScreenCaptureServerUnittestCallback();
1209 std::shared_ptr<ScreenCaptureCallBack> screenCaptureCb =
1210 std::make_shared<ScreenCaptureServerUnittestCallbackMock>(listener);
1211 screenCaptureServerInner->SetScreenCaptureCallback(screenCaptureCb);
1212 screenCaptureServerInner->SetCaptureMode(config_.captureMode);
1213 screenCaptureServerInner->SetDataType(config_.dataType);
1214 screenCaptureServerInner->InitAudioCap(config_.audioInfo.innerCapInfo);
1215 screenCaptureServerInner->InitVideoCap(config_.videoInfo.videoCapInfo);
1216 screenCaptureServerInner->InitAudioCap(config_.audioInfo.micCapInfo);
1217 int32_t ret = screenCaptureServerInner->StartScreenCapture(false);
1218 ASSERT_EQ(ret, MSERR_OK);
1219 sleep(RECORDER_TIME);
1220
1221 auto notificationSubscriber = NotificationSubscriber();
1222 int32_t invalidNotificationId = ScreenCaptureServer::maxSessionId_ + 1;
1223 OHOS::sptr<OHOS::Notification::NotificationButtonOption> buttonOption =
1224 new(std::nothrow) OHOS::Notification::NotificationButtonOption();
1225 buttonOption->SetButtonName("null");
1226 notificationSubscriber.OnResponse(invalidNotificationId, buttonOption);
1227
1228 sleep(RECORDER_TIME);
1229 ASSERT_NE(¬ificationSubscriber, nullptr);
1230 screenCaptureServerInner->StopScreenCapture();
1231 screenCaptureServerInner->Release();
1232 }
1233
1234 HWTEST_F(ScreenCaptureServerFunctionTest, SetDisplayId_001, TestSize.Level2)
1235 {
1236 uint64_t displayId = 0;
1237 screenCaptureServer_->SetDisplayId(displayId);
1238 ASSERT_EQ(screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.displayId, displayId);
1239 }
1240
1241 HWTEST_F(ScreenCaptureServerFunctionTest, SetMissionId_001, TestSize.Level2)
1242 {
1243 uint64_t missionId = 0;
1244 screenCaptureServer_->SetMissionId(missionId);
1245 ASSERT_EQ(screenCaptureServer_->missionIds_.back(), missionId);
1246 }
1247
1248 HWTEST_F(ScreenCaptureServerFunctionTest, StartScreenCaptureInner_001, TestSize.Level2)
1249 {
1250 SetValidConfig();
1251 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1252 screenCaptureServer_->appInfo_.appUid = ScreenCaptureServer::ROOT_UID + 1;
1253 ASSERT_EQ(screenCaptureServer_->StartScreenCaptureInner(false), MSERR_OK);
1254 }
1255
1256 HWTEST_F(ScreenCaptureServerFunctionTest, IsTelInCallSkipList_001, TestSize.Level2)
1257 {
1258 screenCaptureServer_->isCalledBySystemApp_ = true;
1259 screenCaptureServer_->appName_ = HiviewCareBundleName;
1260 ASSERT_EQ(screenCaptureServer_->IsTelInCallSkipList(), true);
1261 }
1262
1263 HWTEST_F(ScreenCaptureServerFunctionTest, IsTelInCallSkipList_002, TestSize.Level2)
1264 {
1265 screenCaptureServer_->isCalledBySystemApp_ = true;
1266 screenCaptureServer_->appName_ = "";
1267 ASSERT_EQ(screenCaptureServer_->IsTelInCallSkipList(), false);
1268 }
1269
1270 HWTEST_F(ScreenCaptureServerFunctionTest, IsTelInCallSkipList_003, TestSize.Level2)
1271 {
1272 screenCaptureServer_->isCalledBySystemApp_ = false;
1273 screenCaptureServer_->appName_ = "";
1274 ASSERT_EQ(screenCaptureServer_->IsTelInCallSkipList(), false);
1275 }
1276
1277 HWTEST_F(ScreenCaptureServerFunctionTest, GetStringByResourceName_001, TestSize.Level2)
1278 {
1279 screenCaptureServer_->InitResourceManager();
1280 std::string liveViewText = ScreenCaptureServer::QUOTATION_MARKS_STRING;
1281 liveViewText += screenCaptureServer_->GetStringByResourceName(
1282 ScreenCaptureServer::NOTIFICATION_SCREEN_RECORDING_TITLE_ID).c_str();
1283 MEDIA_LOGI("GetStringByResourceName liveViewText: %{public}s", liveViewText.c_str());
1284 ASSERT_EQ(screenCaptureServer_->GetStringByResourceName(
1285 ScreenCaptureServer::NOTIFICATION_SCREEN_RECORDING_TITLE_ID).size() > 0, true);
1286 ASSERT_EQ(screenCaptureServer_->GetStringByResourceName("NOT_EXITS_ID").size() == 0, true);
1287 screenCaptureServer_->resourceManager_ = nullptr;
1288 ASSERT_EQ(screenCaptureServer_->GetStringByResourceName(
1289 ScreenCaptureServer::NOTIFICATION_SCREEN_RECORDING_TITLE_ID).size() > 0, false);
1290 }
1291
1292 HWTEST_F(ScreenCaptureServerFunctionTest, SetCaptureConfig_001, TestSize.Level2)
1293 {
1294 screenCaptureServer_->SetCaptureConfig(CAPTURE_INVAILD, -1);
1295 screenCaptureServer_->SetCaptureConfig(CAPTURE_INVAILD, 0);
1296 ASSERT_EQ(screenCaptureServer_->captureConfig_.videoInfo.videoCapInfo.taskIDs.back(), 0);
1297 }
1298
1299 HWTEST_F(ScreenCaptureServerFunctionTest, PrepareSelectWindow_001, TestSize.Level2)
1300 {
1301 Json::Value root;
1302 screenCaptureServer_->PrepareSelectWindow(root, screenCaptureServer_);
1303 ASSERT_NE(screenCaptureServer_, nullptr);
1304 }
1305
1306 HWTEST_F(ScreenCaptureServerFunctionTest, PrepareSelectWindow_002, TestSize.Level2)
1307 {
1308 Json::Value root;
1309 const std::string rawString = "{\"displayId\" : 1, \"missionId\" : 1}";
1310 Json::Reader reader;
1311 reader.parse(rawString, root);
1312 screenCaptureServer_->PrepareSelectWindow(root, screenCaptureServer_);
1313 ASSERT_NE(screenCaptureServer_, nullptr);
1314 }
1315
1316 HWTEST_F(ScreenCaptureServerFunctionTest, PrepareSelectWindow_003, TestSize.Level2)
1317 {
1318 Json::Value root;
1319 const std::string rawString = "{\"displayId\" : -1, \"missionId\" : -1}";
1320 Json::Reader reader;
1321 reader.parse(rawString, root);
1322 screenCaptureServer_->PrepareSelectWindow(root, screenCaptureServer_);
1323 ASSERT_NE(screenCaptureServer_, nullptr);
1324 }
1325
1326 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION
1327 HWTEST_F(ScreenCaptureServerFunctionTest, TryNotificationOnPostStartScreenCapture_001, TestSize.Level2)
1328 {
1329 int32_t ret = screenCaptureServer_->TryNotificationOnPostStartScreenCapture();
1330 ASSERT_NE(ret, MSERR_OK);
1331 }
1332 #endif
1333
1334 HWTEST_F(ScreenCaptureServerFunctionTest, ReleaseAudioBufferMix_001, TestSize.Level2)
1335 {
1336 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1337 int32_t ret = screenCaptureServer_->ReleaseAudioBufferMix(AVScreenCaptureMixMode::MIX_MODE);
1338 ASSERT_EQ(ret, MSERR_OK);
1339 ret = screenCaptureServer_->ReleaseAudioBufferMix(AVScreenCaptureMixMode::MIC_MODE);
1340 ASSERT_EQ(ret, MSERR_OK);
1341 ret = screenCaptureServer_->ReleaseAudioBufferMix(AVScreenCaptureMixMode::INNER_MODE);
1342 ASSERT_EQ(ret, MSERR_OK);
1343 }
1344
1345 HWTEST_F(ScreenCaptureServerFunctionTest, ReleaseAudioBufferMix_002, TestSize.Level2)
1346 {
1347 SetValidConfig();
1348 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1349 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
1350 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1351 int32_t ret = screenCaptureServer_->ReleaseAudioBufferMix(AVScreenCaptureMixMode::MIX_MODE);
1352 ASSERT_EQ(ret, MSERR_OK);
1353 ret = screenCaptureServer_->ReleaseAudioBufferMix(AVScreenCaptureMixMode::MIC_MODE);
1354 ASSERT_EQ(ret, MSERR_OK);
1355 ret = screenCaptureServer_->ReleaseAudioBufferMix(AVScreenCaptureMixMode::INNER_MODE);
1356 ASSERT_EQ(ret, MSERR_OK);
1357 }
1358
1359 HWTEST_F(ScreenCaptureServerFunctionTest, MixModeBufferWrite_001, TestSize.Level2)
1360 {
1361 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1362 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1363 const int bufferSize = 10;
1364 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1365 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1366 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1367 SOURCE_DEFAULT);
1368 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1369 SOURCE_DEFAULT);
1370 uint8_t data[bufferSize];
1371 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1372 int32_t ret = screenCaptureServer_->audioSource_->MixModeBufferWrite(innerAudioBuffer, micAudioBuffer, bufferMem);
1373 ASSERT_EQ(ret, MSERR_OK);
1374 }
1375
1376 HWTEST_F(ScreenCaptureServerFunctionTest, MixModeBufferWrite_002, TestSize.Level2)
1377 {
1378 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1379 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1380 const int bufferSize = 10;
1381 uint8_t *innerBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1382 std::shared_ptr<AudioBuffer> innerAudioBuffer = std::make_shared<AudioBuffer>(innerBuffer, bufferSize, 0,
1383 SOURCE_DEFAULT);
1384 std::shared_ptr<AudioBuffer> micAudioBuffer;
1385 uint8_t data[bufferSize];
1386 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1387 int32_t ret = screenCaptureServer_->audioSource_->MixModeBufferWrite(innerAudioBuffer, micAudioBuffer, bufferMem);
1388 ASSERT_EQ(ret, MSERR_OK);
1389 }
1390
1391 HWTEST_F(ScreenCaptureServerFunctionTest, MixModeBufferWrite_003, TestSize.Level2)
1392 {
1393 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1394 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1395 const int bufferSize = 10;
1396 uint8_t *micBuffer = (uint8_t *)malloc(sizeof(uint8_t) * bufferSize);
1397 std::shared_ptr<AudioBuffer> innerAudioBuffer;
1398 std::shared_ptr<AudioBuffer> micAudioBuffer = std::make_shared<AudioBuffer>(micBuffer, bufferSize, 0,
1399 SOURCE_DEFAULT);
1400 uint8_t data[bufferSize];
1401 std::shared_ptr<AVMemory> bufferMem = AVMemory::CreateAVMemory(data, bufferSize, bufferSize);
1402 int32_t ret = screenCaptureServer_->audioSource_->MixModeBufferWrite(innerAudioBuffer, micAudioBuffer, bufferMem);
1403 ASSERT_EQ(ret, MSERR_OK);
1404 }
1405
1406 HWTEST_F(ScreenCaptureServerFunctionTest, AcquireAudioBufferMix_001, TestSize.Level2)
1407 {
1408 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1409 std::shared_ptr<AudioBuffer> innerAudioBuffer;
1410 std::shared_ptr<AudioBuffer> micAudioBuffer;
1411 int32_t ret = screenCaptureServer_->AcquireAudioBufferMix(innerAudioBuffer, micAudioBuffer,
1412 AVScreenCaptureMixMode::MIX_MODE);
1413 ASSERT_EQ(ret, MSERR_OK);
1414 ret = screenCaptureServer_->AcquireAudioBufferMix(innerAudioBuffer, micAudioBuffer,
1415 AVScreenCaptureMixMode::MIC_MODE);
1416 ASSERT_EQ(ret, MSERR_OK);
1417 ret = screenCaptureServer_->AcquireAudioBufferMix(innerAudioBuffer, micAudioBuffer,
1418 AVScreenCaptureMixMode::INNER_MODE);
1419 ASSERT_EQ(ret, MSERR_OK);
1420 }
1421
1422 HWTEST_F(ScreenCaptureServerFunctionTest, AcquireAudioBufferMix_002, TestSize.Level2)
1423 {
1424 SetValidConfig();
1425 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1426 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
1427 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1428 std::shared_ptr<AudioBuffer> innerAudioBuffer;
1429 std::shared_ptr<AudioBuffer> micAudioBuffer;
1430 int32_t ret = screenCaptureServer_->AcquireAudioBufferMix(innerAudioBuffer, micAudioBuffer,
1431 AVScreenCaptureMixMode::MIX_MODE);
1432 ASSERT_EQ(ret, MSERR_OK);
1433 ret = screenCaptureServer_->AcquireAudioBufferMix(innerAudioBuffer, micAudioBuffer,
1434 AVScreenCaptureMixMode::MIC_MODE);
1435 ASSERT_EQ(ret, MSERR_OK);
1436 ret = screenCaptureServer_->AcquireAudioBufferMix(innerAudioBuffer, micAudioBuffer,
1437 AVScreenCaptureMixMode::INNER_MODE);
1438 ASSERT_EQ(ret, MSERR_OK);
1439 }
1440
1441 HWTEST_F(ScreenCaptureServerFunctionTest, GetChoiceFromJson_001, TestSize.Level2)
1442 {
1443 Json::Value root;
1444 std::string content = "ghgh%^&%^$*^(}{^af&**)";
1445 std::string value;
1446 screenCaptureServer_->GetChoiceFromJson(root, content, "choice", value);
1447 ASSERT_NE(screenCaptureServer_, nullptr);
1448 }
1449
1450 HWTEST_F(ScreenCaptureServerFunctionTest, GetChoiceFromJson_002, TestSize.Level2)
1451 {
1452 Json::Value root;
1453 std::string content = "{\"choice_\": \"true\"}";
1454 std::string value;
1455 screenCaptureServer_->GetChoiceFromJson(root, content, "choice", value);
1456 ASSERT_NE(screenCaptureServer_, nullptr);
1457 }
1458
1459 HWTEST_F(ScreenCaptureServerFunctionTest, StartFileInnerAudioCapture_001, TestSize.Level2)
1460 {
1461 RecorderInfo recorderInfo;
1462 SetRecorderInfo("start_file_inner_audio_capture_001.mp4", recorderInfo);
1463 SetValidConfigFile(recorderInfo);
1464 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1465 screenCaptureServer_->SetMicrophoneEnabled(true);
1466 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1467 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1468 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1469 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1470 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1471 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1472 screenCaptureServer_->audioSource_->speakerAliveStatus_ = false;
1473 screenCaptureServer_->StartFileInnerAudioCapture();
1474 screenCaptureServer_->StartFileMicAudioCapture();
1475 sleep(RECORDER_TIME / 2);
1476 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1477 }
1478
1479 HWTEST_F(ScreenCaptureServerFunctionTest, StartFileInnerAudioCapture_002, TestSize.Level2)
1480 {
1481 RecorderInfo recorderInfo;
1482 SetRecorderInfo("start_file_inner_audio_capture_002.mp4", recorderInfo);
1483 SetValidConfigFile(recorderInfo);
1484 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1485 screenCaptureServer_->SetMicrophoneEnabled(true);
1486 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>(
1487 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get());
1488 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>();
1489 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_);
1490 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo.state =
1491 AVScreenCaptureParamValidationState::VALIDATION_VALID;
1492 screenCaptureServer_->audioSource_->isInVoIPCall_ = true;
1493 screenCaptureServer_->StartFileInnerAudioCapture();
1494 screenCaptureServer_->StartFileMicAudioCapture();
1495 sleep(RECORDER_TIME / 2);
1496 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1497 }
1498
1499 #ifdef SUPPORT_CALL
1500 HWTEST_F(ScreenCaptureServerFunctionTest, StopAndRelease_001, TestSize.Level2)
1501 {
1502 ScreenCaptureObserverCallBack* obcb = new ScreenCaptureObserverCallBack(screenCaptureServer_);
1503 if (obcb) {
1504 ASSERT_EQ(obcb->StopAndRelease(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER), true);
1505 }
1506 }
1507
1508 HWTEST_F(ScreenCaptureServerFunctionTest, StopAndRelease_002, TestSize.Level2)
1509 {
1510 ScreenCaptureObserverCallBack* obcb = new ScreenCaptureObserverCallBack(screenCaptureServer_);
1511 if (obcb) {
1512 screenCaptureServer_->Release();
1513 screenCaptureServer_ = nullptr;
1514 ASSERT_EQ(obcb->StopAndRelease(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STOPPED_BY_USER), true);
1515 }
1516 }
1517
1518 /**
1519 * @tc.name: OnTelCallStateChanged_001
1520 * @tc.desc: in call with tel skip
1521 * @tc.type: FUNC
1522 */
1523 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_001, TestSize.Level2)
1524 {
1525 RecorderInfo recorderInfo;
1526 SetRecorderInfo("screen_capture_tel_001.mp4", recorderInfo);
1527 SetValidConfigFile(recorderInfo);
1528 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1529 screenCaptureServer_->SetMicrophoneEnabled(true);
1530 ASSERT_EQ(StartFileAudioCapture(AVScreenCaptureMixMode::MIX_MODE), MSERR_OK);
1531 screenCaptureServer_->appName_ = HiviewCareBundleName;
1532 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
1533 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
1534 sleep(RECORDER_TIME);
1535 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1536 }
1537
1538 /**
1539 * @tc.name: OnTelCallStateChanged_002
1540 * @tc.desc: in call and out call with mic on, CAPTURE_FILE
1541 * @tc.type: FUNC
1542 */
1543 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_002, TestSize.Level2)
1544 {
1545 RecorderInfo recorderInfo;
1546 SetRecorderInfo("screen_capture_tel_002.mp4", recorderInfo);
1547 SetValidConfigFile(recorderInfo);
1548 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1549 screenCaptureServer_->SetMicrophoneEnabled(true);
1550 ASSERT_EQ(StartFileAudioCapture(AVScreenCaptureMixMode::MIX_MODE), MSERR_OK);
1551 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
1552 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
1553 sleep(RECORDER_TIME);
1554 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
1555 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
1556 sleep(RECORDER_TIME);
1557 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1558 }
1559
1560 /**
1561 * @tc.name: OnTelCallStateChanged_003
1562 * @tc.desc: in call and out call with mic off, CAPTURE_FILE
1563 * @tc.type: FUNC
1564 */
1565 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_003, TestSize.Level2)
1566 {
1567 RecorderInfo recorderInfo;
1568 SetRecorderInfo("screen_capture_tel_003.mp4", recorderInfo);
1569 SetValidConfigFile(recorderInfo);
1570 ASSERT_EQ(InitFileScreenCaptureServer(), MSERR_OK);
1571 screenCaptureServer_->SetMicrophoneEnabled(false);
1572 ASSERT_EQ(StartFileAudioCapture(AVScreenCaptureMixMode::MIX_MODE), MSERR_OK);
1573 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
1574 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
1575 sleep(RECORDER_TIME);
1576 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
1577 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
1578 sleep(RECORDER_TIME);
1579 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1580 }
1581
1582 /**
1583 * @tc.name: OnTelCallStateChanged_004
1584 * @tc.desc: in call and out call with mic on, ORIGINAL_STREAM
1585 * @tc.type: FUNC
1586 */
1587 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_004, TestSize.Level2)
1588 {
1589 SetValidConfig();
1590 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1591 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
1592 sleep(RECORDER_TIME);
1593 screenCaptureServer_->SetMicrophoneEnabled(true);
1594 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
1595 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
1596 sleep(RECORDER_TIME);
1597 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
1598 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
1599 sleep(RECORDER_TIME);
1600 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1601 }
1602
1603 /**
1604 * @tc.name: OnTelCallStateChanged_005
1605 * @tc.desc: out call and out call with mic on, ORIGINAL_STREAM (invalid state)
1606 * @tc.type: FUNC
1607 */
1608 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_005, TestSize.Level2)
1609 {
1610 SetValidConfig();
1611 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1612 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
1613 sleep(RECORDER_TIME);
1614 screenCaptureServer_->SetMicrophoneEnabled(true);
1615 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
1616 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
1617 sleep(RECORDER_TIME);
1618 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(false), MSERR_OK);
1619 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(false), MSERR_OK);
1620 sleep(RECORDER_TIME);
1621 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1622 }
1623
1624 /**
1625 * @tc.name: OnTelCallStateChanged_006
1626 * @tc.desc: in call and in call with mic on, ORIGINAL_STREAM (invalid state)
1627 * @tc.type: FUNC
1628 */
1629 HWTEST_F(ScreenCaptureServerFunctionTest, OnTelCallStateChanged_006, TestSize.Level2)
1630 {
1631 SetValidConfig();
1632 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK);
1633 ASSERT_EQ(StartStreamAudioCapture(), MSERR_OK);
1634 sleep(RECORDER_TIME);
1635 screenCaptureServer_->SetMicrophoneEnabled(true);
1636 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
1637 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
1638 sleep(RECORDER_TIME);
1639 ASSERT_EQ(screenCaptureServer_->TelCallStateUpdated(true), MSERR_OK);
1640 ASSERT_EQ(screenCaptureServer_->TelCallAudioStateUpdated(true), MSERR_OK);
1641 sleep(RECORDER_TIME);
1642 ASSERT_EQ(screenCaptureServer_->StopScreenCapture(), MSERR_OK);
1643 }
1644 #endif
1645
1646 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursor_001, TestSize.Level2)
1647 {
1648 screenCaptureServer_->showCursor_ = true;
1649 int ret = screenCaptureServer_->ShowCursor(true);
1650 ASSERT_EQ(ret, MSERR_OK);
1651 }
1652
1653 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursor_002, TestSize.Level2)
1654 {
1655 screenCaptureServer_->showCursor_ = false;
1656 int ret = screenCaptureServer_->ShowCursor(true);
1657 ASSERT_EQ(ret, MSERR_OK);
1658 }
1659
1660 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursor_003, TestSize.Level2)
1661 {
1662 int ret = screenCaptureServer_->ShowCursor(false);
1663 ASSERT_EQ(ret, MSERR_OK);
1664 }
1665
1666 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursor_004, TestSize.Level2)
1667 {
1668 screenCaptureServer_->showCursor_ = false;
1669 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1670 screenCaptureServer_->virtualScreenId_ = 0;
1671 int ret = screenCaptureServer_->ShowCursor(true);
1672 ASSERT_EQ(ret, MSERR_OK);
1673 }
1674
1675 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursorInner_001, TestSize.Level2)
1676 {
1677 screenCaptureServer_->virtualScreenId_ = 0;
1678 int ret = screenCaptureServer_->ShowCursorInner();
1679 ASSERT_EQ(ret, MSERR_OK);
1680 }
1681
1682 HWTEST_F(ScreenCaptureServerFunctionTest, ShowCursorInner_002, TestSize.Level2)
1683 {
1684 screenCaptureServer_->virtualScreenId_ = 0;
1685 screenCaptureServer_->showCursor_ = false;
1686 int ret = screenCaptureServer_->ShowCursorInner();
1687 ASSERT_EQ(ret, MSERR_OK);
1688 }
1689
1690 HWTEST_F(ScreenCaptureServerFunctionTest, OnDeviceAdded_001, TestSize.Level2)
1691 {
1692 std::shared_ptr<MouseChangeListener> listener = std::make_shared<MouseChangeListener>(screenCaptureServer_);
1693 int32_t inputDeviceId = 9;
1694 listener->OnDeviceAdded(inputDeviceId, "test");
1695 ASSERT_EQ(inputDeviceId == 9, true);
1696 }
1697
1698 HWTEST_F(ScreenCaptureServerFunctionTest, OnDeviceRemoved_001, TestSize.Level2)
1699 {
1700 std::shared_ptr<MouseChangeListener> listener = std::make_shared<MouseChangeListener>(screenCaptureServer_);
1701 int32_t inputDeviceId = 9;
1702 listener->OnDeviceRemoved(inputDeviceId, "test");
1703 ASSERT_EQ(inputDeviceId == 9, true);
1704 }
1705
1706 HWTEST_F(ScreenCaptureServerFunctionTest, RegisterMMISystemAbilityListener_001, TestSize.Level2)
1707 {
1708 sptr<ISystemAbilityStatusChange> listener(new (std::nothrow) MMISystemAbilityListener(screenCaptureServer_));
1709 ASSERT_EQ(screenCaptureServer_->RegisterMMISystemAbilityListener(), true);
1710 }
1711
1712 HWTEST_F(ScreenCaptureServerFunctionTest, UnRegisterMMISystemAbilityListener_001, TestSize.Level2)
1713 {
1714 sptr<ISystemAbilityStatusChange> listener(new (std::nothrow) MMISystemAbilityListener(screenCaptureServer_));
1715 ASSERT_EQ(screenCaptureServer_->UnRegisterMMISystemAbilityListener(), true);
1716 }
1717
1718 HWTEST_F(ScreenCaptureServerFunctionTest, OnAddSystemAbility_001, TestSize.Level2)
1719 {
1720 sptr<MMISystemAbilityListener> listener = new MMISystemAbilityListener(screenCaptureServer_);
1721 int32_t systemAbilityId = 10;
1722 std::string deviceId = "9";
1723 listener->OnAddSystemAbility(systemAbilityId, deviceId);
1724 ASSERT_EQ(systemAbilityId == 10, true);
1725 }
1726
1727 HWTEST_F(ScreenCaptureServerFunctionTest, OnAddSystemAbility_002, TestSize.Level2)
1728 {
1729 sptr<MMISystemAbilityListener> listener = new MMISystemAbilityListener(screenCaptureServer_);
1730 int32_t systemAbilityId = 10;
1731 std::string deviceId = "9";
1732 screenCaptureServer_->SetMouseChangeListener(nullptr);
1733 listener->OnAddSystemAbility(systemAbilityId, deviceId);
1734 ASSERT_EQ(systemAbilityId == 10, true);
1735 }
1736
1737 HWTEST_F(ScreenCaptureServerFunctionTest, OnRemoveSystemAbility_001, TestSize.Level2)
1738 {
1739 sptr<MMISystemAbilityListener> listener = new MMISystemAbilityListener(screenCaptureServer_);
1740 int32_t systemAbilityId = 10;
1741 std::string deviceId = "9";
1742 listener->OnRemoveSystemAbility(systemAbilityId, deviceId);
1743 ASSERT_EQ(systemAbilityId == 10, true);
1744 }
1745
1746 HWTEST_F(ScreenCaptureServerFunctionTest, RegisterMouseChangeListener_001, TestSize.Level2)
1747 {
1748 std::string type = "change";
1749 screenCaptureServer_->RegisterMouseChangeListener(type);
1750 ASSERT_EQ(type == "change", true);
1751 }
1752
1753
1754 HWTEST_F(ScreenCaptureServerFunctionTest, RegisterMouseChangeListener_002, TestSize.Level2)
1755 {
1756 std::string type = "change";
1757 screenCaptureServer_->RegisterMouseChangeListener(type);
1758 screenCaptureServer_->RegisterMouseChangeListener(type);
1759 ASSERT_EQ(type == "change", true);
1760 }
1761
1762 HWTEST_F(ScreenCaptureServerFunctionTest, UnRegisterMouseChangeListener_001, TestSize.Level2)
1763 {
1764 std::string type = "change";
1765 screenCaptureServer_->UnRegisterMouseChangeListener(type);
1766 ASSERT_EQ(type == "change", true);
1767 }
1768
1769
1770 HWTEST_F(ScreenCaptureServerFunctionTest, UnRegisterMouseChangeListener_002, TestSize.Level2)
1771 {
1772 std::string type = "change";
1773 screenCaptureServer_->UnRegisterMouseChangeListener(type);
1774 screenCaptureServer_->UnRegisterMouseChangeListener(type);
1775 ASSERT_EQ(type == "change", true);
1776 }
1777
1778 HWTEST_F(ScreenCaptureServerFunctionTest, PostStartScreenCaptureSuccessAction_001, TestSize.Level2)
1779 {
1780 screenCaptureServer_->showCursor_ = false;
1781 screenCaptureServer_->PostStartScreenCaptureSuccessAction();
1782 ASSERT_EQ(screenCaptureServer_->showCursor_ == false, true);
1783 }
1784
1785 HWTEST_F(ScreenCaptureServerFunctionTest, PostStartScreenCaptureSuccessAction_002, TestSize.Level2)
1786 {
1787 screenCaptureServer_->showCursor_ = true;
1788 screenCaptureServer_->PostStartScreenCaptureSuccessAction();
1789 ASSERT_EQ(screenCaptureServer_->showCursor_ == true, true);
1790 }
1791
1792 HWTEST_F(ScreenCaptureServerFunctionTest, SetCanvasRotation_001, TestSize.Level2)
1793 {
1794 int ret = screenCaptureServer_->SetCanvasRotation(true);
1795 ASSERT_EQ(ret, MSERR_OK);
1796 }
1797
1798 HWTEST_F(ScreenCaptureServerFunctionTest, SetCanvasRotation_002, TestSize.Level2)
1799 {
1800 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
1801 int ret = screenCaptureServer_->SetCanvasRotation(true);
1802 ASSERT_EQ(ret, MSERR_OK);
1803 }
1804
1805 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_001, TestSize.Level2)
1806 {
1807 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
1808 screenCaptureServer_->virtualScreenId_ = 0;
1809 int ret = screenCaptureServer_->ResizeCanvas(580, 1280);
1810 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
1811 }
1812
1813 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_002, TestSize.Level2)
1814 {
1815 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1816 int ret = screenCaptureServer_->ResizeCanvas(580, 1280);
1817 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
1818 }
1819
1820 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_003, TestSize.Level2)
1821 {
1822 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1823 int ret = screenCaptureServer_->ResizeCanvas(-580, 1280);
1824 ASSERT_EQ(ret, MSERR_INVALID_VAL);
1825 }
1826
1827 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_004, TestSize.Level2)
1828 {
1829 screenCaptureServer_->virtualScreenId_ = 0;
1830 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1831 int ret = screenCaptureServer_->ResizeCanvas(10241, 1280);
1832 ASSERT_EQ(ret, MSERR_INVALID_VAL);
1833 }
1834
1835 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_005, TestSize.Level2)
1836 {
1837 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1838 int ret = screenCaptureServer_->ResizeCanvas(580, -1280);
1839 ASSERT_EQ(ret, MSERR_INVALID_VAL);
1840 }
1841
1842 HWTEST_F(ScreenCaptureServerFunctionTest, ResizeCanvas_006, TestSize.Level2)
1843 {
1844 screenCaptureServer_->virtualScreenId_ = 0;
1845 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1846 int ret = screenCaptureServer_->ResizeCanvas(580, 4321);
1847 ASSERT_EQ(ret, MSERR_INVALID_VAL);
1848 }
1849
1850 HWTEST_F(ScreenCaptureServerFunctionTest, StopScreenCaptureByEvent_002, TestSize.Level2)
1851 {
1852 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1853 int ret = screenCaptureServer_->StopScreenCaptureByEvent(AVScreenCaptureStateCode::
1854 SCREEN_CAPTURE_STATE_STOPPED_BY_USER);
1855 ASSERT_EQ(ret, MSERR_OK);
1856 }
1857
1858 HWTEST_F(ScreenCaptureServerFunctionTest, StopScreenCaptureByEvent_003, TestSize.Level2)
1859 {
1860 screenCaptureServer_->captureState_ = AVScreenCaptureState::STOPPED;
1861 int ret = screenCaptureServer_->StopScreenCaptureByEvent(AVScreenCaptureStateCode::
1862 SCREEN_CAPTURE_STATE_STOPPED_BY_USER);
1863 ASSERT_EQ(ret, MSERR_OK);
1864 }
1865
1866 HWTEST_F(ScreenCaptureServerFunctionTest, SkipPrivacyMode_001, TestSize.Level2)
1867 {
1868 std::vector<uint64_t> windowIDsVec;
1869 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
1870 int ret = screenCaptureServer_->SkipPrivacyMode(windowIDsVec);
1871 ASSERT_EQ(ret, MSERR_OK);
1872 }
1873
1874 HWTEST_F(ScreenCaptureServerFunctionTest, SetMaxVideoFrameRate_001, TestSize.Level2)
1875 {
1876 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1877 int ret = screenCaptureServer_->SetMaxVideoFrameRate(-1);
1878 ASSERT_EQ(ret, MSERR_INVALID_VAL);
1879 }
1880
1881 HWTEST_F(ScreenCaptureServerFunctionTest, SetMaxVideoFrameRate_002, TestSize.Level2)
1882 {
1883 screenCaptureServer_->virtualScreenId_ = 0;
1884 screenCaptureServer_->captureState_ = AVScreenCaptureState::CREATED;
1885 int ret = screenCaptureServer_->SetMaxVideoFrameRate(5);
1886 ASSERT_NE(ret, MSERR_OK);
1887 }
1888
1889 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneOn_001, TestSize.Level2)
1890 {
1891 screenCaptureServer_->captureConfig_.dataType = DataType::ORIGINAL_STREAM;
1892 int ret = screenCaptureServer_->SetMicrophoneOn();
1893 ASSERT_EQ(ret, MSERR_OK);
1894 }
1895
1896 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneOn_002, TestSize.Level2)
1897 {
1898 screenCaptureServer_->captureConfig_.dataType = DataType::CAPTURE_FILE;
1899 int ret = screenCaptureServer_->SetMicrophoneOn();
1900 ASSERT_EQ(ret, MSERR_OK);
1901 }
1902
1903 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneOff_001, TestSize.Level2)
1904 {
1905 int ret = screenCaptureServer_->SetMicrophoneOff();
1906 ASSERT_EQ(ret, MSERR_OK);
1907 }
1908
1909 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneEnabled_001, TestSize.Level2)
1910 {
1911 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1912 int ret = screenCaptureServer_->SetMicrophoneEnabled(true);
1913 ASSERT_EQ(ret, MSERR_OK);
1914 }
1915
1916 HWTEST_F(ScreenCaptureServerFunctionTest, SetMicrophoneEnabled_002, TestSize.Level2)
1917 {
1918 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1919 int ret = screenCaptureServer_->SetMicrophoneEnabled(false);
1920 ASSERT_EQ(ret, MSERR_OK);
1921 }
1922
1923 HWTEST_F(ScreenCaptureServerFunctionTest, SetSystemScreenRecorderStatus_001, TestSize.Level2)
1924 {
1925 screenCaptureServer_->appName_ =
1926 GetScreenCaptureSystemParam()["const.multimedia.screencapture.dialogconnectionbundlename"];
1927 screenCaptureServer_->SetSystemScreenRecorderStatus(false);
1928 ASSERT_EQ(ScreenCaptureServer::systemScreenRecorderPid_, -1);
1929 }
1930
1931 HWTEST_F(ScreenCaptureServerFunctionTest, SetSystemScreenRecorderStatus_002, TestSize.Level2)
1932 {
1933 screenCaptureServer_->appName_ =
1934 GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"];
1935 screenCaptureServer_->appInfo_.appPid = 15000;
1936 screenCaptureServer_->SetSystemScreenRecorderStatus(true);
1937 ASSERT_EQ(ScreenCaptureServer::systemScreenRecorderPid_, 15000);
1938 }
1939
1940 HWTEST_F(ScreenCaptureServerFunctionTest, SetSystemScreenRecorderStatus_003, TestSize.Level2)
1941 {
1942 ScreenCaptureServer::systemScreenRecorderPid_ = -1;
1943 screenCaptureServer_->appName_ =
1944 GetScreenCaptureSystemParam()["const.multimedia.screencapture.screenrecorderbundlename"];
1945 screenCaptureServer_->appInfo_.appPid = 15000;
1946 screenCaptureServer_->SetSystemScreenRecorderStatus(false);
1947 ASSERT_EQ(ScreenCaptureServer::systemScreenRecorderPid_, -1);
1948 }
1949
1950 HWTEST_F(ScreenCaptureServerFunctionTest, IsSystemScreenRecorder_001, TestSize.Level2)
1951 {
1952 ScreenCaptureServer::systemScreenRecorderPid_ = -1;
1953 bool ret = ScreenCaptureMonitor::GetInstance()->IsSystemScreenRecorder(15000);
1954 ASSERT_EQ(ret, false);
1955 }
1956
1957 HWTEST_F(ScreenCaptureServerFunctionTest, IsSystemScreenRecorder_002, TestSize.Level2)
1958 {
1959 ScreenCaptureServer::systemScreenRecorderPid_ = -1;
1960 bool ret = ScreenCaptureMonitor::GetInstance()->IsSystemScreenRecorder(-1);
1961 ASSERT_EQ(ret, false);
1962 }
1963
1964 HWTEST_F(ScreenCaptureServerFunctionTest, IsSystemScreenRecorderWorking_001, TestSize.Level2)
1965 {
1966 screenCaptureServer_->SetSystemScreenRecorderStatus(false);
1967 bool ret = ScreenCaptureMonitor::GetInstance()->IsSystemScreenRecorderWorking();
1968 ASSERT_EQ(ret, false);
1969 }
1970
1971 HWTEST_F(ScreenCaptureServerFunctionTest, DestroyPopWindow_001, TestSize.Level2)
1972 {
1973 screenCaptureServer_->captureState_ = AVScreenCaptureState::STARTED;
1974 bool ret = screenCaptureServer_->DestroyPopWindow();
1975 ASSERT_EQ(ret, true);
1976 }
1977
1978 HWTEST_F(ScreenCaptureServerFunctionTest, DestroyPopWindow_002, TestSize.Level2)
1979 {
1980 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
1981 bool ret = screenCaptureServer_->DestroyPopWindow();
1982 ASSERT_EQ(ret, true);
1983 }
1984
1985 HWTEST_F(ScreenCaptureServerFunctionTest, DestroyPopWindow_003, TestSize.Level2)
1986 {
1987 screenCaptureServer_->connection_ =
1988 sptr<UIExtensionAbilityConnection>(new (std::nothrow) UIExtensionAbilityConnection(""));
1989 screenCaptureServer_->captureState_ = AVScreenCaptureState::POPUP_WINDOW;
1990 bool ret = screenCaptureServer_->DestroyPopWindow();
1991 ASSERT_EQ(ret, true);
1992 }
1993 } // Media
1994 } // OHOS