DefaultClient.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_APPLICATIONUTILITIES_DEFAULTCLIENT_INCLUDE_DEFAULTCLIENT_DEFAULTCLIENT_H_
#define ALEXA_CLIENT_SDK_APPLICATIONUTILITIES_DEFAULTCLIENT_INCLUDE_DEFAULTCLIENT_DEFAULTCLIENT_H_
 
#include <ACL/Transport/MessageRouter.h>
#include <ACL/Transport/MessageRouterFactory.h>
#include <acsdkManufactory/Manufactory.h>
#include <ADSL/DirectiveSequencer.h>
#include <AFML/AudioActivityTracker.h>
#include <AFML/FocusManager.h>
#include <AFML/VisualActivityTracker.h>
#include <AIP/AudioInputProcessor.h>
#include <AIP/AudioProvider.h>
#include <acsdkAlerts/AlertsCapabilityAgent.h>
#include <acsdkAlerts/Renderer/Renderer.h>
#include <acsdkAlerts/Storage/AlertStorageInterface.h>
#include <acsdkApplicationAudioPipelineFactoryInterfaces/ApplicationAudioPipelineFactoryInterface.h>
#include <Alexa/AlexaInterfaceCapabilityAgent.h>
#include <Alexa/AlexaInterfaceMessageSender.h>
#include <ApiGateway/ApiGatewayCapabilityAgent.h>
#include <acsdkAudioPlayer/AudioPlayer.h>
#include <acsdkAudioPlayerInterfaces/AudioPlayerObserverInterface.h>
#include <AVSCommon/AVS/Attachment/AttachmentManagerInterface.h>
#include <AVSCommon/AVS/AVSDiscoveryEndpointAttributes.h>
#include <AVSCommon/AVS/DialogUXStateAggregator.h>
#include <AVSCommon/AVS/ExceptionEncounteredSender.h>
#include <AVSCommon/SDKInterfaces/AVSConnectionManagerInterface.h>
#include <AVSCommon/SDKInterfaces/AVSGatewayManagerInterface.h>
#include <AVSCommon/SDKInterfaces/Audio/AudioFactoryInterface.h>
#include <AVSCommon/SDKInterfaces/AuthDelegateInterface.h>
#include <AVSCommon/SDKInterfaces/Bluetooth/BluetoothDeviceConnectionRuleInterface.h>
#include <AVSCommon/SDKInterfaces/CallManagerInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesDelegateInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesObserverInterface.h>
#include <AVSCommon/SDKInterfaces/ConnectionStatusObserverInterface.h>
#include <AVSCommon/SDKInterfaces/Diagnostics/DiagnosticsInterface.h>
#include <AVSCommon/SDKInterfaces/DialogUXStateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/DefaultEndpointAnnotation.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointBuilderInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointIdentifier.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointInterface.h>
#include <AVSCommon/SDKInterfaces/ExpectSpeechTimeoutHandlerInterface.h>
#include <AVSCommon/SDKInterfaces/InternetConnectionMonitorInterface.h>
#include <AVSCommon/SDKInterfaces/LocaleAssetsManagerInterface.h>
#include <AVSCommon/SDKInterfaces/PowerResourceManagerInterface.h>
#include <AVSCommon/SDKInterfaces/SingleSettingObserverInterface.h>
#include <AVSCommon/SDKInterfaces/SpeechInteractionHandlerInterface.h>
#include <AVSCommon/SDKInterfaces/Storage/MiscStorageInterface.h>
#include <AVSCommon/SDKInterfaces/SystemTimeZoneInterface.h>
#include <AVSCommon/SDKInterfaces/TemplateRuntimeObserverInterface.h>
#include <AVSCommon/Utils/DeviceInfo.h>
#include <AVSCommon/Utils/LibcurlUtils/HTTPContentFetcherFactory.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerFactoryInterface.h>
#include <AVSCommon/Utils/MediaPlayer/MediaPlayerInterface.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/Timing/SystemClockMonitor.h>
#include <acsdkBluetooth/Bluetooth.h>
#include <acsdkBluetooth/BluetoothStorageInterface.h>
#include <acsdkNotifications/NotificationRenderer.h>
#include <acsdkNotifications/NotificationsCapabilityAgent.h>
#include <Captions/CaptionManagerInterface.h>
#include <Captions/CaptionPresenterInterface.h>
#include <CertifiedSender/CertifiedSender.h>
#include <CertifiedSender/SQLiteMessageStorage.h>
#include <acsdkDoNotDisturb/DoNotDisturbCapabilityAgent.h>
#include <Endpoints/EndpointRegistrationManager.h>
#include <acsdkEqualizer/EqualizerCapabilityAgent.h>
#include <acsdkEqualizerImplementations/EqualizerController.h>
#include <acsdkEqualizerInterfaces/EqualizerConfigurationInterface.h>
#include <acsdkEqualizerInterfaces/EqualizerModeControllerInterface.h>
#include <acsdkEqualizerInterfaces/EqualizerRuntimeSetupInterface.h>
#include <acsdkEqualizerInterfaces/EqualizerStorageInterface.h>
#include <acsdkExternalMediaPlayer/ExternalMediaPlayer.h>
#include <acsdkExternalMediaPlayerInterfaces/ExternalMediaAdapterHandlerInterface.h>
#include <acsdkShutdownManagerInterfaces/ShutdownManagerInterface.h>
#include <acsdkExternalMediaPlayerInterfaces/ExternalMediaPlayerInterface.h>
#include <acsdkStartupManagerInterfaces/StartupManagerInterface.h>
#include <InteractionModel/InteractionModelCapabilityAgent.h>
 
