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 "base/memory/weak_ptr.h"
8 #include "base/strings/utf_string_conversions.h"
9 #include "chromeos/network/network_configuration_handler.h"
10 #include "chromeos/network/network_connection_handler.h"
11 #include "chromeos/network/network_handler.h"
12 #include "chromeos/network/network_profile_handler.h"
13 #include "chromeos/network/network_state.h"
14 #include "chromeos/network/network_state_handler.h"
15 #include "chromeos/network/network_state_handler_observer.h"
16 #include "chromeos/network/network_type_pattern.h"
17 #include "third_party/cros_system_api/dbus/service_constants.h"
18 #include "ui/aura/window.h"
19 #include "ui/chromeos/network/network_icon.h"
20 #include "ui/chromeos/network/network_info.h"
21 #include "ui/chromeos/network/network_list.h"
22 #include "ui/chromeos/network/network_list_delegate.h"
23 #include "ui/compositor/layer.h"
24 #include "ui/gfx/canvas.h"
25 #include "ui/gfx/font.h"
26 #include "ui/gfx/font_list.h"
27 #include "ui/gfx/geometry/rect.h"
28 #include "ui/gfx/text_constants.h"
29 #include "ui/views/background.h"
30 #include "ui/views/border.h"
31 #include "ui/views/controls/button/blue_button.h"
32 #include "ui/views/controls/button/button.h"
33 #include "ui/views/controls/image_view.h"
34 #include "ui/views/controls/label.h"
35 #include "ui/views/controls/scroll_view.h"
36 #include "ui/views/controls/scrollbar/overlay_scroll_bar.h"
37 #include "ui/views/controls/textfield/textfield.h"
38 #include "ui/views/layout/box_layout.h"
39 #include "ui/views/layout/fill_layout.h"
40 #include "ui/views/widget/widget.h"
41
42 using chromeos::NetworkConfigurationHandler;
43 using chromeos::NetworkConnectionHandler;
44 using chromeos::NetworkHandler;
45 using chromeos::NetworkProfileHandler;
46 using chromeos::NetworkState;
47
48 namespace {
49
50 const int kBackgroundColor = SkColorSetARGB(0x7f, 0, 0, 0);
51
52 // The View for the user to enter the password for connceting to a network. This
53 // view also shows an error message if the network connection fails.
54 class PasswordView : public views::View, public views::ButtonListener {
55 public:
PasswordView(const ui::NetworkInfo & network,const base::Callback<void (bool)> & callback,views::View * parent_container)56 PasswordView(const ui::NetworkInfo& network,
57 const base::Callback<void(bool)>& callback,
58 views::View* parent_container)
59 : network_(network),
60 callback_(callback),
61 parent_container_(parent_container),
62 connect_(NULL),
63 cancel_(NULL),
64 textfield_(NULL),
65 error_msg_(NULL),
66 weak_ptr_(this) {
67 const int kHorizontal = 5;
68 const int kVertical = 0;
69 const int kPadding = 0;
70
71 views::BoxLayout* layout = new views::BoxLayout(
72 views::BoxLayout::kVertical, kHorizontal, kVertical, kPadding);
73 layout->set_main_axis_alignment(
74 views::BoxLayout::MAIN_AXIS_ALIGNMENT_START);
75 layout->set_cross_axis_alignment(
76 views::BoxLayout::CROSS_AXIS_ALIGNMENT_STRETCH);
77 SetLayoutManager(layout);
78
79 views::View* container = new views::View;
80 layout = new views::BoxLayout(
81 views::BoxLayout::kHorizontal, kHorizontal, kVertical, kPadding);
82 layout->set_main_axis_alignment(
83 views::BoxLayout::MAIN_AXIS_ALIGNMENT_START);
84 container->SetLayoutManager(layout);
85
86 textfield_ = new views::Textfield();
87 textfield_->set_placeholder_text(base::ASCIIToUTF16("Password"));
88 textfield_->SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
89 textfield_->set_default_width_in_chars(35);
90 container->AddChildView(textfield_);
91
92 connect_ = new views::BlueButton(this, base::ASCIIToUTF16("Connect"));
93 container->AddChildView(connect_);
94
95 cancel_ = new views::LabelButton(this, base::ASCIIToUTF16("Cancel"));
96 cancel_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
97 container->AddChildView(cancel_);
98
99 AddChildView(container);
100 }
101
~PasswordView()102 virtual ~PasswordView() {}
103
104 private:
Close(bool successful)105 void Close(bool successful) { callback_.Run(successful); }
106
OnKnownError(const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)107 void OnKnownError(const std::string& error_name,
108 scoped_ptr<base::DictionaryValue> error_data) {
109 std::string message;
110 if (!error_data->GetString(chromeos::network_handler::kDbusErrorMessage,
111 &message))
112 message = error_name;
113 if (message.empty())
114 message = std::string("Unknown error.");
115 if (!error_msg_) {
116 error_msg_ = new views::Label();
117 error_msg_->SetFontList(
118 error_msg_->font_list().Derive(0, gfx::Font::BOLD));
119 error_msg_->SetEnabledColor(SK_ColorRED);
120 }
121 error_msg_->SetText(base::UTF8ToUTF16(message));
122 if (!error_msg_->parent()) {
123 AddChildView(error_msg_);
124 InvalidateLayout();
125 parent_container_->Layout();
126 ScrollRectToVisible(error_msg_->bounds());
127 }
128 connect_->SetEnabled(true);
129 }
130
OnSetProfileSucceed(const base::string16 & password)131 void OnSetProfileSucceed(const base::string16& password) {
132 base::DictionaryValue properties;
133 properties.SetStringWithoutPathExpansion(shill::kPassphraseProperty,
134 textfield_->text());
135 NetworkHandler::Get()->network_configuration_handler()->SetProperties(
136 network_.service_path,
137 properties,
138 base::Bind(&PasswordView::OnSetPropertiesSucceed,
139 weak_ptr_.GetWeakPtr()),
140 base::Bind(&PasswordView::OnKnownError, weak_ptr_.GetWeakPtr()));
141 }
142
OnSetPropertiesSucceed()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
OnConnectionSucceed()152 void OnConnectionSucceed() { Close(true); }
153
154 // views::View:
ViewHierarchyChanged(const views::View::ViewHierarchyChangedDetails & details)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:
ButtonPressed(views::Button * sender,const ui::Event & event)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_ = NULL;
169 }
170 connect_->SetEnabled(false);
171 NetworkHandler::Get()->network_configuration_handler()->SetNetworkProfile(
172 network_.service_path,
173 NetworkProfileHandler::GetSharedProfilePath(),
174 base::Bind(&PasswordView::OnSetProfileSucceed,
175 weak_ptr_.GetWeakPtr(),
176 textfield_->text()),
177 base::Bind(&PasswordView::OnKnownError, weak_ptr_.GetWeakPtr()));
178 } else if (sender == cancel_) {
179 Close(false);
180 } else {
181 NOTREACHED();
182 }
183 }
184
185 ui::NetworkInfo network_;
186 base::Callback<void(bool)> callback_;
187 views::View* parent_container_;
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:
NetworkRow(const ui::NetworkInfo & network,views::View * container)202 NetworkRow(const ui::NetworkInfo& network, views::View* container)
203 : network_(network), container_(container), 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
~NetworkRow()210 virtual ~NetworkRow() {}
211
Update(const ui::NetworkInfo & network)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
has_password_view() const227 bool has_password_view() const { return password_view_; }
228
229 private:
OnPasswordComplete(bool successful)230 void OnPasswordComplete(bool successful) {
231 password_view_.reset();
232 InvalidateLayout();
233 container_->Layout();
234 ScrollRectToVisible(GetContentsBounds());
235 }
236
ShowPasswordView(const std::string & service_path)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() == shill::kSecurityNone) {
247 return;
248 }
249
250 password_view_.reset(new PasswordView(
251 network_,
252 base::Bind(&NetworkRow::OnPasswordComplete, weak_ptr_.GetWeakPtr()),
253 container_));
254 password_view_->set_owned_by_client();
255 AddChildView(password_view_.get());
256 PreferredSizeChanged();
257 container_->Layout();
258 ScrollRectToVisible(password_view_->bounds());
259 }
260
OnNetworkConnectionError(const std::string & service_path,const std::string & error_name,scoped_ptr<base::DictionaryValue> error_data)261 void OnNetworkConnectionError(const std::string& service_path,
262 const std::string& error_name,
263 scoped_ptr<base::DictionaryValue> error_data) {
264 if (error_name == NetworkConnectionHandler::kErrorConnectCanceled)
265 return;
266 if (error_name == shill::kErrorBadPassphrase ||
267 error_name == NetworkConnectionHandler::kErrorPassphraseRequired ||
268 error_name == NetworkConnectionHandler::kErrorConfigurationRequired ||
269 error_name == NetworkConnectionHandler::kErrorAuthenticationRequired) {
270 ShowPasswordView(service_path);
271 }
272 }
273
ActivateNetwork()274 void ActivateNetwork() {
275 const chromeos::NetworkState* network =
276 NetworkHandler::Get()->network_state_handler()->GetNetworkState(
277 network_.service_path);
278 if (!network)
279 return;
280 if (network->IsConnectedState()) {
281 NetworkHandler::Get()->network_connection_handler()->DisconnectNetwork(
282 network_.service_path,
283 base::Closure(),
284 chromeos::network_handler::ErrorCallback());
285 } else if (!network->IsConnectingState()) {
286 // |network| is not connected, and not already trying to connect.
287 NetworkHandler::Get()->network_connection_handler()->ConnectToNetwork(
288 network_.service_path,
289 base::Closure(),
290 base::Bind(&NetworkRow::OnNetworkConnectionError,
291 weak_ptr_.GetWeakPtr(),
292 network_.service_path),
293 false);
294 }
295 }
296
297 // views::View:
OnMouseEvent(ui::MouseEvent * event)298 virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
299 if (event->type() != ui::ET_MOUSE_PRESSED)
300 return;
301 ActivateNetwork();
302 event->SetHandled();
303 }
304
OnGestureEvent(ui::GestureEvent * gesture)305 virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
306 if (gesture->type() != ui::ET_GESTURE_TAP)
307 return;
308 ActivateNetwork();
309 gesture->SetHandled();
310 }
311
312 ui::NetworkInfo network_;
313 views::View* container_;
314 scoped_ptr<views::View> password_view_;
315 base::WeakPtrFactory<NetworkRow> weak_ptr_;
316
317 DISALLOW_COPY_AND_ASSIGN(NetworkRow);
318 };
319
320 class NetworkSelector : public ui::NetworkListDelegate,
321 public chromeos::NetworkStateHandlerObserver,
322 public ui::EventHandler {
323 public:
NetworkSelector(aura::Window * container)324 explicit NetworkSelector(aura::Window* container)
325 : background_view_(NULL),
326 scroll_content_(NULL),
327 scroller_(NULL),
328 network_list_(this) {
329 CreateWidget(container);
330 CreateNetworkList();
331
332 NetworkHandler::Get()->network_state_handler()->RequestScan();
333 NetworkHandler::Get()->network_state_handler()->AddObserver(this,
334 FROM_HERE);
335 }
336
~NetworkSelector()337 virtual ~NetworkSelector() {
338 NetworkHandler::Get()->network_state_handler()->RemoveObserver(this,
339 FROM_HERE);
340 }
341
342 private:
CreateWidget(aura::Window * container)343 void CreateWidget(aura::Window* container) {
344 views::Widget::InitParams params;
345 params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
346 params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
347 params.activatable = views::Widget::InitParams::ACTIVATABLE_DEFAULT;
348 params.accept_events = true;
349 params.bounds = gfx::Rect(container->bounds().size());
350 params.parent = container;
351 params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
352 widget_.reset(new views::Widget());
353 widget_->Init(params);
354 widget_->Show();
355
356 background_view_ = new views::View;
357 background_view_->set_background(
358 views::Background::CreateSolidBackground(kBackgroundColor));
359 background_view_->SetBorder(
360 views::Border::CreateEmptyBorder(100, 300, 300, 300));
361 background_view_->SetLayoutManager(new views::FillLayout());
362 background_view_->set_target_handler(this);
363
364 widget_->SetContentsView(background_view_);
365 }
366
CreateNetworkList()367 void CreateNetworkList() {
368 const int kListHeight = 500;
369 scroller_ = new views::ScrollView();
370 scroller_->set_background(
371 views::Background::CreateSolidBackground(SK_ColorWHITE));
372 scroller_->SetBounds(0, 0, 400, kListHeight);
373
374 scroll_content_ = new views::View;
375 scroll_content_->SetLayoutManager(
376 new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
377 scroller_->SetContents(scroll_content_);
378
379 scroller_->ClipHeightTo(kListHeight, kListHeight);
380 scroller_->SetVerticalScrollBar(new views::OverlayScrollBar(false));
381 background_view_->AddChildView(scroller_);
382
383 background_view_->Layout();
384
385 network_list_.set_content_view(scroll_content_);
386 }
387
UpdateNetworkList()388 void UpdateNetworkList() { network_list_.UpdateNetworkList(); }
389
Close()390 void Close() { delete this; }
391
392 // ui::NetworkListDelegate:
CreateViewForNetwork(const ui::NetworkInfo & info)393 virtual views::View* CreateViewForNetwork(
394 const ui::NetworkInfo& info) OVERRIDE {
395 return new NetworkRow(info, background_view_);
396 }
397
IsViewHovered(views::View * view)398 virtual bool IsViewHovered(views::View* view) OVERRIDE {
399 return static_cast<NetworkRow*>(view)->has_password_view();
400 }
401
GetNetworkTypePattern() const402 virtual chromeos::NetworkTypePattern GetNetworkTypePattern() const OVERRIDE {
403 return chromeos::NetworkTypePattern::NonVirtual();
404 }
405
UpdateViewForNetwork(views::View * view,const ui::NetworkInfo & info)406 virtual void UpdateViewForNetwork(views::View* view,
407 const ui::NetworkInfo& info) OVERRIDE {
408 static_cast<NetworkRow*>(view)->Update(info);
409 }
410
CreateInfoLabel()411 virtual views::Label* CreateInfoLabel() OVERRIDE {
412 views::Label* label = new views::Label();
413 return label;
414 }
415
RelayoutScrollList()416 virtual void RelayoutScrollList() OVERRIDE { scroller_->Layout(); }
417
418 // chromeos::NetworkStateHandlerObserver:
NetworkListChanged()419 virtual void NetworkListChanged() OVERRIDE { UpdateNetworkList(); }
420
DeviceListChanged()421 virtual void DeviceListChanged() OVERRIDE {}
422
DefaultNetworkChanged(const chromeos::NetworkState * network)423 virtual void DefaultNetworkChanged(
424 const chromeos::NetworkState* network) OVERRIDE {}
425
NetworkConnectionStateChanged(const chromeos::NetworkState * network)426 virtual void NetworkConnectionStateChanged(
427 const chromeos::NetworkState* network) OVERRIDE {}
428
NetworkPropertiesUpdated(const chromeos::NetworkState * network)429 virtual void NetworkPropertiesUpdated(
430 const chromeos::NetworkState* network) OVERRIDE {}
431
432 // ui::EventHandler:
OnMouseEvent(ui::MouseEvent * mouse)433 virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
434 CHECK_EQ(background_view_, mouse->target());
435 if (mouse->type() == ui::ET_MOUSE_PRESSED && !mouse->handled()) {
436 Close();
437 mouse->SetHandled();
438 }
439 }
440
OnGestureEvent(ui::GestureEvent * gesture)441 virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
442 CHECK_EQ(background_view_, gesture->target());
443 if (gesture->type() == ui::ET_GESTURE_TAP && !gesture->handled()) {
444 Close();
445 gesture->SetHandled();
446 }
447 }
448
449 scoped_ptr<views::Widget> widget_;
450 views::View* background_view_;
451 views::View* scroll_content_;
452 views::ScrollView* scroller_;
453
454 views::View* connect_;
455
456 ui::NetworkListView network_list_;
457
458 DISALLOW_COPY_AND_ASSIGN(NetworkSelector);
459 };
460
461 } // namespace
462
463 namespace athena {
464
CreateNetworkSelector(aura::Window * container)465 void CreateNetworkSelector(aura::Window* container) {
466 new NetworkSelector(container);
467 }
468
469 } // namespace athena
470