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 <AIP/AudioInputProcessor.h>
#include <AIP/AudioProvider.h>
#include <acsdkAlerts/Storage/AlertStorageInterface.h>
#include <acsdkAlertsInterfaces/AlertsCapabilityAgentInterface.h>
#include <acsdkApplicationAudioPipelineFactoryInterfaces/ApplicationAudioPipelineFactoryInterface.h>
#include <acsdkNotificationsInterfaces/NotificationsNotifierInterface.h>
#include <acsdkSystemClockMonitorInterfaces/SystemClockMonitorInterface.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/Bluetooth/BluetoothDeviceManagerInterface.h>
#include <AVSCommon/SDKInterfaces/CallManagerInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesDelegateInterface.h>
#include <AVSCommon/SDKInterfaces/CapabilitiesDelegateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/ChannelVolumeFactoryInterface.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 <acsdk/TemplateRuntimeInterfaces/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 <acsdkBluetoothInterfaces/BluetoothLocalInterface.h>
#include <acsdkBluetoothInterfaces/BluetoothNotifierInterface.h>
#include <acsdkBluetoothInterfaces/BluetoothStorageInterface.h>
#include <acsdkNotificationsInterfaces/NotificationsStorageInterface.h>
#include <Captions/CaptionManagerInterface.h>
#include <Captions/CaptionPresenterInterface.h>
#include <CertifiedSender/CertifiedSender.h>
#include <CertifiedSender/SQLiteMessageStorage.h>
#include <acsdkDeviceSetupInterfaces/DeviceSetupInterface.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 <acsdkInteractionModelInterfaces/InteractionModelNotifierInterface.h>
#include <acsdkStartupManagerInterfaces/StartupManagerInterface.h>
#include <InterruptModel/InterruptModel.h>

#ifdef ENABLE_PCC
#include <acsdk/PhoneCallControllerInterfaces/Phone/PhoneCallerInterface.h>
#include <acsdk/PhoneCallController/PhoneCallController.h>
#endif

#ifdef ENABLE_MCC
#include <acsdk/MeetingClientControllerInterfaces/Calendar/CalendarClientInterface.h>
#include <acsdk/MeetingClientControllerInterfaces/Meeting/MeetingClientInterface.h>
#include <acsdk/MeetingClientController/MeetingClientController.h>
#endif

