MockMediaPlayer.h

Go to the documentation of this file.

/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

#ifndef ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_TEST_AVSCOMMON_UTILS_MEDIAPLAYER_MOCKMEDIAPLAYER_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_TEST_AVSCOMMON_UTILS_MEDIAPLAYER_MOCKMEDIAPLAYER_H_

#include <unordered_set>

#include <gmock/gmock.h>

#include "AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h"
#include "AVSCommon/Utils/MediaPlayer/MediaPlayerObserverInterface.h"
#include "AVSCommon/Utils/MediaPlayer/SourceConfig.h"
#include "AVSCommon/Utils/RequiresShutdown.h"
#include "AVSCommon/Utils/Timing/Stopwatch.h"

namespace alexaClientSDK {
namespace avsCommon {
namespace utils {
namespace mediaPlayer {
namespace test {

static const std::chrono::milliseconds DEFAULT_TIME(50);

class MockMediaPlayerHelper : public MediaPlayerInterface {
public:
    virtual SourceId attachmentSetSource(
        std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> attachmentReader,
        const avsCommon::utils::AudioFormat* audioFormat) = 0;
    virtual SourceId streamSetSource(std::shared_ptr<std::istream> stream, bool repeat) = 0;
    virtual SourceId urlSetSource(const std::string& url) = 0;
};

class MockMediaPlayer
        : public MockMediaPlayerHelper
        , public RequiresShutdown {
public:
    using observer = avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface;
    using MediaPlayerState = avsCommon::utils::mediaPlayer::MediaPlayerState;

    static std::shared_ptr<testing::NiceMock<MockMediaPlayer>> create();

    static void enableConcurrentMediaPlayers();

    MockMediaPlayer();

    // 'override' commented out below to avoid needless warnings generated because MOCK_METHOD* does not use it.

    SourceId setSource(
        std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> attachmentReader,
        const avsCommon::utils::AudioFormat* audioFormat = nullptr,
        const SourceConfig& config = emptySourceConfig()) /*override*/;
    SourceId setSource(
        std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> attachmentReader,
        std::chrono::milliseconds offsetAdjustment,
        const avsCommon::utils::AudioFormat* audioFormat = nullptr,
        const SourceConfig& config = emptySourceConfig()) /*override*/;
    SourceId setSource(
        const std::string& url,
        std::chrono::milliseconds offset = std::chrono::milliseconds::zero(),
        const SourceConfig& config = emptySourceConfig(),
        bool repeat = false,
        const PlaybackContext& playbackContext = PlaybackContext()) /* override */;
    SourceId setSource(
        std::shared_ptr<std::istream> stream,
        bool repeat = false,
        const SourceConfig& config = emptySourceConfig(),
        avsCommon::utils::MediaType format = avsCommon::utils::MediaType::UNKNOWN) /*override*/;
    void addObserver(std::shared_ptr<observer> playerObserver) /*override*/;
    void removeObserver(std::shared_ptr<observer> playerObserver) /*override*/;

    MOCK_METHOD1(play, bool(SourceId));
    MOCK_METHOD1(pause, bool(SourceId));
    MOCK_METHOD1(resume, bool(SourceId));
    MOCK_METHOD3(seekTo, bool(SourceId, std::chrono::milliseconds location, bool fromStart));
    MOCK_METHOD1(stop, bool(SourceId));
    MOCK_METHOD2(stop, bool(SourceId, std::chrono::seconds));
    MOCK_METHOD1(getOffset, std::chrono::milliseconds(SourceId));
    MOCK_METHOD0(getNumBytesBuffered, uint64_t());
    MOCK_METHOD1(
        getMediaPlayerState,
        avsCommon::utils::Optional<avsCommon::utils::mediaPlayer::MediaPlayerState>(SourceId));
    MOCK_METHOD0(getPlaybackAttributes, avsCommon::utils::Optional<PlaybackAttributes>());
    MOCK_METHOD0(getPlaybackReports, std::vector<PlaybackReport>());
    MOCK_METHOD0(getFingerprint, Optional<Fingerprint>());

    void doShutdown() /*override*/;

    MOCK_METHOD2(
        attachmentSetSource,
        SourceId(
            std::shared_ptr<avsCommon::avs::attachment::AttachmentReader> attachmentReader,
            const avsCommon::utils::AudioFormat* audioFormat));
    MOCK_METHOD2(streamSetSource, SourceId(std::shared_ptr<std::istream> stream, bool repeat));
    MOCK_METHOD1(urlSetSource, SourceId(const std::string& url));

    SourceId mockSetSource();

    bool mockPlay(SourceId sourceId);

    bool mockPause(SourceId sourceId);

    bool mockResume(SourceId sourceId);

    bool mockStop(SourceId sourceId);
    bool mockStop2(SourceId sourceId, std::chrono::seconds closePipleineTime);

    bool mockFinished(SourceId sourceId);

    bool mockError(SourceId sourceId);

    bool mockSetOffset(SourceId sourceId, std::chrono::milliseconds offset);

    std::chrono::milliseconds mockGetOffset(SourceId id);

    avsCommon::utils::Optional<avsCommon::utils::mediaPlayer::MediaPlayerState> mockGetState(SourceId id);

    bool mockSeek(SourceId sourceId, std::chrono::milliseconds location, bool fromStart);

    void resetWaitTimer();

    bool waitUntilNextSetSource(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    bool waitUntilPlaybackStarted(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));
    bool waitUntilPlaybackStarted(
        SourceId id,
        const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    bool waitUntilPlaybackPaused(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    bool waitUntilPlaybackResumed(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    bool waitUntilPlaybackStopped(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    bool waitUntilPlaybackFinished(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    bool waitUntilPlaybackError(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    bool waitUntilSeeked(const std::chrono::milliseconds timeout = std::chrono::milliseconds(DEFAULT_TIME));

    SourceId getCurrentSourceId();

    SourceId getSourceId();

    SourceId getLatestSourceId();

    std::unordered_set<std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface>> getObservers()
        const;

private:
    struct Source;

    class SourceState {
    public:
        SourceState(
            Source* source,
            const std::string& name,
            std::function<void(std::shared_ptr<observer>, SourceId, const MediaPlayerState&)> notifyFunction);

        ~SourceState();

        void trigger(const MediaPlayerState = MediaPlayerState(DEFAULT_TIME));

        bool wait(std::chrono::milliseconds timeout);

        void resetStateReached();

    private:
        void notify(
            const std::unordered_set<std::shared_ptr<MediaPlayerObserverInterface>>& observer,
            std::chrono::milliseconds timeout,
            const MediaPlayerState state);

        Source* m_source;

        std::string m_name;

        std::function<void(std::shared_ptr<observer>, SourceId, const MediaPlayerState&)> m_notifyFunction;

        std::mutex m_mutex;

        bool m_stateReached;

        std::condition_variable m_wake;

        std::thread m_thread;

        bool m_shutdown;
    };

    struct Source {
    public:
        Source(MockMediaPlayer* player, SourceId id);

        MockMediaPlayer* mockMediaPlayer;

        SourceId sourceId;

        std::chrono::milliseconds offset;

        SourceState started;

        SourceState paused;

        SourceState resumed;

        SourceState stopped;

        SourceState finished;

        SourceState seekComplete;

        SourceState error;

        avsCommon::utils::timing::Stopwatch stopwatch;
    };

    std::shared_ptr<Source> getCurrentSource(SourceId sourceId);

    std::shared_ptr<Source> getPreviousSource(SourceId sourceId);

    bool isValidSourceId(SourceId sourceId);

    mutable std::mutex m_mutex;

    static std::mutex m_globalMutex;

    static std::vector<std::shared_ptr<Source>> m_sources;

    static std::atomic<SourceId> m_currentSourceId;

    static SourceId m_previousSourceId;

    static bool m_isConcurrentEnabled;

    std::unordered_set<std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface>> m_playerObservers;
};

}  // namespace test
}  // namespace mediaPlayer
}  // namespace utils
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_UTILS_TEST_AVSCOMMON_UTILS_MEDIAPLAYER_MOCKMEDIAPLAYER_H_