1 /*
2  * Copyright (c) 2022 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 "player_mock.h"
17 #include <fcntl.h>
18 #include <sys/stat.h>
19 #include "media_errors.h"
20 #include "transaction/rs_transaction.h"
21 #include "ui/rs_surface_node.h"
22 #include "window_option.h"
23 
24 using namespace OHOS::Media::PlayerTestParam;
25 
26 namespace OHOS {
27 namespace Media {
SetState(PlayerStates state)28 void PlayerCallbackTest::SetState(PlayerStates state)
29 {
30     state_ = state;
31 }
32 
SetSeekDoneFlag(bool seekDoneFlag)33 void PlayerCallbackTest::SetSeekDoneFlag(bool seekDoneFlag)
34 {
35     seekDoneFlag_ = seekDoneFlag;
36 }
37 
SetSpeedDoneFlag(bool speedDoneFlag)38 void PlayerCallbackTest::SetSpeedDoneFlag(bool speedDoneFlag)
39 {
40     speedDoneFlag_ = speedDoneFlag;
41 }
42 
SetSeekPosition(int32_t seekPosition)43 void PlayerCallbackTest::SetSeekPosition(int32_t seekPosition)
44 {
45     seekPosition_ = seekPosition;
46 }
47 
SetTrackDoneFlag(bool trackDoneFlag)48 void PlayerCallbackTest::SetTrackDoneFlag(bool trackDoneFlag)
49 {
50     std::unique_lock<std::mutex> lockSpeed(mutexCond_);
51     trackDoneFlag_ = trackDoneFlag;
52     trackChange_ = trackDoneFlag;
53 }
54 
PrepareSync()55 int32_t PlayerCallbackTest::PrepareSync()
56 {
57     if (state_ != PLAYER_PREPARED) {
58         std::unique_lock<std::mutex> lockPrepare(mutexCond_);
59         condVarPrepare_.wait_for(lockPrepare, std::chrono::seconds(waitsecond));
60         if (state_ != PLAYER_PREPARED) {
61             return -1;
62         }
63     }
64     return MSERR_OK;
65 }
66 
PlaySync()67 int32_t PlayerCallbackTest::PlaySync()
68 {
69     if (state_ != PLAYER_STARTED) {
70         std::unique_lock<std::mutex> lockPlay(mutexCond_);
71         condVarPlay_.wait_for(lockPlay, std::chrono::seconds(waitsecond));
72         if (state_ != PLAYER_STARTED && state_ != PLAYER_PLAYBACK_COMPLETE) {
73             return -1;
74         }
75     }
76     return MSERR_OK;
77 }
78 
PauseSync()79 int32_t PlayerCallbackTest::PauseSync()
80 {
81     if (state_ != PLAYER_PAUSED) {
82         std::unique_lock<std::mutex> lockPause(mutexCond_);
83         condVarPause_.wait_for(lockPause, std::chrono::seconds(waitsecond));
84         if (state_ != PLAYER_PAUSED) {
85             return -1;
86         }
87     }
88     return MSERR_OK;
89 }
90 
StopSync()91 int32_t PlayerCallbackTest::StopSync()
92 {
93     if (state_ != PLAYER_STOPPED) {
94         std::unique_lock<std::mutex> lockStop(mutexCond_);
95         condVarStop_.wait_for(lockStop, std::chrono::seconds(waitsecond));
96         if (state_ != PLAYER_STOPPED) {
97             return -1;
98         }
99     }
100     return MSERR_OK;
101 }
102 
ResetSync()103 int32_t PlayerCallbackTest::ResetSync()
104 {
105     if (state_ != PLAYER_IDLE) {
106         std::unique_lock<std::mutex> lockReset(mutexCond_);
107         condVarReset_.wait_for(lockReset, std::chrono::seconds(waitsecond));
108         if (state_ != PLAYER_IDLE) {
109             return -1;
110         }
111     }
112     return MSERR_OK;
113 }
114 
SeekSync()115 int32_t PlayerCallbackTest::SeekSync()
116 {
117     if (seekDoneFlag_ == false) {
118         std::unique_lock<std::mutex> lockSeek(mutexCond_);
119         condVarSeek_.wait_for(lockSeek, std::chrono::seconds(waitsecond));
120         if (seekDoneFlag_ == false) {
121             return -1;
122         }
123     }
124     return MSERR_OK;
125 }
126 
SpeedSync()127 int32_t PlayerCallbackTest::SpeedSync()
128 {
129     if (speedDoneFlag_ == false) {
130         std::unique_lock<std::mutex> lockSpeed(mutexCond_);
131         condVarSpeed_.wait_for(lockSpeed, std::chrono::seconds(waitsecond));
132         if (speedDoneFlag_ == false) {
133             return -1;
134         }
135     }
136     return MSERR_OK;
137 }
138 
TrackSync(bool & trackChange)139 int32_t PlayerCallbackTest::TrackSync(bool &trackChange)
140 {
141     if (trackDoneFlag_ == false) {
142         std::unique_lock<std::mutex> lockTrackDone(mutexCond_);
143         condVarTrackDone_.wait_for(lockTrackDone, std::chrono::seconds(waitsecond));
144         if (trackDoneFlag_ == false) {
145             return -1;
146         }
147     }
148 
149     trackChange = trackChange_;
150 
151     return MSERR_OK;
152 }
153 
TrackInfoUpdateSync()154 int32_t PlayerCallbackTest::TrackInfoUpdateSync()
155 {
156     if (trackInfoUpdate_ == false) {
157         std::unique_lock<std::mutex> lock(mutexCond_);
158         condVarTrackInfoUpdate_.wait_for(lock, std::chrono::seconds(waitsecond), [this]() {
159             return trackInfoUpdate_;
160         });
161         if (trackInfoUpdate_ == false) {
162             return -1;
163         }
164     }
165     trackInfoUpdate_ = false;
166     return MSERR_OK;
167 }
168 
HandleTrackChangeCallback(int32_t extra,const Format & infoBody)169 void PlayerCallbackTest::HandleTrackChangeCallback(int32_t extra, const Format &infoBody)
170 {
171     (void)extra;
172     trackChange_ = true;
173     trackDoneFlag_ = true;
174     int32_t index;
175     int32_t isSelect;
176     infoBody.GetIntValue(std::string(PlayerKeys::PLAYER_TRACK_INDEX), index);
177     infoBody.GetIntValue(std::string(PlayerKeys::PLAYER_IS_SELECT), isSelect);
178     std::cout << "INFO_TYPE_TRACKCHANGE: index " << index << " isSelect " << isSelect << std::endl;
179     condVarTrackDone_.notify_all();
180 }
181 
HandleSubtitleCallback(int32_t extra,const Format & infoBody)182 void PlayerCallbackTest::HandleSubtitleCallback(int32_t extra, const Format &infoBody)
183 {
184     (void)extra;
185     infoBody.GetStringValue(std::string(PlayerKeys::SUBTITLE_TEXT), text_);
186     std::cout << "text = " << text_ << std::endl;
187     textUpdate_ = true;
188     condVarText_.notify_all();
189 }
190 
HandleTrackInfoCallback(int32_t extra,const Format & infoBody)191 void PlayerCallbackTest::HandleTrackInfoCallback(int32_t extra, const Format &infoBody)
192 {
193     (void)extra;
194     std::cout << "track info update" << std::endl;
195     trackInfoUpdate_ = true;
196     condVarTrackInfoUpdate_.notify_all();
197 }
198 
OnInfo(PlayerOnInfoType type,int32_t extra,const Format & infoBody)199 void PlayerCallbackTest::OnInfo(PlayerOnInfoType type, int32_t extra, const Format &infoBody)
200 {
201     switch (type) {
202         case INFO_TYPE_SEEKDONE:
203             SetSeekDoneFlag(true);
204             SeekNotify(extra, infoBody);
205             break;
206         case INFO_TYPE_STATE_CHANGE:
207             state_ = static_cast<PlayerStates>(extra);
208             SetState(state_);
209             Notify(state_);
210             break;
211         case INFO_TYPE_SPEEDDONE:
212             SetSpeedDoneFlag(true);
213             condVarSpeed_.notify_all();
214             break;
215         case INFO_TYPE_POSITION_UPDATE:
216             std::cout << "cur position is " << static_cast<uint64_t>(extra) << std::endl;
217             break;
218         case INFO_TYPE_BITRATE_COLLECT:
219             std::cout << "INFO_TYPE_BITRATE_COLLECT: " << extra << std::endl;
220             break;
221         case INFO_TYPE_INTERRUPT_EVENT:
222             std::cout << "INFO_TYPE_INTERRUPT_EVENT: " << extra << std::endl;
223             break;
224         case INFO_TYPE_RESOLUTION_CHANGE:
225             std::cout << "INFO_TYPE_RESOLUTION_CHANGE: " << extra << std::endl;
226             break;
227         case INFO_TYPE_TRACKCHANGE:
228             HandleTrackChangeCallback(extra, infoBody);
229             break;
230         case INFO_TYPE_SUBTITLE_UPDATE: {
231             HandleSubtitleCallback(extra, infoBody);
232             break;
233         }
234         case INFO_TYPE_TRACK_INFO_UPDATE: {
235             HandleTrackInfoCallback(extra, infoBody);
236             break;
237         }
238         case INFO_TYPE_AUDIO_DEVICE_CHANGE: {
239             std::cout << "device change reason is " << extra;
240             break;
241         }
242         default:
243             break;
244     }
245 }
246 
SubtitleTextUpdate(std::string text)247 std::string PlayerCallbackTest::SubtitleTextUpdate(std::string text)
248 {
249     std::unique_lock<std::mutex> lock(subtitleMutex_);
250     std::cout << "wait for text update" <<std::endl;
251     condVarText_.wait_for(lock, std::chrono::seconds(waitsecond), [&, this]() {
252         if (text_ != text) {
253             return textUpdate_ = false;
254         }
255         return textUpdate_;
256     });
257     std::cout << "text updated" <<std::endl;
258     textUpdate_ = false;
259     return text_;
260 }
261 
OnError(int32_t errorCode,const std::string & errorMsg)262 void PlayerCallbackTest::OnError(int32_t errorCode, const std::string &errorMsg)
263 {
264     if (!trackDoneFlag_) {
265         trackDoneFlag_ = true;
266         condVarTrackDone_.notify_all();
267     }
268     std::cout << "Error received, errorCode: " << errorCode << " errorMsg: " << errorMsg << std::endl;
269 }
270 
Notify(PlayerStates currentState)271 void PlayerCallbackTest::Notify(PlayerStates currentState)
272 {
273     if (currentState == PLAYER_PREPARED) {
274         condVarPrepare_.notify_all();
275     } else if (currentState == PLAYER_STARTED) {
276         condVarPlay_.notify_all();
277     } else if (currentState == PLAYER_PAUSED) {
278         condVarPause_.notify_all();
279     } else if (currentState == PLAYER_STOPPED) {
280         condVarStop_.notify_all();
281     } else if (currentState == PLAYER_IDLE) {
282         condVarReset_.notify_all();
283     }
284 }
285 
SeekNotify(int32_t extra,const Format & infoBody)286 void PlayerCallbackTest::SeekNotify(int32_t extra, const Format &infoBody)
287 {
288     if (seekMode_ == PlayerSeekMode::SEEK_CLOSEST) {
289         if (seekPosition_ == extra) {
290             condVarSeek_.notify_all();
291         }
292     } else if (seekMode_ == PlayerSeekMode::SEEK_PREVIOUS_SYNC) {
293         if (seekPosition_ - extra < DELTA_TIME && extra - seekPosition_ >= 0) {
294             condVarSeek_.notify_all();
295         }
296     } else if (seekMode_ == PlayerSeekMode::SEEK_NEXT_SYNC) {
297         if (extra - seekPosition_ < DELTA_TIME && seekPosition_ - extra >= 0) {
298             condVarSeek_.notify_all();
299         }
300     } else if (abs(seekPosition_ - extra) <= DELTA_TIME) {
301         condVarSeek_.notify_all();
302     } else {
303         SetSeekDoneFlag(false);
304     }
305 }
306 
GetVideoSurface()307 sptr<Surface> PlayerMock::GetVideoSurface()
308 {
309     sptr<Rosen::WindowOption> option = new Rosen::WindowOption();
310     option->SetWindowRect({ 0, 0, width_, height_ });
311     option->SetWindowType(Rosen::WindowType::WINDOW_TYPE_FLOAT);
312     option->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
313     previewWindow_ = Rosen::Window::Create("xcomponent_window", option);
314     if (previewWindow_ == nullptr || previewWindow_->GetSurfaceNode() == nullptr) {
315         return nullptr;
316     }
317 
318     previewWindow_->Show();
319     auto surfaceNode = previewWindow_->GetSurfaceNode();
320     surfaceNode->SetFrameGravity(Rosen::Gravity::RESIZE);
321     Rosen::RSTransaction::FlushImplicitTransaction();
322     return surfaceNode->GetSurface();
323 }
324 
PlayerMock(std::shared_ptr<PlayerCallbackTest> & callback)325 PlayerMock::PlayerMock(std::shared_ptr<PlayerCallbackTest> &callback)
326 {
327     callback_ = callback;
328 }
329 
~PlayerMock()330 PlayerMock::~PlayerMock()
331 {
332     if (previewWindow_ != nullptr) {
333         previewWindow_->Destroy();
334         previewWindow_ = nullptr;
335     }
336 
337     if (previewWindowNext_ != nullptr) {
338         previewWindowNext_->Destroy();
339         previewWindowNext_ = nullptr;
340     }
341 }
342 
CreatePlayer()343 bool PlayerMock::CreatePlayer()
344 {
345     player_ = PlayerFactory::CreatePlayer();
346     return player_ != nullptr;
347 }
348 
SetMediaSource(const std::shared_ptr<AVMediaSource> & mediaSource,AVPlayStrategy strategy)349 int32_t PlayerMock::SetMediaSource(const std::shared_ptr<AVMediaSource> &mediaSource, AVPlayStrategy strategy)
350 {
351     std::unique_lock<std::mutex> lock(mutex_);
352     return player_->SetMediaSource(mediaSource, strategy);
353 }
354 
SetSource(const std::string url)355 int32_t PlayerMock::SetSource(const std::string url)
356 {
357     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
358     std::unique_lock<std::mutex> lock(mutex_);
359     int32_t ret = player_->SetSource(url);
360     return ret;
361 }
362 
SetSource(int32_t fd,int64_t offset,int64_t size)363 int32_t PlayerMock::SetSource(int32_t fd, int64_t offset, int64_t size)
364 {
365     std::unique_lock<std::mutex> lock(mutex_);
366     return player_->SetSource(fd, offset, size);
367 }
368 
SetSource(const std::string & path,int64_t offset,int64_t size)369 int32_t PlayerMock::SetSource(const std::string &path, int64_t offset, int64_t size)
370 {
371     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
372     std::string rawFile = path.substr(strlen("file://"));
373     int32_t fd = open(rawFile.c_str(), O_RDONLY);
374     if (fd <= 0) {
375         std::cout << "Open file failed" << std::endl;
376         return -1;
377     }
378 
379     struct stat64 st;
380     if (fstat64(fd, &st) != 0) {
381         std::cout << "Get file state failed" << std::endl;
382         (void)close(fd);
383         return -1;
384     }
385     int64_t length = static_cast<int64_t>(st.st_size);
386     if (size > 0) {
387         length = size;
388     }
389     int32_t ret = player_->SetSource(fd, offset, length);
390     if (ret != 0) {
391         (void)close(fd);
392         return -1;
393     }
394 
395     (void)close(fd);
396     return ret;
397 }
398 
SetDataSrc(const std::string & path,int32_t size,bool seekable)399 int32_t PlayerMock::SetDataSrc(const std::string &path, int32_t size, bool seekable)
400 {
401     if (seekable) {
402         dataSrc_ = MediaDataSourceTestSeekable::Create(path, size);
403     } else {
404         dataSrc_ = MediaDataSourceTestNoSeek::Create(path, size);
405     }
406     return player_->SetSource(dataSrc_);
407 }
408 
Prepare()409 int32_t PlayerMock::Prepare()
410 {
411     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
412     std::unique_lock<std::mutex> lock(mutex_);
413     int32_t ret = player_->Prepare();
414     if (ret == MSERR_OK) {
415         return callback_->PrepareSync();
416     }
417     return ret;
418 }
419 
PrepareAsync()420 int32_t PlayerMock::PrepareAsync()
421 {
422     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
423     std::unique_lock<std::mutex> lock(mutex_);
424     int ret = player_->PrepareAsync();
425     if (ret == MSERR_OK) {
426         return callback_->PrepareSync();
427     }
428     return ret;
429 }
430 
Play()431 int32_t PlayerMock::Play()
432 {
433     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
434     std::unique_lock<std::mutex> lock(mutex_);
435     int32_t ret = player_->Play();
436     if (ret == MSERR_OK) {
437         return callback_->PlaySync();
438     }
439     return ret;
440 }
441 
Pause()442 int32_t PlayerMock::Pause()
443 {
444     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
445     std::unique_lock<std::mutex> lock(mutex_);
446     int32_t ret = player_->Pause();
447     if (ret == MSERR_OK) {
448         return callback_->PauseSync();
449     }
450     return ret;
451 }
452 
Stop()453 int32_t PlayerMock::Stop()
454 {
455     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
456     std::unique_lock<std::mutex> lock(mutex_);
457     int32_t ret = player_->Stop();
458     if (ret == MSERR_OK) {
459         if (dataSrc_ != nullptr) {
460             dataSrc_->Reset();
461         }
462         return callback_->StopSync();
463     }
464     return ret;
465 }
466 
SeekPrepare(int32_t & mseconds,PlayerSeekMode & mode)467 void PlayerMock::SeekPrepare(int32_t &mseconds, PlayerSeekMode &mode)
468 {
469     UNITTEST_CHECK_AND_RETURN_LOG(player_ != nullptr && callback_ != nullptr, "player or callback is nullptr");
470     int32_t duration = 0;
471     int32_t seekPosition = 0;
472     callback_->SetSeekDoneFlag(false);
473     player_->GetDuration(duration);
474     if (mseconds < 0) {
475         seekPosition = 0;
476     } else if (mseconds > duration) {
477         seekPosition = duration;
478     } else {
479         seekPosition = mseconds;
480     }
481     callback_->SetSeekPosition(seekPosition);
482 }
483 
Seek(int32_t mseconds,PlayerSeekMode mode)484 int32_t PlayerMock::Seek(int32_t mseconds, PlayerSeekMode mode)
485 {
486     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
487     std::unique_lock<std::mutex> lock(mutex_);
488     SeekPrepare(mseconds, mode);
489     int32_t ret = player_->Seek(mseconds, mode);
490     if (ret == MSERR_OK) {
491         return callback_->SeekSync();
492     }
493     return ret;
494 }
495 
Reset()496 int32_t PlayerMock::Reset()
497 {
498     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
499     int32_t ret = player_->Reset();
500     if (ret == MSERR_OK) {
501         return callback_->ResetSync();
502     }
503     return ret;
504 }
505 
Release()506 int32_t PlayerMock::Release()
507 {
508     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
509     if (previewWindow_ != nullptr) {
510         previewWindow_->Destroy();
511         previewWindow_ = nullptr;
512     }
513     callback_ = nullptr;
514     return player_->Release();
515 }
516 
ReleaseSync()517 int32_t PlayerMock::ReleaseSync()
518 {
519     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
520     if (previewWindow_ != nullptr) {
521         previewWindow_->Destroy();
522         previewWindow_ = nullptr;
523     }
524     callback_ = nullptr;
525     return player_->ReleaseSync();
526 }
527 
SetVolume(float leftVolume,float rightVolume)528 int32_t PlayerMock::SetVolume(float leftVolume, float rightVolume)
529 {
530     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
531     std::unique_lock<std::mutex> lock(mutex_);
532     return player_->SetVolume(leftVolume, rightVolume);
533 }
534 
SetLooping(bool loop)535 int32_t PlayerMock::SetLooping(bool loop)
536 {
537     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
538     std::unique_lock<std::mutex> lock(mutex_);
539     return player_->SetLooping(loop);
540 }
541 
GetCurrentTime(int32_t & currentTime)542 int32_t PlayerMock::GetCurrentTime(int32_t &currentTime)
543 {
544     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
545     std::unique_lock<std::mutex> lock(mutex_);
546     return player_->GetCurrentTime(currentTime);
547 }
548 
GetVideoTrackInfo(std::vector<Format> & videoTrack)549 int32_t PlayerMock::GetVideoTrackInfo(std::vector<Format> &videoTrack)
550 {
551     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
552     return player_->GetVideoTrackInfo(videoTrack);
553 }
554 
GetPlaybackInfo(Format & playbackInfo)555 int32_t PlayerMock::GetPlaybackInfo(Format &playbackInfo)
556 {
557     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
558     return player_->GetPlaybackInfo(playbackInfo);
559 }
560 
GetAudioTrackInfo(std::vector<Format> & audioTrack)561 int32_t PlayerMock::GetAudioTrackInfo(std::vector<Format> &audioTrack)
562 {
563     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
564     return player_->GetAudioTrackInfo(audioTrack);
565 }
566 
GetVideoWidth()567 int32_t PlayerMock::GetVideoWidth()
568 {
569     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
570     return player_->GetVideoWidth();
571 }
572 
GetVideoHeight()573 int32_t PlayerMock::GetVideoHeight()
574 {
575     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
576     return player_->GetVideoHeight();
577 }
578 
GetDuration(int32_t & duration)579 int32_t PlayerMock::GetDuration(int32_t &duration)
580 {
581     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
582     return player_->GetDuration(duration);
583 }
584 
SetPlaybackSpeed(PlaybackRateMode mode)585 int32_t PlayerMock::SetPlaybackSpeed(PlaybackRateMode mode)
586 {
587     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
588     callback_->SetSpeedDoneFlag(false);
589     int32_t ret = player_->SetPlaybackSpeed(mode);
590     if (ret == MSERR_OK) {
591         return callback_->SpeedSync();
592     }
593     return player_->SetPlaybackSpeed(mode);
594 }
595 
GetPlaybackSpeed(PlaybackRateMode & mode)596 int32_t PlayerMock::GetPlaybackSpeed(PlaybackRateMode &mode)
597 {
598     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
599     return player_->GetPlaybackSpeed(mode);
600 }
601 
SelectBitRate(uint32_t bitRate)602 int32_t PlayerMock::SelectBitRate(uint32_t bitRate)
603 {
604     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
605     return player_->SelectBitRate(bitRate);
606 }
607 
IsPlaying()608 bool PlayerMock::IsPlaying()
609 {
610     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
611     std::unique_lock<std::mutex> lock(mutex_);
612     return player_->IsPlaying();
613 }
614 
IsLooping()615 bool PlayerMock::IsLooping()
616 {
617     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
618     std::unique_lock<std::mutex> lock(mutex_);
619     return player_->IsLooping();
620 }
621 
SetParameter(const Format & param)622 int32_t PlayerMock::SetParameter(const Format &param)
623 {
624     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
625     return player_->SetParameter(param);
626 }
627 
SetPlayerCallback(const std::shared_ptr<PlayerCallback> & callback)628 int32_t PlayerMock::SetPlayerCallback(const std::shared_ptr<PlayerCallback> &callback)
629 {
630     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
631     std::unique_lock<std::mutex> lock(mutex_);
632     return player_->SetPlayerCallback(callback);
633 }
634 
SetVideoSurface(sptr<Surface> surface)635 int32_t PlayerMock::SetVideoSurface(sptr<Surface> surface)
636 {
637     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
638     std::unique_lock<std::mutex> lock(mutex_);
639     return player_->SetVideoSurface(surface);
640 }
641 
SelectTrack(int32_t index,bool & trackChange)642 int32_t PlayerMock::SelectTrack(int32_t index, bool &trackChange)
643 {
644     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
645     std::unique_lock<std::mutex> lock(mutex_);
646     callback_->SetTrackDoneFlag(false);
647     int32_t ret = player_->SelectTrack(index, PlayerSwitchMode::SWITCH_SMOOTH);
648     if (callback_->TrackSync(trackChange) != MSERR_OK) {
649         return -1;
650     }
651     return ret;
652 }
653 
DeselectTrack(int32_t index,bool & trackChange)654 int32_t PlayerMock::DeselectTrack(int32_t index, bool &trackChange)
655 {
656     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
657     std::unique_lock<std::mutex> lock(mutex_);
658     callback_->SetTrackDoneFlag(false);
659     int32_t ret = player_->DeselectTrack(index);
660     if (callback_->TrackSync(trackChange) != MSERR_OK) {
661         return -1;
662     }
663     return ret;
664 }
665 
GetCurrentTrack(int32_t trackType,int32_t & index)666 int32_t PlayerMock::GetCurrentTrack(int32_t trackType, int32_t &index)
667 {
668     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
669     std::unique_lock<std::mutex> lock(mutex_);
670     return player_->GetCurrentTrack(trackType, index);
671 }
672 
AddSubSource(const std::string & url)673 int32_t PlayerMock::AddSubSource(const std::string &url)
674 {
675     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
676     (void)player_->AddSubSource(url);
677     std::cout << "wait for track info callback" << std::endl;
678     return callback_->TrackInfoUpdateSync();
679 }
680 
AddSubSource(const std::string & path,int64_t offset,int64_t size)681 int32_t PlayerMock::AddSubSource(const std::string &path, int64_t offset, int64_t size)
682 {
683     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr && callback_ != nullptr, -1, "player or callback is nullptr");
684     std::string rawFile = path.substr(strlen("file://"));
685     int32_t fileDescriptor = open(rawFile.c_str(), O_RDONLY);
686     if (fileDescriptor <= 0) {
687         std::cout << "Open file failed." << std::endl;
688         return -1;
689     }
690 
691     struct stat64 st;
692     if (fstat64(fileDescriptor, &st) != 0) {
693         std::cout << "Get file state failed" << std::endl;
694         (void)close(fileDescriptor);
695         return -1;
696     }
697     int64_t stLen = static_cast<int64_t>(st.st_size);
698     if (size > 0) {
699         stLen = size;
700     }
701     int32_t ret = player_->AddSubSource(fileDescriptor, offset, stLen);
702     if (ret != 0) {
703         (void)close(fileDescriptor);
704         return -1;
705     }
706     (void)close(fileDescriptor);
707     std::cout << "wait for track info callback" << std::endl;
708     return callback_->TrackInfoUpdateSync();
709 }
710 
GetSubtitleText(std::string text)711 std::string PlayerMock::GetSubtitleText(std::string text)
712 {
713     return callback_->SubtitleTextUpdate(text);
714 }
715 
GetVideoSurfaceNext()716 sptr<Surface> PlayerMock::GetVideoSurfaceNext()
717 {
718     sptr<Rosen::WindowOption> option = new Rosen::WindowOption();
719     option->SetWindowRect({ 0, 0, nextSurfaceWidth_, nextSurfaceHeight_ });
720     option->SetWindowType(Rosen::WindowType::WINDOW_TYPE_FLOAT);
721     option->SetWindowMode(Rosen::WindowMode::WINDOW_MODE_FLOATING);
722     previewWindowNext_ = Rosen::Window::Create("xcomponent_window_next", option);
723     if (previewWindowNext_ == nullptr || previewWindowNext_->GetSurfaceNode() == nullptr) {
724         return nullptr;
725     }
726 
727     previewWindowNext_->Show();
728     auto surfaceNode = previewWindowNext_->GetSurfaceNode();
729     surfaceNode->SetFrameGravity(Rosen::Gravity::RESIZE);
730     Rosen::RSTransaction::FlushImplicitTransaction();
731     return surfaceNode->GetSurface();
732 }
733 
SetPlayRange(int64_t start,int64_t end)734 int32_t PlayerMock::SetPlayRange(int64_t start, int64_t end)
735 {
736     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
737     std::unique_lock<std::mutex> lock(mutex_);
738     return player_->SetPlayRange(start, end);
739 }
740 
SeekContinuous(int32_t mseconds)741 int32_t PlayerMock::SeekContinuous(int32_t mseconds)
742 {
743     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
744     std::unique_lock<std::mutex> lock(mutex_);
745     return player_->Seek(mseconds, PlayerSeekMode::SEEK_CONTINOUS);
746 }
747 
SetPlaybackStrategy(AVPlayStrategy strategy)748 int32_t PlayerMock::SetPlaybackStrategy(AVPlayStrategy strategy)
749 {
750     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
751     std::unique_lock<std::mutex> lock(mutex_);
752     return player_->SetPlaybackStrategy(strategy);
753 }
754 
SetMediaMuted(OHOS::Media::MediaType mediaType,bool isMuted)755 int32_t PlayerMock::SetMediaMuted(OHOS::Media::MediaType mediaType, bool isMuted)
756 {
757     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
758     std::unique_lock<std::mutex> lock(mutex_);
759     return player_->SetMediaMuted(mediaType, isMuted);
760 }
761 
SetDeviceChangeCbStatus(bool status)762 int32_t PlayerMock::SetDeviceChangeCbStatus(bool status)
763 {
764     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
765     return player_->SetDeviceChangeCbStatus(status);
766 }
767 
SetMaxAmplitudeCbStatus(bool status)768 int32_t PlayerMock::SetMaxAmplitudeCbStatus(bool status)
769 {
770     UNITTEST_CHECK_AND_RETURN_RET_LOG(player_ != nullptr, -1, "player_ == nullptr");
771     return player_->SetMaxAmplitudeCbStatus(status);
772 }
773 } // namespace Media
774 } // namespace OHOS
775