CommunicationProperty.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 ACSDKCOMMUNICATIONINTERFACES_COMMUNICATIONPROPERTY_H_
#define ACSDKCOMMUNICATIONINTERFACES_COMMUNICATIONPROPERTY_H_

#include <functional>

#include <AVSCommon/Utils/Logger/Logger.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <acsdkCommunicationInterfaces/CommunicationPropertyChangeSubscriber.h>
#include <acsdk/Notifier/Notifier.h>

namespace alexaClientSDK {
namespace acsdkCommunicationInterfaces {

template <typename T>
class CommunicationProperty {
public:
    bool setValue(T newValue) {
        std::unique_lock<std::mutex> lock(m_propertyMutex);
        m_value = newValue;
        auto weakSubscriptionProxy = m_weakSubscriptionProxy;
        auto propertyName = m_name;
        m_staticExecutor.execute([weakSubscriptionProxy, newValue, propertyName]() {
            weakSubscriptionProxy->notifyObservers(
                [=](const std::shared_ptr<CommunicationPropertyChangeSubscriber<T>>& obs) {
                    obs->onCommunicationPropertyChange(propertyName, newValue);
                });
        });
        return true;
    }

    T getValue() {
        std::unique_lock<std::mutex> lock(m_propertyMutex);
        return m_value;
    }

    static std::shared_ptr<CommunicationProperty<T>> create(const std::string& name, T initValue, bool writeable) {
        return std::shared_ptr<CommunicationProperty<T>>(new CommunicationProperty(name, initValue, writeable));
    }

    bool isWriteable() {
        return m_writeable;
    }

    bool addSubscriber(const std::weak_ptr<CommunicationPropertyChangeSubscriber<T>>& subscriber) {
        m_weakSubscriptionProxy->addWeakPtrObserver(subscriber);
        return !subscriber.expired();
    }

    void removeSubscriber(const std::shared_ptr<CommunicationPropertyChangeSubscriber<T>>& subscriber) {
        m_weakSubscriptionProxy->removeWeakPtrObserver(subscriber);
    }

private:
    bool notifyOnCommunicationPropertyChange(const std::string& propertyName, T newValue) {
        m_weakSubscriptionProxy->notifyObservers(
            [=](const std::shared_ptr<CommunicationPropertyChangeSubscriber<T>>& obs) {
                obs->onCommunicationPropertyChange(propertyName, newValue);
            });
        return true;
    }

    CommunicationProperty<T>(std::string name, T initValue, bool writeable) :
            m_weakSubscriptionProxy{std::make_shared<notifier::Notifier<CommunicationPropertyChangeSubscriber<T>>>()},
            m_name{std::move(name)},
            m_value{std::move(initValue)},
            m_writeable{writeable} {
    }

private:
    const std::shared_ptr<notifier::Notifier<CommunicationPropertyChangeSubscriber<T>>> m_weakSubscriptionProxy;

    const std::string m_name;

    T m_value;

    const bool m_writeable;

    std::mutex m_propertyMutex;

    static avsCommon::utils::threading::Executor m_staticExecutor;
};

template <typename T>
avsCommon::utils::threading::Executor CommunicationProperty<T>::m_staticExecutor;

}  // namespace acsdkCommunicationInterfaces
}  // namespace alexaClientSDK

#endif  // ACSDKCOMMUNICATIONINTERFACES_COMMUNICATIONPROPERTY_H_