AlertsCapabilityAgent.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_ACSDKALERTS_INCLUDE_ACSDKALERTS_ALERTSCAPABILITYAGENT_H_
#define ALEXA_CLIENT_SDK_ACSDKALERTS_INCLUDE_ACSDKALERTS_ALERTSCAPABILITYAGENT_H_

#include <chrono>
#include <set>
#include <string>
#include <unordered_set>

#include <acsdkAlertsInterfaces/AlertsCapabilityAgentInterface.h>
#include <acsdkAlertsInterfaces/AlertObserverInterface.h>
#include <acsdkManufactory/Annotated.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <acsdkSystemClockMonitorInterfaces/SystemClockNotifierInterface.h>
#include <acsdkSystemClockMonitorInterfaces/SystemClockMonitorObserverInterface.h>
#include <AVSCommon/AVS/CapabilityAgent.h>
#include <AVSCommon/AVS/MessageRequest.h>
#include <AVSCommon/AVS/FocusState.h>
#include <AVSCommon/AVS/CapabilityConfiguration.h>
#include <AVSCommon/SDKInterfaces/AudioFocusAnnotation.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/ConnectionStatusObserverInterface.h>
#include <AVSCommon/SDKInterfaces/ContextManagerInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/SDKInterfaces/MessageSenderInterface.h>
#include <AVSCommon/SDKInterfaces/SpeakerManagerInterface.h>
#include <AVSCommon/SDKInterfaces/Audio/AudioFactoryInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/DefaultEndpointAnnotation.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointCapabilitiesRegistrarInterface.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/Timing/Timer.h>
#include <CertifiedSender/CertifiedSender.h>
#include <RegistrationManager/CustomerDataManagerInterface.h>
#include <Settings/DeviceSettingsManager.h>
#include <Settings/Setting.h>
#include <Settings/SettingEventMetadata.h>

#include "acsdkAlerts/Alert.h"
#include "acsdkAlerts/AlertScheduler.h"

