• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development 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 
17 #include <gtest/gtest.h>
18 #include <iostream>
19 #include <thread>
20 #include <memory>
21 #include <string>
22 #include <chrono>
23 #include <fcntl.h>
24 #include <cstdlib>
25 #include <cstring>
26 
27 
28 #include "common/sharing_log.h"
29 #include "media_controller.h"
30 #include "media_channel.h"
31 #include "common/event_comm.h"
32 #include "common/media_log.h"
33 #include "media_channel_def.h"
34 #include "media_channel.h"
35 #include "video_play_controller.h"
36 #include "buffer_dispatcher.h"
37 #include "protocol/frame/h264_frame.h"
38 #include "extend/magic_enum/magic_enum.hpp"
39 #include "surface.h"
40 #include "surface_utils.h"
41 #include "transaction/rs_transaction.h"
42 #include "ui/rs_surface_node.h"
43 #include "utils/utils.h"
44 #include "securec.h"
45 #include "window.h"
46 #include "window_option.h"
47 #include "ui/rs_surface_node.h"
48 #include "configuration/include/config.h"
49 #include "common/reflect_registration.h"
50 
51 using namespace testing::ext;
52 using namespace OHOS::Sharing;
53 
54 namespace OHOS {
55 namespace Sharing {
56 class MediaplayerTestConsumer final: public BaseConsumer {
UpdateOperation(ProsumerStatusMsg::Ptr & statusMsg)57     void UpdateOperation(ProsumerStatusMsg::Ptr &statusMsg) override
58     {
59         (void)statusMsg;
60     }
61 
HandleEvent(SharingEvent & event)62     int32_t HandleEvent(SharingEvent &event) override
63     {
64         (void) event;
65         return 0;
66     }
67 
Release()68     int32_t Release() override
69     {
70         return 0;
71     }
72 };
73 
74 REGISTER_CLASS_REFLECTOR(MediaplayerTestConsumer);
75 
76 class MediaControllerTestBaseImpl
77         : public Singleton<MediaControllerTestBaseImpl> {
78 private:
79     FILE *videoTestFp_;
80     std::string videoTestPath_ = "/data/mediaplayer_video_test.mp4";
81     DataBuffer::Ptr videoTestData_;
82     std::vector<DataBuffer::Ptr> videoFrames_;
83     MediaData::Ptr mediaData_;
84     size_t videoTestDataLen_;
85 
86     VideoTrack videoTrack_;
87     BufferDispatcher::Ptr dispatcher_ = nullptr;
88     MediaChannel::Ptr mediaChannel_ = nullptr;
89 
90     bool playbackRun_;
91     std::unique_ptr<std::thread> playbackThread_ = nullptr;
92 
93     sptr<Rosen::WindowOption> windowOption_ = nullptr;
94     sptr<Rosen::Window>  window_ = nullptr;
95     std::shared_ptr<Rosen::RSSurfaceNode>  surfaceNode_ = nullptr;
96     sptr<Surface>  surface_ = nullptr;
97     uint64_t surfaceId_ = 0;
98 
99     bool isFirstKeyFrame_ = false;
100     size_t frameNums_ = 0;
101     std::chrono::steady_clock::time_point gopInterval_;
102 public:
GetVideoTestData(void)103     DataBuffer::Ptr& GetVideoTestData(void)
104     {
105         return videoTestData_;
106     }
107 
GetVideoTestDataLength(void) const108     size_t GetVideoTestDataLength(void) const
109     {
110         return videoTestDataLen_;
111     }
112 
GetSurface(void)113     sptr<Surface>& GetSurface(void)
114     {
115         return surface_;
116     }
117 
GetBufferDispatcher(void)118     BufferDispatcher::Ptr& GetBufferDispatcher(void)
119     {
120         return dispatcher_;
121     }
122 
GetVideoTrack(void)123     VideoTrack& GetVideoTrack(void)
124     {
125         return videoTrack_;
126     }
127 
GetMediaChannel(void)128     MediaChannel::Ptr& GetMediaChannel(void)
129     {
130         return mediaChannel_;
131     }
132 
GetId(void)133     uint32_t GetId(void)
134     {
135         return mediaChannel_->GetId();
136     }
137 
VideoTrackReset(void)138     void VideoTrackReset(void)
139     {
140         videoTrack_.codecId = CodecId::CODEC_H264;
141         videoTrack_.width = defaultWidth;
142         videoTrack_.height = defaultHeight;
143         videoTrack_.frameRate = defaultFrameRate;
144     }
145 
IsPlaybackRunning(void) const146     bool IsPlaybackRunning(void) const
147     {
148         return playbackRun_;
149     }
150 
PlaybackStop(void)151     void PlaybackStop(void)
152     {
153         playbackRun_ = false;
154         playbackThread_->join();
155         playbackThread_ = nullptr;
156     }
157 
BufferDispatcherReset(void)158     void BufferDispatcherReset(void)
159     {
160         if (dispatcher_ != nullptr) {
161             dispatcher_->StopDispatch();
162             dispatcher_->FlushBuffer();
163             dispatcher_->ReleaseAllReceiver();
164         }
165     }
VideoPlayerPlaybackStart(void)166     void VideoPlayerPlaybackStart(void)
167     {
168         EXPECT_EQ(nullptr, playbackThread_);
169         EXPECT_EQ(false, playbackRun_);
170         constexpr uint32_t waitForThread = 100;
171 
172         playbackRun_ = true;
173         playbackThread_ = std::make_unique<std::thread>(
174             [this]() {
175                 constexpr uint32_t interval = 20;
176                 SHARING_LOGD("VideoPlayerPlayback test start\n");
177                 while (IsPlaybackRunning()) {
178                     SHARING_LOGD("VideoPlayerPlayback Writing\n");
179                     VideoDataPlayOnce();
180                     std::this_thread::sleep_for(std::chrono::milliseconds(interval));
181                 }
182                 SHARING_LOGD("VideoPlayerPlayback test complete\n");
183             }
184         );
185         pthread_setname_np(playbackThread_->native_handle(), "VideoPlayerPlayback");
186         std::this_thread::sleep_for(std::chrono::milliseconds(waitForThread));
187     }
188 
SpsDataSetup(const char * buf,size_t len)189     void SpsDataSetup(const char *buf, size_t len)
190     {
191         auto sps = std::make_shared<MediaData>();
192         sps->buff = std::make_shared<DataBuffer>();
193         sps->mediaType = MEDIA_TYPE_VIDEO;
194         sps->buff->Assign(const_cast<char *>(buf), len);
195         dispatcher_->SetSpsNalu(sps);
196     }
197 
PpsDataSetup(const char * buf,size_t len)198     void PpsDataSetup(const char *buf, size_t len)
199     {
200         auto pps = std::make_shared<MediaData>();
201         pps->buff = std::make_shared<DataBuffer>();
202         pps->mediaType = MEDIA_TYPE_VIDEO;
203         pps->buff->Assign(const_cast<char *>(buf), len);
204         dispatcher_->SetPpsNalu(pps);
205     }
206 
MediaDataSetup(const char * buf,size_t len,size_t prefix)207     void MediaDataSetup(const char *buf, size_t len, size_t prefix)
208     {
209         auto mediaData = std::make_shared<MediaData>();
210         mediaData->buff = std::make_shared<DataBuffer>();
211         mediaData->mediaType = MEDIA_TYPE_VIDEO;
212         mediaData->isRaw = false;
213         mediaData->keyFrame = (*(buf + prefix) & 0x1f) == 0x05 ? true : false;
214         if (mediaData->keyFrame) {
215             if (isFirstKeyFrame_) {
216                 MEDIA_LOGD("TEST STATISTICS Miracast:first, agent ID:%{public}d, get video frame.", GetId());
217                 isFirstKeyFrame_ = false;
218             } else {
219                 auto end = std::chrono::steady_clock::now();
220                 std::chrono::duration<double, std::milli> diff = end - gopInterval_;
221                 MEDIA_LOGD("TEST STATISTIC Miracast:interval:%{public}.0f ms, "
222                     "agent ID:%{public}d, get video frame, gop:%{public}d, "
223                     "average receiving frames time:%{public}.0f ms.",
224                     diff.count(), GetId(), frameNums_, diff.count() / frameNums_);
225             }
226             frameNums_ = 0;
227             gopInterval_ = std::chrono::steady_clock::now();
228         }
229         ++frameNums_;
230         mediaData->buff->ReplaceData((char *)buf, len);
231         mediaData->pts = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
232         dispatcher_->InputData(mediaData);
233     }
234 
VideoDataPlayOnce(void)235     void VideoDataPlayOnce(void)
236     {
237         SplitH264(reinterpret_cast<char *>(videoTestData_->Data()), videoTestData_->Size(), 0,
238             [&](const char *buf, size_t len, size_t prefix) {
239                 if ((*(buf + prefix) & 0x1f) == 0x06) {
240                     return;
241                 }
242                 if ((*(buf + prefix) & 0x1f) == 0x07) {
243                     auto spsOld = dispatcher_->GetSPS();
244                     if (spsOld != nullptr && spsOld->buff != nullptr) {
245                         return;
246                     }
247                     SpsDataSetup(buf, len);
248                     return;
249                 }
250                 if ((*(buf + prefix) & 0x1f) == 0x08) {
251                     auto ppsOld = dispatcher_->GetPPS();
252                     if (ppsOld != nullptr && ppsOld->buff != nullptr) {
253                         return;
254                     }
255                     PpsDataSetup(buf, len);
256                     return;
257                 }
258                 MediaDataSetup(buf, len, prefix);
259             });
260     }
261 
262 private:
VideoTestDataLoad(void)263     void VideoTestDataLoad(void)
264     {
265         videoTestFp_ = ::fopen(videoTestPath_.c_str(), "r");
266         EXPECT_NE(nullptr, videoTestFp_);
267 
268         bool ret = fseek(videoTestFp_, 0, SEEK_END);
269         EXPECT_EQ(false, ret < 0);
270 
271         size_t fileLen = ftell(videoTestFp_);
272         EXPECT_EQ(false, fileLen < 0);
273 
274         videoTestDataLen_ = fileLen + 1;
275         rewind(videoTestFp_);
276         char *videoTestDataTmp = new char[videoTestDataLen_];
277         EXPECT_NE(nullptr, videoTestDataTmp);
278 
279         memset_s(videoTestDataTmp, videoTestDataLen_, 0, videoTestDataLen_);
280 
281         ret = fread(videoTestDataTmp, 1, fileLen, videoTestFp_);
282         EXPECT_EQ(true, ret > 0);
283 
284         ::fclose(videoTestFp_);
285         videoTestData_ = std::make_shared<DataBuffer>(videoTestDataLen_);
286         videoTestData_->Assign(videoTestDataTmp, fileLen);
287         videoTestFp_ = nullptr;
288         delete[] videoTestDataTmp;
289     }
290 
VideoTestDataUnLoad(void)291     void VideoTestDataUnLoad(void)
292     {
293         if (nullptr != videoTestFp_) {
294             ::fclose(videoTestFp_);
295             videoTestFp_ = nullptr;
296         }
297         if (nullptr != videoTestData_) {
298             videoTestData_ = nullptr;
299         }
300         videoTestDataLen_ = 0;
301     }
302 
InitWindow(void)303     void InitWindow(void)
304     {
305         EXPECT_EQ(nullptr, windowOption_);
306         EXPECT_EQ(nullptr, window_);
307         EXPECT_EQ(nullptr, surfaceNode_);
308         EXPECT_EQ(nullptr, surface_);
309 
310         windowOption_ = new Rosen::WindowOption();
311         windowOption_->SetWindowRect({
312             defaultPositionX,
313             defaultPositionY,
314             defaultWidth,
315             defaultHeight});
316         windowOption_->SetWindowType(
317             Rosen::WindowType::WINDOW_TYPE_APP_LAUNCHING);
318         windowOption_->SetWindowMode(
319             Rosen::WindowMode::WINDOW_MODE_FULLSCREEN);
320         window_ = Rosen::Window::Create(
321             "Video Controller Test Window",
322             windowOption_);
323 
324         surfaceNode_ = window_->GetSurfaceNode();
325         surfaceNode_->SetFrameGravity(Rosen::Gravity::RESIZE);
326         Rosen::RSTransaction::FlushImplicitTransaction();
327 
328         surface_ = surfaceNode_->GetSurface();
329         window_->SetRequestedOrientation(Rosen::Orientation::HORIZONTAL);
330         window_->Show();
331         surfaceId_ = surface_->GetUniqueId();
332 
333         int32_t ret = SurfaceUtils::GetInstance()->Add(surfaceId_, surface_);
334         EXPECT_EQ(ret, 0);
335     }
336 
InitMediaChannel(void)337     void InitMediaChannel(void)
338     {
339         if (nullptr != mediaChannel_) {
340             EXPECT_EQ(nullptr, mediaChannel_);
341             return;
342         }
343         mediaChannel_ = std::make_shared<MediaChannel>();
344         EXPECT_NE(nullptr, mediaChannel_);
345 
346         std::string consumerClassName("MediaplayerTestConsumer");
347         mediaChannel_->CreateConsumer(consumerClassName);
348     }
349 
350 //Audio
351 private:
352     AudioTrack audioTrack_;
353 
354 public:
GetAudioTrack(void)355     AudioTrack& GetAudioTrack(void)
356     {
357         return audioTrack_;
358     }
359 
AudioTrackReset(void)360     void AudioTrackReset(void)
361     {
362         audioTrack_.codecId = CodecId::CODEC_AAC;
363         audioTrack_.sampleRate = defaultSampleRate;
364         audioTrack_.sampleBit = DEFAULT_SAMPLE_BIT;
365         audioTrack_.channels = defaultChannels;
366     }
367 
368 public:
MediaControllerTestBaseImpl()369     MediaControllerTestBaseImpl()
370     {
371         Config::GetInstance().Init();
372         dispatcher_ = std::make_shared<BufferDispatcher>(maxBufferCapacity, maxBufferCapacityIncrement);
373         VideoTestDataLoad();
374         VideoTrackReset();
375         AudioTrackReset();
376         InitWindow();
377     }
378 
~MediaControllerTestBaseImpl()379     ~MediaControllerTestBaseImpl() override
380     {
381         PlaybackStop();
382         VideoTestDataUnLoad();
383         BufferDispatcherReset();
384     }
385 
386 public:
387     static constexpr int32_t maxBufferCapacity = ::MAX_BUFFER_CAPACITY;
388     static constexpr int32_t maxBufferCapacityIncrement = ::BUFFER_CAPACITY_INCREMENT;
389     static constexpr int32_t stabilityLoops = 100;
390     static constexpr int32_t defaultPositionX = 0;
391     static constexpr int32_t defaultPositionY = 0;
392     static constexpr int32_t defaultHeight = 720;
393     static constexpr int32_t defaultWidth = 1280;
394     static constexpr int32_t defaultFrameRate = 30;
395     static constexpr int32_t defaultChannels = 2;
396     static constexpr int32_t defaultSampleRate = 48000;
397     static constexpr int32_t defaultBitsPerSample = 16;
398     static constexpr float defaultVolume = 1.0;
399 };
400 
401 class MediaControllerUnitTest : public testing::Test {};
402 
403 namespace {
404 MediaControllerTestBaseImpl& g_testBase =
405     MediaControllerTestBaseImpl::GetInstance();
406 
407 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Create_01,
408          Function | SmallTest | Level2)
409 {
410     SHARING_LOGD("trace");
411     std::shared_ptr<ContextEventMsg> cem = std::make_shared<ContextEventMsg>();
412     std::unique_ptr<MediaController> mediaController =
413         std::make_unique<MediaController>(g_testBase.GetId());
414     EXPECT_NE(nullptr, mediaController);
415 }
416 
417 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_SetMediaChannel_01,
418          Function | SmallTest | Level2)
419 {
420     SHARING_LOGD("trace");
421     std::unique_ptr<MediaController> mediaController =
422         std::make_unique<MediaController>(g_testBase.GetId());
423     EXPECT_NE(nullptr, mediaController);
424 
425     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
426 }
427 
428 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Init_01,
429          Function | SmallTest | Level2)
430 {
431     SHARING_LOGD("trace");
432     bool ret = true;
433     std::unique_ptr<MediaController> mediaController =
434         std::make_unique<MediaController>(g_testBase.GetId());
435     EXPECT_NE(nullptr, mediaController);
436 
437     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
438     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
439     EXPECT_EQ(ret, false);
440 
441     g_testBase.VideoTrackReset();
442 }
443 
444 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Init_02,
445          Function | SmallTest | Level2)
446 {
447     SHARING_LOGD("trace");
448     bool ret = true;
449     std::unique_ptr<MediaController> mediaController =
450         std::make_unique<MediaController>(g_testBase.GetId());
451     EXPECT_NE(nullptr, mediaController);
452 
453     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
454     g_testBase.GetVideoTrack().codecId = CodecId::CODEC_NONE;
455     g_testBase.GetAudioTrack().codecId = CodecId::CODEC_NONE;
456     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
457     EXPECT_EQ(ret, false);
458 
459     g_testBase.VideoTrackReset();
460     g_testBase.AudioTrackReset();
461 }
462 
463 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Init_03,
464          Function | SmallTest | Level2)
465 {
466     SHARING_LOGD("trace");
467     bool ret = true;
468     std::unique_ptr<MediaController> mediaController =
469         std::make_unique<MediaController>(g_testBase.GetId());
470     EXPECT_NE(nullptr, mediaController);
471 
472     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
473     g_testBase.GetAudioTrack().codecId = CodecId::CODEC_H264;
474     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
475     EXPECT_EQ(ret, false);
476 
477     g_testBase.AudioTrackReset();
478 }
479 
480 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Play_01, Function | SmallTest | Level2)
481 {
482     SHARING_LOGD("trace");
483     bool ret = true;
484     std::unique_ptr<MediaController> mediaController =
485         std::make_unique<MediaController>(g_testBase.GetId());
486     EXPECT_NE(nullptr, mediaController);
487 
488     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
489     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
490     EXPECT_EQ(ret, true);
491 
492     mediaController->Start();
493     EXPECT_EQ(ret, true);
494 
495     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
496     EXPECT_EQ(ret, true);
497 
498     g_testBase.VideoDataPlayOnce();
499     mediaController->Stop();
500 }
501 
502 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Start_01, Function | SmallTest | Level2)
503 {
504     SHARING_LOGD("trace");
505     bool ret = true;
506     std::unique_ptr<MediaController> mediaController =
507         std::make_unique<MediaController>(g_testBase.GetId());
508     EXPECT_NE(nullptr, mediaController);
509 
510     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
511     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
512     EXPECT_EQ(ret, true);
513 
514     mediaController->Start();
515 }
516 
517 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Start_02, Function | SmallTest | Level2)
518 {
519     SHARING_LOGD("trace");
520     std::unique_ptr<MediaController> mediaController =
521         std::make_unique<MediaController>(g_testBase.GetId());
522     EXPECT_NE(nullptr, mediaController);
523 
524     mediaController->Start();
525 }
526 
527 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Start_03, Function | SmallTest | Level2)
528 {
529     SHARING_LOGD("trace");
530     bool ret = true;
531     std::unique_ptr<MediaController> mediaController =
532         std::make_unique<MediaController>(g_testBase.GetId());
533     EXPECT_NE(nullptr, mediaController);
534 
535     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
536     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
537     EXPECT_EQ(ret, true);
538 
539     mediaController->Release();
540     mediaController->Start();
541 }
542 
543 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Start_04, Function | SmallTest | Level2)
544 {
545     SHARING_LOGD("trace");
546     bool ret = true;
547     std::unique_ptr<MediaController> mediaController =
548         std::make_unique<MediaController>(g_testBase.GetId());
549     EXPECT_NE(nullptr, mediaController);
550 
551     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
552     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
553     EXPECT_EQ(ret, true);
554 
555     mediaController->Start();
556 
557     mediaController->Stop();
558     mediaController->Start();
559 }
560 
561 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Start_05, Function | SmallTest | Level2)
562 {
563     SHARING_LOGD("trace");
564     bool ret = true;
565     std::unique_ptr<MediaController> mediaController =
566         std::make_unique<MediaController>(g_testBase.GetId());
567     EXPECT_NE(nullptr, mediaController);
568 
569     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
570     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
571     EXPECT_EQ(ret, true);
572 
573     mediaController->Start();
574     mediaController->Start();
575     mediaController->Stop();
576 }
577 
578 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Start_06, Function | SmallTest | Level2)
579 {
580     SHARING_LOGD("trace");
581     std::unique_ptr<MediaController> mediaController =
582         std::make_unique<MediaController>(g_testBase.GetId());
583     EXPECT_NE(nullptr, mediaController);
584 
585     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
586     mediaController->Start();
587 }
588 
589 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_AppendSurface_01, Function | SmallTest | Level2)
590 {
591     SHARING_LOGD("trace");
592     bool ret = true;
593     std::unique_ptr<MediaController> mediaController =
594         std::make_unique<MediaController>(g_testBase.GetId());
595     EXPECT_NE(nullptr, mediaController);
596 
597     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
598     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
599     EXPECT_EQ(ret, true);
600 
601     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
602     EXPECT_EQ(ret, true);
603 }
604 
605 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_AppendSurface_02, Function | SmallTest | Level2)
606 {
607     SHARING_LOGD("trace");
608     bool ret = true;
609     std::unique_ptr<MediaController> mediaController =
610         std::make_unique<MediaController>(g_testBase.GetId());
611     EXPECT_NE(nullptr, mediaController);
612 
613     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
614     EXPECT_EQ(ret, true);
615 
616     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::BACKGROUND);
617     EXPECT_EQ(ret, false);
618 }
619 
620 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_AppendSurface_03, Function | SmallTest | Level2)
621 {
622     SHARING_LOGD("trace");
623     bool ret = true;
624     std::unique_ptr<MediaController> mediaController =
625         std::make_unique<MediaController>(g_testBase.GetId());
626     EXPECT_NE(nullptr, mediaController);
627 
628     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
629     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
630     EXPECT_EQ(ret, true);
631 
632     mediaController->videoTrack_.codecId = CodecId::CODEC_NONE;
633     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
634     EXPECT_EQ(ret, true);
635 
636     g_testBase.VideoTrackReset();
637 }
638 
639 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_AppendSurface_04, Function | SmallTest | Level2)
640 {
641     SHARING_LOGD("trace");
642     bool ret = true;
643     std::unique_ptr<MediaController> mediaController =
644         std::make_unique<MediaController>(g_testBase.GetId());
645     EXPECT_NE(nullptr, mediaController);
646 
647     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
648     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
649     EXPECT_EQ(ret, true);
650 
651     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
652     EXPECT_EQ(ret, true);
653 
654     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
655     EXPECT_EQ(ret, false);
656 }
657 
658 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_AppendSurface_05, Function | SmallTest | Level2)
659 {
660     SHARING_LOGD("trace");
661     bool ret = true;
662     std::unique_ptr<MediaController> mediaController =
663         std::make_unique<MediaController>(g_testBase.GetId());
664     EXPECT_NE(nullptr, mediaController);
665 
666     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
667     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
668     EXPECT_EQ(ret, true);
669 
670     mediaController->Start();
671 
672     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
673     EXPECT_EQ(ret, true);
674 }
675 
676 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_AppendSurface_06, Function | SmallTest | Level2)
677 {
678     SHARING_LOGD("trace");
679     bool ret = true;
680     std::unique_ptr<MediaController> mediaController =
681         std::make_unique<MediaController>(g_testBase.GetId());
682     EXPECT_NE(nullptr, mediaController);
683 
684     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
685     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
686     EXPECT_EQ(ret, true);
687 
688     mediaController->videoTrack_.codecId = CodecId::CODEC_NONE;
689     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
690     EXPECT_EQ(ret, false);
691 }
692 
693 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_RemoveSurface_01, Function | SmallTest | Level2)
694 {
695     SHARING_LOGD("trace");
696     bool ret = true;
697     std::unique_ptr<MediaController> mediaController =
698         std::make_unique<MediaController>(g_testBase.GetId());
699     EXPECT_NE(nullptr, mediaController);
700 
701     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
702     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
703     EXPECT_EQ(ret, true);
704 
705     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
706     EXPECT_EQ(ret, true);
707 
708     mediaController->RemoveSurface(g_testBase.GetSurface()->GetUniqueId());
709 }
710 
711 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_SetVolume_01, Function | SmallTest | Level2)
712 {
713     SHARING_LOGD("trace");
714     bool ret = true;
715     std::unique_ptr<MediaController> mediaController =
716         std::make_unique<MediaController>(g_testBase.GetId());
717     EXPECT_NE(nullptr, mediaController);
718 
719     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
720     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
721     EXPECT_EQ(ret, true);
722 
723     mediaController->SetVolume(MediaControllerTestBaseImpl::defaultVolume);
724 }
725 
726 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_SetKeyMode_01, Function | SmallTest | Level2)
727 {
728     SHARING_LOGD("trace");
729     bool ret = true;
730     std::unique_ptr<MediaController> mediaController =
731         std::make_unique<MediaController>(g_testBase.GetId());
732     EXPECT_NE(nullptr, mediaController);
733 
734     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
735     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
736     EXPECT_EQ(ret, true);
737 
738     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
739     EXPECT_EQ(ret, true);
740 
741     mediaController->SetKeyMode(g_testBase.GetSurface()->GetUniqueId(), false);
742 }
743 
744 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_SetKeyRedirect_01, Function | SmallTest | Level2)
745 {
746     SHARING_LOGD("trace");
747     bool ret = true;
748     std::unique_ptr<MediaController> mediaController =
749         std::make_unique<MediaController>(g_testBase.GetId());
750     EXPECT_NE(nullptr, mediaController);
751 
752     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
753     EXPECT_EQ(ret, true);
754 
755     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
756     EXPECT_EQ(ret, true);
757 
758     mediaController->SetKeyRedirect(g_testBase.GetSurface()->GetUniqueId(), false);
759 }
760 
761 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_OnPlayControllerNotify_01, Function | SmallTest | Level2)
762 {
763     SHARING_LOGD("trace");
764     bool ret = true;
765     ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
766     std::unique_ptr<MediaController> mediaController =
767         std::make_unique<MediaController>(g_testBase.GetId());
768     EXPECT_NE(nullptr, mediaController);
769 
770     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
771     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
772     EXPECT_EQ(ret, true);
773 
774     ret = mediaController->AppendSurface(g_testBase.GetSurface(), SceneType::FOREGROUND);
775     EXPECT_EQ(ret, true);
776 
777     statusMsg->errorCode = ERR_OK;
778     statusMsg->prosumerId = g_testBase.GetId();
779     statusMsg->agentId = g_testBase.GetId();
780     mediaController->OnPlayControllerNotify(statusMsg);
781 }
782 
783 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_OnPlayControllerNotify_02, Function | SmallTest | Level2)
784 {
785     SHARING_LOGD("trace");
786     ProsumerStatusMsg::Ptr statusMsg = std::make_shared<ProsumerStatusMsg>();
787     std::unique_ptr<MediaController> mediaController =
788         std::make_unique<MediaController>(g_testBase.GetId());
789     EXPECT_NE(nullptr, mediaController);
790 
791     statusMsg->errorCode = ERR_OK;
792     statusMsg->prosumerId = g_testBase.GetId();
793     mediaController->OnPlayControllerNotify(statusMsg);
794 }
795 
796 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Stop_01, Function | SmallTest | Level2)
797 {
798     SHARING_LOGD("trace");
799     bool ret = true;
800     std::unique_ptr<MediaController> mediaController =
801         std::make_unique<MediaController>(g_testBase.GetId());
802     EXPECT_NE(nullptr, mediaController);
803 
804     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
805     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
806     EXPECT_EQ(ret, true);
807 
808     mediaController->Start();
809     EXPECT_EQ(ret, true);
810 
811     mediaController->Stop();
812 }
813 
814 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Stop_02, Function | SmallTest | Level2)
815 {
816     SHARING_LOGD("trace");
817     bool ret = true;
818     std::unique_ptr<MediaController> mediaController =
819         std::make_unique<MediaController>(g_testBase.GetId());
820     EXPECT_NE(nullptr, mediaController);
821 
822     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
823     EXPECT_EQ(ret, true);
824 
825     mediaController->Stop();
826 }
827 
828 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Stop_03, Function | SmallTest | Level2)
829 {
830     SHARING_LOGD("trace");
831     std::unique_ptr<MediaController> mediaController =
832         std::make_unique<MediaController>(g_testBase.GetId());
833     EXPECT_NE(nullptr, mediaController);
834 
835     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
836     mediaController->Stop();
837 }
838 
839 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Stop_04, Function | SmallTest | Level2)
840 {
841     SHARING_LOGD("trace");
842     bool ret = true;
843     std::unique_ptr<MediaController> mediaController =
844         std::make_unique<MediaController>(g_testBase.GetId());
845     EXPECT_NE(nullptr, mediaController);
846 
847     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
848     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
849     EXPECT_EQ(ret, true);
850 
851     mediaController->Release();
852 
853     mediaController->Stop();
854 }
855 
856 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Stop_05, Function | SmallTest | Level2)
857 {
858     SHARING_LOGD("trace");
859     bool ret = true;
860     std::unique_ptr<MediaController> mediaController =
861         std::make_unique<MediaController>(g_testBase.GetId());
862     EXPECT_NE(nullptr, mediaController);
863 
864     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
865     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
866     EXPECT_EQ(ret, true);
867 
868     mediaController->Start();
869     mediaController->Stop();
870     mediaController->Start();
871     mediaController->Stop();
872 }
873 
874 HWTEST_F(MediaControllerUnitTest, Media_Controller_Test_Release_01, Function | SmallTest | Level2)
875 {
876     SHARING_LOGD("trace");
877     bool ret = true;
878     std::unique_ptr<MediaController> mediaController =
879         std::make_unique<MediaController>(g_testBase.GetId());
880     EXPECT_NE(nullptr, mediaController);
881 
882     mediaController->SetMediaChannel(g_testBase.GetMediaChannel());
883     ret = mediaController->Init(g_testBase.GetAudioTrack(), g_testBase.GetVideoTrack());
884     EXPECT_EQ(ret, true);
885 
886     mediaController->Release();
887 }
888 
889 } // namespace
890 } // namespace Sharing
891 } // namespace OHOS