SpeakerManager.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_CAPABILITYAGENTS_SPEAKERMANAGER_INCLUDE_SPEAKERMANAGER_SPEAKERMANAGER_H_
#define ALEXA_CLIENT_SDK_CAPABILITYAGENTS_SPEAKERMANAGER_INCLUDE_SPEAKERMANAGER_SPEAKERMANAGER_H_
 
#include <future>
#include <map>
#include <memory>
#include <unordered_set>
#include <vector>
 
#include <acsdkManufactory/Annotated.h>
#include <acsdkShutdownManagerInterfaces/ShutdownNotifierInterface.h>
#include <AVSCommon/AVS/AVSDirective.h>
#include <AVSCommon/AVS/CapabilityAgent.h>
#include <AVSCommon/AVS/CapabilityConfiguration.h>
#include <AVSCommon/SDKInterfaces/CapabilityConfigurationInterface.h>
#include <AVSCommon/SDKInterfaces/ContextManagerInterface.h>
#include <AVSCommon/SDKInterfaces/MessageSenderInterface.h>
#include <AVSCommon/SDKInterfaces/SpeakerManagerInterface.h>
#include <AVSCommon/SDKInterfaces/SpeakerManagerObserverInterface.h>
#include <AVSCommon/SDKInterfaces/Storage/MiscStorageInterface.h>
#include <AVSCommon/SDKInterfaces/Endpoints/DefaultEndpointAnnotation.h>
#include <AVSCommon/SDKInterfaces/Endpoints/EndpointCapabilitiesRegistrarInterface.h>
#include <AVSCommon/Utils/functional/hash.h>
#include <AVSCommon/Utils/Metrics/MetricRecorderInterface.h>
#include <AVSCommon/Utils/RequiresShutdown.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <AVSCommon/Utils/RetryTimer.h>
#include <AVSCommon/Utils/WaitEvent.h>
#include <SpeakerManager/SpeakerManagerStorageInterface.h>
#include <SpeakerManager/SpeakerManagerStorageState.h>
#include <SpeakerManager/SpeakerManagerConfigHelper.h>
 
namespace alexaClientSDK {
namespace capabilityAgents {
namespace speakerManager {
 
class SpeakerManager
        : public avsCommon::avs::CapabilityAgent
        , public avsCommon::sdkInterfaces::CapabilityConfigurationInterface
        , public avsCommon::sdkInterfaces::SpeakerManagerInterface
        , public avsCommon::utils::RequiresShutdown {
public:
    static std::shared_ptr<SpeakerManagerInterface> createSpeakerManagerCapabilityAgent(
        const std::shared_ptr<avsCommon::sdkInterfaces::storage::MiscStorageInterface>& storage,
        const std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface>& contextManager,
        const std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface>& messageSender,
        const std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface>&
            exceptionEncounteredSender,
        const std::shared_ptr<acsdkShutdownManagerInterfaces::ShutdownNotifierInterface>& shutdownNotifier,
        const acsdkManufactory::Annotated<
            avsCommon::sdkInterfaces::endpoints::DefaultEndpointAnnotation,
            avsCommon::sdkInterfaces::endpoints::EndpointCapabilitiesRegistrarInterface>& endpointCapabilitiesRegistrar,
        const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface>& metricRecorder);
 
    static std::shared_ptr<SpeakerManager> create(
        const std::shared_ptr<SpeakerManagerStorageInterface>& storage,
        const std::vector<std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface>>& volumeInterfaces,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionEncounteredSender,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr);
 
    avsCommon::avs::DirectiveHandlerConfiguration getConfiguration() const override;
    void handleDirectiveImmediately(std::shared_ptr<avsCommon::avs::AVSDirective> directive) override;
    void preHandleDirective(std::shared_ptr<avsCommon::avs::CapabilityAgent::DirectiveInfo> info) override;
    void handleDirective(std::shared_ptr<avsCommon::avs::CapabilityAgent::DirectiveInfo> info) override;
    void cancelDirective(std::shared_ptr<avsCommon::avs::CapabilityAgent::DirectiveInfo> info) override;
 
    // @name RequiresShutdown Functions
    void doShutdown() override;
 
    // @name SpeakerManagerInterface Functions
    std::future<bool> setVolume(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        int8_t volume,
        const NotificationProperties& properties) override;
    std::future<bool> adjustVolume(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        int8_t delta,
        const NotificationProperties& properties) override;
    std::future<bool> setMute(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        bool mute,
        const NotificationProperties& properties) override;
    std::future<bool> setVolume(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        int8_t volume,
        bool forceNoNotifications = false,
        avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source source =
            avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source::LOCAL_API) override;
    std::future<bool> adjustVolume(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        int8_t delta,
        bool forceNoNotifications = false,
        avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source source =
            avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source::LOCAL_API) override;
    std::future<bool> setMute(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        bool mute,
        bool forceNoNotifications = false,
        avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source source =
            avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source::LOCAL_API) override;
 
#ifdef ENABLE_MAXVOLUME_SETTING
    std::future<bool> setMaximumVolumeLimit(const int8_t maximumVolumeLimit) override;
#endif
    std::future<bool> getSpeakerSettings(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings* settings) override;
    void addSpeakerManagerObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerObserverInterface> observer) override;
    void removeSpeakerManagerObserver(
        std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerObserverInterface> observer) override;
    void addChannelVolumeInterface(
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface> channelVolumeInterface) override;
 
    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> getCapabilityConfigurations() override;
 
private:
    SpeakerManager(
        const std::shared_ptr<SpeakerManagerStorageInterface>& speakerManagerStorage,
        const std::vector<std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface>>& groupVolumeInterfaces,
        std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> contextManager,
        std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> messageSender,
        std::shared_ptr<avsCommon::sdkInterfaces::ExceptionEncounteredSenderInterface> exceptionEncounteredSender,
        std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder);
 
