Channel.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_CHANNEL_H_
#define ALEXA_CLIENT_SDK_AFML_INCLUDE_AFML_CHANNEL_H_

#include <algorithm>
#include <chrono>
#include <list>
#include <memory>
#include <string>

#include <AVSCommon/AVS/ContentType.h>
#include <AVSCommon/AVS/FocusState.h>
#include <AVSCommon/SDKInterfaces/ChannelObserverInterface.h>
#include <AVSCommon/SDKInterfaces/FocusManagerInterface.h>
#include <AVSCommon/Utils/Timing/Timer.h>

#include <AVSCommon/Utils/Power/PowerResource.h>

namespace alexaClientSDK {
namespace afml {

class Channel {
public:
    /*
     * This class contains the states of the @c Channel.
     */
    struct State {
        State(const std::string& name);

        State();

        /*
         * The channel's name.  Although the name is not dynamic, it is useful for identifying which channel the state
         * belongs to.
         */
        std::string name;

        avsCommon::avs::FocusState focusState;

        std::string interfaceName;

        std::chrono::steady_clock::time_point timeAtIdle;
    };

    Channel(const std::string& name, const unsigned int priority, bool isVirtual = false);

    const std::string& getName() const;

    unsigned int getPriority() const;

    bool setFocus(avsCommon::avs::FocusState focus, avsCommon::avs::MixingBehavior behavior, bool forceUpdate = false);

    void setPrimaryActivity(std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> activity);

    bool releaseActivity(std::shared_ptr<avsCommon::sdkInterfaces::ChannelObserverInterface> observer);

    bool releaseActivity(const std::string& interfaceName);

    bool isActive();

    bool operator>(const Channel& rhs) const;

    std::string getInterface() const;

    Channel::State getState() const;

    std::vector<Channel::State> getActivityUpdates();

    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> getPrimaryActivity();

    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> getActivity(
        const std::string& interfaceName);

    std::vector<std::string> getInterfaceList() const;

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

    bool releaseActivityLocked(
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> activityToRelease);

    bool removeActivityHelperLocked(
        std::list<std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity>>::iterator
            activityToRemoveIt);
    void addToChannelUpdatesLocked(const std::string& interfaceName, avsCommon::avs::FocusState focusState);

    void processPolicyLocked(
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> incomingActivity,
        std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> currentActivity);

    void patienceTimerCallback(std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> activity);

    void updateChannelInterfaceLocked();

    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> getPrimaryActivityLocked() const;

private:
    const unsigned int m_priority;

    bool m_isVirtual;

    State m_state;

    std::list<std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity>> m_activities;

    mutable std::mutex m_mutex;

    std::vector<Channel::State> m_activityUpdates;

    avsCommon::utils::timing::Timer m_patienceTimer;

    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> m_patienceInitiator;

    std::shared_ptr<avsCommon::sdkInterfaces::FocusManagerInterface::Activity> m_patienceReceiver;

    std::shared_ptr<avsCommon::utils::power::PowerResource> m_powerResource;
};
}  // namespace afml
}  // namespace alexaClientSDK

#endif  // ALEXA_CLIENT_SDK_AFML_INCLUDE_AFML_CHANNEL_H_