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_