AudioPlayer.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_ACSDKAUDIOPLAYER_INCLUDE_ACSDKAUDIOPLAYER_AUDIOPLAYER_H_
#define ALEXA_CLIENT_SDK_ACSDKAUDIOPLAYER_INCLUDE_ACSDKAUDIOPLAYER_AUDIOPLAYER_H_

#include <deque>
#include <list>
#include <memory>

#include <acsdkAudioPlayerInterfaces/AudioPlayerInterface.h>
#include <acsdk/CryptoInterfaces/CryptoFactoryInterface.h>
#include <acsdkManufactory/Annotated.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <AVSCommon/AVS/CapabilityAgent.h>
#include <AVSCommon/AVS/CapabilityConfiguration.h>
#include <AVSCommon/AVS/PlayBehavior.h>
#include <AVSCommon/AVS/PlayerActivity.h>
#include <AVSCommon/AVS/PlayRequestor.h>
#include <AVSCommon/SDKInterfaces/Audio/MixingBehavior.h>
#include <AVSCommon/SDKInterfaces/AudioFocusAnnotation.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/ChannelVolumeInterface.h>
#include <AVSCommon/SDKInterfaces/ContextManagerInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/SDKInterfaces/LocalPlaybackHandlerInterface.h>
#include <AVSCommon/SDKInterfaces/MessageSenderInterface.h>
#include <AVSCommon/SDKInterfaces/PlaybackRouterInterface.h>
#include <AVSCommon/SDKInterfaces/RenderPlayerInfoCardsProviderInterface.h>
#include <AVSCommon/SDKInterfaces/RenderPlayerInfoCardsProviderRegistrarInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/DefaultEndpointAnnotation.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointCapabilitiesRegistrarInterface.h>
#include <AVSCommon/Utils/MediaPlayer/ErrorTypes.h>
#include <AVSCommon/Utils/MediaPlayer/PooledMediaResourceProviderInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerFactoryObserverInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerObserverInterface.h>
#include <AVSCommon/Utils/Metrics/DataPointDurationBuilder.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/Timing/Timer.h>
#include <AVSCommon/Utils/Timing/TimeUtils.h>
#include <Captions/CaptionManagerInterface.h>

#include "AudioItem.h"
#include "ClearBehavior.h"
#include "ProgressTimer.h"

