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