#ifdef ENABLE_PCC
#include <AVSCommon/SDKInterfaces/Phone/PhoneCallerInterface.h>
#include <PhoneCallController/PhoneCallController.h>
#endif
 
#ifdef ENABLE_MCC
#include <AVSCommon/SDKInterfaces/Calendar/CalendarClientInterface.h>
#include <AVSCommon/SDKInterfaces/Meeting/MeetingClientInterface.h>
#include <MeetingClientController/MeetingClientController.h>
#endif
 
#include <AVSCommon/SDKInterfaces/SystemSoundPlayerInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointInterface.h>
#include <Endpoints/Endpoint.h>
#include <PlaybackController/PlaybackController.h>
#include <PlaybackController/PlaybackRouter.h>
#include <RegistrationManager/RegistrationManager.h>
#include <Settings/DeviceSettingsManager.h>
#include <Settings/Storage/DeviceSettingStorageInterface.h>
#include <SoftwareComponentReporter/SoftwareComponentReporterCapabilityAgent.h>
#include <SpeakerManager/DefaultChannelVolumeFactory.h>
#include <SpeakerManager/SpeakerManager.h>
#include <SpeechSynthesizer/SpeechSynthesizer.h>
#include <System/SoftwareInfoSender.h>
#include <System/UserInactivityMonitor.h>
#include <TemplateRuntime/TemplateRuntime.h>
 
#ifdef ENABLE_REVOKE_AUTH
#include <System/RevokeAuthorizationHandler.h>
#endif
 
#include "DefaultClient/ConnectionRetryTrigger.h"
#include "DefaultClient/EqualizerRuntimeSetup.h"
#include "DefaultClient/ExternalCapabilitiesBuilderInterface.h"
 
