OLD | NEW |
| (Empty) |
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 "athena/system/network_selector.h" | |
6 | |
7 #include "athena/screen/public/screen_manager.h" | |
8 #include "base/memory/weak_ptr.h" | |
9 #include "base/strings/utf_string_conversions.h" | |
10 #include "chromeos/network/network_configuration_handler.h" | |
11 #include "chromeos/network/network_connection_handler.h" | |
12 #include "chromeos/network/network_handler.h" | |
13 #include "chromeos/network/network_profile_handler.h" | |
14 #include "chromeos/network/network_state.h" | |
15 #include "chromeos/network/network_state_handler.h" | |
16 #include "chromeos/network/network_state_handler_observer.h" | |
17 #include "chromeos/network/network_type_pattern.h" | |
18 #include "third_party/cros_system_api/dbus/service_constants.h" | |
19 #include "ui/aura/window.h" | |
20 #include "ui/chromeos/network/network_icon.h" | |
21 #include "ui/chromeos/network/network_info.h" | |
22 #include "ui/chromeos/network/network_list.h" | |
23 #include "ui/chromeos/network/network_list_delegate.h" | |
24 #include "ui/compositor/layer.h" | |
25 #include "ui/gfx/canvas.h" | |
26 #include "ui/gfx/font.h" | |
27 #include "ui/gfx/font_list.h" | |
28 #include "ui/gfx/geometry/rect.h" | |
29 #include "ui/gfx/text_constants.h" | |
30 #include "ui/views/background.h" | |
31 #include "ui/views/border.h" | |
32 #include "ui/views/controls/button/blue_button.h" | |
33 #include "ui/views/controls/button/button.h" | |
34 #include "ui/views/controls/image_view.h" | |
35 #include "ui/views/controls/label.h" | |
36 #include "ui/views/controls/scroll_view.h" | |
37 #include "ui/views/controls/scrollbar/overlay_scroll_bar.h" | |
38 #include "ui/views/controls/textfield/textfield.h" | |
39 #include "ui/views/layout/box_layout.h" | |
40 #include "ui/views/layout/fill_layout.h" | |
41 #include "ui/views/widget/widget.h" | |
42 #include "ui/views/window/dialog_delegate.h" | |
43 | |
44 using chromeos::NetworkConfigurationHandler; | |
45 using chromeos::NetworkConfigurationObserver; | |
46 using chromeos::NetworkConnectionHandler; | |
47 using chromeos::NetworkHandler; | |
48 using chromeos::NetworkProfileHandler; | |
49 using chromeos::NetworkState; | |
50 | |
51 namespace { | |
52 | |
53 // The View for the user to enter the password for connceting to a network. This | |
54 // view also shows an error message if the network connection fails. | |
55 class PasswordView : public views::View, public views::ButtonListener { | |
56 public: | |
57 PasswordView(const ui::NetworkInfo& network, | |
58 const base::Callback<void(bool)>& callback) | |
59 : network_(network), | |
60 callback_(callback), | |
61 connect_(nullptr), | |
62 cancel_(nullptr), | |
63 textfield_(nullptr), | |
64 error_msg_(nullptr), | |
65 weak_ptr_(this) { | |
66 const int kHorizontal = 5; | |
67 const int kVertical = 0; | |
68 const int kPadding = 0; | |
69 | |
70 views::BoxLayout* layout = new views::BoxLayout( | |
71 views::BoxLayout::kVertical, kHorizontal, kVertical, kPadding); | |
72 layout->set_main_axis_alignment( | |
73 views::BoxLayout::MAIN_AXIS_ALIGNMENT_START); | |
74 layout->set_cross_axis_alignment( | |
75 views::BoxLayout::CROSS_AXIS_ALIGNMENT_STRETCH); | |
76 SetLayoutManager(layout); | |
77 | |
78 views::View* container = new views::View; | |
79 layout = new views::BoxLayout( | |
80 views::BoxLayout::kHorizontal, kHorizontal, kVertical, kPadding); | |
81 layout->set_main_axis_alignment( | |
82 views::BoxLayout::MAIN_AXIS_ALIGNMENT_START); | |
83 container->SetLayoutManager(layout); | |
84 | |
85 textfield_ = new views::Textfield(); | |
86 textfield_->set_placeholder_text(base::ASCIIToUTF16("Password")); | |
87 textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD); | |
88 textfield_->set_default_width_in_chars(35); | |
89 container->AddChildView(textfield_); | |
90 | |
91 connect_ = new views::BlueButton(this, base::ASCIIToUTF16("Connect")); | |
92 container->AddChildView(connect_); | |
93 | |
94 cancel_ = new views::LabelButton(this, base::ASCIIToUTF16("Cancel")); | |
95 cancel_->SetHorizontalAlignment(gfx::ALIGN_CENTER); | |
96 container->AddChildView(cancel_); | |
97 | |
98 AddChildView(container); | |
99 } | |
100 | |
101 ~PasswordView() override {} | |
102 | |
103 private: | |
104 void CloseDialog(bool successful) { callback_.Run(successful); } | |
105 | |
106 void OnKnownError(const std::string& error_name, | |
107 scoped_ptr<base::DictionaryValue> error_data) { | |
108 std::string message; | |
109 if (!error_data->GetString(chromeos::network_handler::kDbusErrorMessage, | |
110 &message)) | |
111 message = error_name; | |
112 if (message.empty()) | |
113 message = std::string("Unknown error."); | |
114 if (!error_msg_) { | |
115 error_msg_ = new views::Label(); | |
116 error_msg_->SetFontList( | |
117 error_msg_->font_list().Derive(0, gfx::Font::BOLD)); | |
118 error_msg_->SetEnabledColor(SK_ColorRED); | |
119 } | |
120 error_msg_->SetText(base::UTF8ToUTF16(message)); | |
121 if (!error_msg_->parent()) { | |
122 AddChildView(error_msg_); | |
123 InvalidateLayout(); | |
124 GetWidget()->GetRootView()->Layout(); | |
125 ScrollRectToVisible(error_msg_->bounds()); | |
126 } | |
127 connect_->SetEnabled(true); | |
128 } | |
129 | |
130 void OnSetProfileSucceed(const base::string16& password) { | |
131 base::DictionaryValue properties; | |
132 properties.SetStringWithoutPathExpansion(shill::kPassphraseProperty, | |
133 textfield_->text()); | |
134 NetworkHandler::Get()->network_configuration_handler()->SetProperties( | |
135 network_.service_path, | |
136 properties, | |
137 NetworkConfigurationObserver::SOURCE_USER_ACTION, | |
138 base::Bind(&PasswordView::OnSetPropertiesSucceed, | |
139 weak_ptr_.GetWeakPtr()), | |
140 base::Bind(&PasswordView::OnKnownError, weak_ptr_.GetWeakPtr())); | |
141 } | |
142 | |
143 void OnSetPropertiesSucceed() { | |
144 const bool check_error_state = false; | |
145 NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork( | |
146 network_.service_path, | |
147 base::Bind(&PasswordView::OnConnectionSucceed, weak_ptr_.GetWeakPtr()), | |
148 base::Bind(&PasswordView::OnKnownError, weak_ptr_.GetWeakPtr()), | |
149 check_error_state); | |
150 } | |
151 | |
152 void OnConnectionSucceed() { CloseDialog(true); } | |
153 | |
154 // views::View: | |
155 virtual void ViewHierarchyChanged( | |
156 const views::View::ViewHierarchyChangedDetails& details) override { | |
157 if (details.is_add && details.child == this) | |
158 textfield_->RequestFocus(); | |
159 } | |
160 | |
161 // views::ButtonListener: | |
162 virtual void ButtonPressed(views::Button* sender, | |
163 const ui::Event& event) override { | |
164 if (sender == connect_) { | |
165 if (error_msg_) { | |
166 RemoveChildView(error_msg_); | |
167 delete error_msg_; | |
168 error_msg_ = nullptr; | |
169 } | |
170 connect_->SetEnabled(false); | |
171 NetworkHandler::Get()->network_configuration_handler()->SetNetworkProfile( | |
172 network_.service_path, | |
173 NetworkProfileHandler::GetSharedProfilePath(), | |
174 NetworkConfigurationObserver::SOURCE_USER_ACTION, | |
175 base::Bind(&PasswordView::OnSetProfileSucceed, | |
176 weak_ptr_.GetWeakPtr(), | |
177 textfield_->text()), | |
178 base::Bind(&PasswordView::OnKnownError, weak_ptr_.GetWeakPtr())); | |
179 } else if (sender == cancel_) { | |
180 CloseDialog(false); | |
181 } else { | |
182 NOTREACHED(); | |
183 } | |
184 } | |
185 | |
186 ui::NetworkInfo network_; | |
187 base::Callback<void(bool)> callback_; | |
188 | |
189 views::BlueButton* connect_; | |
190 views::LabelButton* cancel_; | |
191 views::Textfield* textfield_; | |
192 views::Label* error_msg_; | |
193 base::WeakPtrFactory<PasswordView> weak_ptr_; | |
194 | |
195 DISALLOW_COPY_AND_ASSIGN(PasswordView); | |
196 }; | |
197 | |
198 // A View that represents a single row in the network list. This row also | |
199 // contains the View for taking password for password-protected networks. | |
200 class NetworkRow : public views::View { | |
201 public: | |
202 NetworkRow(const ui::NetworkInfo& network) | |
203 : network_(network), weak_ptr_(this) { | |
204 SetBorder(views::Border::CreateEmptyBorder(10, 5, 10, 5)); | |
205 SetLayoutManager( | |
206 new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 10)); | |
207 Update(network); | |
208 } | |
209 | |
210 ~NetworkRow() override {} | |
211 | |
212 void Update(const ui::NetworkInfo& network) { | |
213 network_ = network; | |
214 views::ImageView* icon = new views::ImageView(); | |
215 icon->SetImage(network.image); | |
216 icon->SetBounds(0, 0, network.image.width(), network.image.height()); | |
217 | |
218 views::Label* label = new views::Label(network.label); | |
219 if (network.highlight) | |
220 label->SetFontList(label->font_list().Derive(0, gfx::Font::BOLD)); | |
221 AddChildView(icon); | |
222 AddChildView(label); | |
223 if (password_view_) | |
224 AddChildView(password_view_.get()); | |
225 } | |
226 | |
227 bool has_password_view() const { return password_view_; } | |
228 | |
229 private: | |
230 void OnPasswordComplete(bool successful) { | |
231 password_view_.reset(); | |
232 InvalidateLayout(); | |
233 GetWidget()->GetRootView()->Layout(); | |
234 ScrollRectToVisible(GetContentsBounds()); | |
235 } | |
236 | |
237 void ShowPasswordView(const std::string& service_path) { | |
238 const NetworkState* network = | |
239 NetworkHandler::Get()->network_state_handler()->GetNetworkState( | |
240 service_path); | |
241 if (!network) | |
242 return; | |
243 | |
244 // If this is not a wifi network that needs a password, then ignore. | |
245 if (network->type() != shill::kTypeWifi || | |
246 network->security_class() == shill::kSecurityNone) { | |
247 return; | |
248 } | |
249 | |
250 password_view_.reset(new PasswordView( | |
251 network_, | |
252 base::Bind(&NetworkRow::OnPasswordComplete, weak_ptr_.GetWeakPtr()))); | |
253 password_view_->set_owned_by_client(); | |
254 AddChildView(password_view_.get()); | |
255 PreferredSizeChanged(); | |
256 GetWidget()->GetRootView()->Layout(); | |
257 ScrollRectToVisible(password_view_->bounds()); | |
258 } | |
259 | |
260 void OnNetworkConnectionError(const std::string& service_path, | |
261 const std::string& error_name, | |
262 scoped_ptr<base::DictionaryValue> error_data) { | |
263 if (error_name == NetworkConnectionHandler::kErrorConnectCanceled) | |
264 return; | |
265 if (error_name == shill::kErrorBadPassphrase || | |
266 error_name == NetworkConnectionHandler::kErrorPassphraseRequired || | |
267 error_name == NetworkConnectionHandler::kErrorConfigurationRequired || | |
268 error_name == NetworkConnectionHandler::kErrorAuthenticationRequired) { | |
269 ShowPasswordView(service_path); | |
270 } | |
271 } | |
272 | |
273 void ActivateNetwork() { | |
274 const chromeos::NetworkState* network = | |
275 NetworkHandler::Get()->network_state_handler()->GetNetworkState( | |
276 network_.service_path); | |
277 if (!network) | |
278 return; | |
279 if (network->IsConnectedState()) { | |
280 NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork( | |
281 network_.service_path, | |
282 base::Closure(), | |
283 chromeos::network_handler::ErrorCallback()); | |
284 } else if (!network->IsConnectingState()) { | |
285 // |network| is not connected, and not already trying to connect. | |
286 NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork( | |
287 network_.service_path, | |
288 base::Closure(), | |
289 base::Bind(&NetworkRow::OnNetworkConnectionError, | |
290 weak_ptr_.GetWeakPtr(), | |
291 network_.service_path), | |
292 false); | |
293 } | |
294 } | |
295 | |
296 // views::View: | |
297 virtual void OnMouseEvent(ui::MouseEvent* event) override { | |
298 if (event->type() != ui::ET_MOUSE_PRESSED) | |
299 return; | |
300 ActivateNetwork(); | |
301 event->SetHandled(); | |
302 } | |
303 | |
304 virtual void OnGestureEvent(ui::GestureEvent* gesture) override { | |
305 if (gesture->type() != ui::ET_GESTURE_TAP) | |
306 return; | |
307 ActivateNetwork(); | |
308 gesture->SetHandled(); | |
309 } | |
310 | |
311 ui::NetworkInfo network_; | |
312 scoped_ptr<views::View> password_view_; | |
313 base::WeakPtrFactory<NetworkRow> weak_ptr_; | |
314 | |
315 DISALLOW_COPY_AND_ASSIGN(NetworkRow); | |
316 }; | |
317 | |
318 class NetworkSelector : public ui::NetworkListDelegate, | |
319 public chromeos::NetworkStateHandlerObserver, | |
320 public views::DialogDelegate { | |
321 public: | |
322 NetworkSelector() | |
323 : scroll_content_(nullptr), scroller_(nullptr), network_list_(this) { | |
324 CreateNetworkList(); | |
325 CreateWidget(); | |
326 | |
327 NetworkHandler::Get()->network_state_handler()->RequestScan(); | |
328 NetworkHandler::Get()->network_state_handler()->AddObserver(this, | |
329 FROM_HERE); | |
330 } | |
331 | |
332 ~NetworkSelector() override { | |
333 NetworkHandler::Get()->network_state_handler()->RemoveObserver(this, | |
334 FROM_HERE); | |
335 } | |
336 | |
337 private: | |
338 void CreateWidget() { | |
339 // Same as CreateDialogWidgetWithBounds() with an empty |bounds|. | |
340 views::Widget* widget = views::DialogDelegate::CreateDialogWidget( | |
341 this, athena::ScreenManager::Get()->GetContext(), nullptr); | |
342 widget->Show(); | |
343 widget->CenterWindow(gfx::Size(400, 400)); | |
344 } | |
345 | |
346 void CreateNetworkList() { | |
347 const int kListHeight = 400; | |
348 scroller_ = new views::ScrollView(); | |
349 scroller_->set_background( | |
350 views::Background::CreateSolidBackground(SK_ColorWHITE)); | |
351 | |
352 scroll_content_ = new views::View; | |
353 scroll_content_->SetLayoutManager( | |
354 new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0)); | |
355 scroller_->SetContents(scroll_content_); | |
356 | |
357 scroller_->ClipHeightTo(kListHeight, kListHeight); | |
358 scroller_->SetVerticalScrollBar(new views::OverlayScrollBar(false)); | |
359 | |
360 network_list_.set_content_view(scroll_content_); | |
361 } | |
362 | |
363 void UpdateNetworkList() { network_list_.UpdateNetworkList(); } | |
364 | |
365 // ui::NetworkListDelegate: | |
366 virtual views::View* CreateViewForNetwork( | |
367 const ui::NetworkInfo& info) override { | |
368 return new NetworkRow(info); | |
369 } | |
370 | |
371 virtual bool IsViewHovered(views::View* view) override { | |
372 return static_cast<NetworkRow*>(view)->has_password_view(); | |
373 } | |
374 | |
375 virtual chromeos::NetworkTypePattern GetNetworkTypePattern() const override { | |
376 return chromeos::NetworkTypePattern::NonVirtual(); | |
377 } | |
378 | |
379 virtual void UpdateViewForNetwork(views::View* view, | |
380 const ui::NetworkInfo& info) override { | |
381 static_cast<NetworkRow*>(view)->Update(info); | |
382 } | |
383 | |
384 virtual views::Label* CreateInfoLabel() override { | |
385 views::Label* label = new views::Label(); | |
386 return label; | |
387 } | |
388 | |
389 virtual void RelayoutScrollList() override { scroller_->Layout(); } | |
390 | |
391 // chromeos::NetworkStateHandlerObserver: | |
392 virtual void NetworkListChanged() override { UpdateNetworkList(); } | |
393 | |
394 virtual void DeviceListChanged() override {} | |
395 | |
396 virtual void DefaultNetworkChanged( | |
397 const chromeos::NetworkState* network) override {} | |
398 | |
399 virtual void NetworkConnectionStateChanged( | |
400 const chromeos::NetworkState* network) override {} | |
401 | |
402 virtual void NetworkPropertiesUpdated( | |
403 const chromeos::NetworkState* network) override {} | |
404 | |
405 // views::DialogDelegate: | |
406 virtual ui::ModalType GetModalType() const override { | |
407 return ui::MODAL_TYPE_SYSTEM; | |
408 } | |
409 virtual void DeleteDelegate() override { delete this; } | |
410 virtual views::Widget* GetWidget() override { return scroller_->GetWidget(); } | |
411 virtual const views::Widget* GetWidget() const override { | |
412 return scroller_->GetWidget(); | |
413 } | |
414 virtual views::View* GetContentsView() override { return scroller_; } | |
415 virtual int GetDialogButtons() const override { return ui::DIALOG_BUTTON_OK; } | |
416 virtual bool Close() override { return true; } | |
417 | |
418 views::View* scroll_content_; | |
419 views::ScrollView* scroller_; | |
420 | |
421 views::View* connect_; | |
422 | |
423 ui::NetworkListView network_list_; | |
424 | |
425 DISALLOW_COPY_AND_ASSIGN(NetworkSelector); | |
426 }; | |
427 | |
428 } // namespace | |
429 | |
430 namespace athena { | |
431 | |
432 void CreateNetworkSelector() { | |
433 new NetworkSelector(); | |
434 } | |
435 | |
436 } // namespace athena | |
OLD | NEW |