1// Copyright (c) 2012 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/ui/webui/chromeos/login/network_screen_handler.h"
6
7#include "base/bind.h"
8#include "base/bind_helpers.h"
9#include "base/memory/weak_ptr.h"
10#include "base/prefs/pref_service.h"
11#include "base/strings/utf_string_conversions.h"
12#include "base/values.h"
13#include "chrome/browser/browser_process.h"
14#include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
15#include "chrome/browser/chromeos/base/locale_util.h"
16#include "chrome/browser/chromeos/customization_document.h"
17#include "chrome/browser/chromeos/idle_detector.h"
18#include "chrome/browser/chromeos/login/screens/core_oobe_actor.h"
19#include "chrome/browser/chromeos/login/ui/input_events_blocker.h"
20#include "chrome/browser/chromeos/system/input_device_settings.h"
21#include "chrome/browser/chromeos/system/timezone_util.h"
22#include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
23#include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
24#include "chrome/common/pref_names.h"
25#include "chrome/grit/generated_resources.h"
26#include "chromeos/ime/extension_ime_util.h"
27#include "chromeos/network/network_handler.h"
28#include "chromeos/network/network_state_handler.h"
29#include "ui/base/l10n/l10n_util.h"
30#include "ui/gfx/rect.h"
31#include "ui/views/layout/fill_layout.h"
32#include "ui/views/widget/widget.h"
33
34namespace {
35
36const char kJsScreenPath[] = "login.NetworkScreen";
37
38// JS API callbacks names.
39const char kJsApiNetworkOnExit[] = "networkOnExit";
40const char kJsApiNetworkOnLanguageChanged[] = "networkOnLanguageChanged";
41const char kJsApiNetworkOnInputMethodChanged[] = "networkOnInputMethodChanged";
42const char kJsApiNetworkOnTimezoneChanged[] = "networkOnTimezoneChanged";
43
44// For "UI Language" drop-down menu at OOBE screen we need to decide which
45// entry to mark "selected". If user has just selected "requested_locale",
46// but "loaded_locale" was actually loaded, we mark original user choice
47// "selected" only if loaded_locale is a backup for "requested_locale".
48std::string CalculateSelectedLanguage(const std::string& requested_locale,
49                                      const std::string& loaded_locale) {
50  std::string resolved_locale;
51  if (!l10n_util::CheckAndResolveLocale(requested_locale, &resolved_locale))
52    return loaded_locale;
53
54  if (resolved_locale == loaded_locale)
55    return requested_locale;
56
57  return loaded_locale;
58}
59
60}  // namespace
61
62namespace chromeos {
63
64// NetworkScreenHandler, public: -----------------------------------------------
65
66NetworkScreenHandler::NetworkScreenHandler(CoreOobeActor* core_oobe_actor)
67    : BaseScreenHandler(kJsScreenPath),
68      screen_(NULL),
69      core_oobe_actor_(core_oobe_actor),
70      is_continue_enabled_(false),
71      show_on_init_(false),
72      weak_ptr_factory_(this) {
73  DCHECK(core_oobe_actor_);
74
75  input_method::InputMethodManager* manager =
76      input_method::InputMethodManager::Get();
77  manager->AddObserver(this);
78}
79
80NetworkScreenHandler::~NetworkScreenHandler() {
81  if (screen_)
82    screen_->OnActorDestroyed(this);
83
84  input_method::InputMethodManager* manager =
85      input_method::InputMethodManager::Get();
86  manager->RemoveObserver(this);
87}
88
89// NetworkScreenHandler, NetworkScreenActor implementation: --------------------
90
91void NetworkScreenHandler::SetDelegate(NetworkScreenActor::Delegate* screen) {
92  screen_ = screen;
93}
94
95void NetworkScreenHandler::PrepareToShow() {
96}
97
98void NetworkScreenHandler::Show() {
99  if (!page_is_ready()) {
100    show_on_init_ = true;
101    return;
102  }
103
104  // Here we should handle default locales, for which we do not have UI
105  // resources. This would load fallback, but properly show "selected" locale
106  // in the UI.
107  if (selected_language_code_.empty()) {
108    const StartupCustomizationDocument* startup_manifest =
109        StartupCustomizationDocument::GetInstance();
110    HandleOnLanguageChanged(startup_manifest->initial_locale_default());
111  }
112
113  PrefService* prefs = g_browser_process->local_state();
114  if (prefs->GetBoolean(prefs::kFactoryResetRequested)) {
115    if (core_oobe_actor_)
116      core_oobe_actor_->ShowDeviceResetScreen();
117    return;
118  }
119
120  // Make sure all our network technologies are turned on. On OOBE, the user
121  // should be able to select any of the available networks on the device.
122  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
123  handler->SetTechnologyEnabled(NetworkTypePattern::NonVirtual(),
124                                true,
125                                chromeos::network_handler::ErrorCallback());
126  ShowScreen(OobeUI::kScreenOobeNetwork, NULL);
127  core_oobe_actor_->InitDemoModeDetection();
128}
129
130void NetworkScreenHandler::Hide() {
131}
132
133void NetworkScreenHandler::ShowError(const base::string16& message) {
134  CallJS("showError", message);
135}
136
137void NetworkScreenHandler::ClearErrors() {
138  if (page_is_ready())
139    core_oobe_actor_->ClearErrors();
140}
141
142void NetworkScreenHandler::ShowConnectingStatus(
143    bool connecting,
144    const base::string16& network_id) {
145}
146
147void NetworkScreenHandler::EnableContinue(bool enabled) {
148  is_continue_enabled_ = enabled;
149  if (page_is_ready())
150    CallJS("enableContinueButton", enabled);
151}
152
153// NetworkScreenHandler, BaseScreenHandler implementation: --------------------
154
155void NetworkScreenHandler::DeclareLocalizedValues(
156    LocalizedValuesBuilder* builder) {
157  if (system::InputDeviceSettings::Get()->ForceKeyboardDrivenUINavigation())
158    builder->Add("networkScreenGreeting", IDS_REMORA_CONFIRM_MESSAGE);
159  else
160    builder->Add("networkScreenGreeting", IDS_WELCOME_SCREEN_GREETING);
161
162  builder->Add("networkScreenTitle", IDS_WELCOME_SCREEN_TITLE);
163  builder->Add("networkScreenAccessibleTitle",
164               IDS_NETWORK_SCREEN_ACCESSIBLE_TITLE);
165  builder->Add("selectLanguage", IDS_LANGUAGE_SELECTION_SELECT);
166  builder->Add("selectKeyboard", IDS_KEYBOARD_SELECTION_SELECT);
167  builder->Add("selectNetwork", IDS_NETWORK_SELECTION_SELECT);
168  builder->Add("selectTimezone", IDS_OPTIONS_SETTINGS_TIMEZONE_DESCRIPTION);
169  builder->Add("proxySettings", IDS_OPTIONS_PROXIES_CONFIGURE_BUTTON);
170  builder->Add("continueButton", IDS_NETWORK_SELECTION_CONTINUE_BUTTON);
171}
172
173void NetworkScreenHandler::GetAdditionalParameters(
174    base::DictionaryValue* dict) {
175  const std::string application_locale =
176      g_browser_process->GetApplicationLocale();
177  const std::string selected_language = selected_language_code_.empty() ?
178      application_locale : selected_language_code_;
179  const std::string selected_input_method =
180      input_method::InputMethodManager::Get()
181          ->GetActiveIMEState()
182          ->GetCurrentInputMethod()
183          .id();
184
185  dict->Set("languageList",
186            GetUILanguageList(NULL, selected_language).release());
187  dict->Set("inputMethodsList",
188            GetAndActivateLoginKeyboardLayouts(
189                application_locale, selected_input_method).release());
190  dict->Set("timezoneList", GetTimezoneList());
191}
192
193void NetworkScreenHandler::Initialize() {
194  EnableContinue(is_continue_enabled_);
195  if (show_on_init_) {
196    show_on_init_ = false;
197    Show();
198  }
199
200  timezone_subscription_ = CrosSettings::Get()->AddSettingsObserver(
201      kSystemTimezone,
202      base::Bind(&NetworkScreenHandler::OnSystemTimezoneChanged,
203                 base::Unretained(this)));
204  OnSystemTimezoneChanged();
205}
206
207// NetworkScreenHandler, WebUIMessageHandler implementation: -------------------
208
209void NetworkScreenHandler::RegisterMessages() {
210  AddCallback(kJsApiNetworkOnExit, &NetworkScreenHandler::HandleOnExit);
211  AddCallback(kJsApiNetworkOnLanguageChanged,
212              &NetworkScreenHandler::HandleOnLanguageChanged);
213  AddCallback(kJsApiNetworkOnInputMethodChanged,
214              &NetworkScreenHandler::HandleOnInputMethodChanged);
215  AddCallback(kJsApiNetworkOnTimezoneChanged,
216              &NetworkScreenHandler::HandleOnTimezoneChanged);
217}
218
219
220// NetworkScreenHandler, private: ----------------------------------------------
221
222void NetworkScreenHandler::HandleOnExit() {
223  core_oobe_actor_->StopDemoModeDetection();
224  ClearErrors();
225  if (screen_)
226    screen_->OnContinuePressed();
227}
228
229struct NetworkScreenHandlerOnLanguageChangedCallbackData {
230  explicit NetworkScreenHandlerOnLanguageChangedCallbackData(
231      const base::WeakPtr<NetworkScreenHandler>& handler)
232      : handler(handler) {}
233
234  base::WeakPtr<NetworkScreenHandler> handler;
235
236  // Block UI while resource bundle is being reloaded.
237  chromeos::InputEventsBlocker input_events_blocker;
238};
239
240// static
241void NetworkScreenHandler::OnLanguageChangedCallback(
242    scoped_ptr<NetworkScreenHandlerOnLanguageChangedCallbackData> context,
243    const std::string& requested_locale,
244    const std::string& loaded_locale,
245    const bool success) {
246  if (!context || !context->handler)
247    return;
248
249  NetworkScreenHandler* const self = context->handler.get();
250
251  if (success) {
252    if (requested_locale == loaded_locale) {
253      self->selected_language_code_ = requested_locale;
254    } else {
255      self->selected_language_code_ =
256          CalculateSelectedLanguage(requested_locale, loaded_locale);
257    }
258  } else {
259    self->selected_language_code_ = loaded_locale;
260  }
261
262  self->ReloadLocalizedContent();
263
264  // We still do not have device owner, so owner settings are not applied.
265  // But Guest session can be started before owner is created, so we need to
266  // save locale settings directly here.
267  g_browser_process->local_state()->SetString(prefs::kApplicationLocale,
268                                              self->selected_language_code_);
269
270  AccessibilityManager::Get()->OnLocaleChanged();
271}
272
273void NetworkScreenHandler::HandleOnLanguageChanged(const std::string& locale) {
274  const std::string app_locale = g_browser_process->GetApplicationLocale();
275  if (app_locale == locale)
276    return;
277
278  base::WeakPtr<NetworkScreenHandler> weak_self =
279      weak_ptr_factory_.GetWeakPtr();
280  scoped_ptr<NetworkScreenHandlerOnLanguageChangedCallbackData> callback_data(
281      new NetworkScreenHandlerOnLanguageChangedCallbackData(weak_self));
282  scoped_ptr<locale_util::SwitchLanguageCallback> callback(
283      new locale_util::SwitchLanguageCallback(
284          base::Bind(&NetworkScreenHandler::OnLanguageChangedCallback,
285                     base::Passed(callback_data.Pass()))));
286  locale_util::SwitchLanguage(locale,
287                              true /* enableLocaleKeyboardLayouts */,
288                              true /* login_layouts_only */,
289                              callback.Pass());
290}
291
292void NetworkScreenHandler::HandleOnInputMethodChanged(const std::string& id) {
293  input_method::InputMethodManager::Get()
294      ->GetActiveIMEState()
295      ->ChangeInputMethod(id, false /* show_message */);
296}
297
298void NetworkScreenHandler::HandleOnTimezoneChanged(
299    const std::string& timezone_id) {
300  std::string current_timezone_id;
301  CrosSettings::Get()->GetString(kSystemTimezone, &current_timezone_id);
302  if (current_timezone_id == timezone_id)
303    return;
304
305  CrosSettings::Get()->SetString(kSystemTimezone, timezone_id);
306}
307
308void NetworkScreenHandler::OnSystemTimezoneChanged() {
309  std::string current_timezone_id;
310  CrosSettings::Get()->GetString(kSystemTimezone, &current_timezone_id);
311  CallJS("setTimezone", current_timezone_id);
312}
313
314void NetworkScreenHandler::InputMethodChanged(
315    input_method::InputMethodManager* manager, bool show_message) {
316  CallJS("setInputMethod",
317         manager->GetActiveIMEState()->GetCurrentInputMethod().id());
318}
319
320void NetworkScreenHandler::ReloadLocalizedContent() {
321  base::DictionaryValue localized_strings;
322  static_cast<OobeUI*>(web_ui()->GetController())
323      ->GetLocalizedStrings(&localized_strings);
324  core_oobe_actor_->ReloadContent(localized_strings);
325
326  // Buttons are recreated, updated "Continue" button state.
327  EnableContinue(is_continue_enabled_);
328}
329
330// static
331base::ListValue* NetworkScreenHandler::GetTimezoneList() {
332  std::string current_timezone_id;
333  CrosSettings::Get()->GetString(kSystemTimezone, &current_timezone_id);
334
335  scoped_ptr<base::ListValue> timezone_list(new base::ListValue);
336  scoped_ptr<base::ListValue> timezones = system::GetTimezoneList().Pass();
337  for (size_t i = 0; i < timezones->GetSize(); ++i) {
338    const base::ListValue* timezone = NULL;
339    CHECK(timezones->GetList(i, &timezone));
340
341    std::string timezone_id;
342    CHECK(timezone->GetString(0, &timezone_id));
343
344    std::string timezone_name;
345    CHECK(timezone->GetString(1, &timezone_name));
346
347    scoped_ptr<base::DictionaryValue> timezone_option(
348        new base::DictionaryValue);
349    timezone_option->SetString("value", timezone_id);
350    timezone_option->SetString("title", timezone_name);
351    timezone_option->SetBoolean("selected", timezone_id == current_timezone_id);
352    timezone_list->Append(timezone_option.release());
353  }
354
355  return timezone_list.release();
356}
357
358}  // namespace chromeos
359