Alert.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_ACSDKALERTS_INCLUDE_ACSDKALERTS_ALERT_H_
#define ALEXA_CLIENT_SDK_ACSDKALERTS_INCLUDE_ACSDKALERTS_ALERT_H_

#include "acsdkAlerts/Renderer/Renderer.h"
#include "acsdkAlerts/Renderer/RendererObserverInterface.h"

#include <AVSCommon/AVS/FocusState.h>
#include <AVSCommon/AVS/MixingBehavior.h>
#include <AVSCommon/Utils/Timing/Timer.h>
#include <AVSCommon/Utils/Timing/TimePoint.h>
#include <AVSCommon/Utils/Timing/TimeUtils.h>
#include <acsdkAlertsInterfaces/AlertObserverInterface.h>

#include <Settings/DeviceSettingsManager.h>

#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>

#include <rapidjson/document.h>

namespace alexaClientSDK {
namespace acsdkAlerts {

class Alert
        : public renderer::RendererObserverInterface
        , public std::enable_shared_from_this<Alert> {
public:
    enum class State {
        UNSET,
        SET,
        READY,
        ACTIVATING,
        ACTIVE,
        SNOOZING,
        SNOOZED,
        STOPPING,
        STOPPED,
        COMPLETED
    };

    enum class StopReason {
        UNSET,
        AVS_STOP,
        LOCAL_STOP,
        SHUTDOWN,
        LOG_OUT
    };

    struct Asset {
        Asset() = default;

        Asset(const std::string& id, const std::string& url) : id{id}, url{url} {
        }

        std::string id;
        std::string url;
    };

    struct AssetConfiguration {
        AssetConfiguration() : loopPause{std::chrono::milliseconds{0}} {
        }

        std::unordered_map<std::string, Asset> assets;
        std::vector<std::string> assetPlayOrderItems;
        std::string backgroundAssetId;
        std::chrono::milliseconds loopPause;
    };

    struct StaticData {
        StaticData() : dbId{0} {
        }
        std::string token;

        int dbId;
    };

    struct DynamicData {
        DynamicData() : state{State::SET}, loopCount{0}, hasRenderingFailed{false}, originalTime(""), label("") {
        }
        State state;

        avsCommon::utils::timing::TimePoint timePoint;

        int loopCount;

        bool hasRenderingFailed;

        std::string originalTime;

        std::string label;

        AssetConfiguration assetConfiguration;
    };

    enum class ParseFromJsonStatus {
        OK,
        MISSING_REQUIRED_PROPERTY,
        INVALID_VALUE
    };

    struct ContextInfo {
        ContextInfo(const std::string& token, const std::string& type, const std::string& scheduledTime_ISO_8601) :
                token{token},
                type{type},
                scheduledTime_ISO_8601{scheduledTime_ISO_8601} {
        }

        std::string token;
        std::string type;
        std::string scheduledTime_ISO_8601;
    };

    static avsCommon::utils::Optional<acsdkAlertsInterfaces::AlertObserverInterface::OriginalTime>
    validateOriginalTimeString(const std::string& originalTimeStr);

    static avsCommon::utils::Optional<std::string> validateLabelString(const std::string& label);

    static std::string stateToString(Alert::State state);

    static std::string stopReasonToString(Alert::StopReason stopReason);

    static std::string parseFromJsonStatusToString(Alert::ParseFromJsonStatus parseFromJsonStatus);

    Alert(
        std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
            defaultAudioFactory,
        std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()> shortAudioFactory,
        std::shared_ptr<settings::DeviceSettingsManager> settingsManager);

    virtual std::string getTypeName() const = 0;

    std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
    getDefaultAudioFactory() const;

    std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()> getShortAudioFactory()
        const;

    Alert::ContextInfo getContextInfo() const;

    acsdkAlertsInterfaces::AlertObserverInterface::AlertInfo createAlertInfo(
        acsdkAlertsInterfaces::AlertObserverInterface::State state,
        const std::string& reason = "") const;

    void onRendererStateChange(renderer::RendererObserverInterface::State state, const std::string& reason) override;

    ParseFromJsonStatus parseFromJson(const rapidjson::Value& payload, std::string* errorMessage);

    void setRenderer(std::shared_ptr<renderer::RendererInterface> renderer);

    void setObserver(acsdkAlertsInterfaces::AlertObserverInterface* observer);

    void activate();

    void deactivate(StopReason reason);

    bool updateScheduledTime(const std::string& newScheduledTime);

    bool snooze(const std::string& updatedScheduledTime);

    void setFocusState(avsCommon::avs::FocusState focusState, avsCommon::avs::MixingBehavior behavior);

    bool setStateActive();

    void reset();

    std::string getToken() const;

    int64_t getScheduledTime_Unix() const;

    std::string getScheduledTime_ISO_8601() const;

    std::chrono::system_clock::time_point getScheduledTime_Utc_TimePoint() const;

    acsdkAlertsInterfaces::AlertObserverInterface::Type getType() const;

    avsCommon::utils::Optional<acsdkAlertsInterfaces::AlertObserverInterface::OriginalTime> getOriginalTime() const;

    avsCommon::utils::Optional<std::string> getLabel() const;

    Alert::State getState() const;

    StopReason getStopReason() const;

    void getAlertData(StaticData* staticData, DynamicData* dynamicData) const;

    bool setAlertData(StaticData* staticData, DynamicData* dynamicData);

    int getId() const;

    bool isPastDue(int64_t currentUnixTime, std::chrono::seconds timeLimit);

    int getLoopCount() const;

    std::chrono::milliseconds getLoopPause() const;

    std::string getBackgroundAssetId() const;

    AssetConfiguration getAssetConfiguration() const;

    bool setAssetConfiguration(const AssetConfiguration& assetConfiguration);

    void printDiagnostic();

private:
    std::string getTokenLocked() const;

    Alert::State getStateLocked() const;

    int64_t getScheduledTime_UnixLocked() const;

    std::string getScheduledTime_ISO_8601Locked() const;

    std::chrono::system_clock::time_point getScheduledTime_Utc_TimePointLocked() const;

    avsCommon::utils::Optional<acsdkAlertsInterfaces::AlertObserverInterface::OriginalTime> getOriginalTimeLocked()
        const;

    avsCommon::utils::Optional<std::string> getLabelLocked() const;

    acsdkAlertsInterfaces::AlertObserverInterface::AlertInfo createAlertInfoLocked(
        acsdkAlertsInterfaces::AlertObserverInterface::State state,
        const std::string& reason = "") const;

    void startRenderer();

    void startRendererLocked();

    void onMaxTimerExpiration();

    bool isAlertPausedLocked() const;

    void notifyObserver(acsdkAlertsInterfaces::AlertObserverInterface::State state, const std::string& reason = "")
        const;

    mutable std::mutex m_mutex;
    StaticData m_staticData;
    DynamicData m_dynamicData;
    StopReason m_stopReason;
    avsCommon::avs::FocusState m_focusState;
    avsCommon::avs::MixingBehavior m_mixingBehavior;
    bool m_hasTimerExpired;
    avsCommon::utils::timing::Timer m_maxLengthTimer;
    acsdkAlertsInterfaces::AlertObserverInterface* m_observer;
    std::shared_ptr<renderer::RendererInterface> m_renderer;
    const std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
        m_defaultAudioFactory;
    const std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
        m_shortAudioFactory;
    std::shared_ptr<settings::DeviceSettingsManager> m_settingsManager;
    bool m_focusChangedDuringAlertActivation;
    bool m_startRendererAgainAfterFullStop;
};

struct TimeComparator {
    bool operator()(const std::shared_ptr<Alert>& lhs, const std::shared_ptr<Alert>& rhs) const {
        if (lhs->getScheduledTime_Unix() == rhs->getScheduledTime_Unix()) {
            return (lhs->getToken() < rhs->getToken());
        }

        return (lhs->getScheduledTime_Unix() < rhs->getScheduledTime_Unix());
    }
};

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

inline std::ostream& operator<<(std::ostream& stream, const Alert::StopReason& reason) {
    return stream << Alert::stopReasonToString(reason);
}

inline std::ostream& operator<<(std::ostream& stream, const Alert::ParseFromJsonStatus& status) {
    return stream << Alert::parseFromJsonStatusToString(status);
}

}  // namespace acsdkAlerts
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_ACSDKALERTS_INCLUDE_ACSDKALERTS_ALERT_H_