namespace alexaClientSDK {
namespace defaultClient {
 
class DefaultClient : public avsCommon::sdkInterfaces::SpeechInteractionHandlerInterface {
public:
    using DefaultClientManufactory = acsdkManufactory::Manufactory<
        std::shared_ptr<acsdkAlerts::AlertsCapabilityAgent>,
        std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>,
        std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerInterface>,
        std::shared_ptr<acsdkEqualizerInterfaces::EqualizerRuntimeSetupInterface>,
        std::shared_ptr<acsdkExternalMediaPlayer::ExternalMediaPlayer>,  
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface>,
        std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownManagerInterface>,
        std::shared_ptr<acsdkStartupManagerInterfaces::StartupManagerInterface>,
        std::shared_ptr<afml::interruptModel::InterruptModel>,
        std::shared_ptr<avsCommon::avs::attachment::AttachmentManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::AuthDelegateInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::AVSConnectionManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::AVSGatewayManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeFactoryInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::ExpectSpeechTimeoutHandlerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface>,
        acsdkManufactory::
            Annotated<avsCommon::sdkInterfaces::AudioFocusAnnotation, avsCommon::sdkInterfaces::FocusManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::HTTPContentFetcherInterfaceFactoryInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionMonitorInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::LocaleAssetsManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::PowerResourceManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::RenderPlayerInfoCardsProviderRegistrarInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::SystemTimeZoneInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::audio::AudioFactoryInterface>,
        acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointBuilderInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::storage::MiscStorageInterface>,
        std::shared_ptr<avsCommon::utils::DeviceInfo>,
        std::shared_ptr<avsCommon::utils::configuration::ConfigurationNode>,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>,
        std::shared_ptr<avsCommon::utils::timing::SystemClockMonitor>,
        std::shared_ptr<capabilityAgents::alexa::AlexaInterfaceMessageSender>,
        std::shared_ptr<capabilityAgents::doNotDisturb::DoNotDisturbCapabilityAgent>,
        std::shared_ptr<captions::CaptionManagerInterface>,
        std::shared_ptr<certifiedSender::CertifiedSender>,
        std::shared_ptr<registrationManager::CustomerDataManager>,
        std::shared_ptr<settings::DeviceSettingsManager>,
        std::shared_ptr<settings::storage::DeviceSettingStorageInterface>>;
 
    static std::unique_ptr<DefaultClient> create(
        const std::shared_ptr<DefaultClientManufactory>& manufactory,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> bluetoothMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> ringtoneMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> systemSoundMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> bluetoothSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> ringtoneSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> systemSoundSpeaker,
        const std::multimap<
            avsCommon::sdkInterfaces::ChannelVolumeInterface::Type,
            std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface>> additionalSpeakers,
#ifdef ENABLE_PCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> phoneSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::phone::PhoneCallerInterface> phoneCaller,
#endif
#ifdef ENABLE_MCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> meetingSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::meeting::MeetingClientInterface> meetingClient,
        std::shared_ptr<avsCommon::sdkInterfaces::calendar::CalendarClientInterface> calendarClient,
#endif
#ifdef ENABLE_COMMS_AUDIO_PROXY
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> commsMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> commsSpeaker,
        std::shared_ptr<alexaClientSDK::avsCommon::avs::AudioInputStream> sharedDataStream,
#endif
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationsStorageInterface> notificationsStorage,
        std::shared_ptr<acsdkBluetooth::BluetoothStorageInterface> bluetoothStorage,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DialogUXStateObserverInterface>>
            alexaDialogStateObservers,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::ConnectionStatusObserverInterface>>
            connectionObservers,
        bool isGuiSupported,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>
            enabledConnectionRules = std::unordered_set<
                std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>(),
        avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion =
            avsCommon::sdkInterfaces::softwareInfo::INVALID_FIRMWARE_VERSION,
        bool sendSoftwareInfoOnConnected = false,
        std::shared_ptr<avsCommon::sdkInterfaces::SoftwareInfoSenderObserverInterface> softwareInfoSenderObserver =
            nullptr,
        std::unique_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface> bluetoothDeviceManager =
            nullptr,
        std::shared_ptr<avsCommon::sdkInterfaces::diagnostics::DiagnosticsInterface> diagnostics = nullptr,
        const std::shared_ptr<ExternalCapabilitiesBuilderInterface>& externalCapabilitiesBuilder = nullptr,
        capabilityAgents::aip::AudioProvider firstInteractionAudioProvider =
            capabilityAgents::aip::AudioProvider::null());
 
