DefaultClientBuilder.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_DEFAULTCLIENTBUILDER_H_
#define ALEXA_CLIENT_SDK_APPLICATIONUTILITIES_DEFAULTCLIENT_INCLUDE_DEFAULTCLIENT_DEFAULTCLIENTBUILDER_H_

#include <ACL/Transport/MessageRouter.h>
#include <ACL/Transport/MessageRouterFactory.h>
#include <AIP/AudioInputProcessor.h>
#include <AIP/AudioProvider.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/CapabilitiesDelegateInterface.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/ExpectSpeechTimeoutHandlerInterface.h>
#include <AVSCommon/SDKInterfaces/InternetConnectionMonitorInterface.h>
#include <AVSCommon/SDKInterfaces/LocaleAssetsManagerInterface.h>
#include <AVSCommon/SDKInterfaces/PowerResourceManagerInterface.h>
#include <AVSCommon/SDKInterfaces/Storage/MiscStorageInterface.h>
#include <AVSCommon/SDKInterfaces/SystemTimeZoneInterface.h>
#include <AVSCommon/Utils/DeviceInfo.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 <CertifiedSender/CertifiedSender.h>
#include <Endpoints/Endpoint.h>
#include <Settings/Storage/DeviceSettingStorageInterface.h>
#include <System/SoftwareInfoSender.h>
#include <acsdk/SDKClient/FeatureClientBuilderInterface.h>
#include <acsdk/SDKClient/SDKClientRegistry.h>
#include <acsdkAlerts/Storage/AlertStorageInterface.h>
#include <acsdkAudioPlayer/AudioPlayer.h>
#include <acsdkBluetoothInterfaces/BluetoothStorageInterface.h>
#include <acsdkExternalMediaPlayer/ExternalMediaPlayer.h>
#include <acsdkNotificationsInterfaces/NotificationsStorageInterface.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 "DefaultClient/EqualizerRuntimeSetup.h"
#include "DefaultClient/ExternalCapabilitiesBuilderInterface.h"

#include "DefaultClient.h"

namespace alexaClientSDK {
namespace defaultClient {
class DefaultClientBuilder : public sdkClient::FeatureClientBuilderInterface {
public:
    static std::unique_ptr<DefaultClientBuilder> create(
        std::shared_ptr<avsCommon::utils::DeviceInfo> deviceInfo,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> customerDataManager,
        std::unordered_map<std::string, std::shared_ptr<avsCommon::utils::mediaPlayer::MediaPlayerInterface>>
            externalMusicProviderMediaPlayers,
        std::unordered_map<std::string, std::shared_ptr<avsCommon::sdkInterfaces::SpeakerInterface>>
            externalMusicProviderSpeakers,
        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,
        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<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,
        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>(),
        std::shared_ptr<avsCommon::sdkInterfaces::ExpectSpeechTimeoutHandlerInterface> expectSpeechTimeoutHandler =
            nullptr,
        capabilityAgents::aip::AudioProvider firstInteractionAudioProvider =
            capabilityAgents::aip::AudioProvider::null(),
        std::shared_ptr<alexaClientSDK::cryptoInterfaces::CryptoFactoryInterface> cryptoFactory = nullptr);

    std::shared_ptr<DefaultClient> construct(const std::shared_ptr<sdkClient::SDKClientRegistry>& sdkClientRegistry);

    std::string name() override;

private:
    DefaultClientBuilder();

    bool m_constructed;

    std::shared_ptr<alexaClientSDK::avsCommon::utils::DeviceInfo> m_deviceInfo;

    std::shared_ptr<alexaClientSDK::registrationManager::CustomerDataManagerInterface> m_customerDataManager;

    std::
        unordered_map<std::string, std::shared_ptr<alexaClientSDK::avsCommon::utils::mediaPlayer::MediaPlayerInterface>>
            m_externalMusicProviderMediaPlayers;

    std::unordered_map<std::string, std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface>>
        m_externalMusicProviderSpeakers;

    alexaClientSDK::acsdkExternalMediaPlayer::ExternalMediaPlayer::AdapterCreationMap m_adapterCreationMap;

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

    std::unique_ptr<alexaClientSDK::avsCommon::utils::mediaPlayer::MediaPlayerFactoryInterface>
        m_audioMediaPlayerFactory;

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

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

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

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

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

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_speakSpeaker;

