Renderer.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 ACSDKALERTS_RENDERER_RENDERER_H_
#define ACSDKALERTS_RENDERER_RENDERER_H_

#include "acsdkAlerts/Renderer/RendererInterface.h"
#include "acsdkAlerts/Renderer/RendererObserverInterface.h"

#include <acsdkApplicationAudioPipelineFactoryInterfaces/ApplicationAudioPipelineFactoryInterface.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <AVSCommon/SDKInterfaces/InternetConnectionMonitorInterface.h>
#include <AVSCommon/SDKInterfaces/InternetConnectionObserverInterface.h>
#include <AVSCommon/SDKInterfaces/SpeakerManagerInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerObserverInterface.h>
#include <AVSCommon/Utils/MediaPlayer/SourceConfig.h>
#include <AVSCommon/Utils/MediaType.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>

#include <chrono>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <string>
#include <vector>

namespace alexaClientSDK {
namespace acsdkAlerts {

static const constexpr char* ALERTS_MEDIA_PLAYER_NAME = "AlertsMediaPlayer";

namespace renderer {

class Renderer
        : public RendererInterface
        , public avsCommon::sdkInterfaces::InternetConnectionObserverInterface
        , public avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface
        , public avsCommon::utils::RequiresShutdown
        , public std::enable_shared_from_this<Renderer> {
public:
    static std::shared_ptr<Renderer> createAlertRenderer(
        const std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>&
            audioPipelineFactory,
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder,
        const std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface>& shutdownNotifier,
        const std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionMonitorInterface>& internetConnectionMonitor);

    static std::shared_ptr<Renderer> create(
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> mediaPlayer,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr,
        std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionMonitorInterface> internetConnectionMonitor =
            nullptr);

    void start(
        std::shared_ptr<RendererObserverInterface> observer,
        std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()> audioFactory,
        bool volumeRampEnabled,
        const std::vector<std::string>& urls = std::vector<std::string>(),
        int loopCount = 0,
        std::chrono::milliseconds loopPause = std::chrono::milliseconds{0},
        bool startWithPause = false) override;

    void stop() override;

    void onFirstByteRead(SourceId sourceId, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;

    void onPlaybackStarted(SourceId sourceId, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;

    void onPlaybackStopped(SourceId sourceId, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;

    void onPlaybackFinished(SourceId sourceId, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;

    void onPlaybackError(
        SourceId sourceId,
        const avsCommon::utils::mediaPlayer::ErrorType& type,
        std::string error,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;

    void onConnectionStatusChanged(bool connected) override;

private:
    using SourceId = avsCommon::utils::mediaPlayer::MediaPlayerInterface::SourceId;

    Renderer(
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> mediaPlayer,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder,
        std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionMonitorInterface> internetConnectionMonitor);


    void executeStart(
        std::shared_ptr<RendererObserverInterface> observer,
        std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()> audioFactory,
        bool volumeRampEnabled,
        const std::vector<std::string>& urls,
        int loopCount,
        std::chrono::milliseconds loopPause,
        bool startWithPause);

    void executeStop();

    void executeOnPlaybackStarted(SourceId sourceId);

    void executeOnPlaybackStopped(SourceId sourceId);

    void executeOnPlaybackFinished(SourceId sourceId);

    void executeOnPlaybackError(
        SourceId sourceId,
        const avsCommon::utils::mediaPlayer::ErrorType& type,
        const std::string& error);

    void notifyObserver(RendererObserverInterface::State state, const std::string& message = "");

    void resetSourceId();

    bool shouldPlayDefault();

    bool shouldMediaPlayerRepeat();

    bool shouldRenderNext();

    bool shouldPause();

    bool isLastSourceInLoop();

    bool isLastSource();

    bool pause(std::chrono::milliseconds duration);

    void play();

    avsCommon::utils::mediaPlayer::SourceConfig generateMediaConfiguration();

    bool renderNextAudioAsset(bool* pauseInterruptedOut = nullptr);

    void handlePlaybackError(const std::string& error);


    void doShutdown() override;


    std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> m_mediaPlayer;

    std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> m_metricRecorder;

    std::shared_ptr<RendererObserverInterface> m_observer;

    std::vector<std::string> m_urls;

    int m_numberOfStreamsRenderedThisLoop;

    int m_remainingLoopCount;

    int m_directiveLoopCount;

    std::chrono::milliseconds m_loopPause;

    bool m_shouldPauseBeforeRender;

    std::chrono::time_point<std::chrono::steady_clock> m_loopStartTime;

    std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()> m_defaultAudioFactory;

    bool m_isStopping;

    bool m_isStartPending;

    std::condition_variable m_waitCondition;

    std::mutex m_waitMutex;

    SourceId m_currentSourceId;

    bool m_volumeRampEnabled;


    avsCommon::utils::threading::Executor m_executor;

    std::chrono::steady_clock::time_point m_renderStartTime;

    std::atomic_bool m_isNetworkConnected;

    std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionMonitorInterface> m_internetConnectionMonitor;
};

}  // namespace renderer
}  // namespace acsdkAlerts
}  // namespace alexaClientSDK

#endif  // ACSDKALERTS_RENDERER_RENDERER_H_