PowerResourceManagerInterface.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_POWERRESOURCEMANAGERINTERFACE_H_
#define ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_POWERRESOURCEMANAGERINTERFACE_H_

#include <bitset>
#include <chrono>
#include <memory>
#include <ostream>
#include <string>

namespace alexaClientSDK {
namespace avsCommon {
namespace sdkInterfaces {

class PowerResourceManagerInterface {
public:
    enum class PowerResourceLevel {
        STANDBY_LOW = 0,
        STANDBY_MED,
        STANDBY_HIGH,
        ACTIVE_LOW,
        ACTIVE_MED,
        ACTIVE_HIGH
    };

    enum PowerResourceTypeIndex {
        TYPE_CPU = 0,
        TYPE_DDR,
        TYPE_STORAGE,
        TYPE_NETWORK,
        TYPE_RESERVED_ONE,
        TYPE_RESERVED_TWO,
        NUM_OF_TYPES
    };

    using PartialStateBitSet = std::bitset<PowerResourceTypeIndex::NUM_OF_TYPES>;

    enum PowerResourceTypeFlag {
        TYPE_ALL_FLAG = 0,
        TYPE_CPU_FLAG = 1 << PowerResourceTypeIndex::TYPE_CPU,
        TYPE_DDR_FLAG = 1 << PowerResourceTypeIndex::TYPE_DDR,
        TYPE_STORAGE_FLAG = 1 << PowerResourceTypeIndex::TYPE_STORAGE,
        TYPE_NETWORK_FLAG = 1 << PowerResourceTypeIndex::TYPE_NETWORK,
        TYPE_RESERVED_ONE_FLAG = 1 << PowerResourceTypeIndex::TYPE_RESERVED_ONE,
        TYPE_RESERVED_TWO_FLAG = 1 << PowerResourceTypeIndex::TYPE_RESERVED_TWO
    };

    virtual ~PowerResourceManagerInterface() = default;

    virtual void acquirePowerResource(
        const std::string& component,
        const PowerResourceLevel level = PowerResourceLevel::STANDBY_MED) = 0;

    virtual void releasePowerResource(const std::string& component) = 0;

    virtual bool isPowerResourceAcquired(const std::string& component) = 0;

    virtual std::chrono::milliseconds getTimeSinceLastResumeMS();

    virtual std::chrono::milliseconds getTimeSinceLastPartialMS(
        const std::string& component,
        PartialStateBitSet& resourceFlags,
        PartialStateBitSet partialState = PowerResourceTypeFlag::TYPE_ALL_FLAG);

    class PowerResourceId {
    public:
        std::string getResourceId() const {
            return m_resourceId;
        }
        PowerResourceId(const std::string& resourceId) : m_resourceId(resourceId) {
        }

    private:
        const std::string m_resourceId;
    };

    virtual std::shared_ptr<PowerResourceId> create(
        const std::string& resourceId,
        bool isRefCounted = true,
        const PowerResourceLevel level = PowerResourceLevel::STANDBY_MED) = 0;

    virtual bool acquire(
        const std::shared_ptr<PowerResourceId>& id,
        const std::chrono::milliseconds autoReleaseTimeout = std::chrono::milliseconds::zero()) = 0;

    virtual bool release(const std::shared_ptr<PowerResourceId>& id) = 0;

    virtual bool close(const std::shared_ptr<PowerResourceId>& id) = 0;
};

inline std::chrono::milliseconds PowerResourceManagerInterface::getTimeSinceLastResumeMS() {
    return std::chrono::milliseconds::zero();
}

inline std::chrono::milliseconds PowerResourceManagerInterface::getTimeSinceLastPartialMS(
    const std::string& component,
    PartialStateBitSet& resourceFlags,
    PartialStateBitSet partialState) {
    return std::chrono::milliseconds::zero();
}

inline std::string powerResourceLevelToString(PowerResourceManagerInterface::PowerResourceLevel level) {
    switch (level) {
        case PowerResourceManagerInterface::PowerResourceLevel::STANDBY_LOW:
            return "STANDBY_LOW";
        case PowerResourceManagerInterface::PowerResourceLevel::STANDBY_MED:
            return "STANDBY_MED";
        case PowerResourceManagerInterface::PowerResourceLevel::STANDBY_HIGH:
            return "STANDBY_HIGH";
        case PowerResourceManagerInterface::PowerResourceLevel::ACTIVE_LOW:
            return "ACTIVE_LOW";
        case PowerResourceManagerInterface::PowerResourceLevel::ACTIVE_MED:
            return "ACTIVE_MED";
        case PowerResourceManagerInterface::PowerResourceLevel::ACTIVE_HIGH:
            return "ACTIVE_HIGH";
    }

    return "UNKNOWN";
}

inline std::ostream& operator<<(std::ostream& stream, PowerResourceManagerInterface::PowerResourceLevel level) {
    return stream << powerResourceLevelToString(level);
}

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

#endif  // ALEXA_CLIENT_SDK_AVSCOMMON_SDKINTERFACES_INCLUDE_AVSCOMMON_SDKINTERFACES_POWERRESOURCEMANAGERINTERFACE_H_