AlertObserverInterface.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_ACSDKALERTSINTERFACES_INCLUDE_ACSDKALERTSINTERFACES_ALERTOBSERVERINTERFACE_H_
#define ALEXA_CLIENT_SDK_ACSDKALERTSINTERFACES_INCLUDE_ACSDKALERTSINTERFACES_ALERTOBSERVERINTERFACE_H_

#include <iomanip>
#include <string>
#include <sstream>

#include <AVSCommon/Utils/Optional.h>

namespace alexaClientSDK {
namespace acsdkAlertsInterfaces {

class AlertObserverInterface {
public:
    static const int ORIGINAL_TIME_FIELD_MIN = 0;
    static const int ORIGINAL_TIME_HOUR_MAX = 23;
    static const int ORIGINAL_TIME_MINUTE_MAX = 59;
    static const int ORIGINAL_TIME_SECOND_MAX = 59;
    static const int ORIGINAL_TIME_MILLISECOND_MAX = 999;

    template <class T>
    static bool withinBounds(T value, T minVal, T maxVal) {
        return value >= minVal && value <= maxVal;
    }

    enum class State {
        READY,
        STARTED,
        STOPPED,
        SNOOZED,
        COMPLETED,
        PAST_DUE,
        FOCUS_ENTERED_FOREGROUND,
        FOCUS_ENTERED_BACKGROUND,
        ERROR,
        DELETED,
        SCHEDULED_FOR_LATER
    };

    enum class Type {
        ALARM,
        TIMER,
        REMINDER
    };

    struct OriginalTime {
        OriginalTime(
            int hour = ORIGINAL_TIME_FIELD_MIN,
            int minute = ORIGINAL_TIME_FIELD_MIN,
            int second = ORIGINAL_TIME_FIELD_MIN,
            int millisecond = ORIGINAL_TIME_FIELD_MIN) :
                hour{hour},
                minute{minute},
                second{second},
                millisecond{millisecond} {
            if (!withinBounds(hour, ORIGINAL_TIME_FIELD_MIN, ORIGINAL_TIME_HOUR_MAX) ||
                !withinBounds(minute, ORIGINAL_TIME_FIELD_MIN, ORIGINAL_TIME_MINUTE_MAX) ||
                !withinBounds(second, ORIGINAL_TIME_FIELD_MIN, ORIGINAL_TIME_SECOND_MAX) ||
                !withinBounds(millisecond, ORIGINAL_TIME_FIELD_MIN, ORIGINAL_TIME_MILLISECOND_MAX)) {
                this->hour = ORIGINAL_TIME_FIELD_MIN;
                this->minute = ORIGINAL_TIME_FIELD_MIN;
                this->second = ORIGINAL_TIME_FIELD_MIN;
                this->millisecond = ORIGINAL_TIME_FIELD_MIN;
            }
        }

        bool operator==(const OriginalTime& rhs) const {
            return hour == rhs.hour && minute == rhs.minute && second == rhs.second && millisecond == rhs.millisecond;
        }

        int hour;
        int minute;
        int second;
        int millisecond;
    };

    struct AlertInfo {
        AlertInfo(
            const std::string& token,
            const Type type,
            const State state,
            const std::chrono::system_clock::time_point& scheduledTime,
            const avsCommon::utils::Optional<OriginalTime>& originalTime = avsCommon::utils::Optional<OriginalTime>(),
            const avsCommon::utils::Optional<std::string>& label = avsCommon::utils::Optional<std::string>(),
            const std::string& reason = "") :
                token{token},
                type{type},
                state{state},
                scheduledTime{scheduledTime},
                originalTime{originalTime},
                label{label},
                reason{reason} {
        }

        std::string token;
        Type type;
        State state;
        std::chrono::system_clock::time_point scheduledTime;
        avsCommon::utils::Optional<OriginalTime> originalTime;
        avsCommon::utils::Optional<std::string> label;
        std::string reason;
    };

    virtual ~AlertObserverInterface() = default;

    virtual void onAlertStateChange(const AlertInfo& alertInfo) = 0;

    static std::string stateToString(State state);

    static std::string typeToString(Type type);

    static std::string originalTimeToString(const OriginalTime& originalTime);
};

inline std::string AlertObserverInterface::stateToString(State state) {
    switch (state) {
        case State::READY:
            return "READY";
        case State::STARTED:
            return "STARTED";
        case State::STOPPED:
            return "STOPPED";
        case State::SNOOZED:
            return "SNOOZED";
        case State::COMPLETED:
            return "COMPLETED";
        case State::PAST_DUE:
            return "PAST_DUE";
        case State::FOCUS_ENTERED_FOREGROUND:
            return "FOCUS_ENTERED_FOREGROUND";
        case State::FOCUS_ENTERED_BACKGROUND:
            return "FOCUS_ENTERED_BACKGROUND";
        case State::ERROR:
            return "ERROR";
        case State::DELETED:
            return "DELETED";
        case State::SCHEDULED_FOR_LATER:
            return "SCHEDULED_FOR_LATER";
    }
    return "Unknown State";
}

inline std::string AlertObserverInterface::typeToString(Type type) {
    switch (type) {
        case Type::ALARM:
            return "ALARM";
        case Type::TIMER:
            return "TIMER";
        case Type::REMINDER:
            return "REMINDER";
    }
    return "Unknown Type";
}

inline std::string AlertObserverInterface::originalTimeToString(const OriginalTime& originalTime) {
    std::stringstream ss;
    ss << std::setfill('0') << std::setw(2) << originalTime.hour << ":" << std::setfill('0') << std::setw(2)
       << originalTime.minute << ":" << std::setfill('0') << std::setw(2) << originalTime.second << "."
       << std::setfill('0') << std::setw(3) << originalTime.millisecond;
    return ss.str();
}

inline std::ostream& operator<<(std::ostream& stream, const AlertObserverInterface::State& state) {
    return stream << AlertObserverInterface::stateToString(state);
}

inline std::ostream& operator<<(std::ostream& stream, const AlertObserverInterface::Type& type) {
    return stream << AlertObserverInterface::typeToString(type);
}

inline std::ostream& operator<<(std::ostream& stream, const AlertObserverInterface::OriginalTime& originalTime) {
    return stream << AlertObserverInterface::originalTimeToString(originalTime);
}

}  // namespace acsdkAlertsInterfaces
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ACSDKALERTSINTERFACES_INCLUDE_ACSDKALERTSINTERFACES_ALERTOBSERVERINTERFACE_H_