FocusManager.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_AFML_INCLUDE_AFML_FOCUSMANAGER_H_
#define ALEXA_CLIENT_SDK_AFML_INCLUDE_AFML_FOCUSMANAGER_H_

#include <algorithm>
#include <map>
#include <mutex>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include <acsdkManufactory/Annotated.h>
#include <AVSCommon/SDKInterfaces/AudioFocusAnnotation.h>
#include <AVSCommon/SDKInterfaces/ChannelObserverInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/Utils/Threading/Executor.h>
#include <InterruptModel/InterruptModel.h>

#include "AFML/Channel.h"
#include "AFML/ActivityTrackerInterface.h"

namespace alexaClientSDK {
namespace afml {

class FocusManager : public avsCommon::sdkInterfaces::FocusManagerInterface {
public:
    class ChannelConfiguration {
    public:
        ChannelConfiguration(const std::string& configName, unsigned int configPriority) :
                name{configName},
                priority{configPriority} {
        }

        std::string toString() const {
            return "name:'" + name + "', priority:" + std::to_string(priority);
        }

        std::string name;

        unsigned int priority;

        static bool readChannelConfiguration(
            const std::string& channelTypeKey,
            std::vector<afml::FocusManager::ChannelConfiguration>* virtualChannelConfigurations);
    };

    FocusManager(
        const std::vector<ChannelConfiguration>& channelConfigurations,
        std::shared_ptr<ActivityTrackerInterface> activityTrackerInterface = nullptr,
        const std::vector<ChannelConfiguration>& virtualChannelConfigurations = std::vector<ChannelConfiguration>(),
        std::shared_ptr<interruptModel::InterruptModel> interruptModel = nullptr);

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

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

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

    void stopForegroundActivity() override;

    void stopAllActivities() override;

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

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

    void modifyContentType(
        const std::string& channelName,
        const std::string& interfaceName,
        avsCommon::avs::ContentType contentType) override;

    static const std::vector<FocusManager::ChannelConfiguration> getDefaultAudioChannels();

    static const std::vector<FocusManager::ChannelConfiguration> getDefaultVisualChannels();

private:
    using ChannelsToInterfaceNamesMap = std::map<std::shared_ptr<Channel>, std::string>;
    struct ChannelPtrComparator {
        bool operator()(const std::shared_ptr<Channel>& first, const std::shared_ptr<Channel>& second) const {
            return *first > *second;
        }
    };

    void readChannelConfiguration(const std::vector<ChannelConfiguration>& channelConfigurations, bool isVirtual);

    void setChannelFocus(
        const std::shared_ptr<Channel>& channel,
        avsCommon::avs::FocusState focus,
        avsCommon::avs::MixingBehavior behavior,
        bool forceUpdate = false);

    void acquireChannelHelper(
        std::shared_ptr<Channel> channelToAcquire,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> channelActivity);

    void releaseChannelHelper(
        std::shared_ptr<Channel> channelToRelease,
        std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> channelObserver,
        std::shared_ptr<std::promise<bool>> releaseChannelSuccess,
        const std::string& channelName);

    void stopForegroundActivityHelper(
        std::shared_ptr<Channel> foregroundChannel,
        std::string foregroundChannelInterface);

    void stopAllActivitiesHelper(const ChannelsToInterfaceNamesMap& channelsOwnersMap);

    std::shared_ptr<Channel> getChannel(const std::string& channelName) const;

    std::shared_ptr<Channel> getHighestPriorityActiveChannelLocked() const;

    bool isChannelForegroundedLocked(const std::shared_ptr<Channel>& channel) const;

    bool doesChannelNameExist(const std::string& name) const;

    bool doesChannelPriorityExist(const unsigned int priority) const;

    void foregroundHighestPriorityActiveChannel();

    void notifyActivityTracker();

    avsCommon::avs::MixingBehavior getMixingBehavior(
        std::shared_ptr<Channel> lowPrioChannel,
        std::shared_ptr<Channel> highPrioChannel);

    void setBackgroundChannelMixingBehavior(std::shared_ptr<Channel> foregroundChannel);

    std::mutex m_mutex;

    std::unordered_map<std::string, std::shared_ptr<Channel>> m_allChannels;

    std::set<std::shared_ptr<Channel>, ChannelPtrComparator> m_activeChannels;

    std::unordered_set<std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerObserverInterface>> m_observers;

    /*
     * A vector of channel's State that has been updated due to @c acquireChannel(), @c releaseChannel() or
     * stopForegroundActivity().  This is accessed by functions in the @c m_executor worker thread, and do not require
     * any synchronization.
     */
    std::vector<Channel::State> m_activityUpdates;

    std::shared_ptr<ActivityTrackerInterface> m_activityTracker;

    std::shared_ptr<interruptModel::InterruptModel> m_interruptModel;

    avsCommon::utils::threading::Executor m_executor;
};

}  // namespace afml
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AFML_INCLUDE_AFML_FOCUSMANAGER_H_