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     cout << "Error received, errorCode:" << errorCode << endl;
43 }
44 
OnAudioBufferAvailable(bool isReady,AudioCaptureSourceType type)45 void ScreenCaptureUnitTestCallback::OnAudioBufferAvailable(bool isReady, AudioCaptureSourceType type)
46 {
47     cout << "OnAudioBufferAvailable S, isReady:" << isReady << endl;
48     ASSERT_FALSE(screenCapture_->IsDataCallBackEnabled());
49     if (!isReady) {
50         cout << "OnAudioBufferAvailable isReady false E" << endl;
51         return;
52     }
53     std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
54     if (screenCapture_->AcquireAudioBuffer(audioBuffer, type) == MSERR_OK) {
55         if (audioBuffer == nullptr || audioBuffer->buffer == nullptr) {
56             cout << "AcquireAudioBuffer failed, audio buffer empty, PLEASE CHECK IF IT IS OK!!!" <<
57                 "audioBuffer:" << (audioBuffer == nullptr) << endl;
58             return;
59         }
60         cout << "AcquireAudioBuffer, audioBufferLen:" << audioBuffer->length <<
61             ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:" << audioBuffer->sourcetype << endl;
62         DumpAudioBuffer(audioBuffer);
63     }
64     if (!screenCapture_->IsStateChangeCallBackEnabled()) {
65         if (aFlag_ == 1) {
66             cout << "OnAudioBufferAvailable ReleaseAudioBuffer" << endl;
67             screenCapture_->ReleaseAudioBuffer(type);
68         }
69     } else {
70         cout << "OnAudioBufferAvailable ReleaseAudioBuffer" << endl;
71         screenCapture_->ReleaseAudioBuffer(type);
72     }
73     cout << "OnAudioBufferAvailable isReady true E" << endl;
74 }
75 
DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)76 void ScreenCaptureUnitTestCallback::DumpAudioBuffer(std::shared_ptr<AudioBuffer> audioBuffer)
77 {
78     if ((audioBuffer == nullptr) || (audioBuffer->buffer == nullptr)) {
79         cout << "DumpAudioBuffer audioBuffer or audioBuffer->buffer is nullptr:" << (audioBuffer == nullptr) << endl;
80         return;
81     }
82     if (!screenCapture_->IsStateChangeCallBackEnabled()) {
83         if (aFile_ == nullptr) {
84             cout << "DumpAudioBuffer aFile_ is nullptr" << endl;
85             return;
86         }
87         if (fwrite(audioBuffer->buffer, 1, audioBuffer->length, aFile_) != static_cast<size_t>(audioBuffer->length)) {
88             cout << "DumpAudioBuffer error occurred in fwrite:" << strerror(errno) <<endl;
89         }
90         return;
91     }
92 
93     AudioCaptureSourceType type = audioBuffer->sourcetype;
94     AVScreenCaptureBufferType bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_INVALID;
95     if (type == AudioCaptureSourceType::SOURCE_DEFAULT || type == AudioCaptureSourceType::MIC) {
96         bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC;
97         DumpBuffer(micAudioFile_, audioBuffer->buffer, audioBuffer->length, audioBuffer->timestamp, bufferType);
98         return;
99     }
100     if (type == AudioCaptureSourceType::ALL_PLAYBACK || type == AudioCaptureSourceType::APP_PLAYBACK) {
101         bufferType = AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER;
102         DumpBuffer(innerAudioFile_, audioBuffer->buffer, audioBuffer->length, audioBuffer->timestamp, bufferType);
103         return;
104     }
105     cout << "DumpAudioBuffer invalid bufferType:" << bufferType << ", type:" << type << endl;
106 }
107 
OnVideoBufferAvailable(bool isReady)108 void ScreenCaptureUnitTestCallback::OnVideoBufferAvailable(bool isReady)
109 {
110     cout << "OnVideoBufferAvailable S, isReady:" << isReady << endl;
111     ASSERT_FALSE(screenCapture_->IsDataCallBackEnabled());
112     if (!isReady) {
113         cout << "OnVideoBufferAvailable isReady false E" << endl;
114         return;
115     }
116     cout << "OnVideoBufferAvailable isReady true" << endl;
117     int32_t fence = 0;
118     int64_t timestamp = 0;
119     OHOS::Rect damage;
120     sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
121     if (surfacebuffer == nullptr) {
122         cout << "OnVideoBufferAvailable isReady true, AcquireVideoBuffer failed" << endl;
123         return;
124     }
125     int32_t length = surfacebuffer->GetSize();
126     cout << "AcquireVideoBuffer, videoBufferLen: " << surfacebuffer->GetSize() <<
127         ",  videoBufferWidth:" << surfacebuffer->GetWidth() <<
128         ",  videoBufferHeight:" << surfacebuffer->GetHeight() <<
129         ",  timestamp:" << timestamp << ", size:"<< length << endl;
130     frameNumber++;
131     DumpVideoBuffer(surfacebuffer, timestamp);
132     if (!screenCapture_->IsStateChangeCallBackEnabled()) {
133         if (vFlag_ == 1) {
134             cout << "OnVideoBufferAvailable ReleaseVideoBuffer" << endl;
135             screenCapture_->ReleaseVideoBuffer();
136         }
137     } else {
138         cout << "OnAudioBufferAvailable ReleaseVideoBuffer" << endl;
139         screenCapture_->ReleaseVideoBuffer();
140     }
141     cout << "OnVideoBufferAvailable isReady true E" << endl;
142 }
143 
DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer,int64_t timestamp)144 void ScreenCaptureUnitTestCallback::DumpVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp)
145 {
146     if ((surfacebuffer == nullptr) || (surfacebuffer->GetVirAddr() == nullptr)) {
147         cout << "DumpVideoBuffer surfacebuffer or surfacebuffer->GetVirAddr() is nullptr:" <<
148             (surfacebuffer == nullptr) << endl;
149         return;
150     }
151     if (!screenCapture_->IsStateChangeCallBackEnabled()) {
152         if (vFile_ == nullptr) {
153             cout << "DumpVideoBuffer vFile_ is nullptr" << endl;
154             return;
155         }
156         if (fwrite(surfacebuffer->GetVirAddr(), 1, surfacebuffer->GetSize(), vFile_) != surfacebuffer->GetSize()) {
157             cout << "DumpVideoBuffer error occurred in fwrite:" << strerror(errno) <<endl;
158         }
159         return;
160     }
161     DumpBuffer(videoFile_, reinterpret_cast<uint8_t *>(surfacebuffer->GetVirAddr()), surfacebuffer->GetSize(),
162         timestamp, AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
163 }
164 
OnError(int32_t errorCode,void * userData)165 void ScreenCaptureUnitTestCallback::OnError(int32_t errorCode, void *userData)
166 {
167     ASSERT_TRUE(screenCapture_->IsErrorCallBackEnabled());
168     cout << "Error received, errorCode:" << errorCode << ", userData:" << userData << endl;
169 }
170 
OnStateChange(AVScreenCaptureStateCode stateCode)171 void ScreenCaptureUnitTestCallback::OnStateChange(AVScreenCaptureStateCode stateCode)
172 {
173     MEDIA_LOGI("ScreenCaptureUnitTestCallback::OnStateChange stateCode:%{public}d", stateCode);
174     screenCaptureState_ = stateCode;
175     cout << "OnStateChange received, stateCode:" << stateCode << endl;
176 }
177 
OnBufferAvailable(std::shared_ptr<AVBuffer> buffer,AVScreenCaptureBufferType bufferType,int64_t timestamp)178 void ScreenCaptureUnitTestCallback::OnBufferAvailable(std::shared_ptr<AVBuffer> buffer,
179     AVScreenCaptureBufferType bufferType, int64_t timestamp)
180 {
181     ASSERT_TRUE(screenCapture_->IsDataCallBackEnabled());
182     MEDIA_LOGD("ScreenCaptureUnitTestCallback::OnBufferAvailable bufferType:%{public}d, timestamp:%{public}" PRId64,
183         bufferType, timestamp);
184     cout << "OnBufferAvailable received, bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
185     if (buffer == nullptr || buffer->memory_ == nullptr) {
186         return;
187     }
188     switch (bufferType) {
189         case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO: {
190             sptr<OHOS::SurfaceBuffer> surfaceBuffer = buffer->memory_->GetSurfaceBuffer();
191             if (surfaceBuffer == nullptr || surfaceBuffer->GetVirAddr() == nullptr) {
192                 MEDIA_LOGW("OnBufferAvailable videoBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!"
193                     "bufferType:%{public}d, timestamp:%{public}" PRId64, bufferType, timestamp);
194                 cout << "OnBufferAvailable videoBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!" <<
195                     "bufferType:" << bufferType << ", timestamp:" << timestamp << (surfaceBuffer == nullptr) <<endl;
196                 return;
197             }
198             ProcessVideoBuffer(surfaceBuffer, timestamp);
199             break;
200         }
201         case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER: // fall-through
202         case AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC: {
203             uint8_t *auduioBuffer = buffer->memory_->GetAddr();
204             if (auduioBuffer == nullptr) {
205                 MEDIA_LOGW("OnBufferAvailable audioBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!"
206                     "bufferType:%{public}d, timestamp:%{public}" PRId64, bufferType, timestamp);
207                 cout << "OnBufferAvailable audioBuffer received is nullptr, PLEASE CHECK IF IT IS OK!!!" <<
208                     "bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
209                 return;
210             }
211             ProcessAudioBuffer(auduioBuffer, buffer->memory_->GetSize(), timestamp, bufferType);
212             break;
213         }
214         default:
215             cout << "OnBufferAvailable received invalid bufferType:" << bufferType <<
216                 ", timestamp:" << timestamp << endl;
217             break;
218     }
219 }
220 
DumpBuffer(FILE * file,uint8_t * buffer,int32_t size,int64_t timestamp,AVScreenCaptureBufferType bufferType)221 void ScreenCaptureUnitTestCallback::DumpBuffer(FILE *file, uint8_t *buffer, int32_t size, int64_t timestamp,
222     AVScreenCaptureBufferType bufferType)
223 {
224     cout << "DumpBuffer, bufferLen:" << size << ", bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
225     if ((file == nullptr) || (buffer == nullptr)) {
226         cout << "DumpBuffer failed, file:" << (file == nullptr) << ", buffer:" << (buffer == nullptr) <<
227             ", bufferLen:" << size << ", bufferType:" << bufferType << ", timestamp:" << timestamp << endl;
228         return;
229     }
230     if (fwrite(buffer, 1, size, file) != static_cast<size_t>(size)) {
231         cout << "error occurred in fwrite:" << strerror(errno) << ", bufferType:" << bufferType <<
232             ", timestamp:" << timestamp << endl;
233     }
234 }
235 
CheckDataCallbackVideo(int32_t flag)236 void ScreenCaptureUnitTestCallback::CheckDataCallbackVideo(int32_t flag)
237 {
238     if (flag != 1) {
239         return;
240     }
241     if (screenCapture_->IsDataCallBackEnabled()) {
242         int32_t fence = 0;
243         int64_t timestamp = 0;
244         OHOS::Rect damage;
245         sptr<OHOS::SurfaceBuffer> surfacebuffer = screenCapture_->AcquireVideoBuffer(fence, timestamp, damage);
246         EXPECT_EQ(nullptr, surfacebuffer);
247         EXPECT_NE(MSERR_OK, screenCapture_->ReleaseVideoBuffer());
248     }
249 }
250 
ProcessVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer,int64_t timestamp)251 void ScreenCaptureUnitTestCallback::ProcessVideoBuffer(sptr<OHOS::SurfaceBuffer> surfacebuffer, int64_t timestamp)
252 {
253     int32_t size = surfacebuffer->GetSize();
254     DumpBuffer(videoFile_, reinterpret_cast<uint8_t *>(surfacebuffer->GetVirAddr()), size, timestamp);
255     CheckDataCallbackVideo(videoFlag_);
256 }
257 
CheckDataCallbackAudio(AudioCaptureSourceType type,int32_t flag)258 void ScreenCaptureUnitTestCallback::CheckDataCallbackAudio(AudioCaptureSourceType type, int32_t flag)
259 {
260     if (flag != 1) {
261         return;
262     }
263     if (screenCapture_->IsDataCallBackEnabled()) {
264         std::shared_ptr<AudioBuffer> audioBuffer = nullptr;
265         EXPECT_NE(MSERR_OK, screenCapture_->AcquireAudioBuffer(audioBuffer, type));
266         EXPECT_NE(MSERR_OK, screenCapture_->ReleaseAudioBuffer(type));
267     }
268 }
269 
ProcessAudioBuffer(uint8_t * buffer,int32_t size,int64_t timestamp,AVScreenCaptureBufferType bufferType)270 void ScreenCaptureUnitTestCallback::ProcessAudioBuffer(uint8_t *buffer, int32_t size, int64_t timestamp,
271     AVScreenCaptureBufferType bufferType)
272 {
273     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
274         DumpBuffer(innerAudioFile_, buffer, size, timestamp, bufferType);
275         CheckDataCallbackAudio(AudioCaptureSourceType::ALL_PLAYBACK, innerAudioFlag_);
276         return;
277     }
278     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC) {
279         DumpBuffer(micAudioFile_, buffer, size, timestamp, bufferType);
280         CheckDataCallbackAudio(AudioCaptureSourceType::MIC, micAudioFlag_);
281         return;
282     }
283     cout << "ProcessAudioBuffer invalid bufferType:" << bufferType << endl;
284 }
285 
GetFrameNumber()286 int32_t ScreenCaptureUnitTestCallback::GetFrameNumber()
287 {
288     int32_t tempNum = frameNumber;
289     frameNumber = 0;
290     return tempNum;
291 }
292 
InitCaptureTrackInfo(FILE * file,int32_t flag,AVScreenCaptureBufferType bufferType)293 void ScreenCaptureUnitTestCallback::InitCaptureTrackInfo(FILE *file, int32_t flag, AVScreenCaptureBufferType bufferType)
294 {
295     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_VIDEO) {
296         videoFile_ = file;
297         videoFlag_ = flag;
298     }
299     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER) {
300         innerAudioFile_ = file;
301         innerAudioFlag_ = flag;
302     }
303     if (bufferType == AVScreenCaptureBufferType::SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC) {
304         micAudioFile_ = file;
305         micAudioFlag_ = flag;
306     }
307 }
308 
309 const std::string ScreenCaptureUnitTest::SCREEN_CAPTURE_ROOT_DIR = "/data/test/media/";
310 
SetAccessTokenPermission()311 void ScreenCaptureUnitTest::SetAccessTokenPermission()
312 {
313     vector<string> permission;
314     permission.push_back("ohos.permission.MICROPHONE");
315     permission.push_back("ohos.permission.READ_MEDIA");
316     permission.push_back("ohos.permission.WRITE_MEDIA");
317     uint64_t tokenId = 0;
318 
319     auto perms = std::make_unique<const char* []>(permission.size());
320     for (size_t i = 0; i < permission.size(); i++) {
321         perms[i] = permission[i].c_str();
322     }
323     NativeTokenInfoParams infoInstance = {
324         .dcapsNum = 0,
325         .permsNum = static_cast<int32_t>(permission.size()),
326         .aclsNum = 0,
327         .dcaps = nullptr,
328         .perms = perms.get(),
329         .acls = nullptr,
330         .processName = "avscreencapture_unittest",
331         .aplStr = "system_basic",
332     };
333     tokenId = GetAccessTokenId(&infoInstance);
334     if (tokenId == 0) {
335         MEDIA_LOGE("Get Access Token Id Failed");
336         return;
337     }
338     int ret = SetSelfTokenID(tokenId);
339     if (ret != 0) {
340         MEDIA_LOGE("Set Acess Token Id failed");
341         return;
342     }
343     ret = Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
344     if (ret < 0) {
345         MEDIA_LOGE("Reload Native Token Info Failed");
346     }
347 }
348 
SetHapPermission()349 void ScreenCaptureUnitTest::SetHapPermission()
350 {
351     HapInfoParams info = {
352         .userID = 100, // 100 UserID
353         .bundleName = "com.ohos.test.screencapturetdd",
354         .instIndex = 0, // 0 index
355         .appIDDesc = "com.ohos.test.screencapturetdd",
356         .isSystemApp = true
357     };
358 
359     HapPolicyParams policy = {
360         .apl = APL_SYSTEM_BASIC,
361         .domain = "test.domain.screencapturetdd",
362         .permList = { },
363         .permStateList = {
364             {
365                 .permissionName = "ohos.permission.MICROPHONE",
366                 .isGeneral = true,
367                 .resDeviceID = { "local" },
368                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
369                 .grantFlags = { 1 }
370             },
371             {
372                 .permissionName = "ohos.permission.READ_MEDIA",
373                 .isGeneral = true,
374                 .resDeviceID = { "local" },
375                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
376                 .grantFlags = { 1 }
377             },
378             {
379                 .permissionName = "ohos.permission.WRITE_MEDIA",
380                 .isGeneral = true,
381                 .resDeviceID = { "local" },
382                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
383                 .grantFlags = { 1 }
384             },
385             {
386                 .permissionName = "ohos.permission.KEEP_BACKGROUND_RUNNING",
387                 .isGeneral = true,
388                 .resDeviceID = { "local" },
389                 .grantStatus = { PermissionState::PERMISSION_GRANTED },
390                 .grantFlags = { 1 }
391             }
392         }
393     };
394     AccessTokenIDEx tokenIdEx = { 0 };
395     tokenIdEx = AccessTokenKit::AllocHapToken(info, policy);
396     int ret = SetSelfTokenID(tokenIdEx.tokenIDEx);
397     if (ret != 0) {
398         MEDIA_LOGE("Set hap token failed, err: %{public}d", ret);
399     }
400 }
401 
SetUpTestCase(void)402 void ScreenCaptureUnitTest::SetUpTestCase(void)
403 {
404     SetHapPermission();
405 }
406 
TearDownTestCase(void)407 void ScreenCaptureUnitTest::TearDownTestCase(void)
408 {
409     AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(100,
410         "com.ohos.test.screencapturetdd", 0); // 100 UserId 0 Index
411     AccessTokenKit::DeleteToken(tokenId);
412 }
413 
SetUp(void)414 void ScreenCaptureUnitTest::SetUp(void)
415 {
416     screenCapture_ = ScreenCaptureMockFactory::CreateScreenCapture();
417     ASSERT_NE(nullptr, screenCapture_);
418 }
419 
TearDown(void)420 void ScreenCaptureUnitTest::TearDown(void)
421 {
422     if (screenCaptureCb_ != nullptr) {
423         screenCaptureCb_.reset();
424         screenCaptureCb_ = nullptr;
425     }
426     if (screenCapture_ != nullptr) {
427         screenCapture_->Release();
428         screenCapture_ = nullptr;
429     }
430     CloseFile();
431 }
432 
SetConfig(AVScreenCaptureConfig & config)433 int32_t ScreenCaptureUnitTest::SetConfig(AVScreenCaptureConfig &config)
434 {
435     AudioCaptureInfo miccapinfo = {
436         .audioSampleRate = 16000,
437         .audioChannels = 2,
438         .audioSource = SOURCE_DEFAULT
439     };
440 
441     VideoCaptureInfo videocapinfo = {
442         .videoFrameWidth = 720,
443         .videoFrameHeight = 1280,
444         .videoSource = VIDEO_SOURCE_SURFACE_RGBA
445     };
446 
447     VideoEncInfo videoEncInfo = {
448         .videoCodec = VideoCodecFormat::H264,
449         .videoBitrate = 2000000,
450         .videoFrameRate = 30
451     };
452 
453     AudioInfo audioinfo = {
454         .micCapInfo = miccapinfo,
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                 cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
649                 continue;
650             }
651             cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:" <<
652                 audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:" <<
653                 audioBuffer->sourcetype << endl;
654             screenCapture_->ReleaseAudioBuffer(type);
655         } else {
656             cout << "AcquireAudioBuffer failed" << endl;
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                 cout << "AcquireAudioBuffer failed, audio buffer is nullptr" << endl;
675                 continue;
676             }
677             cout << "index audio:" << index_audio_frame++ << ", AcquireAudioBuffer, audioBufferLen:" <<
678                 audioBuffer->length << ", timestampe:" << audioBuffer->timestamp << ", audioSourceType:" <<
679                 audioBuffer->sourcetype << endl;
680         } else {
681             cout << "AcquireAudioBuffer failed" << endl;
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         cout << "AcquireBuffer, videoBufferLen: " << buffer->GetSize() <<
696         ",  videoBufferWidth: " << buffer->GetWidth() <<
697         ",  videoBufferHeight: " << buffer->GetHeight() <<
698         ",  timestamp: " << timestamp << endl;
699     } else {
700         cout << "buffer empty" << endl;
701     }
702     consumer_->ReleaseBuffer(buffer, flushFence);
703 }
704 
705 /**
706  * @tc.name: screen_capture_specified_window_cb_01
707  * @tc.desc: open microphone, capture screen, inner audio, mic audio
708  * @tc.type: FUNC
709  * @tc.require: play something audio resource to get inner audio
710  */
711 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_01, TestSize.Level2)
712 {
713     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_01 before");
714     SetConfig(config_);
715     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
716     config_.audioInfo.innerCapInfo.audioChannels = 2;
717     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
718     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
719     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
720     std::string deviceId = "";
721     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
722     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
723     MEDIA_LOGI("screen_capture_specified_window_cb_01 missionInfos size:%{public}s, result:%{public}d",
724         std::to_string(missionInfos.size()).c_str(), result);
725     if (missionInfos.size() > 0) {
726         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
727             MEDIA_LOGI("screen_capture_specified_window_cb_01 missionId:%{public}d", info.id);
728             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
729         }
730     } else {
731         MEDIA_LOGE("screen_capture_specified_window_cb_01 GetMissionInfos failed");
732     }
733 
734     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
735     ASSERT_NE(nullptr, screenCaptureCb_);
736     std::string name = "screen_capture_specified_window_cb_01";
737     // track enalbed: inner: true, mic: true, video: true
738     OpenFile(name, true, true, true);
739     // check track aquire & release: inner: 1, mic: 1, video: 1
740     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
741     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
742     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
743     bool isMicrophone = true; // Enable Mic
744     screenCapture_->SetMicrophoneEnabled(isMicrophone);
745     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
746     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, 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     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
799 
800     screenCapture_->SetMicrophoneEnabled(false); // Enable Mic
801     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
802     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
803     sleep(RECORDER_TIME);
804     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
805     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
806     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
807     CloseFile();
808     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_02 after");
809 }
810 
811 /**
812  * @tc.name: screen_capture_specified_window_cb_03
813  * @tc.desc: Enable microphone, capture screen, mic audio
814  * @tc.type: FUNC
815  * @tc.require:
816  */
817 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_03, TestSize.Level2)
818 {
819     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 before");
820     SetConfig(config_);
821     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
822     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
823     std::string deviceId = "";
824     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
825     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
826     MEDIA_LOGI("screen_capture_specified_window_cb_03 missionInfos size:%{public}s, result:%{public}d",
827         std::to_string(missionInfos.size()).c_str(), result);
828     if (missionInfos.size() > 0) {
829         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
830             MEDIA_LOGI("screen_capture_specified_window_cb_03 missionId:%{public}d", info.id);
831             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
832         }
833     } else {
834         MEDIA_LOGE("screen_capture_specified_window_cb_03 GetMissionInfos failed");
835     }
836 
837     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
838     ASSERT_NE(nullptr, screenCaptureCb_);
839     std::string name = "screen_capture_specified_window_cb_03";
840     // track enalbed: inner: false, mic: true, video: true
841     OpenFile(name, false, true, true);
842     // check track aquire & release: inner: 1, mic: 1, video: 1
843     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
844     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
845     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
846     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
847     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
848 
849     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
850     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
851     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
852     sleep(RECORDER_TIME);
853     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
854     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
855     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
856     CloseFile();
857     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_03 after");
858 }
859 
860 /**
861  * @tc.name: screen_capture_specified_window_cb_04
862  * @tc.desc: Enable microphone, capture screen, inner audio
863  * @tc.type: FUNC
864  * @tc.require: play something audio resource to get inner audio
865  */
866 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_04, TestSize.Level2)
867 {
868     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 before");
869     SetConfig(config_);
870     config_.audioInfo.micCapInfo.audioSampleRate = 0;
871     config_.audioInfo.micCapInfo.audioChannels = 0;
872     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
873     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
874     config_.audioInfo.innerCapInfo.audioChannels = 2;
875     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
876     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
877     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
878     std::string deviceId = "";
879     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
880     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
881     MEDIA_LOGI("screen_capture_specified_window_cb_04 missionInfos size:%{public}s, result:%{public}d",
882         std::to_string(missionInfos.size()).c_str(), result);
883     if (missionInfos.size() > 0) {
884         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
885             MEDIA_LOGI("screen_capture_specified_window_cb_04 missionId:%{public}d", info.id);
886             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
887         }
888     } else {
889         MEDIA_LOGE("screen_capture_specified_window_cb_04 GetMissionInfos failed");
890     }
891 
892     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
893     ASSERT_NE(nullptr, screenCaptureCb_);
894     std::string name = "screen_capture_specified_window_cb_04";
895     // track enalbed: inner: true, mic: false, video: true
896     OpenFile(name, true, false, true);
897     // check track aquire & release: inner: 1, mic: 1, video: 1
898     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
899     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
900     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
901     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
902     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
903 
904     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
905     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
906     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
907     sleep(RECORDER_TIME);
908     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
909     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
910     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
911     CloseFile();
912     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_04 after");
913 }
914 
915 /**
916  * @tc.name: screen_capture_specified_window_cb_05
917  * @tc.desc: Enable microphone, capture inner audio, mic audio
918  * @tc.type: FUNC
919  * @tc.require: play something audio resource to get inner audio
920  */
921 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_05, TestSize.Level2)
922 {
923     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 before");
924     SetConfig(config_);
925     config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
926     config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
927     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
928     config_.audioInfo.innerCapInfo.audioChannels = 2;
929     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
930     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
931     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
932     std::string deviceId = "";
933     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
934     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
935     MEDIA_LOGI("screen_capture_specified_window_cb_05 missionInfos size:%{public}s, result:%{public}d",
936         std::to_string(missionInfos.size()).c_str(), result);
937     if (missionInfos.size() > 0) {
938         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
939             MEDIA_LOGI("screen_capture_specified_window_cb_05 missionId:%{public}d", info.id);
940             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
941         }
942     } else {
943         MEDIA_LOGE("screen_capture_specified_window_cb_05 GetMissionInfos failed");
944     }
945 
946     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
947     ASSERT_NE(nullptr, screenCaptureCb_);
948     std::string name = "screen_capture_specified_window_cb_05";
949     // track enalbed: inner: true, mic: true, video: false
950     OpenFile(name, true, true, false);
951     // check track aquire & release: inner: 1, mic: 1, video: 1
952     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
953     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
954     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
955     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
956     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
957 
958     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
959     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
960     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
961     sleep(RECORDER_TIME);
962     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
963     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
964     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
965     CloseFile();
966     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_05 after");
967 }
968 
969 /**
970  * @tc.name: screen_capture_specified_window_cb_06
971  * @tc.desc: Enable microphone, capture inner audio only
972  * @tc.type: FUNC
973  * @tc.require: play something audio resource to get inner audio
974  */
975 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_06, TestSize.Level2)
976 {
977     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 before");
978     SetConfig(config_);
979     config_.videoInfo.videoCapInfo.videoFrameWidth = 0;
980     config_.videoInfo.videoCapInfo.videoFrameHeight = 0;
981     config_.audioInfo.micCapInfo.audioSampleRate = 0;
982     config_.audioInfo.micCapInfo.audioChannels = 0;
983     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
984     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
985     config_.audioInfo.innerCapInfo.audioChannels = 2;
986     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
987     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
988     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
989     std::string deviceId = "";
990     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
991     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
992     MEDIA_LOGI("screen_capture_specified_window_cb_06 missionInfos size:%{public}s, result:%{public}d",
993         std::to_string(missionInfos.size()).c_str(), result);
994     if (missionInfos.size() > 0) {
995         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
996             MEDIA_LOGI("screen_capture_specified_window_cb_06 missionId:%{public}d", info.id);
997             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
998         }
999     } else {
1000         MEDIA_LOGE("screen_capture_specified_window_cb_06 GetMissionInfos failed");
1001     }
1002 
1003     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1004     ASSERT_NE(nullptr, screenCaptureCb_);
1005     std::string name = "screen_capture_specified_window_cb_06";
1006     // track enalbed: inner: true, mic: false, video: false
1007     OpenFile(name, true, false, false);
1008     // check track aquire & release: inner: 1, mic: 1, video: 1
1009     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1010     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1011     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1012     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
1013     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
1014 
1015     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1016     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1017     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
1018     sleep(RECORDER_TIME);
1019     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1020     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1021     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1022     CloseFile();
1023     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_06 after");
1024 }
1025 
OnScreenCaptureStarted(int32_t pid)1026 void ScreenCaptureMonitorListenerMock::OnScreenCaptureStarted(int32_t pid)
1027 {
1028     MEDIA_LOGI("OnScreenCaptureStarted pid %{public}d name %{public}s", pid, name_.c_str());
1029     stateFlag_ = 1; // 1 start
1030 }
1031 
OnScreenCaptureFinished(int32_t pid)1032 void ScreenCaptureMonitorListenerMock::OnScreenCaptureFinished(int32_t pid)
1033 {
1034     MEDIA_LOGI("OnScreenCaptureFinished pid %{public}d name %{public}s", pid, name_.c_str());
1035     stateFlag_ = 2; // 2 finish
1036 }
1037 
BeforeScreenCaptureSpecifiedWindowCbCase07(void)1038 void ScreenCaptureUnitTest::BeforeScreenCaptureSpecifiedWindowCbCase07(void)
1039 {
1040     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 before");
1041     SetConfig(config_);
1042     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1043     config_.audioInfo.micCapInfo.audioChannels = 0;
1044     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1045     config_.captureMode = CaptureMode::CAPTURE_SPECIFIED_WINDOW;
1046 }
1047 /**
1048  * @tc.name: screen_capture_specified_window_cb_07
1049  * @tc.desc: Enable microphone, capture screen only
1050  * @tc.type: FUNC
1051  * @tc.require:
1052  */
1053 HWTEST_F(ScreenCaptureUnitTest, screen_capture_specified_window_cb_07, TestSize.Level2)
1054 {
1055     BeforeScreenCaptureSpecifiedWindowCbCase07();
1056     std::shared_ptr<OHOS::AAFwk::AbilityManagerClient> client_ = OHOS::AAFwk::AbilityManagerClient::GetInstance();
1057     std::string deviceId = "";
1058     std::vector<OHOS::AAFwk::MissionInfo> missionInfos;
1059     auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
1060     MEDIA_LOGI("screen_capture_specified_window_cb_07 missionInfos size:%{public}s, result:%{public}d",
1061         std::to_string(missionInfos.size()).c_str(), result);
1062     if (missionInfos.size() > 0) {
1063         for (OHOS::AAFwk::MissionInfo info : missionInfos) {
1064             MEDIA_LOGI("screen_capture_specified_window_cb_07 missionId:%{public}d", info.id);
1065             config_.videoInfo.videoCapInfo.taskIDs.push_back(info.id);
1066         }
1067     } else {
1068         MEDIA_LOGE("screen_capture_specified_window_cb_07 GetMissionInfos failed");
1069     }
1070     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1071     ASSERT_NE(nullptr, screenCaptureCb_);
1072     std::string name = "screen_capture_specified_window_cb_07";
1073     OpenFile(name, false, false, true);
1074     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1075     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1076     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1077     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
1078     sptr<ScreenCaptureMonitor::ScreenCaptureMonitorListener> screenCaptureMonitorListener1 =
1079         new ScreenCaptureMonitorListenerMock("scm1");
1080     sptr<ScreenCaptureMonitor::ScreenCaptureMonitorListener> screenCaptureMonitorListener2 =
1081         new ScreenCaptureMonitorListenerMock("scm2");
1082     EXPECT_EQ(0,
1083         static_cast<ScreenCaptureMonitorListenerMock *>(screenCaptureMonitorListener1.GetRefPtr())->stateFlag_);
1084     ScreenCaptureMonitor::GetInstance()->RegisterScreenCaptureMonitorListener(screenCaptureMonitorListener1);
1085     ScreenCaptureMonitor::GetInstance()->RegisterScreenCaptureMonitorListener(screenCaptureMonitorListener2);
1086     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1087     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1088     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCapture());
1089     sleep(RECORDER_TIME);
1090     EXPECT_NE(-1, ScreenCaptureMonitor::GetInstance()->IsScreenCaptureWorking());
1091     EXPECT_EQ(1, // 1 start
1092         static_cast<ScreenCaptureMonitorListenerMock *>(screenCaptureMonitorListener1.GetRefPtr())->stateFlag_);
1093     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1094     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1095     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1096     EXPECT_EQ(2, // 1 finish
1097         static_cast<ScreenCaptureMonitorListenerMock *>(screenCaptureMonitorListener1.GetRefPtr())->stateFlag_);
1098     ScreenCaptureMonitor::GetInstance()->UnregisterScreenCaptureMonitorListener(screenCaptureMonitorListener1);
1099     ScreenCaptureMonitor::GetInstance()->UnregisterScreenCaptureMonitorListener(screenCaptureMonitorListener2);
1100     EXPECT_EQ(-1, ScreenCaptureMonitor::GetInstance()->IsScreenCaptureWorking());
1101     CloseFile();
1102     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_specified_window_cb_07 after");
1103 }
1104 
1105 /**
1106  * @tc.name: screen_capture_save_file_cb_01
1107  * @tc.desc: do screencapture capture file mode, capture inner audio and mic audio
1108  * @tc.type: FUNC
1109  * @tc.require: play something audio resource to get inner audio
1110  */
1111 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_cb_01, TestSize.Level2)
1112 {
1113     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_01 before");
1114     RecorderInfo recorderInfo;
1115     SetRecorderInfo("screen_capture_save_file_cb_01.mp4", recorderInfo);
1116     SetConfigFile(config_, recorderInfo);
1117     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1118     config_.audioInfo.innerCapInfo.audioChannels = 2;
1119     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1120 
1121     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1122     ASSERT_NE(nullptr, screenCaptureCb_);
1123     // callback enabled: errorCallback: true, dataCallback: false, stateChangeCallback: true
1124     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, false, true));
1125 
1126     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1127     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1128     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording());
1129     sleep(RECORDER_TIME);
1130     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1131     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording());
1132     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1133     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_01 after");
1134 }
1135 
1136 /**
1137  * @tc.name: screen_capture_save_file_cb_02
1138  * @tc.desc: do screencapture capture file mode, capture inner audio
1139  * @tc.type: FUNC
1140  * @tc.require: play something audio resource to get inner audio
1141  */
1142 HWTEST_F(ScreenCaptureUnitTest, screen_capture_save_file_cb_02, TestSize.Level2)
1143 {
1144     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_02 before");
1145     RecorderInfo recorderInfo;
1146     SetRecorderInfo("screen_capture_save_file_cb_02.mp4", recorderInfo);
1147     SetConfigFile(config_, recorderInfo);
1148     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1149     config_.audioInfo.micCapInfo.audioChannels = 0;
1150     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1151     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1152     config_.audioInfo.innerCapInfo.audioChannels = 2;
1153     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1154 
1155     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1156     ASSERT_NE(nullptr, screenCaptureCb_);
1157     // callback enabled: errorCallback: true, dataCallback: false, stateChangeCallback: true
1158     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, false, true));
1159 
1160     screenCapture_->SetMicrophoneEnabled(true); // Enable Mic
1161     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1162     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenRecording());
1163     sleep(RECORDER_TIME);
1164     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1165     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenRecording());
1166     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1167     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_save_file_cb_02 after");
1168 }
1169 
1170 /**
1171  * @tc.name: screen_capture_with_surface_cb_01
1172  * @tc.desc: do screencapture capture surface mode, capture screen, inner audio and mic audio
1173  * @tc.type: FUNC
1174  * @tc.require: play something audio resource to get inner audio
1175  */
1176 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_01, TestSize.Level2)
1177 {
1178     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 before");
1179     SetConfig(config_);
1180     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1181     config_.audioInfo.innerCapInfo.audioChannels = 2;
1182     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1183     bool isMicrophone = true;
1184     screenCapture_->SetMicrophoneEnabled(isMicrophone);
1185     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 CreateRecorder");
1186     std::shared_ptr<Recorder> recorder = nullptr;
1187     recorder = RecorderFactory::CreateRecorder();
1188     int32_t videoSourceId = 0;
1189     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1190     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1191     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1192     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1193     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1194     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1195     OpenFileFd("screen_capture_with_surface_cb_01.mp4");
1196     ASSERT_TRUE(outputFd_ >= 0);
1197     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1198     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1199     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1200 
1201     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1202     ASSERT_NE(nullptr, screenCaptureCb_);
1203 
1204     std::string name = "screen_capture_with_surface_cb_01";
1205     // track enalbed: inner: true, mic: true, video: true(surface mode)
1206     OpenFile(name, true, true, false);
1207     // check track aquire & release: inner: 1, mic: 1, video: 1
1208     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1209     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1210     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1211     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
1212     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
1213 
1214     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1215     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1216     EXPECT_EQ(MSERR_OK, recorder->Start());
1217     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 recorder Start");
1218     sleep(RECORDER_TIME);
1219     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1220     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1221     EXPECT_EQ(MSERR_OK, recorder->Reset());
1222     EXPECT_EQ(MSERR_OK, recorder->Release());
1223     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1224     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1225     CloseFile();
1226     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_01 after");
1227 }
1228 
1229 /**
1230  * @tc.name: screen_capture_with_surface_cb_02
1231  * @tc.desc: do screencapture capture surface mode, capture screen and inner audio
1232  * @tc.type: FUNC
1233  * @tc.require: play something audio resource to get inner audio
1234  */
1235 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_02, TestSize.Level2)
1236 {
1237     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 before");
1238     SetConfig(config_);
1239     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1240     config_.audioInfo.micCapInfo.audioChannels = 0;
1241     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1242     config_.audioInfo.innerCapInfo.audioSampleRate = 16000;
1243     config_.audioInfo.innerCapInfo.audioChannels = 2;
1244     config_.audioInfo.innerCapInfo.audioSource = AudioCaptureSourceType::ALL_PLAYBACK;
1245     screenCapture_->SetMicrophoneEnabled(true);
1246     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 CreateRecorder");
1247     std::shared_ptr<Recorder> recorder = nullptr;
1248     recorder = RecorderFactory::CreateRecorder();
1249     int32_t videoSourceId = 0;
1250     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1251     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1252     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1253     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1254     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1255     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1256     OpenFileFd("screen_capture_with_surface_cb_02.mp4");
1257     ASSERT_TRUE(outputFd_ >= 0);
1258     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1259     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1260     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1261 
1262     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1263     ASSERT_NE(nullptr, screenCaptureCb_);
1264 
1265     std::string name = "screen_capture_with_surface_cb_02";
1266     // track enalbed: inner: true, mic: false, video: true(surface mode)
1267     OpenFile(name, true, false, false);
1268     // check track aquire & release: inner: 1, mic: 1, video: 1
1269     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1270     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1271     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1272     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
1273     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
1274 
1275     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1276     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1277     EXPECT_EQ(MSERR_OK, recorder->Start());
1278     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 recorder Start");
1279     sleep(RECORDER_TIME);
1280     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1281     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1282     EXPECT_EQ(MSERR_OK, recorder->Reset());
1283     EXPECT_EQ(MSERR_OK, recorder->Release());
1284     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1285     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1286     CloseFile();
1287     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_02 after");
1288 }
1289 
1290 /**
1291  * @tc.name: screen_capture_with_surface_cb_03
1292  * @tc.desc: do screencapture capture surface mode, capture screen and mic audio
1293  * @tc.type: FUNC
1294  * @tc.require:
1295  */
1296 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_03, TestSize.Level2)
1297 {
1298     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 before");
1299     SetConfig(config_);
1300     screenCapture_->SetMicrophoneEnabled(true);
1301     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 CreateRecorder");
1302     std::shared_ptr<Recorder> recorder = RecorderFactory::CreateRecorder();
1303     int32_t videoSourceId = 0;
1304     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1305     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1306     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1307     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1308     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1309     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1310     OpenFileFd("screen_capture_with_surface_cb_03.mp4");
1311     ASSERT_TRUE(outputFd_ >= 0);
1312     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1313     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1314     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1315 
1316     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1317     ASSERT_NE(nullptr, screenCaptureCb_);
1318 
1319     std::string name = "screen_capture_with_surface_cb_03";
1320     // track enalbed: inner: false, mic: true, video: true(surface mode)
1321     OpenFile(name, false, true, false);
1322     // check track aquire & release: inner: 1, mic: 1, video: 1
1323     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1324     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1325     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1326     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
1327     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
1328 
1329     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1330     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1331     EXPECT_EQ(MSERR_OK, recorder->Start());
1332     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 recorder Start");
1333     sleep(RECORDER_TIME);
1334     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1335     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1336     EXPECT_EQ(MSERR_OK, recorder->Reset());
1337     EXPECT_EQ(MSERR_OK, recorder->Release());
1338     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1339     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1340     CloseFile();
1341     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_03 after");
1342 }
1343 
1344 /**
1345  * @tc.name: screen_capture_with_surface_cb_04
1346  * @tc.desc: do screencapture capture surface mode, capture screen only
1347  * @tc.type: FUNC
1348  * @tc.require:
1349  */
1350 HWTEST_F(ScreenCaptureUnitTest, screen_capture_with_surface_cb_04, TestSize.Level2)
1351 {
1352     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 before");
1353     SetConfig(config_);
1354     config_.audioInfo.micCapInfo.audioSampleRate = 0;
1355     config_.audioInfo.micCapInfo.audioChannels = 0;
1356     config_.audioInfo.micCapInfo.audioSource = AudioCaptureSourceType::SOURCE_DEFAULT;
1357     screenCapture_->SetMicrophoneEnabled(true);
1358     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 CreateRecorder");
1359     std::shared_ptr<Recorder> recorder = RecorderFactory::CreateRecorder();
1360     int32_t videoSourceId = 0;
1361     EXPECT_EQ(MSERR_OK, recorder->SetVideoSource(VIDEO_SOURCE_SURFACE_RGBA, videoSourceId));
1362     EXPECT_EQ(MSERR_OK, recorder->SetOutputFormat(OutputFormatType::FORMAT_MPEG_4));
1363     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncoder(videoSourceId, VideoCodecFormat::H264));
1364     EXPECT_EQ(MSERR_OK, recorder->SetVideoSize(videoSourceId, 720, 1080));
1365     EXPECT_EQ(MSERR_OK, recorder->SetVideoFrameRate(videoSourceId, 30));
1366     EXPECT_EQ(MSERR_OK, recorder->SetVideoEncodingBitRate(videoSourceId, 2000000));
1367     OpenFileFd("screen_capture_with_surface_cb_04.mp4");
1368     ASSERT_TRUE(outputFd_ >= 0);
1369     EXPECT_EQ(MSERR_OK, recorder->SetOutputFile(outputFd_));
1370     EXPECT_EQ(MSERR_OK, recorder->Prepare());
1371     sptr<OHOS::Surface> consumer = recorder->GetSurface(videoSourceId);
1372 
1373     screenCaptureCb_ = std::make_shared<ScreenCaptureUnitTestCallback>(screenCapture_);
1374     ASSERT_NE(nullptr, screenCaptureCb_);
1375 
1376     std::string name = "screen_capture_with_surface_cb_04";
1377     // track enalbed: inner: false, mic: false, video: false
1378     OpenFile(name, false, false, false);
1379     // check track aquire & release: inner: 1, mic: 1, video: 1
1380     screenCaptureCb_->InitCaptureTrackInfo(innerAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_INNER);
1381     screenCaptureCb_->InitCaptureTrackInfo(micAudioFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_AUDIO_MIC);
1382     screenCaptureCb_->InitCaptureTrackInfo(videoFile_, 1, SCREEN_CAPTURE_BUFFERTYPE_VIDEO);
1383     // callback enabled: errorCallback: true, dataCallback: true, stateChangeCallback: true
1384     EXPECT_EQ(MSERR_OK, screenCapture_->SetScreenCaptureCallback(screenCaptureCb_, true, true, true));
1385 
1386     EXPECT_EQ(MSERR_OK, screenCapture_->Init(config_));
1387     EXPECT_EQ(MSERR_OK, screenCapture_->StartScreenCaptureWithSurface(consumer));
1388     EXPECT_EQ(MSERR_OK, recorder->Start());
1389     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 recorder Start");
1390     sleep(RECORDER_TIME);
1391     EXPECT_EQ(AVScreenCaptureStateCode::SCREEN_CAPTURE_STATE_STARTED, screenCaptureCb_->GetScreenCaptureState());
1392     EXPECT_EQ(MSERR_OK, recorder->Stop(true));
1393     EXPECT_EQ(MSERR_OK, recorder->Reset());
1394     EXPECT_EQ(MSERR_OK, recorder->Release());
1395     EXPECT_EQ(MSERR_OK, screenCapture_->StopScreenCapture());
1396     EXPECT_EQ(MSERR_OK, screenCapture_->Release());
1397     CloseFile();
1398     MEDIA_LOGI("ScreenCaptureUnitTest screen_capture_with_surface_cb_04 after");
1399 }
1400 } // namespace Media
1401 } // namespace OHOS