EndpointRegistrationObserverInterface.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_ENDPOINTS_ENDPOINTREGISTRATIONOBSERVERINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_ENDPOINTS_ENDPOINTREGISTRATIONOBSERVERINTERFACE_H_

#include "AVSCommon/AVS/AVSDiscoveryEndpointAttributes.h"
#include "AVSCommon/AVS/CapabilityConfiguration.h"
#include "AVSCommon/SDKInterfaces/Endpoints/EndpointIdentifier.h"

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {
namespace endpoints {

class EndpointRegistrationObserverInterface {
public:
    enum class RegistrationResult {
        SUCCEEDED,
        CONFIGURATION_ERROR,
        INTERNAL_ERROR,
        PENDING_REGISTRATION,
        PENDING_DEREGISTRATION,
        PENDING_UPDATE,
        ALREADY_REGISTERED
    };

    enum class UpdateResult {
        SUCCEEDED,
        CONFIGURATION_ERROR,
        INTERNAL_ERROR,
        NOT_REGISTERED,
        PENDING_UPDATE,
        PENDING_REGISTRATION,
        PENDING_DEREGISTRATION
    };

    enum class DeregistrationResult {
        SUCCEEDED,
        NOT_REGISTERED,
        INTERNAL_ERROR,
        CONFIGURATION_ERROR,
        PENDING_UPDATE,
        PENDING_REGISTRATION,
        PENDING_DEREGISTRATION
    };

    virtual ~EndpointRegistrationObserverInterface() = default;

    virtual void onEndpointRegistration(
        const EndpointIdentifier& endpointId,
        const avs::AVSDiscoveryEndpointAttributes& attributes,
        const RegistrationResult result) = 0;

    virtual void onEndpointUpdate(
        const EndpointIdentifier& endpointId,
        const avs::AVSDiscoveryEndpointAttributes& attributes,
        const UpdateResult result) = 0;

    virtual void onEndpointDeregistration(const EndpointIdentifier& endpointId, const DeregistrationResult result) = 0;

    virtual void onPendingEndpointRegistrationOrUpdate(
        const EndpointIdentifier& endpointId,
        const avs::AVSDiscoveryEndpointAttributes& attributes,
        const std::vector<avs::CapabilityConfiguration>& capabilities) {
    }
};

inline std::ostream& operator<<(
    std::ostream& stream,
    const EndpointRegistrationObserverInterface::RegistrationResult& registrationResult) {
    switch (registrationResult) {
        case EndpointRegistrationObserverInterface::RegistrationResult::SUCCEEDED:
            stream << "SUCCEEDED";
            break;
        case EndpointRegistrationObserverInterface::RegistrationResult::CONFIGURATION_ERROR:
            stream << "CONFIGURATION_ERROR";
            break;
        case EndpointRegistrationObserverInterface::RegistrationResult::INTERNAL_ERROR:
            stream << "INTERNAL_ERROR";
            break;
        case EndpointRegistrationObserverInterface::RegistrationResult::PENDING_REGISTRATION:
            stream << "PENDING_REGISTRATION";
            break;
        case EndpointRegistrationObserverInterface::RegistrationResult::PENDING_DEREGISTRATION:
            stream << "PENDING_DEREGISTRATION";
            break;
        case EndpointRegistrationObserverInterface::RegistrationResult::PENDING_UPDATE:
            stream << "PENDING_UPDATE";
            break;
        case EndpointRegistrationObserverInterface::RegistrationResult::ALREADY_REGISTERED:
            stream << "ALREADY_REGISTERED";
            break;
        default:
            stream << "UNKNOWN";
            break;
    }
    return stream;
}

inline std::ostream& operator<<(
    std::ostream& stream,
    const EndpointRegistrationObserverInterface::DeregistrationResult& deregistrationResult) {
    switch (deregistrationResult) {
        case EndpointRegistrationObserverInterface::DeregistrationResult::SUCCEEDED:
            stream << "SUCCEEDED";
            break;
        case EndpointRegistrationObserverInterface::DeregistrationResult::NOT_REGISTERED:
            stream << "NOT_REGISTERED";
            break;
        case EndpointRegistrationObserverInterface::DeregistrationResult::CONFIGURATION_ERROR:
            stream << "CONFIGURATION_ERROR";
            break;
        case EndpointRegistrationObserverInterface::DeregistrationResult::INTERNAL_ERROR:
            stream << "INTERNAL_ERROR";
            break;
        case EndpointRegistrationObserverInterface::DeregistrationResult::PENDING_REGISTRATION:
            stream << "PENDING_REGISTRATION";
            break;
        case EndpointRegistrationObserverInterface::DeregistrationResult::PENDING_DEREGISTRATION:
            stream << "PENDING_DEREGISTRATION";
            break;
        case EndpointRegistrationObserverInterface::DeregistrationResult::PENDING_UPDATE:
            stream << "PENDING_UPDATE";
            break;
        default:
            stream << "UNKNOWN";
            break;
    }
    return stream;
}

inline std::ostream& operator<<(
    std::ostream& stream,
    const EndpointRegistrationObserverInterface::UpdateResult& updateResult) {
    switch (updateResult) {
        case EndpointRegistrationObserverInterface::UpdateResult::SUCCEEDED:
            stream << "SUCCEEDED";
            break;
        case EndpointRegistrationObserverInterface::UpdateResult::NOT_REGISTERED:
            stream << "NOT_REGISTERED";
            break;
        case EndpointRegistrationObserverInterface::UpdateResult::CONFIGURATION_ERROR:
            stream << "CONFIGURATION_ERROR";
            break;
        case EndpointRegistrationObserverInterface::UpdateResult::INTERNAL_ERROR:
            stream << "INTERNAL_ERROR";
            break;
        case EndpointRegistrationObserverInterface::UpdateResult::PENDING_REGISTRATION:
            stream << "PENDING_REGISTRATION";
            break;
        case EndpointRegistrationObserverInterface::UpdateResult::PENDING_DEREGISTRATION:
            stream << "PENDING_DEREGISTRATION";
            break;
        case EndpointRegistrationObserverInterface::UpdateResult::PENDING_UPDATE:
            stream << "PENDING_UPDATE";
        default:
            stream << "UNKNOWN";
            break;
    }
    return stream;
}

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

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_ENDPOINTS_ENDPOINTREGISTRATIONOBSERVERINTERFACE_H_