    std::vector<std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface>> m_audioSpeakers;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_alertsSpeaker;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_notificationsSpeaker;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_bluetoothSpeaker;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_ringtoneSpeaker;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_systemSoundSpeaker;

    std::multimap<
        alexaClientSDK::avsCommon::sdkInterfaces::ChannelVolumeInterface::Type,
        std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface>>
        m_additionalSpeakers;

    std::shared_ptr<EqualizerRuntimeSetup> m_equalizerRuntimeSetup;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::audio::AudioFactoryInterface> m_audioFactory;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> m_authDelegate;

    std::shared_ptr<alexaClientSDK::acsdkAlerts::storage::AlertStorageInterface> m_alertStorage;

    std::shared_ptr<alexaClientSDK::certifiedSender::MessageStorageInterface> m_messageStorage;

    std::shared_ptr<alexaClientSDK::acsdkNotificationsInterfaces::NotificationsStorageInterface> m_notificationsStorage;

    std::shared_ptr<alexaClientSDK::settings::storage::DeviceSettingStorageInterface> m_deviceSettingStorage;

    std::shared_ptr<alexaClientSDK::acsdkBluetoothInterfaces::BluetoothStorageInterface> m_bluetoothStorage;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::storage::MiscStorageInterface> m_miscStorage;

    std::unordered_set<std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::DialogUXStateObserverInterface>>
        m_alexaDialogStateObservers;

    std::unordered_set<std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::ConnectionStatusObserverInterface>>
        m_connectionObservers;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::InternetConnectionMonitorInterface>
        m_internetConnectionMonitor;

    bool m_isGuiSupported;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::CapabilitiesDelegateInterface> m_capabilitiesDelegate;

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

    std::shared_ptr<alexaClientSDK::acl::TransportFactoryInterface> m_transportFactory;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AVSGatewayManagerInterface> m_avsGatewayManager;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::LocaleAssetsManagerInterface> m_localeAssetsManager;

    std::unordered_set<
        std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceConnectionRuleInterface>>
        m_enabledConnectionRules;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SystemTimeZoneInterface> m_systemTimezone;

    alexaClientSDK::avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion m_firmwareVersion;

    bool m_sendSoftwareInfoOnConnected;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SoftwareInfoSenderObserverInterface>
        m_softwareInfoSenderObserver;

    std::unique_ptr<alexaClientSDK::avsCommon::sdkInterfaces::bluetooth::BluetoothDeviceManagerInterface>
        m_bluetoothDeviceManager;

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

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::PowerResourceManagerInterface> m_powerResourceManager;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::diagnostics::DiagnosticsInterface> m_diagnostics;

    std::shared_ptr<ExternalCapabilitiesBuilderInterface> m_externalCapabilitiesBuilder;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::ChannelVolumeFactoryInterface> m_channelVolumeFactory;

    bool m_startAlertSchedulingOnInitialization;

    std::shared_ptr<alexaClientSDK::acl::MessageRouterFactoryInterface> m_messageRouterFactory;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::ExpectSpeechTimeoutHandlerInterface>
        m_expectSpeechTimeoutHandler;

    alexaClientSDK::capabilityAgents::aip::AudioProvider m_firstInteractionAudioProvider =
        alexaClientSDK::capabilityAgents::aip::AudioProvider::null();

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

#ifdef ENABLE_COMMS_AUDIO_PROXY
    std::shared_ptr<alexaClientSDK::avsCommon::utils::mediaPlayer::MediaPlayerInterface> m_commsMediaPlayer;

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_commsSpeaker;

    std::shared_ptr<alexaClientSDK::avsCommon::avs::AudioInputStream> m_sharedDataStream;
#endif

#ifdef ENABLE_PCC
    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_phoneSpeaker;

    std::shared_ptr<phoneCallControllerInterfaces::phone::PhoneCallerInterface> m_phoneCaller;
#endif

#ifdef ENABLE_MCC
    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeakerInterface> m_meetingSpeaker;

    std::shared_ptr<meetingClientControllerInterfaces::meeting::MeetingClientInterface> m_meetingClient;

    std::shared_ptr<meetingClientControllerInterfaces::calendar::CalendarClientInterface> m_calendarClient;
#endif
};
}  // namespace defaultClient
}  // namespace alexaClientSDK
#endif  // ALEXA_CLIENT_SDK_APPLICATIONUTILITIES_DEFAULTCLIENT_INCLUDE_DEFAULTCLIENT_DEFAULTCLIENTBUILDER_H_