namespace alexaClientSDK {
namespace acsdkAudioPlayer {

enum class AudioPlayerState {
    IDLE,
    BUFFERING,
    BUFFER_UNDERRUN,
    PLAYING,
    STOPPED,
    PAUSED,
    FINISHED
};

/*
 * Convert a @c AudioPlayerState to @c std::string.
 *
 * @param state The @c AudioPlayerState to convert.
 * @return The string representation of @c AudioPlayerState.
 */
inline std::string playerStateToString(AudioPlayerState state) {
    switch (state) {
        case AudioPlayerState::IDLE:
            return "IDLE";
        case AudioPlayerState::PLAYING:
            return "PLAYING";
        case AudioPlayerState::STOPPED:
            return "STOPPED";
        case AudioPlayerState::PAUSED:
            return "PAUSED";
        case AudioPlayerState::BUFFERING:
            return "BUFFERING";
        case AudioPlayerState::BUFFER_UNDERRUN:
            return "BUFFER_UNDERRUN";
        case AudioPlayerState::FINISHED:
            return "FINISHED";
    }
    return "unknown AudioPlayerState";
}

class AudioPlayer
        : public avsCommon::avs::CapabilityAgent
        , public ProgressTimer::ContextInterface
        , public acsdkAudioPlayerInterfaces::AudioPlayerInterface
        , public avsCommon::sdkInterfaces::MediaPropertiesInterface
        , public avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderInterface
        , public avsCommon::sdkInterfaces::CapabilityConfigurationInterface
        , public avsCommon::sdkInterfaces::LocalPlaybackHandlerInterface
        , public avsCommon::utils::mediaPlayer::MediaPlayerObserverInterface
        , public avsCommon::utils::mediaPlayer::MediaPlayerFactoryObserverInterface
        , public avsCommon::utils::RequiresShutdown
        , public std::enable_shared_from_this<AudioPlayer> {
public:
    virtual ~AudioPlayer();

    static std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerInterface> createAudioPlayerInterface(
        const std::shared_ptr<avsCommon::utils::mediaPlayer::PooledMediaResourceProviderInterface>&
            mediaResourceProvider,
        const std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface>& messageSender,
        const acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::AudioFocusAnnotation,
            avsCommon::sdkInterfaces::FocusManagerInterface>& annotatedFocusManager,
        const std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface>& contextManager,
        const std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface>& exceptionSender,
        const std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface>& playbackRouter,
        const std::shared_ptr<captions::CaptionManagerInterface>& captionManager,
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder,
        const std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface>& shutdownNotifier,
        const acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointCapabilitiesRegistrarInterface>& endpointCapabilitiesRegistrar,
        const std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderRegistrarInterface>&
            renderPlayerInfoCardsProviderRegistrar,
        const std::shared_ptr<cryptoInterfaces::CryptoFactoryInterface>& cryptoFactory);

    static std::shared_ptr<AudioPlayer> create(
        std::shared_ptr<avsCommon::utils::mediaPlayer::PooledMediaResourceProviderInterface> mediaResourceProvider,
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender,
        std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> playbackRouter,
        std::shared_ptr<cryptoInterfaces::CryptoFactoryInterface> cryptoFactory,
        std::shared_ptr<captions::CaptionManagerInterface> captionManager = nullptr,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr);

    void provideState(const avsCommon::avs::NamespaceAndName& stateProviderName, unsigned int stateRequestToken)
        override;

    void handleDirectiveImmediately(std::shared_ptr<avsCommon::avs::AVSDirective> directive) override;
    void preHandleDirective(std::shared_ptr<DirectiveInfo> info) override;
    void handleDirective(std::shared_ptr<DirectiveInfo> info) override;
    void cancelDirective(std::shared_ptr<DirectiveInfo> info) override;
    void onDeregistered() override;
    avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;

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

    void onFirstByteRead(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackStarted(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackStopped(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackFinished(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackError(
        SourceId id,
        const avsCommon::utils::mediaPlayer::ErrorType& type,
        std::string error,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackPaused(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onPlaybackResumed(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onBufferUnderrun(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onBufferRefilled(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onBufferingComplete(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;
    void onSeeked(
        SourceId id,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& startState,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& endState) override;
    void onTags(
        SourceId id,
        std::unique_ptr<const VectorOfTags> vectorOfTags,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state) override;

    void onReadyToProvideNextPlayer() override;

    void onProgressReportDelayElapsed() override;
    void onProgressReportIntervalElapsed() override;
    void onProgressReportIntervalUpdated() override;
    void requestProgress() override;

    void addObserver(std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface> observer) override;
    void removeObserver(std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface> observer) override;
    void stopPlayback() override;

    void setObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsObserverInterface> observer) override;

    bool localOperation(PlaybackOperation op) override;
    bool localSeekTo(std::chrono::milliseconds location, bool fromStart) override;

    std::chrono::milliseconds getAudioItemOffset() override;
    std::chrono::milliseconds getAudioItemDuration() override;

    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> getCapabilityConfigurations() override;

    void doShutdown() override;

private:
    class MessageRequestObserver : public avsCommon::avs::MessageRequest {
    public:
        MessageRequestObserver(
            std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder,
            const std::string& jsonContent,
            const std::string& uriPathExtension = "");

        void sendCompleted(
            avsCommon::sdkInterfaces::MessageRequestObserverInterface::Status sendMessageStatus) override;
    private:
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> mMetricRecorder;
    };
    struct PlayDirectiveInfo {
        const std::string messageId;

        const std::string dialogRequestId;

        std::string stopMessageId;

        avsCommon::avs::PlayRequestor playRequestor;

        AudioItem audioItem;

        avsCommon::avs::PlayBehavior playBehavior;

        avsCommon::sdkInterfaces::audio::MixingBehavior mixingBehavior;

        SourceId sourceId;

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

        std::chrono::milliseconds initialOffset;

        std::string errorMsg;

        avsCommon::utils::mediaPlayer::ErrorType errorType;

        bool isBuffered;

        bool isPNFSent;

        bool normalizationEnabled;

        avsCommon::utils::metrics::DataPointDurationBuilder queueTimeMetricData;

        std::shared_ptr<const VectorOfTags> cachedMetadata;

        std::vector<avsCommon::utils::audioAnalyzer::AudioAnalyzerState> analyzersData;

        PlayDirectiveInfo(const std::string& messageId, const std::string& dialogRequestId);
    };

    AudioPlayer(
        std::shared_ptr<avsCommon::utils::mediaPlayer::PooledMediaResourceProviderInterface> mediaResourceProvider,
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionSender,
        std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> playbackRouter,
        std::vector<std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface>> audioChannelVolumeInterfaces,
        std::shared_ptr<cryptoInterfaces::CryptoFactoryInterface> cryptoFactory,
        std::shared_ptr<captions::CaptionManagerInterface> captionManager = nullptr,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr);

    bool parseDirectivePayload(std::shared_ptr<DirectiveInfo> info, rapidjson::Document* document);

    void preHandlePlayDirective(std::shared_ptr<DirectiveInfo> info);

    void handlePlayDirective(std::shared_ptr<DirectiveInfo> info);

    void handleStopDirective(std::shared_ptr<DirectiveInfo> info);

    void handleClearQueueDirective(std::shared_ptr<DirectiveInfo> info);

    void handleUpdateProgressReportIntervalDirective(std::shared_ptr<DirectiveInfo> info);

    void removeDirective(std::shared_ptr<DirectiveInfo> info);

    void setHandlingCompleted(std::shared_ptr<DirectiveInfo> info);


    void executeProvideState(bool sendToken = false, unsigned int stateRequestToken = 0);

    void executeOnFocusChanged(avsCommon::avs::FocusState newFocus, avsCommon::avs::MixingBehavior behavior);

    void executeOnPlaybackStarted(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnPlaybackStopped(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnPlaybackFinished(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnBufferingComplete(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnSeeked(
        SourceId id,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& startState,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& endState);

    void handlePlaybackCompleted();

    void callProgressTimer(std::function<void()> call);

    void setIsInProgress(bool isInProgress);

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

    void executeOnPlaybackPaused(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnPlaybackResumed(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnBufferUnderrun(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnBufferRefilled(SourceId id, const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnTags(
        SourceId id,
        std::shared_ptr<const VectorOfTags> vectorOfTags,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void executeOnReadyToProvideNextPlayer();

    void executePrePlay(std::shared_ptr<PlayDirectiveInfo> info);

    void executePlay(const std::string& messageId);

    void playNextItem();

    void executeStop(const std::string& messageId = "", bool startNextSong = false);

    void executeClearQueue(ClearBehavior clearBehavior);

    void executeUpdateProgressReportInterval(std::chrono::milliseconds progressReportInterval);

    void executeLocalOperation(PlaybackOperation op, std::promise<bool> success);

    void executeLocalOperationTimedout();

    bool executeLocalSeekTo(std::chrono::milliseconds location, bool fromStart);

    std::chrono::milliseconds getDuration();

    void changeState(AudioPlayerState state);

    void sendEventWithTokenAndOffset(
        const std::string& eventName,
        bool includePlaybackReports = false,
        std::chrono::milliseconds offset = avsCommon::utils::mediaPlayer::MEDIA_PLAYER_INVALID_OFFSET);

    void sendPlaybackStartedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackNearlyFinishedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackStutterStartedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackStutterFinishedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackFinishedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackSeekedEvent(
        const avsCommon::utils::mediaPlayer::MediaPlayerState& startState,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& endState);

    void sendPlaybackFailedEvent(
        const std::string& failingToken,
        avsCommon::utils::mediaPlayer::ErrorType errorType,
        const std::string& message,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackStoppedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackPausedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackResumedEvent(const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void sendPlaybackQueueClearedEvent();

    void sendEvent(
        const std::string& eventName,
        const std::string& dialogRequestIdString = "",
        const std::string& payload = "{}",
        const std::string& context = "");

    void sendStreamMetadataExtractedEvent(
        AudioItem& audioItem,
        std::shared_ptr<const VectorOfTags> vectorOfTags,
        const avsCommon::utils::mediaPlayer::MediaPlayerState& state);

    void notifyObserver();

    void notifySeekActivity(
        const acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface::SeekStatus& seekStatus,
        std::chrono::milliseconds offset);

    acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface::Context getObserverContext(
        std::chrono::milliseconds offset = std::chrono::milliseconds(-1));

    std::chrono::milliseconds getOffset();

    void attachPlaybackAttributesIfAvailable(rapidjson::Value& parent, rapidjson::Document::AllocatorType& allocator);

    void attachPlaybackReportsIfAvailable(rapidjson::Value& parent, rapidjson::Document::AllocatorType& allocator);

    avsCommon::utils::mediaPlayer::MediaPlayerState getMediaPlayerState();

    void clearPlayQueue(const bool stopCurrentPlayer);

    void stopAndReleaseMediaPlayer(std::shared_ptr<PlayDirectiveInfo> playbackItem);

    void releaseMediaPlayer(std::shared_ptr<PlayDirectiveInfo> playbackItem);

    bool configureMediaPlayer(std::shared_ptr<PlayDirectiveInfo>& playbackItem);

    bool isMessageInQueue(const std::string& messageId);

    bool executeStopDucking();

    bool executeStartDucking();

    void parseHeadersFromPlayDirective(const rapidjson::Value& httpHeaders, AudioItem* audioItem);

    std::string getTrackProtectionName(
        const avsCommon::utils::mediaPlayer::MediaPlayerState::MediaPlayerProtection& mediaPlayerProtection) const;

    std::string getTrackProtectionName(const avsCommon::utils::mediaPlayer::MediaPlayerState& mediaPlayerState) const;

    std::string getPlaylistType(const avsCommon::utils::mediaPlayer::MediaPlayerState& mediaPlayerState) const;

    std::string getPlaylistType(const std::string& playlistType) const;

    std::string packageContextForEvent(
        std::chrono::milliseconds offsetOverride = avsCommon::utils::mediaPlayer::MEDIA_PLAYER_INVALID_OFFSET) const;

    avsCommon::avs::PlayerActivity activityFromState(AudioPlayerState state) const;

    std::string getDomainNameHash(const std::string& url) const;

    bool isPlaybackActive() const;

    avsCommon::utils::timing::TimeUtils m_timeUtils;

    std::shared_ptr<avsCommon::utils::mediaPlayer::PooledMediaResourceProviderInterface> m_mediaResourceProvider;

    std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> m_messageSender;

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

    std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> m_contextManager;

    std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> m_playbackRouter;

    std::shared_ptr<cryptoInterfaces::CryptoFactoryInterface> m_cryptoFactory;

    std::shared_ptr<captions::CaptionManagerInterface> m_captionManager;

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

    AudioPlayerState m_currentState;

    mutable std::mutex m_currentStateMutex;

    std::condition_variable m_currentStateConditionVariable;


    avsCommon::avs::FocusState m_focus;

    /*
     * The queue of @c PlayDirectiveInfo to play.  The @c PlayBehavior is already resolved when items are
     * added to the queue.  This queue is used to find the next @c AudioItem to play when @c playNextItem() is called.
     */
    std::deque<std::shared_ptr<PlayDirectiveInfo>> m_audioPlayQueue;

    std::shared_ptr<PlayDirectiveInfo> m_currentlyPlaying;

    std::shared_ptr<PlayDirectiveInfo> m_itemPendingPlaybackStart;

    std::chrono::steady_clock::time_point m_bufferUnderrunTimestamp;

    ProgressTimer m_progressTimer;

    std::chrono::milliseconds m_offset;

    std::unordered_set<std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface>> m_observers;

    std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsObserverInterface> m_renderPlayerObserver;

    bool m_playNextItemAfterStopped;

    bool m_isStopCalled;

    bool m_okToRequestNextTrack;

    avsCommon::utils::mediaPlayer::MediaPlayerState::MediaPlayerProtection m_currentMediaPlayerProtection;

    std::string m_currentPlaylistType;

    bool m_isAcquireChannelRequestPending;


    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> m_capabilityConfigurations;

    avsCommon::avs::ContentType m_currentMixability;

    avsCommon::avs::MixingBehavior m_mixingBehavior;

    avsCommon::utils::metrics::DataPointDurationBuilder m_playbackTimeMetricData;

    avsCommon::utils::metrics::DataPointDurationBuilder m_autoProgressTimeMetricData;

    avsCommon::utils::metrics::DataPointDurationBuilder m_playCommandToPlayingTimeMetricData;

    bool m_isRecordingTimeToPlayback;

    bool m_isAutoProgressing;

    bool m_isLocalResumePending;

    std::promise<bool> m_localResumeSuccess;

    bool m_isStartingPlayback;

    bool m_isPausingPlayback;

    std::vector<std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface>> m_audioChannelVolumeInterfaces;

    std::string m_cachedContext;

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

    std::string m_lastDialogRequestId;
};

}  // namespace acsdkAudioPlayer
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ACSDKAUDIOPLAYER_INCLUDE_ACSDKAUDIOPLAYER_AUDIOPLAYER_H_