LWAAuthorizationAdapter.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 ACSDKAUTHORIZATION_LWA_LWAAUTHORIZATIONADAPTER_H_
#define ACSDKAUTHORIZATION_LWA_LWAAUTHORIZATIONADAPTER_H_

#include <condition_variable>
#include <thread>

#include <acsdkAuthorization/LWA/LWAAuthorizationConfiguration.h>
#include <acsdkAuthorizationInterfaces/AuthorizationAdapterInterface.h>
#include <acsdkAuthorizationInterfaces/LWA/LWAAuthorizationInterface.h>
#include <acsdkAuthorizationInterfaces/LWA/LWAAuthorizationStorageInterface.h>
#include <AVSCommon/Utils/Configuration/ConfigurationNode.h>
#include <AVSCommon/Utils/DeviceInfo.h>
#include <AVSCommon/Utils/LibcurlUtils/HttpGetInterface.h>
#include <AVSCommon/Utils/LibcurlUtils/HttpPostInterface.h>
#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/RetryTimer.h>

namespace alexaClientSDK {
namespace acsdkAuthorization {
namespace lwa {

class LWAAuthorizationAdapter
        : public acsdkAuthorizationInterfaces::lwa::LWAAuthorizationInterface
        , public acsdkAuthorizationInterfaces::AuthorizationAdapterInterface
        , public std::enable_shared_from_this<LWAAuthorizationAdapter> {
public:
    ~LWAAuthorizationAdapter();

    static std::shared_ptr<LWAAuthorizationAdapter> create(
        const std::shared_ptr<avsCommon::utils::configuration::ConfigurationNode>& configuration,
        std::unique_ptr<avsCommon::utils::libcurlUtils::HttpPostInterface> httpPost,
        const std::shared_ptr<avsCommon::utils::DeviceInfo>& deviceInfo,
        const std::shared_ptr<acsdkAuthorizationInterfaces::lwa::LWAAuthorizationStorageInterface>& storage,
        std::unique_ptr<avsCommon::utils::libcurlUtils::HttpGetInterface> httpGet = nullptr,
        const std::string& adapterId = "");

    bool authorizeUsingCBL(
        const std::shared_ptr<acsdkAuthorizationInterfaces::lwa::CBLAuthorizationObserverInterface>& observer) override;
    bool authorizeUsingCBLWithCustomerProfile(
        const std::shared_ptr<acsdkAuthorizationInterfaces::lwa::CBLAuthorizationObserverInterface>& observer) override;

    std::string getId() override;

    std::string getAuthToken() override;
    void reset() override;
    void onAuthFailure(const std::string& authToken) override;
    avsCommon::sdkInterfaces::AuthObserverInterface::FullState getState() override;
    std::shared_ptr<acsdkAuthorizationInterfaces::AuthorizationInterface> getAuthorizationInterface() override;
    avsCommon::sdkInterfaces::AuthObserverInterface::FullState onAuthorizationManagerReady(
        const std::shared_ptr<acsdkAuthorizationInterfaces::AuthorizationManagerInterface>& manager) override;

private:
    enum class TokenExchangeMethod {
        NONE,
        CBL
    };

    struct RefreshTokenResponse {
        std::string refreshToken;

        std::string accessToken;

        std::chrono::steady_clock::time_point requestTime;

        std::chrono::seconds expiration;

        bool isRefreshTokenVerified;

        RefreshTokenResponse() :
                refreshToken{""},
                accessToken{""},
                requestTime{std::chrono::steady_clock::now()},
                expiration{std::chrono::seconds::zero()},
                isRefreshTokenVerified{true} {
        }

        std::chrono::steady_clock::time_point getExpirationTime() const {
            return requestTime + expiration;
        }
    };

    enum class FlowState {
        IDLE,
        REQUESTING_TOKEN,
        REFRESHING_TOKEN,
        CLEARING_DATA,
        STOPPING
    };

    LWAAuthorizationAdapter(
        const std::string& adapterId,
        std::unique_ptr<avsCommon::utils::libcurlUtils::HttpPostInterface> httpPost,
        const std::shared_ptr<acsdkAuthorizationInterfaces::lwa::LWAAuthorizationStorageInterface>& storage,
        std::unique_ptr<avsCommon::utils::libcurlUtils::HttpGetInterface> httpGet);

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

    FlowState retrievePersistedData();

    avsCommon::utils::libcurlUtils::HTTPResponse requestRefresh(std::chrono::steady_clock::time_point* requestTime);

    FlowState handleIdle();

    FlowState handleRequestingToken();

    FlowState handleRefreshingToken();

    FlowState handleClearingData();

    FlowState handleStopping();

    void handleAuthorizationFlow(FlowState state);

    bool authorizeUsingCBLHelper(
        const std::shared_ptr<acsdkAuthorizationInterfaces::lwa::CBLAuthorizationObserverInterface>& observer,
        bool requestCustomerProfile);

    avsCommon::utils::Optional<avsCommon::sdkInterfaces::AuthObserverInterface::Error> requestCodePair();

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

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

    avsCommon::utils::Optional<avsCommon::sdkInterfaces::AuthObserverInterface::Error> exchangeToken(
        RefreshTokenResponse* tokenResponse);

    avsCommon::utils::libcurlUtils::HTTPResponse sendTokenRequest(std::chrono::steady_clock::time_point* requestTime);

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

    bool shouldStopRetrying();

    bool shouldStopRetryingLocked();

    bool isShuttingDown();

    void stop();

    void resetAuthMethodLocked();

    void setRefreshTokenResponse(const RefreshTokenResponse& response, bool persist = true);

    void setRefreshTokenResponseLocked(const RefreshTokenResponse& response, bool persist = true);

    void updateStateAndNotifyManager(
        avsCommon::sdkInterfaces::AuthObserverInterface::State state,
        avsCommon::sdkInterfaces::AuthObserverInterface::Error error);

    bool getCustomerProfile(const std::string& accessToken);

    std::mutex m_mutex;

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

    std::unique_ptr<avsCommon::utils::libcurlUtils::HttpGetInterface> m_httpGet;

    std::shared_ptr<acsdkAuthorizationInterfaces::lwa::LWAAuthorizationStorageInterface> m_storage;

    std::unique_ptr<LWAAuthorizationConfiguration> m_configuration;

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

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

    std::string m_userId;

    std::condition_variable m_wake;

    std::thread m_authorizationFlowThread;

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

    std::string m_deviceCode;

    std::string m_userCode;

    std::chrono::seconds m_tokenRequestInterval;

    std::shared_ptr<acsdkAuthorizationInterfaces::lwa::CBLAuthorizationObserverInterface> m_cblRequester;

    bool m_requestCustomerProfile;

    bool m_authFailureReported;

    TokenExchangeMethod m_authMethod;

    RefreshTokenResponse m_refreshTokenResponse;

    std::shared_ptr<acsdkAuthorizationInterfaces::AuthorizationManagerInterface> m_manager;

    bool m_isShuttingDown;

    bool m_isClearingData;

    const std::string m_adapterId;
};

}  // namespace lwa
}  // namespace acsdkAuthorization
}  // namespace alexaClientSDK

#endif  // ACSDKAUTHORIZATION_LWA_LWAAUTHORIZATIONADAPTER_H_