CBLAuthDelegate.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 CBLAUTHDELEGATE_CBLAUTHDELEGATE_H_
#define CBLAUTHDELEGATE_CBLAUTHDELEGATE_H_

#include <chrono>
#include <condition_variable>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_set>

#include <AVSCommon/SDKInterfaces/AuthDelegateInterface.h>
#include <AVSCommon/SDKInterfaces/AuthObserverInterface.h>
#include <AVSCommon/Utils/Configuration/ConfigurationNode.h>
#include <AVSCommon/Utils/LibcurlUtils/HttpPostInterface.h>
#include <AVSCommon/Utils/DeviceInfo.h>
#include <AVSCommon/Utils/RetryTimer.h>
#include <RegistrationManager/CustomerDataHandler.h>
#include <acsdkAuthorization/LWA/LWAAuthorizationConfiguration.h>

#include "CBLAuthDelegate/CBLAuthDelegateStorageInterface.h"
#include "CBLAuthDelegate/CBLAuthRequesterInterface.h"

namespace alexaClientSDK {
namespace authorization {
namespace cblAuthDelegate {

class CBLAuthDelegate
        : public avsCommon::sdkInterfaces::AuthDelegateInterface
        , public registrationManager::CustomerDataHandler {
public:
    static std::shared_ptr<AuthDelegateInterface> createAuthDelegateInterface(
        const std::shared_ptr<avsCommon::utils::configuration::ConfigurationNode>& configuration,
        const std::shared_ptr<registrationManager::CustomerDataManagerInterface>& customerDataManager,
        const std::shared_ptr<CBLAuthDelegateStorageInterface>& storage,
        const std::shared_ptr<CBLAuthRequesterInterface>& authRequester,
        std::unique_ptr<avsCommon::utils::libcurlUtils::HttpPostInterface> httpPost,
        const std::shared_ptr<avsCommon::utils::DeviceInfo>& deviceInfo);

    static std::unique_ptr<CBLAuthDelegate> create(
        const avsCommon::utils::configuration::ConfigurationNode& configuration,
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> customerDataManager,
        std::shared_ptr<CBLAuthDelegateStorageInterface> storage,
        std::shared_ptr<CBLAuthRequesterInterface> authRequester,
        std::shared_ptr<avsCommon::utils::libcurlUtils::HttpPostInterface> httpPost = nullptr,
        std::shared_ptr<avsCommon::utils::DeviceInfo> deviceInfo = nullptr);

    CBLAuthDelegate(const CBLAuthDelegate& rhs) = delete;

    ~CBLAuthDelegate();

    CBLAuthDelegate& operator=(const CBLAuthDelegate& rhs) = delete;

    void addAuthObserver(std::shared_ptr<avsCommon::sdkInterfaces::AuthObserverInterface> observer) override;
    void removeAuthObserver(std::shared_ptr<avsCommon::sdkInterfaces::AuthObserverInterface> observer) override;
    std::string getAuthToken() override;
    void onAuthFailure(const std::string& token) override;

    void clearData() override;

private:
    enum class FlowState {
        STARTING,
        REQUESTING_CODE_PAIR,
        REQUESTING_TOKEN,
        REFRESHING_TOKEN,
        STOPPING
    };

    CBLAuthDelegate(
        std::shared_ptr<registrationManager::CustomerDataManagerInterface> customerDataManager,
        std::shared_ptr<CBLAuthDelegateStorageInterface> storage,
        std::shared_ptr<CBLAuthRequesterInterface> authRequester,
        std::shared_ptr<avsCommon::utils::libcurlUtils::HttpPostInterface> httpPost);

    bool init(
        const avsCommon::utils::configuration::ConfigurationNode& configuration,
        const std::shared_ptr<avsCommon::utils::DeviceInfo>& deviceInfo);

    void stop();

    void handleAuthorizationFlow();

    FlowState handleStarting();

    FlowState handleRequestingCodePair();

    FlowState handleRequestingToken();

    FlowState handleRefreshingToken();

    FlowState handleStopping();

    avsCommon::utils::libcurlUtils::HTTPResponse requestCodePair();

    avsCommon::utils::libcurlUtils::HTTPResponse requestToken();

    avsCommon::utils::libcurlUtils::HTTPResponse requestRefresh();

    avsCommon::sdkInterfaces::AuthObserverInterface::Error receiveCodePairResponse(
        const avsCommon::utils::libcurlUtils::HTTPResponse& response);

    avsCommon::sdkInterfaces::AuthObserverInterface::Error receiveTokenResponse(
        const avsCommon::utils::libcurlUtils::HTTPResponse& response,
        bool expiresImmediately);

    void setAuthState(avsCommon::sdkInterfaces::AuthObserverInterface::State newState);

    void setAuthError(avsCommon::sdkInterfaces::AuthObserverInterface::Error error);

    void setRefreshToken(const std::string& refreshToken);

    void clearRefreshToken();

    bool isStopping();

    std::shared_ptr<CBLAuthDelegateStorageInterface> m_storage;

    std::shared_ptr<avsCommon::utils::libcurlUtils::HttpPostInterface> m_httpPost;

    std::shared_ptr<CBLAuthRequesterInterface> m_authRequester;

    std::unique_ptr<acsdkAuthorization::lwa::LWAAuthorizationConfiguration> m_configuration;

    bool m_isStopping;

    std::mutex m_mutex;

    std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::AuthObserverInterface>> m_observers;

    std::string m_accessToken;

    avsCommon::sdkInterfaces::AuthObserverInterface::State m_authState;

    avsCommon::sdkInterfaces::AuthObserverInterface::Error m_authError;

    std::string m_deviceCode;

    std::string m_userCode;

    std::thread m_authorizationFlowThread;

    std::chrono::steady_clock::time_point m_codePairExpirationTime;

    std::chrono::steady_clock::time_point m_tokenExpirationTime;

    std::string m_refreshToken;

    std::condition_variable m_wake;

    std::chrono::steady_clock::time_point m_timeToRefresh;

    std::chrono::steady_clock::time_point m_requestTime;

    int m_retryCount;

    bool m_newRefreshToken;

    bool m_authFailureReported;
};

}  // namespace cblAuthDelegate
}  // namespace authorization
}  // namespace alexaClientSDK

#endif  // CBLAUTHDELEGATE_CBLAUTHDELEGATE_H_