    static std::unique_ptr<DefaultClient> create(
        std::shared_ptr<avsCommon::utils::DeviceInfo> deviceInfo,
        std::shared_ptr<registrationManager::CustomerDataManager> customerDataManager,
        const std::unordered_map<std::string, std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface>>&
            externalMusicProviderMediaPlayers,
        const std::unordered_map<std::string, std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface>>&
            externalMusicProviderSpeakers,
        const acsdkExternalMediaPlayer::ExternalMediaPlayer::AdapterCreationMap& adapterCreationMap,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> speakMediaPlayer,
        std::unique_ptr<avsCommon::utils::mediaPlayer::MediaPlayerFactoryInterface> audioMediaPlayerFactory,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> alertsMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> notificationsMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> bluetoothMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> ringtoneMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> systemSoundMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> speakSpeaker,
        std::vector<std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface>> audioSpeakers,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> alertsSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> notificationsSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> bluetoothSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> ringtoneSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> systemSoundSpeaker,
        const std::multimap<
            avsCommon::sdkInterfaces::ChannelVolumeInterface::Type,
            std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface>> additionalSpeakers,
#ifdef ENABLE_PCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> phoneSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::phone::PhoneCallerInterface> phoneCaller,
#endif
#ifdef ENABLE_MCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> meetingSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::meeting::MeetingClientInterface> meetingClient,
        std::shared_ptr<avsCommon::sdkInterfaces::calendar::CalendarClientInterface> calendarClient,
#endif
#ifdef ENABLE_COMMS_AUDIO_PROXY
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> commsMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> commsSpeaker,
        std::shared_ptr<alexaClientSDK::avsCommon::avs::AudioInputStream> sharedDataStream,
#endif
        std::shared_ptr<EqualizerRuntimeSetup> equalizerRuntimeSetup,
        std::shared_ptr<avsCommon::sdkInterfaces::audio::AudioFactoryInterface> audioFactory,
        std::shared_ptr<avsCommon::sdkInterfaces::AuthDelegateInterface> authDelegate,
        std::shared_ptr<acsdkAlerts::storage::AlertStorageInterface> alertStorage,
        std::shared_ptr<certifiedSender::MessageStorageInterface> messageStorage,
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationsStorageInterface> notificationsStorage,
        std::unique_ptr<settings::storage::DeviceSettingStorageInterface> deviceSettingStorage,
        std::shared_ptr<acsdkBluetooth::BluetoothStorageInterface> bluetoothStorage,
        std::shared_ptr<avsCommon::sdkInterfaces::storage::MiscStorageInterface> miscStorage,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DialogUXStateObserverInterface>>
            alexaDialogStateObservers,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::ConnectionStatusObserverInterface>>
            connectionObservers,
        std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionMonitorInterface> internetConnectionMonitor,
        bool isGuiSupported,
        std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateInterface> capabilitiesDelegate,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<alexaClientSDK::acl::TransportFactoryInterface> transportFactory,
        std::shared_ptr<avsCommon::sdkInterfaces::AVSGatewayManagerInterface> avsGatewayManager,
        std::shared_ptr<avsCommon::sdkInterfaces::LocaleAssetsManagerInterface> localeAssetsManager,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>
            enabledConnectionRules = std::unordered_set<
                std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>(),
        std::shared_ptr<avsCommon::sdkInterfaces::SystemTimeZoneInterface> systemTimezone = nullptr,
        avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion =
            avsCommon::sdkInterfaces::softwareInfo::INVALID_FIRMWARE_VERSION,
        bool sendSoftwareInfoOnConnected = false,
        std::shared_ptr<avsCommon::sdkInterfaces::SoftwareInfoSenderObserverInterface> softwareInfoSenderObserver =
            nullptr,
        std::unique_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface> bluetoothDeviceManager =
            nullptr,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr,
        std::shared_ptr<avsCommon::sdkInterfaces::PowerResourceManagerInterface> powerResourceManager = nullptr,
        std::shared_ptr<avsCommon::sdkInterfaces::diagnostics::DiagnosticsInterface> diagnostics = nullptr,
        const std::shared_ptr<ExternalCapabilitiesBuilderInterface>& externalCapabilitiesBuilder = nullptr,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeFactoryInterface> channelVolumeFactory =
            std::make_shared<alexaClientSDK::capabilityAgents::speakerManager::DefaultChannelVolumeFactory>(),
        bool startAlertSchedulingOnInitialization = true,
        std::shared_ptr<alexaClientSDK::acl::MessageRouterFactoryInterface> messageRouterFactory =
            std::make_shared<alexaClientSDK::acl::MessageRouterFactory>(),
        const std::shared_ptr<avsCommon::sdkInterfaces::ExpectSpeechTimeoutHandlerInterface>&
            expectSpeechTimeoutHandler = nullptr,
        capabilityAgents::aip::AudioProvider firstInteractionAudioProvider =
            capabilityAgents::aip::AudioProvider::null());
 
