VisualCharacteristicsInterface.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 ACSDK_VISUALCHARACTERISTICSINTERFACES_VISUALCHARACTERISTICSINTERFACE_H_
#define ACSDK_VISUALCHARACTERISTICSINTERFACES_VISUALCHARACTERISTICSINTERFACE_H_

#include <string>
#include <vector>

namespace alexaClientSDK {
namespace visualCharacteristicsInterfaces {

struct Dimension {
    enum class Unit {
        PIXEL,

        DPI,

        DP,

        CENTIMETERS,

        INCHES
    };

    Unit unit;

    double width;

    double height;

    static const std::string unitToText(const Unit unit) {
        switch (unit) {
            case Unit::PIXEL:
                return "PIXEL";
            case Unit::DPI:
                return "DPI";
            case Unit::DP:
                return "DP";
            case Unit::CENTIMETERS:
                return "CENTIMETERS";
            case Unit::INCHES:
                return "INCHES";
        }

        return std::string();
    }
};

struct WindowSize {
    enum class WindowSizeType {
        DISCRETE,

        CONTINUOUS
    };

    std::string id;

    WindowSizeType type;

    Dimension minimum;
    Dimension maximum;

    static const std::string windowSizeTypeToText(const WindowSizeType windowSizeType) {
        switch (windowSizeType) {
            case WindowSizeType::DISCRETE:
                return "DISCRETE";
            case WindowSizeType::CONTINUOUS:
                return "CONTINUOUS";
        }

        return std::string();
    }
};

struct WindowTemplate {
    enum class WindowType {
        STANDARD,

        OVERLAY
    };

    std::string id;

    WindowType type;

    std::vector<WindowSize> sizes;

    std::vector<std::string> interactionModes;

    static const std::string windowTypeToText(const WindowType windowType) {
        switch (windowType) {
            case WindowType::STANDARD:
                return "STANDARD";
            case WindowType::OVERLAY:
                return "OVERLAY";
        }

        return std::string();
    }
};

struct InteractionMode {
    enum class UIMode {
        AUTO,

        HUB,

        TV,

        MOBILE,

        PC,

        HEADLESS
    };

    enum class Unit {
        CENTIMETERS,

        INCHES
    };

    UIMode uiMode;

    std::string id;

    Unit interactionDistanceUnit;

    int interactionDistanceValue;

    bool touchSupported;

    bool keyboardSupported;

    bool videoSupported;

    bool dialogSupported;

    static const std::string uiModeToText(const UIMode uiMode) {
        switch (uiMode) {
            case UIMode::AUTO:
                return "AUTO";
            case UIMode::HUB:
                return "HUB";
            case UIMode::TV:
                return "TV";
            case UIMode::MOBILE:
                return "MOBILE";
            case UIMode::PC:
                return "PC";
            case UIMode::HEADLESS:
                return "HEADLESS";
        }

        return std::string();
    }

    static const std::string unitToText(const Unit unit) {
        switch (unit) {
            case Unit::CENTIMETERS:
                return "CENTIMETERS";
            case Unit::INCHES:
                return "INCHES";
        }

        return std::string();
    }
};

struct DisplayCharacteristics {
    enum Type {
        PIXEL
    };

    enum TouchType {
        SINGLE,

        UNSUPPORTED
    };

    enum Shape {
        RECTANGLE,

        ROUND
    };

    Type type;

    std::vector<TouchType> touch;

    Shape shape;

    int pixelDensity;

    Dimension resolution;

    Dimension densityIndependentResolution;

    Dimension physicalSize;

    static const std::string typeToText(const Type type) {
        switch (type) {
            case Type::PIXEL:
                return "PIXEL";
        }

        return std::string();
    }

    static const std::string touchTypeToText(const TouchType touchType) {
        switch (touchType) {
            case TouchType::SINGLE:
                return "SINGLE";
            case TouchType::UNSUPPORTED:
                return "UNSUPPORTED";
        }

        return std::string();
    }

    static const std::string shapeToText(const Shape shape) {
        switch (shape) {
            case Shape::RECTANGLE:
                return "RECTANGLE";
            case Shape::ROUND:
                return "ROUND";
        }

        return std::string();
    }
};

struct WindowInstance {
    std::string id;
    std::string templateId;
    std::string interactionMode;
    std::string sizeConfigurationId;
};

struct OrchestratorWindowInstance : public WindowInstance {
    bool includeInWindowState;
    bool supportsBackgroundPresentations;
    int display;
    int zOrderIndex;
};

struct VisualCharacteristicsConfiguration {
    std::vector<InteractionMode> interactionModes;
    std::vector<WindowTemplate> windowTemplates;
    DisplayCharacteristics displayCharacteristics;
};

class VisualCharacteristicsInterface {
public:
    virtual ~VisualCharacteristicsInterface() = default;

    virtual std::vector<WindowTemplate> getWindowTemplates() = 0;

    virtual std::vector<InteractionMode> getInteractionModes() = 0;

    virtual DisplayCharacteristics getDisplayCharacteristics() = 0;

    virtual void setWindowInstances(
        const std::vector<WindowInstance>& instances,
        const std::string& defaultWindowInstanceId) = 0;

    virtual bool addWindowInstance(const WindowInstance& instance) = 0;

    virtual bool removeWindowInstance(const std::string& windowInstanceId) = 0;

    virtual void updateWindowInstance(const WindowInstance& instance) = 0;

    virtual bool setDefaultWindowInstance(const std::string& windowInstanceId) = 0;
};
}  // namespace visualCharacteristicsInterfaces
}  // namespace alexaClientSDK
#endif  // ACSDK_VISUALCHARACTERISTICSINTERFACES_VISUALCHARACTERISTICSINTERFACE_H_