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 } else { 815 MEDIA_LOGE("screen_capture_specified_screen_file_02 GetAllScreens failed"); 816 } 817 818 config_.videoInfo.videoCapInfo.displayId = screens[0]->GetId(); 819 820 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 821 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 822 sleep(RECORDER_TIME); 823 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 824 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 825 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_02 after"); 826 } 827 828 /** 829 * @tc.name: screen_capture_specified_screen_file_03 830 * @tc.desc: do screencapture with specified screen 831 * @tc.type: FUNC 832 * @tc.require: 833 */ 834 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_file_03, TestSize.Level2) 835 { 836 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_03 before"); 837 RecorderInfo recorderInfo; 838 SetRecorderInfo("screen_capture_specified_screen_file_03.mp4", recorderInfo); 839 SetConfigFile(config_, recorderInfo); 840 AudioCaptureInfo micCapInfo = { 841 .audioSampleRate = 16000, 842 .audioChannels = 2, 843 .audioSource = AudioCaptureSourceType::MIC 844 }; 845 config_.audioInfo.micCapInfo = micCapInfo; 846 AudioCaptureInfo innerCapInfo = { 847 .audioSampleRate = 16000, 848 .audioChannels = 2, 849 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 850 }; 851 config_.audioInfo.innerCapInfo = innerCapInfo; 852 config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_SCREEN; 853 854 std::vector<sptr<Screen>> screens; 855 DMError ret = ScreenManager::GetInstance().GetAllScreens(screens); 856 MEDIA_LOGI("screen_capture_specified_screen_file_03 screens size:%{public}s, ret:%{public}d", 857 std::to_string(screens.size()).c_str(), ret); 858 if (screens.size() > 0) { 859 MEDIA_LOGI("screen_capture_specified_screen_file_03 screens id(size-1):%{public}s", 860 std::to_string(screens[screens.size() - 1]->GetId()).c_str()); 861 MEDIA_LOGI("screen_capture_specified_screen_file_03 screens id(size-1):%{public}s", 862 std::to_string(screens[0]->GetId()).c_str()); 863 config_.videoInfo.videoCapInfo.displayId = screens[0]->GetId(); 864 } else { 865 MEDIA_LOGE("screen_capture_specified_screen_file_03 GetAllScreens failed"); 866 } 867 868 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 869 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 870 sleep(RECORDER_TIME); 871 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 872 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 873 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_file_03 after"); 874 } 875 876 /** 877 * @tc.name: screen_capture_specified_screen_01 878 * @tc.desc: screen capture specified screen test 879 * @tc.type: FUNC 880 * @tc.require: 881 */ 882 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_screen_01, TestSize.Level1) 883 { 884 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_01 before"); 885 SetConfig(config_); 886 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 887 std::vector<sptr<Screen>> screens; 888 DMError ret = ScreenManager::GetInstance().GetAllScreens(screens); 889 MEDIA_LOGI("screen_capture_specified_screen_01 screens size:%{public}s, ret:%{public}d", 890 std::to_string(screens.size()).c_str(), ret); 891 if (screens.size() > 0) { 892 MEDIA_LOGI("screen_capture_specified_screen_01 screens id(size-1):%{public}s", 893 std::to_string(screens[screens.size() - 1]->GetId()).c_str()); 894 MEDIA_LOGI("screen_capture_specified_screen_01 screens id(size-1):%{public}s", 895 std::to_string(screens[0]->GetId()).c_str()); 896 config_.videoInfo.videoCapInfo.displayId = screens[0]->GetId(); 897 } else { 898 MEDIA_LOGE("screen_capture_specified_screen_01 GetAllScreens failed"); 899 } 900 OpenFile("screen_capture_specified_screen_01"); 901 902 aFlag = 1; 903 vFlag = 1; 904 bool isMicrophone = true; 905 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 906 ASSERT_NE(nullptr, screenCaptureCb_); 907 screenCapture_->SetMicrophoneEnabled(isMicrophone); 908 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 909 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 910 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 911 sleep(3); 912 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 913 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 914 CloseFile(); 915 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_screen_01 after"); 916 } 917 918 /** 919 * @tc.name: screen_capture_check_param_01 920 * @tc.desc: do screencapture 921 * @tc.type: FUNC 922 * @tc.require: 923 */ 924 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_01, TestSize.Level2) 925 { 926 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_01 before"); 927 RecorderInfo recorderInfo; 928 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 929 SetConfigFile(config_, recorderInfo); 930 AudioCaptureInfo micCapInfoRateSmall = { 931 .audioSampleRate = 0, 932 .audioChannels = 2, 933 .audioSource = AudioCaptureSourceType::MIC 934 }; 935 config_.audioInfo.micCapInfo = micCapInfoRateSmall; 936 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 937 938 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 939 config_.recorderInfo = recorderInfo; 940 config_.audioInfo.micCapInfo.audioSampleRate = 8000000; 941 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 942 943 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 944 config_.recorderInfo = recorderInfo; 945 config_.audioInfo.micCapInfo.audioSampleRate = 16000; 946 config_.audioInfo.micCapInfo.audioChannels = 0; 947 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 948 949 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 950 config_.recorderInfo = recorderInfo; 951 config_.audioInfo.micCapInfo.audioChannels = 200; 952 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 953 954 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 955 config_.recorderInfo = recorderInfo; 956 config_.audioInfo.micCapInfo.audioChannels = 2; 957 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::APP_PLAYBACK; 958 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 959 960 SetRecorderInfo("screen_capture_check_param_01.mp4", recorderInfo); 961 config_.recorderInfo = recorderInfo; 962 config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_INVALID; 963 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 964 965 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_01 after"); 966 } 967 968 /** 969 * @tc.name: screen_capture_check_param_02 970 * @tc.desc: do screencapture 971 * @tc.type: FUNC 972 * @tc.require: 973 */ 974 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_02, TestSize.Level2) 975 { 976 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_02 before"); 977 RecorderInfo recorderInfo; 978 SetRecorderInfo("screen_capture_check_param_02.mp4", recorderInfo); 979 SetConfigFile(config_, recorderInfo); 980 AudioCaptureInfo micCapInfo = { 981 .audioSampleRate = 16000, 982 .audioChannels = 2, 983 .audioSource = AudioCaptureSourceType::MIC 984 }; 985 config_.audioInfo.micCapInfo = micCapInfo; 986 AudioEncInfo audioEncInfoBitSmall = { 987 .audioBitrate = 0, 988 .audioCodecformat = AudioCodecFormat::AAC_LC 989 }; 990 config_.audioInfo.audioEncInfo = audioEncInfoBitSmall; 991 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 992 993 SetRecorderInfo("screen_capture_check_param_02.mp4", recorderInfo); 994 config_.recorderInfo = recorderInfo; 995 config_.audioInfo.audioEncInfo.audioBitrate = 4800000; 996 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 997 998 SetRecorderInfo("screen_capture_check_param_02.mp4", recorderInfo); 999 config_.recorderInfo = recorderInfo; 1000 config_.audioInfo.audioEncInfo.audioBitrate = 48000; 1001 config_.audioInfo.audioEncInfo.audioCodecformat = AudioCodecFormat::AUDIO_CODEC_FORMAT_BUTT; 1002 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1003 1004 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_02 after"); 1005 } 1006 1007 /** 1008 * @tc.name: screen_capture_check_param_03 1009 * @tc.desc: do screencapture 1010 * @tc.type: FUNC 1011 * @tc.require: 1012 */ 1013 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_03, TestSize.Level2) 1014 { 1015 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_03 before"); 1016 RecorderInfo recorderInfo; 1017 SetRecorderInfo("screen_capture_check_param_03.mp4", recorderInfo); 1018 SetConfigFile(config_, recorderInfo); 1019 AudioCaptureInfo micCapInfo = { 1020 .audioSampleRate = 16000, 1021 .audioChannels = 2, 1022 .audioSource = AudioCaptureSourceType::MIC 1023 }; 1024 config_.audioInfo.micCapInfo = micCapInfo; 1025 VideoCaptureInfo videoCapInfoWidthSmall = { 1026 .videoFrameWidth = 0, 1027 .videoFrameHeight = 1080, 1028 .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA 1029 }; 1030 config_.videoInfo.videoCapInfo = videoCapInfoWidthSmall; 1031 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1032 1033 SetRecorderInfo("screen_capture_check_param_03.mp4", recorderInfo); 1034 config_.recorderInfo = recorderInfo; 1035 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 1036 config_.videoInfo.videoCapInfo.videoFrameHeight = 0; 1037 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1038 1039 SetRecorderInfo("screen_capture_check_param_03.mp4", recorderInfo); 1040 config_.recorderInfo = recorderInfo; 1041 config_.videoInfo.videoCapInfo.videoFrameHeight = 1080; 1042 config_.videoInfo.videoCapInfo.videoSource = VideoSourceType::VIDEO_SOURCE_BUTT; 1043 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1044 1045 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_03 after"); 1046 } 1047 1048 /** 1049 * @tc.name: screen_capture_check_param_04 1050 * @tc.desc: do screencapture 1051 * @tc.type: FUNC 1052 * @tc.require: 1053 */ 1054 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_04, TestSize.Level2) 1055 { 1056 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_04 before"); 1057 RecorderInfo recorderInfo; 1058 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1059 SetConfigFile(config_, recorderInfo); 1060 AudioCaptureInfo micCapInfo = { 1061 .audioSampleRate = 16000, 1062 .audioChannels = 2, 1063 .audioSource = AudioCaptureSourceType::MIC 1064 }; 1065 config_.audioInfo.micCapInfo = micCapInfo; 1066 VideoEncInfo videoEncInfoBitSmall = { 1067 .videoCodec = VideoCodecFormat::MPEG4, 1068 .videoBitrate = 0, 1069 .videoFrameRate = 30 1070 }; 1071 config_.videoInfo.videoEncInfo = videoEncInfoBitSmall; 1072 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1073 1074 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1075 config_.recorderInfo = recorderInfo; 1076 config_.videoInfo.videoEncInfo.videoBitrate = 30000001; 1077 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1078 1079 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1080 config_.recorderInfo = recorderInfo; 1081 config_.videoInfo.videoEncInfo.videoBitrate = 2000000; 1082 config_.videoInfo.videoEncInfo.videoFrameRate = 0; 1083 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1084 1085 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1086 config_.recorderInfo = recorderInfo; 1087 config_.videoInfo.videoEncInfo.videoFrameRate = 300; 1088 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1089 1090 SetRecorderInfo("screen_capture_check_param_04.mp4", recorderInfo); 1091 config_.recorderInfo = recorderInfo; 1092 config_.videoInfo.videoEncInfo.videoFrameRate = 30; 1093 config_.videoInfo.videoEncInfo.videoCodec = VideoCodecFormat::VIDEO_CODEC_FORMAT_BUTT; 1094 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1095 1096 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_04 after"); 1097 } 1098 1099 /** 1100 * @tc.name: screen_capture_check_param_05 1101 * @tc.desc: do screencapture 1102 * @tc.type: FUNC 1103 * @tc.require: 1104 */ 1105 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_05, TestSize.Level2) 1106 { 1107 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_05 before"); 1108 RecorderInfo recorderInfo; 1109 SetRecorderInfo("screen_capture_check_param_05.mp4", recorderInfo); 1110 SetConfigFile(config_, recorderInfo); 1111 AudioCaptureInfo innerCapInfo = { 1112 .audioSampleRate = 16000, 1113 .audioChannels = 2, 1114 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 1115 }; 1116 config_.audioInfo.innerCapInfo = innerCapInfo; 1117 config_.dataType = DataType::ENCODED_STREAM; 1118 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1119 1120 SetRecorderInfo("screen_capture_check_param_05.mp4", recorderInfo); 1121 config_.recorderInfo = recorderInfo; 1122 config_.dataType = DataType::INVAILD; 1123 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1124 1125 SetRecorderInfo("screen_capture_check_param_05.mp4", recorderInfo); 1126 config_.recorderInfo = recorderInfo; 1127 config_.dataType = DataType::CAPTURE_FILE; 1128 config_.captureMode = CaptureMode::CAPTURE_INVAILD; 1129 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1130 1131 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_05 after"); 1132 } 1133 1134 /** 1135 * @tc.name: screen_capture_check_param_06 1136 * @tc.desc: do screencapture 1137 * @tc.type: FUNC 1138 * @tc.require: 1139 */ 1140 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_06, TestSize.Level2) 1141 { 1142 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_06 before"); 1143 RecorderInfo recorderInfo; 1144 SetRecorderInfo("screen_capture_check_param_06.mp4", recorderInfo); 1145 recorderInfo.fileFormat = "avi"; // native default m4a, capi avi 1146 SetConfigFile(config_, recorderInfo); 1147 AudioCaptureInfo innerCapInfo = { 1148 .audioSampleRate = 16000, 1149 .audioChannels = 2, 1150 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 1151 }; 1152 config_.audioInfo.innerCapInfo = innerCapInfo; 1153 screenCapture_->Init(config_); // not check 1154 config_.recorderInfo.fileFormat = "m4a"; 1155 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1156 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_06 after"); 1157 } 1158 1159 /** 1160 * @tc.name: screen_capture_check_param_07 1161 * @tc.desc: do screencapture 1162 * @tc.type: FUNC 1163 * @tc.require: 1164 */ 1165 HWTEST_F(ScreenCaptureUnitTest, screen_capture_check_param_07, TestSize.Level2) 1166 { 1167 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_07 before"); 1168 RecorderInfo recorderInfo; 1169 SetRecorderInfo("screen_capture_check_param_07.mp4", recorderInfo); 1170 SetConfigFile(config_, recorderInfo); 1171 AudioCaptureInfo innerCapInfo = { 1172 .audioSampleRate = 16000, 1173 .audioChannels = 2, 1174 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 1175 }; 1176 AudioCaptureInfo micCapInfo = { 1177 .audioSampleRate = 48000, 1178 .audioChannels = 2, 1179 .audioSource = AudioCaptureSourceType::MIC 1180 }; 1181 config_.audioInfo.innerCapInfo = innerCapInfo; 1182 config_.audioInfo.micCapInfo = micCapInfo; 1183 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1184 1185 SetRecorderInfo("screen_capture_check_param_07.mp4", recorderInfo); 1186 config_.recorderInfo = recorderInfo; 1187 config_.audioInfo.micCapInfo.audioSampleRate = 16000; 1188 config_.audioInfo.micCapInfo.audioChannels = 1; 1189 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1190 1191 SetRecorderInfo("screen_capture_check_param_07.mp4", recorderInfo); 1192 config_.recorderInfo = recorderInfo; 1193 config_.audioInfo.micCapInfo.audioSampleRate = 48000; 1194 config_.audioInfo.micCapInfo.audioChannels = 1; 1195 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1196 1197 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_check_param_07 after"); 1198 } 1199 1200 /** 1201 * @tc.name: screen_capture_video_configure_0001 1202 * @tc.desc: init with videoFrameWidth -1 1203 * @tc.type: FUNC 1204 * @tc.require: 1205 */ 1206 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0001, TestSize.Level2) 1207 { 1208 SetConfig(config_); 1209 config_.videoInfo.videoCapInfo.videoFrameWidth = -1; 1210 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1211 1212 bool isMicrophone = false; 1213 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1214 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1215 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1216 } 1217 1218 /** 1219 * @tc.name: screen_capture_video_configure_0002 1220 * @tc.desc: init with videoFrameHeight -1 1221 * @tc.type: FUNC 1222 * @tc.require: 1223 */ 1224 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0002, TestSize.Level2) 1225 { 1226 SetConfig(config_); 1227 config_.videoInfo.videoCapInfo.videoFrameHeight = -1; 1228 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1229 1230 bool isMicrophone = false; 1231 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1232 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1233 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1234 } 1235 1236 /** 1237 * @tc.name: screen_capture_video_configure_0003 1238 * @tc.desc: init with videoSource yuv 1239 * @tc.type: FUNC 1240 * @tc.require: 1241 */ 1242 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0003, TestSize.Level2) 1243 { 1244 SetConfig(config_); 1245 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV; 1246 1247 bool isMicrophone = false; 1248 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1249 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1250 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1251 } 1252 1253 /** 1254 * @tc.name: screen_capture_video_configure_0004 1255 * @tc.desc: init with videoSource es 1256 * @tc.type: FUNC 1257 * @tc.require: 1258 */ 1259 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_configure_0004, TestSize.Level0) 1260 { 1261 SetConfig(config_); 1262 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_ES; 1263 1264 bool isMicrophone = false; 1265 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1266 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1267 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1268 } 1269 1270 /** 1271 * @tc.name: screen_capture_without_audio_data 1272 * @tc.desc: close microphone 1273 * @tc.type: FUNC 1274 * @tc.require: 1275 */ 1276 HWTEST_F(ScreenCaptureUnitTest, screen_capture_without_audio_data, TestSize.Level2) 1277 { 1278 SetConfig(config_); 1279 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1280 OpenFile("screen_capture_without_audio_data"); 1281 1282 aFlag = 0; 1283 vFlag = 1; 1284 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1285 ASSERT_NE(nullptr, screenCaptureCb_); 1286 bool isMicrophone = false; 1287 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1288 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1289 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1290 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1291 sleep(RECORDER_TIME); 1292 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1293 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1294 CloseFile(); 1295 } 1296 1297 /** 1298 * @tc.name: screen_capture_audio_configure_0001 1299 * @tc.desc: init with audioSampleRate -1 1300 * @tc.type: FUNC 1301 * @tc.require: 1302 */ 1303 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0001, TestSize.Level2) 1304 { 1305 SetConfig(config_); 1306 config_.audioInfo.micCapInfo.audioSampleRate = -1; 1307 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1308 1309 bool isMicrophone = true; 1310 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1311 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1312 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1313 } 1314 1315 /** 1316 * @tc.name: screen_capture_audio_configure_0002 1317 * @tc.desc: init with audioChannels -1 1318 * @tc.type: FUNC 1319 * @tc.require: 1320 */ 1321 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0002, TestSize.Level2) 1322 { 1323 SetConfig(config_); 1324 config_.audioInfo.micCapInfo.audioChannels = -1; 1325 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1326 1327 bool isMicrophone = true; 1328 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1329 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1330 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1331 } 1332 1333 /** 1334 * @tc.name: screen_capture_audio_configure_0003 1335 * @tc.desc: init with audioSource SOURCE_INVALID 1336 * @tc.type: FUNC 1337 * @tc.require: 1338 */ 1339 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audio_configure_0003, TestSize.Level2) 1340 { 1341 SetConfig(config_); 1342 config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID; 1343 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1344 1345 bool isMicrophone = true; 1346 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1347 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1348 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1349 } 1350 1351 /** 1352 * @tc.name: screen_capture_avconfigure 1353 * @tc.desc: init with both audioinfo and videoinfo invaild 1354 * @tc.type: FUNC 1355 * @tc.require: 1356 */ 1357 HWTEST_F(ScreenCaptureUnitTest, screen_capture_avconfigure, TestSize.Level2) 1358 { 1359 SetConfig(config_); 1360 config_.audioInfo.micCapInfo.audioSource = SOURCE_INVALID; 1361 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_YUV; 1362 1363 bool isMicrophone = true; 1364 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1365 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1366 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1367 } 1368 1369 /** 1370 * @tc.name: screen_capture_with_audio_data 1371 * @tc.desc: open microphone 1372 * @tc.type: FUNC 1373 * @tc.require: 1374 */ 1375 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_audio_data, TestSize.Level2) 1376 { 1377 SetConfig(config_); 1378 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1379 OpenFile("screen_capture_with_audio_data"); 1380 1381 aFlag = 1; 1382 vFlag = 1; 1383 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1384 ASSERT_NE(nullptr, screenCaptureCb_); 1385 bool isMicrophone = true; 1386 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1387 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1388 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1389 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1390 sleep(RECORDER_TIME); 1391 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1392 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1393 CloseFile(); 1394 } 1395 1396 /** 1397 * @tc.name: screen_capture_captureMode_0001 1398 * @tc.desc: screen capture with captureMode -1 1399 * @tc.type: FUNC 1400 * @tc.require: 1401 */ 1402 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0001, TestSize.Level2) 1403 { 1404 SetConfig(config_); 1405 config_.captureMode = static_cast<CaptureMode>(-1); 1406 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1407 1408 bool isMicrophone = true; 1409 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1410 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1411 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1412 } 1413 1414 /** 1415 * @tc.name: screen_capture_captureMode_0002 1416 * @tc.desc: screen capture with captureMode 5 1417 * @tc.type: FUNC 1418 * @tc.require: 1419 */ 1420 HWTEST_F(ScreenCaptureUnitTest, screen_capture_captureMode_0002, TestSize.Level2) 1421 { 1422 SetConfig(config_); 1423 config_.captureMode = static_cast<CaptureMode>(5); 1424 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1425 1426 bool isMicrophone = true; 1427 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1428 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1429 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1430 } 1431 1432 /** 1433 * @tc.name: screen_capture_init_datatype_0001 1434 * @tc.desc: screen capture init with ENCODED_STREAM 1435 * @tc.type: FUNC 1436 * @tc.require: 1437 */ 1438 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0001, TestSize.Level2) 1439 { 1440 SetConfig(config_); 1441 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1442 config_.dataType = ENCODED_STREAM; 1443 1444 bool isMicrophone = true; 1445 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1446 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1447 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1448 } 1449 1450 /** 1451 * @tc.name: screen_capture_init_datatype_0002 1452 * @tc.desc: screen capture init with CAPTURE_FILE 1453 * @tc.type: FUNC 1454 * @tc.require: 1455 */ 1456 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0002, TestSize.Level2) 1457 { 1458 SetConfig(config_); 1459 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1460 config_.dataType = CAPTURE_FILE; 1461 1462 bool isMicrophone = true; 1463 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1464 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1465 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1466 } 1467 1468 /** 1469 * @tc.name: screen_capture_init_datatype_0003 1470 * @tc.desc: screen capture init with INVAILD 1471 * @tc.type: FUNC 1472 * @tc.require: 1473 */ 1474 HWTEST_F(ScreenCaptureUnitTest, screen_capture_init_datatype_0003, TestSize.Level2) 1475 { 1476 SetConfig(config_); 1477 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1478 config_.dataType = INVAILD; 1479 1480 bool isMicrophone = true; 1481 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1482 EXPECT_NE(MSERR_OK, screenCapture_->Init(config_)); 1483 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1484 } 1485 1486 /** 1487 * @tc.name: screen_capture_audioSampleRate_48000 1488 * @tc.desc: screen capture with audioSampleRate 48000 1489 * @tc.type: FUNC 1490 * @tc.require: 1491 */ 1492 HWTEST_F(ScreenCaptureUnitTest, screen_capture_audioSampleRate_48000, TestSize.Level2) 1493 { 1494 SetConfig(config_); 1495 config_.audioInfo.micCapInfo.audioSampleRate = 48000; 1496 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1497 1498 aFlag = 1; 1499 vFlag = 1; 1500 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1501 ASSERT_NE(nullptr, screenCaptureCb_); 1502 bool isMicrophone = true; 1503 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1504 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1505 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1506 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1507 sleep(RECORDER_TIME); 1508 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1509 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1510 } 1511 1512 /** 1513 * @tc.name: screen_capture_video_size_0001 1514 * @tc.desc: screen capture with 160x160 1515 * @tc.type: FUNC 1516 * @tc.require: 1517 */ 1518 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0001, TestSize.Level2) 1519 { 1520 SetConfig(config_); 1521 config_.videoInfo.videoCapInfo.videoFrameWidth = 160; 1522 config_.videoInfo.videoCapInfo.videoFrameHeight = 160; 1523 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1524 1525 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0001.yuv"; 1526 vFile = fopen(name.c_str(), "w+"); 1527 if (vFile == nullptr) { 1528 cout << "vFile video open failed, " << strerror(errno) << endl; 1529 } 1530 1531 aFlag = 1; 1532 vFlag = 1; 1533 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1534 ASSERT_NE(nullptr, screenCaptureCb_); 1535 bool isMicrophone = true; 1536 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1537 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1538 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1539 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1540 sleep(RECORDER_TIME); 1541 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1542 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1543 CloseFile(); 1544 } 1545 1546 /** 1547 * @tc.name: screen_capture_video_size_0002 1548 * @tc.desc: screen capture with 640x480 1549 * @tc.type: FUNC 1550 * @tc.require: 1551 */ 1552 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0002, TestSize.Level2) 1553 { 1554 SetConfig(config_); 1555 config_.videoInfo.videoCapInfo.videoFrameWidth = 640; 1556 config_.videoInfo.videoCapInfo.videoFrameHeight = 480; 1557 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1558 1559 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0002.yuv"; 1560 vFile = fopen(name.c_str(), "w+"); 1561 if (vFile == nullptr) { 1562 cout << "vFile video open failed, " << strerror(errno) << endl; 1563 } 1564 1565 aFlag = 1; 1566 vFlag = 1; 1567 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1568 ASSERT_NE(nullptr, screenCaptureCb_); 1569 bool isMicrophone = true; 1570 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1571 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1572 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1573 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1574 sleep(RECORDER_TIME); 1575 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1576 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1577 CloseFile(); 1578 } 1579 1580 /** 1581 * @tc.name: screen_capture_video_size_0003 1582 * @tc.desc: screen capture with 1920x1080 1583 * @tc.type: FUNC 1584 * @tc.require: 1585 */ 1586 HWTEST_F(ScreenCaptureUnitTest, screen_capture_video_size_0003, TestSize.Level2) 1587 { 1588 SetConfig(config_); 1589 config_.videoInfo.videoCapInfo.videoFrameWidth = 1920; 1590 config_.videoInfo.videoCapInfo.videoFrameHeight = 1080; 1591 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1592 1593 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_video_size_0003.yuv"; 1594 vFile = fopen(name.c_str(), "w+"); 1595 if (vFile == nullptr) { 1596 cout << "vFile video open failed, " << strerror(errno) << endl; 1597 } 1598 1599 aFlag = 1; 1600 vFlag = 1; 1601 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1602 ASSERT_NE(nullptr, screenCaptureCb_); 1603 bool isMicrophone = true; 1604 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1605 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1606 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1607 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1608 sleep(RECORDER_TIME); 1609 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1610 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1611 CloseFile(); 1612 } 1613 1614 /** 1615 * @tc.name: screen_capture_from_display 1616 * @tc.desc: screen capture from display 1617 * @tc.type: FUNC 1618 * @tc.require: 1619 */ 1620 HWTEST_F(ScreenCaptureUnitTest, screen_capture_from_display, TestSize.Level0) 1621 { 1622 SetConfig(config_); 1623 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1624 sptr<Display> display = DisplayManager::GetInstance().GetDefaultDisplaySync(); 1625 ASSERT_NE(display, nullptr); 1626 cout << "get displayinfo: " << endl; 1627 cout << "width: " << display->GetWidth() << "; height: " << display->GetHeight() << "; density: " << 1628 display->GetDpi() << "; refreshRate: " << display->GetRefreshRate() << endl; 1629 1630 config_.videoInfo.videoCapInfo.videoFrameWidth = display->GetWidth(); 1631 config_.videoInfo.videoCapInfo.videoFrameHeight = display->GetHeight(); 1632 1633 aFlag = 1; 1634 vFlag = 1; 1635 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1636 ASSERT_NE(nullptr, screenCaptureCb_); 1637 bool isMicrophone = true; 1638 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1639 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1640 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1641 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1642 sleep(RECORDER_TIME); 1643 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1644 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1645 } 1646 1647 /** 1648 * @tc.name: screen_capture_buffertest_0001 1649 * @tc.desc: screen capture buffer test 1650 * @tc.type: FUNC 1651 * @tc.require: 1652 */ 1653 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0001, TestSize.Level2) 1654 { 1655 SetConfig(config_); 1656 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1657 1658 bool isMicrophone = true; 1659 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1660 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1661 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1662 int index = 200; 1663 int index_video_frame = 0; 1664 audioLoop_ = std::make_unique<std::thread>(&ScreenCaptureUnitTest::AudioLoopWithoutRelease, this); 1665 while (index) { 1666 int32_t fence = 0; 1667 int64_t timestamp = 0; 1668 OHOS::Rect damage; 1669 sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage); 1670 if (surfacebuffer != nullptr) { 1671 int32_t length = surfacebuffer->GetSize(); 1672 cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:" << 1673 surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl; 1674 } else { 1675 cout << "AcquireVideoBuffer failed" << endl; 1676 } 1677 index--; 1678 } 1679 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1680 if (audioLoop_ != nullptr && audioLoop_->joinable()) { 1681 audioLoop_->join(); 1682 audioLoop_.reset(); 1683 audioLoop_ = nullptr; 1684 } 1685 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1686 } 1687 1688 /** 1689 * @tc.name: screen_capture_buffertest_0002 1690 * @tc.desc: screen capture buffer test 1691 * @tc.type: FUNC 1692 * @tc.require: 1693 */ 1694 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0002, TestSize.Level2) 1695 { 1696 SetConfig(config_); 1697 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1698 1699 bool isMicrophone = true; 1700 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1701 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1702 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1703 int index = 200; 1704 int index_video_frame = 0; 1705 audioLoop_ = std::make_unique<std::thread>(&ScreenCaptureUnitTest::AudioLoop, this); 1706 while (index) { 1707 int32_t fence = 0; 1708 int64_t timestamp = 0; 1709 OHOS::Rect damage; 1710 sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage); 1711 if (surfacebuffer != nullptr) { 1712 int32_t length = surfacebuffer->GetSize(); 1713 cout << "index video:" << index_video_frame++ << "; AcquireVideoBuffer, videoBufferLen:" << 1714 surfacebuffer->GetSize() << ", timestamp:" << timestamp << ", size:"<< length << endl; 1715 screenCapture_->ReleaseVideoBuffer(); 1716 } else { 1717 cout << "AcquireVideoBuffer failed" << endl; 1718 } 1719 index--; 1720 } 1721 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1722 if (audioLoop_ != nullptr && audioLoop_->joinable()) { 1723 audioLoop_->join(); 1724 audioLoop_.reset(); 1725 audioLoop_ = nullptr; 1726 } 1727 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1728 } 1729 1730 /** 1731 * @tc.name: screen_capture_buffertest_0003 1732 * @tc.desc: screen capture buffer test 1733 * @tc.type: FUNC 1734 * @tc.require: 1735 */ 1736 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0003, TestSize.Level2) 1737 { 1738 SetConfig(config_); 1739 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1740 1741 aFlag = 0; 1742 vFlag = 1; 1743 bool isMicrophone = true; 1744 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1745 ASSERT_NE(nullptr, screenCaptureCb_); 1746 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1747 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1748 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1749 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1750 sleep(15); 1751 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1752 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1753 } 1754 1755 /** 1756 * @tc.name: screen_capture_buffertest_0004 1757 * @tc.desc: screen capture buffer test 1758 * @tc.type: FUNC 1759 * @tc.require: 1760 */ 1761 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0004, TestSize.Level2) 1762 { 1763 SetConfig(config_); 1764 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1765 1766 aFlag = 1; 1767 vFlag = 0; 1768 bool isMicrophone = true; 1769 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1770 ASSERT_NE(nullptr, screenCaptureCb_); 1771 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1772 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1773 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1774 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1775 sleep(10); 1776 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1777 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1778 } 1779 1780 /** 1781 * @tc.name: screen_capture_buffertest_0005 1782 * @tc.desc: screen capture buffer test 1783 * @tc.type: FUNC 1784 * @tc.require: 1785 */ 1786 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_0005, TestSize.Level2) 1787 { 1788 SetConfig(config_); 1789 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1790 1791 aFlag = 0; 1792 vFlag = 0; 1793 bool isMicrophone = true; 1794 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1795 ASSERT_NE(nullptr, screenCaptureCb_); 1796 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1797 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1798 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1799 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1800 sleep(10); 1801 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1802 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1803 } 1804 1805 /** 1806 * @tc.name: screen_capture_buffertest_Rotation 1807 * @tc.desc: screen capture buffer test 1808 * @tc.type: FUNC 1809 * @tc.require: 1810 */ 1811 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_Rotation, TestSize.Level2) 1812 { 1813 SetConfig(config_); 1814 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1815 1816 aFlag = 0; 1817 vFlag = 0; 1818 bool isMicrophone = true; 1819 bool canvasRotation = true; 1820 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1821 ASSERT_NE(nullptr, screenCaptureCb_); 1822 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1823 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 1824 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1825 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1826 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1827 EXPECT_EQ(MSERR_OK, screenCapture_->SetCanvasRotation(canvasRotation)); 1828 sleep(10); 1829 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1830 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1831 } 1832 1833 /** 1834 * @tc.name: screen_capture_mic_open_close_open 1835 * @tc.desc: screen capture mic test 1836 * @tc.type: FUNC 1837 * @tc.require: 1838 */ 1839 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_open_close_open, TestSize.Level2) 1840 { 1841 SetConfig(config_); 1842 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1843 1844 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_mic_open_close_open.pcm"; 1845 aFile = fopen(name.c_str(), "w+"); 1846 if (aFile == nullptr) { 1847 cout << "aFile audio open failed, " << strerror(errno) << endl; 1848 } 1849 1850 aFlag = 1; 1851 vFlag = 1; 1852 bool isMicrophone = true; 1853 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1854 ASSERT_NE(nullptr, screenCaptureCb_); 1855 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1856 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1857 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1858 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1859 sleep(5); 1860 isMicrophone = false; 1861 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1862 sleep(3); 1863 isMicrophone = true; 1864 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1865 sleep(3); 1866 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1867 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1868 CloseFile(); 1869 } 1870 1871 /** 1872 * @tc.name: screen_capture_mic_close_open_close 1873 * @tc.desc: screen capture mic test 1874 * @tc.type: FUNC 1875 * @tc.require: 1876 */ 1877 HWTEST_F(ScreenCaptureUnitTest, screen_capture_mic_close_open_close, TestSize.Level2) 1878 { 1879 SetConfig(config_); 1880 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1881 1882 std::string name = SCREEN_CAPTURE_ROOT_DIR + "screen_capture_mic_close_open_close.pcm"; 1883 aFile = fopen(name.c_str(), "w+"); 1884 if (aFile == nullptr) { 1885 cout << "aFile audio open failed, " << strerror(errno) << endl; 1886 } 1887 1888 aFlag = 1; 1889 vFlag = 1; 1890 bool isMicrophone = false; 1891 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 1892 ASSERT_NE(nullptr, screenCaptureCb_); 1893 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1894 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 1895 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1896 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 1897 sleep(5); 1898 isMicrophone = true; 1899 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1900 sleep(3); 1901 isMicrophone = false; 1902 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1903 sleep(3); 1904 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1905 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1906 CloseFile(); 1907 } 1908 1909 /** 1910 * @tc.name: screen_capture_with_surface_01 1911 * @tc.desc: do screencapture 1912 * @tc.type: FUNC 1913 * @tc.require: 1914 */ 1915 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_01, TestSize.Level2) 1916 { 1917 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 before"); 1918 SetConfig(config_); 1919 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 1920 config_.videoInfo.videoCapInfo.videoFrameHeight = 1280; 1921 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1922 bool isMicrophone = true; 1923 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1924 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 CreateRecorder"); 1925 std::shared_ptr<Recorder> recorder = nullptr; 1926 recorder = RecorderFactory::CreateRecorder(); 1927 int32_t videoSourceId = 0; 1928 EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId)); 1929 EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4)); 1930 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264)); 1931 EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1280)); 1932 EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30)); 1933 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000)); 1934 OpenFileFd("screen_capture_with_surface_01.mp4"); 1935 ASSERT_TRUE(outputFd_ >= 0); 1936 EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_)); 1937 EXPECT_EQ(MSERR_OK, recorder->Prepare()); 1938 sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId); 1939 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1940 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer)); 1941 EXPECT_EQ(MSERR_OK, recorder->Start()); 1942 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 recorder Start"); 1943 sleep(RECORDER_TIME); 1944 EXPECT_EQ(MSERR_OK, recorder->Stop(true)); 1945 EXPECT_EQ(MSERR_OK, recorder->Reset()); 1946 EXPECT_EQ(MSERR_OK, recorder->Release()); 1947 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1948 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1949 CloseFile(); 1950 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_01 after"); 1951 } 1952 1953 /** 1954 * @tc.name: screen_capture_with_surface_02 1955 * @tc.desc: do screencapture 1956 * @tc.type: FUNC 1957 * @tc.require: 1958 */ 1959 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_02, TestSize.Level2) 1960 { 1961 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 before"); 1962 SetConfig(config_); 1963 config_.videoInfo.videoCapInfo.videoFrameWidth = 480; 1964 config_.videoInfo.videoCapInfo.videoFrameHeight = 640; 1965 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 1966 bool isMicrophone = true; 1967 screenCapture_->SetMicrophoneEnabled(isMicrophone); 1968 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 CreateRecorder"); 1969 std::shared_ptr<Recorder> recorder = nullptr; 1970 recorder = RecorderFactory::CreateRecorder(); 1971 int32_t videoSourceId = 0; 1972 EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId)); 1973 EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4)); 1974 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264)); 1975 EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 480, 640)); 1976 EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30)); 1977 EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000)); 1978 OpenFileFd("screen_capture_with_surface_02.mp4"); 1979 ASSERT_TRUE(outputFd_ >= 0); 1980 EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_)); 1981 EXPECT_EQ(MSERR_OK, recorder->Prepare()); 1982 sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId); 1983 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 1984 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer)); 1985 EXPECT_EQ(MSERR_OK, recorder->Start()); 1986 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 recorder Start"); 1987 sleep(RECORDER_TIME); 1988 EXPECT_EQ(MSERR_OK, recorder->Stop(true)); 1989 EXPECT_EQ(MSERR_OK, recorder->Reset()); 1990 EXPECT_EQ(MSERR_OK, recorder->Release()); 1991 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 1992 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 1993 CloseFile(); 1994 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_02 after"); 1995 } 1996 1997 /** 1998 * @tc.name: screen_capture_buffertest_resize_01 1999 * @tc.desc: screen capture buffer test 2000 * @tc.type: FUNC 2001 * @tc.require: 2002 */ 2003 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_resize_01, TestSize.Level2) 2004 { 2005 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_01 before"); 2006 SetConfig(config_); 2007 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2008 2009 aFlag = 1; 2010 vFlag = 1; 2011 bool isMicrophone = false; 2012 2013 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2014 ASSERT_NE(nullptr, screenCaptureCb_); 2015 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2016 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2017 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2018 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2019 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2020 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2021 sleep(5); 2022 cout << "screenCapture_->ResizeCanvas start 1" << endl; 2023 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2024 cout << "screenCapture_->ResizeCanvas end 1" << endl; 2025 sleep(5); 2026 cout << "screenCapture_->ResizeCanvas start 2" << endl; 2027 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(1980, 3520)); 2028 cout << "screenCapture_->ResizeCanvas end 2" << endl; 2029 sleep(5); 2030 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2031 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2032 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2033 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_01 after"); 2034 } 2035 2036 /** 2037 * @tc.name: screen_capture_buffertest_resize_02 2038 * @tc.desc: screen capture buffer test 2039 * @tc.type: FUNC 2040 * @tc.require: 2041 */ 2042 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_resize_02, TestSize.Level2) 2043 { 2044 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_02 before"); 2045 SetConfig(config_); 2046 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2047 2048 aFlag = 1; 2049 vFlag = 1; 2050 bool isMicrophone = false; 2051 2052 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2053 ASSERT_NE(nullptr, screenCaptureCb_); 2054 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2055 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2056 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2057 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2058 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2059 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2060 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2061 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2062 sleep(RECORDER_TIME); 2063 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2064 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2065 sleep(RECORDER_TIME); 2066 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2067 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(27000, 480)); 2068 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 48000)); 2069 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2070 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_resize_02 after"); 2071 } 2072 2073 /** 2074 * @tc.name: screen_capture_with_surface_resize_show_size 2075 * @tc.desc: do screencapture 2076 * @tc.type: FUNC 2077 * @tc.require: 2078 */ 2079 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_resize_show_size, TestSize.Level2) 2080 { 2081 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_resize_show_size before"); 2082 SetConfig(config_); 2083 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 2084 config_.videoInfo.videoCapInfo.videoFrameHeight = 1280; 2085 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2086 bool isMicrophone = false; 2087 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2088 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2089 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2090 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2091 2092 sptr<OHOS::Surface> consumer = OHOS::Surface::CreateSurfaceAsConsumer(); 2093 consumer->SetDefaultUsage(BUFFER_USAGE_CPU_READ | BUFFER_USAGE_MEM_MMZ_CACHE); 2094 auto producer = consumer->GetProducer(); 2095 auto producerSurface = OHOS::Surface::CreateSurfaceAsProducer(producer); 2096 2097 sptr<IBufferConsumerListener> surfaceCb = OHOS::sptr<ScreenCapBufferDemoConsumerListener>::MakeSptr(consumer); 2098 consumer->RegisterConsumerListener(surfaceCb); 2099 2100 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(producerSurface)); 2101 sleep(5); 2102 cout << "screenCapture_->ResizeCanvas start 1" << endl; 2103 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2104 cout << "screenCapture_->ResizeCanvas end 1" << endl; 2105 sleep(5); 2106 cout << "screenCapture_->ResizeCanvas start 2" << endl; 2107 EXPECT_EQ(MSERR_OK, screenCapture_->ResizeCanvas(1980, 3520)); 2108 cout << "screenCapture_->ResizeCanvas end 2" << endl; 2109 sleep(5); 2110 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2111 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2112 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2113 CloseFile(); 2114 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_resize_show_size after"); 2115 } 2116 2117 /** 2118 * @tc.name: screen_capture_save_file_resize 2119 * @tc.desc: do screencapture 2120 * @tc.type: FUNC 2121 * @tc.require: 2122 */ 2123 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_resize, TestSize.Level2) 2124 { 2125 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_resize before"); 2126 RecorderInfo recorderInfo; 2127 SetRecorderInfo("screen_capture_save_file_resize.mp4", recorderInfo); 2128 SetConfigFile(config_, recorderInfo); 2129 AudioCaptureInfo innerCapInfo = { 2130 .audioSampleRate = 16000, 2131 .audioChannels = 2, 2132 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 2133 }; 2134 config_.audioInfo.innerCapInfo = innerCapInfo; 2135 bool isMicrophone = false; 2136 2137 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2138 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2139 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2140 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2141 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 2142 sleep(RECORDER_TIME); 2143 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2144 sleep(RECORDER_TIME); 2145 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 2146 EXPECT_NE(MSERR_OK, screenCapture_->ResizeCanvas(270, 480)); 2147 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2148 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_resize after"); 2149 } 2150 2151 /** 2152 * @tc.name: screen_capture_save_file_skip_privacy 2153 * @tc.desc: do screencapture 2154 * @tc.type: FUNC 2155 * @tc.require: 2156 */ 2157 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_skip_privacy, TestSize.Level2) 2158 { 2159 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy before"); 2160 RecorderInfo recorderInfo; 2161 SetRecorderInfo("screen_capture_save_file_skip_privacy.mp4", recorderInfo); 2162 SetConfigFile(config_, recorderInfo); 2163 AudioCaptureInfo innerCapInfo = { 2164 .audioSampleRate = 16000, 2165 .audioChannels = 2, 2166 .audioSource = AudioCaptureSourceType::APP_PLAYBACK 2167 }; 2168 config_.audioInfo.innerCapInfo = innerCapInfo; 2169 vector<int> windowIds = {-1, 2, 5}; 2170 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2171 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2172 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2173 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording()); 2174 sleep(RECORDER_TIME); 2175 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2176 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2177 #else 2178 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2179 #endif 2180 sleep(RECORDER_TIME); 2181 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording()); 2182 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2183 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2184 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy after"); 2185 } 2186 2187 /** 2188 * @tc.name: screen_capture_save_file_skip_privacy_01 2189 * @tc.desc: screen capture buffer test 2190 * @tc.type: FUNC 2191 * @tc.require: 2192 */ 2193 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_skip_privacy_01, TestSize.Level2) 2194 { 2195 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy_01 before"); 2196 SetConfig(config_); 2197 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2198 2199 aFlag = 1; 2200 vFlag = 1; 2201 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2202 ASSERT_NE(nullptr, screenCaptureCb_); 2203 vector<int> windowIds = {-1, 2, 5}; 2204 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2205 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2206 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2207 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2208 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2209 sleep(RECORDER_TIME); 2210 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2211 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2212 #else 2213 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2214 #endif 2215 windowIds = {-1, 2, 7}; 2216 sleep(RECORDER_TIME); 2217 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2218 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2219 #else 2220 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2221 #endif 2222 sleep(RECORDER_TIME); 2223 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2224 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2225 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2226 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_skip_privacy_01 after"); 2227 } 2228 2229 /** 2230 * @tc.name: screen_capture_with_surface_skip_privacy_01 2231 * @tc.desc: do screencapture 2232 * @tc.type: FUNC 2233 * @tc.require: 2234 */ 2235 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_skip_privacy_01, TestSize.Level2) 2236 { 2237 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_skip_privacy_01 before"); 2238 SetConfig(config_); 2239 config_.videoInfo.videoCapInfo.videoFrameWidth = 720; 2240 config_.videoInfo.videoCapInfo.videoFrameHeight = 1280; 2241 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2242 bool isMicrophone = false; 2243 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2244 vector<int> windowIds = {-1, 2, 5}; 2245 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2246 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2247 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2248 sptr<OHOS::Surface> consumer = OHOS::Surface::CreateSurfaceAsConsumer(); 2249 consumer->SetDefaultUsage(BUFFER_USAGE_CPU_READ | BUFFER_USAGE_MEM_MMZ_CACHE); 2250 auto producer = consumer->GetProducer(); 2251 auto producerSurface = OHOS::Surface::CreateSurfaceAsProducer(producer); 2252 sptr<IBufferConsumerListener> surfaceCb = OHOS::sptr<ScreenCapBufferDemoConsumerListener>::MakeSptr(consumer); 2253 consumer->RegisterConsumerListener(surfaceCb); 2254 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(producerSurface)); 2255 sleep(RECORDER_TIME); 2256 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2257 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2258 #else 2259 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2260 #endif 2261 sleep(RECORDER_TIME); 2262 windowIds = {-1, 2, 6}; 2263 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2264 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2265 #else 2266 EXPECT_NE(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2267 #endif 2268 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2269 EXPECT_EQ(MSERR_OK, screenCapture_->SkipPrivacyMode(&windowIds[0], static_cast<int32_t>(windowIds.size()))); 2270 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2271 CloseFile(); 2272 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_skip_privacy_01 after"); 2273 } 2274 2275 /** 2276 * @tc.name: screen_capture_buffertest_max_frame_rate_01 2277 * @tc.desc: screen capture buffer test 2278 * @tc.type: FUNC 2279 * @tc.require: 2280 */ 2281 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_max_frame_rate_01, TestSize.Level2) 2282 { 2283 SetConfig(config_); 2284 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2285 2286 aFlag = 1; 2287 vFlag = 1; 2288 bool isMicrophone = false; 2289 2290 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2291 ASSERT_NE(nullptr, screenCaptureCb_); 2292 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2293 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2294 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2295 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2296 sleep(RECORDER_TIME_5); 2297 int32_t totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2298 double averageFrameRate_01 = ((double)totalFrameNum)/RECORDER_TIME_5; 2299 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2300 EXPECT_EQ(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(15)); 2301 #else 2302 EXPECT_NE(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(15)); 2303 #endif 2304 sleep(RECORDER_TIME_5); 2305 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2306 double averageFrameRate_02 = ((double)totalFrameNum)/RECORDER_TIME_5; 2307 sleep(RECORDER_TIME_5); 2308 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2309 double averageFrameRate_03 = ((double)totalFrameNum)/RECORDER_TIME_5; 2310 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2311 EXPECT_EQ(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(90)); 2312 #else 2313 EXPECT_NE(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(90)); 2314 #endif 2315 sleep(RECORDER_TIME_5); 2316 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2317 double averageFrameRate_04 = ((double)totalFrameNum)/RECORDER_TIME_5; 2318 sleep(RECORDER_TIME_5); 2319 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2320 double averageFrameRate_05 = ((double)totalFrameNum)/RECORDER_TIME_5; 2321 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2322 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2323 EXPECT_TRUE(averageFrameRate_02 < (15 * EXCESS_RATE)); 2324 EXPECT_TRUE(averageFrameRate_03 < (15 * EXCESS_RATE)); 2325 EXPECT_TRUE(averageFrameRate_04 < (90 * EXCESS_RATE)); 2326 EXPECT_TRUE(averageFrameRate_05 < (90 * EXCESS_RATE)); 2327 cout << "SetMaxVideoFrameRate end averageFrameRate_01: " << averageFrameRate_01 << ",set 15,averageFrameRate_02: " 2328 << averageFrameRate_02 << " averageFrameRate_03: " << averageFrameRate_03 << ",set 90,averageFrameRate_04: " 2329 << averageFrameRate_04 << " averageFrameRate_05: " << averageFrameRate_05 << endl; 2330 } 2331 2332 /** 2333 * @tc.name: screen_capture_buffertest_max_frame_rate_02 2334 * @tc.desc: screen capture buffer test 2335 * @tc.type: FUNC 2336 * @tc.require: 2337 */ 2338 HWTEST_F(ScreenCaptureUnitTest, screen_capture_buffertest_max_frame_rate_02, TestSize.Level2) 2339 { 2340 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_max_frame_rate_02 before"); 2341 SetConfig(config_); 2342 config_.videoInfo.videoCapInfo.videoSource = VIDEO_SOURCE_SURFACE_RGBA; 2343 2344 aFlag = 1; 2345 vFlag = 1; 2346 bool isMicrophone = false; 2347 2348 screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_, aFile, vFile, aFlag, vFlag); 2349 ASSERT_NE(nullptr, screenCaptureCb_); 2350 screenCapture_->SetMicrophoneEnabled(isMicrophone); 2351 EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_)); 2352 EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_)); 2353 EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture()); 2354 sleep(RECORDER_TIME_5); 2355 int32_t totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2356 double averageFrameRate_01 = ((double)totalFrameNum)/RECORDER_TIME_5; 2357 EXPECT_NE(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(-10)); 2358 sleep(RECORDER_TIME_5); 2359 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2360 double averageFrameRate_02 = ((double)totalFrameNum)/RECORDER_TIME_5; 2361 sleep(RECORDER_TIME_5); 2362 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2363 double averageFrameRate_03 = ((double)totalFrameNum)/RECORDER_TIME_5; 2364 #ifdef SUPPORT_SCREEN_CAPTURE_WINDOW_NOTIFICATION 2365 EXPECT_EQ(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(1000000000)); 2366 #else 2367 EXPECT_NE(MSERR_OK, screenCapture_->SetMaxVideoFrameRate(1000000000)); 2368 #endif 2369 sleep(RECORDER_TIME_5); 2370 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2371 double averageFrameRate_04 = ((double)totalFrameNum)/RECORDER_TIME_5; 2372 sleep(RECORDER_TIME_5); 2373 totalFrameNum = screenCaptureCb_->GetFrameNumber(); 2374 double averageFrameRate_05 = ((double)totalFrameNum)/RECORDER_TIME_5; 2375 2376 EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture()); 2377 EXPECT_EQ(MSERR_OK, screenCapture_->Release()); 2378 cout << "SetMaxVideoFrameRate end averageFrameRate_01: " << averageFrameRate_01 2379 << ",set -10,averageFrameRate_02: " << averageFrameRate_02 << " averageFrameRate_03: " 2380 << averageFrameRate_03 << ",set 1000000000,averageFrameRate_04: " << averageFrameRate_04 2381 << " averageFrameRate_05: " << averageFrameRate_05 << endl; 2382 MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_buffertest_max_frame_rate_02 after"); 2383 } 2384 2385 } // namespace Media 2386 } // namespace OHOS