#include <acsdk/AudioEncoderInterfaces/AudioEncoderInterface.h>
#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/RegistrationManagerInterface.h>
#include <RegistrationManager/RegistrationNotifierInterface.h>
#include <RegistrationManager/RegistrationObserverInterface.h>
#include <Settings/DeviceSettingsManager.h>
#include <Settings/Storage/DeviceSettingStorageInterface.h>
#include <SoftwareComponentReporter/SoftwareComponentReporterCapabilityAgent.h>
#include <acsdk/SDKClient/FeatureClientInterface.h>
#include <acsdk/SpeakerManager/Factories.h>
#include <SpeechSynthesizer/SpeechSynthesizer.h>
#include <System/SoftwareInfoSender.h>
#include <System/UserInactivityMonitor.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 sdkClient::FeatureClientInterface {
public:
    using DefaultClientSubsetManufactory = acsdkManufactory::Manufactory<
        std::shared_ptr<acsdkAlertsInterfaces::AlertsCapabilityAgentInterface>,
        std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>,
        std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerInterface>,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothLocalInterface>,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothNotifierInterface>,
        std::shared_ptr<acsdkEqualizerInterfaces::EqualizerRuntimeSetupInterface>,
        std::shared_ptr<acsdkExternalMediaPlayer::ExternalMediaPlayer>,
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface>,
        std::shared_ptr<acsdkInteractionModelInterfaces::InteractionModelNotifierInterface>,
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationsNotifierInterface>,
        std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownManagerInterface>,
        std::shared_ptr<acsdkStartupManagerInterfaces::StartupManagerInterface>,
        std::shared_ptr<acsdkSystemClockMonitorInterfaces::SystemClockMonitorInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveSequencerInterface>,
        std::shared_ptr<afml::interruptModel::InterruptModel>,
        std::shared_ptr<avsCommon::avs::DialogUXStateAggregator>,
        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::SystemSoundPlayerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::SystemTimeZoneInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::UserInactivityMonitorInterface>,
        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<capabilityAgents::alexa::AlexaInterfaceMessageSender>,
        std::shared_ptr<capabilityAgents::doNotDisturb::DoNotDisturbCapabilityAgent>,
        std::shared_ptr<captions::CaptionManagerInterface>,
        std::shared_ptr<certifiedSender::CertifiedSender>,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface>,
        std::shared_ptr<registrationManager::RegistrationManagerInterface>,
        std::shared_ptr<registrationManager::RegistrationNotifierInterface>,
        std::shared_ptr<settings::DeviceSettingsManager>,
        std::shared_ptr<settings::storage::DeviceSettingStorageInterface>,
        std::shared_ptr<audioEncoderInterfaces::AudioEncoderInterface>,
        std::shared_ptr<acsdkDeviceSetupInterfaces::DeviceSetupInterface>>;

    using DefaultClientManufactory = acsdkManufactory::Manufactory<
        std::shared_ptr<acsdkAlertsInterfaces::AlertsCapabilityAgentInterface>,
        std::shared_ptr<acsdkApplicationAudioPipelineFactoryInterfaces::ApplicationAudioPipelineFactoryInterface>,
        std::shared_ptr<acsdkAudioPlayerInterfaces::AudioPlayerInterface>,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothLocalInterface>,
        std::shared_ptr<acsdkBluetoothInterfaces::BluetoothNotifierInterface>,
        std::shared_ptr<acsdkEqualizerInterfaces::EqualizerRuntimeSetupInterface>,
        std::shared_ptr<acsdkExternalMediaPlayer::ExternalMediaPlayer>,
        std::shared_ptr<acsdkExternalMediaPlayerInterfaces::ExternalMediaPlayerInterface>,
        std::shared_ptr<acsdkInteractionModelInterfaces::InteractionModelNotifierInterface>,
        std::shared_ptr<acsdkNotificationsInterfaces::NotificationsNotifierInterface>,
        std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownManagerInterface>,
        std::shared_ptr<acsdkStartupManagerInterfaces::StartupManagerInterface>,
        std::shared_ptr<acsdkSystemClockMonitorInterfaces::SystemClockMonitorInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::DirectiveSequencerInterface>,
        std::shared_ptr<afml::interruptModel::InterruptModel>,
        std::shared_ptr<avsCommon::avs::DialogUXStateAggregator>,
        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::SystemSoundPlayerInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::SystemTimeZoneInterface>,
        std::shared_ptr<avsCommon::sdkInterfaces::UserInactivityMonitorInterface>,
        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<capabilityAgents::alexa::AlexaInterfaceMessageSender>,
        std::shared_ptr<capabilityAgents::doNotDisturb::DoNotDisturbCapabilityAgent>,
        std::shared_ptr<captions::CaptionManagerInterface>,
        std::shared_ptr<certifiedSender::CertifiedSender>,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface>,
        std::shared_ptr<registrationManager::RegistrationManagerInterface>,
        std::shared_ptr<registrationManager::RegistrationNotifierInterface>,
        std::shared_ptr<settings::DeviceSettingsManager>,
        std::shared_ptr<settings::storage::DeviceSettingStorageInterface>,
        std::shared_ptr<audioEncoderInterfaces::AudioEncoderInterface>,
        std::shared_ptr<acsdkDeviceSetupInterfaces::DeviceSetupInterface>>;

    static std::unique_ptr<DefaultClient> create(
        const std::shared_ptr<DefaultClientSubsetManufactory>& manufactory,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> ringtoneMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> ringtoneSpeaker,
        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<phoneCallControllerInterfaces::phone::PhoneCallerInterface> phoneCaller,
#endif
#ifdef ENABLE_MCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> meetingSpeaker,
        std::shared_ptr<meetingClientControllerInterfaces::meeting::MeetingClientInterface> meetingClient,
        std::shared_ptr<meetingClientControllerInterfaces::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::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DialogUXStateObserverInterface>>
            alexaDialogStateObservers,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::ConnectionStatusObserverInterface>>
            connectionObservers,
        bool isGuiSupported,
        avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion =
            avsCommon::sdkInterfaces::softwareInfo::INVALID_FIRMWARE_VERSION,
        bool sendSoftwareInfoOnConnected = false,
        std::shared_ptr<avsCommon::sdkInterfaces::SoftwareInfoSenderObserverInterface> softwareInfoSenderObserver =
            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(),
        const std::shared_ptr<sdkClient::SDKClientRegistry>& sdkClientRegistry = nullptr);

    static std::unique_ptr<DefaultClient> create(
        std::shared_ptr<avsCommon::utils::DeviceInfo> deviceInfo,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> 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<phoneCallControllerInterfaces::phone::PhoneCallerInterface> phoneCaller,
#endif
#ifdef ENABLE_MCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> meetingSpeaker,
        std::shared_ptr<meetingClientControllerInterfaces::meeting::MeetingClientInterface> meetingClient,
        std::shared_ptr<meetingClientControllerInterfaces::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::shared_ptr<settings::storage::DeviceSettingStorageInterface> deviceSettingStorage,
        std::shared_ptr<acsdkBluetoothInterfaces::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 =
            speakerManager::createChannelVolumeFactory(),
        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(),
        const std::shared_ptr<alexaClientSDK::cryptoInterfaces::CryptoFactoryInterface>& cryptoFactory = nullptr,
        const std::shared_ptr<sdkClient::SDKClientRegistry>& sdkClientRegistry = nullptr);

    bool configure(const std::shared_ptr<sdkClient::SDKClientRegistry>& sdkClientRegistry) override;
    void doShutdown() override;

    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<templateRuntimeInterfaces::TemplateRuntimeObserverInterface> observer);

    void removeTemplateRuntimeObserver(
        std::shared_ptr<templateRuntimeInterfaces::TemplateRuntimeObserverInterface> observer);

    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::RegistrationManagerInterface> getRegistrationManager();

    void addRegistrationObserver(const std::shared_ptr<registrationManager::RegistrationObserverInterface>& observer);

    void removeRegistrationObserver(
        const std::shared_ptr<registrationManager::RegistrationObserverInterface>& observer);