    struct ChannelVolumeInterfaceHash {
    public:
        size_t operator()(const std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface>& key) const {
            if (nullptr == key) {
                return 0;
            }
            return key->getId();
        }
    };
 
    struct ChannelVolumeInterfaceEqualTo {
    public:
        bool operator()(
            const std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface> channelVolumeInterface1,
            std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface> channelVolumeInterface2) const {
            if (!channelVolumeInterface1 || !channelVolumeInterface2) {
                return true;
            }
            return channelVolumeInterface1->getId() == channelVolumeInterface2->getId();
        }
    };
 
    using SpeakerSet = std::unordered_set<
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface>,
        ChannelVolumeInterfaceHash,
        ChannelVolumeInterfaceEqualTo>;
 
    void addChannelVolumeInterfaceIntoSpeakerMap(
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelVolumeInterface> channelVolumeInterface);
 
    bool parseDirectivePayload(std::string payload, rapidjson::Document* document);
 
    void executeSetHandlingCompleted(std::shared_ptr<DirectiveInfo> info);
 
    void removeDirective(std::shared_ptr<DirectiveInfo> info);
 
    void sendExceptionEncountered(
        std::shared_ptr<CapabilityAgent::DirectiveInfo> info,
        const std::string& message,
        avsCommon::avs::ExceptionErrorType type);
 
    bool updateContextManager(
        const avsCommon::sdkInterfaces::ChannelVolumeInterface::Type& type,
        const avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings& settings);
 
    void executeSendSpeakerSettingsChangedEvent(
        const std::string& eventName,
        avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings settings);
 
    bool executeSetVolume(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        int8_t volume,
        const avsCommon::sdkInterfaces::SpeakerManagerInterface::NotificationProperties& properties);
 
    bool executeRestoreVolume(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source source);
 
    bool executeAdjustVolume(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        int8_t delta,
        const avsCommon::sdkInterfaces::SpeakerManagerInterface::NotificationProperties& properties);
 
    bool executeSetMute(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        bool mute,
        const avsCommon::sdkInterfaces::SpeakerManagerInterface::NotificationProperties& properties);
 
#ifdef ENABLE_MAXVOLUME_SETTING
 
    bool executeSetMaximumVolumeLimit(const int8_t maximumVolumeLimit);
#endif  // ENABLE_MAXVOLUME_SETTING
 
    bool executeGetSpeakerSettings(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings* settings);
 
    bool executeSetSpeakerSettings(
        const avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        const avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings& settings);
 
    bool executeInitializeSpeakerSettings(avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type);
 
    void executeNotifySettingsChanged(
        const avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings& settings,
        const std::string& eventName,
        const avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source& source,
        const avsCommon::sdkInterfaces::ChannelVolumeInterface::Type& type);
 
    void executeNotifyObserver(
        const avsCommon::sdkInterfaces::SpeakerManagerObserverInterface::Source& source,
        const avsCommon::sdkInterfaces::ChannelVolumeInterface::Type& type,
        const avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings& settings);
 
    void executePersistConfiguration();
 
    void convertSettingsToChannelState(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        SpeakerManagerStorageState::ChannelState* storageState);
 
    int8_t getMaximumVolumeLimit();
 
    template <typename Task, typename... Args>
    bool retryAndApplySettings(Task task, Args&&... args);
 
    void presetChannelDefaults(
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type,
        const SpeakerManagerStorageState::ChannelState& state);
 
    void loadConfiguration();
 
    void updateChannelSettings();
 
    void updateChannelSettings(avsCommon::sdkInterfaces::ChannelVolumeInterface::Type type);
 
    int8_t adjustVolumeRange(int64_t volume);
 
    SpeakerManagerConfigHelper m_config;
 
    std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> m_metricRecorder;
 
    std::shared_ptr<avsCommon::sdkInterfaces::ContextManagerInterface> m_contextManager;
 
    std::shared_ptr<avsCommon::sdkInterfaces::MessageSenderInterface> m_messageSender;
 
    int m_minUnmuteVolume;
 
    std::unordered_map<
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type,
        SpeakerSet,
        avsCommon::utils::functional::EnumClassHash>
        m_speakerMap;
 
    std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::SpeakerManagerObserverInterface>> m_observers;
 
    std::unordered_set<std::shared_ptr<avsCommon::avs::CapabilityConfiguration>> m_capabilityConfigurations;
 
    avsCommon::utils::WaitEvent m_waitCancelEvent;
 
    avsCommon::utils::RetryTimer m_retryTimer;
 
    const std::size_t m_maxRetries;
 
    int8_t m_maximumVolumeLimit;
 
    bool m_restoreMuteState;
 
    std::map<
        avsCommon::sdkInterfaces::ChannelVolumeInterface::Type,
        avsCommon::sdkInterfaces::SpeakerInterface::SpeakerSettings>
        m_speakerSettings;
 
    avsCommon::utils::threading::Executor m_executor;
};
 
}  // namespace speakerManager
}  // namespace capabilityAgents
}  // namespace alexaClientSDK
 
#endif  // ALEXA_CLIENT_SDK_CAPABILITYAGENTS_SPEAKERMANAGER_INCLUDE_SPEAKERMANAGER_SPEAKERMANAGER_H_