services/surfaceflinger/Scheduler/RefreshRateConfigs.h - android_frameworks_native - Gitiles

 /*
  * Copyright 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License 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.
  */

 #pragma once

 #include <android-base/stringprintf.h>

 #include <algorithm>
 #include <numeric>
 #include <optional>
 #include <type_traits>

 #include "DisplayHardware/HWComposer.h"
 #include "HwcStrongTypes.h"
 #include "Scheduler/SchedulerUtils.h"
 #include "Scheduler/StrongTyping.h"

 namespace android::scheduler {

 using namespace std::chrono_literals;

 enum class RefreshRateConfigEvent : unsigned { None = 0b0, Changed = 0b1 };

 inline RefreshRateConfigEvent operator|(RefreshRateConfigEvent lhs, RefreshRateConfigEvent rhs) {
     using T = std::underlying_type_t<RefreshRateConfigEvent>;
     return static_cast<RefreshRateConfigEvent>(static_cast<T>(lhs) | static_cast<T>(rhs));
 }

 /**
  * This class is used to encapsulate configuration for refresh rates. It holds information
  * about available refresh rates on the device, and the mapping between the numbers and human
  * readable names.
  */
 class RefreshRateConfigs {
 public:
     // Margin used when matching refresh rates to the content desired ones.
     static constexpr nsecs_t MARGIN_FOR_PERIOD_CALCULATION =
         std::chrono::nanoseconds(800us).count();

     class RefreshRate {
     private:
         // Effectively making the constructor private while allowing
         // std::make_unique to create the object
         struct ConstructorTag {
             explicit ConstructorTag(int) {}
         };

     public:
         RefreshRate(HwcConfigIndexType configId,
                     std::shared_ptr<const HWC2::Display::Config> config, std::string name,
                     float fps, ConstructorTag)
               : configId(configId), hwcConfig(config), name(std::move(name)), fps(fps) {}

         RefreshRate(const RefreshRate&) = delete;

         HwcConfigIndexType getConfigId() const { return configId; }
         nsecs_t getVsyncPeriod() const { return hwcConfig->getVsyncPeriod(); }
         int32_t getConfigGroup() const { return hwcConfig->getConfigGroup(); }
         const std::string& getName() const { return name; }
         float getFps() const { return fps; }

         // Checks whether the fps of this RefreshRate struct is within a given min and max refresh
         // rate passed in. FPS_EPSILON is applied to the boundaries for approximation.
         bool inPolicy(float minRefreshRate, float maxRefreshRate) const {
             return (fps >= (minRefreshRate - FPS_EPSILON) && fps <= (maxRefreshRate + FPS_EPSILON));
         }

         bool operator!=(const RefreshRate& other) const {
             return configId != other.configId || hwcConfig != other.hwcConfig;
         }

         bool operator<(const RefreshRate& other) const { return getFps() < other.getFps(); }

         bool operator==(const RefreshRate& other) const { return !(*this != other); }

     private:
         friend RefreshRateConfigs;
         friend class RefreshRateConfigsTest;

         // The tolerance within which we consider FPS approximately equals.
         static constexpr float FPS_EPSILON = 0.001f;

         // This config ID corresponds to the position of the config in the vector that is stored
         // on the device.
         const HwcConfigIndexType configId;
         // The config itself
         std::shared_ptr<const HWC2::Display::Config> hwcConfig;
         // Human readable name of the refresh rate.
         const std::string name;
         // Refresh rate in frames per second
         const float fps = 0;
     };

     using AllRefreshRatesMapType =
             std::unordered_map<HwcConfigIndexType, std::unique_ptr<const RefreshRate>>;

     struct Policy {
         struct Range {
             float min = 0;
             float max = std::numeric_limits<float>::max();

             bool operator==(const Range& other) const {
                 return min == other.min && max == other.max;
             }

             bool operator!=(const Range& other) const { return !(*this == other); }
         };

         // The default config, used to ensure we only initiate display config switches within the
         // same config group as defaultConfigId's group.
         HwcConfigIndexType defaultConfig;
         // The primary refresh rate range represents display manager's general guidance on the
         // display configs we'll consider when switching refresh rates. Unless we get an explicit
         // signal from an app, we should stay within this range.
         Range primaryRange;
         // The app request refresh rate range allows us to consider more display configs when
         // switching refresh rates. Although we should generally stay within the primary range,
         // specific considerations, such as layer frame rate settings specified via the
         // setFrameRate() api, may cause us to go outside the primary range. We never go outside the
         // app request range. The app request range will be greater than or equal to the primary
         // refresh rate range, never smaller.
         Range appRequestRange;
         // Whether or not we switch config groups to get the best frame rate. Only used by tests.
         bool allowGroupSwitching = false;

         Policy() = default;
         Policy(HwcConfigIndexType defaultConfig, const Range& range)
               : Policy(defaultConfig, range, range) {}
         Policy(HwcConfigIndexType defaultConfig, const Range& primaryRange,
                const Range& appRequestRange)
               : defaultConfig(defaultConfig),
                 primaryRange(primaryRange),
                 appRequestRange(appRequestRange) {}

         bool operator==(const Policy& other) const {
             return defaultConfig == other.defaultConfig && primaryRange == other.primaryRange &&
                     appRequestRange == other.appRequestRange &&
                     allowGroupSwitching == other.allowGroupSwitching;
         }

         bool operator!=(const Policy& other) const { return !(*this == other); }
     };

     // Return code set*Policy() to indicate the current policy is unchanged.
     static constexpr int CURRENT_POLICY_UNCHANGED = 1;

     // We maintain the display manager policy and the override policy separately. The override
     // policy is used by CTS tests to get a consistent device state for testing. While the override
     // policy is set, it takes precedence over the display manager policy. Once the override policy
     // is cleared, we revert to using the display manager policy.

     // Sets the display manager policy to choose refresh rates. The return value will be:
     //   - A negative value if the policy is invalid or another error occurred.
     //   - NO_ERROR if the policy was successfully updated, and the current policy is different from
     //     what it was before the call.
     //   - CURRENT_POLICY_UNCHANGED if the policy was successfully updated, but the current policy
     //     is the same as it was before the call.
     status_t setDisplayManagerPolicy(const Policy& policy) EXCLUDES(mLock);
     // Sets the override policy. See setDisplayManagerPolicy() for the meaning of the return value.
     status_t setOverridePolicy(const std::optional<Policy>& policy) EXCLUDES(mLock);
     // Gets the current policy, which will be the override policy if active, and the display manager
     // policy otherwise.
     Policy getCurrentPolicy() const EXCLUDES(mLock);
     // Gets the display manager policy, regardless of whether an override policy is active.
     Policy getDisplayManagerPolicy() const EXCLUDES(mLock);

     // Returns true if config is allowed by the current policy.
     bool isConfigAllowed(HwcConfigIndexType config) const EXCLUDES(mLock);

     // Describes the different options the layer voted for refresh rate
     enum class LayerVoteType {
         NoVote,          // Doesn't care about the refresh rate
         Min,             // Minimal refresh rate available
         Max,             // Maximal refresh rate available
         Heuristic,       // Specific refresh rate that was calculated by platform using a heuristic
         ExplicitDefault, // Specific refresh rate that was provided by the app with Default
                          // compatibility
         ExplicitExactOrMultiple // Specific refresh rate that was provided by the app with
                                 // ExactOrMultiple compatibility
     };

     // Captures the layer requirements for a refresh rate. This will be used to determine the
     // display refresh rate.
     struct LayerRequirement {
         // Layer's name. Used for debugging purposes.
         std::string name;
         // Layer vote type.
         LayerVoteType vote = LayerVoteType::NoVote;
         // Layer's desired refresh rate, if applicable.
         float desiredRefreshRate = 0.0f;
         // Layer's weight in the range of [0, 1]. The higher the weight the more impact this layer
         // would have on choosing the refresh rate.
         float weight = 0.0f;
         // Whether layer is in focus or not based on WindowManager's state
         bool focused = false;

         bool operator==(const LayerRequirement& other) const {
             return name == other.name && vote == other.vote &&
                     desiredRefreshRate == other.desiredRefreshRate && weight == other.weight &&
                     focused == other.focused;
         }

         bool operator!=(const LayerRequirement& other) const { return !(*this == other); }
     };

     // Returns the refresh rate that fits best to the given layers.
     const RefreshRate& getRefreshRateForContent(const std::vector<LayerRequirement>& layers) const
             EXCLUDES(mLock);

     // Global state describing signals that affect refresh rate choice.
     struct GlobalSignals {
         // Whether the user touched the screen recently. Used to apply touch boost.
         bool touch = false;
         // True if the system hasn't seen any buffers posted to layers recently.
         bool idle = false;
     };

     // Returns the refresh rate that fits best to the given layers.
     //   layers - The layer requirements to consider.
     //   globalSignals - global state of touch and idle
     //   outSignalsConsidered - An output param that tells the caller whether the refresh rate was
     //                          chosen based on touch boost and/or idle timer.
     const RefreshRate& getBestRefreshRate(const std::vector<LayerRequirement>& layers,
                                           const GlobalSignals& globalSignals,
                                           GlobalSignals* outSignalsConsidered = nullptr) const
             EXCLUDES(mLock);

     // Returns all the refresh rates supported by the device. This won't change at runtime.
     const AllRefreshRatesMapType& getAllRefreshRates() const EXCLUDES(mLock);

     // Returns the lowest refresh rate supported by the device. This won't change at runtime.
     const RefreshRate& getMinRefreshRate() const { return *mMinSupportedRefreshRate; }

     // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
     // uses the primary range, not the app request range.
     const RefreshRate& getMinRefreshRateByPolicy() const EXCLUDES(mLock);

     // Returns the highest refresh rate supported by the device. This won't change at runtime.
     const RefreshRate& getMaxRefreshRate() const { return *mMaxSupportedRefreshRate; }

     // Returns the highest refresh rate according to the current policy. May change at runtime. Only
     // uses the primary range, not the app request range.
     const RefreshRate& getMaxRefreshRateByPolicy() const EXCLUDES(mLock);

     // Returns the current refresh rate
     const RefreshRate& getCurrentRefreshRate() const EXCLUDES(mLock);

     // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
     // the policy.
     const RefreshRate& getCurrentRefreshRateByPolicy() const;

     // Returns the refresh rate that corresponds to a HwcConfigIndexType. This won't change at
     // runtime.
     const RefreshRate& getRefreshRateFromConfigId(HwcConfigIndexType configId) const {
         return *mRefreshRates.at(configId);
     };

     // Stores the current configId the device operates at
     void setCurrentConfigId(HwcConfigIndexType configId) EXCLUDES(mLock);

     // Returns a string that represents the layer vote type
     static std::string layerVoteTypeString(LayerVoteType vote);

     // Returns a known frame rate that is the closest to frameRate
     float findClosestKnownFrameRate(float frameRate) const;

     RefreshRateConfigs(const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs,
                        HwcConfigIndexType currentConfigId);

     // Returns whether switching configs (refresh rate or resolution) is possible.
     // TODO(b/158780872): Consider HAL support, and skip frame rate detection if the configs only
     // differ in resolution.
     bool canSwitch() const { return mRefreshRates.size() > 1; }

     // Class to enumerate options around toggling the kernel timer on and off. We have an option
     // for no change to avoid extra calls to kernel.
     enum class KernelIdleTimerAction {
         NoChange, // Do not change the idle timer.
         TurnOff,  // Turn off the idle timer.
         TurnOn    // Turn on the idle timer.
     };
     // Checks whether kernel idle timer should be active depending the policy decisions around
     // refresh rates.
     KernelIdleTimerAction getIdleTimerAction() const;

 private:
     friend class RefreshRateConfigsTest;

     void constructAvailableRefreshRates() REQUIRES(mLock);
     static std::vector<float> constructKnownFrameRates(
             const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs);

     void getSortedRefreshRateList(
             const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
             std::vector<const RefreshRate*>* outRefreshRates);

     // Returns the refresh rate with the highest score in the collection specified from begin
     // to end. If there are more than one with the same highest refresh rate, the first one is
     // returned.
     template <typename Iter>
     const RefreshRate* getBestRefreshRate(Iter begin, Iter end) const;

     // Returns number of display frames and remainder when dividing the layer refresh period by
     // display refresh period.
     std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const;

     // Returns the lowest refresh rate according to the current policy. May change at runtime. Only
     // uses the primary range, not the app request range.
     const RefreshRate& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock);

     // Returns the highest refresh rate according to the current policy. May change at runtime. Only
     // uses the primary range, not the app request range.
     const RefreshRate& getMaxRefreshRateByPolicyLocked() const REQUIRES(mLock);

     // Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
     // the policy.
     const RefreshRate& getCurrentRefreshRateByPolicyLocked() const REQUIRES(mLock);

     const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
     bool isPolicyValid(const Policy& policy);

     // The list of refresh rates, indexed by display config ID. This must not change after this
     // object is initialized.
     AllRefreshRatesMapType mRefreshRates;

     // The list of refresh rates in the primary range of the current policy, ordered by vsyncPeriod
     // (the first element is the lowest refresh rate).
     std::vector<const RefreshRate*> mPrimaryRefreshRates GUARDED_BY(mLock);

     // The list of refresh rates in the app request range of the current policy, ordered by
     // vsyncPeriod (the first element is the lowest refresh rate).
     std::vector<const RefreshRate*> mAppRequestRefreshRates GUARDED_BY(mLock);

     // The current config. This will change at runtime. This is set by SurfaceFlinger on
     // the main thread, and read by the Scheduler (and other objects) on other threads.
     const RefreshRate* mCurrentRefreshRate GUARDED_BY(mLock);

     // The policy values will change at runtime. They're set by SurfaceFlinger on the main thread,
     // and read by the Scheduler (and other objects) on other threads.
     Policy mDisplayManagerPolicy GUARDED_BY(mLock);
     std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);

     // The min and max refresh rates supported by the device.
     // This will not change at runtime.
     const RefreshRate* mMinSupportedRefreshRate;
     const RefreshRate* mMaxSupportedRefreshRate;

     mutable std::mutex mLock;

     // A sorted list of known frame rates that a Heuristic layer will choose
     // from based on the closest value.
     const std::vector<float> mKnownFrameRates;
 };

 } // namespace android::scheduler
	/*
	* Copyright 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License 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.
	*/

	#pragma once

	#include <android-base/stringprintf.h>

	#include <algorithm>
	#include <numeric>
	#include <optional>
	#include <type_traits>

	#include "DisplayHardware/HWComposer.h"
	#include "HwcStrongTypes.h"
	#include "Scheduler/SchedulerUtils.h"
	#include "Scheduler/StrongTyping.h"

	namespace android::scheduler {

	using namespace std::chrono_literals;

	enum class RefreshRateConfigEvent : unsigned { None = 0b0, Changed = 0b1 };

	inline RefreshRateConfigEvent operator\|(RefreshRateConfigEvent lhs, RefreshRateConfigEvent rhs) {
	using T = std::underlying_type_t<RefreshRateConfigEvent>;
	return static_cast<RefreshRateConfigEvent>(static_cast<T>(lhs) \| static_cast<T>(rhs));
	}

	/**
	* This class is used to encapsulate configuration for refresh rates. It holds information
	* about available refresh rates on the device, and the mapping between the numbers and human
	* readable names.
	*/
	class RefreshRateConfigs {
	public:
	// Margin used when matching refresh rates to the content desired ones.
	static constexpr nsecs_t MARGIN_FOR_PERIOD_CALCULATION =
	std::chrono::nanoseconds(800us).count();

	class RefreshRate {
	private:
	// Effectively making the constructor private while allowing
	// std::make_unique to create the object
	struct ConstructorTag {
	explicit ConstructorTag(int) {}
	};

	public:
	RefreshRate(HwcConfigIndexType configId,
	std::shared_ptr<const HWC2::Display::Config> config, std::string name,
	float fps, ConstructorTag)
	: configId(configId), hwcConfig(config), name(std::move(name)), fps(fps) {}

	RefreshRate(const RefreshRate&) = delete;

	HwcConfigIndexType getConfigId() const { return configId; }
	nsecs_t getVsyncPeriod() const { return hwcConfig->getVsyncPeriod(); }
	int32_t getConfigGroup() const { return hwcConfig->getConfigGroup(); }
	const std::string& getName() const { return name; }
	float getFps() const { return fps; }

	// Checks whether the fps of this RefreshRate struct is within a given min and max refresh
	// rate passed in. FPS_EPSILON is applied to the boundaries for approximation.
	bool inPolicy(float minRefreshRate, float maxRefreshRate) const {
	return (fps >= (minRefreshRate - FPS_EPSILON) && fps <= (maxRefreshRate + FPS_EPSILON));
	}

	bool operator!=(const RefreshRate& other) const {
	return configId != other.configId \|\| hwcConfig != other.hwcConfig;
	}

	bool operator<(const RefreshRate& other) const { return getFps() < other.getFps(); }

	bool operator==(const RefreshRate& other) const { return !(*this != other); }

	private:
	friend RefreshRateConfigs;
	friend class RefreshRateConfigsTest;

	// The tolerance within which we consider FPS approximately equals.
	static constexpr float FPS_EPSILON = 0.001f;

	// This config ID corresponds to the position of the config in the vector that is stored
	// on the device.
	const HwcConfigIndexType configId;
	// The config itself
	std::shared_ptr<const HWC2::Display::Config> hwcConfig;
	// Human readable name of the refresh rate.
	const std::string name;
	// Refresh rate in frames per second
	const float fps = 0;
	};

	using AllRefreshRatesMapType =
	std::unordered_map<HwcConfigIndexType, std::unique_ptr<const RefreshRate>>;

	struct Policy {
	struct Range {
	float min = 0;
	float max = std::numeric_limits<float>::max();

	bool operator==(const Range& other) const {
	return min == other.min && max == other.max;
	}

	bool operator!=(const Range& other) const { return !(*this == other); }
	};

	// The default config, used to ensure we only initiate display config switches within the
	// same config group as defaultConfigId's group.
	HwcConfigIndexType defaultConfig;
	// The primary refresh rate range represents display manager's general guidance on the
	// display configs we'll consider when switching refresh rates. Unless we get an explicit
	// signal from an app, we should stay within this range.
	Range primaryRange;
	// The app request refresh rate range allows us to consider more display configs when
	// switching refresh rates. Although we should generally stay within the primary range,
	// specific considerations, such as layer frame rate settings specified via the
	// setFrameRate() api, may cause us to go outside the primary range. We never go outside the
	// app request range. The app request range will be greater than or equal to the primary
	// refresh rate range, never smaller.
	Range appRequestRange;
	// Whether or not we switch config groups to get the best frame rate. Only used by tests.
	bool allowGroupSwitching = false;

	Policy() = default;
	Policy(HwcConfigIndexType defaultConfig, const Range& range)
	: Policy(defaultConfig, range, range) {}
	Policy(HwcConfigIndexType defaultConfig, const Range& primaryRange,
	const Range& appRequestRange)
	: defaultConfig(defaultConfig),
	primaryRange(primaryRange),
	appRequestRange(appRequestRange) {}

	bool operator==(const Policy& other) const {
	return defaultConfig == other.defaultConfig && primaryRange == other.primaryRange &&
	appRequestRange == other.appRequestRange &&
	allowGroupSwitching == other.allowGroupSwitching;
	}

	bool operator!=(const Policy& other) const { return !(*this == other); }
	};

	// Return code set*Policy() to indicate the current policy is unchanged.
	static constexpr int CURRENT_POLICY_UNCHANGED = 1;

	// We maintain the display manager policy and the override policy separately. The override
	// policy is used by CTS tests to get a consistent device state for testing. While the override
	// policy is set, it takes precedence over the display manager policy. Once the override policy
	// is cleared, we revert to using the display manager policy.

	// Sets the display manager policy to choose refresh rates. The return value will be:
	// - A negative value if the policy is invalid or another error occurred.
	// - NO_ERROR if the policy was successfully updated, and the current policy is different from
	// what it was before the call.
	// - CURRENT_POLICY_UNCHANGED if the policy was successfully updated, but the current policy
	// is the same as it was before the call.
	status_t setDisplayManagerPolicy(const Policy& policy) EXCLUDES(mLock);
	// Sets the override policy. See setDisplayManagerPolicy() for the meaning of the return value.
	status_t setOverridePolicy(const std::optional<Policy>& policy) EXCLUDES(mLock);
	// Gets the current policy, which will be the override policy if active, and the display manager
	// policy otherwise.
	Policy getCurrentPolicy() const EXCLUDES(mLock);
	// Gets the display manager policy, regardless of whether an override policy is active.
	Policy getDisplayManagerPolicy() const EXCLUDES(mLock);

	// Returns true if config is allowed by the current policy.
	bool isConfigAllowed(HwcConfigIndexType config) const EXCLUDES(mLock);

	// Describes the different options the layer voted for refresh rate
	enum class LayerVoteType {
	NoVote, // Doesn't care about the refresh rate
	Min, // Minimal refresh rate available
	Max, // Maximal refresh rate available
	Heuristic, // Specific refresh rate that was calculated by platform using a heuristic
	ExplicitDefault, // Specific refresh rate that was provided by the app with Default
	// compatibility
	ExplicitExactOrMultiple // Specific refresh rate that was provided by the app with
	// ExactOrMultiple compatibility
	};

	// Captures the layer requirements for a refresh rate. This will be used to determine the
	// display refresh rate.
	struct LayerRequirement {
	// Layer's name. Used for debugging purposes.
	std::string name;
	// Layer vote type.
	LayerVoteType vote = LayerVoteType::NoVote;
	// Layer's desired refresh rate, if applicable.
	float desiredRefreshRate = 0.0f;
	// Layer's weight in the range of [0, 1]. The higher the weight the more impact this layer
	// would have on choosing the refresh rate.
	float weight = 0.0f;
	// Whether layer is in focus or not based on WindowManager's state
	bool focused = false;

	bool operator==(const LayerRequirement& other) const {
	return name == other.name && vote == other.vote &&
	desiredRefreshRate == other.desiredRefreshRate && weight == other.weight &&
	focused == other.focused;
	}

	bool operator!=(const LayerRequirement& other) const { return !(*this == other); }
	};

	// Returns the refresh rate that fits best to the given layers.
	const RefreshRate& getRefreshRateForContent(const std::vector<LayerRequirement>& layers) const
	EXCLUDES(mLock);

	// Global state describing signals that affect refresh rate choice.
	struct GlobalSignals {
	// Whether the user touched the screen recently. Used to apply touch boost.
	bool touch = false;
	// True if the system hasn't seen any buffers posted to layers recently.
	bool idle = false;
	};

	// Returns the refresh rate that fits best to the given layers.
	// layers - The layer requirements to consider.
	// globalSignals - global state of touch and idle
	// outSignalsConsidered - An output param that tells the caller whether the refresh rate was
	// chosen based on touch boost and/or idle timer.
	const RefreshRate& getBestRefreshRate(const std::vector<LayerRequirement>& layers,
	const GlobalSignals& globalSignals,
	GlobalSignals* outSignalsConsidered = nullptr) const
	EXCLUDES(mLock);

	// Returns all the refresh rates supported by the device. This won't change at runtime.
	const AllRefreshRatesMapType& getAllRefreshRates() const EXCLUDES(mLock);

	// Returns the lowest refresh rate supported by the device. This won't change at runtime.
	const RefreshRate& getMinRefreshRate() const { return *mMinSupportedRefreshRate; }

	// Returns the lowest refresh rate according to the current policy. May change at runtime. Only
	// uses the primary range, not the app request range.
	const RefreshRate& getMinRefreshRateByPolicy() const EXCLUDES(mLock);

	// Returns the highest refresh rate supported by the device. This won't change at runtime.
	const RefreshRate& getMaxRefreshRate() const { return *mMaxSupportedRefreshRate; }

	// Returns the highest refresh rate according to the current policy. May change at runtime. Only
	// uses the primary range, not the app request range.
	const RefreshRate& getMaxRefreshRateByPolicy() const EXCLUDES(mLock);

	// Returns the current refresh rate
	const RefreshRate& getCurrentRefreshRate() const EXCLUDES(mLock);

	// Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
	// the policy.
	const RefreshRate& getCurrentRefreshRateByPolicy() const;

	// Returns the refresh rate that corresponds to a HwcConfigIndexType. This won't change at
	// runtime.
	const RefreshRate& getRefreshRateFromConfigId(HwcConfigIndexType configId) const {
	return *mRefreshRates.at(configId);
	};

	// Stores the current configId the device operates at
	void setCurrentConfigId(HwcConfigIndexType configId) EXCLUDES(mLock);

	// Returns a string that represents the layer vote type
	static std::string layerVoteTypeString(LayerVoteType vote);

	// Returns a known frame rate that is the closest to frameRate
	float findClosestKnownFrameRate(float frameRate) const;

	RefreshRateConfigs(const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs,
	HwcConfigIndexType currentConfigId);

	// Returns whether switching configs (refresh rate or resolution) is possible.
	// TODO(b/158780872): Consider HAL support, and skip frame rate detection if the configs only
	// differ in resolution.
	bool canSwitch() const { return mRefreshRates.size() > 1; }

	// Class to enumerate options around toggling the kernel timer on and off. We have an option
	// for no change to avoid extra calls to kernel.
	enum class KernelIdleTimerAction {
	NoChange, // Do not change the idle timer.
	TurnOff, // Turn off the idle timer.
	TurnOn // Turn on the idle timer.
	};
	// Checks whether kernel idle timer should be active depending the policy decisions around
	// refresh rates.
	KernelIdleTimerAction getIdleTimerAction() const;

	private:
	friend class RefreshRateConfigsTest;

	void constructAvailableRefreshRates() REQUIRES(mLock);
	static std::vector<float> constructKnownFrameRates(
	const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs);

	void getSortedRefreshRateList(
	const std::function<bool(const RefreshRate&)>& shouldAddRefreshRate,
	std::vector<const RefreshRate> outRefreshRates);

	// Returns the refresh rate with the highest score in the collection specified from begin
	// to end. If there are more than one with the same highest refresh rate, the first one is
	// returned.
	template <typename Iter>
	const RefreshRate* getBestRefreshRate(Iter begin, Iter end) const;

	// Returns number of display frames and remainder when dividing the layer refresh period by
	// display refresh period.
	std::pair<nsecs_t, nsecs_t> getDisplayFrames(nsecs_t layerPeriod, nsecs_t displayPeriod) const;

	// Returns the lowest refresh rate according to the current policy. May change at runtime. Only
	// uses the primary range, not the app request range.
	const RefreshRate& getMinRefreshRateByPolicyLocked() const REQUIRES(mLock);

	// Returns the highest refresh rate according to the current policy. May change at runtime. Only
	// uses the primary range, not the app request range.
	const RefreshRate& getMaxRefreshRateByPolicyLocked() const REQUIRES(mLock);

	// Returns the current refresh rate, if allowed. Otherwise the default that is allowed by
	// the policy.
	const RefreshRate& getCurrentRefreshRateByPolicyLocked() const REQUIRES(mLock);

	const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);
	bool isPolicyValid(const Policy& policy);

	// The list of refresh rates, indexed by display config ID. This must not change after this
	// object is initialized.
	AllRefreshRatesMapType mRefreshRates;

	// The list of refresh rates in the primary range of the current policy, ordered by vsyncPeriod
	// (the first element is the lowest refresh rate).
	std::vector<const RefreshRate*> mPrimaryRefreshRates GUARDED_BY(mLock);

	// The list of refresh rates in the app request range of the current policy, ordered by
	// vsyncPeriod (the first element is the lowest refresh rate).
	std::vector<const RefreshRate*> mAppRequestRefreshRates GUARDED_BY(mLock);

	// The current config. This will change at runtime. This is set by SurfaceFlinger on
	// the main thread, and read by the Scheduler (and other objects) on other threads.
	const RefreshRate* mCurrentRefreshRate GUARDED_BY(mLock);

	// The policy values will change at runtime. They're set by SurfaceFlinger on the main thread,
	// and read by the Scheduler (and other objects) on other threads.
	Policy mDisplayManagerPolicy GUARDED_BY(mLock);
	std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);

	// The min and max refresh rates supported by the device.
	// This will not change at runtime.
	const RefreshRate* mMinSupportedRefreshRate;
	const RefreshRate* mMaxSupportedRefreshRate;

	mutable std::mutex mLock;

	// A sorted list of known frame rates that a Heuristic layer will choose
	// from based on the closest value.
	const std::vector<float> mKnownFrameRates;
	};

	} // namespace android::scheduler