#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::UpdateResult> updateEndpoint(
        const avsCommon::sdkInterfaces::endpoints::EndpointIdentifier& endpointId,
        const std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointModificationData>& endpointModificationData);

    std::future<endpoints::EndpointRegistrationManager::DeregistrationResult> deregisterEndpoint(
        avsCommon::sdkInterfaces::endpoints::EndpointIdentifier endpointId);

    std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointBuilderInterface> getDefaultEndpointBuilder();

    void addEndpointRegistrationManagerObserver(
        const std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointRegistrationObserverInterface>& observer);

    void removeEndpointRegistrationManagerObserver(
        const std::shared_ptr<avsCommon::sdkInterfaces::endpoints::EndpointRegistrationObserverInterface>& observer);

    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();

    void enableVideo();

    void disableVideo();

    /*
     * 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();

    bool setEncodingAudioFormat(avsCommon::utils::AudioFormat::Encoding encoding);

    capabilityAgents::aip::AudioInputProcessor::EncodingFormatResponse requestEncodingAudioFormats(
        const capabilityAgents::aip::AudioInputProcessor::EncodingFormatRequest& encodings);

    std::shared_ptr<acsdkDeviceSetupInterfaces::DeviceSetupInterface> getDeviceSetup();

    std::shared_ptr<acsdkBluetoothInterfaces::BluetoothLocalInterface> getBluetoothLocal();

    void stopInteraction();

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::FocusManagerInterface> getAudioFocusManager();

private:
    DefaultClient();

    bool initialize(
        const std::shared_ptr<DefaultClientManufactory>& manufactory,
        std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface> ringtoneMediaPlayer,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> ringtoneSpeaker,
        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<phoneCallControllerInterfaces::phone::PhoneCallerInterface> phoneCaller,
#endif
#ifdef ENABLE_MCC
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface> meetingSpeaker,
        std::shared_ptr<meetingClientControllerInterfaces::meeting::MeetingClientInterface> meetingClient,
        std::shared_ptr<meetingClientControllerInterfaces::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::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::DialogUXStateObserverInterface>>
            alexaDialogStateObservers,
        std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::ConnectionStatusObserverInterface>>
            connectionObservers,
        bool isGuiSupported,
        avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion,
        bool sendSoftwareInfoOnConnected,
        std::shared_ptr<avsCommon::sdkInterfaces::SoftwareInfoSenderObserverInterface> softwareInfoSenderObserver,
        std::shared_ptr<avsCommon::sdkInterfaces::diagnostics::DiagnosticsInterface> diagnostics,
        const std::shared_ptr<ExternalCapabilitiesBuilderInterface>& externalCapabilitiesBuilder,
        capabilityAgents::aip::AudioProvider firstInteractionAudioProvider,
        const std::shared_ptr<sdkClient::SDKClientRegistry>& sdkClientRegistry = nullptr);

    std::shared_ptr<avsCommon::sdkInterfaces::DirectiveSequencerInterface> m_directiveSequencer;

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

    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<acsdkAlertsInterfaces::AlertsCapabilityAgentInterface> m_alertsCapabilityAgent;

    std::shared_ptr<acsdkBluetoothInterfaces::BluetoothLocalInterface> m_bluetoothLocal;

    std::shared_ptr<acsdkBluetoothInterfaces::BluetoothNotifierInterface> m_bluetoothNotifier;

    std::shared_ptr<acsdkInteractionModelInterfaces::InteractionModelNotifierInterface> m_interactionModelNotifier;

    std::shared_ptr<acsdkNotificationsInterfaces::NotificationsNotifierInterface> m_notificationsNotifier;

#ifdef ENABLE_PCC
    std::shared_ptr<phoneCallController::PhoneCallController> m_phoneCallControllerCapabilityAgent;
#endif

#ifdef ENABLE_MCC
    std::shared_ptr<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<templateRuntimeInterfaces::TemplateRuntimeInterface> 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::RegistrationManagerInterface> m_registrationManager;

    std::shared_ptr<registrationManager::RegistrationNotifierInterface> m_registrationNotifier;

    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<acsdkSystemClockMonitorInterfaces::SystemClockMonitorInterface> 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;

    std::shared_ptr<acsdkDeviceSetupInterfaces::DeviceSetupInterface> m_deviceSetup;
};

}  // namespace defaultClient
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_APPLICATIONUTILITIES_DEFAULTCLIENT_INCLUDE_DEFAULTCLIENT_DEFAULTCLIENT_H_