SettingsManager.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_SETTINGS_INCLUDE_SETTINGS_SETTINGSMANAGER_H_
#define ALEXA_CLIENT_SDK_SETTINGS_INCLUDE_SETTINGS_SETTINGSMANAGER_H_

#include <cstddef>
#include <memory>
#include <mutex>
#include <type_traits>
#include <utility>

#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/Logger/LogEntry.h>
#include <AVSCommon/Utils/Logger/LoggerUtils.h>
#include <RegistrationManager/CustomerDataHandler.h>

#include "Settings/SettingEventMetadata.h"
#include "Settings/SettingInterface.h"
#include "Settings/SettingStringConversion.h"

namespace alexaClientSDK {
namespace settings {

template <typename SettingsT>
struct SettingConfiguration {
    std::shared_ptr<SettingsT> setting;
    avsCommon::utils::Optional<settings::SettingEventMetadata> metadata;
};

template <typename... SettingsT>
class SettingsManager : public registrationManager::CustomerDataHandler {
public:
    template <size_t index>
    using SettingType = typename std::tuple_element<index, std::tuple<SettingsT...>>::type;

    template <size_t index>
    using ValueType = typename SettingType<index>::ValueType;

    template <size_t index>
    using ObserverType = typename SettingType<index>::ObserverType;

    template <typename SettingT>
    using SettingPointerType = std::shared_ptr<SettingT>;

    using SettingConfigurations = std::tuple<SettingConfiguration<SettingsT>...>;

    static constexpr size_t NUMBER_OF_SETTINGS{sizeof...(SettingsT)};

    SettingsManager(
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> dataManager,
        SettingConfigurations settingConfigurations);

    SettingsManager(std::shared_ptr<registrationManager::CustomerDataManagerInterface> dataManager);

    virtual ~SettingsManager() = default;

    template <size_t index>
    SetSettingResult setValue(const ValueType<index>& value);

    template <size_t index>
    std::pair<bool, ValueType<index>> getValue(const ValueType<index>& defaultValue = ValueType<index>()) const;

    template <size_t index>
    std::string getJsonValue() const;

    template <size_t index>
    bool addObserver(std::shared_ptr<ObserverType<index>> observer);

    template <size_t index>
    void removeObserver(std::shared_ptr<ObserverType<index>> observer);

    template <size_t index>
    bool addSetting(std::shared_ptr<SettingType<index>> setting);

    template <size_t index>
    void removeSetting(std::shared_ptr<SettingType<index>> setting);

    template <size_t index>
    bool hasSetting();

    SettingConfigurations getConfigurations() const;

    template <size_t index>
    std::shared_ptr<SettingType<index>> getSetting() const;

    void clearData() override;

private:
    using LogEntry = avsCommon::utils::logger::LogEntry;

    template <size_t index>
    typename std::enable_if<index >= NUMBER_OF_SETTINGS, void>::type doClearData() {
    }

    template <size_t index>
    typename std::enable_if<index <= NUMBER_OF_SETTINGS - 1, void>::type doClearData() {
        auto& setting = std::get<index>(m_settings);
        if (setting) {
            if (!setting->clearData(setting->getDefault())) {
                avsCommon::utils::logger::acsdkError(LogEntry("SettingManager", "clearDataFailed")
                                                         .d("reason", "invalidSetting")
                                                         .d("settingIndex", index));
            }
        } else {
            avsCommon::utils::logger::acsdkDebug0(
                LogEntry("SettingManager", __func__).d("reason", "invalidSetting").d("settingIndex", index));
        }
        doClearData<index + 1>();
    }

    SettingsManager(const SettingsManager&) = delete;

    SettingsManager& operator=(const SettingsManager&) = delete;

    mutable std::mutex m_mutex;

    // A tuple with all the settings supported by this manager.
    std::tuple<SettingPointerType<SettingsT>...> m_settings;

