InteractionManager.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 ACSDK_SAMPLE_INTERACTIONMANAGER_INTERACTIONMANAGER_H_
#define ACSDK_SAMPLE_INTERACTIONMANAGER_INTERACTIONMANAGER_H_

#include <memory>

#include <Audio/MicrophoneInterface.h>
#include <AVSCommon/SDKInterfaces/Diagnostics/AudioInjectorInterface.h>
#include <AVSCommon/SDKInterfaces/DialogUXStateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/CallStateObserverInterface.h>
#include <AVSCommon/SDKInterfaces/Diagnostics/DiagnosticsInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointIdentifier.h>
#include <AVSCommon/SDKInterfaces/SpeakerInterface.h>
#include <AVSCommon/SDKInterfaces/SpeechInteractionHandlerInterface.h>
#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <DefaultClient/DefaultClient.h>
#include <Settings/SpeechConfirmationSettingType.h>
#include <Settings/Types/NetworkInfo.h>
#include <Settings/WakeWordConfirmationSettingType.h>

#include "KeywordObserver.h"
#include "UIManager.h"

#ifdef ENABLE_PCC
#include <acsdk/PhoneCallControllerAdapter/PhoneCaller.h>
#endif

#ifdef ENABLE_MCC
#include <acsdk/MeetingClientControllerAdapter/CalendarClient.h>
#include <acsdk/MeetingClientControllerAdapter/MeetingClient.h>
#endif

#ifdef POWER_CONTROLLER
#include <acsdk/Sample/PeripheralEndpoint/PeripheralEndpointPowerControllerHandler.h>
#endif

#ifdef TOGGLE_CONTROLLER
#include <acsdk/Sample/PeripheralEndpoint/PeripheralEndpointToggleControllerHandler.h>
#endif

#ifdef RANGE_CONTROLLER
#include <acsdk/Sample/PeripheralEndpoint/PeripheralEndpointRangeControllerHandler.h>
#endif

#ifdef MODE_CONTROLLER
#include <acsdk/Sample/PeripheralEndpoint/PeripheralEndpointModeControllerHandler.h>
#endif

