// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "power_manager/powerd/policy/internal_backlight_controller.h"

#include <sys/time.h>

#include <algorithm>
#include <cmath>
#include <string>
#include <vector>

#include <base/logging.h>
#include <base/strings/string_number_conversions.h>
#include <base/strings/string_split.h>
#include <base/strings/string_util.h>
#include <base/strings/stringprintf.h>
#include <dbus/message.h>

#include "power_manager/common/clock.h"
#include "power_manager/common/power_constants.h"
#include "power_manager/common/prefs.h"
#include "power_manager/powerd/policy/backlight_controller_observer.h"
#include "power_manager/powerd/system/dbus_wrapper.h"
#include "power_manager/powerd/system/display/display_power_setter.h"
#include "power_manager/proto_bindings/policy.pb.h"

namespace power_manager {
namespace policy {

namespace {

// Maximum valid value for percentages.
const double kMaxPercent = 100.0;

// When going into the idle-induced dim state, the backlight dims to this
// fraction (in the range [0.0, 1.0]) of its maximum brightness level.  This is
// a fraction rather than a percent so it won't change if
// kDefaultLevelToPercentExponent is modified.
const double kDimmedBrightnessFraction = 0.1;

// Value for |level_to_percent_exponent_|, assuming that at least
// |kMinLevelsForNonLinearScale| brightness levels are available -- if not, we
// just use 1.0 to give us a linear scale.
const double kDefaultLevelToPercentExponent = 0.5;

// Returns the animation duration for |transition|.
base::TimeDelta TransitionToTimeDelta(
    BacklightController::Transition transition) {
  switch (transition) {
    case BacklightController::Transition::INSTANT:
      return base::TimeDelta();
    case BacklightController::Transition::FAST:
      return base::TimeDelta::FromMilliseconds(kFastBacklightTransitionMs);
    case BacklightController::Transition::SLOW:
      return base::TimeDelta::FromMilliseconds(kSlowBacklightTransitionMs);
  }
}

// Clamps |percent| to fit between kMinVisiblePercent and 100.
double ClampPercentToVisibleRange(double percent) {
  return std::min(
      kMaxPercent,
      std::max(InternalBacklightController::kMinVisiblePercent, percent));
}

// Reads |pref_name| from |prefs| and returns the desired initial brightness
// percent corresponding to |backlight_nits|, the backlight's actual maximum
// luminance. Crashes on failure.
//
// The pref's value should consist of one or more lines, each containing either
// a single double brightness percentage or a space-separated "<double-percent>
// <int64_t-max-level>" pair. The percentage from the first line either using
// the single-value format or matching |backlight_nits| will be returned.
//
// For example,
//
// 60.0 300
// 50.0 400
// 40.0
//
// indicates that 60% should be used if the maximum luminance is 300, 50% should
// be used if it's 400, and 40% should be used otherwise.
//
// Note that this method will crash if no matching lines are found.
double GetInitialBrightnessPercent(PrefsInterface* prefs,
                                   const std::string& pref_name,
                                   int64_t backlight_nits) {
  DCHECK(prefs);
  std::string pref_value;
  CHECK(prefs->GetString(pref_name, &pref_value))
      << "Unable to read pref " << pref_name;

  std::vector<std::string> lines = base::SplitString(
      pref_value, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
  for (size_t i = 0; i < lines.size(); ++i) {
    std::vector<std::string> parts =
        base::SplitString(lines[i], base::kWhitespaceASCII,
                          base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
    CHECK(parts.size() == 1U || parts.size() == 2U)
        << "Unable to parse \"" << lines[i] << "\" from pref " << pref_name;

    double percent = 0.0;
    CHECK(base::StringToDouble(parts[0], &percent) && percent >= 0.0 &&
          percent <= 100.0)
        << "Unable to parse \"" << parts[0] << "\" from pref " << pref_name
        << " as double in [0.0, 100.0]";
    if (parts.size() == 1U)
      return percent;

    int64_t nits = -1;
    CHECK(base::StringToInt64(parts[1], &nits))
        << "Unable to parse \"" << parts[1] << "\" from pref " << pref_name;
    if (nits == backlight_nits)
      return percent;
  }

  LOG(FATAL) << "Unable to find initial brightness percentage in pref "
             << pref_name << " for " << backlight_nits << " nits";
  return kMaxPercent;
}

}  // namespace

const int64_t InternalBacklightController::kMaxBrightnessSteps = 16;
const double InternalBacklightController::kMinVisiblePercent =
    kMaxPercent / kMaxBrightnessSteps;
const double InternalBacklightController::kMinLevelsForNonLinearMapping = 100;
const double InternalBacklightController::kDefaultMinVisibleBrightnessFraction =
    0.0065;
const int InternalBacklightController::kAmbientLightSensorTimeoutSec = 10;

InternalBacklightController::InternalBacklightController()
    : clock_(new Clock),
      dimmed_brightness_percent_(kDimmedBrightnessFraction * 100.0),
      level_to_percent_exponent_(kDefaultLevelToPercentExponent),
      weak_ptr_factory_(this) {}

InternalBacklightController::~InternalBacklightController() = default;

void InternalBacklightController::Init(
    system::BacklightInterface* backlight,
    PrefsInterface* prefs,
    system::AmbientLightSensorInterface* sensor,
    system::DisplayPowerSetterInterface* display_power_setter,
    system::DBusWrapperInterface* dbus_wrapper,
    LidState initial_lid_state) {
  backlight_ = backlight;
  prefs_ = prefs;
  display_power_setter_ = display_power_setter;
  dbus_wrapper_ = dbus_wrapper;
  lid_state_ = initial_lid_state;

  max_level_ = backlight_->GetMaxBrightnessLevel();
  current_level_ = backlight_->GetCurrentBrightnessLevel();

  if (!prefs_->GetInt64(kMinVisibleBacklightLevelPref, &min_visible_level_)) {
    min_visible_level_ = static_cast<int64_t>(
        lround(kDefaultMinVisibleBrightnessFraction * max_level_));
  }
  min_visible_level_ = std::min(
      std::max(min_visible_level_, static_cast<int64_t>(1)), max_level_);

  const double initial_percent = LevelToPercent(current_level_);
  ambient_light_brightness_percent_ = initial_percent;

  int64_t max_nits = 0;
  prefs_->GetInt64(kInternalBacklightMaxNitsPref, &max_nits);
  ac_explicit_brightness_percent_ = GetInitialBrightnessPercent(
      prefs_, kInternalBacklightNoAlsAcBrightnessPref, max_nits);
  battery_explicit_brightness_percent_ = GetInitialBrightnessPercent(
      prefs_, kInternalBacklightNoAlsBatteryBrightnessPref, max_nits);

  prefs_->GetBool(kInstantTransitionsBelowMinLevelPref,
                  &instant_transitions_below_min_level_);

  if (sensor) {
    ambient_light_handler_.reset(new AmbientLightHandler(sensor, this));
    ambient_light_handler_->set_name("panel");
    std::string pref_value;
    CHECK(prefs_->GetString(kInternalBacklightAlsStepsPref, &pref_value))
        << "Failed to read pref " << kInternalBacklightAlsStepsPref;

    double als_smoothing_constant;
    CHECK(prefs_->GetDouble(kAlsSmoothingConstantPref, &als_smoothing_constant))
        << "Failed to read pref " << kAlsSmoothingConstantPref;
    ambient_light_handler_->Init(pref_value, initial_percent,
                                 als_smoothing_constant);
  } else {
    use_ambient_light_ = false;
  }

  int64_t turn_off_screen_timeout_ms = 0;
  prefs_->GetInt64(kTurnOffScreenTimeoutMsPref, &turn_off_screen_timeout_ms);
  turn_off_screen_timeout_ =
      base::TimeDelta::FromMilliseconds(turn_off_screen_timeout_ms);

  if (max_level_ == min_visible_level_ || kMaxBrightnessSteps == 1) {
    step_percent_ = kMaxPercent;
  } else {
    // 1 is subtracted from kMaxBrightnessSteps to account for the step between
    // |min_brightness_level_| and 0.
    step_percent_ =
        (kMaxPercent - kMinVisiblePercent) /
        std::min(kMaxBrightnessSteps - 1, max_level_ - min_visible_level_);
  }
  CHECK_GT(step_percent_, 0.0);

  system::BacklightInterface::BrightnessScale brightness_scale =
      backlight_->GetBrightnessScale();
  switch (brightness_scale) {
    case system::BacklightInterface::BrightnessScale::kLinear:
      level_to_percent_exponent_ = kDefaultLevelToPercentExponent;
      break;
    case system::BacklightInterface::BrightnessScale::kNonLinear:
      level_to_percent_exponent_ = 1.0;
      break;
    default:
      level_to_percent_exponent_ = max_level_ >= kMinLevelsForNonLinearMapping
                                       ? kDefaultLevelToPercentExponent
                                       : 1.0;
  }

  dimmed_brightness_percent_ = ClampPercentToVisibleRange(
      LevelToPercent(lround(kDimmedBrightnessFraction * max_level_)));

  RegisterIncreaseBrightnessHandler(
      dbus_wrapper_, kIncreaseScreenBrightnessMethod,
      base::Bind(&InternalBacklightController::HandleIncreaseBrightnessRequest,
                 weak_ptr_factory_.GetWeakPtr()));
  RegisterDecreaseBrightnessHandler(
      dbus_wrapper_, kDecreaseScreenBrightnessMethod,
      base::Bind(&InternalBacklightController::HandleDecreaseBrightnessRequest,
                 weak_ptr_factory_.GetWeakPtr()));
  RegisterSetBrightnessHandler(
      dbus_wrapper_, kSetScreenBrightnessMethod,
      base::Bind(&InternalBacklightController::HandleSetBrightnessRequest,
                 weak_ptr_factory_.GetWeakPtr()));
  RegisterGetBrightnessHandler(
      dbus_wrapper_, kGetScreenBrightnessPercentMethod,
      base::Bind(&InternalBacklightController::HandleGetBrightnessRequest,
                 weak_ptr_factory_.GetWeakPtr()));

  init_time_ = clock_->GetCurrentTime();
  LOG(INFO) << "Backlight has range [0, " << max_level_ << "] with "
            << step_percent_ << "% step and minimum-visible level of "
            << min_visible_level_ << "; current level is " << current_level_
            << " (" << LevelToPercent(current_level_) << "%)";
}

void InternalBacklightController::AddObserver(
    BacklightControllerObserver* observer) {
  DCHECK(observer);
  observers_.AddObserver(observer);
}

void InternalBacklightController::RemoveObserver(
    BacklightControllerObserver* observer) {
  DCHECK(observer);
  observers_.RemoveObserver(observer);
}

void InternalBacklightController::HandlePowerSourceChange(PowerSource source) {
  if (got_power_source_ && power_source_ == source)
    return;

  VLOG(1) << "Power source changed to " << PowerSourceToString(source);

  const bool on_ac = source == PowerSource::AC;

  // Ensure that the screen isn't dimmed in response to a transition to AC
  // or brightened in response to a transition to battery.
  if (got_power_source_) {
    const bool battery_exceeds_ac =
        battery_explicit_brightness_percent_ > ac_explicit_brightness_percent_;
    if (on_ac && battery_exceeds_ac)
      ac_explicit_brightness_percent_ = battery_explicit_brightness_percent_;
    else if (!on_ac && battery_exceeds_ac)
      battery_explicit_brightness_percent_ = ac_explicit_brightness_percent_;
  }

  power_source_ = source;
  got_power_source_ = true;
  UpdateState(
      on_ac ? BacklightBrightnessChange_Cause_EXTERNAL_POWER_CONNECTED
            : BacklightBrightnessChange_Cause_EXTERNAL_POWER_DISCONNECTED);
  if (ambient_light_handler_)
    ambient_light_handler_->HandlePowerSourceChange(source);
}

void InternalBacklightController::HandleDisplayModeChange(DisplayMode mode) {
  if (display_mode_ == mode)
    return;

  display_mode_ = mode;

  // If there's no external display now, make sure that the panel is on.
  if (display_mode_ == DisplayMode::NORMAL)
    EnsureUserBrightnessIsNonzero(BacklightBrightnessChange_Cause_OTHER);
}

void InternalBacklightController::HandleSessionStateChange(SessionState state) {
  EnsureUserBrightnessIsNonzero(BacklightBrightnessChange_Cause_OTHER);
  if (state == SessionState::STARTED) {
    als_adjustment_count_ = 0;
    user_adjustment_count_ = 0;
  }
}

void InternalBacklightController::HandlePowerButtonPress() {
  EnsureUserBrightnessIsNonzero(BacklightBrightnessChange_Cause_USER_ACTIVITY);
}

void InternalBacklightController::HandleLidStateChange(LidState state) {
  lid_state_ = state;
  UpdateState(BacklightBrightnessChange_Cause_OTHER);
}

void InternalBacklightController::HandleUserActivity(UserActivityType type) {
  // Don't increase the brightness automatically when the user hits a brightness
  // key: if they hit brightness-up, HandleIncreaseBrightnessRequest() will be
  // called soon anyway; if they hit brightness-down, the screen shouldn't get
  // turned back on. Also ignore volume keys.
  if (type != USER_ACTIVITY_BRIGHTNESS_UP_KEY_PRESS &&
      type != USER_ACTIVITY_BRIGHTNESS_DOWN_KEY_PRESS &&
      type != USER_ACTIVITY_VOLUME_UP_KEY_PRESS &&
      type != USER_ACTIVITY_VOLUME_DOWN_KEY_PRESS &&
      type != USER_ACTIVITY_VOLUME_MUTE_KEY_PRESS)
    EnsureUserBrightnessIsNonzero(
        BacklightBrightnessChange_Cause_USER_ACTIVITY);
}

void InternalBacklightController::HandleVideoActivity(bool is_fullscreen) {}

void InternalBacklightController::HandleWakeNotification() {
  // Increase the brightness of the display, even though the user might have set
  // it to zero, as this notification is waking up the device to get the user's
  // attention.
  EnsureUserBrightnessIsNonzero(
      BacklightBrightnessChange_Cause_WAKE_NOTIFICATION);
}

void InternalBacklightController::HandleHoverStateChange(bool hovering) {}

void InternalBacklightController::HandleTabletModeChange(TabletMode mode) {}

void InternalBacklightController::HandlePolicyChange(
    const PowerManagementPolicy& policy) {
  bool got_policy_brightness = false;

  double ac_brightness = ac_explicit_brightness_percent_;
  if (policy.has_ac_brightness_percent()) {
    LOG(INFO) << "Got policy-triggered request to set AC brightness to "
              << policy.ac_brightness_percent() << "%";
    ac_brightness = policy.ac_brightness_percent();
    got_policy_brightness = true;
  }
  double battery_brightness = battery_explicit_brightness_percent_;
  if (policy.has_battery_brightness_percent()) {
    LOG(INFO) << "Got policy-triggered request to set battery brightness to "
              << policy.battery_brightness_percent() << "%";
    battery_brightness = policy.battery_brightness_percent();
    got_policy_brightness = true;
  }

  using_policy_brightness_ = got_policy_brightness;
  if (got_policy_brightness) {
    SetExplicitBrightnessPercent(ac_brightness, battery_brightness,
                                 Transition::FAST,
                                 BacklightBrightnessChange_Cause_OTHER);
  }
  force_nonzero_brightness_for_user_activity_ =
      policy.has_force_nonzero_brightness_for_user_activity()
          ? policy.force_nonzero_brightness_for_user_activity()
          : true;
}

void InternalBacklightController::HandleDisplayServiceStart() {
  display_power_setter_->SetDisplayPower(display_power_state_,
                                         base::TimeDelta());
}

void InternalBacklightController::SetDimmedForInactivity(bool dimmed) {
  if (dimmed_for_inactivity_ == dimmed)
    return;

  VLOG(1) << (dimmed ? "Dimming" : "No longer dimming") << " for inactivity";
  dimmed_for_inactivity_ = dimmed;
  UpdateState(dimmed ? BacklightBrightnessChange_Cause_USER_INACTIVITY
                     : BacklightBrightnessChange_Cause_USER_ACTIVITY,
              dimmed ? Transition::FAST : Transition::INSTANT);
}

void InternalBacklightController::SetOffForInactivity(bool off) {
  if (off_for_inactivity_ == off)
    return;

  VLOG(1) << (off ? "Turning backlight off" : "No longer keeping backlight off")
          << " for inactivity";
  off_for_inactivity_ = off;
  UpdateState(off ? BacklightBrightnessChange_Cause_USER_INACTIVITY
                  : BacklightBrightnessChange_Cause_USER_ACTIVITY);
}

void InternalBacklightController::SetSuspended(bool suspended) {
  if (suspended_ == suspended)
    return;

  VLOG(1) << (suspended ? "Suspending" : "Unsuspending") << " backlight";
  suspended_ = suspended;
  UpdateState(BacklightBrightnessChange_Cause_OTHER);

  if (!suspended && use_ambient_light_)
    ambient_light_handler_->HandleResume();
}

void InternalBacklightController::SetShuttingDown(bool shutting_down) {
  if (shutting_down_ == shutting_down)
    return;

  if (shutting_down)
    VLOG(1) << "Preparing backlight for shutdown";
  else
    LOG(WARNING) << "Exiting shutting-down state";
  shutting_down_ = shutting_down;
  UpdateState(BacklightBrightnessChange_Cause_OTHER);
}

void InternalBacklightController::SetForcedOff(bool forced_off) {
  if (forced_off_ == forced_off)
    return;

  VLOG(1) << (forced_off ? "Forcing" : "Not forcing") << " backlight off";
  forced_off_ = forced_off;
  UpdateState(forced_off
                  ? BacklightBrightnessChange_Cause_FORCED_OFF
                  : BacklightBrightnessChange_Cause_NO_LONGER_FORCED_OFF);
}

bool InternalBacklightController::GetForcedOff() {
  return forced_off_;
}

bool InternalBacklightController::GetBrightnessPercent(double* percent) {
  DCHECK(percent);
  *percent = LevelToPercent(current_level_);
  return true;
}

int InternalBacklightController::GetNumAmbientLightSensorAdjustments() const {
  return als_adjustment_count_;
}

int InternalBacklightController::GetNumUserAdjustments() const {
  return user_adjustment_count_;
}

double InternalBacklightController::LevelToPercent(int64_t raw_level) const {
  // If the passed-in level is below the minimum visible level, just map it
  // linearly into [0, kMinVisiblePercent).
  if (raw_level < min_visible_level_)
    return kMinVisiblePercent * raw_level / min_visible_level_;

  // Since we're at or above the minimum level, we know that we're at 100% if
  // the min and max are equal.
  if (min_visible_level_ == max_level_)
    return 100.0;

  double linear_fraction = static_cast<double>(raw_level - min_visible_level_) /
                           (max_level_ - min_visible_level_);
  return kMinVisiblePercent +
         (kMaxPercent - kMinVisiblePercent) *
             pow(linear_fraction, level_to_percent_exponent_);
}

int64_t InternalBacklightController::PercentToLevel(double percent) const {
  if (percent < kMinVisiblePercent)
    return lround(min_visible_level_ * percent / kMinVisiblePercent);

  if (percent == kMaxPercent)
    return max_level_;

  double linear_fraction =
      (percent - kMinVisiblePercent) / (kMaxPercent - kMinVisiblePercent);
  return lround(min_visible_level_ +
                (max_level_ - min_visible_level_) *
                    pow(linear_fraction, 1.0 / level_to_percent_exponent_));
}

void InternalBacklightController::SetBrightnessPercentForAmbientLight(
    double brightness_percent,
    AmbientLightHandler::BrightnessChangeCause cause) {
  ambient_light_brightness_percent_ = brightness_percent;
  got_ambient_light_brightness_percent_ = true;

  if (!use_ambient_light_)
    return;

  // If powerd hasn't started controlling the backlight yet, don't blame ambient
  // light for any brightness change that UpdateState() may end up making.
  const BacklightBrightnessChange_Cause backlight_cause =
      already_set_initial_state_ ? AmbientLightHandler::ToProtobufCause(cause)
                                 : BacklightBrightnessChange_Cause_OTHER;

  // This method is also called for power source changes while
  // AmbientLightHandler is controlling the brightness. Perform a fast
  // transition in that case.
  const bool ambient_light_changed =
      backlight_cause == BacklightBrightnessChange_Cause_AMBIENT_LIGHT_CHANGED;
  const Transition transition =
      ambient_light_changed ? Transition::SLOW : Transition::FAST;

  const int64_t old_level = current_level_;
  UpdateState(backlight_cause, transition);
  if (ambient_light_changed && current_level_ != old_level)
    als_adjustment_count_++;
}

void InternalBacklightController::OnColorTemperatureChanged(
    int color_temperature) {
  dbus::Signal signal(kPowerManagerInterface,
                      kAmbientColorTemperatureChangedSignal);
  dbus::MessageWriter(&signal).AppendInt32(color_temperature);
  dbus_wrapper_->EmitSignal(&signal);
}

double InternalBacklightController::SnapBrightnessPercentToNearestStep(
    double percent) const {
  return round(percent / step_percent_) * step_percent_;
}

double InternalBacklightController::GetExplicitBrightnessPercent() const {
  return power_source_ == PowerSource::AC
             ? ac_explicit_brightness_percent_
             : battery_explicit_brightness_percent_;
}

double InternalBacklightController::GetUndimmedBrightnessPercent() const {
  if (use_ambient_light_)
    return ClampPercentToVisibleRange(ambient_light_brightness_percent_);

  const double percent = GetExplicitBrightnessPercent();
  return percent <= kEpsilon ? 0.0 : ClampPercentToVisibleRange(percent);
}

void InternalBacklightController::HandleIncreaseBrightnessRequest() {
  double old_percent = GetUndimmedBrightnessPercent();
  double new_percent =
      (old_percent < kMinVisiblePercent - kEpsilon)
          ? kMinVisiblePercent
          : ClampPercentToVisibleRange(SnapBrightnessPercentToNearestStep(
                old_percent + step_percent_));

  // If we don't actually change the brightness, emit a signal so the UI can
  // show the user that nothing changed.
  const double current_percent = LevelToPercent(current_level_);
  HandleSetBrightnessRequest(new_percent, Transition::FAST,
                             SetBacklightBrightnessRequest_Cause_USER_REQUEST);
  if (LevelToPercent(current_level_) == current_percent) {
    EmitBrightnessChangedSignal(dbus_wrapper_, kScreenBrightnessChangedSignal,
                                current_percent,
                                BacklightBrightnessChange_Cause_USER_REQUEST);
  }
}

void InternalBacklightController::HandleDecreaseBrightnessRequest(
    bool allow_off) {
  // Lower the backlight to the next step, turning it off if it was already at
  // the minimum visible level.
  double old_percent = GetUndimmedBrightnessPercent();
  double new_percent =
      old_percent <= kMinVisiblePercent + kEpsilon
          ? 0.0
          : ClampPercentToVisibleRange(SnapBrightnessPercentToNearestStep(
                old_percent - step_percent_));

  if (!allow_off && new_percent <= kEpsilon) {
    user_adjustment_count_++;
    return;
  }

  // If we don't actually change the brightness, emit a signal so the UI can
  // show the user that nothing changed.
  const double current_percent = LevelToPercent(current_level_);
  HandleSetBrightnessRequest(new_percent, Transition::FAST,
                             SetBacklightBrightnessRequest_Cause_USER_REQUEST);
  if (LevelToPercent(current_level_) == current_percent) {
    EmitBrightnessChangedSignal(dbus_wrapper_, kScreenBrightnessChangedSignal,
                                current_percent,
                                BacklightBrightnessChange_Cause_USER_REQUEST);
  }
}

void InternalBacklightController::HandleSetBrightnessRequest(
    double percent,
    Transition transition,
    SetBacklightBrightnessRequest_Cause cause) {
  BacklightBrightnessChange_Cause change_cause =
      BacklightBrightnessChange_Cause_OTHER;
  const char* cause_str = "unknown";
  switch (cause) {
    case SetBacklightBrightnessRequest_Cause_USER_REQUEST:
      cause_str = "user-triggered";
      change_cause = BacklightBrightnessChange_Cause_USER_REQUEST;
      break;
    case SetBacklightBrightnessRequest_Cause_MODEL:
      cause_str = "model-triggered";
      change_cause = BacklightBrightnessChange_Cause_MODEL;
      break;
  }

  LOG(INFO) << "Got " << cause_str << " request to set brightness to "
            << percent << "%";
  if (cause == SetBacklightBrightnessRequest_Cause_USER_REQUEST)
    user_adjustment_count_++;
  using_policy_brightness_ = false;

  // When the user explicitly requests a specific brightness level, use it for
  // both AC and battery power.
  SetExplicitBrightnessPercent(percent, percent, transition, change_cause);
}

void InternalBacklightController::HandleGetBrightnessRequest(
    double* percent_out, bool* success_out) {
  DCHECK(percent_out);
  DCHECK(success_out);
  *percent_out = LevelToPercent(current_level_);
  *success_out = true;
}

void InternalBacklightController::EnsureUserBrightnessIsNonzero(
    BacklightBrightnessChange_Cause cause) {
  // Avoid turning the backlight back on if an external display is
  // connected since doing so may result in the desktop being resized. Also
  // don't turn it on if a policy has forced the brightness to zero.
  if (force_nonzero_brightness_for_user_activity_ &&
      display_mode_ == DisplayMode::NORMAL &&
      GetExplicitBrightnessPercent() < kMinVisiblePercent &&
      !using_policy_brightness_ && !use_ambient_light_) {
    SetExplicitBrightnessPercent(kMinVisiblePercent, kMinVisiblePercent,
                                 Transition::FAST, cause);
  }
}

void InternalBacklightController::SetExplicitBrightnessPercent(
    double ac_percent,
    double battery_percent,
    Transition transition,
    BacklightBrightnessChange_Cause cause) {
  use_ambient_light_ = false;
  ac_explicit_brightness_percent_ =
      ac_percent <= kEpsilon ? 0.0 : ClampPercentToVisibleRange(ac_percent);
  battery_explicit_brightness_percent_ =
      battery_percent <= kEpsilon ? 0.0
                                  : ClampPercentToVisibleRange(battery_percent);
  UpdateState(cause, transition);
}

void InternalBacklightController::UpdateState(
    BacklightBrightnessChange_Cause cause, Transition adjust_transition) {
  // Give up on the ambient light sensor if it's not supplying readings.
  if (use_ambient_light_ && !got_ambient_light_brightness_percent_ &&
      clock_->GetCurrentTime() - init_time_ >=
          base::TimeDelta::FromSeconds(kAmbientLightSensorTimeoutSec)) {
    LOG(ERROR) << "Giving up on ambient light sensor after getting no reading "
               << "within " << kAmbientLightSensorTimeoutSec << " seconds";
    use_ambient_light_ = false;
  }

  // Hold off on changing the brightness at startup until all the required
  // state has been received.
  // TODO(chromeos-power): Don't bail out if we'll turn the display off, since
  // that's independent of all of this.
  if (!got_power_source_ ||
      (use_ambient_light_ && !got_ambient_light_brightness_percent_))
    return;

  // First, figure out the backlight brightness and display power state that we
  // should be using right now.
  double brightness_percent = 100.0;
  Transition brightness_transition = Transition::INSTANT;

  chromeos::DisplayPowerState display_power = chromeos::DISPLAY_POWER_ALL_ON;
  base::TimeDelta display_delay;
  bool set_display_power = true;

  if (shutting_down_ || forced_off_) {
    brightness_percent = 0.0;
    display_power = chromeos::DISPLAY_POWER_ALL_OFF;
  } else if (suspended_) {
    brightness_percent = 0.0;
    // Chrome puts displays into the correct power state before suspend.
    set_display_power = false;
  } else if (off_for_inactivity_) {
    brightness_percent = 0.0;
    brightness_transition = Transition::FAST;
    display_power = chromeos::DISPLAY_POWER_ALL_OFF;
    display_delay = TransitionToTimeDelta(brightness_transition);
  } else if (lid_state_ == LidState::CLOSED) {
    brightness_percent = 0.0;
    // Leave external displays on for docked mode.
    display_power = chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON;
  } else {
    brightness_percent =
        std::min(GetUndimmedBrightnessPercent(),
                 dimmed_for_inactivity_ ? dimmed_brightness_percent_ : 100.0);
    const bool turning_on =
        display_power_state_ != chromeos::DISPLAY_POWER_ALL_ON ||
        current_level_ == 0;
    brightness_transition =
        turning_on ? Transition::INSTANT
                   : (already_set_initial_state_ ? adjust_transition
                                                 : Transition::SLOW);

    if (brightness_percent <= kEpsilon) {
      // Keep external display(s) on if the brightness was explicitly set to 0.
      display_power = chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON;
      display_delay = TransitionToTimeDelta(brightness_transition) +
                      turn_off_screen_timeout_;
    }
  }

  // Now apply the state that we decided on.
  if (set_display_power && display_power != display_power_state_) {
    // For instant transitions, this call blocks until Chrome confirms that it
    // has made the change.
    display_power_setter_->SetDisplayPower(display_power, display_delay);
    display_power_state_ = display_power;
  }

  // Apply the brightness after toggling the display power. If we do it the
  // other way around, then the brightness set here has a potential to get
  // interleaved with the display power toggle operation in some drivers
  // resulting in this request being dropped and the brightness being set to its
  // previous value instead. See chrome-os-partner:31186 and :35662 for more
  // details.
  const int64_t new_level = PercentToLevel(brightness_percent);
  if (new_level != current_level_ || backlight_->TransitionInProgress()) {
    // Force an instant transition if we're moving into or out of the
    // below-min-visible (i.e. off-but-nonzero) range.
    bool starting_below_min_visible_level = current_level_ < min_visible_level_;
    bool ending_below_min_visible_level = new_level < min_visible_level_;
    if (instant_transitions_below_min_level_ &&
        starting_below_min_visible_level != ending_below_min_visible_level)
      brightness_transition = Transition::INSTANT;

    base::TimeDelta interval = TransitionToTimeDelta(brightness_transition);
    LOG(INFO) << "Setting brightness to " << new_level << " ("
              << brightness_percent << "%) over " << interval.InMilliseconds()
              << " ms";
    if (!backlight_->SetBrightnessLevel(new_level, interval)) {
      LOG(WARNING) << "Could not set brightness";
    } else {
      current_level_ = new_level;
      EmitBrightnessChangedSignal(dbus_wrapper_, kScreenBrightnessChangedSignal,
                                  brightness_percent, cause);
      for (BacklightControllerObserver& observer : observers_)
        observer.OnBrightnessChange(brightness_percent, cause, this);
    }
  }

  already_set_initial_state_ = true;
}

}  // namespace policy
}  // namespace power_manager