ConnectionStatusObserverInterface.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 ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_CONNECTIONSTATUSOBSERVERINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_CONNECTIONSTATUSOBSERVERINTERFACE_H_

#include <iostream>
#include <vector>

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {

static const int ENGINE_TYPE_ALEXA_VOICE_SERVICES = 1;

class ConnectionStatusObserverInterface {
public:
    enum class Status {
        DISCONNECTED,

        PENDING,

        CONNECTED
    };

    enum class ChangedReason {
        NONE,

        SUCCESS,

        UNRECOVERABLE_ERROR,

        ACL_CLIENT_REQUEST,

        ACL_DISABLED,

        DNS_TIMEDOUT,

        CONNECTION_TIMEDOUT,

        CONNECTION_THROTTLED,

        INVALID_AUTH,

        PING_TIMEDOUT,

        WRITE_TIMEDOUT,

        READ_TIMEDOUT,

        FAILURE_PROTOCOL_ERROR,

        INTERNAL_ERROR,

        SERVER_INTERNAL_ERROR,

        SERVER_SIDE_DISCONNECT,

        SERVER_ENDPOINT_CHANGED
    };

    struct EngineConnectionStatus {
        EngineConnectionStatus(const int connectEngineType, ChangedReason connectReason, Status connectStatus) :
                engineType{connectEngineType},
                reason{connectReason},
                status{connectStatus} {
        }
        // The engine type
        int engineType;
        // Reason for connection state change
        ChangedReason reason;
        // State of connection
        Status status;
    };

    virtual ~ConnectionStatusObserverInterface() = default;

    virtual void onConnectionStatusChanged(const Status status, const ChangedReason reason) = 0;

    virtual void onConnectionStatusChanged(
        const Status status,
        const std::vector<EngineConnectionStatus>& engineStatuses){};
};

inline std::ostream& operator<<(std::ostream& stream, ConnectionStatusObserverInterface::Status status) {
    switch (status) {
        case ConnectionStatusObserverInterface::Status::DISCONNECTED:
            stream << "DISCONNECTED";
            break;
        case ConnectionStatusObserverInterface::Status::PENDING:
            stream << "PENDING";
            break;
        case ConnectionStatusObserverInterface::Status::CONNECTED:
            stream << "CONNECTED";
            break;
    }
    return stream;
}

inline std::ostream& operator<<(std::ostream& stream, ConnectionStatusObserverInterface::ChangedReason reason) {
    switch (reason) {
        case ConnectionStatusObserverInterface::ChangedReason::NONE:
            stream << "NONE";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::SUCCESS:
            stream << "SUCCESS";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::UNRECOVERABLE_ERROR:
            stream << "UNRECOVERABLE_ERROR";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::ACL_CLIENT_REQUEST:
            stream << "ACL_CLIENT_REQUEST";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::ACL_DISABLED:
            stream << "ACL_DISABLED";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::DNS_TIMEDOUT:
            stream << "DNS_TIMEDOUT";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::CONNECTION_TIMEDOUT:
            stream << "CONNECTION_TIMEDOUT";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::CONNECTION_THROTTLED:
            stream << "CONNECTION_THROTTLED";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::INVALID_AUTH:
            stream << "INVALID_AUTH";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::PING_TIMEDOUT:
            stream << "PING_TIMEDOUT";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::WRITE_TIMEDOUT:
            stream << "WRITE_TIMEDOUT";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::READ_TIMEDOUT:
            stream << "READ_TIMEDOUT";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::FAILURE_PROTOCOL_ERROR:
            stream << "FAILURE_PROTOCOL_ERROR";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::INTERNAL_ERROR:
            stream << "INTERNAL_ERROR";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::SERVER_INTERNAL_ERROR:
            stream << "SERVER_INTERNAL_ERROR";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::SERVER_SIDE_DISCONNECT:
            stream << "SERVER_SIDE_DISCONNECT";
            break;
        case ConnectionStatusObserverInterface::ChangedReason::SERVER_ENDPOINT_CHANGED:
            stream << "SERVER_ENDPOINT_CHANGED";
            break;
    }
    return stream;
}

}  // namespace sdkInterfaces
}  // namespace avsCommon
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_CONNECTIONSTATUSOBSERVERINTERFACE_H_