| OLD | NEW |
|---|
| (Empty) |
| 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 "ui/chromeos/network/network_state_notifier.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/location.h" | |
| 9 #include "base/strings/string16.h" | |
| 10 #include "base/strings/string_util.h" | |
| 11 #include "base/strings/utf_string_conversions.h" | |
| 12 #include "chromeos/network/network_configuration_handler.h" | |
| 13 #include "chromeos/network/network_connection_handler.h" | |
| 14 #include "chromeos/network/network_event_log.h" | |
| 15 #include "chromeos/network/network_state.h" | |
| 16 #include "chromeos/network/network_state_handler.h" | |
| 17 #include "chromeos/network/shill_property_util.h" | |
| 18 #include "third_party/cros_system_api/dbus/service_constants.h" | |
| 19 #include "ui/base/l10n/l10n_util.h" | |
| 20 #include "ui/base/resource/resource_bundle.h" | |
| 21 #include "ui/chromeos/network/network_connect.h" | |
| 22 #include "ui/chromeos/resources/grit/ui_chromeos_resources.h" | |
| 23 #include "ui/chromeos/strings/grit/ui_chromeos_strings.h" | |
| 24 #include "ui/message_center/message_center.h" | |
| 25 #include "ui/message_center/notification.h" | |
| 26 | |
| 27 using chromeos::NetworkConnectionHandler; | |
| 28 using chromeos::NetworkHandler; | |
| 29 using chromeos::NetworkState; | |
| 30 using chromeos::NetworkStateHandler; | |
| 31 using chromeos::NetworkTypePattern; | |
| 32 | |
| 33 namespace { | |
| 34 | |
| 35 const int kMinTimeBetweenOutOfCreditsNotifySeconds = 10 * 60; | |
| 36 | |
| 37 // Ignore in-progress error. | |
| 38 bool ShillErrorIsIgnored(const std::string& shill_error) { | |
| 39 if (shill_error == shill::kErrorResultInProgress) | |
| 40 return true; | |
| 41 return false; | |
| 42 } | |
| 43 | |
| 44 // Error messages based on |error_name|, not network_state->error(). | |
| 45 base::string16 GetConnectErrorString(const std::string& error_name) { | |
| 46 if (error_name == NetworkConnectionHandler::kErrorNotFound) | |
| 47 return l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_CONNECT_FAILED); | |
| 48 if (error_name == NetworkConnectionHandler::kErrorConfigureFailed) { | |
| 49 return l10n_util::GetStringUTF16( | |
| 50 IDS_CHROMEOS_NETWORK_ERROR_CONFIGURE_FAILED); | |
| 51 } | |
| 52 if (error_name == NetworkConnectionHandler::kErrorCertLoadTimeout) { | |
| 53 return l10n_util::GetStringUTF16( | |
| 54 IDS_CHROMEOS_NETWORK_ERROR_CERTIFICATES_NOT_LOADED); | |
| 55 } | |
| 56 if (error_name == ui::NetworkConnect::kErrorActivateFailed) { | |
| 57 return l10n_util::GetStringUTF16( | |
| 58 IDS_CHROMEOS_NETWORK_ERROR_ACTIVATION_FAILED); | |
| 59 } | |
| 60 return base::string16(); | |
| 61 } | |
| 62 | |
| 63 void ShowErrorNotification(const std::string& notification_id, | |
| 64 const std::string& network_type, | |
| 65 const base::string16& title, | |
| 66 const base::string16& message, | |
| 67 const base::Closure& callback) { | |
| 68 int icon_id = (network_type == shill::kTypeCellular) | |
| 69 ? IDR_AURA_UBER_TRAY_NETWORK_FAILED_CELLULAR | |
| 70 : IDR_AURA_UBER_TRAY_NETWORK_FAILED; | |
| 71 const gfx::Image& icon = | |
| 72 ui::ResourceBundle::GetSharedInstance().GetImageNamed(icon_id); | |
| 73 message_center::MessageCenter::Get()->AddNotification( | |
| 74 message_center::Notification::CreateSystemNotification( | |
| 75 notification_id, title, message, icon, | |
| 76 ui::NetworkStateNotifier::kNotifierNetworkError, callback)); | |
| 77 } | |
| 78 | |
| 79 } // namespace | |
| 80 | |
| 81 namespace ui { | |
| 82 | |
| 83 const char NetworkStateNotifier::kNotifierNetwork[] = "ui.chromeos.network"; | |
| 84 const char NetworkStateNotifier::kNotifierNetworkError[] = | |
| 85 "ui.chromeos.network.error"; | |
| 86 | |
| 87 const char NetworkStateNotifier::kNetworkConnectNotificationId[] = | |
| 88 "chrome://settings/internet/connect"; | |
| 89 const char NetworkStateNotifier::kNetworkActivateNotificationId[] = | |
| 90 "chrome://settings/internet/activate"; | |
| 91 const char NetworkStateNotifier::kNetworkOutOfCreditsNotificationId[] = | |
| 92 "chrome://settings/internet/out-of-credits"; | |
| 93 | |
| 94 NetworkStateNotifier::NetworkStateNotifier(NetworkConnect* network_connect) | |
| 95 : network_connect_(network_connect), | |
| 96 did_show_out_of_credits_(false), | |
| 97 weak_ptr_factory_(this) { | |
| 98 if (!NetworkHandler::IsInitialized()) | |
| 99 return; | |
| 100 NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler(); | |
| 101 handler->AddObserver(this, FROM_HERE); | |
| 102 UpdateDefaultNetwork(handler->DefaultNetwork()); | |
| 103 } | |
| 104 | |
| 105 NetworkStateNotifier::~NetworkStateNotifier() { | |
| 106 if (!NetworkHandler::IsInitialized()) | |
| 107 return; | |
| 108 NetworkHandler::Get()->network_state_handler()->RemoveObserver(this, | |
| 109 FROM_HERE); | |
| 110 } | |
| 111 | |
| 112 void NetworkStateNotifier::DefaultNetworkChanged(const NetworkState* network) { | |
| 113 if (!UpdateDefaultNetwork(network)) | |
| 114 return; | |
| 115 // If the default network changes to another network, allow the out of | |
| 116 // credits notification to be shown again. A delay prevents the notification | |
| 117 // from being shown too frequently (see below). | |
| 118 if (network) | |
| 119 did_show_out_of_credits_ = false; | |
| 120 } | |
| 121 | |
| 122 void NetworkStateNotifier::NetworkPropertiesUpdated( | |
| 123 const NetworkState* network) { | |
| 124 if (network->type() != shill::kTypeCellular) | |
| 125 return; | |
| 126 UpdateCellularOutOfCredits(network); | |
| 127 UpdateCellularActivating(network); | |
| 128 } | |
| 129 | |
| 130 bool NetworkStateNotifier::UpdateDefaultNetwork(const NetworkState* network) { | |
| 131 std::string default_network_path; | |
| 132 if (network) | |
| 133 default_network_path = network->path(); | |
| 134 if (default_network_path != last_default_network_) { | |
| 135 last_default_network_ = default_network_path; | |
| 136 return true; | |
| 137 } | |
| 138 return false; | |
| 139 } | |
| 140 | |
| 141 void NetworkStateNotifier::UpdateCellularOutOfCredits( | |
| 142 const NetworkState* cellular) { | |
| 143 // Only display a notification if we are out of credits and have not already | |
| 144 // shown a notification (or have since connected to another network type). | |
| 145 if (!cellular->cellular_out_of_credits() || did_show_out_of_credits_) | |
| 146 return; | |
| 147 | |
| 148 // Only display a notification if not connected, connecting, or waiting to | |
| 149 // connect to another network. | |
| 150 NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler(); | |
| 151 const NetworkState* default_network = handler->DefaultNetwork(); | |
| 152 if (default_network && default_network != cellular) | |
| 153 return; | |
| 154 if (handler->ConnectingNetworkByType(NetworkTypePattern::NonVirtual()) || | |
| 155 NetworkHandler::Get() | |
| 156 ->network_connection_handler() | |
| 157 ->HasPendingConnectRequest()) | |
| 158 return; | |
| 159 | |
| 160 did_show_out_of_credits_ = true; | |
| 161 base::TimeDelta dtime = base::Time::Now() - out_of_credits_notify_time_; | |
| 162 if (dtime.InSeconds() > kMinTimeBetweenOutOfCreditsNotifySeconds) { | |
| 163 out_of_credits_notify_time_ = base::Time::Now(); | |
| 164 base::string16 error_msg = l10n_util::GetStringFUTF16( | |
| 165 IDS_NETWORK_OUT_OF_CREDITS_BODY, base::UTF8ToUTF16(cellular->name())); | |
| 166 ShowErrorNotification( | |
| 167 kNetworkOutOfCreditsNotificationId, cellular->type(), | |
| 168 l10n_util::GetStringUTF16(IDS_NETWORK_OUT_OF_CREDITS_TITLE), error_msg, | |
| 169 base::Bind(&NetworkStateNotifier::ShowNetworkSettings, | |
| 170 weak_ptr_factory_.GetWeakPtr(), cellular->path())); | |
| 171 } | |
| 172 } | |
| 173 | |
| 174 void NetworkStateNotifier::UpdateCellularActivating( | |
| 175 const NetworkState* cellular) { | |
| 176 // Keep track of any activating cellular network. | |
| 177 std::string activation_state = cellular->activation_state(); | |
| 178 if (activation_state == shill::kActivationStateActivating) { | |
| 179 cellular_activating_.insert(cellular->path()); | |
| 180 return; | |
| 181 } | |
| 182 // Only display a notification if this network was activating and is now | |
| 183 // activated. | |
| 184 if (!cellular_activating_.count(cellular->path()) || | |
| 185 activation_state != shill::kActivationStateActivated) | |
| 186 return; | |
| 187 | |
| 188 cellular_activating_.erase(cellular->path()); | |
| 189 int icon_id; | |
| 190 if (cellular->network_technology() == shill::kNetworkTechnologyLte) | |
| 191 icon_id = IDR_AURA_UBER_TRAY_NOTIFICATION_LTE; | |
| 192 else | |
| 193 icon_id = IDR_AURA_UBER_TRAY_NOTIFICATION_3G; | |
| 194 const gfx::Image& icon = | |
| 195 ui::ResourceBundle::GetSharedInstance().GetImageNamed(icon_id); | |
| 196 message_center::MessageCenter::Get()->AddNotification( | |
| 197 message_center::Notification::CreateSystemNotification( | |
| 198 kNetworkActivateNotificationId, | |
| 199 l10n_util::GetStringUTF16(IDS_NETWORK_CELLULAR_ACTIVATED_TITLE), | |
| 200 l10n_util::GetStringFUTF16(IDS_NETWORK_CELLULAR_ACTIVATED, | |
| 201 base::UTF8ToUTF16((cellular->name()))), | |
| 202 icon, kNotifierNetwork, | |
| 203 base::Bind(&NetworkStateNotifier::ShowNetworkSettings, | |
| 204 weak_ptr_factory_.GetWeakPtr(), cellular->path()))); | |
| 205 } | |
| 206 | |
| 207 void NetworkStateNotifier::ShowNetworkConnectError( | |
| 208 const std::string& error_name, | |
| 209 const std::string& service_path) { | |
| 210 if (service_path.empty()) { | |
| 211 base::DictionaryValue shill_properties; | |
| 212 ShowConnectErrorNotification(error_name, service_path, shill_properties); | |
| 213 return; | |
| 214 } | |
| 215 // Get the up-to-date properties for the network and display the error. | |
| 216 NetworkHandler::Get()->network_configuration_handler()->GetProperties( | |
| 217 service_path, | |
| 218 base::Bind(&NetworkStateNotifier::ConnectErrorPropertiesSucceeded, | |
| 219 weak_ptr_factory_.GetWeakPtr(), error_name), | |
| 220 base::Bind(&NetworkStateNotifier::ConnectErrorPropertiesFailed, | |
| 221 weak_ptr_factory_.GetWeakPtr(), error_name, service_path)); | |
| 222 } | |
| 223 | |
| 224 void NetworkStateNotifier::ShowMobileActivationError( | |
| 225 const std::string& service_path) { | |
| 226 const NetworkState* cellular = | |
| 227 NetworkHandler::Get()->network_state_handler()->GetNetworkState( | |
| 228 service_path); | |
| 229 if (!cellular || cellular->type() != shill::kTypeCellular) { | |
| 230 NET_LOG_ERROR("ShowMobileActivationError without Cellular network", | |
| 231 service_path); | |
| 232 return; | |
| 233 } | |
| 234 message_center::MessageCenter::Get()->AddNotification( | |
| 235 message_center::Notification::CreateSystemNotification( | |
| 236 kNetworkActivateNotificationId, | |
| 237 l10n_util::GetStringUTF16(IDS_NETWORK_ACTIVATION_ERROR_TITLE), | |
| 238 l10n_util::GetStringFUTF16(IDS_NETWORK_ACTIVATION_NEEDS_CONNECTION, | |
| 239 base::UTF8ToUTF16(cellular->name())), | |
| 240 ui::ResourceBundle::GetSharedInstance().GetImageNamed( | |
| 241 IDR_AURA_UBER_TRAY_NETWORK_FAILED_CELLULAR), | |
| 242 kNotifierNetworkError, | |
| 243 base::Bind(&NetworkStateNotifier::ShowNetworkSettings, | |
| 244 weak_ptr_factory_.GetWeakPtr(), service_path))); | |
| 245 } | |
| 246 | |
| 247 void NetworkStateNotifier::RemoveConnectNotification() { | |
| 248 message_center::MessageCenter* message_center = | |
| 249 message_center::MessageCenter::Get(); | |
| 250 if (message_center) { | |
| 251 message_center->RemoveNotification(kNetworkConnectNotificationId, | |
| 252 false /* not by user */); | |
| 253 } | |
| 254 } | |
| 255 | |
| 256 void NetworkStateNotifier::ConnectErrorPropertiesSucceeded( | |
| 257 const std::string& error_name, | |
| 258 const std::string& service_path, | |
| 259 const base::DictionaryValue& shill_properties) { | |
| 260 std::string state; | |
| 261 shill_properties.GetStringWithoutPathExpansion(shill::kStateProperty, &state); | |
| 262 if (chromeos::NetworkState::StateIsConnected(state) || | |
| 263 chromeos::NetworkState::StateIsConnecting(state)) { | |
| 264 // Network is no longer in an error state. This can happen if an | |
| 265 // unexpected idle state transition occurs, see crbug.com/333955. | |
| 266 return; | |
| 267 } | |
| 268 ShowConnectErrorNotification(error_name, service_path, shill_properties); | |
| 269 } | |
| 270 | |
| 271 void NetworkStateNotifier::ConnectErrorPropertiesFailed( | |
| 272 const std::string& error_name, | |
| 273 const std::string& service_path, | |
| 274 const std::string& shill_connect_error, | |
| 275 scoped_ptr<base::DictionaryValue> shill_error_data) { | |
| 276 base::DictionaryValue shill_properties; | |
| 277 ShowConnectErrorNotification(error_name, service_path, shill_properties); | |
| 278 } | |
| 279 | |
| 280 void NetworkStateNotifier::ShowConnectErrorNotification( | |
| 281 const std::string& error_name, | |
| 282 const std::string& service_path, | |
| 283 const base::DictionaryValue& shill_properties) { | |
| 284 base::string16 error = GetConnectErrorString(error_name); | |
| 285 if (error.empty()) { | |
| 286 std::string shill_error; | |
| 287 shill_properties.GetStringWithoutPathExpansion(shill::kErrorProperty, | |
| 288 &shill_error); | |
| 289 if (!chromeos::NetworkState::ErrorIsValid(shill_error)) { | |
| 290 shill_properties.GetStringWithoutPathExpansion( | |
| 291 shill::kPreviousErrorProperty, &shill_error); | |
| 292 NET_LOG_DEBUG("Notify Service.PreviousError: " + shill_error, | |
| 293 service_path); | |
| 294 if (!chromeos::NetworkState::ErrorIsValid(shill_error)) | |
| 295 shill_error.clear(); | |
| 296 } else { | |
| 297 NET_LOG_DEBUG("Notify Service.Error: " + shill_error, service_path); | |
| 298 } | |
| 299 | |
| 300 const NetworkState* network = | |
| 301 NetworkHandler::Get()->network_state_handler()->GetNetworkState( | |
| 302 service_path); | |
| 303 if (network) { | |
| 304 // Always log last_error, but only use it if shill_error is empty. | |
| 305 // TODO(stevenjb): This shouldn't ever be necessary, but is kept here as | |
| 306 // a failsafe since more information is better than less when debugging | |
| 307 // and we have encountered some strange edge cases before. | |
| 308 NET_LOG_DEBUG("Notify Network.last_error: " + network->last_error(), | |
| 309 service_path); | |
| 310 if (shill_error.empty()) | |
| 311 shill_error = network->last_error(); | |
| 312 } | |
| 313 | |
| 314 if (ShillErrorIsIgnored(shill_error)) { | |
| 315 NET_LOG_DEBUG("Notify Ignoring error: " + error_name, service_path); | |
| 316 return; | |
| 317 } | |
| 318 | |
| 319 error = network_connect_->GetErrorString(shill_error, service_path); | |
| 320 if (error.empty()) | |
| 321 error = l10n_util::GetStringUTF16(IDS_CHROMEOS_NETWORK_ERROR_UNKNOWN); | |
| 322 } | |
| 323 NET_LOG_ERROR("Notify connect error: " + base::UTF16ToUTF8(error), | |
| 324 service_path); | |
| 325 | |
| 326 std::string network_name = | |
| 327 chromeos::shill_property_util::GetNameFromProperties(service_path, | |
| 328 shill_properties); | |
| 329 std::string network_error_details; | |
| 330 shill_properties.GetStringWithoutPathExpansion(shill::kErrorDetailsProperty, | |
| 331 &network_error_details); | |
| 332 | |
| 333 base::string16 error_msg; | |
| 334 if (!network_error_details.empty()) { | |
| 335 // network_name should't be empty if network_error_details is set. | |
| 336 error_msg = l10n_util::GetStringFUTF16( | |
| 337 IDS_NETWORK_CONNECTION_ERROR_MESSAGE_WITH_SERVER_MESSAGE, | |
| 338 base::UTF8ToUTF16(network_name), error, | |
| 339 base::UTF8ToUTF16(network_error_details)); | |
| 340 } else if (network_name.empty()) { | |
| 341 error_msg = l10n_util::GetStringFUTF16( | |
| 342 IDS_NETWORK_CONNECTION_ERROR_MESSAGE_NO_NAME, error); | |
| 343 } else { | |
| 344 error_msg = | |
| 345 l10n_util::GetStringFUTF16(IDS_NETWORK_CONNECTION_ERROR_MESSAGE, | |
| 346 base::UTF8ToUTF16(network_name), error); | |
| 347 } | |
| 348 | |
| 349 std::string network_type; | |
| 350 shill_properties.GetStringWithoutPathExpansion(shill::kTypeProperty, | |
| 351 &network_type); | |
| 352 | |
| 353 ShowErrorNotification( | |
| 354 kNetworkConnectNotificationId, network_type, | |
| 355 l10n_util::GetStringUTF16(IDS_NETWORK_CONNECTION_ERROR_TITLE), error_msg, | |
| 356 base::Bind(&NetworkStateNotifier::ShowNetworkSettings, | |
| 357 weak_ptr_factory_.GetWeakPtr(), service_path)); | |
| 358 } | |
| 359 | |
| 360 void NetworkStateNotifier::ShowNetworkSettings( | |
| 361 const std::string& service_path) { | |
| 362 network_connect_->ShowNetworkSettings(service_path); | |
| 363 } | |
| 364 | |
| 365 } // namespace ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 693493003:
Revert "Move network_connect code to ui/chromeos/network" (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master