AlexaInterfaceMessageSenderInterface.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_ALEXAINTERFACEMESSAGESENDERINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_ALEXAINTERFACEMESSAGESENDERINTERFACE_H_

#include <memory>

#include <AVSCommon/AVS/AlexaResponseType.h>
#include <AVSCommon/AVS/AVSMessageEndpoint.h>

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {

class AlexaInterfaceMessageSenderInterface {
public:
    enum class ErrorResponseType {
        ALREADY_IN_OPERATION,

        BRIDGE_UNREACHABLE,

        ENDPOINT_BUSY,

        ENDPOINT_LOW_POWER,

        ENDPOINT_UNREACHABLE,

        EXPIRED_AUTHORIZATION_CREDENTIAL,

        FIRMWARE_OUT_OF_DATE,

        HARDWARE_MALFUNCTION,

        INSUFFICIENT_PERMISSIONS,

        INTERNAL_ERROR,

        INVALID_AUTHORIZATION_CREDENTIAL,

        INVALID_DIRECTIVE,

        INVALID_VALUE,

        NO_SUCH_ENDPOINT,

        NOT_CALIBRATED,

        NOT_SUPPORTED_IN_CURRENT_MODE,

        NOT_IN_OPERATION,

        POWER_LEVEL_NOT_SUPPORTED,

        RATE_LIMIT_EXCEEDED,

        TEMPERATURE_VALUE_OUT_OF_RANGE,

        VALUE_OUT_OF_RANGE
    };

    enum class AlexaVideoErrorResponseType {
        ACTION_NOT_PERMITTED_FOR_CONTENT,

        CONFIRMATION_REQUIRED,

        CONTENT_NOT_RECORDABLE,

        NOT_SUBSCRIBED,

        RECORDING_EXISTS,

        STORAGE_FULL,

        TITLE_DISAMBIGUATION_REQUIRED,

        TUNER_OCCUPIED,

        NONE
    };

    virtual ~AlexaInterfaceMessageSenderInterface() = default;

    virtual bool sendResponseEvent(
        const std::string& instance,
        const std::string& correlationToken,
        const avsCommon::avs::AVSMessageEndpoint& endpoint,
        const std::string& jsonPayload = "{}") = 0;

    virtual bool sendResponseEvent(
        const std::string& instance,
        const std::string& correlationToken,
        const avsCommon::avs::AVSMessageEndpoint& endpoint,
        const std::string& responseNamespace,
        const std::string& responseName,
        const std::string& jsonPayload = "{}") = 0;

    virtual bool sendErrorResponseEvent(
        const std::string& instance,
        const std::string& correlationToken,
        const avsCommon::avs::AVSMessageEndpoint& endpoint,
        const ErrorResponseType errorType,
        const std::string& errorMessage = "") = 0;

    virtual bool sendErrorResponseEvent(
        const std::string& instance,
        const std::string& correlationToken,
        const avsCommon::avs::AVSMessageEndpoint& endpoint,
        const std::string& responseNamespace,
        const std::string& jsonPayload = "{}") = 0;

    virtual bool sendDeferredResponseEvent(
        const std::string& instance,
        const std::string& correlationToken,
        const int estimatedDeferralInSeconds = 0) = 0;

    static std::string alexaVideoErrorResponseToString(AlexaVideoErrorResponseType responseType);

    static ErrorResponseType alexaResponseTypeToErrorType(const avsCommon::avs::AlexaResponseType responseType);
};

inline std::string AlexaInterfaceMessageSenderInterface::alexaVideoErrorResponseToString(
    AlexaVideoErrorResponseType responseType) {
    switch (responseType) {
        case AlexaVideoErrorResponseType::ACTION_NOT_PERMITTED_FOR_CONTENT:
            return "ACTION_NOT_PERMITTED_FOR_CONTENT";
        case AlexaVideoErrorResponseType::CONFIRMATION_REQUIRED:
            return "CONFIRMATION_REQUIRED";
        case AlexaVideoErrorResponseType::CONTENT_NOT_RECORDABLE:
            return "CONTENT_NOT_RECORDABLE";
        case AlexaVideoErrorResponseType::NOT_SUBSCRIBED:
            return "NOT_SUBSCRIBED";
        case AlexaVideoErrorResponseType::RECORDING_EXISTS:
            return "RECORDING_EXISTS";
        case AlexaVideoErrorResponseType::STORAGE_FULL:
            return "STORAGE_FULL";
        case AlexaVideoErrorResponseType::TITLE_DISAMBIGUATION_REQUIRED:
            return "TITLE_DISAMBIGUATION_REQUIRED";
        case AlexaVideoErrorResponseType::TUNER_OCCUPIED:
            return "TUNER_OCCUPIED";
        case AlexaVideoErrorResponseType::NONE:
            return "";
    }
    return "UNKNOWN";
}

inline AlexaInterfaceMessageSenderInterface::ErrorResponseType AlexaInterfaceMessageSenderInterface::
    alexaResponseTypeToErrorType(const avsCommon::avs::AlexaResponseType responseType) {
    switch (responseType) {
        case avs::AlexaResponseType::SUCCESS:  // not supported
            return ErrorResponseType::INTERNAL_ERROR;
        case avs::AlexaResponseType::ALREADY_IN_OPERATION:
            return ErrorResponseType::ALREADY_IN_OPERATION;
        case avs::AlexaResponseType::BRIDGE_UNREACHABLE:
            return ErrorResponseType::BRIDGE_UNREACHABLE;
        case avs::AlexaResponseType::ENDPOINT_BUSY:
            return ErrorResponseType::ENDPOINT_BUSY;
        case avs::AlexaResponseType::ENDPOINT_LOW_POWER:
            return ErrorResponseType::ENDPOINT_LOW_POWER;
        case avs::AlexaResponseType::ENDPOINT_UNREACHABLE:
            return ErrorResponseType::ENDPOINT_UNREACHABLE;
        case avs::AlexaResponseType::FIRMWARE_OUT_OF_DATE:
            return ErrorResponseType::FIRMWARE_OUT_OF_DATE;
        case avs::AlexaResponseType::HARDWARE_MALFUNCTION:
            return ErrorResponseType::HARDWARE_MALFUNCTION;
        case avs::AlexaResponseType::INSUFFICIENT_PERMISSIONS:
            return ErrorResponseType::INSUFFICIENT_PERMISSIONS;
        case avs::AlexaResponseType::INTERNAL_ERROR:
            return ErrorResponseType::INTERNAL_ERROR;
        case avs::AlexaResponseType::INVALID_VALUE:
            return ErrorResponseType::INVALID_VALUE;
        case avs::AlexaResponseType::NOT_CALIBRATED:
            return ErrorResponseType::NOT_CALIBRATED;
        case avs::AlexaResponseType::NOT_SUPPORTED_IN_CURRENT_MODE:
            return ErrorResponseType::NOT_SUPPORTED_IN_CURRENT_MODE;
        case avs::AlexaResponseType::NOT_IN_OPERATION:
            return ErrorResponseType::NOT_IN_OPERATION;
        case avs::AlexaResponseType::POWER_LEVEL_NOT_SUPPORTED:
            return ErrorResponseType::POWER_LEVEL_NOT_SUPPORTED;
        case avs::AlexaResponseType::RATE_LIMIT_EXCEEDED:
            return ErrorResponseType::RATE_LIMIT_EXCEEDED;
        case avs::AlexaResponseType::TEMPERATURE_VALUE_OUT_OF_RANGE:
            return ErrorResponseType::TEMPERATURE_VALUE_OUT_OF_RANGE;
        case avs::AlexaResponseType::VALUE_OUT_OF_RANGE:
            return ErrorResponseType::VALUE_OUT_OF_RANGE;
    }
    return ErrorResponseType::INTERNAL_ERROR;
}

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

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_ALEXAINTERFACEMESSAGESENDERINTERFACE_H_