1 /* 2 * Copyright (c) 2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <fcntl.h> 17 #include <iostream> 18 #include <string> 19 #include "media_errors.h" 20 #include "screen_capture_unit_test.h" 21 #include "ability_manager_client.h" 22 #include "accesstoken_kit.h" 23 #include "token_setproc.h" 24 25 using namespace OHOS; 26 using namespace OHOS::Media; 27 using namespace testing::ext; 28 using namespace std; 29 using namespace OHOS::Rosen; 30 using namespace OHOS::Media::ScreenCaptureTestParam; 31 32 namespace OHOS { 33 namespace Media { 34 35 /** 36 * @tc.name: screen_capture_save_file_mix_01 37 * @tc.desc: do screencapture 38 * @tc.type: FUNC 39 * @tc.require: 40 */ 41 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_mix_01, TestSize.Level2) 42 { 43 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_01 before"); 44 RecorderInfo recorderInfo; 45 SetRecorderInfo("screen_capture_save_file_mix_01.mp4", recorderInfo); 46 SetConfigFile(config_, recorderInfo); 47 AudioCaptureInfo micCapInfo = { 48 .audioSampleRate = 16000, 49 .audioChannels = 2, 50 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT 51 }; 52 config_.audioInfo.micCapInfo = micCapInfo; 53 AudioCaptureInfo innerCapInfo = { 54 .audioSampleRate = 16000, 55 .audioChannels = 2, 56 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 57 }; 58 config_.audioInfo.innerCapInfo = innerCapInfo; 59 60 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 61 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 62 sleep(RECORDER_TIME); 63 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 64 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 65 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_01 after"); 66 } 67 68 /** 69 * @tc.name: screen_capture_save_file_mix_02 70 * @tc.desc: do screencapture 71 * @tc.type: FUNC 72 * @tc.require: 73 */ 74 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_mix_02, TestSize.Level2) 75 { 76 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_02 before"); 77 RecorderInfo recorderInfo; 78 SetRecorderInfo("screen_capture_save_file_mix_02.mp4", recorderInfo); 79 SetConfigFile(config_, recorderInfo); 80 AudioCaptureInfo micCapInfo = { 81 .audioSampleRate = 16000, 82 .audioChannels = 2, 83 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT 84 }; 85 config_.audioInfo.micCapInfo = micCapInfo; 86 AudioCaptureInfo innerCapInfo = { 87 .audioSampleRate = 16000, 88 .audioChannels = 2, 89 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK 90 }; 91 config_.audioInfo.innerCapInfo = innerCapInfo; 92 93 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 94 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 95 sleep(RECORDER_TIME); 96 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 97 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 98 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_02 after"); 99 } 100 101 /** 102 * @tc.name: screen_capture_save_file_mix_03 103 * @tc.desc: do screencapture 104 * @tc.type: FUNC 105 * @tc.require: 106 */ 107 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_mix_03, TestSize.Level2) 108 { 109 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_03 before"); 110 RecorderInfo recorderInfo; 111 SetRecorderInfo("screen_capture_save_file_mix_03.mp4", recorderInfo); 112 SetConfigFile(config_, recorderInfo); 113 AudioCaptureInfo micCapInfo = { 114 .audioSampleRate = 48000, 115 .audioChannels = 2, 116 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT 117 }; 118 config_.audioInfo.micCapInfo = micCapInfo; 119 AudioCaptureInfo innerCapInfo = { 120 .audioSampleRate = 48000, 121 .audioChannels = 2, 122 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 123 }; 124 config_.audioInfo.innerCapInfo = innerCapInfo; 125 126 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 127 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 128 sleep(RECORDER_TIME); 129 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 130 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 131 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_03 after"); 132 } 133 134 /** 135 * @tc.name: screen_capture_save_file_mix_04 136 * @tc.desc: do screencapture 137 * @tc.type: FUNC 138 * @tc.require: 139 */ 140 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_mix_04, TestSize.Level2) 141 { 142 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_04 before"); 143 RecorderInfo recorderInfo; 144 SetRecorderInfo("screen_capture_save_file_mix_04.mp4", recorderInfo); 145 SetConfigFile(config_, recorderInfo); 146 AudioCaptureInfo micCapInfo = { 147 .audioSampleRate = 48000, 148 .audioChannels = 2, 149 .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT 150 }; 151 config_.audioInfo.micCapInfo = micCapInfo; 152 AudioCaptureInfo innerCapInfo = { 153 .audioSampleRate = 48000, 154 .audioChannels = 2, 155 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK 156 }; 157 config_.audioInfo.innerCapInfo = innerCapInfo; 158 159 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 160 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 161 sleep(RECORDER_TIME); 162 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 163 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 164 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_mix_04 after"); 165 } 166 167 /** 168 * @tc.name: screen_capture_specified_window_file_01 169 * @tc.desc: do screencapture 170 * @tc.type: FUNC 171 * @tc.require: 172 */ 173 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_01, TestSize.Level2) 174 { 175 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_01 before"); 176 std::shared_ptr<ScreenCaptureController> controller = 177 ScreenCaptureControllerFactory::CreateScreenCaptureController(); 178 int32_t sessionId = 0; 179 std::string choice = "false"; 180 controller->ReportAVScreenCaptureUserChoice(sessionId, choice); 181 RecorderInfo recorderInfo; 182 SetRecorderInfo("screen_capture_specified_window_file_01.mp4", recorderInfo); 183 SetConfigFile(config_, recorderInfo); 184 AudioCaptureInfo innerCapInfo = { 185 .audioSampleRate = 16000, 186 .audioChannels = 2, 187 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK 188 }; 189 config_.audioInfo.innerCapInfo = innerCapInfo; 190 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; 191 std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); 192 std::string deviceId = ""; 193 std::vector<OHOS::AAFwk::MissionInfo> missionInfos; 194 auto result = client_->GetMissionInfos(deviceId, 20, missionInfos); 195 MEDIA_LOGI("screen_capture_specified_window_file_01 missionInfos size:%{public}s, result:%{public}d", 196 std::to_string(missionInfos.size()).c_str(), result); 197 for (OHOS::AAFwk::MissionInfo info : missionInfos) { 198 MEDIA_LOGI("screen_capture_specified_window_file_01 missionId : %{public}d", info.id); 199 } 200 if (missionInfos.size() > 0) { 201 config_.videoInfo.videoCapInfo.taskIDs.push_back(missionInfos[0].id); 202 } else { 203 MEDIA_LOGE("screen_capture_specified_window_file_01 GetMissionInfos failed"); 204 } 205 206 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 207 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 208 sleep(RECORDER_TIME); 209 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 210 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 211 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_01 after"); 212 } 213 214 /** 215 * @tc.name: screen_capture_specified_window_file_02 216 * @tc.desc: do screencapture 217 * @tc.type: FUNC 218 * @tc.require: 219 */ 220 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_02, TestSize.Level2) 221 { 222 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_02 before"); 223 RecorderInfo recorderInfo; 224 SetRecorderInfo("screen_capture_specified_window_file_02.mp4", recorderInfo); 225 SetConfigFile(config_, recorderInfo); 226 AudioCaptureInfo innerCapInfo = { 227 .audioSampleRate = 16000, 228 .audioChannels = 2, 229 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK 230 }; 231 config_.audioInfo.innerCapInfo = innerCapInfo; 232 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; 233 std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); 234 std::string deviceId = ""; 235 std::vector<OHOS::AAFwk::MissionInfo> missionInfos; 236 auto result = client_->GetMissionInfos(deviceId, 20, missionInfos); 237 MEDIA_LOGI("screen_capture_specified_window_file_02 missionInfos size:%{public}s, result:%{public}d", 238 std::to_string(missionInfos.size()).c_str(), result); 239 for (OHOS::AAFwk::MissionInfo info : missionInfos) { 240 MEDIA_LOGI("screen_capture_specified_window_file_02 missionId : %{public}d", info.id); 241 } 242 if (missionInfos.size() > 0) { 243 config_.videoInfo.videoCapInfo.taskIDs.push_back(missionInfos[(missionInfos.size()-1)/2].id); 244 } else { 245 MEDIA_LOGE("screen_capture_specified_window_file_02 GetMissionInfos failed"); 246 } 247 248 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 249 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 250 sleep(RECORDER_TIME); 251 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 252 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 253 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_02 after"); 254 } 255 256 /** 257 * @tc.name: screen_capture_specified_window_file_03 258 * @tc.desc: do screencapture 259 * @tc.type: FUNC 260 * @tc.require: 261 */ 262 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_03, TestSize.Level2) 263 { 264 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_03 before"); 265 RecorderInfo recorderInfo; 266 SetRecorderInfo("screen_capture_specified_window_file_03.mp4", recorderInfo); 267 SetConfigFile(config_, recorderInfo); 268 AudioCaptureInfo innerCapInfo = { 269 .audioSampleRate = 16000, 270 .audioChannels = 2, 271 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK 272 }; 273 config_.audioInfo.innerCapInfo = innerCapInfo; 274 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; 275 std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); 276 std::string deviceId = ""; 277 std::vector<OHOS::AAFwk::MissionInfo> missionInfos; 278 auto result = client_->GetMissionInfos(deviceId, 20, missionInfos); 279 MEDIA_LOGI("screen_capture_specified_window_file_03 missionInfos size:%{public}s, result:%{public}d", 280 std::to_string(missionInfos.size()).c_str(), result); 281 for (OHOS::AAFwk::MissionInfo info : missionInfos) { 282 MEDIA_LOGI("screen_capture_specified_window_file_03 missionId : %{public}d", info.id); 283 } 284 if (missionInfos.size() > 0) { 285 config_.videoInfo.videoCapInfo.taskIDs.push_back(missionInfos[missionInfos.size()-1].id); 286 } else { 287 MEDIA_LOGE("screen_capture_specified_window_file_03 GetMissionInfos failed"); 288 } 289 290 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 291 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 292 sleep(RECORDER_TIME); 293 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 294 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 295 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_03 after"); 296 } 297 298 /** 299 * @tc.name: screen_capture_specified_window_file_04 300 * @tc.desc: do screencapture 301 * @tc.type: FUNC 302 * @tc.require: 303 */ 304 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_file_04, TestSize.Level2) 305 { 306 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_04 before"); 307 RecorderInfo recorderInfo; 308 SetRecorderInfo("screen_capture_specified_window_file_04.mp4", recorderInfo); 309 SetConfigFile(config_, recorderInfo); 310 AudioCaptureInfo innerCapInfo = { 311 .audioSampleRate = 16000, 312 .audioChannels = 2, 313 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK 314 }; 315 config_.audioInfo.innerCapInfo = innerCapInfo; 316 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; 317 std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); 318 std::string deviceId = ""; 319 std::vector<OHOS::AAFwk::MissionInfo> missionInfos; 320 auto result = client_->GetMissionInfos(deviceId, 20, missionInfos); 321 MEDIA_LOGI("screen_capture_specified_window_file_04 missionInfos size:%{public}s, result:%{public}d", 322 std::to_string(missionInfos.size()).c_str(), result); 323 if (missionInfos.size() > 0) { 324 for (OHOS::AAFwk::MissionInfo info : missionInfos) { 325 MEDIA_LOGI("screen_capture_specified_window_file_04 missionId:%{public}d", info.id); 326 config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id); 327 } 328 } else { 329 MEDIA_LOGE("screen_capture_specified_window_file_04 GetMissionInfos failed"); 330 } 331 332 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 333 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 334 sleep(RECORDER_TIME); 335 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 336 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 337 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_04 after"); 338 } 339 340 /** 341 * @tc.name: screen_capture_specified_window 342 * @tc.desc: open microphone 343 * @tc.type: FUNC 344 * @tc.require: 345 */ 346 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window, TestSize.Level2) 347 { 348 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window before"); 349 SetConfig(config_); 350 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; 351 std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); 352 std::string deviceId = ""; 353 std::vector<OHOS::AAFwk::MissionInfo> missionInfos; 354 auto result = client_->GetMissionInfos(deviceId, 10, missionInfos); 355 MEDIA_LOGI("screen_capture_specified_window missionInfos size:%{public}s, result:%{public}d", 356 std::to_string(missionInfos.size()).c_str(), result); 357 if (missionInfos.size() > 0) { 358 for (OHOS::AAFwk::MissionInfo info : missionInfos) { 359 MEDIA_LOGI("screen_capture_specified_window missionId:%{public}d", info.id); 360 config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id); 361 } 362 } else { 363 MEDIA_LOGE("screen_capture_specified_window GetMissionInfos failed"); 364 } 365 OpenFile("screen_capture_specified_window"); 366 367 aFlag = 1; 368 vFlag = 1; 369 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 370 ASSERT_NE(nullptr, screenCaptureCb_); 371 bool isMicrophone = true; 372 screenCapture_->SetMicrophoneEnabled(isMicrophone); 373 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 374 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 375 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 376 sleep(RECORDER_TIME); 377 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 378 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 379 CloseFile(); 380 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window after"); 381 } 382 383 /** 384 * @tc.name: screen_capture_specified_window_Rotation 385 * @tc.desc: open microphone 386 * @tc.type: FUNC 387 * @tc.require: 388 */ 389 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_Rotation, TestSize.Level2) 390 { 391 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_Rotation before"); 392 SetConfig(config_); 393 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; 394 std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); 395 std::string deviceId = ""; 396 std::vector<OHOS::AAFwk::MissionInfo> missionInfos; 397 auto result = client_->GetMissionInfos(deviceId, 10, missionInfos); 398 MEDIA_LOGI("screen_capture_specified_window_Rotation missionInfos size:%{public}s, result:%{public}d", 399 std::to_string(missionInfos.size()).c_str(), result); 400 if (missionInfos.size() > 0) { 401 for (OHOS::AAFwk::MissionInfo info : missionInfos) { 402 MEDIA_LOGI("screen_capture_specified_window_Rotation missionId:%{public}d", info.id); 403 config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id); 404 } 405 } else { 406 MEDIA_LOGE("screen_capture_specified_window_Rotation GetMissionInfos failed"); 407 } 408 OpenFile("screen_capture_specified_window_Rotation"); 409 410 aFlag = 1; 411 vFlag = 1; 412 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 413 ASSERT_NE(nullptr, screenCaptureCb_); 414 bool isMicrophone = true; 415 screenCapture_->SetMicrophoneEnabled(isMicrophone); 416 bool canvasRotation = true; 417 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 418 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 419 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 420 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 421 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 422 sleep(RECORDER_TIME); 423 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 424 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 425 CloseFile(); 426 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_Rotation after"); 427 } 428 429 /** 430 * @tc.name: screen_capture_save_file_01 431 * @tc.desc: do screencapture 432 * @tc.type: FUNC 433 * @tc.require: 434 */ 435 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_01, TestSize.Level2) 436 { 437 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_01 before"); 438 RecorderInfo recorderInfo; 439 SetRecorderInfo("screen_capture_get_screen_capture_01.mp4", recorderInfo); 440 SetConfigFile(config_, recorderInfo); 441 AudioCaptureInfo innerCapInfo = { 442 .audioSampleRate = 16000, 443 .audioChannels = 2, 444 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 445 }; 446 config_.audioInfo.innerCapInfo = innerCapInfo; 447 448 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 449 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 450 sleep(RECORDER_TIME); 451 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 452 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 453 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_01 after"); 454 } 455 456 /** 457 * @tc.name: screen_capture_save_file_02 458 * @tc.desc: do screencapture 459 * @tc.type: FUNC 460 * @tc.require: 461 */ 462 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_02, TestSize.Level2) 463 { 464 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_02 before"); 465 RecorderInfo recorderInfo; 466 SetRecorderInfo("screen_capture_get_screen_capture_02.mp4", recorderInfo); 467 SetConfigFile(config_, recorderInfo); 468 AudioCaptureInfo innerCapInfo = { 469 .audioSampleRate = 16000, 470 .audioChannels = 2, 471 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 472 }; 473 AudioCaptureInfo micCapInfoInvalidChannels = { 474 .audioSampleRate = 16000, 475 .audioChannels = 0, 476 .audioSource = AudioCaptureSourceType::MIC 477 }; 478 config_.audioInfo.innerCapInfo = innerCapInfo; 479 config_.audioInfo.micCapInfo = micCapInfoInvalidChannels; 480 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 481 482 AudioCaptureInfo micCapInfoInvalidSampleRate = { 483 .audioSampleRate = 0, 484 .audioChannels = 2, 485 .audioSource = AudioCaptureSourceType::MIC 486 }; 487 SetRecorderInfo("screen_capture_get_screen_capture_02.mp4", recorderInfo); 488 config_.recorderInfo = recorderInfo; 489 config_.audioInfo.micCapInfo = micCapInfoInvalidSampleRate; 490 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 491 492 AudioCaptureInfo micCapInfoIgnored = { 493 .audioSampleRate = 0, 494 .audioChannels = 0, 495 .audioSource = AudioCaptureSourceType::MIC 496 }; 497 SetRecorderInfo("screen_capture_get_screen_capture_02.mp4", recorderInfo); 498 config_.recorderInfo = recorderInfo; 499 config_.audioInfo.micCapInfo = micCapInfoIgnored; 500 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 501 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 502 sleep(RECORDER_TIME); 503 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 504 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 505 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_02 after"); 506 } 507 508 /** 509 * @tc.name: screen_capture_save_file_03 510 * @tc.desc: do screencapture 511 * @tc.type: FUNC 512 * @tc.require: 513 */ 514 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_03, TestSize.Level2) 515 { 516 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_03 before"); 517 RecorderInfo recorderInfo; 518 SetRecorderInfo("screen_capture_get_screen_capture_03.mp4", recorderInfo); 519 SetConfigFile(config_, recorderInfo); 520 AudioCaptureInfo micCapInfo = { 521 .audioSampleRate = 16000, 522 .audioChannels = 2, 523 .audioSource = AudioCaptureSourceType::MIC 524 }; 525 config_.audioInfo.micCapInfo = micCapInfo; 526 AudioCaptureInfo innerCapInfo = { 527 .audioSampleRate = 16000, 528 .audioChannels = 2, 529 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 530 }; 531 config_.audioInfo.innerCapInfo = innerCapInfo; 532 533 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 534 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 535 sleep(RECORDER_TIME); 536 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 537 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 538 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_03 after"); 539 } 540 541 /** 542 * @tc.name: screen_capture_save_file_04 543 * @tc.desc: do screencapture 544 * @tc.type: FUNC 545 * @tc.require: 546 */ 547 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_04, TestSize.Level2) 548 { 549 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_04 before"); 550 RecorderInfo recorderInfo; 551 SetRecorderInfo("screen_capture_get_screen_capture_04.mp4", recorderInfo); 552 SetConfigFile(config_, recorderInfo); 553 AudioCaptureInfo innerCapInfo = { 554 .audioSampleRate = 16000, 555 .audioChannels = 2, 556 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 557 }; 558 config_.audioInfo.innerCapInfo = innerCapInfo; 559 560 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 561 EXPECT_NE(MSERR_OK, screenCapture_->StartScreenCapture()); 562 sleep(RECORDER_TIME); 563 EXPECT_NE(MSERR_OK, screenCapture_->StopScreenCapture()); 564 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 565 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_04 after"); 566 } 567 568 /** 569 * @tc.name: screen_capture_save_file_05 570 * @tc.desc: open microphone 571 * @tc.type: FUNC 572 * @tc.require: 573 */ 574 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_05, TestSize.Level2) 575 { 576 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_05 before"); 577 SetConfig(config_); 578 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 579 OpenFile("screen_capture_get_screen_capture_05"); 580 581 aFlag = 1; 582 vFlag = 1; 583 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 584 ASSERT_NE(nullptr, screenCaptureCb_); 585 bool isMicrophone = true; 586 screenCapture_->SetMicrophoneEnabled(isMicrophone); 587 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 588 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 589 EXPECT_NE(MSERR_OK, screenCapture_->StartScreenRecording()); 590 sleep(RECORDER_TIME); 591 EXPECT_NE(MSERR_OK, screenCapture_->StopScreenRecording()); 592 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 593 CloseFile(); 594 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_05 after"); 595 } 596 597 /** 598 * @tc.name: screen_capture_save_file_Rotation 599 * @tc.desc: do screencapture 600 * @tc.type: FUNC 601 * @tc.require: 602 */ 603 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation, TestSize.Level2) 604 { 605 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation before"); 606 SetConfig(config_); 607 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 608 OpenFile("screen_capture_save_file_Rotation"); 609 610 aFlag = 1; 611 vFlag = 1; 612 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 613 ASSERT_NE(nullptr, screenCaptureCb_); 614 bool isMicrophone = true; 615 screenCapture_->SetMicrophoneEnabled(isMicrophone); 616 bool canvasRotation = true; 617 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 618 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 619 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 620 EXPECT_NE(MSERR_OK, screenCapture_->StartScreenRecording()); 621 sleep(RECORDER_TIME); 622 EXPECT_NE(MSERR_OK, screenCapture_->StopScreenRecording()); 623 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 624 CloseFile(); 625 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation after"); 626 } 627 628 /** 629 * @tc.name: screen_capture_save_file_Rotation_01 630 * @tc.desc: do screencapture 631 * @tc.type: FUNC 632 * @tc.require: 633 */ 634 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_01, TestSize.Level2) 635 { 636 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_01 before"); 637 RecorderInfo recorderInfo; 638 SetRecorderInfo("screen_capture_get_screen_capture_Rotation_01.mp4", recorderInfo); 639 SetConfigFile(config_, recorderInfo); 640 AudioCaptureInfo innerCapInfo = { 641 .audioSampleRate = 16000, 642 .audioChannels = 2, 643 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 644 }; 645 config_.audioInfo.innerCapInfo = innerCapInfo; 646 config_.videoInfo.videoCapInfo.videoFrameWidth = 2720; 647 config_.videoInfo.videoCapInfo.videoFrameHeight = 1260; 648 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 649 bool canvasRotation = true; 650 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 651 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 652 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 653 sleep(RECORDER_TIME); 654 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 655 canvasRotation = false; 656 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 657 sleep(RECORDER_TIME); 658 canvasRotation = true; 659 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 660 sleep(RECORDER_TIME); 661 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 662 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 663 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_01 after"); 664 } 665 666 /** 667 * @tc.name: screen_capture_save_file_Rotation_02 668 * @tc.desc: do screencapture 669 * @tc.type: FUNC 670 * @tc.require: 671 */ 672 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_02, TestSize.Level2) 673 { 674 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_02 before"); 675 RecorderInfo recorderInfo; 676 SetRecorderInfo("screen_capture_get_screen_capture_Rotation_02.mp4", recorderInfo); 677 SetConfigFile(config_, recorderInfo); 678 AudioCaptureInfo innerCapInfo = { 679 .audioSampleRate = 16000, 680 .audioChannels = 2, 681 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 682 }; 683 config_.audioInfo.innerCapInfo = innerCapInfo; 684 config_.videoInfo.videoCapInfo.videoFrameWidth = 2720; 685 config_.videoInfo.videoCapInfo.videoFrameHeight = 1260; 686 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 687 bool canvasRotation = true; 688 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 689 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 690 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 691 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 692 sleep(RECORDER_TIME); 693 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 694 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 695 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_02 after"); 696 } 697 698 /** 699 * @tc.name: screen_capture_save_file_Rotation_03 700 * @tc.desc: do screencapture 701 * @tc.type: FUNC 702 * @tc.require: 703 */ 704 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_Rotation_03, TestSize.Level2) 705 { 706 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_03 before"); 707 RecorderInfo recorderInfo; 708 SetRecorderInfo("screen_capture_get_screen_capture_Rotation_03.mp4", recorderInfo); 709 SetConfigFile(config_, recorderInfo); 710 AudioCaptureInfo innerCapInfo = { 711 .audioSampleRate = 16000, 712 .audioChannels = 2, 713 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 714 }; 715 config_.audioInfo.innerCapInfo = innerCapInfo; 716 config_.videoInfo.videoCapInfo.videoFrameWidth = 2720; 717 config_.videoInfo.videoCapInfo.videoFrameHeight = 1260; 718 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 719 bool canvasRotation = false; 720 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 721 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 722 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 723 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 724 sleep(RECORDER_TIME); 725 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 726 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 727 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_Rotation_03 after"); 728 } 729 730 /** 731 * @tc.name: screen_capture_specified_screen_file_01 732 * @tc.desc: do screencapture with specified screen 733 * @tc.type: FUNC 734 * @tc.require: 735 */ 736 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_01, TestSize.Level2) 737 { 738 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_01 before"); 739 RecorderInfo recorderInfo; 740 SetRecorderInfo("screen_capture_specified_screen_file_01.mp4", recorderInfo); 741 SetConfigFile(config_, recorderInfo); 742 AudioCaptureInfo innerCapInfo = { 743 .audioSampleRate = 16000, 744 .audioChannels = 2, 745 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 746 }; 747 config_.audioInfo.innerCapInfo = innerCapInfo; 748 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_SCREEN; 749 750 std::vector<sptr<Screen>> screens; 751 DMError ret = ScreenManager::GetInstance().GetAllScreens(screens); 752 MEDIA_LOGI("screen_capture_specified_screen_file_01 screens size:%{public}s, ret:%{public}d", 753 std::to_string(screens.size()).c_str(), ret); 754 if (screens.size() > 0) { 755 MEDIA_LOGI("screen_capture_specified_screen_file_01 screens id(size-1):%{public}s", 756 std::to_string(screens[screens.size() - 1]->GetId()).c_str()); 757 MEDIA_LOGI("screen_capture_specified_screen_file_01 screens id(size-1):%{public}s", 758 std::to_string(screens[0]->GetId()).c_str()); 759 config_.videoInfo.videoCapInfo.displayId = screens[0]->GetId(); 760 } else { 761 MEDIA_LOGE("screen_capture_specified_screen_file_01 GetAllScreens failed"); 762 } 763 764 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 765 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 766 sleep(RECORDER_TIME); 767 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 768 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 769 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_01 after"); 770 } 771 772 /** 773 * @tc.name: screen_capture_specified_screen_file_02 774 * @tc.desc: do screencapture with specified screen 775 * @tc.type: FUNC 776 * @tc.require: 777 */ 778 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_02, TestSize.Level2) 779 { 780 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_02 before"); 781 RecorderInfo recorderInfo; 782 SetRecorderInfo("screen_capture_specified_screen_file_02.mp4", recorderInfo); 783 SetConfigFile(config_, recorderInfo); 784 AudioCaptureInfo innerCapInfo = { 785 .audioSampleRate = 48000, 786 .audioChannels = 2, 787 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 788 }; 789 config_.audioInfo.innerCapInfo = innerCapInfo; 790 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_SCREEN; 791 792 std::vector<sptr<Screen>> screens; 793 DMError ret = ScreenManager::GetInstance().GetAllScreens(screens); 794 MEDIA_LOGI("screen_capture_specified_screen_file_02 screens size:%{public}s, ret:%{public}d", 795 std::to_string(screens.size()).c_str(), ret); 796 if (screens.size() > 0) { 797 MEDIA_LOGI("screen_capture_specified_screen_file_02 screens id(size-1):%{public}s", 798 std::to_string(screens[screens.size() - 1]->GetId()).c_str()); 799 MEDIA_LOGI("screen_capture_specified_screen_file_02 screens id(size-1):%{public}s", 800 std::to_string(screens[0]->GetId()).c_str()); 801 config_.videoInfo.videoCapInfo.displayId = screens[0]->GetId(); 802 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 803 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 804 sleep(RECORDER_TIME); 805 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 806 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 807 } else { 808 MEDIA_LOGE("screen_capture_specified_screen_file_02 GetAllScreens failed"); 809 } 810 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_02 after"); 811 } 812 813 /** 814 * @tc.name: screen_capture_specified_screen_file_03 815 * @tc.desc: do screencapture with specified screen 816 * @tc.type: FUNC 817 * @tc.require: 818 */ 819 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_03, TestSize.Level2) 820 { 821 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_03 before"); 822 RecorderInfo recorderInfo; 823 SetRecorderInfo("screen_capture_specified_screen_file_03.mp4", recorderInfo); 824 SetConfigFile(config_, recorderInfo); 825 AudioCaptureInfo micCapInfo = { 826 .audioSampleRate = 16000, 827 .audioChannels = 2, 828 .audioSource = AudioCaptureSourceType::MIC 829 }; 830 config_.audioInfo.micCapInfo = micCapInfo; 831 AudioCaptureInfo innerCapInfo = { 832 .audioSampleRate = 16000, 833 .audioChannels = 2, 834 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 835 }; 836 config_.audioInfo.innerCapInfo = innerCapInfo; 837 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_SCREEN; 838 839 std::vector<sptr<Screen>> screens; 840 DMError ret = ScreenManager::GetInstance().GetAllScreens(screens); 841 MEDIA_LOGI("screen_capture_specified_screen_file_03 screens size:%{public}s, ret:%{public}d", 842 std::to_string(screens.size()).c_str(), ret); 843 if (screens.size() > 0) { 844 MEDIA_LOGI("screen_capture_specified_screen_file_03 screens id(size-1):%{public}s", 845 std::to_string(screens[screens.size() - 1]->GetId()).c_str()); 846 MEDIA_LOGI("screen_capture_specified_screen_file_03 screens id(size-1):%{public}s", 847 std::to_string(screens[0]->GetId()).c_str()); 848 config_.videoInfo.videoCapInfo.displayId = screens[0]->GetId(); 849 } else { 850 MEDIA_LOGE("screen_capture_specified_screen_file_03 GetAllScreens failed"); 851 } 852 853 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 854 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 855 sleep(RECORDER_TIME); 856 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 857 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 858 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_03 after"); 859 } 860 861 /** 862 * @tc.name: screen_capture_specified_screen_01 863 * @tc.desc: screen capture specified screen test 864 * @tc.type: FUNC 865 * @tc.require: 866 */ 867 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_01, TestSize.Level1) 868 { 869 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_01 before"); 870 SetConfig(config_); 871 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 872 std::vector<sptr<Screen>> screens; 873 DMError ret = ScreenManager::GetInstance().GetAllScreens(screens); 874 MEDIA_LOGI("screen_capture_specified_screen_01 screens size:%{public}s, ret:%{public}d", 875 std::to_string(screens.size()).c_str(), ret); 876 if (screens.size() > 0) { 877 MEDIA_LOGI("screen_capture_specified_screen_01 screens id(size-1):%{public}s", 878 std::to_string(screens[screens.size() - 1]->GetId()).c_str()); 879 MEDIA_LOGI("screen_capture_specified_screen_01 screens id(size-1):%{public}s", 880 std::to_string(screens[0]->GetId()).c_str()); 881 config_.videoInfo.videoCapInfo.displayId = screens[0]->GetId(); 882 } else { 883 MEDIA_LOGE("screen_capture_specified_screen_01 GetAllScreens failed"); 884 } 885 OpenFile("screen_capture_specified_screen_01"); 886 887 aFlag = 1; 888 vFlag = 1; 889 bool isMicrophone = true; 890 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 891 ASSERT_NE(nullptr, screenCaptureCb_); 892 screenCapture_->SetMicrophoneEnabled(isMicrophone); 893 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 894 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 895 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 896 sleep(RECORDER_TIME); 897 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 898 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 899 CloseFile(); 900 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_01 after"); 901 } 902 903 /** 904 * @tc.name: screen_capture_check_param_01 905 * @tc.desc: do screencapture 906 * @tc.type: FUNC 907 * @tc.require: 908 */ 909 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_01, TestSize.Level2) 910 { 911 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_01 before"); 912 RecorderInfo recorderInfo; 913 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 914 SetConfigFile(config_, recorderInfo); 915 AudioCaptureInfo micCapInfoRateSmall = { 916 .audioSampleRate = 0, 917 .audioChannels = 2, 918 .audioSource = AudioCaptureSourceType::MIC 919 }; 920 config_.audioInfo.micCapInfo = micCapInfoRateSmall; 921 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 922 923 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 924 config_.recorderInfo = recorderInfo; 925 config_.audioInfo.micCapInfo.audioSampleRate = 8000000; 926 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 927 928 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 929 config_.recorderInfo = recorderInfo; 930 config_.audioInfo.micCapInfo.audioSampleRate = 16000; 931 config_.audioInfo.micCapInfo.audioChannels = 0; 932 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 933 934 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 935 config_.recorderInfo = recorderInfo; 936 config_.audioInfo.micCapInfo.audioChannels = 200; 937 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 938 939 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 940 config_.recorderInfo = recorderInfo; 941 config_.audioInfo.micCapInfo.audioChannels = 2; 942 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::APP_PLAYBACK; 943 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 944 945 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 946 config_.recorderInfo = recorderInfo; 947 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_INVALID; 948 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 949 950 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_01 after"); 951 } 952 953 /** 954 * @tc.name: screen_capture_check_param_02 955 * @tc.desc: do screencapture 956 * @tc.type: FUNC 957 * @tc.require: 958 */ 959 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_02, TestSize.Level2) 960 { 961 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_02 before"); 962 RecorderInfo recorderInfo; 963 SetRecorderInfo("screen_capture_check_param_02.mp4", recorderInfo); 964 SetConfigFile(config_, recorderInfo); 965 AudioCaptureInfo micCapInfo = { 966 .audioSampleRate = 16000, 967 .audioChannels = 2, 968 .audioSource = AudioCaptureSourceType::MIC 969 }; 970 config_.audioInfo.micCapInfo = micCapInfo; 971 AudioEncInfo audioEncInfoBitSmall = { 972 .audioBitrate = 0, 973 .audioCodecformat = AudioCodecFormat::AAC_LC 974 }; 975 config_.audioInfo.audioEncInfo = audioEncInfoBitSmall; 976 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 977 978 SetRecorderInfo("screen_capture_check_param_02.mp4", recorderInfo); 979 config_.recorderInfo = recorderInfo; 980 config_.audioInfo.audioEncInfo.audioBitrate = 4800000; 981 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 982 983 SetRecorderInfo("screen_capture_check_param_02.mp4", recorderInfo); 984 config_.recorderInfo = recorderInfo; 985 config_.audioInfo.audioEncInfo.audioBitrate = 48000; 986 config_.audioInfo.audioEncInfo.audioCodecformat = AudioCodecFormat::AUDIO_CODEC_FORMAT_BUTT; 987 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 988 989 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_02 after"); 990 } 991 992 /** 993 * @tc.name: screen_capture_check_param_03 994 * @tc.desc: do screencapture 995 * @tc.type: FUNC 996 * @tc.require: 997 */ 998 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_03, TestSize.Level2) 999 { 1000 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_03 before"); 1001 RecorderInfo recorderInfo; 1002 SetRecorderInfo("screen_capture_check_param_03.mp4", recorderInfo); 1003 SetConfigFile(config_, recorderInfo); 1004 AudioCaptureInfo micCapInfo = { 1005 .audioSampleRate = 16000, 1006 .audioChannels = 2, 1007 .audioSource = AudioCaptureSourceType::MIC 1008 }; 1009 config_.audioInfo.micCapInfo = micCapInfo; 1010 VideoCaptureInfo videoCapInfoWidthSmall = { 1011 .videoFrameWidth = 0, 1012 .videoFrameHeight = 1080, 1013 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA 1014 }; 1015 config_.videoInfo.videoCapInfo = videoCapInfoWidthSmall; 1016 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1017 1018 SetRecorderInfo("screen_capture_check_param_03.mp4", recorderInfo); 1019 config_.recorderInfo = recorderInfo; 1020 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 1021 config_.videoInfo.videoCapInfo.videoFrameHeight = 0; 1022 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1023 1024 SetRecorderInfo("screen_capture_check_param_03.mp4", recorderInfo); 1025 config_.recorderInfo = recorderInfo; 1026 config_.videoInfo.videoCapInfo.videoFrameHeight = 1080; 1027 config_.videoInfo.videoCapInfo.videoSource = VideoSourceType::VIDEO_SOURCE_BUTT; 1028 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1029 1030 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_03 after"); 1031 } 1032 1033 /** 1034 * @tc.name: screen_capture_check_param_04 1035 * @tc.desc: do screencapture 1036 * @tc.type: FUNC 1037 * @tc.require: 1038 */ 1039 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_04, TestSize.Level2) 1040 { 1041 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_04 before"); 1042 RecorderInfo recorderInfo; 1043 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1044 SetConfigFile(config_, recorderInfo); 1045 AudioCaptureInfo micCapInfo = { 1046 .audioSampleRate = 16000, 1047 .audioChannels = 2, 1048 .audioSource = AudioCaptureSourceType::MIC 1049 }; 1050 config_.audioInfo.micCapInfo = micCapInfo; 1051 VideoEncInfo videoEncInfoBitSmall = { 1052 .videoCodec = VideoCodecFormat::MPEG4, 1053 .videoBitrate = 0, 1054 .videoFrameRate = 30 1055 }; 1056 config_.videoInfo.videoEncInfo = videoEncInfoBitSmall; 1057 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1058 1059 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1060 config_.recorderInfo = recorderInfo; 1061 config_.videoInfo.videoEncInfo.videoBitrate = 30000001; 1062 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1063 1064 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1065 config_.recorderInfo = recorderInfo; 1066 config_.videoInfo.videoEncInfo.videoBitrate = 2000000; 1067 config_.videoInfo.videoEncInfo.videoFrameRate = 0; 1068 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1069 1070 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1071 config_.recorderInfo = recorderInfo; 1072 config_.videoInfo.videoEncInfo.videoFrameRate = 300; 1073 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1074 1075 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1076 config_.recorderInfo = recorderInfo; 1077 config_.videoInfo.videoEncInfo.videoFrameRate = 30; 1078 config_.videoInfo.videoEncInfo.videoCodec = VideoCodecFormat::VIDEO_CODEC_FORMAT_BUTT; 1079 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1080 1081 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_04 after"); 1082 } 1083 1084 /** 1085 * @tc.name: screen_capture_check_param_05 1086 * @tc.desc: do screencapture 1087 * @tc.type: FUNC 1088 * @tc.require: 1089 */ 1090 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_05, TestSize.Level2) 1091 { 1092 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_05 before"); 1093 RecorderInfo recorderInfo; 1094 SetRecorderInfo("screen_capture_check_param_05.mp4", recorderInfo); 1095 SetConfigFile(config_, recorderInfo); 1096 AudioCaptureInfo innerCapInfo = { 1097 .audioSampleRate = 16000, 1098 .audioChannels = 2, 1099 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 1100 }; 1101 config_.audioInfo.innerCapInfo = innerCapInfo; 1102 config_.dataType = DataType::ENCODED_STREAM; 1103 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1104 1105 SetRecorderInfo("screen_capture_check_param_05.mp4", recorderInfo); 1106 config_.recorderInfo = recorderInfo; 1107 config_.dataType = DataType::INVAILD; 1108 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1109 1110 SetRecorderInfo("screen_capture_check_param_05.mp4", recorderInfo); 1111 config_.recorderInfo = recorderInfo; 1112 config_.dataType = DataType::CAPTURE_FILE; 1113 config_.captureMode = CaptureMode::CAPTURE_INVAILD; 1114 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1115 1116 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_05 after"); 1117 } 1118 1119 /** 1120 * @tc.name: screen_capture_check_param_06 1121 * @tc.desc: do screencapture 1122 * @tc.type: FUNC 1123 * @tc.require: 1124 */ 1125 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_06, TestSize.Level2) 1126 { 1127 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_06 before"); 1128 RecorderInfo recorderInfo; 1129 SetRecorderInfo("screen_capture_check_param_06.mp4", recorderInfo); 1130 recorderInfo.fileFormat = "avi"; // native default m4a, capi avi 1131 SetConfigFile(config_, recorderInfo); 1132 AudioCaptureInfo innerCapInfo = { 1133 .audioSampleRate = 16000, 1134 .audioChannels = 2, 1135 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 1136 }; 1137 config_.audioInfo.innerCapInfo = innerCapInfo; 1138 screenCapture_->Init(config_); // not check 1139 config_.recorderInfo.fileFormat = "m4a"; 1140 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1141 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_06 after"); 1142 } 1143 1144 /** 1145 * @tc.name: screen_capture_check_param_07 1146 * @tc.desc: do screencapture 1147 * @tc.type: FUNC 1148 * @tc.require: 1149 */ 1150 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_07, TestSize.Level2) 1151 { 1152 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_07 before"); 1153 RecorderInfo recorderInfo; 1154 SetRecorderInfo("screen_capture_check_param_07.mp4", recorderInfo); 1155 SetConfigFile(config_, recorderInfo); 1156 AudioCaptureInfo innerCapInfo = { 1157 .audioSampleRate = 16000, 1158 .audioChannels = 2, 1159 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 1160 }; 1161 AudioCaptureInfo micCapInfo = { 1162 .audioSampleRate = 48000, 1163 .audioChannels = 2, 1164 .audioSource = AudioCaptureSourceType::MIC 1165 }; 1166 config_.audioInfo.innerCapInfo = innerCapInfo; 1167 config_.audioInfo.micCapInfo = micCapInfo; 1168 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1169 1170 SetRecorderInfo("screen_capture_check_param_07.mp4", recorderInfo); 1171 config_.recorderInfo = recorderInfo; 1172 config_.audioInfo.micCapInfo.audioSampleRate = 16000; 1173 config_.audioInfo.micCapInfo.audioChannels = 1; 1174 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1175 1176 SetRecorderInfo("screen_capture_check_param_07.mp4", recorderInfo); 1177 config_.recorderInfo = recorderInfo; 1178 config_.audioInfo.micCapInfo.audioSampleRate = 48000; 1179 config_.audioInfo.micCapInfo.audioChannels = 1; 1180 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1181 1182 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_07 after"); 1183 } 1184 1185 /** 1186 * @tc.name: screen_capture_video_configure_0001 1187 * @tc.desc: init with videoFrameWidth -1 1188 * @tc.type: FUNC 1189 * @tc.require: 1190 */ 1191 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0001, TestSize.Level2) 1192 { 1193 SetConfig(config_); 1194 config_.videoInfo.videoCapInfo.videoFrameWidth = -1; 1195 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1196 1197 bool isMicrophone = false; 1198 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1199 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1200 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1201 } 1202 1203 /** 1204 * @tc.name: screen_capture_video_configure_0002 1205 * @tc.desc: init with videoFrameHeight -1 1206 * @tc.type: FUNC 1207 * @tc.require: 1208 */ 1209 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0002, TestSize.Level2) 1210 { 1211 SetConfig(config_); 1212 config_.videoInfo.videoCapInfo.videoFrameHeight = -1; 1213 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1214 1215 bool isMicrophone = false; 1216 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1217 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1218 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1219 } 1220 1221 /** 1222 * @tc.name: screen_capture_video_configure_0003 1223 * @tc.desc: init with videoSource yuv 1224 * @tc.type: FUNC 1225 * @tc.require: 1226 */ 1227 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0003, TestSize.Level2) 1228 { 1229 SetConfig(config_); 1230 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV; 1231 1232 bool isMicrophone = false; 1233 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1234 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1235 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1236 } 1237 1238 /** 1239 * @tc.name: screen_capture_video_configure_0004 1240 * @tc.desc: init with videoSource es 1241 * @tc.type: FUNC 1242 * @tc.require: 1243 */ 1244 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0004, TestSize.Level0) 1245 { 1246 SetConfig(config_); 1247 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_ES; 1248 1249 bool isMicrophone = false; 1250 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1251 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1252 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1253 } 1254 1255 /** 1256 * @tc.name: screen_capture_without_audio_data 1257 * @tc.desc: close microphone 1258 * @tc.type: FUNC 1259 * @tc.require: 1260 */ 1261 HWTEST_F(ScreenCaptureUnitTest, screen_capture_without_audio_data, TestSize.Level2) 1262 { 1263 SetConfig(config_); 1264 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1265 OpenFile("screen_capture_without_audio_data"); 1266 1267 aFlag = 0; 1268 vFlag = 1; 1269 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1270 ASSERT_NE(nullptr, screenCaptureCb_); 1271 bool isMicrophone = false; 1272 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1273 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1274 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1275 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1276 sleep(RECORDER_TIME); 1277 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1278 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1279 CloseFile(); 1280 } 1281 1282 /** 1283 * @tc.name: screen_capture_audio_configure_0001 1284 * @tc.desc: init with audioSampleRate -1 1285 * @tc.type: FUNC 1286 * @tc.require: 1287 */ 1288 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0001, TestSize.Level2) 1289 { 1290 SetConfig(config_); 1291 config_.audioInfo.micCapInfo.audioSampleRate = -1; 1292 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1293 1294 bool isMicrophone = true; 1295 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1296 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1297 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1298 } 1299 1300 /** 1301 * @tc.name: screen_capture_audio_configure_0002 1302 * @tc.desc: init with audioChannels -1 1303 * @tc.type: FUNC 1304 * @tc.require: 1305 */ 1306 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0002, TestSize.Level2) 1307 { 1308 SetConfig(config_); 1309 config_.audioInfo.micCapInfo.audioChannels = -1; 1310 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1311 1312 bool isMicrophone = true; 1313 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1314 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1315 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1316 } 1317 1318 /** 1319 * @tc.name: screen_capture_audio_configure_0003 1320 * @tc.desc: init with audioSource SOURCE_INVALID 1321 * @tc.type: FUNC 1322 * @tc.require: 1323 */ 1324 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0003, TestSize.Level2) 1325 { 1326 SetConfig(config_); 1327 config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID; 1328 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1329 1330 bool isMicrophone = true; 1331 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1332 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1333 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1334 } 1335 1336 /** 1337 * @tc.name: screen_capture_avconfigure 1338 * @tc.desc: init with both audioinfo and videoinfo invaild 1339 * @tc.type: FUNC 1340 * @tc.require: 1341 */ 1342 HWTEST_F(ScreenCaptureUnitTest, screen_capture_avconfigure, TestSize.Level2) 1343 { 1344 SetConfig(config_); 1345 config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID; 1346 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV; 1347 1348 bool isMicrophone = true; 1349 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1350 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1351 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1352 } 1353 1354 /** 1355 * @tc.name: screen_capture_with_audio_data 1356 * @tc.desc: open microphone 1357 * @tc.type: FUNC 1358 * @tc.require: 1359 */ 1360 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_audio_data, TestSize.Level2) 1361 { 1362 SetConfig(config_); 1363 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1364 OpenFile("screen_capture_with_audio_data"); 1365 1366 aFlag = 1; 1367 vFlag = 1; 1368 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1369 ASSERT_NE(nullptr, screenCaptureCb_); 1370 bool isMicrophone = true; 1371 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1372 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1373 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1374 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1375 sleep(RECORDER_TIME); 1376 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1377 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1378 CloseFile(); 1379 } 1380 1381 /** 1382 * @tc.name: screen_capture_captureMode_0001 1383 * @tc.desc: screen capture with captureMode -1 1384 * @tc.type: FUNC 1385 * @tc.require: 1386 */ 1387 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0001, TestSize.Level2) 1388 { 1389 SetConfig(config_); 1390 config_.captureMode = static_cast<CaptureMode>(-1); 1391 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1392 1393 bool isMicrophone = true; 1394 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1395 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1396 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1397 } 1398 1399 /** 1400 * @tc.name: screen_capture_captureMode_0002 1401 * @tc.desc: screen capture with captureMode 5 1402 * @tc.type: FUNC 1403 * @tc.require: 1404 */ 1405 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0002, TestSize.Level2) 1406 { 1407 SetConfig(config_); 1408 config_.captureMode = static_cast<CaptureMode>(5); 1409 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1410 1411 bool isMicrophone = true; 1412 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1413 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1414 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1415 } 1416 1417 /** 1418 * @tc.name: screen_capture_init_datatype_0001 1419 * @tc.desc: screen capture init with ENCODED_STREAM 1420 * @tc.type: FUNC 1421 * @tc.require: 1422 */ 1423 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0001, TestSize.Level2) 1424 { 1425 SetConfig(config_); 1426 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1427 config_.dataType = ENCODED_STREAM; 1428 1429 bool isMicrophone = true; 1430 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1431 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1432 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1433 } 1434 1435 /** 1436 * @tc.name: screen_capture_init_datatype_0002 1437 * @tc.desc: screen capture init with CAPTURE_FILE 1438 * @tc.type: FUNC 1439 * @tc.require: 1440 */ 1441 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0002, TestSize.Level2) 1442 { 1443 SetConfig(config_); 1444 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1445 config_.dataType = CAPTURE_FILE; 1446 1447 bool isMicrophone = true; 1448 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1449 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1450 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1451 } 1452 1453 /** 1454 * @tc.name: screen_capture_init_datatype_0003 1455 * @tc.desc: screen capture init with INVAILD 1456 * @tc.type: FUNC 1457 * @tc.require: 1458 */ 1459 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0003, TestSize.Level2) 1460 { 1461 SetConfig(config_); 1462 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1463 config_.dataType = INVAILD; 1464 1465 bool isMicrophone = true; 1466 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1467 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1468 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1469 } 1470 1471 /** 1472 * @tc.name: screen_capture_audioSampleRate_48000 1473 * @tc.desc: screen capture with audioSampleRate 48000 1474 * @tc.type: FUNC 1475 * @tc.require: 1476 */ 1477 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audioSampleRate_48000, TestSize.Level2) 1478 { 1479 SetConfig(config_); 1480 config_.audioInfo.micCapInfo.audioSampleRate = 48000; 1481 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1482 1483 aFlag = 1; 1484 vFlag = 1; 1485 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1486 ASSERT_NE(nullptr, screenCaptureCb_); 1487 bool isMicrophone = true; 1488 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1489 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1490 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1491 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1492 sleep(RECORDER_TIME); 1493 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1494 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1495 } 1496 1497 /** 1498 * @tc.name: screen_capture_video_size_0001 1499 * @tc.desc: screen capture with 160x160 1500 * @tc.type: FUNC 1501 * @tc.require: 1502 */ 1503 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0001, TestSize.Level2) 1504 { 1505 SetConfig(config_); 1506 config_.videoInfo.videoCapInfo.videoFrameWidth = 160; 1507 config_.videoInfo.videoCapInfo.videoFrameHeight = 160; 1508 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1509 1510 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0001.yuv"; 1511 vFile = fopen(name.c_str(), "w+"); 1512 if (vFile == nullptr) { 1513 cout << "vFile video open failed, " << strerror(errno) << endl; 1514 } 1515 1516 aFlag = 1; 1517 vFlag = 1; 1518 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1519 ASSERT_NE(nullptr, screenCaptureCb_); 1520 bool isMicrophone = true; 1521 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1522 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1523 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1524 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1525 sleep(RECORDER_TIME); 1526 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1527 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1528 CloseFile(); 1529 } 1530 1531 /** 1532 * @tc.name: screen_capture_video_size_0002 1533 * @tc.desc: screen capture with 640x480 1534 * @tc.type: FUNC 1535 * @tc.require: 1536 */ 1537 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0002, TestSize.Level2) 1538 { 1539 SetConfig(config_); 1540 config_.videoInfo.videoCapInfo.videoFrameWidth = 640; 1541 config_.videoInfo.videoCapInfo.videoFrameHeight = 480; 1542 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1543 1544 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0002.yuv"; 1545 vFile = fopen(name.c_str(), "w+"); 1546 if (vFile == nullptr) { 1547 cout << "vFile video open failed, " << strerror(errno) << endl; 1548 } 1549 1550 aFlag = 1; 1551 vFlag = 1; 1552 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1553 ASSERT_NE(nullptr, screenCaptureCb_); 1554 bool isMicrophone = true; 1555 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1556 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1557 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1558 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1559 sleep(RECORDER_TIME); 1560 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1561 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1562 CloseFile(); 1563 } 1564 1565 /** 1566 * @tc.name: screen_capture_video_size_0003 1567 * @tc.desc: screen capture with 1920x1080 1568 * @tc.type: FUNC 1569 * @tc.require: 1570 */ 1571 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0003, TestSize.Level2) 1572 { 1573 SetConfig(config_); 1574 config_.videoInfo.videoCapInfo.videoFrameWidth = 1920; 1575 config_.videoInfo.videoCapInfo.videoFrameHeight = 1080; 1576 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1577 1578 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0003.yuv"; 1579 vFile = fopen(name.c_str(), "w+"); 1580 if (vFile == nullptr) { 1581 cout << "vFile video open failed, " << strerror(errno) << endl; 1582 } 1583 1584 aFlag = 1; 1585 vFlag = 1; 1586 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1587 ASSERT_NE(nullptr, screenCaptureCb_); 1588 bool isMicrophone = true; 1589 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1590 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1591 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1592 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1593 sleep(RECORDER_TIME); 1594 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1595 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1596 CloseFile(); 1597 } 1598 1599 /** 1600 * @tc.name: screen_capture_from_display 1601 * @tc.desc: screen capture from display 1602 * @tc.type: FUNC 1603 * @tc.require: 1604 */ 1605 HWTEST_F(ScreenCaptureUnitTest, screen_capture_from_display, TestSize.Level0) 1606 { 1607 SetConfig(config_); 1608 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1609 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync(); 1610 ASSERT_NE(display, nullptr); 1611 cout << "get displayinfo: " << endl; 1612 cout << "width: " << display->GetWidth() << "; height: " << display->GetHeight() << "; density: " << 1613 display->GetDpi() << "; refreshRate: " << display->GetRefreshRate() << endl; 1614 1615 config_.videoInfo.videoCapInfo.videoFrameWidth = display->GetWidth(); 1616 config_.videoInfo.videoCapInfo.videoFrameHeight = display->GetHeight(); 1617 1618 aFlag = 1; 1619 vFlag = 1; 1620 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1621 ASSERT_NE(nullptr, screenCaptureCb_); 1622 bool isMicrophone = true; 1623 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1624 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1625 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1626 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1627 sleep(RECORDER_TIME); 1628 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1629 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1630 } 1631 1632 /** 1633 * @tc.name: screen_capture_buffertest_0001 1634 * @tc.desc: screen capture buffer test 1635 * @tc.type: FUNC 1636 * @tc.require: 1637 */ 1638 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0001, TestSize.Level2) 1639 { 1640 SetConfig(config_); 1641 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1642 1643 bool isMicrophone = true; 1644 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1645 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1646 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1647 int index = 200; 1648 int index_video_frame = 0; 1649 audioLoop_ = std::make_unique<std::thread>(&ScreenCaptureUnitTest::AudioLoopWithoutRelease, this); 1650 while (index) { 1651 int32_t fence = 0; 1652 int64_t timestamp = 0; 1653 OHOS::Rect damage; 1654 sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage); 1655 if (surfacebuffer != nullptr) { 1656 int32_t length = surfacebuffer->GetSize(); 1657 MEDIA_LOGD("index video:%{public}d, videoBufferLen:%{public}d, timestamp:%{public}" PRId64 1658 ", size:%{public}d", index_video_frame++, surfacebuffer->GetSize(), timestamp, length); 1659 } else { 1660 MEDIA_LOGE("AcquireVideoBuffer failed"); 1661 } 1662 index--; 1663 } 1664 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1665 if (audioLoop_ != nullptr && audioLoop_->joinable()) { 1666 audioLoop_->join(); 1667 audioLoop_.reset(); 1668 audioLoop_ = nullptr; 1669 } 1670 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1671 } 1672 1673 /** 1674 * @tc.name: screen_capture_buffertest_0002 1675 * @tc.desc: screen capture buffer test 1676 * @tc.type: FUNC 1677 * @tc.require: 1678 */ 1679 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0002, TestSize.Level2) 1680 { 1681 SetConfig(config_); 1682 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1683 1684 bool isMicrophone = true; 1685 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1686 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1687 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1688 int index = 10; 1689 int index_video_frame = 0; 1690 audioLoop_ = std::make_unique<std::thread>(&ScreenCaptureUnitTest::AudioLoop, this); 1691 while (index) { 1692 int32_t fence = 0; 1693 int64_t timestamp = 0; 1694 OHOS::Rect damage; 1695 sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage); 1696 if (surfacebuffer != nullptr) { 1697 int32_t length = surfacebuffer->GetSize(); 1698 MEDIA_LOGD("index video:%{public}d, videoBufferLen:%{public}d, timestamp:%{public}" PRId64 1699 ", size:%{public}d", index_video_frame++, surfacebuffer->GetSize(), timestamp, length); 1700 screenCapture_->ReleaseVideoBuffer(); 1701 } else { 1702 MEDIA_LOGE("AcquireVideoBuffer failed"); 1703 } 1704 index--; 1705 } 1706 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1707 if (audioLoop_ != nullptr && audioLoop_->joinable()) { 1708 audioLoop_->join(); 1709 audioLoop_.reset(); 1710 audioLoop_ = nullptr; 1711 } 1712 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1713 } 1714 1715 /** 1716 * @tc.name: screen_capture_buffertest_0003 1717 * @tc.desc: screen capture buffer test 1718 * @tc.type: FUNC 1719 * @tc.require: 1720 */ 1721 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0003, TestSize.Level2) 1722 { 1723 SetConfig(config_); 1724 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1725 1726 aFlag = 0; 1727 vFlag = 1; 1728 bool isMicrophone = true; 1729 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1730 ASSERT_NE(nullptr, screenCaptureCb_); 1731 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1732 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1733 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1734 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1735 sleep(RECORDER_TIME * 2); 1736 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1737 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1738 } 1739 1740 /** 1741 * @tc.name: screen_capture_buffertest_0004 1742 * @tc.desc: screen capture buffer test 1743 * @tc.type: FUNC 1744 * @tc.require: 1745 */ 1746 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0004, TestSize.Level2) 1747 { 1748 SetConfig(config_); 1749 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1750 1751 aFlag = 1; 1752 vFlag = 0; 1753 bool isMicrophone = true; 1754 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1755 ASSERT_NE(nullptr, screenCaptureCb_); 1756 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1757 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1758 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1759 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1760 sleep(RECORDER_TIME * 2); 1761 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1762 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1763 } 1764 1765 /** 1766 * @tc.name: screen_capture_buffertest_0005 1767 * @tc.desc: screen capture buffer test 1768 * @tc.type: FUNC 1769 * @tc.require: 1770 */ 1771 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0005, TestSize.Level2) 1772 { 1773 SetConfig(config_); 1774 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1775 1776 aFlag = 0; 1777 vFlag = 0; 1778 bool isMicrophone = true; 1779 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1780 ASSERT_NE(nullptr, screenCaptureCb_); 1781 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1782 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1783 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1784 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1785 sleep(RECORDER_TIME * 2); 1786 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1787 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1788 } 1789 1790 /** 1791 * @tc.name: screen_capture_buffertest_Rotation 1792 * @tc.desc: screen capture buffer test 1793 * @tc.type: FUNC 1794 * @tc.require: 1795 */ 1796 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_Rotation, TestSize.Level2) 1797 { 1798 SetConfig(config_); 1799 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1800 1801 aFlag = 0; 1802 vFlag = 0; 1803 bool isMicrophone = true; 1804 bool canvasRotation = true; 1805 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1806 ASSERT_NE(nullptr, screenCaptureCb_); 1807 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1808 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 1809 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1810 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1811 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1812 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 1813 sleep(RECORDER_TIME * 2); 1814 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1815 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1816 } 1817 1818 /** 1819 * @tc.name: screen_capture_mic_open_close_open 1820 * @tc.desc: screen capture mic test 1821 * @tc.type: FUNC 1822 * @tc.require: 1823 */ 1824 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_open_close_open, TestSize.Level2) 1825 { 1826 SetConfig(config_); 1827 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1828 1829 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_mic_open_close_open.pcm"; 1830 aFile = fopen(name.c_str(), "w+"); 1831 if (aFile == nullptr) { 1832 cout << "aFile audio open failed, " << strerror(errno) << endl; 1833 } 1834 1835 aFlag = 1; 1836 vFlag = 1; 1837 bool isMicrophone = true; 1838 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1839 ASSERT_NE(nullptr, screenCaptureCb_); 1840 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1841 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1842 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1843 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1844 sleep(RECORDER_TIME * 2); 1845 isMicrophone = false; 1846 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1847 sleep(RECORDER_TIME); 1848 isMicrophone = true; 1849 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1850 sleep(RECORDER_TIME); 1851 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1852 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1853 CloseFile(); 1854 } 1855 1856 /** 1857 * @tc.name: screen_capture_mic_close_open_close 1858 * @tc.desc: screen capture mic test 1859 * @tc.type: FUNC 1860 * @tc.require: 1861 */ 1862 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_close_open_close, TestSize.Level2) 1863 { 1864 SetConfig(config_); 1865 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1866 1867 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_mic_close_open_close.pcm"; 1868 aFile = fopen(name.c_str(), "w+"); 1869 if (aFile == nullptr) { 1870 cout << "aFile audio open failed, " << strerror(errno) << endl; 1871 } 1872 1873 aFlag = 1; 1874 vFlag = 1; 1875 bool isMicrophone = false; 1876 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1877 ASSERT_NE(nullptr, screenCaptureCb_); 1878 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1879 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1880 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1881 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1882 sleep(RECORDER_TIME * 2); 1883 isMicrophone = true; 1884 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1885 sleep(RECORDER_TIME); 1886 isMicrophone = false; 1887 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1888 sleep(RECORDER_TIME); 1889 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1890 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1891 CloseFile(); 1892 } 1893 1894 /** 1895 * @tc.name: screen_capture_with_surface_01 1896 * @tc.desc: do screencapture 1897 * @tc.type: FUNC 1898 * @tc.require: 1899 */ 1900 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_01, TestSize.Level2) 1901 { 1902 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 before"); 1903 SetConfig(config_); 1904 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 1905 config_.videoInfo.videoCapInfo.videoFrameHeight = 1280; 1906 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1907 bool isMicrophone = true; 1908 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1909 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 CreateRecorder"); 1910 std::shared_ptr<Recorder> recorder = nullptr; 1911 recorder = RecorderFactory::CreateRecorder(); 1912 int32_t videoSourceId = 0; 1913 EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId)); 1914 EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4)); 1915 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264)); 1916 EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1280)); 1917 EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30)); 1918 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000)); 1919 OpenFileFd("screen_capture_with_surface_01.mp4"); 1920 ASSERT_TRUE(outputFd_ >= 0); 1921 EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_)); 1922 EXPECT_EQ(MSERR_OK, recorder->Prepare()); 1923 sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId); 1924 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1925 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer)); 1926 EXPECT_EQ(MSERR_OK, recorder->Start()); 1927 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 recorder Start"); 1928 sleep(RECORDER_TIME); 1929 EXPECT_EQ(MSERR_OK, recorder->Stop(true)); 1930 EXPECT_EQ(MSERR_OK, recorder->Reset()); 1931 EXPECT_EQ(MSERR_OK, recorder->Release()); 1932 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1933 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1934 CloseFile(); 1935 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 after"); 1936 } 1937 1938 /** 1939 * @tc.name: screen_capture_with_surface_02 1940 * @tc.desc: do screencapture 1941 * @tc.type: FUNC 1942 * @tc.require: 1943 */ 1944 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_02, TestSize.Level2) 1945 { 1946 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 before"); 1947 SetConfig(config_); 1948 config_.videoInfo.videoCapInfo.videoFrameWidth = 480; 1949 config_.videoInfo.videoCapInfo.videoFrameHeight = 640; 1950 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1951 bool isMicrophone = true; 1952 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1953 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 CreateRecorder"); 1954 std::shared_ptr<Recorder> recorder = nullptr; 1955 recorder = RecorderFactory::CreateRecorder(); 1956 int32_t videoSourceId = 0; 1957 EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId)); 1958 EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4)); 1959 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264)); 1960 EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 480, 640)); 1961 EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30)); 1962 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000)); 1963 OpenFileFd("screen_capture_with_surface_02.mp4"); 1964 ASSERT_TRUE(outputFd_ >= 0); 1965 EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_)); 1966 EXPECT_EQ(MSERR_OK, recorder->Prepare()); 1967 sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId); 1968 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1969 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer)); 1970 EXPECT_EQ(MSERR_OK, recorder->Start()); 1971 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 recorder Start"); 1972 sleep(RECORDER_TIME); 1973 EXPECT_EQ(MSERR_OK, recorder->Stop(true)); 1974 EXPECT_EQ(MSERR_OK, recorder->Reset()); 1975 EXPECT_EQ(MSERR_OK, recorder->Release()); 1976 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1977 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1978 CloseFile(); 1979 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 after"); 1980 } 1981 1982 /** 1983 * @tc.name: screen_capture_buffertest_resize_01 1984 * @tc.desc: screen capture buffer test 1985 * @tc.type: FUNC 1986 * @tc.require: 1987 */ 1988 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_resize_01, TestSize.Level2) 1989 { 1990 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_01 before"); 1991 SetConfig(config_); 1992 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1993 1994 aFlag = 1; 1995 vFlag = 1; 1996 bool isMicrophone = false; 1997 1998 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1999 ASSERT_NE(nullptr, screenCaptureCb_); 2000 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2001 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2002 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2003 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2004 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2005 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2006 sleep(RECORDER_TIME); 2007 cout << "screenCapture_->ResizeCanvas start 1" << endl; 2008 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2009 cout << "screenCapture_->ResizeCanvas end 1" << endl; 2010 sleep(RECORDER_TIME); 2011 cout << "screenCapture_->ResizeCanvas start 2" << endl; 2012 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(1980, 3520)); 2013 cout << "screenCapture_->ResizeCanvas end 2" << endl; 2014 sleep(RECORDER_TIME); 2015 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2016 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2017 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2018 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_01 after"); 2019 } 2020 2021 /** 2022 * @tc.name: screen_capture_buffertest_resize_02 2023 * @tc.desc: screen capture buffer test 2024 * @tc.type: FUNC 2025 * @tc.require: 2026 */ 2027 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_resize_02, TestSize.Level2) 2028 { 2029 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_02 before"); 2030 SetConfig(config_); 2031 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2032 2033 aFlag = 1; 2034 vFlag = 1; 2035 bool isMicrophone = false; 2036 2037 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2038 ASSERT_NE(nullptr, screenCaptureCb_); 2039 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2040 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2041 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2042 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2043 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2044 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2045 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2046 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2047 sleep(RECORDER_TIME); 2048 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2049 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2050 sleep(RECORDER_TIME); 2051 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2052 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2053 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2054 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2055 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_02 after"); 2056 } 2057 2058 /** 2059 * @tc.name: screen_capture_with_surface_resize_show_size 2060 * @tc.desc: do screencapture 2061 * @tc.type: FUNC 2062 * @tc.require: 2063 */ 2064 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_resize_show_size, TestSize.Level2) 2065 { 2066 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_resize_show_size before"); 2067 SetConfig(config_); 2068 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 2069 config_.videoInfo.videoCapInfo.videoFrameHeight = 1280; 2070 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2071 bool isMicrophone = false; 2072 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2073 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2074 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2075 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2076 2077 sptr<OHOS::Surface> consumer = OHOS::Surface::CreateSurfaceAsConsumer(); 2078 consumer->SetDefaultUsage(BUFFER_USAGE_CPU_READ | BUFFER_USAGE_MEM_MMZ_CACHE); 2079 auto producer = consumer->GetProducer(); 2080 auto producerSurface = OHOS::Surface::CreateSurfaceAsProducer(producer); 2081 2082 sptr<IBufferConsumerListener> surfaceCb = OHOS::sptr<ScreenCapBufferDemoConsumerListener>::MakeSptr(consumer); 2083 consumer->RegisterConsumerListener(surfaceCb); 2084 2085 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(producerSurface)); 2086 sleep(RECORDER_TIME); 2087 cout << "screenCapture_->ResizeCanvas start 1" << endl; 2088 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2089 cout << "screenCapture_->ResizeCanvas end 1" << endl; 2090 sleep(RECORDER_TIME); 2091 cout << "screenCapture_->ResizeCanvas start 2" << endl; 2092 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(1980, 3520)); 2093 cout << "screenCapture_->ResizeCanvas end 2" << endl; 2094 sleep(RECORDER_TIME); 2095 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2096 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2097 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2098 CloseFile(); 2099 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_resize_show_size after"); 2100 } 2101 2102 /** 2103 * @tc.name: screen_capture_save_file_resize 2104 * @tc.desc: do screencapture 2105 * @tc.type: FUNC 2106 * @tc.require: 2107 */ 2108 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_resize, TestSize.Level2) 2109 { 2110 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_resize before"); 2111 RecorderInfo recorderInfo; 2112 SetRecorderInfo("screen_capture_save_file_resize.mp4", recorderInfo); 2113 SetConfigFile(config_, recorderInfo); 2114 AudioCaptureInfo innerCapInfo = { 2115 .audioSampleRate = 16000, 2116 .audioChannels = 2, 2117 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 2118 }; 2119 config_.audioInfo.innerCapInfo = innerCapInfo; 2120 bool isMicrophone = false; 2121 2122 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2123 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2124 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2125 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2126 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 2127 sleep(RECORDER_TIME); 2128 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2129 sleep(RECORDER_TIME); 2130 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 2131 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2132 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2133 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_resize after"); 2134 } 2135 2136 /** 2137 * @tc.name: screen_capture_save_file_skip_privacy 2138 * @tc.desc: do screencapture 2139 * @tc.type: FUNC 2140 * @tc.require: 2141 */ 2142 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_skip_privacy, TestSize.Level2) 2143 { 2144 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy before"); 2145 RecorderInfo recorderInfo; 2146 SetRecorderInfo("screen_capture_save_file_skip_privacy.mp4", recorderInfo); 2147 SetConfigFile(config_, recorderInfo); 2148 AudioCaptureInfo innerCapInfo = { 2149 .audioSampleRate = 16000, 2150 .audioChannels = 2, 2151 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 2152 }; 2153 config_.audioInfo.innerCapInfo = innerCapInfo; 2154 vector<int> windowIds = {-1, 2, 5}; 2155 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2156 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2157 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2158 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 2159 sleep(RECORDER_TIME); 2160 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2161 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2162 #else 2163 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2164 #endif 2165 sleep(RECORDER_TIME); 2166 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 2167 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2168 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2169 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy after"); 2170 } 2171 2172 /** 2173 * @tc.name: screen_capture_save_file_skip_privacy_01 2174 * @tc.desc: screen capture buffer test 2175 * @tc.type: FUNC 2176 * @tc.require: 2177 */ 2178 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_skip_privacy_01, TestSize.Level2) 2179 { 2180 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy_01 before"); 2181 SetConfig(config_); 2182 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2183 2184 aFlag = 1; 2185 vFlag = 1; 2186 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2187 ASSERT_NE(nullptr, screenCaptureCb_); 2188 vector<int> windowIds = {-1, 2, 5}; 2189 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2190 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2191 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2192 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2193 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2194 sleep(RECORDER_TIME); 2195 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2196 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2197 #else 2198 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2199 #endif 2200 windowIds = {-1, 2, 7}; 2201 sleep(RECORDER_TIME); 2202 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2203 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2204 #else 2205 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2206 #endif 2207 sleep(RECORDER_TIME); 2208 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2209 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2210 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2211 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy_01 after"); 2212 } 2213 2214 /** 2215 * @tc.name: screen_capture_with_surface_skip_privacy_01 2216 * @tc.desc: do screencapture 2217 * @tc.type: FUNC 2218 * @tc.require: 2219 */ 2220 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_skip_privacy_01, TestSize.Level2) 2221 { 2222 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_skip_privacy_01 before"); 2223 SetConfig(config_); 2224 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 2225 config_.videoInfo.videoCapInfo.videoFrameHeight = 1280; 2226 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2227 bool isMicrophone = false; 2228 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2229 vector<int> windowIds = {-1, 2, 5}; 2230 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2231 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2232 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2233 sptr<OHOS::Surface> consumer = OHOS::Surface::CreateSurfaceAsConsumer(); 2234 consumer->SetDefaultUsage(BUFFER_USAGE_CPU_READ | BUFFER_USAGE_MEM_MMZ_CACHE); 2235 auto producer = consumer->GetProducer(); 2236 auto producerSurface = OHOS::Surface::CreateSurfaceAsProducer(producer); 2237 sptr<IBufferConsumerListener> surfaceCb = OHOS::sptr<ScreenCapBufferDemoConsumerListener>::MakeSptr(consumer); 2238 consumer->RegisterConsumerListener(surfaceCb); 2239 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(producerSurface)); 2240 sleep(RECORDER_TIME); 2241 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2242 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2243 #else 2244 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2245 #endif 2246 sleep(RECORDER_TIME); 2247 windowIds = {-1, 2, 6}; 2248 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2249 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2250 #else 2251 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2252 #endif 2253 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2254 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2255 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2256 CloseFile(); 2257 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_skip_privacy_01 after"); 2258 } 2259 2260 /** 2261 * @tc.name: screen_capture_buffertest_max_frame_rate_01 2262 * @tc.desc: screen capture buffer test 2263 * @tc.type: FUNC 2264 * @tc.require: 2265 */ 2266 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_max_frame_rate_01, TestSize.Level2) 2267 { 2268 SetConfig(config_); 2269 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2270 2271 aFlag = 1; 2272 vFlag = 1; 2273 bool isMicrophone = false; 2274 2275 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2276 ASSERT_NE(nullptr, screenCaptureCb_); 2277 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2278 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2279 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2280 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2281 sleep(RECORDER_TIME_5); 2282 int32_t totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2283 double averageFrameRate_01 = ((double)totalFrameNum)/RECORDER_TIME_5; 2284 EXPECT_EQ(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(5)); 2285 sleep(RECORDER_TIME_5); 2286 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2287 double averageFrameRate_02 = ((double)totalFrameNum)/RECORDER_TIME_5; 2288 sleep(RECORDER_TIME_5); 2289 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2290 double averageFrameRate_03 = ((double)totalFrameNum)/RECORDER_TIME_5; 2291 EXPECT_EQ(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(15)); 2292 sleep(RECORDER_TIME_5); 2293 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2294 double averageFrameRate_04 = ((double)totalFrameNum)/RECORDER_TIME_5; 2295 sleep(RECORDER_TIME_5); 2296 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2297 double averageFrameRate_05 = ((double)totalFrameNum)/RECORDER_TIME_5; 2298 EXPECT_EQ(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(90)); 2299 sleep(RECORDER_TIME_5); 2300 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2301 double averageFrameRate_06 = ((double)totalFrameNum)/RECORDER_TIME_5; 2302 sleep(RECORDER_TIME_5); 2303 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2304 double averageFrameRate_07 = ((double)totalFrameNum)/RECORDER_TIME_5; 2305 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2306 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2307 EXPECT_TRUE(averageFrameRate_02 < (5 * EXCESS_RATE)); 2308 EXPECT_TRUE(averageFrameRate_03 < (5 * EXCESS_RATE)); 2309 EXPECT_TRUE(averageFrameRate_04 < (15 * EXCESS_RATE)); 2310 EXPECT_TRUE(averageFrameRate_05 < (15 * EXCESS_RATE)); 2311 EXPECT_TRUE(averageFrameRate_06 < (90 * EXCESS_RATE)); 2312 EXPECT_TRUE(averageFrameRate_07 < (90 * EXCESS_RATE)); 2313 cout << "SetMaxVideoFrameRate end averageFrameRate_01: " << averageFrameRate_01 << ",set 5,averageFrameRate_02: " 2314 << averageFrameRate_02 << " averageFrameRate_03: " << averageFrameRate_03 << ",set 15,averageFrameRate_04: " 2315 << averageFrameRate_04 << " averageFrameRate_05: " << averageFrameRate_05 << ",set 90,averageFrameRate_06: " 2316 << averageFrameRate_06 << " averageFrameRate_07: " << averageFrameRate_07 << endl; 2317 } 2318 2319 /** 2320 * @tc.name: screen_capture_buffertest_max_frame_rate_02 2321 * @tc.desc: screen capture buffer test 2322 * @tc.type: FUNC 2323 * @tc.require: 2324 */ 2325 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_max_frame_rate_02, TestSize.Level2) 2326 { 2327 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_max_frame_rate_02 before"); 2328 SetConfig(config_); 2329 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2330 2331 aFlag = 1; 2332 vFlag = 1; 2333 bool isMicrophone = false; 2334 2335 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2336 ASSERT_NE(nullptr, screenCaptureCb_); 2337 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2338 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2339 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2340 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2341 sleep(RECORDER_TIME_5); 2342 int32_t totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2343 double averageFrameRate_01 = ((double)totalFrameNum)/RECORDER_TIME_5; 2344 EXPECT_NE(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(-10)); 2345 sleep(RECORDER_TIME_5); 2346 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2347 double averageFrameRate_02 = ((double)totalFrameNum)/RECORDER_TIME_5; 2348 sleep(RECORDER_TIME_5); 2349 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2350 double averageFrameRate_03 = ((double)totalFrameNum)/RECORDER_TIME_5; 2351 EXPECT_EQ(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(1000000000)); 2352 sleep(RECORDER_TIME_5); 2353 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2354 double averageFrameRate_04 = ((double)totalFrameNum)/RECORDER_TIME_5; 2355 sleep(RECORDER_TIME_5); 2356 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2357 double averageFrameRate_05 = ((double)totalFrameNum)/RECORDER_TIME_5; 2358 2359 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2360 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2361 cout << "SetMaxVideoFrameRate end averageFrameRate_01: " << averageFrameRate_01 2362 << ",set -10,averageFrameRate_02: " << averageFrameRate_02 << " averageFrameRate_03: " 2363 << averageFrameRate_03 << ",set 1000000000,averageFrameRate_04: " << averageFrameRate_04 2364 << " averageFrameRate_05: " << averageFrameRate_05 << endl; 2365 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_max_frame_rate_02 after"); 2366 } 2367 2368 /** 2369 * @tc.name: screen_capture_with_surface_update_surface 2370 * @tc.desc: do screencapture 2371 * @tc.type: FUNC 2372 * @tc.require: 2373 */ 2374 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_update_surface, TestSize.Level2) 2375 { 2376 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_update_surface before"); 2377 SetConfig(config_); 2378 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 2379 config_.videoInfo.videoCapInfo.videoFrameHeight = 1280; 2380 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2381 bool isMicrophone = false; 2382 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2383 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2384 2385 sptr<OHOS::Surface> consumer = OHOS::Surface::CreateSurfaceAsConsumer(); 2386 consumer->SetDefaultUsage(BUFFER_USAGE_CPU_READ | BUFFER_USAGE_MEM_MMZ_CACHE); 2387 auto producer = consumer->GetProducer(); 2388 auto producerSurface = OHOS::Surface::CreateSurfaceAsProducer(producer); 2389 2390 sptr<IBufferConsumerListener> surfaceCb = OHOS::sptr<ScreenCapBufferDemoConsumerListener>::MakeSptr(consumer); 2391 consumer->RegisterConsumerListener(surfaceCb); 2392 2393 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(producerSurface)); 2394 sleep(RECORDER_TIME); 2395 MEDIA_LOGI("screenCapture_->UpdateSurface start 1"); 2396 EXPECT_EQ(MSERR_OK, screenCapture_->UpdateSurface(producerSurface)); 2397 MEDIA_LOGI("screenCapture_->UpdateSurface end 1"); 2398 sleep(RECORDER_TIME); 2399 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2400 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2401 CloseFile(); 2402 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_update_surface after"); 2403 } 2404 2405 /** 2406 * @tc.name: screen_capture_specified_window_file_01 2407 * @tc.desc: do screencapture 2408 * @tc.type: FUNC 2409 * @tc.require: 2410 */ 2411 HWTEST_F(ScreenCaptureUnitTest, screen_capture_config_paramer_01, TestSize.Level2) 2412 { 2413 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_config_paramer_01 before"); 2414 std::shared_ptr<ScreenCaptureController> controller = 2415 ScreenCaptureControllerFactory::CreateScreenCaptureController(); 2416 int32_t sessionId = 0; 2417 std::string resultStr = ""; 2418 controller->GetAVScreenCaptureConfigurableParameters(sessionId, resultStr); 2419 RecorderInfo recorderInfo; 2420 SetRecorderInfo("screen_capture_specified_window_file_01.mp4", recorderInfo); 2421 SetConfigFile(config_, recorderInfo); 2422 AudioCaptureInfo innerCapInfo = { 2423 .audioSampleRate = 16000, 2424 .audioChannels = 2, 2425 .audioSource = AudioCaptureSourceType::ALL_PLAYBACK 2426 }; 2427 config_.audioInfo.innerCapInfo = innerCapInfo; 2428 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW; 2429 std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance(); 2430 std::string deviceId = ""; 2431 std::vector<OHOS::AAFwk::MissionInfo> missionInfos; 2432 auto result = client_->GetMissionInfos(deviceId, 20, missionInfos); 2433 MEDIA_LOGI("screen_capture_specified_window_file_01 missionInfos size:%{public}s, result:%{public}d", 2434 std::to_string(missionInfos.size()).c_str(), result); 2435 for (OHOS::AAFwk::MissionInfo info : missionInfos) { 2436 MEDIA_LOGI("screen_capture_specified_window_file_01 missionId : %{public}d", info.id); 2437 } 2438 if (missionInfos.size() > 0) { 2439 config_.videoInfo.videoCapInfo.taskIDs.push_back(missionInfos[0].id); 2440 } else { 2441 MEDIA_LOGE("screen_capture_specified_window_file_01 GetMissionInfos failed"); 2442 } 2443 2444 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2445 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 2446 sleep(RECORDER_TIME); 2447 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 2448 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2449 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_file_01 after"); 2450 } 2451 } // namespace Media 2452 } // namespace OHOS