NotificationRenderer.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 ACSDKNOTIFICATIONS_NOTIFICATIONRENDERER_H_
#define ACSDKNOTIFICATIONS_NOTIFICATIONRENDERER_H_

#include <mutex>
#include <unordered_set>

#include <acsdkApplicationAudioPipelineFactoryInterfaces/ApplicationAudioPipelineFactoryInterface.h>
#include <acsdkManufactory/Annotated.h>
#include <acsdkNotificationsInterfaces/NotificationRendererInterface.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <AVSCommon/AVS/MixingBehavior.h>
#include <AVSCommon/SDKInterfaces/AudioFocusAnnotation.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerObserverInterface.h>
#include <AVSCommon/Utils/MediaType.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>

namespace alexaClientSDK {
namespace acsdkNotifications {

static const constexpr char* NOTIFICATIONS_MEDIA_PLAYER_NAME = "NotificationsMediaPlayer";

class NotificationRenderer
        : public acsdkNotificationsInterfaces::NotificationRendererInterface
        , public avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface
        , public avsCommon::utils::RequiresShutdown
        , public avsCommon::sdkInterfaces::ChannelObserverInterface
        , public std::enable_shared_from_this<NotificationRenderer> {
public:
    using SourceId = avsCommon::utils::mediaPlayer::MediaPlayerInterface::SourceId;

    static std::shared_ptr<NotificationRendererInterface> createNotificationRendererInterface(
        const std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>&
            audioPipelineFactory,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::AudioFocusAnnotation,
            avsCommon::sdkInterfaces::FocusManagerInterface> audioFocusManager,
        const std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface>& shutdownNotifier);

    static std::shared_ptr<NotificationRenderer> create(
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> mediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager);

    void addObserver(
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationRendererObserverInterface> observer) override;
    void removeObserver(
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationRendererObserverInterface> observer) override;
    bool renderNotification(
        std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()> audioFactory,
        const std::string& url) override;
    bool cancelNotificationRendering() 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 doShutdown() override;

    void onFocusChanged(alexaClientSDK::avsCommon::avs::FocusState newFocus, avsCommon::avs::MixingBehavior behavior)
        override;

private:
    enum class State {
        IDLE,
        RENDERING_PREFERRED,
        RENDERING_DEFAULT,
        CANCELLING,
        NOTIFYING
    };

    NotificationRenderer(
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> mediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager);

    void onRenderingFinished(SourceId sourceId);

    bool setState(State newState);

    bool setStateLocked(State newState);

    bool verifyRenderingLocked(const std::string& caller, SourceId sourceId);

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

    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> m_focusManager;

    avsCommon::avs::FocusState m_focusState;

    std::unordered_set<std::shared_ptr<acsdkNotificationsInterfaces::NotificationRendererObserverInterface>>
        m_observers;

    std::mutex m_mutex;

    std::condition_variable m_wakeTrigger;

    State m_state;

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

    SourceId m_sourceId;

    std::future<void> m_renderFallbackFuture;

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

    friend std::ostream& operator<<(std::ostream& stream, const NotificationRenderer::State state);
};

}  // namespace acsdkNotifications
}  // namespace alexaClientSDK

#endif  // ACSDKNOTIFICATIONS_NOTIFICATIONRENDERER_H_