FocusManagerInterface.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_FOCUSMANAGERINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_FOCUSMANAGERINTERFACE_H_

#include <future>
#include <memory>
#include <mutex>
#include <string>
#include <vector>

#include <AVSCommon/AVS/ContentType.h>
#include "ChannelObserverInterface.h"
#include "FocusManagerObserverInterface.h"

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {

class FocusManagerInterface {
public:
    class Activity {
    public:
        static std::shared_ptr<Activity> create(
            const std::string& interfaceName,
            const std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface>& channelObserver,
            const std::chrono::milliseconds& patienceDuration = std::chrono::milliseconds::zero(),
            const avsCommon::avs::ContentType contentType = avsCommon::avs::ContentType::NONMIXABLE);

        bool operator==(const Activity& rhs) {
            return this->m_interface == rhs.m_interface;
        }

        const std::string getInterface() const;

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

        avsCommon::avs::ContentType getContentType() const;

        void setContentType(avsCommon::avs::ContentType contentType);

        avsCommon::avs::MixingBehavior getMixingBehavior() const;

        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> getChannelObserver() const;

        bool notifyObserver(avs::FocusState focus, avsCommon::avs::MixingBehavior behavior);

    private:
        Activity(
            const std::string& interfaceName,
            const std::chrono::milliseconds& patienceDuration,
            const std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface>& channelObserver,
            const avsCommon::avs::ContentType contentType) :
                m_interface{interfaceName},
                m_patienceDuration{patienceDuration},
                m_channelObserver{channelObserver},
                m_contentType{contentType},
                m_mixingBehavior{avsCommon::avs::MixingBehavior::UNDEFINED} {
        }

        void setMixingBehavior(avsCommon::avs::MixingBehavior behavior);

        // The mutex that synchronizes all operations within the activity
        mutable std::mutex m_mutex;

        // The interface name of the Activity.
        const std::string m_interface;

        // The duration of patience in milliseconds of the Activity.
        const std::chrono::milliseconds m_patienceDuration;

        // The channel observer of the Activity.
        const std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> m_channelObserver;

        // The ContentType associated with this Activity
        avsCommon::avs::ContentType m_contentType;

        // Last MixingBehavior associated with this activity
        avsCommon::avs::MixingBehavior m_mixingBehavior;
    };

    static constexpr const char* DIALOG_CHANNEL_NAME = "Dialog";

    static constexpr unsigned int DIALOG_CHANNEL_PRIORITY = 100;

    static constexpr const char* COMMUNICATIONS_CHANNEL_NAME = "Communications";

    static constexpr unsigned int COMMUNICATIONS_CHANNEL_PRIORITY = 150;

    static constexpr const char* ALERT_CHANNEL_NAME = "Alert";

    static constexpr unsigned int ALERT_CHANNEL_PRIORITY = 200;

    static constexpr const char* CONTENT_CHANNEL_NAME = "Content";

    static constexpr unsigned int CONTENT_CHANNEL_PRIORITY = 300;

    static constexpr const char* VISUAL_CHANNEL_NAME = "Visual";

    static constexpr unsigned int VISUAL_CHANNEL_PRIORITY = 100;

    virtual ~FocusManagerInterface() = default;

    virtual bool acquireChannel(
        const std::string& channelName,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> channelObserver,
        const std::string& interfaceName) = 0;

    virtual bool acquireChannel(
        const std::string& channelName,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> channelActivity) = 0;

    virtual std::future<bool> releaseChannel(
        const std::string& channelName,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> channelObserver) = 0;

    virtual void stopForegroundActivity() = 0;

    virtual void stopAllActivities() = 0;

    virtual void addObserver(
        const std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerObserverInterface>& observer) = 0;

    virtual void removeObserver(
        const std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerObserverInterface>& observer) = 0;

    virtual void modifyContentType(
        const std::string& channelName,
        const std::string& interfaceName,
        avsCommon::avs::ContentType contentType) = 0;
};

inline std::shared_ptr<FocusManagerInterface::Activity> FocusManagerInterface::Activity::create(
    const std::string& interfaceName,
    const std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface>& channelObserver,
    const std::chrono::milliseconds& patienceDuration,
    const avsCommon::avs::ContentType contentType) {
    if (interfaceName.empty() || patienceDuration.count() < 0 || channelObserver == nullptr) {
        return nullptr;
    }

    auto activity = std::shared_ptr<FocusManagerInterface::Activity>(
        new FocusManagerInterface::Activity(interfaceName, patienceDuration, channelObserver, contentType));
    return activity;
}

inline const std::string FocusManagerInterface::Activity::getInterface() const {
    return m_interface;
}

inline std::chrono::milliseconds FocusManagerInterface::Activity::getPatienceDuration() const {
    return m_patienceDuration;
}

inline avsCommon::avs::ContentType FocusManagerInterface::Activity::getContentType() const {
    std::unique_lock<std::mutex> lock(m_mutex);
    return m_contentType;
}

inline void FocusManagerInterface::Activity::setContentType(avsCommon::avs::ContentType contentType) {
    std::unique_lock<std::mutex> lock(m_mutex);
    m_contentType = contentType;
}

inline avsCommon::avs::MixingBehavior FocusManagerInterface::Activity::getMixingBehavior() const {
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_mixingBehavior;
}

inline std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> FocusManagerInterface::Activity::
    getChannelObserver() const {
    return m_channelObserver;
}

inline bool FocusManagerInterface::Activity::notifyObserver(
    avs::FocusState focus,
    avsCommon::avs::MixingBehavior behavior) {
    if (m_channelObserver) {
        avsCommon::avs::MixingBehavior overrideBehavior{behavior};
        // If the activity/channelObserver is already paused , do not duck
        if ((avsCommon::avs::MixingBehavior::MUST_PAUSE == getMixingBehavior()) &&
            (avsCommon::avs::MixingBehavior::MAY_DUCK == behavior)) {
            overrideBehavior = avsCommon::avs::MixingBehavior::MUST_PAUSE;
        }

        m_channelObserver->onFocusChanged(focus, overrideBehavior);
        // Set the current mixing behavior that the observer received.
        setMixingBehavior(overrideBehavior);
        return true;
    }
    return false;
}

inline void FocusManagerInterface::Activity::setMixingBehavior(avsCommon::avs::MixingBehavior behavior) {
    std::unique_lock<std::mutex> lock(m_mutex);
    m_mixingBehavior = behavior;
}

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

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_FOCUSMANAGERINTERFACE_H_