    void connect(bool performReset = true);
 
    void disconnect();
 
    std::string getAVSGateway();
 
    void stopForegroundActivity();
 
    void stopAllActivities();
 
    void localStopActiveAlert();
 
    void addAlexaDialogStateObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::DialogUXStateObserverInterface> observer);
 
    void removeAlexaDialogStateObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::DialogUXStateObserverInterface> observer);
 
    void addMessageObserver(std::shared_ptr<avsCommon::sdkInterfaces::MessageObserverInterface> observer);
 
    void removeMessageObserver(std::shared_ptr<avsCommon::sdkInterfaces::MessageObserverInterface> observer);
 
    void addConnectionObserver(std::shared_ptr<avsCommon::sdkInterfaces::ConnectionStatusObserverInterface> observer);
 
    void removeConnectionObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::ConnectionStatusObserverInterface> observer);
 
    void addInternetConnectionObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionObserverInterface> observer);
 
    void removeInternetConnectionObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionObserverInterface> observer);
 
    void addAlertsObserver(std::shared_ptr<acsdkAlertsInterfaces::AlertObserverInterface> observer);
 
    void removeAlertsObserver(std::shared_ptr<acsdkAlertsInterfaces::AlertObserverInterface> observer);
 
    void addAudioPlayerObserver(std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface> observer);
 
    void removeAudioPlayerObserver(std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerObserverInterface> observer);
 
    void addTemplateRuntimeObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::TemplateRuntimeObserverInterface> observer);
 
    void removeTemplateRuntimeObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::TemplateRuntimeObserverInterface> observer);
 
    void TemplateRuntimeDisplayCardCleared();
 
    void addNotificationsObserver(
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationsObserverInterface> observer);
 
    void removeNotificationsObserver(
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationsObserverInterface> observer);
 
    void addExternalMediaPlayerObserver(
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerObserverInterface> observer);
 
    void removeExternalMediaPlayerObserver(
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerObserverInterface> observer);
 
    void addBluetoothDeviceObserver(
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothDeviceObserverInterface> observer);
 
    void removeBluetoothDeviceObserver(
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothDeviceObserverInterface> observer);
 
    void addCaptionPresenter(std::shared_ptr<captions::CaptionPresenterInterface> presenter);
 
    void setCaptionMediaPlayers(
        const std::vector<std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface>>& mediaPlayers);
 
    /*
     * Get a reference to the PlaybackRouter
     *
     * @return shared_ptr to the PlaybackRouter.
     */
    std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> getPlaybackRouter() const;
 
    void addSpeakerManagerObserver(std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerObserverInterface> observer);
 
    void removeSpeakerManagerObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerObserverInterface> observer);
 
    std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> getSpeakerManager();
 
    void addSpeechSynthesizerObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::SpeechSynthesizerObserverInterface> observer);
 
    void removeSpeechSynthesizerObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::SpeechSynthesizerObserverInterface> observer);
 
    std::shared_ptr<registrationManager::RegistrationManager> getRegistrationManager();
 