namespace alexaClientSDK {
namespace acsdkAlerts {

static const std::chrono::minutes ALERT_PAST_DUE_CUTOFF_MINUTES = std::chrono::minutes(30);

class AlertsCapabilityAgent
        : public avsCommon::avs::CapabilityAgent
        , public avsCommon::sdkInterfaces::ConnectionStatusObserverInterface
        , public avsCommon::sdkInterfaces::CapabilityConfigurationInterface
        , public avsCommon::sdkInterfaces::SpeakerManagerObserverInterface
        , public avsCommon::sdkInterfaces::FocusManagerObserverInterface
        , public acsdkAlertsInterfaces::AlertObserverInterface
        , public acsdkAlertsInterfaces::AlertsCapabilityAgentInterface
        , public acsdkSystemClockMonitorInterfaces::SystemClockMonitorObserverInterface
        , public avsCommon::utils::RequiresShutdown
        , public registrationManager::CustomerDataHandler
        , public std::enable_shared_from_this<AlertsCapabilityAgent> {
public:
    static std::shared_ptr<AlertsCapabilityAgentInterface> createAlertsCapabilityAgent(
        const std::shared_ptr<acsdkAlerts::renderer::Renderer>& alertRenderer,
        const std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface>& shutdownNotifier,
        const std::shared_ptr<avsCommon::sdkInterfaces::AVSConnectionManagerInterface>& connectionManager,
        const std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface>& contextManager,
        const std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface>&
            exceptionEncounteredSender,
        const acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::AudioFocusAnnotation,
            avsCommon::sdkInterfaces::FocusManagerInterface>& audioFocusManager,
        const std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface>& messageSender,
        const std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface>& speakerManager,
        const std::shared_ptr<avsCommon::sdkInterfaces::audio::AudioFactoryInterface>& audioFactory,
        const acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointCapabilitiesRegistrarInterface>& endpointCapabilitiesRegistrar,
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder,
        const std::shared_ptr<acsdkSystemClockMonitorInterfaces::SystemClockNotifierInterface>& systemClockMonitor,
        const std::shared_ptr<certifiedSender::CertifiedSender>& certifiedSender,
        const std::shared_ptr<registrationManager::CustomerDataManagerInterface>& dataManager,
        const std::shared_ptr<settings::DeviceSettingsManager>& settingsManager,
        const std::shared_ptr<storage::AlertStorageInterface>& alertStorage,
        bool startAlertSchedulingOnInitialization = true);

    static std::shared_ptr<AlertsCapabilityAgent> create(
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::AVSConnectionManagerInterface> connectionManager,
        std::shared_ptr<certifiedSender::CertifiedSender> certifiedMessageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> speakerManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionEncounteredSender,
        std::shared_ptr<storage::AlertStorageInterface> alertStorage,
        std::shared_ptr<avsCommon::sdkInterfaces::audio::AlertsAudioFactoryInterface> alertsAudioFactory,
        std::shared_ptr<renderer::RendererInterface> alertRenderer,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> dataManager,
        std::shared_ptr<settings::AlarmVolumeRampSetting> alarmVolumeRampSetting,
        std::shared_ptr<settings::DeviceSettingsManager> settingsManager,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr,
        bool startAlertSchedulingOnInitialization = true,
        std::shared_ptr<acsdkSystemClockMonitorInterfaces::SystemClockNotifierInterface> systemClockMonitor = nullptr);

    avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;

    void handleDirectiveImmediately(std::shared_ptr<avsCommon::avs::AVSDirective> directive) override;

    void preHandleDirective(std::shared_ptr<DirectiveInfo> info) override;

    void handleDirective(std::shared_ptr<DirectiveInfo> info) override;

    void cancelDirective(std::shared_ptr<DirectiveInfo> info) override;

    void onDeregistered() override;

    void onConnectionStatusChanged(const Status status, const ChangedReason reason) override;

    void onFocusChanged(avsCommon::avs::FocusState focusState, avsCommon::avs::MixingBehavior behavior) override;

    void onAlertStateChange(const AlertInfo& alertInfo) override;

    void onFocusChanged(const std::string& channelName, avsCommon::avs::FocusState newFocus) override;

    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> getCapabilityConfigurations() override;

    void onSpeakerSettingsChanged(
        const Source& source,
        const avsCommon::sdkInterfaces::ChannelVolumeInterface::Type& type,
        const avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings& settings) override;

    void onSystemClockSynchronized() override;


    void clearData() override;

    void addObserver(std::shared_ptr<acsdkAlertsInterfaces::AlertObserverInterface> observer) override;
    void removeObserver(std::shared_ptr<acsdkAlertsInterfaces::AlertObserverInterface> observer) override;
    void removeAllAlerts() override;
    void onLocalStop() override;

    static settings::SettingEventMetadata getAlarmVolumeRampMetadata();

    int getAlertVolume();

private:
    AlertsCapabilityAgent(
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<certifiedSender::CertifiedSender> certifiedMessageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> focusManager,
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> speakerManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionEncounteredSender,
        std::shared_ptr<storage::AlertStorageInterface> alertStorage,
        std::shared_ptr<avsCommon::sdkInterfaces::audio::AlertsAudioFactoryInterface> alertsAudioFactory,
        std::shared_ptr<renderer::RendererInterface> alertRenderer,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> dataManager,
        std::shared_ptr<settings::AlarmVolumeRampSetting> alarmVolumeRampSetting,
        std::shared_ptr<settings::DeviceSettingsManager> settingsManager,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder,
        std::shared_ptr<acsdkSystemClockMonitorInterfaces::SystemClockNotifierInterface> systemClockMonitor);

    void doShutdown() override;

    bool initialize(bool startAlertSchedulingOnInitialization = true);

    bool initializeAlerts(bool startAlertSchedulingOnInitialization = true);


    void executeHandleDirectiveImmediately(std::shared_ptr<DirectiveInfo> info);

    void executeOnConnectionStatusChanged(const Status status, const ChangedReason reason);

    void executeOnSpeakerSettingsChanged(
        const avsCommon::sdkInterfaces::ChannelVolumeInterface::Type& type,
        const avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings& settings);

    void executeOnAlertStateChange(const acsdkAlertsInterfaces::AlertObserverInterface::AlertInfo& alertInfo);

    void executeAddObserver(std::shared_ptr<acsdkAlertsInterfaces::AlertObserverInterface> observer);

    void executeRemoveObserver(std::shared_ptr<acsdkAlertsInterfaces::AlertObserverInterface> observer);

    void executeNotifyObservers(const acsdkAlertsInterfaces::AlertObserverInterface::AlertInfo& alertInfo);

    void executeRemoveAllAlerts();

    void executeOnLocalStop();

    bool handleSetAlert(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const rapidjson::Document& payload,
        std::string* alertToken);

    bool handleDeleteAlert(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const rapidjson::Document& payload,
        std::string* alertToken);

    bool handleDeleteAlerts(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const rapidjson::Document& payload);

    bool handleSetVolume(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const rapidjson::Document& payload);

    bool handleAdjustVolume(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const rapidjson::Document& payload);

    bool handleSetAlarmVolumeRamp(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const rapidjson::Document& payload);

    void sendEvent(
        const std::string& eventName,
        const std::string& alertToken,
        bool isCertified = false,
        const std::string& scheduledTime = std::string(),
        const std::string& eventTime = std::string());

    void sendBulkEvent(const std::string& eventName, const std::list<std::string>& tokenList, bool isCertified = false);

    void updateAVSWithLocalVolumeChanges(int8_t volume, bool forceUpdate);

    void sendProcessingDirectiveException(
        const std::shared_ptr<avsCommon::avs::AVSDirective>& directive,
        const std::string& errorMessage);

    void acquireChannel();

    void releaseChannel();

    void updateContextManager();

    std::string getContextString();

    bool getAlertVolumeSettings(avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings* speakerSettings);

    bool getSpeakerVolumeSettings(avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings* speakerSettings);

    void setNextAlertVolume(int64_t volume);

    void submitAlertStartedMetricWithMetadata(const std::string& alertToken, const std::string& alertType);

    void submitAlertCanceledMetricWithMetadata(
        const std::string& alertToken,
        const std::string& alertType,
        const std::string& scheduledTime);


    std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> m_metricRecorder;
    std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> m_messageSender;
    std::shared_ptr<certifiedSender::CertifiedSender> m_certifiedSender;
    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface> m_focusManager;
    std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerInterface> m_speakerManager;
    std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> m_contextManager;

    std::unordered_set<std::shared_ptr<acsdkAlertsInterfaces::AlertObserverInterface>> m_observers;

    bool m_isConnected;

    AlertScheduler m_alertScheduler;


    std::shared_ptr<avsCommon::sdkInterfaces::audio::AlertsAudioFactoryInterface> m_alertsAudioFactory;

    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> m_capabilityConfigurations;

    avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings m_lastReportedSpeakerSettings;

    bool m_contentChannelIsActive;

    bool m_commsChannelIsActive;

    bool m_alertIsSounding;

    std::clock_t m_startSystemClock;

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

    std::shared_ptr<settings::AlarmVolumeRampSetting> m_alarmVolumeRampSetting;

    std::shared_ptr<settings::DeviceSettingsManager> m_settingsManager;

    std::shared_ptr<acsdkSystemClockMonitorInterfaces::SystemClockNotifierInterface> m_systemClockMonitor;
};

}  // namespace acsdkAlerts
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ACSDKALERTS_INCLUDE_ACSDKALERTS_ALERTSCAPABILITYAGENT_H_