ArtifactWrapper.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 ACSDKASSETMANAGERCLIENT_ARTIFACTWRAPPER_H_
#define ACSDKASSETMANAGERCLIENT_ARTIFACTWRAPPER_H_

#include <acsdk/Notifier/Notifier.h>

#include <condition_variable>
#include <memory>
#include <mutex>
#include <string>

#include "acsdkAssetManagerClientInterfaces/ArtifactUpdateValidator.h"
#include "acsdkAssetManagerClientInterfaces/ArtifactWrapperInterface.h"
#include "acsdkAssetsInterfaces/ArtifactRequest.h"
#include "acsdkAssetsInterfaces/Communication/AmdCommunicationInterface.h"
#include "acsdkAssetsInterfaces/Priority.h"
#include "acsdkAssetsInterfaces/State.h"

namespace alexaClientSDK {
namespace acsdkAssets {
namespace client {

class ArtifactWrapper
        : public clientInterfaces::ArtifactWrapperInterface
        , public notifier::Notifier<clientInterfaces::ArtifactChangeObserver>
        , public acsdkCommunicationInterfaces::CommunicationPropertyChangeSubscriber<int>
        , public acsdkCommunicationInterfaces::CommunicationPropertyChangeSubscriber<std::string> {
public:
    static std::shared_ptr<ArtifactWrapper> create(
            const std::shared_ptr<commonInterfaces::AmdCommunicationInterface>& amdComm,
            const std::shared_ptr<commonInterfaces::ArtifactRequest>& request,
            const std::shared_ptr<clientInterfaces::ArtifactUpdateValidator>& updateValidator = nullptr);

    ~ArtifactWrapper() override = default;

    inline bool operator==(const ArtifactWrapper& rhs) const {
        return m_request->getSummary() == rhs.m_request->getSummary();
    }

    inline bool operator!=(const ArtifactWrapper& rhs) const {
        return !(rhs == *this);
    }

    inline std::string name() const override {
        return m_request->getSummary();
    }

    bool download() const override;

    inline bool isAvailable() const override {
        std::lock_guard<std::mutex> lock(m_stateMutex);
        return m_state == commonInterfaces::State::LOADED;
    }

    inline bool isPending() const override {
        std::lock_guard<std::mutex> lock(m_stateMutex);
        return m_state == commonInterfaces::State::INIT || m_state == commonInterfaces::State::REQUESTING ||
               m_state == commonInterfaces::State::DOWNLOADING;
    }

    inline std::shared_ptr<commonInterfaces::ArtifactRequest> getRequest() const override {
        return m_request;
    }

    std::string getPath() const override;

    commonInterfaces::Priority getPriority() const override;

    bool setPriority(commonInterfaces::Priority priority) override;

    void erase() override;

    void addWeakPtrObserver(const std::weak_ptr<clientInterfaces::ArtifactChangeObserver>& observer) override {
        return notifier::Notifier<clientInterfaces::ArtifactChangeObserver>::addWeakPtrObserver(observer);
    }

    void removeWeakPtrObserver(const std::weak_ptr<clientInterfaces::ArtifactChangeObserver>& observer) override {
        return notifier::Notifier<clientInterfaces::ArtifactChangeObserver>::removeWeakPtrObserver(observer);
    }

private:
    ArtifactWrapper(
            std::shared_ptr<commonInterfaces::AmdCommunicationInterface> amdComm,
            std::shared_ptr<commonInterfaces::ArtifactRequest> request,
            const std::shared_ptr<clientInterfaces::ArtifactUpdateValidator>& updateValidator = nullptr);

    void onCommunicationPropertyChange(const std::string& PropertyName, int newValue) override;
    void onCommunicationPropertyChange(const std::string& PropertyName, std::string newValue) override;

    void onAmdInit();

    void onStateChange(commonInterfaces::State newState);

    void onUpdateAvailable(const std::string& newPath);

private:
    const std::shared_ptr<commonInterfaces::AmdCommunicationInterface> m_amdComm;
    const std::shared_ptr<commonInterfaces::ArtifactRequest> m_request;
    const std::weak_ptr<clientInterfaces::ArtifactUpdateValidator> m_updateValidator;

    commonInterfaces::State m_state;
    commonInterfaces::Priority m_desiredPriority;
    mutable std::mutex m_stateMutex;
    mutable std::condition_variable m_stateTrigger;
};

}  // namespace client
}  // namespace acsdkAssets
}  // namespace alexaClientSDK

#endif  // ACSDKASSETMANAGERCLIENT_ARTIFACTWRAPPER_H_