#ifdef ENABLE_REVOKE_AUTH
 
    void addRevokeAuthorizationObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::RevokeAuthorizationObserverInterface> observer);
 
    void removeRevokeAuthorizationObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::RevokeAuthorizationObserverInterface> observer);
#endif
 
    std::shared_ptr<acsdkEqualizer::EqualizerController> getEqualizerController();
 
    void addEqualizerControllerListener(
        std::shared_ptr<acsdkEqualizerInterfaces::EqualizerControllerListenerInterface> listener);
 
    void removeEqualizerControllerListener(
        std::shared_ptr<acsdkEqualizerInterfaces::EqualizerControllerListenerInterface> listener);
 
    void addContextManagerObserver(std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerObserverInterface> observer);
 
    void removeContextManagerObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerObserverInterface> observer);
 
    bool setFirmwareVersion(avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion);
 
    std::future<bool> notifyOfWakeWord(
        capabilityAgents::aip::AudioProvider wakeWordAudioProvider,
        avsCommon::avs::AudioInputStream::Index beginIndex,
        avsCommon::avs::AudioInputStream::Index endIndex,
        std::string keyword,
        std::chrono::steady_clock::time_point startOfSpeechTimestamp,
        std::shared_ptr<const std::vector<char>> KWDMetadata = nullptr) override;
 
    std::future<bool> notifyOfTapToTalk(
        capabilityAgents::aip::AudioProvider tapToTalkAudioProvider,
        avsCommon::avs::AudioInputStream::Index beginIndex = capabilityAgents::aip::AudioInputProcessor::INVALID_INDEX,
        std::chrono::steady_clock::time_point startOfSpeechTimestamp = std::chrono::steady_clock::now()) override;
 
    std::future<bool> notifyOfHoldToTalkStart(
        capabilityAgents::aip::AudioProvider holdToTalkAudioProvider,
        std::chrono::steady_clock::time_point startOfSpeechTimestamp = std::chrono::steady_clock::now(),
        avsCommon::avs::AudioInputStream::Index beginIndex =
            capabilityAgents::aip::AudioInputProcessor::INVALID_INDEX) override;
 
    std::future<bool> notifyOfHoldToTalkEnd() override;
 
    std::future<bool> notifyOfTapToTalkEnd() override;
 
    std::shared_ptr<settings::DeviceSettingsManager> getSettingsManager();
 
    std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointBuilderInterface> createEndpointBuilder();
 
    std::future<endpoints::EndpointRegistrationManager::RegistrationResult> registerEndpoint(
        std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointInterface> endpoint);
 
    std::future<endpoints::EndpointRegistrationManager::DeregistrationResult> deregisterEndpoint(
        avsCommon::sdkInterfaces::endpoints::EndpointIdentifier endpointId);
 
    std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointBuilderInterface> getDefaultEndpointBuilder();
 
    void addAudioInputProcessorObserver(
        const std::shared_ptr<avsCommon::sdkInterfaces::AudioInputProcessorObserverInterface>& observer);
 
    void removeAudioInputProcessorObserver(
        const std::shared_ptr<avsCommon::sdkInterfaces::AudioInputProcessorObserverInterface>& observer);
 
    void addCallStateObserver(std::shared_ptr<avsCommon::sdkInterfaces::CallStateObserverInterface> observer);
 
    void removeCallStateObserver(std::shared_ptr<avsCommon::sdkInterfaces::CallStateObserverInterface> observer);
 
    bool isCommsEnabled();
 
    void acceptCommsCall();
 
    void sendDtmf(avsCommon::sdkInterfaces::CallManagerInterface::DTMFTone dtmfTone);
 
    void stopCommsCall();
 
    void audioPlayerLocalStop();
 
    bool isCommsCallMuted();
 
    void muteCommsCall();
 
    void unmuteCommsCall();
 
    /*
     * To be called when system clock is synchronized.
     */
    void onSystemClockSynchronized();
 
    void registerExternalMediaPlayerAdapterHandler(
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaAdapterHandlerInterface>
            externalMediaPlayerAdapterHandler);
 
    std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownManagerInterface> getShutdownManager();
 
    ~DefaultClient();
 
