chrome/browser/signin/easy_unlock_screenlock_state_handler.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 "chrome/browser/signin/easy_unlock_screenlock_state_handler.h"
   6
   7 #include "base/bind.h"
   8 #include "base/strings/string16.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "chrome/browser/chromeos/chromeos_utils.h"
  11 #include "chrome/browser/signin/easy_unlock_metrics.h"
  12 #include "chrome/grit/generated_resources.h"
  13 #include "ui/base/l10n/l10n_util.h"
  14
  15 namespace {
  16
  17 ScreenlockBridge::UserPodCustomIcon GetIconForState(
  18     EasyUnlockScreenlockStateHandler::State state) {
  19   switch (state) {
  20     case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
  21     case EasyUnlockScreenlockStateHandler::STATE_NO_PHONE:
  22     case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED:
  23     case EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED:
  24     case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE:
  25     case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED:
  26     case EasyUnlockScreenlockStateHandler::STATE_RSSI_TOO_LOW:
  27       return ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED;
  28     case EasyUnlockScreenlockStateHandler::STATE_TX_POWER_TOO_HIGH:
  29     case EasyUnlockScreenlockStateHandler::
  30              STATE_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH:
  31       // TODO(isherman): This icon is currently identical to the regular locked
  32       // icon.  Once the reduced proximity range flag is removed, consider
  33       // deleting the redundant icon.
  34       return ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED_WITH_PROXIMITY_HINT;
  35     case EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING:
  36       return ScreenlockBridge::USER_POD_CUSTOM_ICON_SPINNER;
  37     case EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED:
  38       return ScreenlockBridge::USER_POD_CUSTOM_ICON_UNLOCKED;
  39     default:
  40       return ScreenlockBridge::USER_POD_CUSTOM_ICON_NONE;
  41   }
  42 }
  43
  44 bool HardlockOnClick(EasyUnlockScreenlockStateHandler::State state) {
  45   return state != EasyUnlockScreenlockStateHandler::STATE_INACTIVE;
  46 }
  47
  48 size_t GetTooltipResourceId(EasyUnlockScreenlockStateHandler::State state) {
  49   switch (state) {
  50     case EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH:
  51       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_NO_BLUETOOTH;
  52     case EasyUnlockScreenlockStateHandler::STATE_NO_PHONE:
  53       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_NO_PHONE;
  54     case EasyUnlockScreenlockStateHandler::STATE_PHONE_NOT_AUTHENTICATED:
  55       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_NOT_AUTHENTICATED;
  56     case EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED:
  57       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_LOCKED;
  58     case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE:
  59       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_UNLOCKABLE;
  60     case EasyUnlockScreenlockStateHandler::STATE_RSSI_TOO_LOW:
  61       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_RSSI_TOO_LOW;
  62     case EasyUnlockScreenlockStateHandler::STATE_TX_POWER_TOO_HIGH:
  63       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_TX_POWER_TOO_HIGH;
  64     case EasyUnlockScreenlockStateHandler::
  65              STATE_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH:
  66       return
  67           IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH;
  68     case EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED:
  69       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_INSTRUCTIONS;
  70     case EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED:
  71       return IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_UNSUPPORTED_ANDROID_VERSION;
  72     default:
  73       return 0;
  74   }
  75 }
  76
  77 bool TooltipContainsDeviceType(EasyUnlockScreenlockStateHandler::State state) {
  78   return state == EasyUnlockScreenlockStateHandler::STATE_AUTHENTICATED ||
  79          state == EasyUnlockScreenlockStateHandler::STATE_PHONE_UNLOCKABLE ||
  80          state == EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH ||
  81          state == EasyUnlockScreenlockStateHandler::STATE_PHONE_UNSUPPORTED ||
  82          state == EasyUnlockScreenlockStateHandler::STATE_TX_POWER_TOO_HIGH ||
  83          state == EasyUnlockScreenlockStateHandler::
  84                       STATE_PHONE_LOCKED_AND_TX_POWER_TOO_HIGH;
  85 }
  86
  87 }  // namespace
  88
  89
  90 EasyUnlockScreenlockStateHandler::EasyUnlockScreenlockStateHandler(
  91     const std::string& user_email,
  92     HardlockState initial_hardlock_state,
  93     ScreenlockBridge* screenlock_bridge)
  94     : state_(STATE_INACTIVE),
  95       user_email_(user_email),
  96       screenlock_bridge_(screenlock_bridge),
  97       hardlock_state_(initial_hardlock_state),
  98       hardlock_ui_shown_(false),
  99       is_trial_run_(false) {
 100   DCHECK(screenlock_bridge_);
 101   screenlock_bridge_->AddObserver(this);
 102 }
 103
 104 EasyUnlockScreenlockStateHandler::~EasyUnlockScreenlockStateHandler() {
 105   screenlock_bridge_->RemoveObserver(this);
 106   // Make sure the screenlock state set by this gets cleared.
 107   ChangeState(STATE_INACTIVE);
 108 }
 109
 110 bool EasyUnlockScreenlockStateHandler::IsActive() const {
 111   return state_ != STATE_INACTIVE;
 112 }
 113
 114 bool EasyUnlockScreenlockStateHandler::InStateValidOnRemoteAuthFailure() const {
 115   // Note that NO_PHONE is not valid in this case because the phone may close
 116   // the connection if the auth challenge sent to it is invalid. This case
 117   // should be handled as authentication failure.
 118   return state_ == EasyUnlockScreenlockStateHandler::STATE_NO_BLUETOOTH ||
 119          state_ == EasyUnlockScreenlockStateHandler::STATE_PHONE_LOCKED;
 120 }
 121
 122 void EasyUnlockScreenlockStateHandler::ChangeState(State new_state) {
 123   if (state_ == new_state)
 124     return;
 125
 126   state_ = new_state;
 127
 128   // If lock screen is not active or it forces offline password, just cache the
 129   // current state. The screenlock state will get refreshed in |ScreenDidLock|.
 130   if (!screenlock_bridge_->IsLocked())
 131     return;
 132
 133   // Do nothing when auth type is online.
 134   if (screenlock_bridge_->lock_handler()->GetAuthType(user_email_) ==
 135       ScreenlockBridge::LockHandler::ONLINE_SIGN_IN) {
 136     return;
 137   }
 138
 139   // No hardlock UI for trial run.
 140   if (!is_trial_run_ && hardlock_state_ != NO_HARDLOCK) {
 141     ShowHardlockUI();
 142     return;
 143   }
 144
 145   UpdateScreenlockAuthType();
 146
 147   ScreenlockBridge::UserPodCustomIcon icon = GetIconForState(state_);
 148
 149   if (icon == ScreenlockBridge::USER_POD_CUSTOM_ICON_NONE) {
 150     screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_email_);
 151     return;
 152   }
 153
 154   ScreenlockBridge::UserPodCustomIconOptions icon_options;
 155   icon_options.SetIcon(icon);
 156
 157   // Don't hardlock on trial run.
 158   if (is_trial_run_)
 159     icon_options.SetTrialRun();
 160   else if (HardlockOnClick(state_))
 161     icon_options.SetHardlockOnClick();
 162
 163   UpdateTooltipOptions(&icon_options);
 164
 165   // For states without tooltips, we still need to set an accessibility label.
 166   if (state_ == EasyUnlockScreenlockStateHandler::STATE_BLUETOOTH_CONNECTING) {
 167     icon_options.SetAriaLabel(
 168         l10n_util::GetStringUTF16(IDS_SMART_LOCK_SPINNER_ACCESSIBILITY_LABEL));
 169   }
 170
 171   screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_email_,
 172                                                             icon_options);
 173 }
 174
 175 void EasyUnlockScreenlockStateHandler::SetHardlockState(
 176     HardlockState new_state) {
 177   if (hardlock_state_ == new_state)
 178     return;
 179
 180   if (new_state == LOGIN_FAILED && hardlock_state_ != NO_HARDLOCK)
 181     return;
 182
 183   hardlock_state_ = new_state;
 184
 185   // If hardlock_state_ was set to NO_HARDLOCK, this means the screen is about
 186   // to get unlocked. No need to update it in this case.
 187   if (hardlock_state_ != NO_HARDLOCK) {
 188     hardlock_ui_shown_ = false;
 189
 190     RefreshScreenlockState();
 191   }
 192 }
 193
 194 void EasyUnlockScreenlockStateHandler::MaybeShowHardlockUI() {
 195   if (hardlock_state_ != NO_HARDLOCK)
 196     ShowHardlockUI();
 197 }
 198
 199 void EasyUnlockScreenlockStateHandler::SetTrialRun() {
 200   if (is_trial_run_)
 201     return;
 202   is_trial_run_ = true;
 203   RefreshScreenlockState();
 204   RecordEasyUnlockTrialRunEvent(EASY_UNLOCK_TRIAL_RUN_EVENT_LAUNCHED);
 205 }
 206
 207 void EasyUnlockScreenlockStateHandler::RecordClickOnLockIcon() {
 208   if (!is_trial_run_)
 209     return;
 210   RecordEasyUnlockTrialRunEvent(EASY_UNLOCK_TRIAL_RUN_EVENT_CLICKED_LOCK_ICON);
 211 }
 212
 213 void EasyUnlockScreenlockStateHandler::OnScreenDidLock(
 214     ScreenlockBridge::LockHandler::ScreenType screen_type) {
 215   RefreshScreenlockState();
 216 }
 217
 218 void EasyUnlockScreenlockStateHandler::OnScreenDidUnlock(
 219     ScreenlockBridge::LockHandler::ScreenType screen_type) {
 220   if (hardlock_state_ == LOGIN_FAILED)
 221     hardlock_state_ = NO_HARDLOCK;
 222   hardlock_ui_shown_ = false;
 223   is_trial_run_ = false;
 224 }
 225
 226 void EasyUnlockScreenlockStateHandler::OnFocusedUserChanged(
 227     const std::string& user_id) {
 228 }
 229
 230 void EasyUnlockScreenlockStateHandler::RefreshScreenlockState() {
 231   State last_state = state_;
 232   // This should force updating screenlock state.
 233   state_ = STATE_INACTIVE;
 234   ChangeState(last_state);
 235 }
 236
 237 void EasyUnlockScreenlockStateHandler::ShowHardlockUI() {
 238   DCHECK(hardlock_state_ != NO_HARDLOCK);
 239
 240   if (!screenlock_bridge_->IsLocked())
 241     return;
 242
 243   // Do not override online signin.
 244   const ScreenlockBridge::LockHandler::AuthType existing_auth_type =
 245       screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
 246   if (existing_auth_type == ScreenlockBridge::LockHandler::ONLINE_SIGN_IN)
 247     return;
 248
 249   if (existing_auth_type != ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
 250     screenlock_bridge_->lock_handler()->SetAuthType(
 251         user_email_,
 252         ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 253         base::string16());
 254   }
 255
 256   if (hardlock_state_ == NO_PAIRING) {
 257     screenlock_bridge_->lock_handler()->HideUserPodCustomIcon(user_email_);
 258     hardlock_ui_shown_ = false;
 259     return;
 260   }
 261
 262   if (hardlock_ui_shown_)
 263     return;
 264
 265   ScreenlockBridge::UserPodCustomIconOptions icon_options;
 266   if (hardlock_state_ == LOGIN_FAILED) {
 267     icon_options.SetIcon(ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED);
 268   } else if (hardlock_state_ == PAIRING_CHANGED ||
 269              hardlock_state_ == PAIRING_ADDED) {
 270     icon_options.SetIcon(
 271         ScreenlockBridge::USER_POD_CUSTOM_ICON_LOCKED_TO_BE_ACTIVATED);
 272   } else {
 273     icon_options.SetIcon(ScreenlockBridge::USER_POD_CUSTOM_ICON_HARDLOCKED);
 274   }
 275
 276   base::string16 device_name = GetDeviceName();
 277   base::string16 tooltip;
 278   if (hardlock_state_ == USER_HARDLOCK) {
 279     tooltip = l10n_util::GetStringFUTF16(
 280         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_USER, device_name);
 281   } else if (hardlock_state_ == PAIRING_CHANGED) {
 282     tooltip = l10n_util::GetStringUTF16(
 283         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_PAIRING_CHANGED);
 284   } else if (hardlock_state_ == PAIRING_ADDED) {
 285     tooltip = l10n_util::GetStringFUTF16(
 286         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_HARDLOCK_PAIRING_ADDED, device_name,
 287         device_name);
 288   } else if (hardlock_state_ == LOGIN_FAILED) {
 289     tooltip = l10n_util::GetStringUTF16(
 290         IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_LOGIN_FAILURE);
 291   } else {
 292     LOG(ERROR) << "Unknown hardlock state " << hardlock_state_;
 293   }
 294   icon_options.SetTooltip(tooltip, true /* autoshow */);
 295
 296   screenlock_bridge_->lock_handler()->ShowUserPodCustomIcon(user_email_,
 297                                                             icon_options);
 298   hardlock_ui_shown_ = true;
 299 }
 300
 301 void EasyUnlockScreenlockStateHandler::UpdateTooltipOptions(
 302     ScreenlockBridge::UserPodCustomIconOptions* icon_options) {
 303   size_t resource_id = 0;
 304   base::string16 device_name;
 305   if (is_trial_run_ && state_ == STATE_AUTHENTICATED) {
 306     resource_id = IDS_EASY_UNLOCK_SCREENLOCK_TOOLTIP_INITIAL_AUTHENTICATED;
 307   } else {
 308     resource_id = GetTooltipResourceId(state_);
 309     if (TooltipContainsDeviceType(state_))
 310       device_name = GetDeviceName();
 311   }
 312
 313   if (!resource_id)
 314     return;
 315
 316   base::string16 tooltip;
 317   if (device_name.empty()) {
 318     tooltip = l10n_util::GetStringUTF16(resource_id);
 319   } else {
 320     tooltip = l10n_util::GetStringFUTF16(resource_id, device_name);
 321   }
 322
 323   if (tooltip.empty())
 324     return;
 325
 326   icon_options->SetTooltip(
 327       tooltip,
 328       is_trial_run_ || (state_ != STATE_AUTHENTICATED) /* autoshow tooltip */);
 329 }
 330
 331 base::string16 EasyUnlockScreenlockStateHandler::GetDeviceName() {
 332 #if defined(OS_CHROMEOS)
 333   return chromeos::GetChromeDeviceType();
 334 #else
 335   // TODO(tbarzic): Figure out the name for non Chrome OS case.
 336   return base::ASCIIToUTF16("Chrome");
 337 #endif
 338 }
 339
 340 void EasyUnlockScreenlockStateHandler::UpdateScreenlockAuthType() {
 341   if (!is_trial_run_ && hardlock_state_ != NO_HARDLOCK)
 342     return;
 343
 344   // Do not override online signin.
 345   const ScreenlockBridge::LockHandler::AuthType existing_auth_type =
 346       screenlock_bridge_->lock_handler()->GetAuthType(user_email_);
 347   DCHECK_NE(ScreenlockBridge::LockHandler::ONLINE_SIGN_IN, existing_auth_type);
 348
 349   if (state_ == STATE_AUTHENTICATED) {
 350     if (existing_auth_type != ScreenlockBridge::LockHandler::USER_CLICK) {
 351       screenlock_bridge_->lock_handler()->SetAuthType(
 352           user_email_,
 353           ScreenlockBridge::LockHandler::USER_CLICK,
 354           l10n_util::GetStringUTF16(
 355               IDS_EASY_UNLOCK_SCREENLOCK_USER_POD_AUTH_VALUE));
 356     }
 357   } else if (existing_auth_type !=
 358              ScreenlockBridge::LockHandler::OFFLINE_PASSWORD) {
 359     screenlock_bridge_->lock_handler()->SetAuthType(
 360         user_email_,
 361         ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
 362         base::string16());
 363   }
 364 }