athena/system/network_selector.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 "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