• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <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 #include <nativetoken_kit.h>
25 
26 using namespace OHOS;
27 using namespace OHOS::Media;
28 using namespace testing::ext;
29 using namespace std;
30 using namespace OHOS::Rosen;
31 using namespace OHOS::Media::ScreenCaptureTestParam;
32 using namespace Security::AccessToken;
33 
34 namespace OHOS {
35 namespace Media {
36 namespace {
37     constexpr int32_t FLIE_CREATE_FLAGS = 0777;
38 }
OnError(int32_t errorCode)39 void ScreenCaptureUnitTestCallback::OnError(int32_t errorCode)
40 {
41     ASSERT_FALSE(screenCapture_->IsErrorCallbackEnabled());
42 }
43 
OnAudioBufferAvailable(bool isReady,AudioCaptureSourceType type)44 void ScreenCaptureUnitTestCallback::OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type)
45 {
46     ASSERT_FALSE(screenCapture_->IsDataCallbackEnabled());
47     if (!isReady) {
48         return;
49     }
50     std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
51     if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
52         if (audioBuffer == nullptr || audioBuffer->buffer == nullptr) {
53             MEDIA_LOGE("AcquireAudioBuffer failed, audio buffer empty, PLEASE CHECK IF IT IS OK!!!");
54             return;
55         }
56         MEDIA_LOGD("AcquireAudioBuffer, audioBufferLen:%{public}d, timeStamp:%{public}" PRId64
57             ", audioSourceType:%{public}d", audioBuffer->length, audioBuffer->timestamp, audioBuffer->sourcetype);
58         DumpAudioBuffer(audioBuffer);
59         if (!screenCapture_->IsStateChangeCallbackEnabled()) {
60             if (aFlag_ == 1) {
61                 screenCapture_->ReleaseAudioBuffer(type);
62             }
63         } else {
64             screenCapture_->ReleaseAudioBuffer(type);
65         }
66     }
67 }
68 
DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)69 void ScreenCaptureUnitTestCallback::DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)
70 {
71     if ((audioBuffer == nullptr) || (audioBuffer->buffer == nullptr)) {
72         MEDIA_LOGE("DumpAudioBuffer audioBuffer or audioBuffer->buffer is nullptr");
73         return;
74     }
75     if (!screenCapture_->IsStateChangeCallbackEnabled()) {
76         if (aFile_ == nullptr) {
77             MEDIA_LOGD("DumpAudioBuffer aFile_ is nullptr");
78             return;
79         }
80         if (fwrite(audioBuffer->buffer, 1, audioBuffer->length, aFile_) != static_cast<size_t>(audioBuffer->length)) {
81             MEDIA_LOGE("DumpAudioBuffer error occurred in fwrite");
82         }
83         return;
84     }
85 
86     AudioCaptureSourceType type = audioBuffer->sourcetype;
87     AVScreenCaptureBufferType bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_INVALID;
88     if (type == AudioCaptureSourceType::SOURCE_DEFAULT || type == AudioCaptureSourceType::MIC) {
89         bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC;
90         DumpBuffer(micAudioFile_, audioBuffer->buffer, audioBuffer->length, audioBuffer->timestamp, bufferType);
91         return;
92     }
93     if (type == AudioCaptureSourceType::ALL_PLAYBACK || type == AudioCaptureSourceType::APP_PLAYBACK) {
94         bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER;
95         DumpBuffer(innerAudioFile_, audioBuffer->buffer, audioBuffer->length, audioBuffer->timestamp, bufferType);
96         return;
97     }
98     MEDIA_LOGE("DumpAudioBuffer invalid bufferType:%{public}d, type:%{public}d", bufferType, type);
99 }
100 
OnVideoBufferAvailable(bool isReady)101 void ScreenCaptureUnitTestCallback::OnVideoBufferAvailable(bool isReady)
102 {
103     ASSERT_FALSE(screenCapture_->IsDataCallbackEnabled());
104     if (!isReady) {
105         return;
106     }
107     int32_t fence = 0;
108     int64_t timestamp = 0;
109     OHOS::Rect damage;
110     sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
111     if (surfacebuffer == nullptr) {
112         MEDIA_LOGE("surfacebuffer is nullptr");
113         return;
114     }
115     int32_t length = surfacebuffer->GetSize();
116     MEDIA_LOGD("AcquireVideoBuffer, videoBufferLen:%{public}d, videoBufferWidth:%{public}d,"
117         " videoBufferHeight:%{public}d, timestamp:%{public}" PRId64 ", size:%{public}d", surfacebuffer->GetSize(),
118         surfacebuffer->GetWidth(), surfacebuffer->GetHeight(), timestamp, length);
119     frameNumber++;
120     DumpVideoBuffer(surfacebuffer, timestamp);
121     if (!screenCapture_->IsStateChangeCallbackEnabled()) {
122         if (vFlag_ == 1) {
123             screenCapture_->ReleaseVideoBuffer();
124         }
125     } else {
126         screenCapture_->ReleaseVideoBuffer();
127     }
128 }
129 
DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer,int64_t timestamp)130 void ScreenCaptureUnitTestCallback::DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp)
131 {
132     if ((surfacebuffer == nullptr) || (surfacebuffer->GetVirAddr() == nullptr)) {
133         MEDIA_LOGE("DumpVideoBuffer surfacebuffer or surfacebuffer->GetVirAddr() is nullptr");
134         return;
135     }
136     if (!screenCapture_->IsStateChangeCallbackEnabled()) {
137         if (vFile_ == nullptr) {
138             MEDIA_LOGE("DumpVideoBuffer vFile_ is nullptr");
139             return;
140         }
141         if (fwrite(surfacebuffer->GetVirAddr(), 1, surfacebuffer->GetSize(), vFile_) != surfacebuffer->GetSize()) {
142             MEDIA_LOGE("DumpVideoBuffer error occurred in fwrite");
143         }
144         return;
145     }
146     DumpBuffer(videoFile_, reinterpret_cast<uint8_t *>(surfacebuffer->GetVirAddr()), surfacebuffer->GetSize(),
147         timestamp, AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
148 }
149 
OnError(int32_t errorCode,void * userData)150 void ScreenCaptureUnitTestCallback::OnError(int32_t errorCode, void *userData)
151 {
152     ASSERT_TRUE(screenCapture_->IsErrorCallbackEnabled());
153     MEDIA_LOGE("Error received, errorCode:%{public}d", errorCode);
154 }
155 
OnStateChange(AVScreenCaptureStateCode stateCode)156 void ScreenCaptureUnitTestCallback::OnStateChange(AVScreenCaptureStateCode stateCode)
157 {
158     MEDIA_LOGI("ScreenCaptureUnitTestCallback::OnStateChange stateCode:%{public}d", static_cast<int32_t>(stateCode));
159     screenCaptureState_.store(stateCode);
160 }
161 
OnCaptureContentChanged(AVScreenCaptureContentChangedEvent event,ScreenCaptureRect * area)162 void ScreenCaptureUnitTestCallback::OnCaptureContentChanged(AVScreenCaptureContentChangedEvent event,
163     ScreenCaptureRect* area)
164 {
165     MEDIA_LOGI("ScreenCaptureUnitTestCallback::OnCaptureContentChanged event:%{public}d", static_cast<int32_t>(event));
166     screenCaptureContentChange_.store(event);
167     area_ = area;
168 }
169 
OnDisplaySelected(uint64_t displayId)170 void ScreenCaptureUnitTestCallback::OnDisplaySelected(uint64_t displayId)
171 {
172     MEDIA_LOGI("ScreenCaptureUnitTestCallback::OnDisplaySelected displayId:%{public}" PRIu64, displayId);
173     screenCaptureDisplayId_ = displayId;
174 }
175 
OnBufferAvailable(std::shared_ptr<AVBuffer> buffer,AVScreenCaptureBufferType bufferType,int64_t timestamp)176 void ScreenCaptureUnitTestCallback::OnBufferAvailable(std::shared_ptr<AVBuffer> buffer,
177     AVScreenCaptureBufferType bufferType, int64_t timestamp)
178 {
179     ASSERT_TRUE(screenCapture_->IsDataCallbackEnabled());
180     MEDIA_LOGD("ScreenCaptureUnitTestCallback::OnBufferAvailable bufferType:%{public}d, timestamp:%{public}" PRId64,
181         bufferType, timestamp);
182     if (buffer == nullptr || buffer->memory_ == nullptr) {
183         return;
184     }
185     switch (bufferType) {
186         case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO: {
187             sptr<OHOS::SurfaceBuffer> surfaceBuffer = buffer->memory_->GetSurfaceBuffer();
188             if (surfaceBuffer == nullptr || surfaceBuffer->GetVirAddr() == nullptr) {
189                 MEDIA_LOGW("OnBufferAvailable videoBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!"
190                     "bufferType:%{public}d, timestamp:%{public}" PRId64, bufferType, timestamp);
191                 return;
192             }
193             ProcessVideoBuffer(surfaceBuffer, timestamp);
194             break;
195         }
196         case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER: // fall-through
197         case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC: {
198             uint8_t *auduioBuffer = buffer->memory_->GetAddr();
199             if (auduioBuffer == nullptr) {
200                 MEDIA_LOGW("OnBufferAvailable audioBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!"
201                     "bufferType:%{public}d, timestamp:%{public}" PRId64, bufferType, timestamp);
202                 return;
203             }
204             ProcessAudioBuffer(auduioBuffer, buffer->memory_->GetSize(), timestamp, bufferType);
205             break;
206         }
207         default:
208             MEDIA_LOGE("OnBufferAvailable received invalid bufferType:%{public}d, timestamp:%{public}" PRId64,
209                 bufferType, timestamp);
210             break;
211     }
212 }
213 
DumpBuffer(FILE * file,uint8_t * buffer,int32_t size,int64_t timestamp,AVScreenCaptureBufferType bufferType)214 void ScreenCaptureUnitTestCallback::DumpBuffer(FILE *file, uint8_t *buffer, int32_t size, int64_t timestamp,
215     AVScreenCaptureBufferType bufferType)
216 {
217     MEDIA_LOGD("DumpBuffer, bufferLen:%{public}d, bufferType:%{public}d, timestamp:%{public}" PRId64, size,
218         bufferType, timestamp);
219     if ((file == nullptr) || (buffer == nullptr)) {
220         MEDIA_LOGE("file or buffer is nullptr");
221         return;
222     }
223     if (fwrite(buffer, 1, size, file) != static_cast<size_t>(size)) {
224         MEDIA_LOGE("error occurred in fwrite");
225         return;
226     }
227 }
228 
CheckDataCallbackVideo(int32_t flag)229 void ScreenCaptureUnitTestCallback::CheckDataCallbackVideo(int32_t flag)
230 {
231     if (flag != 1) {
232         return;
233     }
234     if (screenCapture_->IsDataCallbackEnabled()) {
235         int32_t fence = 0;
236         int64_t timestamp = 0;
237         OHOS::Rect damage;
238         sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
239         EXPECT_EQ(nullptr, surfacebuffer);
240         EXPECT_NE(MSERR_OK, screenCapture_->ReleaseVideoBuffer());
241     }
242 }
243 
ProcessVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer,int64_t timestamp)244 void ScreenCaptureUnitTestCallback::ProcessVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp)
245 {
246     int32_t size = surfacebuffer->GetSize();
247     DumpBuffer(videoFile_, reinterpret_cast<uint8_t *>(surfacebuffer->GetVirAddr()), size, timestamp);
248     CheckDataCallbackVideo(videoFlag_);
249 }
250 
CheckDataCallbackAudio(AudioCaptureSourceType type,int32_t flag)251 void ScreenCaptureUnitTestCallback::CheckDataCallbackAudio(AudioCaptureSourceType type, int32_t flag)
252 {
253     if (flag != 1) {
254         return;
255     }
256     if (screenCapture_->IsDataCallbackEnabled()) {
257         std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
258         EXPECT_NE(MSERR_OK, screenCapture_->AcquireAudioBuffer(audioBuffer, type));
259         EXPECT_NE(MSERR_OK, screenCapture_->ReleaseAudioBuffer(type));
260     }
261 }
262 
ProcessAudioBuffer(uint8_t * buffer,int32_t size,int64_t timestamp,AVScreenCaptureBufferType bufferType)263 void ScreenCaptureUnitTestCallback::ProcessAudioBuffer(uint8_t *buffer, int32_t size, int64_t timestamp,
264     AVScreenCaptureBufferType bufferType)
265 {
266     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
267         DumpBuffer(innerAudioFile_, buffer, size, timestamp, bufferType);
268         CheckDataCallbackAudio(AudioCaptureSourceType::ALL_PLAYBACK, innerAudioFlag_);
269         return;
270     }
271     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC) {
272         DumpBuffer(micAudioFile_, buffer, size, timestamp, bufferType);
273         CheckDataCallbackAudio(AudioCaptureSourceType::MIC, micAudioFlag_);
274         return;
275     }
276     MEDIA_LOGE("DumpAudioBuffer invalid bufferType:%{public}d", bufferType);
277 }
278 
GetFrameNumber()279 int32_t ScreenCaptureUnitTestCallback::GetFrameNumber()
280 {
281     int32_t tempNum = frameNumber;
282     frameNumber = 0;
283     return tempNum;
284 }
285 
InitCaptureTrackInfo(FILE * file,int32_t flag,AVScreenCaptureBufferType bufferType)286 void ScreenCaptureUnitTestCallback::InitCaptureTrackInfo(FILE *file, int32_t flag, AVScreenCaptureBufferType bufferType)
287 {
288     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO) {
289         videoFile_ = file;
290         videoFlag_ = flag;
291     }
292     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
293         innerAudioFile_ = file;
294         innerAudioFlag_ = flag;
295     }
296     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC) {
297         micAudioFile_ = file;
298         micAudioFlag_ = flag;
299     }
300 }
301 
302 const std::string ScreenCaptureUnitTest::SCREEN_CAPTURE_ROOT_DIR = "/data/test/media/";
303 
SetAccessTokenPermission()304 void ScreenCaptureUnitTest::SetAccessTokenPermission()
305 {
306     vector<string> permission;
307     permission.push_back("ohos.permission.MICROPHONE");
308     permission.push_back("ohos.permission.READ_MEDIA");
309     permission.push_back("ohos.permission.WRITE_MEDIA");
310     uint64_t tokenId = 0;
311 
312     auto perms = std::make_unique<const char* []>(permission.size());
313     for (size_t i = 0; i < permission.size(); i++) {
314         perms[i] = permission[i].c_str();
315     }
316     NativeTokenInfoParams infoInstance = {
317         .dcapsNum = 0,
318         .permsNum = static_cast<int32_t>(permission.size()),
319         .aclsNum = 0,
320         .dcaps = nullptr,
321         .perms = perms.get(),
322         .acls = nullptr,
323         .processName = "avscreencapture_unittest",
324         .aplStr = "system_basic",
325     };
326     tokenId = GetAccessTokenId(&infoInstance);
327     if (tokenId == 0) {
328         MEDIA_LOGE("Get Access Token Id Failed");
329         return;
330     }
331     int ret = SetSelfTokenID(tokenId);
332     if (ret != 0) {
333         MEDIA_LOGE("Set Acess Token Id failed");
334         return;
335     }
336     ret = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
337     if (ret < 0) {
338         MEDIA_LOGE("Reload Native Token Info Failed");
339     }
340 }
341 
SetHapPermission()342 void ScreenCaptureUnitTest::SetHapPermission()
343 {
344     HapInfoParams info = {
345         .userID = 100, // 100 UserID
346         .bundleName = "com.ohos.test.screencapturetdd",
347         .instIndex = 0, // 0 index
348         .appIDDesc = "com.ohos.test.screencapturetdd",
349         .isSystemApp = true
350     };
351 
352     HapPolicyParams policy = {
353         .apl = APL_SYSTEM_BASIC,
354         .domain = "test.domain.screencapturetdd",
355         .permList = { },
356         .permStateList = {
357             {
358                 .permissionName = "ohos.permission.MICROPHONE",
359                 .isGeneral = true,
360                 .resDeviceID = { "local" },
361                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
362                 .grantFlags = { 1 }
363             },
364             {
365                 .permissionName = "ohos.permission.READ_MEDIA",
366                 .isGeneral = true,
367                 .resDeviceID = { "local" },
368                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
369                 .grantFlags = { 1 }
370             },
371             {
372                 .permissionName = "ohos.permission.WRITE_MEDIA",
373                 .isGeneral = true,
374                 .resDeviceID = { "local" },
375                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
376                 .grantFlags = { 1 }
377             },
378             {
379                 .permissionName = "ohos.permission.KEEP_BACKGROUND_RUNNING",
380                 .isGeneral = true,
381                 .resDeviceID = { "local" },
382                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
383                 .grantFlags = { 1 }
384             }
385         }
386     };
387     AccessTokenIDEx tokenIdEx = { 0 };
388     tokenIdEx = AccessTokenKit::AllocHapToken(info, policy);
389     int ret = SetSelfTokenID(tokenIdEx.tokenIDEx);
390     if (ret != 0) {
391         MEDIA_LOGE("Set hap token failed, err: %{public}d", ret);
392     }
393 }
394 
SetUpTestCase(void)395 void ScreenCaptureUnitTest::SetUpTestCase(void)
396 {
397     SetHapPermission();
398 }
399 
TearDownTestCase(void)400 void ScreenCaptureUnitTest::TearDownTestCase(void)
401 {
402     AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(100,
403         "com.ohos.test.screencapturetdd", 0); // 100 UserId 0 Index
404     AccessTokenKit::DeleteToken(tokenId);
405 }
406 
SetUp(void)407 void ScreenCaptureUnitTest::SetUp(void)
408 {
409     screenCapture_ = ScreenCaptureMockFactory::CreateScreenCapture();
410     ASSERT_NE(nullptr, screenCapture_);
411 }
412 
TearDown(void)413 void ScreenCaptureUnitTest::TearDown(void)
414 {
415     if (screenCaptureCb_ != nullptr) {
416         screenCaptureCb_.reset();
417         screenCaptureCb_ = nullptr;
418     }
419     if (screenCapture_ != nullptr) {
420         screenCapture_->Release();
421         screenCapture_ = nullptr;
422     }
423     CloseFile();
424 }
425 
SetConfig(AVScreenCaptureConfig & config)426 int32_t ScreenCaptureUnitTest::SetConfig(AVScreenCaptureConfig &config)
427 {
428     AudioCaptureInfo miccapinfo = {
429         .audioSampleRate = 16000,
430         .audioChannels = 2,
431         .audioSource = SOURCE_DEFAULT
432     };
433 
434     AudioCaptureInfo innercapinfo = {
435         .audioSampleRate = 16000,
436         .audioChannels = 2,
437         .audioSource = SOURCE_DEFAULT
438     };
439 
440     VideoCaptureInfo videocapinfo = {
441         .videoFrameWidth = 720,
442         .videoFrameHeight = 1280,
443         .videoSource = VIDEO_SOURCE_SURFACE_RGBA
444     };
445 
446     VideoEncInfo videoEncInfo = {
447         .videoCodec = VideoCodecFormat::H264,
448         .videoBitrate = 2000000,
449         .videoFrameRate = 30
450     };
451 
452     AudioInfo audioinfo = {
453         .micCapInfo = miccapinfo,
454         .innerCapInfo = innercapinfo,
455     };
456 
457     VideoInfo videoinfo = {
458         .videoCapInfo = videocapinfo,
459         .videoEncInfo = videoEncInfo
460     };
461 
462     config = {
463         .captureMode = CAPTURE_HOME_SCREEN,
464         .dataType = ORIGINAL_STREAM,
465         .audioInfo = audioinfo,
466         .videoInfo = videoinfo
467     };
468     return MSERR_OK;
469 }
470 
SetConfigFile(AVScreenCaptureConfig & config,RecorderInfo & recorderInfo)471 int32_t ScreenCaptureUnitTest::SetConfigFile(AVScreenCaptureConfig &config, RecorderInfo &recorderInfo)
472 {
473     AudioEncInfo audioEncInfo = {
474         .audioBitrate = 48000,
475         .audioCodecformat = AudioCodecFormat::AAC_LC
476     };
477 
478     VideoCaptureInfo videoCapInfo = {
479         .videoFrameWidth = 720,
480         .videoFrameHeight = 1080,
481         .videoSource = VideoSourceType::VIDEO_SOURCE_SURFACE_RGBA
482     };
483 
484     VideoEncInfo videoEncInfo = {
485         .videoCodec = VideoCodecFormat::H264,
486         .videoBitrate = 2000000,
487         .videoFrameRate = 30
488     };
489 
490     AudioCaptureInfo innerCapInfo = {
491         .audioSampleRate = 0,
492         .audioChannels = 0,
493         .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
494     };
495 
496     AudioCaptureInfo micCapInfo = {
497         .audioSampleRate = 0,
498         .audioChannels = 0,
499         .audioSource = AudioCaptureSourceType::SOURCE_DEFAULT
500     };
501 
502     AudioInfo audioInfo = {
503         .micCapInfo = micCapInfo,
504         .innerCapInfo = innerCapInfo,
505         .audioEncInfo = audioEncInfo
506     };
507 
508     VideoInfo videoInfo = {
509         .videoCapInfo = videoCapInfo,
510         .videoEncInfo = videoEncInfo
511     };
512 
513     config = {
514         .captureMode = CaptureMode::CAPTURE_HOME_SCREEN,
515         .dataType = DataType::CAPTURE_FILE,
516         .audioInfo = audioInfo,
517         .videoInfo = videoInfo,
518         .recorderInfo = recorderInfo
519     };
520     return MSERR_OK;
521 }
522 
OpenFile(std::string name,bool isInnerAudioEnabled,bool isMicAudioEnabled,bool isVideoEnabled)523 void ScreenCaptureUnitTest::OpenFile(std::string name, bool isInnerAudioEnabled, bool isMicAudioEnabled,
524     bool isVideoEnabled)
525 {
526     if (isInnerAudioEnabled) {
527         std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s_inner.pcm";
528         if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
529             name.c_str()) >= 0) {
530             innerAudioFile_ = fopen(fileName, "w+");
531             if (innerAudioFile_ == nullptr) {
532                 cout << "micAudioFile_ open failed, " << strerror(errno) << endl;
533             }
534         } else {
535             cout << "snprintf micAudioFile_ failed, " << strerror(errno) << endl;
536             return;
537         }
538     }
539     if (isMicAudioEnabled) {
540         std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s_mic.pcm";
541         if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
542             name.c_str()) >= 0) {
543             micAudioFile_ = fopen(fileName, "w+");
544             if (micAudioFile_ == nullptr) {
545                 cout << "micAudioFile_ open failed, " << strerror(errno) << endl;
546             }
547         } else {
548             cout << "snprintf micAudioFile_ failed, " << strerror(errno) << endl;
549             return;
550         }
551     }
552     if (isVideoEnabled) {
553         std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s.yuv";
554         if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
555             name.c_str()) >= 0) {
556             videoFile_ = fopen(fileName, "w+");
557             if (videoFile_ == nullptr) {
558                 cout << "videoFile_ open failed, " << strerror(errno) << endl;
559             }
560         } else {
561             cout << "snprintf videoFile_ failed, " << strerror(errno) << endl;
562             return;
563         }
564     }
565 }
566 
SetRecorderInfo(std::string name,RecorderInfo & recorderInfo)567 int32_t ScreenCaptureUnitTest::SetRecorderInfo(std::string name, RecorderInfo &recorderInfo)
568 {
569     OpenFileFd(name);
570     recorderInfo.url = "fd://" + to_string(outputFd_);
571     recorderInfo.fileFormat = "mp4";
572     return MSERR_OK;
573 }
574 
OpenFileFd(std::string name)575 void ScreenCaptureUnitTest::OpenFileFd(std::string name)
576 {
577     CloseFile();
578     outputFd_ = open((SCREEN_CAPTURE_ROOT_DIR + name).c_str(), O_RDWR | O_CREAT, FLIE_CREATE_FLAGS);
579 }
580 
OpenFile(std::string name)581 void ScreenCaptureUnitTest::OpenFile(std::string name)
582 {
583     CloseFile();
584     std::string nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s.pcm";
585     if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
586         name.c_str()) >= 0) {
587         aFile = fopen(fileName, "w+");
588         if (aFile == nullptr) {
589             cout << "aFile audio open failed, " << strerror(errno) << endl;
590         }
591     } else {
592         cout << "snprintf audio file failed, " << strerror(errno) << endl;
593         return;
594     }
595     nameFormt = SCREEN_CAPTURE_ROOT_DIR + "%s.yuv";
596     if (snprintf_s(fileName, sizeof(fileName), sizeof(fileName) - 1, nameFormt.c_str(),
597         name.c_str()) >= 0) {
598         vFile = fopen(fileName, "w+");
599         if (vFile == nullptr) {
600             cout << "vFile video open failed, " << strerror(errno) << endl;
601         }
602     } else {
603         cout << "snprintf video file failed, " << strerror(errno) << endl;
604         return;
605     }
606 }
607 
CloseFile(void)608 void ScreenCaptureUnitTest::CloseFile(void)
609 {
610     if (aFile != nullptr) {
611         fclose(aFile);
612         aFile = nullptr;
613     }
614     if (vFile != nullptr) {
615         fclose(vFile);
616         vFile = nullptr;
617     }
618     if (videoFile_ != nullptr) {
619         fclose(videoFile_);
620         videoFile_ = nullptr;
621     }
622     if (innerAudioFile_ != nullptr) {
623         fclose(innerAudioFile_);
624         innerAudioFile_ = nullptr;
625     }
626     if (micAudioFile_ != nullptr) {
627         fclose(micAudioFile_);
628         micAudioFile_ = nullptr;
629     }
630     if (outputFd_ != -1) {
631         (void)::close(outputFd_);
632         outputFd_ = -1;
633     }
634 }
635 
AudioLoop(void)636 void ScreenCaptureUnitTest::AudioLoop(void)
637 {
638     int index_ = 200;
639     int index_audio_frame = 0;
640     while (index_) {
641         if (screenCapture_ == nullptr) {
642             break;
643         }
644         std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
645         AudioCaptureSourceType type = MIC;
646         if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
647             if (audioBuffer == nullptr) {
648                 MEDIA_LOGE("AcquireAudioBuffer failed, audio buffer is nullptr");
649                 continue;
650             }
651             MEDIA_LOGD("index audio:%{public}d, audioBufferLen:%{public}d, timestamp:%{public}" PRId64
652                 ", audioSourceType:%{public}d", index_audio_frame++, audioBuffer->length, audioBuffer->timestamp,
653                 audioBuffer->sourcetype);
654             screenCapture_->ReleaseAudioBuffer(type);
655         } else {
656             MEDIA_LOGE("AcquireAudioBuffer failed");
657         }
658         index_--;
659     }
660 }
661 
AudioLoopWithoutRelease(void)662 void ScreenCaptureUnitTest::AudioLoopWithoutRelease(void)
663 {
664     int index_ = 200;
665     int index_audio_frame = 0;
666     while (index_) {
667         if (screenCapture_ == nullptr) {
668             break;
669         }
670         std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
671         AudioCaptureSourceType type = MIC;
672         if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
673             if (audioBuffer == nullptr) {
674                 MEDIA_LOGE("AcquireAudioBuffer failed, audio buffer is nullptr");
675                 continue;
676             }
677             MEDIA_LOGD("index audio:%{public}d, audioBufferLen:%{public}d, timestamp:%{public}" PRId64
678                 ", audioSourceType:%{public}d", index_audio_frame++, audioBuffer->length, audioBuffer->timestamp,
679                 audioBuffer->sourcetype);
680         } else {
681             MEDIA_LOGE("AcquireAudioBuffer failed");
682         }
683         index_--;
684     }
685 }
686 
OnBufferAvailable()687 void ScreenCapBufferDemoConsumerListener::OnBufferAvailable()
688 {
689     int32_t flushFence = 0;
690     int64_t timestamp = 0;
691     OHOS::Rect damage;
692     OHOS::sptr<OHOS::SurfaceBuffer> buffer = nullptr;
693     consumer_->AcquireBuffer(buffer, flushFence, timestamp, damage);
694     if (buffer != nullptr) {
695         MEDIA_LOGD("AcquireBuffer, videoBufferLen:%{public}d, videoBufferWidth:%{public}d,"
696             "videoBufferHeight:%{public}d, timestamp:%{public}" PRId64, buffer->GetSize(), buffer->GetWidth(),
697             buffer->GetHeight(), timestamp);
698     } else {
699         MEDIA_LOGE("buffer empty");
700     }
701     consumer_->ReleaseBuffer(buffer, flushFence);
702 }
703 
704 /**
705  * @tc.name: screen_capture_specified_window_cb_01
706  * @tc.desc: open microphone, capture screen, inner audio, mic audio
707  * @tc.type: FUNC
708  * @tc.require: play something audio resource to get inner audio
709  */
710 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_01, TestSize.Level2)
711 {
712     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 before");
713     SetConfig(config_);
714     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
715     config_.audioInfo.innerCapInfo.audioChannels = 2;
716     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
717     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
718     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
719     std::string deviceId = "";
720     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
721     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
722     MEDIA_LOGI("screen_capture_specified_window_cb_01 missionInfos size:%{public}s, result:%{public}d",
723         std::to_string(missionInfos.size()).c_str(), result);
724     if (missionInfos.size() > 0) {
725         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
726             MEDIA_LOGI("screen_capture_specified_window_cb_01 missionId:%{public}d", info.id);
727             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
728         }
729     } else {
730         MEDIA_LOGE("screen_capture_specified_window_cb_01 GetMissionInfos failed");
731     }
732 
733     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
734     ASSERT_NE(nullptr, screenCaptureCb_);
735     std::string name = "screen_capture_specified_window_cb_01";
736     // track enalbed: inner: true, mic: true, video: true
737     OpenFile(name, true, true, true);
738     // check track aquire & release: inner: 1, mic: 1, video: 1
739     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
740     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
741     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
742     bool isMicrophone = true; // Enable Mic
743     screenCapture_->SetMicrophoneEnabled(isMicrophone);
744     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
745     // captureContentChangeCallback: true
746     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
747 
748     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
749     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
750     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
751     sleep(RECORDER_TIME);
752     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
753     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
754     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
755     CloseFile();
756     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 after");
757 }
758 
759 /**
760  * @tc.name: screen_capture_specified_window_cb_02
761  * @tc.desc: diable microphone, capture screen, inner audio, mic audio
762  * @tc.type: FUNC
763  * @tc.require: play something audio resource to get inner audio
764  */
765 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_02, TestSize.Level2)
766 {
767     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 before");
768     SetConfig(config_);
769     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
770     config_.audioInfo.innerCapInfo.audioChannels = 2;
771     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
772     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
773     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
774     std::string deviceId = "";
775     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
776     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
777     MEDIA_LOGI("screen_capture_specified_window_cb_02 missionInfos size:%{public}s, result:%{public}d",
778         std::to_string(missionInfos.size()).c_str(), result);
779     if (missionInfos.size() > 0) {
780         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
781             MEDIA_LOGI("screen_capture_specified_window_cb_02 missionId:%{public}d", info.id);
782             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
783         }
784     } else {
785         MEDIA_LOGE("screen_capture_specified_window_cb_02 GetMissionInfos failed");
786     }
787 
788     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
789     ASSERT_NE(nullptr, screenCaptureCb_);
790     std::string name = "screen_capture_specified_window_cb_02";
791     // track enalbed: inner: true, mic: true, video: true
792     OpenFile(name, true, true, true);
793     // check track aquire & release: inner: 1, mic: 1, video: 1
794     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
795     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
796     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
797     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
798     // captureContentChangeCallback: true
799     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
800 
801     screenCapture_->SetMicrophoneEnabled(false); // Enable Mic
802     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
803     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
804     sleep(RECORDER_TIME);
805     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
806     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
807     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
808     CloseFile();
809     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 after");
810 }
811 
812 /**
813  * @tc.name: screen_capture_specified_window_cb_03
814  * @tc.desc: Enable microphone, capture screen, mic audio
815  * @tc.type: FUNC
816  * @tc.require:
817  */
818 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_03, TestSize.Level2)
819 {
820     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 before");
821     SetConfig(config_);
822     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
823     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
824     std::string deviceId = "";
825     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
826     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
827     MEDIA_LOGI("screen_capture_specified_window_cb_03 missionInfos size:%{public}s, result:%{public}d",
828         std::to_string(missionInfos.size()).c_str(), result);
829     if (missionInfos.size() > 0) {
830         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
831             MEDIA_LOGI("screen_capture_specified_window_cb_03 missionId:%{public}d", info.id);
832             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
833         }
834     } else {
835         MEDIA_LOGE("screen_capture_specified_window_cb_03 GetMissionInfos failed");
836     }
837 
838     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
839     ASSERT_NE(nullptr, screenCaptureCb_);
840     std::string name = "screen_capture_specified_window_cb_03";
841     // track enalbed: inner: false, mic: true, video: true
842     OpenFile(name, false, true, true);
843     // check track aquire & release: inner: 1, mic: 1, video: 1
844     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
845     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
846     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
847     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
848     // captureContentChangeCallback: true
849     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
850 
851     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
852     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
853     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
854     sleep(RECORDER_TIME);
855     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
856     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
857     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
858     CloseFile();
859     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 after");
860 }
861 
862 /**
863  * @tc.name: screen_capture_specified_window_cb_04
864  * @tc.desc: Enable microphone, capture screen, inner audio
865  * @tc.type: FUNC
866  * @tc.require: play something audio resource to get inner audio
867  */
868 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_04, TestSize.Level2)
869 {
870     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 before");
871     SetConfig(config_);
872     config_.audioInfo.micCapInfo.audioSampleRate = 0;
873     config_.audioInfo.micCapInfo.audioChannels = 0;
874     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
875     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
876     config_.audioInfo.innerCapInfo.audioChannels = 2;
877     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
878     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
879     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
880     std::string deviceId = "";
881     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
882     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
883     MEDIA_LOGI("screen_capture_specified_window_cb_04 missionInfos size:%{public}s, result:%{public}d",
884         std::to_string(missionInfos.size()).c_str(), result);
885     if (missionInfos.size() > 0) {
886         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
887             MEDIA_LOGI("screen_capture_specified_window_cb_04 missionId:%{public}d", info.id);
888             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
889         }
890     } else {
891         MEDIA_LOGE("screen_capture_specified_window_cb_04 GetMissionInfos failed");
892     }
893 
894     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
895     ASSERT_NE(nullptr, screenCaptureCb_);
896     std::string name = "screen_capture_specified_window_cb_04";
897     // track enalbed: inner: true, mic: false, video: true
898     OpenFile(name, true, false, true);
899     // check track aquire & release: inner: 1, mic: 1, video: 1
900     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
901     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
902     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
903     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
904     // captureContentChangeCallback: true
905     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
906 
907     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
908     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
909     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
910     sleep(RECORDER_TIME);
911     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
912     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
913     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
914     CloseFile();
915     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 after");
916 }
917 
918 /**
919  * @tc.name: screen_capture_specified_window_cb_05
920  * @tc.desc: Enable microphone, capture inner audio, mic audio
921  * @tc.type: FUNC
922  * @tc.require: play something audio resource to get inner audio
923  */
924 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_05, TestSize.Level2)
925 {
926     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 before");
927     SetConfig(config_);
928     config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
929     config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
930     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
931     config_.audioInfo.innerCapInfo.audioChannels = 2;
932     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
933     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
934     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
935     std::string deviceId = "";
936     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
937     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
938     MEDIA_LOGI("screen_capture_specified_window_cb_05 missionInfos size:%{public}s, result:%{public}d",
939         std::to_string(missionInfos.size()).c_str(), result);
940     if (missionInfos.size() > 0) {
941         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
942             MEDIA_LOGI("screen_capture_specified_window_cb_05 missionId:%{public}d", info.id);
943             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
944         }
945     } else {
946         MEDIA_LOGE("screen_capture_specified_window_cb_05 GetMissionInfos failed");
947     }
948 
949     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
950     ASSERT_NE(nullptr, screenCaptureCb_);
951     std::string name = "screen_capture_specified_window_cb_05";
952     // track enalbed: inner: true, mic: true, video: false
953     OpenFile(name, true, true, false);
954     // check track aquire & release: inner: 1, mic: 1, video: 1
955     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
956     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
957     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
958     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
959     // captureContentChangeCallback: true
960     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
961 
962     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
963     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
964     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
965     sleep(RECORDER_TIME);
966     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
967     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
968     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
969     CloseFile();
970     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 after");
971 }
972 
973 /**
974  * @tc.name: screen_capture_specified_window_cb_06
975  * @tc.desc: Enable microphone, capture inner audio only
976  * @tc.type: FUNC
977  * @tc.require: play something audio resource to get inner audio
978  */
979 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_06, TestSize.Level2)
980 {
981     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 before");
982     SetConfig(config_);
983     config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
984     config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
985     config_.audioInfo.micCapInfo.audioSampleRate = 0;
986     config_.audioInfo.micCapInfo.audioChannels = 0;
987     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
988     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
989     config_.audioInfo.innerCapInfo.audioChannels = 2;
990     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
991     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
992     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
993     std::string deviceId = "";
994     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
995     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
996     MEDIA_LOGI("screen_capture_specified_window_cb_06 missionInfos size:%{public}s, result:%{public}d",
997         std::to_string(missionInfos.size()).c_str(), result);
998     if (missionInfos.size() > 0) {
999         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
1000             MEDIA_LOGI("screen_capture_specified_window_cb_06 missionId:%{public}d", info.id);
1001             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
1002         }
1003     } else {
1004         MEDIA_LOGE("screen_capture_specified_window_cb_06 GetMissionInfos failed");
1005     }
1006 
1007     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1008     ASSERT_NE(nullptr, screenCaptureCb_);
1009     std::string name = "screen_capture_specified_window_cb_06";
1010     // track enalbed: inner: true, mic: false, video: false
1011     OpenFile(name, true, false, false);
1012     // check track aquire & release: inner: 1, mic: 1, video: 1
1013     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1014     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1015     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1016     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
1017     // captureContentChangeCallback: true
1018     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
1019 
1020     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1021     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1022     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
1023     sleep(RECORDER_TIME);
1024     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1025     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1026     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1027     CloseFile();
1028     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 after");
1029 }
1030 
OnScreenCaptureStarted(int32_t pid)1031 void ScreenCaptureMonitorListenerMock::OnScreenCaptureStarted(int32_t pid)
1032 {
1033     MEDIA_LOGI("OnScreenCaptureStarted pid %{public}d name %{public}s", pid, name_.c_str());
1034     stateFlag_ = 1; // 1 start
1035 }
1036 
OnScreenCaptureFinished(int32_t pid)1037 void ScreenCaptureMonitorListenerMock::OnScreenCaptureFinished(int32_t pid)
1038 {
1039     MEDIA_LOGI("OnScreenCaptureFinished pid %{public}d name %{public}s", pid, name_.c_str());
1040     stateFlag_ = 2; // 2 finish
1041 }
1042 
BeforeScreenCaptureSpecifiedWindowCbCase07(void)1043 void ScreenCaptureUnitTest::BeforeScreenCaptureSpecifiedWindowCbCase07(void)
1044 {
1045     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 before");
1046     SetConfig(config_);
1047     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1048     config_.audioInfo.micCapInfo.audioChannels = 0;
1049     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1050     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
1051 }
1052 /**
1053  * @tc.name: screen_capture_specified_window_cb_07
1054  * @tc.desc: Enable microphone, capture screen only
1055  * @tc.type: FUNC
1056  * @tc.require:
1057  */
1058 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_07, TestSize.Level2)
1059 {
1060     BeforeScreenCaptureSpecifiedWindowCbCase07();
1061     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
1062     std::string deviceId = "";
1063     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
1064     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
1065     MEDIA_LOGI("screen_capture_specified_window_cb_07 missionInfos size:%{public}s, result:%{public}d",
1066         std::to_string(missionInfos.size()).c_str(), result);
1067     if (missionInfos.size() > 0) {
1068         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
1069             MEDIA_LOGI("screen_capture_specified_window_cb_07 missionId:%{public}d", info.id);
1070             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
1071         }
1072     } else {
1073         MEDIA_LOGE("screen_capture_specified_window_cb_07 GetMissionInfos failed");
1074     }
1075     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1076     ASSERT_NE(nullptr, screenCaptureCb_);
1077     std::string name = "screen_capture_specified_window_cb_07";
1078     OpenFile(name, false, false, true);
1079     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1080     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1081     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1082     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
1083     // captureContentChangeCallback: true
1084     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
1085     sptr<ScreenCaptureMonitor::ScreenCaptureMonitorListener> screenCaptureMonitorListener1 =
1086         new ScreenCaptureMonitorListenerMock("scm1");
1087     sptr<ScreenCaptureMonitor::ScreenCaptureMonitorListener> screenCaptureMonitorListener2 =
1088         new ScreenCaptureMonitorListenerMock("scm2");
1089     EXPECT_EQ(0,
1090         static_cast<ScreenCaptureMonitorListenerMock *>(screenCaptureMonitorListener1.GetRefPtr())->stateFlag_);
1091     ScreenCaptureMonitor::GetInstance()->RegisterScreenCaptureMonitorListener(screenCaptureMonitorListener1);
1092     ScreenCaptureMonitor::GetInstance()->RegisterScreenCaptureMonitorListener(screenCaptureMonitorListener2);
1093     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1094     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1095     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
1096     sleep(RECORDER_TIME);
1097     EXPECT_NE(0, (ScreenCaptureMonitor::GetInstance()->IsScreenCaptureWorking()).size());
1098     EXPECT_EQ(1, // 1 start
1099         static_cast<ScreenCaptureMonitorListenerMock *>(screenCaptureMonitorListener1.GetRefPtr())->stateFlag_);
1100     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1101     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1102     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1103     EXPECT_EQ(2, // 1 finish
1104         static_cast<ScreenCaptureMonitorListenerMock *>(screenCaptureMonitorListener1.GetRefPtr())->stateFlag_);
1105     ScreenCaptureMonitor::GetInstance()->UnregisterScreenCaptureMonitorListener(screenCaptureMonitorListener1);
1106     ScreenCaptureMonitor::GetInstance()->UnregisterScreenCaptureMonitorListener(screenCaptureMonitorListener2);
1107     EXPECT_EQ(0, (ScreenCaptureMonitor::GetInstance()->IsScreenCaptureWorking()).size());
1108     CloseFile();
1109     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 after");
1110 }
1111 
1112 /**
1113  * @tc.name: screen_capture_save_file_cb_01
1114  * @tc.desc: do screencapture capture file mode, capture inner audio and mic audio
1115  * @tc.type: FUNC
1116  * @tc.require: play something audio resource to get inner audio
1117  */
1118 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_cb_01, TestSize.Level2)
1119 {
1120     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_01 before");
1121     RecorderInfo recorderInfo;
1122     SetRecorderInfo("screen_capture_save_file_cb_01.mp4", recorderInfo);
1123     SetConfigFile(config_, recorderInfo);
1124     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1125     config_.audioInfo.innerCapInfo.audioChannels = 2;
1126     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1127 
1128     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1129     ASSERT_NE(nullptr, screenCaptureCb_);
1130     // callback enabled: errorCallback: true, dataCallback: false, stateChangeCallback: true,
1131     // captureContentChangeCallback: true
1132     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, false, true, true));
1133 
1134     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1135     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1136     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording());
1137     sleep(RECORDER_TIME);
1138     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1139     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording());
1140     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1141     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_01 after");
1142 }
1143 
1144 /**
1145  * @tc.name: screen_capture_save_file_cb_02
1146  * @tc.desc: do screencapture capture file mode, capture inner audio
1147  * @tc.type: FUNC
1148  * @tc.require: play something audio resource to get inner audio
1149  */
1150 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_cb_02, TestSize.Level2)
1151 {
1152     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_02 before");
1153     RecorderInfo recorderInfo;
1154     SetRecorderInfo("screen_capture_save_file_cb_02.mp4", recorderInfo);
1155     SetConfigFile(config_, recorderInfo);
1156     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1157     config_.audioInfo.micCapInfo.audioChannels = 0;
1158     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1159     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1160     config_.audioInfo.innerCapInfo.audioChannels = 2;
1161     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1162 
1163     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1164     ASSERT_NE(nullptr, screenCaptureCb_);
1165     // callback enabled: errorCallback: true, dataCallback: false, stateChangeCallback: true,
1166     // captureContentChangeCallback: true
1167     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, false, true, true));
1168 
1169     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1170     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1171     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording());
1172     sleep(RECORDER_TIME);
1173     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1174     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording());
1175     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1176     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_02 after");
1177 }
1178 
1179 /**
1180  * @tc.name: screen_capture_with_surface_cb_01
1181  * @tc.desc: do screencapture capture surface mode, capture screen, inner audio and mic audio
1182  * @tc.type: FUNC
1183  * @tc.require: play something audio resource to get inner audio
1184  */
1185 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_01, TestSize.Level2)
1186 {
1187     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 before");
1188     SetConfig(config_);
1189     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1190     config_.audioInfo.innerCapInfo.audioChannels = 2;
1191     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1192     bool isMicrophone = true;
1193     screenCapture_->SetMicrophoneEnabled(isMicrophone);
1194     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 CreateRecorder");
1195     std::shared_ptr<Recorder> recorder = nullptr;
1196     recorder = RecorderFactory::CreateRecorder();
1197     int32_t videoSourceId = 0;
1198     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1199     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1200     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1201     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1202     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1203     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1204     OpenFileFd("screen_capture_with_surface_cb_01.mp4");
1205     ASSERT_TRUE(outputFd_ >= 0);
1206     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1207     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1208     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1209 
1210     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1211     ASSERT_NE(nullptr, screenCaptureCb_);
1212 
1213     std::string name = "screen_capture_with_surface_cb_01";
1214     // track enalbed: inner: true, mic: true, video: true(surface mode)
1215     OpenFile(name, true, true, false);
1216     // check track aquire & release: inner: 1, mic: 1, video: 1
1217     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1218     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1219     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1220     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
1221     // captureContentChangeCallback: true
1222     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
1223 
1224     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1225     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1226     EXPECT_EQ(MSERR_OK, recorder->Start());
1227     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 recorder Start");
1228     sleep(RECORDER_TIME);
1229     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1230     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1231     EXPECT_EQ(MSERR_OK, recorder->Reset());
1232     EXPECT_EQ(MSERR_OK, recorder->Release());
1233     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1234     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1235     CloseFile();
1236     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 after");
1237 }
1238 
1239 /**
1240  * @tc.name: screen_capture_with_surface_cb_02
1241  * @tc.desc: do screencapture capture surface mode, capture screen and inner audio
1242  * @tc.type: FUNC
1243  * @tc.require: play something audio resource to get inner audio
1244  */
1245 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_02, TestSize.Level2)
1246 {
1247     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 before");
1248     SetConfig(config_);
1249     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1250     config_.audioInfo.micCapInfo.audioChannels = 0;
1251     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1252     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1253     config_.audioInfo.innerCapInfo.audioChannels = 2;
1254     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1255     screenCapture_->SetMicrophoneEnabled(true);
1256     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 CreateRecorder");
1257     std::shared_ptr<Recorder> recorder = nullptr;
1258     recorder = RecorderFactory::CreateRecorder();
1259     int32_t videoSourceId = 0;
1260     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1261     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1262     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1263     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1264     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1265     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1266     OpenFileFd("screen_capture_with_surface_cb_02.mp4");
1267     ASSERT_TRUE(outputFd_ >= 0);
1268     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1269     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1270     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1271 
1272     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1273     ASSERT_NE(nullptr, screenCaptureCb_);
1274 
1275     std::string name = "screen_capture_with_surface_cb_02";
1276     // track enalbed: inner: true, mic: false, video: true(surface mode)
1277     OpenFile(name, true, false, false);
1278     // check track aquire & release: inner: 1, mic: 1, video: 1
1279     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1280     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1281     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1282     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
1283     // captureContentChangeCallback: true
1284     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
1285 
1286     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1287     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1288     EXPECT_EQ(MSERR_OK, recorder->Start());
1289     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 recorder Start");
1290     sleep(RECORDER_TIME);
1291     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1292     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1293     EXPECT_EQ(MSERR_OK, recorder->Reset());
1294     EXPECT_EQ(MSERR_OK, recorder->Release());
1295     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1296     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1297     CloseFile();
1298     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 after");
1299 }
1300 
1301 /**
1302  * @tc.name: screen_capture_with_surface_cb_03
1303  * @tc.desc: do screencapture capture surface mode, capture screen and mic audio
1304  * @tc.type: FUNC
1305  * @tc.require:
1306  */
1307 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_03, TestSize.Level2)
1308 {
1309     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 before");
1310     SetConfig(config_);
1311     screenCapture_->SetMicrophoneEnabled(true);
1312     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 CreateRecorder");
1313     std::shared_ptr<Recorder> recorder = RecorderFactory::CreateRecorder();
1314     int32_t videoSourceId = 0;
1315     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1316     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1317     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1318     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1319     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1320     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1321     OpenFileFd("screen_capture_with_surface_cb_03.mp4");
1322     ASSERT_TRUE(outputFd_ >= 0);
1323     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1324     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1325     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1326 
1327     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1328     ASSERT_NE(nullptr, screenCaptureCb_);
1329 
1330     std::string name = "screen_capture_with_surface_cb_03";
1331     // track enalbed: inner: false, mic: true, video: true(surface mode)
1332     OpenFile(name, false, true, false);
1333     // check track aquire & release: inner: 1, mic: 1, video: 1
1334     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1335     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1336     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1337     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
1338     // captureContentChangeCallback: true
1339     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
1340 
1341     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1342     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1343     EXPECT_EQ(MSERR_OK, recorder->Start());
1344     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 recorder Start");
1345     sleep(RECORDER_TIME);
1346     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1347     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1348     EXPECT_EQ(MSERR_OK, recorder->Reset());
1349     EXPECT_EQ(MSERR_OK, recorder->Release());
1350     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1351     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1352     CloseFile();
1353     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 after");
1354 }
1355 
1356 /**
1357  * @tc.name: screen_capture_with_surface_cb_04
1358  * @tc.desc: do screencapture capture surface mode, capture screen only
1359  * @tc.type: FUNC
1360  * @tc.require:
1361  */
1362 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_04, TestSize.Level2)
1363 {
1364     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 before");
1365     SetConfig(config_);
1366     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1367     config_.audioInfo.micCapInfo.audioChannels = 0;
1368     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1369     screenCapture_->SetMicrophoneEnabled(true);
1370     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 CreateRecorder");
1371     std::shared_ptr<Recorder> recorder = RecorderFactory::CreateRecorder();
1372     int32_t videoSourceId = 0;
1373     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1374     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1375     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1376     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1377     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1378     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1379     OpenFileFd("screen_capture_with_surface_cb_04.mp4");
1380     ASSERT_TRUE(outputFd_ >= 0);
1381     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1382     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1383     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1384 
1385     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1386     ASSERT_NE(nullptr, screenCaptureCb_);
1387 
1388     std::string name = "screen_capture_with_surface_cb_04";
1389     // track enalbed: inner: false, mic: false, video: false
1390     OpenFile(name, false, false, false);
1391     // check track aquire & release: inner: 1, mic: 1, video: 1
1392     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1393     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1394     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1395     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true,
1396     // captureContentChangeCallback: true
1397     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true, true));
1398 
1399     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1400     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1401     EXPECT_EQ(MSERR_OK, recorder->Start());
1402     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 recorder Start");
1403     sleep(RECORDER_TIME);
1404     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1405     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1406     EXPECT_EQ(MSERR_OK, recorder->Reset());
1407     EXPECT_EQ(MSERR_OK, recorder->Release());
1408     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1409     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1410     CloseFile();
1411     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 after");
1412 }
1413 } // namespace Media
1414 } // namespace OHOS