DavsClient.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 ACSDKDAVSCLIENT_DAVSCLIENT_H_
#define ACSDKDAVSCLIENT_DAVSCLIENT_H_
 
#include <AVSCommon/SDKInterfaces/InternetConnectionMonitorInterface.h>
#include <AVSCommon/SDKInterfaces/InternetConnectionObserverInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <unordered_map>
#include "DavsHandler.h"
#include "acsdkDavsClientInterfaces/DavsEndpointHandlerInterface.h"
 
namespace alexaClientSDK {
namespace acsdkAssets {
namespace davs {
 
class DavsClient
        : public davsInterfaces::ArtifactHandlerInterface
        , public alexaClientSDK::avsCommon::sdkInterfaces::InternetConnectionObserverInterface {
public:
    ~DavsClient() override = default;
 
    static std::shared_ptr<DavsClient> create(
            std::string workingDirectory,
            std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> authDelegate,
            std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::InternetConnectionMonitorInterface> wifiMonitor,
            std::shared_ptr<davsInterfaces::DavsEndpointHandlerInterface> davsEndpointHandler,
            std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr,
            std::chrono::seconds forcedUpdateInterval = std::chrono::seconds(0));
 
    bool getIdleState() const;
 
    void setIdleState(bool idleState);
 
    std::string registerArtifact(
            std::shared_ptr<commonInterfaces::DavsRequest> artifactRequest,
            std::shared_ptr<davsInterfaces::DavsDownloadCallbackInterface> downloadCallback,
            std::shared_ptr<davsInterfaces::DavsCheckCallbackInterface> checkCallback,
            bool downloadImmediately) override;
    void deregisterArtifact(const std::string& requestUUID) override;
    std::string downloadOnce(
            std::shared_ptr<commonInterfaces::DavsRequest> artifactRequest,
            std::shared_ptr<davsInterfaces::DavsDownloadCallbackInterface> downloadCallback,
            std::shared_ptr<davsInterfaces::DavsCheckCallbackInterface> checkCallback) override;
    void enableAutoUpdate(const std::string& requestUUID, bool enable) override;
 
    void onConnectionStatusChanged(bool connected) override;
 
    /***
     * Information from parsed Json Artifact Push Notification
     */
    struct ArtifactGroup {
        std::string type;
        std::string key;
    };
 
    /***
     * Take a json containing list of artifact group
     * Parse the json. E.g:{"artifactList":[{"type":"test","key":"tar"}]}
     * Then check and update the corresponding artifact
     * @param jsonArtifactList
     */
    void checkAndUpdateArtifactGroupFromJson(const std::string& jsonArtifactList);
 
    /***
     * Take a vector of ArtifactGroup and iterate every Artifact to check and then update
     * @param artifactVector containing artifact requesting to be updated
     */
    void checkAndUpdateArtifactGroupVector(const std::vector<DavsClient::ArtifactGroup>& artifactVector);
 
private:
    DavsClient(
            std::string workingDirectory,
            std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> authDelegate,
            std::shared_ptr<davsInterfaces::DavsEndpointHandlerInterface> davsEndpointHandler,
            std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> metricRecorder = nullptr,
            std::chrono::seconds forcedUpdateInterval = std::chrono::seconds(0));
 
    std::string handleRequest(
            std::shared_ptr<commonInterfaces::DavsRequest> artifactRequest,
            std::shared_ptr<davsInterfaces::DavsDownloadCallbackInterface> downloadCallback,
            std::shared_ptr<davsInterfaces::DavsCheckCallbackInterface> checkCallback,
            bool enableAutoUpdate,
            bool downloadImmediately);
 
    /***
     * Check below if an artifact requesting update before do it:
     * + Still relevant
     * + Enabled update
     * + Registered
     * @param artifactGroup that is requesting an update
     */
    void executeUpdateRegisteredArtifact(const ArtifactGroup& artifactGroup);
 
    std::vector<ArtifactGroup> executeParseArtifactGroupFromJson(const std::string& jsonArtifactList);
 
private:
    const std::string m_workingDirectory;
 
    const std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::AuthDelegateInterface> m_authDelegate;
 
    const std::shared_ptr<davsInterfaces::DavsEndpointHandlerInterface> m_davsEndpointHandler;
 
    const std::shared_ptr<avsCommon::utils::metrics::MetricRecorderInterface> m_metricRecorder;
 
    const std::chrono::seconds m_forcedUpdateInterval;
 
    const std::shared_ptr<alexaClientSDK::avsCommon::utils::power::PowerResource> m_powerResource;
 
    std::unordered_map<std::string, std::shared_ptr<DavsHandler>> m_handlers;
 
    alexaClientSDK::avsCommon::utils::threading::Executor m_executor;
 
    bool m_isDeviceIdle;
    bool m_isConnected;
};
 
}  // namespace davs
}  // namespace acsdkAssets
}  // namespace alexaClientSDK
 
#endif  // ACSDKDAVSCLIENT_DAVSCLIENT_H_