private:
    bool initialize(
        const std::shared_ptr<DefaultClientManufactory>& manufactory,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> bluetoothMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> ringtoneMediaPlayer,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> systemSoundMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> bluetoothSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> ringtoneSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> systemSoundSpeaker,
        const std::multimap<
            avsCommon::sdkInterfaces::ChannelVolumeInterface::Type,
            std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface>> additionalSpeakers,
#ifdef ENABLE_PCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> phoneSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::phone::PhoneCallerInterface> phoneCaller,
#endif
#ifdef ENABLE_MCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> meetingSpeaker,
        std::shared_ptr<avsCommon::sdkInterfaces::meeting::MeetingClientInterface> meetingClient,
        std::shared_ptr<avsCommon::sdkInterfaces::calendar::CalendarClientInterface> calendarClient,
#endif
#ifdef ENABLE_COMMS_AUDIO_PROXY
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> commsMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> commsSpeaker,
        std::shared_ptr<alexaClientSDK::avsCommon::avs::AudioInputStream> sharedDataStream,
#endif
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationsStorageInterface> notificationsStorage,
        std::shared_ptr<acsdkBluetooth::BluetoothStorageInterface> bluetoothStorage,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DialogUXStateObserverInterface>>
            alexaDialogStateObservers,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::ConnectionStatusObserverInterface>>
            connectionObservers,
        bool isGuiSupported,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>
            enabledConnectionRules,
        avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion,
        bool sendSoftwareInfoOnConnected,
        std::shared_ptr<avsCommon::sdkInterfaces::SoftwareInfoSenderObserverInterface> softwareInfoSenderObserver,
        std::unique_ptr<avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface> bluetoothDeviceManager,
        std::shared_ptr<avsCommon::sdkInterfaces::diagnostics::DiagnosticsInterface> diagnostics,
        const std::shared_ptr<ExternalCapabilitiesBuilderInterface>& externalCapabilitiesBuilder,
        capabilityAgents::aip::AudioProvider firstInteractionAudioProvider);
 
    std::shared_ptr<avsCommon::sdkInterfaces::DirectiveSequencerInterface> m_directiveSequencer;
 
    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> m_audioFocusManager;
 
    std::shared_ptr<afml::FocusManager> m_visualFocusManager;
 
    std::shared_ptr<afml::VisualActivityTracker> m_visualActivityTracker;
 
    std::shared_ptr<acl::MessageRouterInterface> m_messageRouter;
 
    std::shared_ptr<acl::AVSConnectionManagerInterface> m_connectionManager;
 
    std::shared_ptr<avsCommon::sdkInterfaces::InternetConnectionMonitorInterface> m_internetConnectionMonitor;
 
    std::shared_ptr<captions::CaptionManagerInterface> m_captionManager;
 
    std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> m_exceptionSender;
 
    std::shared_ptr<certifiedSender::CertifiedSender> m_certifiedSender;
 
    std::shared_ptr<capabilityAgents::aip::AudioInputProcessor> m_audioInputProcessor;
 
    std::shared_ptr<capabilityAgents::speechSynthesizer::SpeechSynthesizer> m_speechSynthesizer;
 
    std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerInterface> m_audioPlayer;
 
    std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface> m_externalMediaPlayer;
 
    std::shared_ptr<capabilityAgents::alexa::AlexaInterfaceMessageSender> m_alexaMessageSender;
 
    std::shared_ptr<capabilityAgents::apiGateway::ApiGatewayCapabilityAgent> m_apiGatewayCapabilityAgent;
 
    std::shared_ptr<acsdkAlerts::AlertsCapabilityAgent> m_alertsCapabilityAgent;
 
    std::shared_ptr<acsdkBluetooth::Bluetooth> m_bluetooth;
 
    std::shared_ptr<capabilityAgents::interactionModel::InteractionModelCapabilityAgent> m_interactionCapabilityAgent;
 
    std::shared_ptr<acsdkNotifications::NotificationRenderer> m_notificationsRenderer;
 
    std::shared_ptr<acsdkNotifications::NotificationsCapabilityAgent> m_notificationsCapabilityAgent;
 
    std::shared_ptr<capabilityAgents::system::UserInactivityMonitor> m_userInactivityMonitor;
 
