lock_screen_note_display_state_handler.cc

// Copyright 2017 The Chromium 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 "ash/lock_screen_action/lock_screen_note_display_state_handler.h"

#include <utility>

#include "ash/lock_screen_action/lock_screen_note_launcher.h"
#include "ash/public/interfaces/tray_action.mojom.h"
#include "ash/shell.h"
#include "ash/system/power/scoped_backlights_forced_off.h"
#include "ash/tray_action/tray_action.h"
#include "base/bind.h"
#include "base/location.h"
#include "base/time/time.h"

namespace ash {

namespace {

// The max amount of time display state change handling can be delayed due to a
// lock screen note action launch. The time starts running when the app launch
// is requested.
constexpr base::TimeDelta kNoteLaunchTimeout =
    base::TimeDelta::FromMilliseconds(1500);

}  // namespace

LockScreenNoteDisplayStateHandler::LockScreenNoteDisplayStateHandler(
    BacklightsForcedOffSetter* backlights_forced_off_setter)
    : backlights_forced_off_setter_(backlights_forced_off_setter),
      backlights_forced_off_observer_(this),
      weak_ptr_factory_(this) {
  backlights_forced_off_observer_.Add(backlights_forced_off_setter_);
}

LockScreenNoteDisplayStateHandler::~LockScreenNoteDisplayStateHandler() =
    default;

void LockScreenNoteDisplayStateHandler::OnBacklightsForcedOffChanged(
    bool backlights_forced_off) {
  // Close lock screen note when backlights are forced off - unless the
  // backlights are forced off by this as part of note app launch.
  if (backlights_forced_off && !backlights_forced_off_) {
    Shell::Get()->tray_action()->CloseLockScreenNote(
        mojom::CloseLockScreenNoteReason::kScreenDimmed);
  }
}

void LockScreenNoteDisplayStateHandler::OnScreenStateChanged(
    BacklightsForcedOffSetter::ScreenState screen_state) {
  if (screen_state != BacklightsForcedOffSetter::ScreenState::ON &&
      note_launch_delayed_until_screen_off_) {
    RunLockScreenNoteLauncher();
  }
}

void LockScreenNoteDisplayStateHandler::AttemptNoteLaunchForStylusEject() {
  if (!LockScreenNoteLauncher::CanAttemptLaunch() ||
      NoteLaunchInProgressOrDelayed()) {
    return;
  }

  if (!backlights_forced_off_ && ShouldForceBacklightsOffForNoteLaunch()) {
    backlights_forced_off_ =
        backlights_forced_off_setter_->ForceBacklightsOff();
  }

  DCHECK(!launch_timer_.IsRunning());
  launch_timer_.Start(
      FROM_HERE, kNoteLaunchTimeout,
      base::Bind(&LockScreenNoteDisplayStateHandler::NoteLaunchDone,
                 weak_ptr_factory_.GetWeakPtr(), false));

  // Delay note launch if backlights are forced off, but the screen hasn't
  // been turned off yet - the note should be launched when the pending
  // backlights state is finished (i.e. the screen is turned off).
  if (backlights_forced_off_setter_->backlights_forced_off() &&
      backlights_forced_off_setter_->screen_state() ==
          BacklightsForcedOffSetter::ScreenState::ON) {
    note_launch_delayed_until_screen_off_ = true;
    return;
  }

  RunLockScreenNoteLauncher();
}

void LockScreenNoteDisplayStateHandler::Reset() {
  note_launch_delayed_until_screen_off_ = false;
  backlights_forced_off_.reset();
  lock_screen_note_launcher_.reset();
  launch_timer_.Stop();
}

void LockScreenNoteDisplayStateHandler::RunLockScreenNoteLauncher() {
  DCHECK(!lock_screen_note_launcher_);
  if (!LockScreenNoteLauncher::CanAttemptLaunch()) {
    Reset();
    return;
  }

  note_launch_delayed_until_screen_off_ = false;

  lock_screen_note_launcher_ = std::make_unique<LockScreenNoteLauncher>();
  lock_screen_note_launcher_->Run(
      mojom::LockScreenNoteOrigin::kStylusEject,
      base::BindOnce(&LockScreenNoteDisplayStateHandler::NoteLaunchDone,
                     weak_ptr_factory_.GetWeakPtr()));
}

bool LockScreenNoteDisplayStateHandler::ShouldForceBacklightsOffForNoteLaunch()
    const {
  // Backlights should be kept off during app launch if the display has been
  // turned off without user interaction (e.g. due to user inactivity), or if
  // the backlights are currently being forced off - the goal is to avoid flash
  // of lock screen UI if the display gets turned on before lock screen app
  // window is shown.
  // There is no need to force the backlight off if the display has been turned
  // off due to user action - in this case display brightness will not change
  // when backlights stop being forced off (due to stylus eject) - the
  // brightness will remain at user selected level, so the lock screen UI will
  // not actually become visible.
  //
  // Note that backlights_forced_off_setter_ check is required as there is a
  // delay between request to force backlights off and screen state getting
  // updated due to that request.
  return backlights_forced_off_setter_->backlights_forced_off() ||
         backlights_forced_off_setter_->screen_state() ==
             BacklightsForcedOffSetter::ScreenState::OFF_AUTO;
}

bool LockScreenNoteDisplayStateHandler::NoteLaunchInProgressOrDelayed() const {
  return note_launch_delayed_until_screen_off_ || lock_screen_note_launcher_;
}

void LockScreenNoteDisplayStateHandler::NoteLaunchDone(bool success) {
  Reset();
}

}  // namespace ash