src/ash/wm/maximize_mode/maximize_mode_controller.cc

   1 // Copyright 2014 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
   5 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
   6
   7 #include "ash/accelerators/accelerator_controller.h"
   8 #include "ash/accelerators/accelerator_table.h"
   9 #include "ash/accelerometer/accelerometer_controller.h"
  10 #include "ash/ash_switches.h"
  11 #include "ash/display/display_manager.h"
  12 #include "ash/shell.h"
  13 #include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
  14 #include "ash/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h"
  15 #include "base/auto_reset.h"
  16 #include "base/command_line.h"
  17 #include "base/metrics/histogram.h"
  18 #include "base/time/default_tick_clock.h"
  19 #include "base/time/tick_clock.h"
  20 #include "ui/base/accelerators/accelerator.h"
  21 #include "ui/events/event.h"
  22 #include "ui/events/keycodes/keyboard_codes.h"
  23 #include "ui/gfx/vector3d_f.h"
  24
  25 #if defined(USE_X11)
  26 #include "ash/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard_x11.h"
  27 #endif
  28
  29 #if defined(OS_CHROMEOS)
  30 #include "chromeos/dbus/dbus_thread_manager.h"
  31 #endif  // OS_CHROMEOS
  32
  33 namespace ash {
  34
  35 namespace {
  36
  37 // The hinge angle at which to enter maximize mode.
  38 const float kEnterMaximizeModeAngle = 200.0f;
  39
  40 // The angle at which to exit maximize mode, this is specifically less than the
  41 // angle to enter maximize mode to prevent rapid toggling when near the angle.
  42 const float kExitMaximizeModeAngle = 160.0f;
  43
  44 // Defines a range for which accelerometer readings are considered accurate.
  45 // When the lid is near open (or near closed) the accelerometer readings may be
  46 // inaccurate and a lid that is fully open may appear to be near closed (and
  47 // vice versa).
  48 const float kMinStableAngle = 20.0f;
  49 const float kMaxStableAngle = 340.0f;
  50
  51 // The time duration to consider the lid to be recently opened.
  52 // This is used to prevent entering maximize mode if an erroneous accelerometer
  53 // reading makes the lid appear to be fully open when the user is opening the
  54 // lid from a closed position.
  55 const base::TimeDelta kLidRecentlyOpenedDuration =
  56     base::TimeDelta::FromSeconds(2);
  57
  58 // The mean acceleration due to gravity on Earth in m/s^2.
  59 const float kMeanGravity = 9.80665f;
  60
  61 // When the device approaches vertical orientation (i.e. portrait orientation)
  62 // the accelerometers for the base and lid approach the same values (i.e.
  63 // gravity pointing in the direction of the hinge). When this happens we cannot
  64 // compute the hinge angle reliably and must turn ignore accelerometer readings.
  65 // This is the minimum acceleration perpendicular to the hinge under which to
  66 // detect hinge angle in m/s^2.
  67 const float kHingeAngleDetectionThreshold = 2.5f;
  68
  69 // The maximum deviation from the acceleration expected due to gravity under
  70 // which to detect hinge angle and screen rotation in m/s^2
  71 const float kDeviationFromGravityThreshold = 1.0f;
  72
  73 // The maximum deviation between the magnitude of the two accelerometers under
  74 // which to detect hinge angle and screen rotation in m/s^2. These
  75 // accelerometers are attached to the same physical device and so should be
  76 // under the same acceleration.
  77 const float kNoisyMagnitudeDeviation = 1.0f;
  78
  79 // The angle which the screen has to be rotated past before the display will
  80 // rotate to match it (i.e. 45.0f is no stickiness).
  81 const float kDisplayRotationStickyAngleDegrees = 60.0f;
  82
  83 // The minimum acceleration in m/s^2 in a direction required to trigger screen
  84 // rotation. This prevents rapid toggling of rotation when the device is near
  85 // flat and there is very little screen aligned force on it. The value is
  86 // effectively the sine of the rise angle required times the acceleration due
  87 // to gravity, with the current value requiring at least a 25 degree rise.
  88 const float kMinimumAccelerationScreenRotation = 4.2f;
  89
  90 const float kRadiansToDegrees = 180.0f / 3.14159265f;
  91
  92 // Returns the angle between |base| and |other| in degrees.
  93 float AngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
  94                                  const gfx::Vector3dF& other) {
  95   return acos(gfx::DotProduct(base, other) /
  96               base.Length() / other.Length()) * kRadiansToDegrees;
  97 }
  98
  99 // Returns the clockwise angle between |base| and |other| where |normal| is the
 100 // normal of the virtual surface to measure clockwise according to.
 101 float ClockwiseAngleBetweenVectorsInDegrees(const gfx::Vector3dF& base,
 102                                             const gfx::Vector3dF& other,
 103                                             const gfx::Vector3dF& normal) {
 104   float angle = AngleBetweenVectorsInDegrees(base, other);
 105   gfx::Vector3dF cross(base);
 106   cross.Cross(other);
 107   // If the dot product of this cross product is normal, it means that the
 108   // shortest angle between |base| and |other| was counterclockwise with respect
 109   // to the surface represented by |normal| and this angle must be reversed.
 110   if (gfx::DotProduct(cross, normal) > 0.0f)
 111     angle = 360.0f - angle;
 112   return angle;
 113 }
 114
 115 }  // namespace
 116
 117 MaximizeModeController::MaximizeModeController()
 118     : rotation_locked_(false),
 119       have_seen_accelerometer_data_(false),
 120       ignore_display_configuration_updates_(false),
 121       shutting_down_(false),
 122       user_rotation_(gfx::Display::ROTATE_0),
 123       last_touchview_transition_time_(base::Time::Now()),
 124       tick_clock_(new base::DefaultTickClock()),
 125       lid_is_closed_(false) {
 126   Shell::GetInstance()->accelerometer_controller()->AddObserver(this);
 127   Shell::GetInstance()->AddShellObserver(this);
 128 #if defined(OS_CHROMEOS)
 129   chromeos::DBusThreadManager::Get()->
 130       GetPowerManagerClient()->AddObserver(this);
 131 #endif  // OS_CHROMEOS
 132 }
 133
 134 MaximizeModeController::~MaximizeModeController() {
 135   Shell::GetInstance()->RemoveShellObserver(this);
 136   Shell::GetInstance()->accelerometer_controller()->RemoveObserver(this);
 137 #if defined(OS_CHROMEOS)
 138   chromeos::DBusThreadManager::Get()->
 139       GetPowerManagerClient()->RemoveObserver(this);
 140 #endif  // OS_CHROMEOS
 141 }
 142
 143 void MaximizeModeController::SetRotationLocked(bool rotation_locked) {
 144   if (rotation_locked_ == rotation_locked)
 145     return;
 146   base::AutoReset<bool> auto_ignore_display_configuration_updates(
 147       &ignore_display_configuration_updates_, true);
 148   rotation_locked_ = rotation_locked;
 149   Shell::GetInstance()->display_manager()->
 150       RegisterDisplayRotationProperties(rotation_locked_, current_rotation_);
 151   FOR_EACH_OBSERVER(Observer, observers_,
 152                     OnRotationLockChanged(rotation_locked_));
 153 }
 154
 155 void MaximizeModeController::AddObserver(Observer* observer) {
 156   observers_.AddObserver(observer);
 157 }
 158
 159 void MaximizeModeController::RemoveObserver(Observer* observer) {
 160   observers_.RemoveObserver(observer);
 161 }
 162
 163 bool MaximizeModeController::CanEnterMaximizeMode() {
 164   // If we have ever seen accelerometer data, then HandleHingeRotation may
 165   // trigger maximize mode at some point in the future.
 166   // The --enable-touch-view-testing switch can also mean that we may enter
 167   // maximize mode.
 168   return have_seen_accelerometer_data_ ||
 169          CommandLine::ForCurrentProcess()->HasSwitch(
 170              switches::kAshEnableTouchViewTesting);
 171 }
 172
 173 void MaximizeModeController::EnableMaximizeModeWindowManager(bool enable) {
 174   if (enable && !maximize_mode_window_manager_.get()) {
 175     maximize_mode_window_manager_.reset(new MaximizeModeWindowManager());
 176     // TODO(jonross): Move the maximize mode notifications from ShellObserver
 177     // to MaximizeModeController::Observer
 178     Shell::GetInstance()->OnMaximizeModeStarted();
 179   } else if (!enable && maximize_mode_window_manager_.get()) {
 180     maximize_mode_window_manager_.reset();
 181     Shell::GetInstance()->OnMaximizeModeEnded();
 182   }
 183 }
 184
 185 bool MaximizeModeController::IsMaximizeModeWindowManagerEnabled() const {
 186   return maximize_mode_window_manager_.get() != NULL;
 187 }
 188
 189 void MaximizeModeController::AddWindow(aura::Window* window) {
 190   if (IsMaximizeModeWindowManagerEnabled())
 191     maximize_mode_window_manager_->AddWindow(window);
 192 }
 193
 194 void MaximizeModeController::Shutdown() {
 195   shutting_down_ = true;
 196   LeaveMaximizeMode();
 197 }
 198
 199 void MaximizeModeController::OnAccelerometerUpdated(
 200     const ui::AccelerometerUpdate& update) {
 201   bool first_accelerometer_update = !have_seen_accelerometer_data_;
 202   have_seen_accelerometer_data_ = true;
 203
 204   // Ignore the reading if it appears unstable. The reading is considered
 205   // unstable if it deviates too much from gravity and/or the magnitude of the
 206   // reading from the lid differs too much from the reading from the base.
 207   float base_magnitude =
 208       update.has(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD) ?
 209       update.get(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD).Length() :
 210       0.0f;
 211   float lid_magnitude = update.has(ui::ACCELEROMETER_SOURCE_SCREEN) ?
 212       update.get(ui::ACCELEROMETER_SOURCE_SCREEN).Length() : 0.0f;
 213   bool lid_stable = update.has(ui::ACCELEROMETER_SOURCE_SCREEN) &&
 214       std::abs(lid_magnitude - kMeanGravity) <= kDeviationFromGravityThreshold;
 215   bool base_angle_stable = lid_stable &&
 216       update.has(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD) &&
 217       std::abs(base_magnitude - lid_magnitude) <= kNoisyMagnitudeDeviation &&
 218       std::abs(base_magnitude - kMeanGravity) <= kDeviationFromGravityThreshold;
 219
 220   if (base_angle_stable) {
 221     // Responding to the hinge rotation can change the maximize mode state which
 222     // affects screen rotation, so we handle hinge rotation first.
 223     HandleHingeRotation(
 224         update.get(ui::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD),
 225         update.get(ui::ACCELEROMETER_SOURCE_SCREEN));
 226   }
 227   if (lid_stable)
 228     HandleScreenRotation(update.get(ui::ACCELEROMETER_SOURCE_SCREEN));
 229
 230   if (first_accelerometer_update) {
 231     // On the first accelerometer update we will know if we have entered
 232     // maximize mode or not. Update the preferences to reflect the current
 233     // state.
 234     Shell::GetInstance()->display_manager()->
 235         RegisterDisplayRotationProperties(rotation_locked_, current_rotation_);
 236   }
 237 }
 238
 239 void MaximizeModeController::OnDisplayConfigurationChanged() {
 240   if (ignore_display_configuration_updates_)
 241     return;
 242   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 243   gfx::Display::Rotation user_rotation = display_manager->
 244       GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
 245   if (user_rotation != current_rotation_) {
 246     // A user may change other display configuration settings. When the user
 247     // does change the rotation setting, then lock rotation to prevent the
 248     // accelerometer from erasing their change.
 249     SetRotationLocked(true);
 250     user_rotation_ = user_rotation;
 251     current_rotation_ = user_rotation;
 252   }
 253 }
 254
 255 #if defined(OS_CHROMEOS)
 256 void MaximizeModeController::LidEventReceived(bool open,
 257                                               const base::TimeTicks& time) {
 258   if (open)
 259     last_lid_open_time_ = time;
 260   lid_is_closed_ = !open;
 261   LeaveMaximizeMode();
 262 }
 263
 264 void MaximizeModeController::SuspendImminent() {
 265   RecordTouchViewStateTransition();
 266 }
 267
 268 void MaximizeModeController::SuspendDone(
 269     const base::TimeDelta& sleep_duration) {
 270   last_touchview_transition_time_ = base::Time::Now();
 271 }
 272 #endif  // OS_CHROMEOS
 273
 274 void MaximizeModeController::HandleHingeRotation(const gfx::Vector3dF& base,
 275                                                  const gfx::Vector3dF& lid) {
 276   static const gfx::Vector3dF hinge_vector(1.0f, 0.0f, 0.0f);
 277   bool maximize_mode_engaged = IsMaximizeModeWindowManagerEnabled();
 278   // Ignore the component of acceleration parallel to the hinge for the purposes
 279   // of hinge angle calculation.
 280   gfx::Vector3dF base_flattened(base);
 281   gfx::Vector3dF lid_flattened(lid);
 282   base_flattened.set_x(0.0f);
 283   lid_flattened.set_x(0.0f);
 284
 285   // As the hinge approaches a vertical angle, the base and lid accelerometers
 286   // approach the same values making any angle calculations highly inaccurate.
 287   // Bail out early when it is too close.
 288   if (base_flattened.Length() < kHingeAngleDetectionThreshold ||
 289       lid_flattened.Length() < kHingeAngleDetectionThreshold) {
 290     return;
 291   }
 292
 293   // Compute the angle between the base and the lid.
 294   float lid_angle = 180.0f - ClockwiseAngleBetweenVectorsInDegrees(
 295       base_flattened, lid_flattened, hinge_vector);
 296   if (lid_angle < 0.0f)
 297     lid_angle += 360.0f;
 298
 299   bool is_angle_stable = lid_angle >= kMinStableAngle &&
 300                          lid_angle <= kMaxStableAngle;
 301
 302   // Clear the last_lid_open_time_ for a stable reading so that there is less
 303   // chance of a delay if the lid is moved from the close state to the fully
 304   // open state very quickly.
 305   if (is_angle_stable)
 306     last_lid_open_time_ = base::TimeTicks();
 307
 308   // Toggle maximize mode on or off when corresponding thresholds are passed.
 309   // TODO(flackr): Make MaximizeModeController own the MaximizeModeWindowManager
 310   // such that observations of state changes occur after the change and shell
 311   // has fewer states to track.
 312   if (maximize_mode_engaged && is_angle_stable &&
 313       lid_angle <= kExitMaximizeModeAngle) {
 314     LeaveMaximizeMode();
 315   } else if (!lid_is_closed_ && !maximize_mode_engaged &&
 316              lid_angle >= kEnterMaximizeModeAngle &&
 317              (is_angle_stable || !WasLidOpenedRecently())) {
 318     EnterMaximizeMode();
 319   }
 320 }
 321
 322 void MaximizeModeController::HandleScreenRotation(const gfx::Vector3dF& lid) {
 323   bool maximize_mode_engaged = IsMaximizeModeWindowManagerEnabled();
 324
 325   // TODO(jonross): track the updated rotation angle even when locked. So that
 326   // when rotation lock is removed the accelerometer rotation can be applied
 327   // without waiting for the next update.
 328   if (!maximize_mode_engaged || rotation_locked_)
 329     return;
 330
 331   DisplayManager* display_manager =
 332       Shell::GetInstance()->display_manager();
 333   gfx::Display::Rotation current_rotation = display_manager->GetDisplayInfo(
 334       gfx::Display::InternalDisplayId()).rotation();
 335
 336   // After determining maximize mode state, determine if the screen should
 337   // be rotated.
 338   gfx::Vector3dF lid_flattened(lid.x(), lid.y(), 0.0f);
 339   float lid_flattened_length = lid_flattened.Length();
 340   // When the lid is close to being flat, don't change rotation as it is too
 341   // sensitive to slight movements.
 342   if (lid_flattened_length < kMinimumAccelerationScreenRotation)
 343     return;
 344
 345   // The reference vector is the angle of gravity when the device is rotated
 346   // clockwise by 45 degrees. Computing the angle between this vector and
 347   // gravity we can easily determine the expected display rotation.
 348   static const gfx::Vector3dF rotation_reference(-1.0f, -1.0f, 0.0f);
 349
 350   // Set the down vector to match the expected direction of gravity given the
 351   // last configured rotation. This is used to enforce a stickiness that the
 352   // user must overcome to rotate the display and prevents frequent rotations
 353   // when holding the device near 45 degrees.
 354   gfx::Vector3dF down(0.0f, 0.0f, 0.0f);
 355   if (current_rotation == gfx::Display::ROTATE_0)
 356     down.set_y(-1.0f);
 357   else if (current_rotation == gfx::Display::ROTATE_90)
 358     down.set_x(-1.0f);
 359   else if (current_rotation == gfx::Display::ROTATE_180)
 360     down.set_y(1.0f);
 361   else
 362     down.set_x(1.0f);
 363
 364   // Don't rotate if the screen has not passed the threshold.
 365   if (AngleBetweenVectorsInDegrees(down, lid_flattened) <
 366       kDisplayRotationStickyAngleDegrees) {
 367     return;
 368   }
 369
 370   float angle = ClockwiseAngleBetweenVectorsInDegrees(rotation_reference,
 371       lid_flattened, gfx::Vector3dF(0.0f, 0.0f, -1.0f));
 372
 373   gfx::Display::Rotation new_rotation = gfx::Display::ROTATE_90;
 374   if (angle < 90.0f)
 375     new_rotation = gfx::Display::ROTATE_0;
 376   else if (angle < 180.0f)
 377     new_rotation = gfx::Display::ROTATE_270;
 378   else if (angle < 270.0f)
 379     new_rotation = gfx::Display::ROTATE_180;
 380
 381   if (new_rotation != current_rotation)
 382     SetDisplayRotation(display_manager, new_rotation);
 383 }
 384
 385 void MaximizeModeController::SetDisplayRotation(
 386     DisplayManager* display_manager,
 387     gfx::Display::Rotation rotation) {
 388   base::AutoReset<bool> auto_ignore_display_configuration_updates(
 389       &ignore_display_configuration_updates_, true);
 390   current_rotation_ = rotation;
 391   display_manager->SetDisplayRotation(gfx::Display::InternalDisplayId(),
 392                                       rotation);
 393 }
 394
 395 void MaximizeModeController::EnterMaximizeMode() {
 396   if (IsMaximizeModeWindowManagerEnabled())
 397     return;
 398   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 399   if (display_manager->HasInternalDisplay()) {
 400     current_rotation_ = user_rotation_ = display_manager->
 401         GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
 402     LoadDisplayRotationProperties();
 403   }
 404   EnableMaximizeModeWindowManager(true);
 405 #if defined(USE_X11)
 406   event_blocker_.reset(new ScopedDisableInternalMouseAndKeyboardX11);
 407 #endif
 408   Shell::GetInstance()->display_controller()->AddObserver(this);
 409 }
 410
 411 void MaximizeModeController::LeaveMaximizeMode() {
 412   if (!IsMaximizeModeWindowManagerEnabled())
 413     return;
 414   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 415   if (display_manager->HasInternalDisplay()) {
 416     gfx::Display::Rotation current_rotation = display_manager->
 417         GetDisplayInfo(gfx::Display::InternalDisplayId()).rotation();
 418     if (current_rotation != user_rotation_)
 419       SetDisplayRotation(display_manager, user_rotation_);
 420   }
 421   if (!shutting_down_)
 422     SetRotationLocked(false);
 423   EnableMaximizeModeWindowManager(false);
 424   event_blocker_.reset();
 425   Shell::GetInstance()->display_controller()->RemoveObserver(this);
 426 }
 427
 428 // Called after maximize mode has started, windows might still animate though.
 429 void MaximizeModeController::OnMaximizeModeStarted() {
 430   RecordTouchViewStateTransition();
 431 }
 432
 433 // Called after maximize mode has ended, windows might still be returning to
 434 // their original position.
 435 void MaximizeModeController::OnMaximizeModeEnded() {
 436   RecordTouchViewStateTransition();
 437 }
 438
 439 void MaximizeModeController::RecordTouchViewStateTransition() {
 440   if (CanEnterMaximizeMode()) {
 441     base::Time current_time = base::Time::Now();
 442     base::TimeDelta delta = current_time - last_touchview_transition_time_;
 443     if (IsMaximizeModeWindowManagerEnabled()) {
 444       UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewInactive", delta);
 445       total_non_touchview_time_ += delta;
 446     } else {
 447       UMA_HISTOGRAM_LONG_TIMES("Ash.TouchView.TouchViewActive", delta);
 448       total_touchview_time_ += delta;
 449     }
 450     last_touchview_transition_time_ = current_time;
 451   }
 452 }
 453
 454 void MaximizeModeController::LoadDisplayRotationProperties() {
 455   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 456   if (!display_manager->registered_internal_display_rotation_lock())
 457     return;
 458
 459   SetDisplayRotation(display_manager,
 460                      display_manager->registered_internal_display_rotation());
 461   SetRotationLocked(true);
 462 }
 463
 464 void MaximizeModeController::OnAppTerminating() {
 465   if (CanEnterMaximizeMode()) {
 466     RecordTouchViewStateTransition();
 467     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewActiveTotal",
 468         total_touchview_time_.InMinutes(),
 469         1, base::TimeDelta::FromDays(7).InMinutes(), 50);
 470     UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.TouchView.TouchViewInactiveTotal",
 471         total_non_touchview_time_.InMinutes(),
 472         1, base::TimeDelta::FromDays(7).InMinutes(), 50);
 473     base::TimeDelta total_runtime = total_touchview_time_ +
 474         total_non_touchview_time_;
 475     if (total_runtime.InSeconds() > 0) {
 476       UMA_HISTOGRAM_PERCENTAGE("Ash.TouchView.TouchViewActivePercentage",
 477           100 * total_touchview_time_.InSeconds() / total_runtime.InSeconds());
 478     }
 479   }
 480   Shell::GetInstance()->display_controller()->RemoveObserver(this);
 481 }
 482
 483 bool MaximizeModeController::WasLidOpenedRecently() const {
 484   if (last_lid_open_time_.is_null())
 485     return false;
 486
 487   base::TimeTicks now = tick_clock_->NowTicks();
 488   DCHECK(now >= last_lid_open_time_);
 489   base::TimeDelta elapsed_time = now - last_lid_open_time_;
 490   return elapsed_time <= kLidRecentlyOpenedDuration;
 491 }
 492
 493 void MaximizeModeController::SetTickClockForTest(
 494     scoped_ptr<base::TickClock> tick_clock) {
 495   DCHECK(tick_clock_);
 496   tick_clock_ = tick_clock.Pass();
 497 }
 498
 499 }  // namespace ash