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