LiveViewControllerTypes.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_ALEXALIVEVIEWCONTROLLERINTERFACES_INCLUDE_ACSDK_ALEXALIVEVIEWCONTROLLERINTERFACES_LIVEVIEWCONTROLLERTYPES_H_
#define ALEXA_CLIENT_SDK_ALEXALIVEVIEWCONTROLLERINTERFACES_INCLUDE_ACSDK_ALEXALIVEVIEWCONTROLLERINTERFACES_LIVEVIEWCONTROLLERTYPES_H_

#include <chrono>
#include <set>
#include <string>

#include <AVSCommon/Utils/Optional.h>
#include <AVSCommon/Utils/JSON/JSONGenerator.h>

namespace alexaClientSDK {
namespace alexaLiveViewControllerInterfaces {

enum class AudioState {
    UNMUTED,
    MUTED,
    DISABLED,
    UNKNOWN
};

inline std::string audioStateToString(AudioState audioState) {
    switch (audioState) {
        case AudioState::MUTED:
            return "MUTED";
        case AudioState::UNMUTED:
            return "UNMUTED";
        case AudioState::DISABLED:
            return "DISABLED";
        case AudioState::UNKNOWN:
            return "";
    }
    return "";
}

inline bool audioStateToMicrophoneState(AudioState audioState) {
    switch (audioState) {
        case AudioState::UNMUTED:
            return true;
        case AudioState::MUTED:
        case AudioState::DISABLED:
        case AudioState::UNKNOWN:
            return false;
    }
    return false;
}

inline AudioState microphoneStateToAudioState(bool microphoneState) {
    if (microphoneState) {
        return AudioState::UNMUTED;
    } else {
        return AudioState::MUTED;
    }
}

enum class CameraState {
    CONNECTING,
    CONNECTED,
    DISCONNECTED,
    ERROR,
    UNKNOWN
};

enum class MotionCapability {
    PHYSICAL_PAN,
    PHYSICAL_TILT,
    PHYSICAL_ZOOM,
    UNKNOWN
};

inline std::string motionCapabilityToString(MotionCapability motionCapability) {
    switch (motionCapability) {
        case MotionCapability::PHYSICAL_PAN:
            return "PHYSICAL_PAN";
        case MotionCapability::PHYSICAL_TILT:
            return "PHYSICAL_TILT";
        case MotionCapability::PHYSICAL_ZOOM:
            return "PHYSICAL_ZOOM";
        case MotionCapability::UNKNOWN:
            return "";
    }
    return "";
}

enum class ConcurrentTwoWayTalkState {
    ENABLED,
    DISABLED,
    UNKNOWN
};

inline std::string concurrentTwoWayTalkStateToString(ConcurrentTwoWayTalkState concurrentTwoWayTalkState) {
    switch (concurrentTwoWayTalkState) {
        case ConcurrentTwoWayTalkState::ENABLED:
            return "ENABLED";
        case ConcurrentTwoWayTalkState::DISABLED:
            return "DISABLED";
        case ConcurrentTwoWayTalkState::UNKNOWN:
            return "";
    }
    return "";
}

enum class DisplayMode {
    FULL_SCREEN,
    OVERLAY,
    UNKNOWN
};

inline std::string displayModeToString(DisplayMode displayMode) {
    switch (displayMode) {
        case DisplayMode::FULL_SCREEN:
            return "FULL_SCREEN";
        case DisplayMode::OVERLAY:
            return "OVERLAY";
        case DisplayMode::UNKNOWN:
            return "";
    }
    return "";
}

enum class LiveViewTrigger {
    USER_ACTION,
    AUTOMATED_EVENT,
    UNKNOWN
};

inline std::string liveViewTriggerToString(LiveViewTrigger liveViewTrigger) {
    switch (liveViewTrigger) {
        case LiveViewTrigger::AUTOMATED_EVENT:
            return "AUTOMATED_EVENT";
        case LiveViewTrigger::USER_ACTION:
            return "USER_ACTION";
        case LiveViewTrigger::UNKNOWN:
            return "";
    }
    return "";
}

enum class OverlayPosition {
    TOP_RIGHT,
    TOP_LEFT,
    BOTTOM_RIGHT,
    BOTTOM_LEFT,
    UNKNOWN
};

inline std::string overlayPositionToString(OverlayPosition overlayPosition) {
    switch (overlayPosition) {
        case OverlayPosition::TOP_RIGHT:
            return "TOP_RIGHT";
        case OverlayPosition::TOP_LEFT:
            return "TOP_LEFT";
        case OverlayPosition::BOTTOM_RIGHT:
            return "BOTTOM_RIGHT";
        case OverlayPosition::BOTTOM_LEFT:
            return "BOTTOM_LEFT";
        case OverlayPosition::UNKNOWN:
            return "";
    }
    return "";
}

enum class OverlayType {
    PICTURE_IN_PICTURE,
    NONE,
    UNKNOWN
};

inline std::string overlayTypeToString(OverlayType overlayType) {
    switch (overlayType) {
        case OverlayType::PICTURE_IN_PICTURE:
            return "PICTURE_IN_PICTURE";
        case OverlayType::NONE:
            return "NONE";
        case OverlayType::UNKNOWN:
            return "";
    }
    return "";
}

enum class Role {
    CAMERA,
    VIEWER,
    UNKNOWN
};

inline std::string roleToString(Role role) {
    switch (role) {
        case Role::CAMERA:
            return "CAMERA";
        case Role::VIEWER:
            return "VIEWER";
        case Role::UNKNOWN:
            return "";
    }
    return "";
}

enum class Status {
    STOP_LIVE_VIEW_REQUESTED,
    MEDIA_SOURCE_NOT_FOUND,
    UNAUTHORIZED,
    BATTERY_LEVEL_TOO_LOW,
    MEDIA_SOURCE_ASLEEP,
    MEDIA_SOURCE_TURNED_OFF
};

enum class TalkMode {
    NO_SUPPORT,
    PRESS_AND_HOLD,
    TAP,
    UNKNOWN
};

inline std::string talkModeToString(TalkMode talkMode) {
    switch (talkMode) {
        case TalkMode::PRESS_AND_HOLD:
            return "PRESS_AND_HOLD";
        case TalkMode::TAP:
            return "TAP";
        case TalkMode::NO_SUPPORT:
            return "NO_SUPPORT";
        case TalkMode::UNKNOWN:
            return "";
    }
    return "";
}

struct AudioProperties {
    TalkMode talkMode;
    ConcurrentTwoWayTalkState concurrentTwoWayTalk;
    AudioState microphoneState;
    AudioState speakerState;
};

struct Camera {
    std::string name;
    std::string make;
    avsCommon::utils::Optional<std::string> model;
    avsCommon::utils::Optional<std::set<MotionCapability>> capabilities;
};

struct DisplayProperties {
    DisplayMode displayMode;
    avsCommon::utils::Optional<OverlayType> overlayType;
    avsCommon::utils::Optional<OverlayPosition> overlayPosition;
};

struct Viewer {
    enum class ViewerState {
        CONNECTED,
        CONNECTING,
        UNKNOWN
    };

