display_settings_manager_impl.cc 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "chromecast/ui/display_settings_manager_impl.h"
  5. #include "base/bind.h"
  6. #include "base/callback.h"
  7. #include "base/check.h"
  8. #include "base/logging.h"
  9. #include "base/time/time.h"
  10. #include "chromecast/graphics/cast_window_manager.h"
  11. #include "chromecast/ui/display_settings/brightness_animation.h"
  12. #include "chromecast/ui/display_settings/color_temperature_animation.h"
  13. #include "ui/display/types/gamma_ramp_rgb_entry.h"
  14. #if defined(USE_AURA)
  15. #include "chromecast/browser/cast_display_configurator.h" // nogncheck
  16. #include "chromecast/ui/display_settings/gamma_configurator.h"
  17. #endif // defined(USE_AURA)
  18. namespace chromecast {
  19. namespace {
  20. constexpr base::TimeDelta kAnimationDuration = base::Seconds(2);
  21. const float kMinApiBrightness = 0.0f;
  22. const float kMaxApiBrightness = 1.0f;
  23. const float kDefaultApiBrightness = kMaxApiBrightness;
  24. } // namespace
  25. DisplaySettingsManagerImpl::DisplaySettingsManagerImpl(
  26. CastWindowManager* window_manager,
  27. shell::CastDisplayConfigurator* display_configurator)
  28. : window_manager_(window_manager),
  29. display_configurator_(display_configurator),
  30. #if defined(USE_AURA)
  31. gamma_configurator_(
  32. std::make_unique<GammaConfigurator>(display_configurator_)),
  33. #endif // defined(USE_AURA)
  34. brightness_(-1.0f),
  35. screen_power_controller_(ScreenPowerController::Create(this)),
  36. weak_factory_(this) {
  37. DCHECK(window_manager_);
  38. #if defined(USE_AURA)
  39. DCHECK(display_configurator_);
  40. #endif // defined(USE_AURA)
  41. }
  42. DisplaySettingsManagerImpl::~DisplaySettingsManagerImpl() = default;
  43. void DisplaySettingsManagerImpl::SetDelegate(
  44. DisplaySettingsManager::Delegate* delegate) {
  45. brightness_animation_ = std::make_unique<BrightnessAnimation>(delegate);
  46. }
  47. void DisplaySettingsManagerImpl::ResetDelegate() {
  48. // Skip a brightess animation to its last step and stop
  49. // This is important for the final brightness to be cached on reboot
  50. brightness_animation_.reset();
  51. }
  52. void DisplaySettingsManagerImpl::SetColorTemperatureConfig(
  53. const DisplaySettingsManager::ColorTemperatureConfig& config) {
  54. DCHECK(!color_temperature_animation_);
  55. color_temperature_animation_ = std::make_unique<ColorTemperatureAnimation>(
  56. display_configurator_, config);
  57. }
  58. void DisplaySettingsManagerImpl::SetGammaCalibration(
  59. const std::vector<display::GammaRampRGBEntry>& gamma) {
  60. #if defined(USE_AURA)
  61. gamma_configurator_->OnCalibratedGammaLoaded(gamma);
  62. #endif // defined(USE_AURA)
  63. }
  64. void DisplaySettingsManagerImpl::NotifyBrightnessChanged(float new_brightness,
  65. float old_brightness) {
  66. for (auto& observer : observers_)
  67. observer->OnDisplayBrightnessChanged(new_brightness);
  68. }
  69. void DisplaySettingsManagerImpl::SetColorInversion(bool enable) {
  70. #if defined(USE_AURA)
  71. gamma_configurator_->SetColorInversion(enable);
  72. #endif // defined(USE_AURA)
  73. }
  74. void DisplaySettingsManagerImpl::AddReceiver(
  75. mojo::PendingReceiver<mojom::DisplaySettings> receiver) {
  76. receivers_.Add(this, std::move(receiver));
  77. }
  78. void DisplaySettingsManagerImpl::SetScreenPowerOn(PowerToggleCallback callback) {
  79. #if defined(USE_AURA)
  80. display_configurator_->EnableDisplay(std::move(callback));
  81. #endif // defined(USE_AURA)
  82. }
  83. void DisplaySettingsManagerImpl::SetScreenPowerOff(PowerToggleCallback callback) {
  84. #if defined(USE_AURA)
  85. display_configurator_->DisableDisplay(std::move(callback));
  86. #endif // defined(USE_AURA)
  87. }
  88. void DisplaySettingsManagerImpl::SetScreenBrightnessOn(
  89. bool brightness_on,
  90. base::TimeDelta duration) {
  91. UpdateBrightness(brightness_on ? brightness_ : 0, duration);
  92. window_manager_->SetTouchInputDisabled(!brightness_on);
  93. }
  94. void DisplaySettingsManagerImpl::SetColorTemperature(float temperature) {
  95. DVLOG(4) << "Setting color temperature to " << temperature << " Kelvin.";
  96. if (!color_temperature_animation_) {
  97. return;
  98. }
  99. color_temperature_animation_->AnimateToNewValue(temperature,
  100. kAnimationDuration);
  101. }
  102. void DisplaySettingsManagerImpl::SetColorTemperatureSmooth(
  103. float temperature,
  104. base::TimeDelta duration) {
  105. DVLOG(4) << "Setting color temperature to " << temperature
  106. << " Kelvin. Duration: " << duration;
  107. if (!color_temperature_animation_) {
  108. return;
  109. }
  110. color_temperature_animation_->AnimateToNewValue(temperature, duration);
  111. }
  112. void DisplaySettingsManagerImpl::ResetColorTemperature() {
  113. if (!color_temperature_animation_) {
  114. return;
  115. }
  116. color_temperature_animation_->AnimateToNeutral(kAnimationDuration);
  117. }
  118. void DisplaySettingsManagerImpl::SetBrightness(float brightness) {
  119. SetBrightnessSmooth(brightness, base::Seconds(0));
  120. }
  121. void DisplaySettingsManagerImpl::SetBrightnessSmooth(float brightness,
  122. base::TimeDelta duration) {
  123. if (brightness < kMinApiBrightness) {
  124. LOG(ERROR) << "brightness " << brightness
  125. << " is less than minimum brightness " << kMinApiBrightness
  126. << ".";
  127. return;
  128. }
  129. if (brightness > kMaxApiBrightness) {
  130. LOG(ERROR) << "brightness " << brightness
  131. << " is greater than maximum brightness " << kMaxApiBrightness
  132. << ".";
  133. return;
  134. }
  135. brightness_ = brightness;
  136. // If the screen is off, keep the new brightness but don't apply it
  137. if (!screen_power_controller_->IsScreenOn()) {
  138. return;
  139. }
  140. UpdateBrightness(brightness_, duration);
  141. }
  142. void DisplaySettingsManagerImpl::ResetBrightness() {
  143. SetBrightness(kDefaultApiBrightness);
  144. }
  145. void DisplaySettingsManagerImpl::SetScreenOn(bool screen_on) {
  146. if (screen_on) {
  147. screen_power_controller_->SetScreenOn();
  148. } else {
  149. screen_power_controller_->SetScreenOff();
  150. }
  151. }
  152. void DisplaySettingsManagerImpl::SetAllowScreenPowerOff(bool allow_power_off) {
  153. screen_power_controller_->SetAllowScreenPowerOff(allow_power_off);
  154. }
  155. void DisplaySettingsManagerImpl::AddDisplaySettingsObserver(
  156. mojo::PendingRemote<mojom::DisplaySettingsObserver> observer) {
  157. mojo::Remote<mojom::DisplaySettingsObserver> observer_remote(
  158. std::move(observer));
  159. observers_.Add(std::move(observer_remote));
  160. }
  161. void DisplaySettingsManagerImpl::UpdateBrightness(float brightness,
  162. base::TimeDelta duration) {
  163. if (brightness_animation_)
  164. brightness_animation_->AnimateToNewValue(brightness, duration);
  165. }
  166. } // namespace chromecast