DialogUXStateAggregator.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_AVS_INCLUDE_AVSCOMMON_AVS_DIALOGUXSTATEAGGREGATOR_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_AVS_INCLUDE_AVSCOMMON_AVS_DIALOGUXSTATEAGGREGATOR_H_

#include <atomic>
#include <chrono>
#include <unordered_set>
#include <vector>

#include <acsdkInteractionModelInterfaces/InteractionModelNotifierInterface.h>
#include <acsdkInteractionModelInterfaces/InteractionModelRequestProcessingObserverInterface.h>
#include <AVSCommon/SDKInterfaces/AudioInputProcessorObserverInterface.h>
#include <AVSCommon/SDKInterfaces/AVSConnectionManagerInterface.h>
#include <AVSCommon/SDKInterfaces/ConnectionStatusObserverInterface.h>
#include <AVSCommon/SDKInterfaces/DialogUXStateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/MessageObserverInterface.h>
#include <AVSCommon/SDKInterfaces/SpeechSynthesizerObserverInterface.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/Timing/Timer.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace avs {

class DialogUXStateAggregator
        : public sdkInterfaces::AudioInputProcessorObserverInterface
        , public sdkInterfaces::SpeechSynthesizerObserverInterface
        , public sdkInterfaces::ConnectionStatusObserverInterface
        , public acsdkInteractionModelInterfaces::InteractionModelRequestProcessingObserverInterface {
public:
    static constexpr std::chrono::milliseconds SHORT_TIMEOUT_FOR_THINKING_TO_IDLE = std::chrono::milliseconds{200};

    static constexpr std::chrono::seconds LONG_TIMEOUT_FOR_THINKING_TO_IDLE = std::chrono::seconds{8};

    static constexpr std::chrono::seconds LONG_TIMEOUT_FOR_LISTENING_TO_IDLE = std::chrono::seconds{8};

    static std::shared_ptr<DialogUXStateAggregator> createDialogUXStateAggregator(
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder,
        const std::shared_ptr<avsCommon::sdkInterfaces::AVSConnectionManagerInterface>& connectionManager,
        const std::shared_ptr<acsdkInteractionModelInterfaces::InteractionModelNotifierInterface>&
            interactionModelNotifier);

    DialogUXStateAggregator(
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr,
        std::chrono::milliseconds timeoutForThinkingToIdle = LONG_TIMEOUT_FOR_THINKING_TO_IDLE,
        std::chrono::milliseconds timeoutForListeningToIdle = LONG_TIMEOUT_FOR_LISTENING_TO_IDLE,
        std::chrono::milliseconds shortTimeoutForThinkingToIdle = SHORT_TIMEOUT_FOR_THINKING_TO_IDLE);

    void addObserver(std::shared_ptr<sdkInterfaces::DialogUXStateObserverInterface> observer);

    void removeObserver(std::shared_ptr<sdkInterfaces::DialogUXStateObserverInterface> observer);

    void onStateChanged(sdkInterfaces::AudioInputProcessorObserverInterface::State state) override;

    void onStateChanged(
        sdkInterfaces::SpeechSynthesizerObserverInterface::SpeechSynthesizerState state,
        const avsCommon::utils::mediaPlayer::MediaPlayerInterface::SourceId mediaSourceId,
        const avsCommon::utils::Optional<avsCommon::utils::mediaPlayer::MediaPlayerState>& mediaPlayerState,
        const std::vector<avsCommon::utils::audioAnalyzer::AudioAnalyzerState>& audioAnalyzerState) override;

    void onRequestProcessingStarted() override;
    void onRequestProcessingCompleted() override;

    void onConnectionStatusChanged(
        const avsCommon::sdkInterfaces::ConnectionStatusObserverInterface::Status status,
        const avsCommon::sdkInterfaces::ConnectionStatusObserverInterface::ChangedReason reason) override;

    void onConnectionStatusChanged(const Status status, const std::vector<EngineConnectionStatus>& engineStatuses)
        override;

private:
    void notifyObserversOfState();

    bool executeSetState(sdkInterfaces::DialogUXStateObserverInterface::DialogUXState newState);

    void executeTryEnterIdleState();

    void executeTryExitThinkingState();

    void transitionFromThinkingTimedOut();

    void transitionFromListeningTimedOut();

    void tryEnterIdleStateOnTimer();

    void onActivityStarted();


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

    std::unordered_set<std::shared_ptr<sdkInterfaces::DialogUXStateObserverInterface>> m_observers;

    sdkInterfaces::DialogUXStateObserverInterface::DialogUXState m_currentState;

    const std::chrono::milliseconds m_timeoutForThinkingToIdle;

    const std::chrono::milliseconds m_shortTimeoutForThinkingToIdle;

    avsCommon::utils::timing::Timer m_thinkingTimeoutTimer;

    avsCommon::utils::timing::Timer m_multiturnSpeakingToListeningTimer;

    const std::chrono::milliseconds m_timeoutForListeningToIdle;

    avsCommon::utils::timing::Timer m_listeningTimeoutTimer;


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

    std::atomic<alexaClientSDK::avsCommon::sdkInterfaces::SpeechSynthesizerObserverInterface::SpeechSynthesizerState>
        m_speechSynthesizerState;

    std::atomic<alexaClientSDK::avsCommon::sdkInterfaces::AudioInputProcessorObserverInterface::State>
        m_audioInputProcessorState;
};

}  // namespace avs
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_AVS_INCLUDE_AVSCOMMON_AVS_DIALOGUXSTATEAGGREGATOR_H_