#ifdef ENABLE_PCC
    std::shared_ptr<capabilityAgents::phoneCallController::PhoneCallController> m_phoneCallControllerCapabilityAgent;
#endif
 
#ifdef ENABLE_MCC
    std::shared_ptr<capabilityAgents::meetingClientController::MeetingClientController>
        m_meetingClientControllerCapabilityAgent;
#endif
 
    std::shared_ptr<avsCommon::sdkInterfaces::CallManagerInterface> m_callManager;
 
    std::shared_ptr<avsCommon::avs::DialogUXStateAggregator> m_dialogUXStateAggregator;
 
    std::shared_ptr<avsCommon::sdkInterfaces::PlaybackRouterInterface> m_playbackRouter;
 
    std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> m_speakerManager;
 
    std::shared_ptr<capabilityAgents::templateRuntime::TemplateRuntime> m_templateRuntime;
 
    std::shared_ptr<acsdkEqualizer::EqualizerCapabilityAgent> m_equalizerCapabilityAgent;
 
    std::shared_ptr<acsdkEqualizer::EqualizerController> m_equalizerController;
 
    std::shared_ptr<acsdkEqualizerInterfaces::EqualizerRuntimeSetupInterface> m_equalizerRuntimeSetup;
 
    std::mutex m_softwareInfoSenderMutex;
 
    std::shared_ptr<capabilityAgents::system::SoftwareInfoSender> m_softwareInfoSender;
 
#ifdef ENABLE_REVOKE_AUTH
    std::shared_ptr<capabilityAgents::system::RevokeAuthorizationHandler> m_revokeAuthorizationHandler;
#endif
 
    std::shared_ptr<avsCommon::sdkInterfaces::AuthDelegateInterface> m_authDelegate;
 
    std::shared_ptr<registrationManager::RegistrationManager> m_registrationManager;
 
    std::shared_ptr<avsCommon::sdkInterfaces::SystemSoundPlayerInterface> m_systemSoundPlayer;
 
    std::shared_ptr<settings::DeviceSettingsManager> m_deviceSettingsManager;
 
    std::shared_ptr<avsCommon::utils::DeviceInfo> m_deviceInfo;
 
    std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> m_contextManager;
 
    std::shared_ptr<endpoints::EndpointRegistrationManager> m_endpointRegistrationManager;
 
    std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointBuilderInterface> m_defaultEndpointBuilder;
 
    std::shared_ptr<avsCommon::sdkInterfaces::AVSGatewayManagerInterface> m_avsGatewayManager;
 
    std::shared_ptr<avsCommon::sdkInterfaces::CapabilitiesDelegateInterface> m_capabilitiesDelegate;
 
    std::shared_ptr<avsCommon::sdkInterfaces::diagnostics::DiagnosticsInterface> m_diagnostics;
 
    std::shared_ptr<avsCommon::utils::timing::SystemClockMonitor> m_systemClockMonitor;
 
    std::list<std::shared_ptr<avsCommon::utils::RequiresShutdown>> m_shutdownObjects;
 
    std::shared_ptr<ConnectionRetryTrigger> m_connectionRetryTrigger;
 
    std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::SoftwareInfoSenderObserverInterface>>
        m_softwareInfoSenderObservers;
 
    std::shared_ptr<capabilityAgents::softwareComponentReporter::SoftwareComponentReporterCapabilityAgent>
        m_softwareReporterCapabilityAgent;
 
    std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownManagerInterface> m_shutdownManager;
};
 
}  // namespace defaultClient
}  // namespace alexaClientSDK
 
#endif  // ALEXA_CLIENT_SDK_APPLICATIONUTILITIES_DEFAULTCLIENT_INCLUDE_DEFAULTCLIENT_DEFAULTCLIENT_H_