namespace alexaClientSDK {
namespace sampleApplications {
namespace common {

class InteractionManager
        : public avsCommon::sdkInterfaces::DialogUXStateObserverInterface
        , public avsCommon::sdkInterfaces::CallStateObserverInterface
        , public avsCommon::utils::RequiresShutdown {
public:
    InteractionManager(
        std::shared_ptr<defaultClient::DefaultClient> client,
        std::shared_ptr<applicationUtilities::resources::audio::MicrophoneInterface> micWrapper,
        std::shared_ptr<UIManager> userInterface,
#ifdef ENABLE_PCC
        std::shared_ptr<phoneCallControllerAdapter::PhoneCaller> phoneCaller,
#endif
#ifdef ENABLE_MCC
        std::shared_ptr<meetingClientControllerAdapter::MeetingClient> meetingClient,
        std::shared_ptr<meetingClientControllerAdapter::CalendarClient> calendarClient,
#endif
        capabilityAgents::aip::AudioProvider holdToTalkAudioProvider,
        capabilityAgents::aip::AudioProvider tapToTalkAudioProvider,
        capabilityAgents::aip::AudioProvider wakeWordAudioProvider = capabilityAgents::aip::AudioProvider::null(),
#ifdef POWER_CONTROLLER
        std::shared_ptr<PeripheralEndpointPowerControllerHandler> powerControllerHandler = nullptr,
#endif
#ifdef TOGGLE_CONTROLLER
        std::shared_ptr<PeripheralEndpointToggleControllerHandler> toggleControllerHandler = nullptr,
#endif
#ifdef RANGE_CONTROLLER
        std::shared_ptr<PeripheralEndpointRangeControllerHandler> rangeControllerHandler = nullptr,
#endif
#ifdef MODE_CONTROLLER
        std::shared_ptr<PeripheralEndpointModeControllerHandler> modeControllerHandler = nullptr,
#endif
        std::shared_ptr<avsCommon::sdkInterfaces::CallManagerInterface> callManager = nullptr,
        std::shared_ptr<avsCommon::sdkInterfaces::diagnostics::DiagnosticsInterface> diagnostics = nullptr);

    void begin();

    void help();

    void limitedHelp();

    void microphoneToggle();

    void holdToggled();

    void tap();

    void stopForegroundActivity();

    void playbackPlay();

    void playbackPause();

    void playbackNext();

    void playbackPrevious();

    void playbackSkipForward();

    void playbackSkipBackward();

    void playbackShuffle(bool action);

    void playbackLoop(bool action);

    void playbackRepeat(bool action);

    void playbackThumbsUp(bool action);

    void playbackThumbsDown(bool action);

    void settings();

    void alarmVolumeRamp();

    void wakewordConfirmation();

    void speechConfirmation();

    void locale();

    void clearCachedEndpointIdentifiers(
        const std::vector<avsCommon::sdkInterfaces::endpoints::EndpointIdentifier>& deletedEndpoints);

#ifdef ENABLE_ENDPOINT_CONTROLLERS

    void endpointModification();

    bool addEndpoint(const std::string& friendlyName);

    bool updateEndpoint(
        const avsCommon::sdkInterfaces::endpoints::EndpointIdentifier& endpointId,
        const std::string& friendlyName);

    void addDynamicEndpoint();

    void modifyDynamicEndpoint();

    void deleteDynamicEndpoint();

    void endpointController();
#endif

#ifdef POWER_CONTROLLER

    void powerController();

#endif
#ifdef TOGGLE_CONTROLLER

    void toggleController();
#endif

#ifdef MODE_CONTROLLER

    void modeController();
#endif

#ifdef RANGE_CONTROLLER

    void rangeController();
#endif

    void timeZone();

    void networkInfo();

    void networkInfoConnectionTypePrompt();
    void networkInfoESSIDPrompt();
    void networkInfoBSSIDPrompt();
    void networkInfoIpPrompt();
    void networkInfoSubnetPrompt();
    void networkInfoMacPrompt();
    void networkInfoDHCPPrompt();
    void networkInfoStaticIpPrompt();

    void doNotDisturb();

    void errorValue();

    void speakerControl();

    void firmwareVersionControl();

    void setFirmwareVersion(avsCommon::sdkInterfaces::softwareInfo::FirmwareVersion firmwareVersion);

    void volumeControl();

    void adjustVolume(avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type, int8_t delta);

    void setMute(avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type, bool mute);

    void overrideHoldToTalkSpeechHandler(
        std::shared_ptr<avsCommon::sdkInterfaces::SpeechInteractionHandlerInterface> holdToTalkHandler);

    void resetDevice();

    void confirmResetDevice();

    void confirmReauthorizeDevice();

#ifdef ENABLE_COMMS

    void commsControl();

    void acceptCall();

    void sendDtmf(avsCommon::sdkInterfaces::CallManagerInterface::DTMFTone dtmfTone);

    void dtmfControl();

    void errorDtmf();

    void stopCall();

    void muteCallToggle();

    void muteSelf();

    void unmuteSelf();

    void enableVideo();

    void disableVideo();

#endif

    void onDialogUXStateChanged(DialogUXState newState) override;

    void onCallStateChange(CallState newState) override;

#ifdef ENABLE_PCC

    void phoneControl();

    void callId();

    void callerId();

    void sendCallActivated(const std::string& callId);
    void sendCallTerminated(const std::string& callId);
    void sendCallFailed(const std::string& callId);
    void sendCallReceived(const std::string& callId, const std::string& callerId);
    void sendCallerIdReceived(const std::string& callId, const std::string& callerId);
    void sendInboundRingingStarted(const std::string& callId);
    void sendOutboundCallRequested(const std::string& callId);
    void sendOutboundRingingStarted(const std::string& callId);
    void sendSendDtmfSucceeded(const std::string& callId);
    void sendSendDtmfFailed(const std::string& callId);

#endif

#ifdef ENABLE_MCC

    void meetingControl();

    void sessionId();

    void calendarItemsFile();

    void sendMeetingJoined(const std::string& sessionId);
    void sendMeetingEnded(const std::string& sessionId);
    void sendSetCurrentMeetingSession(const std::string& sessionId);
    void sendClearCurrentMeetingSession();
    void sendConferenceConfigurationChanged();
    void sendMeetingClientErrorOccured(const std::string& sessionId);
    void sendCalendarItemsRetrieved(const std::string& calendarItemsFile);
    void sendCalendarClientErrorOccured();
#endif

    void setDoNotDisturbMode(bool enable);

    void setAlarmVolumeRamp(bool enable);

    void setSpeechConfirmation(settings::SpeechConfirmationSettingType value);

    void setWakewordConfirmation(settings::WakeWordConfirmationSettingType value);

    void setTimeZone(const std::string& value);

    void setLocale(const settings::DeviceLocales& value);

    settings::types::NetworkInfo getNetworkInfo();

    void setNetworkInfo(const settings::types::NetworkInfo& value);

#ifdef POWER_CONTROLLER

    void setPowerState(const bool powerState);
#endif

#ifdef TOGGLE_CONTROLLER

    void setToggleState(const bool toggleState);
#endif

#ifdef RANGE_CONTROLLER

    void setRangeValue(const int rangeValue);
#endif

#ifdef MODE_CONTROLLER

    void setMode(const std::string mode);
#endif

    void stopMicrophone();

    void startMicrophone();

    void diagnosticsControl();

    void devicePropertiesControl();

    void showDeviceProperties();

    void audioInjectionControl();

    void injectWavFile(const std::string& absoluteFilePath);

    void deviceProtocolTraceControl();

    void printProtocolTrace();

    void setProtocolTraceFlag(bool enabled);

    void clearProtocolTrace();

    void sendDeviceSetupComplete();

private:
    std::shared_ptr<defaultClient::DefaultClient> m_client;

    std::shared_ptr<applicationUtilities::resources::audio::MicrophoneInterface> m_micWrapper;

    std::shared_ptr<UIManager> m_userInterface;

    std::shared_ptr<avsCommon::sdkInterfaces::CallManagerInterface> m_callManager;

#ifdef ENABLE_PCC
    std::shared_ptr<phoneCallControllerAdapter::PhoneCaller> m_phoneCaller;
#endif

#ifdef ENABLE_MCC
    std::shared_ptr<meetingClientControllerAdapter::MeetingClient> m_meetingClient;
    std::shared_ptr<meetingClientControllerAdapter::CalendarClient> m_calendarClient;
#endif

    std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::SpeechInteractionHandlerInterface>
        m_holdToTalkSpeechInteractionHandler;

    capabilityAgents::aip::AudioProvider m_holdToTalkAudioProvider;

    capabilityAgents::aip::AudioProvider m_tapToTalkAudioProvider;

    capabilityAgents::aip::AudioProvider m_wakeWordAudioProvider;

#ifdef POWER_CONTROLLER
    std::shared_ptr<PeripheralEndpointPowerControllerHandler> m_powerControllerHandler;
#endif

#ifdef TOGGLE_CONTROLLER
    std::shared_ptr<PeripheralEndpointToggleControllerHandler> m_toggleControllerHandler;
#endif

#ifdef RANGE_CONTROLLER
    std::shared_ptr<PeripheralEndpointRangeControllerHandler> m_rangeControllerHandler;
#endif

#ifdef MODE_CONTROLLER
    std::shared_ptr<PeripheralEndpointModeControllerHandler> m_modeControllerHandler;
#endif

    bool m_isHoldOccurring;

    bool m_isTapOccurring;

    bool m_isCallConnected;

    bool m_isMicOn;

    avsCommon::utils::Optional<avsCommon::sdkInterfaces::endpoints::EndpointIdentifier> m_dynamicEndpointId;
#ifdef ENABLE_ENDPOINT_CONTROLLERS
    bool m_friendlyNameToggle;
#endif

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

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

    void doShutdown() override;

    void sendGuiToggleEvent(avsCommon::avs::PlaybackToggle toggleType, bool action);
};

}  // namespace common
}  // namespace sampleApplications
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_INTERACTIONMANAGER_INCLUDE_ACSDK_SAMPLE_INTERACTIONMANAGER_INTERACTIONMANAGER_H_