    std::string name;
    bool hasCameraControl;
    ViewerState state;

    bool operator<(const Viewer& anotherViewer) const {
        return (name < anotherViewer.name);
    }
};

inline std::string viewerStateToString(Viewer::ViewerState viewerState) {
    switch (viewerState) {
        case Viewer::ViewerState::CONNECTED:
            return "CONNECTED";
        case Viewer::ViewerState::CONNECTING:
            return "CONNECTING";
        case Viewer::ViewerState::UNKNOWN:
            return "";
    }
    return "";
}

struct Target {
    enum class TargetType {
        ALEXA_ENDPOINT,
        UNKNOWN
    };

    std::string endpointId;
    avsCommon::utils::Optional<TargetType> type;
};

inline std::string targetTypeToString(Target::TargetType targetType) {
    switch (targetType) {
        case Target::TargetType::ALEXA_ENDPOINT:
            return "ALEXA_ENDPOINT";
        case Target::TargetType::UNKNOWN:
            return "";
    }
    return "";
}

struct Participants {
    std::set<Viewer> viewers;
    Camera camera;
};

struct ViewerExperience {
    DisplayProperties suggestedDisplay;
    AudioProperties audioProperties;
    LiveViewTrigger liveViewTrigger;
    std::chrono::milliseconds idleTimeoutInMilliseconds;
};

}  // namespace alexaLiveViewControllerInterfaces
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ALEXALIVEVIEWCONTROLLERINTERFACES_INCLUDE_ACSDK_ALEXALIVEVIEWCONTROLLERINTERFACES_LIVEVIEWCONTROLLERTYPES_H_