1 /* 2 * Copyright (C) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <unistd.h> 17 #include <sys/stat.h> 18 #include "screen_capture_server_function_unittest.h" 19 #include "ui_extension_ability_connection.h" 20 #include "image_source.h" 21 #include "image_type.h" 22 #include "pixel_map.h" 23 #include "media_log.h" 24 #include "media_errors.h" 25 #include "media_utils.h" 26 #include "uri_helper.h" 27 #include "media_dfx.h" 28 #include "scope_guard.h" 29 #include "param_wrapper.h" 30 31 using namespace testing::ext; 32 using namespace OHOS::Media::ScreenCaptureTestParam; 33 using namespace OHOS::Media; 34 35 namespace { 36 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_SCREENCAPTURE, "ScreenCaptureServerFunctionTest"}; 37 static constexpr int64_t AUDIO_CAPTURE_READ_FRAME_TIME = 21333333; // 21333333 ns 21ms 38 } 39 40 namespace OHOS { 41 namespace Media { 42 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperStart_001, TestSize.Level2) 43 { 44 SetValidConfig(); 45 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 46 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 47 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 48 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 49 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 50 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 51 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 52 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 53 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 54 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 55 sleep(RECORDER_TIME); 56 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 57 } 58 59 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperStart_002, TestSize.Level2) 60 { 61 SetValidConfig(); 62 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 63 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 64 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 65 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 66 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 67 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 68 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 69 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 70 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 71 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 72 sleep(RECORDER_TIME); 73 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 74 screenCaptureServer_->innerAudioCapture_->OnStartFailed( 75 ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_INTERNAL, SCREEN_CAPTURE_ERR_UNKNOWN); 76 } 77 78 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperStart_003, TestSize.Level2) 79 { 80 SetValidConfig(); 81 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 82 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 83 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 84 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 85 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 86 screenCaptureServer_->micAudioCapture_ = std::make_shared<MicAudioCapturerWrapper>( 87 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo, screenCaptureServer_->screenCaptureCb_, 88 std::string("OS_MicAudioCapture"), screenCaptureServer_->contentFilter_); 89 screenCaptureServer_->micAudioCapture_->bundleName_ = ScreenRecorderBundleName; 90 ASSERT_EQ(screenCaptureServer_->micAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 91 sleep(RECORDER_TIME); 92 ASSERT_EQ(screenCaptureServer_->micAudioCapture_->Stop(), MSERR_OK); 93 screenCaptureServer_->micAudioCapture_->OnStartFailed( 94 ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_INTERNAL, SCREEN_CAPTURE_ERR_UNKNOWN); 95 } 96 97 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperStart_004, TestSize.Level2) 98 { 99 SetValidConfig(); 100 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 101 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 102 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 103 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 104 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 105 screenCaptureServer_->micAudioCapture_ = std::make_shared<MicAudioCapturerWrapper>( 106 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo, screenCaptureServer_->screenCaptureCb_, 107 std::string("OS_MicAudioCapture"), screenCaptureServer_->contentFilter_); 108 screenCaptureServer_->micAudioCapture_->bundleName_ = ScreenRecorderBundleName; 109 ASSERT_EQ(screenCaptureServer_->micAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 110 sleep(RECORDER_TIME); 111 ASSERT_EQ(screenCaptureServer_->micAudioCapture_->Stop(), MSERR_OK); 112 screenCaptureServer_->micAudioCapture_->screenCaptureCb_ = nullptr; 113 screenCaptureServer_->micAudioCapture_->OnStartFailed( 114 ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_INTERNAL, SCREEN_CAPTURE_ERR_UNKNOWN); 115 } 116 117 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperStart_005, TestSize.Level2) 118 { 119 SetValidConfig(); 120 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 121 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 122 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 123 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 124 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 125 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 126 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 127 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 128 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 129 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 130 sleep(RECORDER_TIME); 131 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 132 screenCaptureServer_->innerAudioCapture_->screenCaptureCb_ = nullptr; 133 screenCaptureServer_->innerAudioCapture_->OnStartFailed( 134 ScreenCaptureErrorType::SCREEN_CAPTURE_ERROR_INTERNAL, SCREEN_CAPTURE_ERR_UNKNOWN); 135 } 136 137 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperPause_001, TestSize.Level2) 138 { 139 SetValidConfig(); 140 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 141 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 142 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 143 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 144 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 145 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 146 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 147 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 148 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 149 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 150 sleep(RECORDER_TIME); 151 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 152 } 153 154 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperPause_002, TestSize.Level2) 155 { 156 SetValidConfig(); 157 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 158 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 159 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 160 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 161 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 162 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 163 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 164 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 165 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 166 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 167 sleep(RECORDER_TIME); 168 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 169 } 170 171 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperPause_003, TestSize.Level2) 172 { 173 SetValidConfig(); 174 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 175 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 176 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 177 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 178 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 179 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 180 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 181 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 182 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 183 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 184 screenCaptureServer_->innerAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RECORDING; 185 sleep(RECORDER_TIME); 186 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 187 } 188 189 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperRelativeSleep_001, TestSize.Level2) 190 { 191 SetValidConfig(); 192 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 193 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 194 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 195 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 196 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 197 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 198 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 199 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 200 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->RelativeSleep(1), MSERR_OK); 201 } 202 203 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperOnInterrupt_001, TestSize.Level2) 204 { 205 SetValidConfig(); 206 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 207 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 208 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 209 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 210 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 211 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 212 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 213 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 214 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 215 AudioStandard::InterruptEvent interruptEvent; 216 screenCaptureServer_->innerAudioCapture_->audioCaptureCallback_->OnInterrupt(interruptEvent); 217 sleep(RECORDER_TIME); 218 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 219 } 220 221 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperUpdateAudioCapturerConfig_001, TestSize.Level2) 222 { 223 SetValidConfig(); 224 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 225 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 226 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 227 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 228 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 229 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 230 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 231 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 232 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 233 ScreenCaptureContentFilter filter; 234 filter.filteredAudioContents.insert(AVScreenCaptureFilterableAudioContent::SCREEN_CAPTURE_CURRENT_APP_AUDIO); 235 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 236 screenCaptureServer_->innerAudioCapture_->UpdateAudioCapturerConfig(filter); 237 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 238 } 239 240 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperUpdateAudioCapturerConfig_002, TestSize.Level2) 241 { 242 SetValidConfig(); 243 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 244 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 245 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 246 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 247 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 248 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 249 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 250 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 251 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 252 ScreenCaptureContentFilter filter; 253 filter.filteredAudioContents.insert(AVScreenCaptureFilterableAudioContent::SCREEN_CAPTURE_NOTIFICATION_AUDIO); 254 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 255 screenCaptureServer_->innerAudioCapture_->UpdateAudioCapturerConfig(filter); 256 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 257 } 258 259 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperUseUpBuffer_001, TestSize.Level2) 260 { 261 SetValidConfig(); 262 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 263 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 264 AVScreenCaptureMixMode::INNER_MODE, screenCaptureServer_.get()); 265 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 266 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 267 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 268 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 269 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 270 screenCaptureServer_->innerAudioCapture_->bundleName_ = ScreenRecorderBundleName; 271 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 272 sleep(RECORDER_TIME); 273 int64_t currentAudioTime = 0; 274 screenCaptureServer_->innerAudioCapture_->GetCurrentAudioTime(currentAudioTime); 275 size_t size = 0; 276 screenCaptureServer_->innerAudioCapture_->GetBufferSize(size); 277 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->AddBufferFrom(0, static_cast<int64_t>(size), currentAudioTime), 278 MSERR_OK); 279 MEDIA_LOGI("UseUpBuffer time: %{public}" PRId64, static_cast<int64_t>(currentAudioTime)); 280 MEDIA_LOGI("UseUpBuffer size: %{public}" PRId64, static_cast<int64_t>(size)); 281 if (screenCaptureServer_->innerAudioCapture_->availBuffers_.front()) { 282 MEDIA_LOGI("UseUpBuffer ftime: %{public}" PRId64, static_cast<int64_t>( 283 screenCaptureServer_->innerAudioCapture_->availBuffers_.front()->timestamp)); 284 } 285 int32_t ret = screenCaptureServer_->innerAudioCapture_->UseUpAllLeftBufferUntil(currentAudioTime); 286 MEDIA_LOGI("UseUpBuffer ret: %{public}d", ret); 287 int64_t currentAudioTime1 = 0; 288 screenCaptureServer_->innerAudioCapture_->GetCurrentAudioTime(currentAudioTime1); 289 int64_t currentAudioTime2 = currentAudioTime1 - AUDIO_CAPTURE_READ_FRAME_TIME * 3; 290 screenCaptureServer_->innerAudioCapture_->AddBufferFrom(AUDIO_CAPTURE_READ_FRAME_TIME * 3, 291 static_cast<int64_t>(size), currentAudioTime2); 292 screenCaptureServer_->innerAudioCapture_->DropBufferUntil(currentAudioTime1); 293 MEDIA_LOGI("UseUpBuffer time: %{public}" PRId64, static_cast<int64_t>(currentAudioTime1)); 294 MEDIA_LOGI("UseUpBuffer before time: %{public}" PRId64, static_cast<int64_t>(currentAudioTime2)); 295 if (screenCaptureServer_->innerAudioCapture_->availBuffers_.front()) { 296 MEDIA_LOGI("UseUpBuffer ftime: %{public}" PRId64, static_cast<int64_t>( 297 screenCaptureServer_->innerAudioCapture_->availBuffers_.front()->timestamp)); 298 } 299 ret = screenCaptureServer_->innerAudioCapture_->UseUpAllLeftBufferUntil(currentAudioTime); 300 MEDIA_LOGI("UseUpBuffer 2 ret: %{public}d", ret); 301 sleep(RECORDER_TIME); 302 ASSERT_EQ(screenCaptureServer_->innerAudioCapture_->Stop(), MSERR_OK); 303 } 304 305 #ifdef SUPPORT_CALL 306 /** 307 * @tc.name: AudioCapturerWrapperInTelCall_001 308 * @tc.desc: start audio capture wrapper during telephone call 309 * @tc.type: FUNC 310 */ 311 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperStartInTelCall_001, TestSize.Level2) 312 { 313 SetValidConfig(); 314 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 315 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 316 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 317 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 318 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 319 screenCaptureServer_->micAudioCapture_ = std::make_shared<MicAudioCapturerWrapper>( 320 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo, screenCaptureServer_->screenCaptureCb_, 321 std::string("OS_MicAudioCapture"), screenCaptureServer_->contentFilter_); 322 screenCaptureServer_->micAudioCapture_->SetIsInTelCall(true); 323 ASSERT_NE(screenCaptureServer_->micAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 324 screenCaptureServer_->micAudioCapture_->screenCaptureCb_ = nullptr; 325 } 326 327 /** 328 * @tc.name: AudioCapturerWrapperInTelCall_002 329 * @tc.desc: resume audio capture wrapper during telephone call 330 * @tc.type: FUNC 331 */ 332 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperInTelCall_002, TestSize.Level2) 333 { 334 SetValidConfig(); 335 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 336 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 337 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 338 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 339 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 340 screenCaptureServer_->micAudioCapture_ = std::make_shared<MicAudioCapturerWrapper>( 341 screenCaptureServer_->captureConfig_.audioInfo.micCapInfo, screenCaptureServer_->screenCaptureCb_, 342 std::string("OS_MicAudioCapture"), screenCaptureServer_->contentFilter_); 343 ASSERT_EQ(screenCaptureServer_->micAudioCapture_->Start(screenCaptureServer_->appInfo_), MSERR_OK); 344 sleep(RECORDER_TIME); 345 screenCaptureServer_->micAudioCapture_->SetIsInTelCall(true); 346 } 347 #endif 348 349 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperAcquireAudioBuffer_001, TestSize.Level2) 350 { 351 SetValidConfig(); 352 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 353 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 354 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 355 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 356 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 357 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 358 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 359 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 360 screenCaptureServer_->innerAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RECORDING; 361 std::shared_ptr<AudioBuffer> audioBuffer; 362 ASSERT_NE(screenCaptureServer_->innerAudioCapture_->AcquireAudioBuffer(audioBuffer), MSERR_OK); 363 } 364 365 HWTEST_F(ScreenCaptureServerFunctionTest, AudioCapturerWrapperAcquireAudioBuffer_002, TestSize.Level2) 366 { 367 SetValidConfig(); 368 ASSERT_EQ(InitStreamScreenCaptureServer(), MSERR_OK); 369 screenCaptureServer_->audioSource_ = std::make_unique<AudioDataSource>( 370 AVScreenCaptureMixMode::MIX_MODE, screenCaptureServer_.get()); 371 screenCaptureServer_->captureCallback_ = std::make_shared<ScreenRendererAudioStateChangeCallback>(); 372 screenCaptureServer_->captureCallback_->SetAudioSource(screenCaptureServer_->audioSource_); 373 screenCaptureServer_->innerAudioCapture_ = std::make_shared<AudioCapturerWrapper>( 374 screenCaptureServer_->captureConfig_.audioInfo.innerCapInfo, screenCaptureServer_->screenCaptureCb_, 375 std::string("OS_InnerAudioCapture"), screenCaptureServer_->contentFilter_); 376 screenCaptureServer_->innerAudioCapture_->captureState_ = AudioCapturerWrapperState::CAPTURER_RELEASED; 377 std::shared_ptr<AudioBuffer> audioBuffer; 378 ASSERT_NE(screenCaptureServer_->innerAudioCapture_->AcquireAudioBuffer(audioBuffer), MSERR_OK); 379 } 380 } // Media 381 } // OHOS