    SettingConfigurations m_settingConfigs;
};

template <typename... SettingsT>
SettingsManager<SettingsT...>::SettingsManager(
    std::shared_ptr<registrationManager::CustomerDataManagerInterface> dataManager,
    SettingConfigurations settingConfiguration) :
        CustomerDataHandler{dataManager},
        m_settingConfigs{settingConfiguration} {
}

template <typename... SettingsT>
SettingsManager<SettingsT...>::SettingsManager(
    std::shared_ptr<registrationManager::CustomerDataManagerInterface> dataManager) :
        CustomerDataHandler{dataManager} {
}

template <typename... SettingsT>
template <size_t index>
std::pair<bool, typename SettingsManager<SettingsT...>::template ValueType<index>> SettingsManager<
    SettingsT...>::getValue(const ValueType<index>& defaultValue) const {
    std::lock_guard<std::mutex> lock{m_mutex};
    auto& setting = std::get<index>(m_settings);
    if (setting) {
        return {true, setting->get()};
    }

    avsCommon::utils::logger::acsdkError(
        LogEntry("SettingManager", "getValueFailed").d("reason", "invalidSetting").d("settingIndex", index));
    return {false, defaultValue};
}

template <typename... SettingsT>
template <size_t index>
std::string SettingsManager<SettingsT...>::getJsonValue() const {
    std::lock_guard<std::mutex> lock{m_mutex};
    auto& setting = std::get<index>(m_settings);
    if (setting) {
        auto result = toSettingString<ValueType<index>>(setting->get());
        if (!result.first) {
            avsCommon::utils::logger::acsdkError(LogEntry("SettingManager", "getStringValueFailed")
                                                     .d("reason", "toSettingStringFailed")
                                                     .d("settingIndex", index));
            return std::string();
        }
        return result.second;
    }

    avsCommon::utils::logger::acsdkDebug0(
        LogEntry("SettingManager", __func__).d("result", "noSettingAvailable").d("settingIndex", index));
    return std::string();
}

template <typename... SettingsT>
template <size_t index>
SetSettingResult SettingsManager<SettingsT...>::setValue(const ValueType<index>& value) {
    std::lock_guard<std::mutex> lock{m_mutex};
    auto& setting = std::get<index>(m_settings);
    if (setting) {
        return setting->setLocalChange(value);
    }

    avsCommon::utils::logger::acsdkError(
        LogEntry("SettingManager", "setValueFailed").d("reason", "invalidSetting").d("settingIndex", index));
    return SetSettingResult::UNAVAILABLE_SETTING;
}

template <typename... SettingsT>
template <size_t index>
bool SettingsManager<SettingsT...>::addObserver(std::shared_ptr<ObserverType<index>> observer) {
    std::lock_guard<std::mutex> lock{m_mutex};
    auto& setting = std::get<index>(m_settings);
    if (setting && observer) {
        return setting->addObserver(observer);
    }

    avsCommon::utils::logger::acsdkError(
        LogEntry("SettingManager", "addObserverFailed").d("reason", "invalidSetting").d("settingIndex", index));
    return false;
}

template <typename... SettingsT>
template <size_t index>
void SettingsManager<SettingsT...>::removeObserver(std::shared_ptr<ObserverType<index>> observer) {
    std::lock_guard<std::mutex> lock{m_mutex};
    auto& setting = std::get<index>(m_settings);
    if (setting && observer) {
        setting->removeObserver(observer);
        return;
    }

    avsCommon::utils::logger::acsdkError(
        LogEntry("SettingManager", "removeObserverFailed").d("reason", "invalidSetting").d("settingIndex", index));
}

template <typename... SettingsT>
template <size_t index>
bool SettingsManager<SettingsT...>::addSetting(std::shared_ptr<SettingType<index>> newSetting) {
    std::lock_guard<std::mutex> lock{m_mutex};
    auto& setting = std::get<index>(m_settings);
    if (!setting && newSetting) {
        setting.swap(newSetting);
        return true;
    }

    avsCommon::utils::logger::acsdkError(
        LogEntry("SettingManager", "addSettingFailed").d("reason", "invalidSetting").d("settingIndex", index));
    return false;
}

template <typename... SettingsT>
template <size_t index>
void SettingsManager<SettingsT...>::removeSetting(std::shared_ptr<SettingType<index>> oldSetting) {
    std::lock_guard<std::mutex> lock{m_mutex};
    auto& setting = std::get<index>(m_settings);
    if (setting == oldSetting) {
        setting.reset();
    } else {
        avsCommon::utils::logger::acsdkError(
            LogEntry("SettingManager", "removeSettingFailed").d("reason", "invalidSetting").d("settingIndex", index));
    }
}

template <typename... SettingsT>
template <size_t index>
bool SettingsManager<SettingsT...>::hasSetting() {
    std::lock_guard<std::mutex> lock{m_mutex};
    return std::get<index>(m_settings);
}

template <typename... SettingsT>
void SettingsManager<SettingsT...>::clearData() {
    std::lock_guard<std::mutex> lock{m_mutex};
    doClearData<0>();
}

template <typename... SettingsT>
std::tuple<SettingConfiguration<SettingsT>...> SettingsManager<SettingsT...>::getConfigurations() const {
    return m_settingConfigs;
}

template <typename... SettingsT>
template <size_t index>
std::shared_ptr<typename SettingsManager<SettingsT...>::template SettingType<index>> SettingsManager<
    SettingsT...>::getSetting() const {
    return std::get<index>(m_settingConfigs).setting;
}

}  // namespace settings
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_SETTINGS_INCLUDE_SETTINGS_SETTINGSMANAGER_H_