Setting.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_SETTING_H_
#define ALEXA_CLIENT_SDK_SETTINGS_INCLUDE_SETTINGS_SETTING_H_

#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <utility>

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

#include "Settings/SetSettingResult.h"
#include "Settings/SettingInterface.h"
#include "Settings/SettingProtocolInterface.h"
#include "Settings/SettingStatus.h"
#include "Settings/SettingStringConversion.h"

namespace alexaClientSDK {
namespace settings {

template <typename ValueT>
class Setting : public SettingInterface<ValueT> {
public:
    using ValueType = ValueT;

    static std::shared_ptr<Setting<ValueT>> create(
        const ValueType& defaultValue,
        std::unique_ptr<SettingProtocolInterface> settingProtocol,
        std::function<bool(const ValueType&)> applyValueFn = std::function<bool(const ValueType&)>());

    SetSettingResult setLocalChange(const ValueType& value) override;
    bool setAvsChange(const ValueType& value) override;
    bool clearData(const ValueType& value) override;

private:
    Setting(
        const ValueType& value,
        std::function<bool(const ValueType&)> applyValueFn,
        std::unique_ptr<SettingProtocolInterface> settingProtocol);

    std::pair<bool, std::string> handleSetValue(const ValueType& value);

    bool restore();

    std::function<bool(const ValueType&)> m_applyFunction;

    std::unique_ptr<SettingProtocolInterface> m_protocol;

    ValueType m_oldValue;

    std::mutex m_mutex;

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

template <typename ValueT>
std::shared_ptr<Setting<ValueT>> Setting<ValueT>::create(
    const ValueType& defaultValue,
    std::unique_ptr<SettingProtocolInterface> settingProtocol,
    std::function<bool(const ValueType&)> applyValueFn) {
    if (!settingProtocol) {
        avsCommon::utils::logger::acsdkError(LogEntry("Setting", "createFailed").d("reason", "nullSettingProtocol"));
        return nullptr;
    }

    auto setting =
        std::shared_ptr<Setting<ValueT>>(new Setting(defaultValue, applyValueFn, std::move(settingProtocol)));

    if (!setting->restore()) {
        avsCommon::utils::logger::acsdkError(LogEntry("Setting", "createFailed").d("reason", "restoreValueFailed"));
        return nullptr;
    }

    return setting;
}

template <typename ValueT>
std::pair<bool, std::string> Setting<ValueT>::handleSetValue(const ValueType& value) {
    bool ok;
    std::string valueStr;
    std::tie(ok, valueStr) = toSettingString<ValueT>(value);
    if (ok && (!this->m_applyFunction || this->m_applyFunction(value))) {
        avsCommon::utils::logger::acsdkInfo(LogEntry("Setting", __func__).obfuscatePrivateData("value", valueStr));
        m_oldValue = this->m_value;
        this->m_value = value;
        return {true, valueStr};
    }
    avsCommon::utils::logger::acsdkError(LogEntry("Setting", "setValueFailed").d("reason", "applyFailed"));
    return {false, toSettingString<ValueType>(this->m_value).second};
}

template <typename ValueT>
bool Setting<ValueT>::setAvsChange(const ValueType& value) {
    auto executeSet = [this, value] {
        std::lock_guard<std::mutex> lock{m_mutex};
        return this->handleSetValue(value);
    };
    auto revertChange = [this] {
        std::lock_guard<std::mutex> lock{m_mutex};
        auto oldValue = m_oldValue;
        return this->handleSetValue(oldValue).second;
    };
    auto notifyObservers = [this](SettingNotifications notification) { this->notifyObservers(notification); };
    return m_protocol->avsChange(executeSet, revertChange, notifyObservers);
}

template <typename ValueT>
SetSettingResult Setting<ValueT>::setLocalChange(const ValueType& value) {
    auto executeSet = [this, value] {
        std::lock_guard<std::mutex> lock{m_mutex};
        return this->handleSetValue(value);
    };
    auto revertChange = [this] {
        std::lock_guard<std::mutex> lock{m_mutex};
        auto oldValue = m_oldValue;
        return this->handleSetValue(oldValue).second;
    };
    auto notifyObservers = [this](SettingNotifications notification) { this->notifyObservers(notification); };
    return m_protocol->localChange(executeSet, revertChange, notifyObservers);
}

template <typename ValueT>
bool Setting<ValueT>::clearData(const ValueType& value) {
    std::unique_lock<std::mutex> lock{m_mutex};
    this->m_value = value;
    // Clear customer's data before restoring the initial value
    auto result = m_protocol->clearData();
    lock.unlock();
    if (result) {
        // this->m_value (initial value) is restored
        // as databaseValue.empty() == true
        restore();
    }
    return result;
}

template <typename ValueT>
bool Setting<ValueT>::restore() {
    auto applyChange = [this](const std::string& databaseValue) -> std::pair<bool, std::string> {
        bool convertOk, setOk;
        ValueT value;
        std::string valueStr;
        if (databaseValue.empty()) {
            convertOk = true;
            value = this->m_value;
        } else {
            std::tie(convertOk, value) = fromSettingString<ValueT>(databaseValue, this->m_value);
        }
        std::lock_guard<std::mutex> lock{m_mutex};
        std::tie(setOk, valueStr) = handleSetValue(value);
        return {convertOk && setOk, valueStr};
    };
    auto notifyObservers = [this](SettingNotifications notification) { this->notifyObservers(notification); };
    return m_protocol->restoreValue(applyChange, notifyObservers);
}

template <typename ValueT>
Setting<ValueT>::Setting(
    const ValueType& value,
    std::function<bool(const ValueType&)> applyValueFn,
    std::unique_ptr<SettingProtocolInterface> settingProtocol) :
        SettingInterface<ValueType>{value},
        m_applyFunction{applyValueFn},
        m_protocol{std::move(settingProtocol)},
        m_oldValue{value} {
}

}  // namespace settings
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_SETTINGS_INCLUDE_SETTINGS_SETTING_H_