Darin Petkov | ac635a8 | 2012-01-10 16:51:58 +0100 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium OS Authors. All rights reserved. |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
Ben Chan | c54afe5 | 2014-11-05 10:28:08 -0800 | [diff] [blame^] | 5 | #include "shill/cellular/cellular_capability_cdma.h" |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 6 | |
Jason Glasgow | 4c0724a | 2012-04-17 15:47:40 -0400 | [diff] [blame] | 7 | #include <string> |
| 8 | #include <vector> |
| 9 | |
Eric Shienbrood | 3e20a23 | 2012-02-16 11:35:56 -0500 | [diff] [blame] | 10 | #include <base/bind.h> |
Ben Chan | a0ddf46 | 2014-02-06 11:32:42 -0800 | [diff] [blame] | 11 | #include <base/strings/stringprintf.h> |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 12 | #include <chromeos/dbus/service_constants.h> |
| 13 | #include <mm/mm-modem.h> |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 14 | |
Ben Chan | c54afe5 | 2014-11-05 10:28:08 -0800 | [diff] [blame^] | 15 | #include "shill/cellular/cellular.h" |
| 16 | #include "shill/cellular/cellular_service.h" |
Christopher Wiley | b691efd | 2012-08-09 13:51:51 -0700 | [diff] [blame] | 17 | #include "shill/logging.h" |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 18 | #include "shill/proxy_factory.h" |
| 19 | |
Eric Shienbrood | 3e20a23 | 2012-02-16 11:35:56 -0500 | [diff] [blame] | 20 | using base::Bind; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 21 | using std::string; |
Jason Glasgow | 4c0724a | 2012-04-17 15:47:40 -0400 | [diff] [blame] | 22 | using std::vector; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 23 | |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 24 | namespace shill { |
| 25 | |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 26 | namespace Logging { |
| 27 | static auto kModuleLogScope = ScopeLogger::kCellular; |
| 28 | static string ObjectID(CellularCapabilityCDMA *c) { |
| 29 | return c->cellular()->GetRpcIdentifier(); |
| 30 | } |
| 31 | } |
| 32 | |
Darin Petkov | ac635a8 | 2012-01-10 16:51:58 +0100 | [diff] [blame] | 33 | // static |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 34 | const char CellularCapabilityCDMA::kPhoneNumber[] = "#777"; |
| 35 | |
Eric Shienbrood | 5de44ab | 2011-12-05 10:46:27 -0500 | [diff] [blame] | 36 | CellularCapabilityCDMA::CellularCapabilityCDMA(Cellular *cellular, |
Thieu Le | ce4483e | 2013-01-23 15:12:03 -0800 | [diff] [blame] | 37 | ProxyFactory *proxy_factory, |
Prathmesh Prabhu | 27526f1 | 2013-03-25 19:42:18 -0700 | [diff] [blame] | 38 | ModemInfo *modem_info) |
| 39 | : CellularCapabilityClassic(cellular, proxy_factory, modem_info), |
Eric Shienbrood | 3e20a23 | 2012-02-16 11:35:56 -0500 | [diff] [blame] | 40 | weak_ptr_factory_(this), |
Christopher Wiley | 1582bdd | 2012-11-15 11:31:14 -0800 | [diff] [blame] | 41 | activation_starting_(false), |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 42 | activation_state_(MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED), |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 43 | registration_state_evdo_(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN), |
Prathmesh Prabhu | 700ff4d | 2014-01-16 15:59:33 -0800 | [diff] [blame] | 44 | registration_state_1x_(MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 45 | SLOG(this, 2) << "Cellular capability constructed: CDMA"; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 46 | } |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 47 | |
Ben Chan | f98f00e | 2014-02-05 14:48:43 -0800 | [diff] [blame] | 48 | CellularCapabilityCDMA::~CellularCapabilityCDMA() {} |
| 49 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 50 | void CellularCapabilityCDMA::InitProxies() { |
Jason Glasgow | 82f9ab3 | 2012-04-04 14:27:19 -0400 | [diff] [blame] | 51 | CellularCapabilityClassic::InitProxies(); |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 52 | proxy_.reset(proxy_factory()->CreateModemCDMAProxy( |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 53 | cellular()->dbus_path(), cellular()->dbus_owner())); |
| 54 | proxy_->set_signal_quality_callback( |
| 55 | Bind(&CellularCapabilityCDMA::OnSignalQualitySignal, |
| 56 | weak_ptr_factory_.GetWeakPtr())); |
| 57 | proxy_->set_activation_state_callback( |
| 58 | Bind(&CellularCapabilityCDMA::OnActivationStateChangedSignal, |
| 59 | weak_ptr_factory_.GetWeakPtr())); |
| 60 | proxy_->set_registration_state_callback( |
| 61 | Bind(&CellularCapabilityCDMA::OnRegistrationStateChangedSignal, |
| 62 | weak_ptr_factory_.GetWeakPtr())); |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 63 | } |
| 64 | |
Ben Chan | f98f00e | 2014-02-05 14:48:43 -0800 | [diff] [blame] | 65 | string CellularCapabilityCDMA::GetTypeString() const { |
| 66 | return kTechnologyFamilyCdma; |
| 67 | } |
| 68 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 69 | void CellularCapabilityCDMA::StartModem(Error *error, |
| 70 | const ResultCallback &callback) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 71 | SLOG(this, 2) << __func__; |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 72 | InitProxies(); |
| 73 | |
| 74 | CellularTaskList *tasks = new CellularTaskList(); |
| 75 | ResultCallback cb = |
| 76 | Bind(&CellularCapabilityCDMA::StepCompletedCallback, |
Thieu Le | 923006b | 2012-04-05 16:32:58 -0700 | [diff] [blame] | 77 | weak_ptr_factory_.GetWeakPtr(), callback, false, tasks); |
Eric Shienbrood | 7fce52c | 2012-04-13 19:11:02 -0400 | [diff] [blame] | 78 | if (!cellular()->IsUnderlyingDeviceEnabled()) |
| 79 | tasks->push_back(Bind(&CellularCapabilityCDMA::EnableModem, |
| 80 | weak_ptr_factory_.GetWeakPtr(), cb)); |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 81 | tasks->push_back(Bind(&CellularCapabilityCDMA::GetModemStatus, |
| 82 | weak_ptr_factory_.GetWeakPtr(), cb)); |
| 83 | tasks->push_back(Bind(&CellularCapabilityCDMA::GetMEID, |
| 84 | weak_ptr_factory_.GetWeakPtr(), cb)); |
| 85 | tasks->push_back(Bind(&CellularCapabilityCDMA::GetModemInfo, |
| 86 | weak_ptr_factory_.GetWeakPtr(), cb)); |
| 87 | tasks->push_back(Bind(&CellularCapabilityCDMA::FinishEnable, |
| 88 | weak_ptr_factory_.GetWeakPtr(), cb)); |
| 89 | |
| 90 | RunNextStep(tasks); |
| 91 | } |
| 92 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 93 | void CellularCapabilityCDMA::ReleaseProxies() { |
Jason Glasgow | 82f9ab3 | 2012-04-04 14:27:19 -0400 | [diff] [blame] | 94 | CellularCapabilityClassic::ReleaseProxies(); |
Darin Petkov | 721ac93 | 2011-11-16 15:43:09 +0100 | [diff] [blame] | 95 | proxy_.reset(); |
| 96 | } |
| 97 | |
Thieu Le | 63881a7 | 2014-07-28 17:28:36 -0700 | [diff] [blame] | 98 | bool CellularCapabilityCDMA::AreProxiesInitialized() const { |
| 99 | return (CellularCapabilityClassic::AreProxiesInitialized() && proxy_.get()); |
| 100 | } |
| 101 | |
Jason Glasgow | 82f9ab3 | 2012-04-04 14:27:19 -0400 | [diff] [blame] | 102 | bool CellularCapabilityCDMA::AllowRoaming() { |
| 103 | return allow_roaming_property(); |
| 104 | } |
| 105 | |
| 106 | |
Darin Petkov | 5f316f6 | 2011-11-18 12:10:26 +0100 | [diff] [blame] | 107 | void CellularCapabilityCDMA::OnServiceCreated() { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 108 | SLOG(this, 2) << __func__; |
Darin Petkov | 381928f | 2012-02-02 23:00:12 +0100 | [diff] [blame] | 109 | cellular()->service()->SetUsageURL(usage_url_); |
Thieu Le | 71f81a6 | 2014-07-11 15:17:47 -0700 | [diff] [blame] | 110 | cellular()->service()->SetActivationType( |
| 111 | CellularService::kActivationTypeOTASP); |
Darin Petkov | 5f316f6 | 2011-11-18 12:10:26 +0100 | [diff] [blame] | 112 | HandleNewActivationState(MM_MODEM_CDMA_ACTIVATION_ERROR_NO_ERROR); |
| 113 | } |
| 114 | |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 115 | void CellularCapabilityCDMA::UpdateStatus(const DBusPropertiesMap &properties) { |
| 116 | string carrier; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 117 | DBusProperties::GetUint32( |
| 118 | properties, "activation_state", &activation_state_); |
Darin Petkov | 5f316f6 | 2011-11-18 12:10:26 +0100 | [diff] [blame] | 119 | // TODO(petkov): For now, get the payment and usage URLs from ModemManager to |
| 120 | // match flimflam. In the future, get these from an alternative source (e.g., |
| 121 | // database, carrier-specific properties, etc.). |
Prathmesh Prabhu | 92df619 | 2014-04-29 18:08:08 -0700 | [diff] [blame] | 122 | UpdateOnlinePortal(properties); |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 123 | uint16_t prl_version; |
Prathmesh Prabhu | 92df619 | 2014-04-29 18:08:08 -0700 | [diff] [blame] | 124 | if (DBusProperties::GetUint16(properties, "prl_version", &prl_version)) |
| 125 | cellular()->set_prl_version(prl_version); |
| 126 | } |
| 127 | |
| 128 | void CellularCapabilityCDMA::UpdateServiceOLP() { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 129 | SLOG(this, 3) << __func__; |
Prathmesh Prabhu | 92df619 | 2014-04-29 18:08:08 -0700 | [diff] [blame] | 130 | // All OLP changes are routed up to the Home Provider. |
| 131 | if (!cellular()->home_provider_info()->IsMobileNetworkOperatorKnown()) { |
| 132 | return; |
Darin Petkov | 381928f | 2012-02-02 23:00:12 +0100 | [diff] [blame] | 133 | } |
Prathmesh Prabhu | 92df619 | 2014-04-29 18:08:08 -0700 | [diff] [blame] | 134 | |
| 135 | const vector<MobileOperatorInfo::OnlinePortal> &olp_list = |
| 136 | cellular()->home_provider_info()->olp_list(); |
| 137 | if (olp_list.empty()) { |
| 138 | return; |
Darin Petkov | 381928f | 2012-02-02 23:00:12 +0100 | [diff] [blame] | 139 | } |
Prathmesh Prabhu | 92df619 | 2014-04-29 18:08:08 -0700 | [diff] [blame] | 140 | |
| 141 | if (olp_list.size() > 1) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 142 | SLOG(this, 1) << "Found multiple online portals. Choosing the first."; |
Darin Petkov | 381928f | 2012-02-02 23:00:12 +0100 | [diff] [blame] | 143 | } |
Prathmesh Prabhu | 92df619 | 2014-04-29 18:08:08 -0700 | [diff] [blame] | 144 | cellular()->service()->SetOLP(olp_list[0].url, |
| 145 | olp_list[0].method, |
| 146 | olp_list[0].post_data); |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 147 | } |
| 148 | |
| 149 | void CellularCapabilityCDMA::SetupConnectProperties( |
| 150 | DBusPropertiesMap *properties) { |
Eric Shienbrood | 5de44ab | 2011-12-05 10:46:27 -0500 | [diff] [blame] | 151 | (*properties)[kConnectPropertyPhoneNumber].writer().append_string( |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 152 | kPhoneNumber); |
| 153 | } |
| 154 | |
Eric Shienbrood | 5de44ab | 2011-12-05 10:46:27 -0500 | [diff] [blame] | 155 | void CellularCapabilityCDMA::Activate(const string &carrier, |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 156 | Error *error, |
| 157 | const ResultCallback &callback) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 158 | SLOG(this, 2) << __func__ << "(" << carrier << ")"; |
Christopher Wiley | 1582bdd | 2012-11-15 11:31:14 -0800 | [diff] [blame] | 159 | // We're going to trigger something which leads to an activation. |
| 160 | activation_starting_ = true; |
Christopher Wiley | 7d0953e | 2012-11-16 00:37:10 -0800 | [diff] [blame] | 161 | if (cellular()->state() == Cellular::kStateEnabled || |
| 162 | cellular()->state() == Cellular::kStateRegistered) { |
Christopher Wiley | 8a46890 | 2012-11-30 11:52:38 -0800 | [diff] [blame] | 163 | ActivationResultCallback activation_callback = |
Christopher Wiley | 7d0953e | 2012-11-16 00:37:10 -0800 | [diff] [blame] | 164 | Bind(&CellularCapabilityCDMA::OnActivateReply, |
| 165 | weak_ptr_factory_.GetWeakPtr(), |
| 166 | callback); |
Christopher Wiley | 8a46890 | 2012-11-30 11:52:38 -0800 | [diff] [blame] | 167 | proxy_->Activate(carrier, error, activation_callback, kTimeoutActivate); |
Christopher Wiley | 7d0953e | 2012-11-16 00:37:10 -0800 | [diff] [blame] | 168 | } else if (cellular()->state() == Cellular::kStateConnected || |
| 169 | cellular()->state() == Cellular::kStateLinked) { |
Christopher Wiley | 8a46890 | 2012-11-30 11:52:38 -0800 | [diff] [blame] | 170 | pending_activation_callback_ = callback; |
| 171 | pending_activation_carrier_ = carrier; |
Samuel Tan | 0d06119 | 2014-07-07 15:45:15 -0700 | [diff] [blame] | 172 | cellular()->Disconnect(error, __func__); |
Christopher Wiley | 7d0953e | 2012-11-16 00:37:10 -0800 | [diff] [blame] | 173 | } else { |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 174 | Error::PopulateAndLog(error, Error::kInvalidArguments, |
Darin Petkov | a3d3be5 | 2011-11-14 21:34:16 +0100 | [diff] [blame] | 175 | "Unable to activate in " + |
| 176 | Cellular::GetStateString(cellular()->state())); |
Christopher Wiley | 1582bdd | 2012-11-15 11:31:14 -0800 | [diff] [blame] | 177 | activation_starting_ = false; |
Darin Petkov | a3d3be5 | 2011-11-14 21:34:16 +0100 | [diff] [blame] | 178 | } |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 179 | } |
| 180 | |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 181 | void CellularCapabilityCDMA::HandleNewActivationState(uint32_t error) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 182 | SLOG(this, 2) << __func__ << "(" << error << ")"; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 183 | if (!cellular()->service().get()) { |
Christopher Wiley | 7d0953e | 2012-11-16 00:37:10 -0800 | [diff] [blame] | 184 | LOG(ERROR) << "In " << __func__ << "(): service is null."; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 185 | return; |
| 186 | } |
Darin Petkov | b9c9933 | 2012-01-12 13:13:00 +0100 | [diff] [blame] | 187 | cellular()->service()->SetActivationState( |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 188 | GetActivationStateString(activation_state_)); |
| 189 | cellular()->service()->set_error(GetActivationErrorString(error)); |
| 190 | } |
| 191 | |
Christopher Wiley | 8a46890 | 2012-11-30 11:52:38 -0800 | [diff] [blame] | 192 | void CellularCapabilityCDMA::DisconnectCleanup() { |
| 193 | CellularCapabilityClassic::DisconnectCleanup(); |
| 194 | if (pending_activation_callback_.is_null()) { |
| 195 | return; |
| 196 | } |
| 197 | if (cellular()->state() == Cellular::kStateEnabled || |
| 198 | cellular()->state() == Cellular::kStateRegistered) { |
| 199 | Error ignored_error; |
| 200 | Activate(pending_activation_carrier_, |
| 201 | &ignored_error, |
| 202 | pending_activation_callback_); |
| 203 | } else { |
| 204 | Error error; |
| 205 | Error::PopulateAndLog( |
| 206 | &error, |
| 207 | Error::kOperationFailed, |
| 208 | "Tried to disconnect before activating cellular service and failed"); |
| 209 | HandleNewActivationState(MM_MODEM_CDMA_ACTIVATION_ERROR_UNKNOWN); |
| 210 | activation_starting_ = false; |
| 211 | pending_activation_callback_.Run(error); |
| 212 | } |
| 213 | pending_activation_callback_.Reset(); |
| 214 | pending_activation_carrier_.clear(); |
| 215 | } |
| 216 | |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 217 | // static |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 218 | string CellularCapabilityCDMA::GetActivationStateString(uint32_t state) { |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 219 | switch (state) { |
| 220 | case MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 221 | return kActivationStateActivated; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 222 | case MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 223 | return kActivationStateActivating; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 224 | case MM_MODEM_CDMA_ACTIVATION_STATE_NOT_ACTIVATED: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 225 | return kActivationStateNotActivated; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 226 | case MM_MODEM_CDMA_ACTIVATION_STATE_PARTIALLY_ACTIVATED: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 227 | return kActivationStatePartiallyActivated; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 228 | default: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 229 | return kActivationStateUnknown; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 230 | } |
| 231 | } |
| 232 | |
| 233 | // static |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 234 | string CellularCapabilityCDMA::GetActivationErrorString(uint32_t error) { |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 235 | switch (error) { |
| 236 | case MM_MODEM_CDMA_ACTIVATION_ERROR_WRONG_RADIO_INTERFACE: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 237 | return kErrorNeedEvdo; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 238 | case MM_MODEM_CDMA_ACTIVATION_ERROR_ROAMING: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 239 | return kErrorNeedHomeNetwork; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 240 | case MM_MODEM_CDMA_ACTIVATION_ERROR_COULD_NOT_CONNECT: |
| 241 | case MM_MODEM_CDMA_ACTIVATION_ERROR_SECURITY_AUTHENTICATION_FAILED: |
| 242 | case MM_MODEM_CDMA_ACTIVATION_ERROR_PROVISIONING_FAILED: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 243 | return kErrorOtaspFailed; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 244 | case MM_MODEM_CDMA_ACTIVATION_ERROR_NO_ERROR: |
| 245 | return ""; |
| 246 | case MM_MODEM_CDMA_ACTIVATION_ERROR_NO_SIGNAL: |
| 247 | default: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 248 | return kErrorActivationFailed; |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 249 | } |
Darin Petkov | a3d3be5 | 2011-11-14 21:34:16 +0100 | [diff] [blame] | 250 | } |
| 251 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 252 | void CellularCapabilityCDMA::GetMEID(const ResultCallback &callback) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 253 | SLOG(this, 2) << __func__; |
Prathmesh Prabhu | 9f06c87 | 2013-11-21 14:08:23 -0800 | [diff] [blame] | 254 | if (cellular()->meid().empty()) { |
Paul Stewart | ee6b3d7 | 2013-07-12 16:07:51 -0700 | [diff] [blame] | 255 | // TODO(petkov): Switch to asynchronous calls (crbug.com/200687). |
Prathmesh Prabhu | 9f06c87 | 2013-11-21 14:08:23 -0800 | [diff] [blame] | 256 | cellular()->set_meid(proxy_->MEID()); |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 257 | SLOG(this, 2) << "MEID: " << cellular()->meid(); |
Darin Petkov | cb54773 | 2011-11-09 13:55:26 +0100 | [diff] [blame] | 258 | } |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 259 | callback.Run(Error()); |
Darin Petkov | cb54773 | 2011-11-09 13:55:26 +0100 | [diff] [blame] | 260 | } |
| 261 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 262 | void CellularCapabilityCDMA::GetProperties(const ResultCallback &callback) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 263 | SLOG(this, 2) << __func__; |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 264 | // No properties. |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 265 | callback.Run(Error()); |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 266 | } |
| 267 | |
Christopher Wiley | 1582bdd | 2012-11-15 11:31:14 -0800 | [diff] [blame] | 268 | bool CellularCapabilityCDMA::IsActivating() const { |
| 269 | return activation_starting_ || |
| 270 | activation_state_ == MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING; |
| 271 | } |
| 272 | |
Ben Chan | 31ce564 | 2013-11-14 13:37:40 -0800 | [diff] [blame] | 273 | bool CellularCapabilityCDMA::IsRegistered() const { |
Darin Petkov | b72cf40 | 2011-11-22 14:51:39 +0100 | [diff] [blame] | 274 | return registration_state_evdo_ != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN || |
| 275 | registration_state_1x_ != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; |
| 276 | } |
| 277 | |
Eric Shienbrood | 7fce52c | 2012-04-13 19:11:02 -0400 | [diff] [blame] | 278 | void CellularCapabilityCDMA::SetUnregistered(bool searching) { |
| 279 | registration_state_evdo_ = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; |
| 280 | registration_state_1x_ = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN; |
| 281 | } |
| 282 | |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 283 | string CellularCapabilityCDMA::GetNetworkTechnologyString() const { |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 284 | if (registration_state_evdo_ != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) { |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 285 | return kNetworkTechnologyEvdo; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 286 | } |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 287 | if (registration_state_1x_ != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) { |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 288 | return kNetworkTechnology1Xrtt; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 289 | } |
| 290 | return ""; |
| 291 | } |
| 292 | |
| 293 | string CellularCapabilityCDMA::GetRoamingStateString() const { |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 294 | uint32_t state = registration_state_evdo_; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 295 | if (state == MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN) { |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 296 | state = registration_state_1x_; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 297 | } |
| 298 | switch (state) { |
| 299 | case MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN: |
| 300 | case MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED: |
| 301 | break; |
| 302 | case MM_MODEM_CDMA_REGISTRATION_STATE_HOME: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 303 | return kRoamingStateHome; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 304 | case MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING: |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 305 | return kRoamingStateRoaming; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 306 | default: |
| 307 | NOTREACHED(); |
| 308 | } |
Ben Chan | 7ea768e | 2013-09-20 15:08:40 -0700 | [diff] [blame] | 309 | return kRoamingStateUnknown; |
Darin Petkov | 20c13ec | 2011-11-09 15:07:15 +0100 | [diff] [blame] | 310 | } |
| 311 | |
Darin Petkov | 3e50924 | 2011-11-10 14:46:44 +0100 | [diff] [blame] | 312 | void CellularCapabilityCDMA::GetSignalQuality() { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 313 | SLOG(this, 2) << __func__; |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 314 | SignalQualityCallback callback = |
| 315 | Bind(&CellularCapabilityCDMA::OnGetSignalQualityReply, |
| 316 | weak_ptr_factory_.GetWeakPtr()); |
Ben Chan | ea18c6c | 2014-09-30 13:08:26 -0700 | [diff] [blame] | 317 | proxy_->GetSignalQuality(nullptr, callback, kTimeoutDefault); |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 318 | } |
| 319 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 320 | void CellularCapabilityCDMA::GetRegistrationState() { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 321 | SLOG(this, 2) << __func__; |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 322 | RegistrationStateCallback callback = |
| 323 | Bind(&CellularCapabilityCDMA::OnGetRegistrationStateReply, |
| 324 | weak_ptr_factory_.GetWeakPtr()); |
Ben Chan | ea18c6c | 2014-09-30 13:08:26 -0700 | [diff] [blame] | 325 | proxy_->GetRegistrationState(nullptr, callback, kTimeoutDefault); |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 326 | } |
| 327 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 328 | void CellularCapabilityCDMA::OnActivateReply( |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 329 | const ResultCallback &callback, uint32_t status, const Error &error) { |
Christopher Wiley | 1582bdd | 2012-11-15 11:31:14 -0800 | [diff] [blame] | 330 | activation_starting_ = false; |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 331 | if (error.IsSuccess()) { |
| 332 | if (status == MM_MODEM_CDMA_ACTIVATION_ERROR_NO_ERROR) { |
| 333 | activation_state_ = MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATING; |
Christopher Wiley | 7d0953e | 2012-11-16 00:37:10 -0800 | [diff] [blame] | 334 | } else { |
| 335 | LOG(WARNING) << "Modem activation failed with status: " |
| 336 | << GetActivationErrorString(status) << " (" << status << ")"; |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 337 | } |
| 338 | HandleNewActivationState(status); |
Christopher Wiley | 7d0953e | 2012-11-16 00:37:10 -0800 | [diff] [blame] | 339 | } else { |
| 340 | LOG(ERROR) << "Activate() failed with error: " << error; |
Eric Shienbrood | 5de44ab | 2011-12-05 10:46:27 -0500 | [diff] [blame] | 341 | } |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 342 | callback.Run(error); |
Eric Shienbrood | 5de44ab | 2011-12-05 10:46:27 -0500 | [diff] [blame] | 343 | } |
| 344 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 345 | void CellularCapabilityCDMA::OnGetRegistrationStateReply( |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 346 | uint32_t state_1x, uint32_t state_evdo, const Error &error) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 347 | SLOG(this, 2) << __func__; |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 348 | if (error.IsSuccess()) |
| 349 | OnRegistrationStateChangedSignal(state_1x, state_evdo); |
| 350 | } |
| 351 | |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 352 | void CellularCapabilityCDMA::OnGetSignalQualityReply(uint32_t quality, |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 353 | const Error &error) { |
| 354 | if (error.IsSuccess()) |
| 355 | OnSignalQualitySignal(quality); |
| 356 | } |
| 357 | |
| 358 | void CellularCapabilityCDMA::OnActivationStateChangedSignal( |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 359 | uint32_t activation_state, |
| 360 | uint32_t activation_error, |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 361 | const DBusPropertiesMap &status_changes) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 362 | SLOG(this, 2) << __func__; |
Prathmesh Prabhu | 9f06c87 | 2013-11-21 14:08:23 -0800 | [diff] [blame] | 363 | string prop_value; |
| 364 | |
| 365 | if (DBusProperties::GetString(status_changes, "mdn", &prop_value)) |
| 366 | cellular()->set_mdn(prop_value); |
| 367 | if (DBusProperties::GetString(status_changes, "min", &prop_value)) |
| 368 | cellular()->set_min(prop_value); |
| 369 | |
Prathmesh Prabhu | 28b4a3b | 2014-03-28 11:52:09 -0700 | [diff] [blame] | 370 | UpdateOnlinePortal(status_changes); |
Darin Petkov | ae0c64e | 2011-11-15 15:50:27 +0100 | [diff] [blame] | 371 | activation_state_ = activation_state; |
| 372 | HandleNewActivationState(activation_error); |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 373 | } |
| 374 | |
Eric Shienbrood | 9a24553 | 2012-03-07 14:20:39 -0500 | [diff] [blame] | 375 | void CellularCapabilityCDMA::OnRegistrationStateChangedSignal( |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 376 | uint32_t state_1x, uint32_t state_evdo) { |
Rebecca Silberstein | c9c31d8 | 2014-10-21 15:01:00 -0700 | [diff] [blame] | 377 | SLOG(this, 2) << __func__; |
Darin Petkov | 184c54e | 2011-11-15 12:44:39 +0100 | [diff] [blame] | 378 | registration_state_1x_ = state_1x; |
| 379 | registration_state_evdo_ = state_evdo; |
| 380 | cellular()->HandleNewRegistrationState(); |
| 381 | } |
| 382 | |
Ben Chan | 7fab897 | 2014-08-10 17:14:46 -0700 | [diff] [blame] | 383 | void CellularCapabilityCDMA::OnSignalQualitySignal(uint32_t strength) { |
Darin Petkov | 3e50924 | 2011-11-10 14:46:44 +0100 | [diff] [blame] | 384 | cellular()->HandleNewSignalQuality(strength); |
| 385 | } |
| 386 | |
Prathmesh Prabhu | 28b4a3b | 2014-03-28 11:52:09 -0700 | [diff] [blame] | 387 | void CellularCapabilityCDMA::UpdateOnlinePortal( |
| 388 | const DBusPropertiesMap &properties) { |
| 389 | // Treat the three updates atomically: Only update the serving operator when |
| 390 | // all three are known: |
| 391 | string olp_url, olp_method, olp_post_data; |
| 392 | if (DBusProperties::GetString(properties, "payment_url", &olp_url) && |
| 393 | DBusProperties::GetString(properties, |
| 394 | "payment_url_method", &olp_method) && |
| 395 | DBusProperties::GetString(properties, |
| 396 | "payment_url_postdata", |
| 397 | &olp_post_data)) { |
Prathmesh Prabhu | 92df619 | 2014-04-29 18:08:08 -0700 | [diff] [blame] | 398 | cellular()->home_provider_info()->UpdateOnlinePortal(olp_url, |
Prathmesh Prabhu | 8599e05 | 2014-04-25 14:20:22 -0700 | [diff] [blame] | 399 | olp_method, |
| 400 | olp_post_data); |
Prathmesh Prabhu | 28b4a3b | 2014-03-28 11:52:09 -0700 | [diff] [blame] | 401 | } |
| 402 | } |
| 403 | |
Darin Petkov | daf4386 | 2011-10-27 11:37:28 +0200 | [diff] [blame] | 404 | } // namespace shill |