1 // 2 // Copyright (C) 2015 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include "shill/dbus/chromeos_mm1_modem_proxy.h" 18 19 #include <memory> 20 #include <tuple> 21 22 #include "shill/cellular/cellular_error.h" 23 #include "shill/logging.h" 24 25 using std::string; 26 27 namespace shill { 28 29 namespace Logging { 30 static auto kModuleLogScope = ScopeLogger::kDBus; 31 static string ObjectID(const dbus::ObjectPath* p) { return p->value(); } 32 } // namespace Logging 33 34 namespace mm1 { 35 36 ChromeosModemProxy::ChromeosModemProxy(const scoped_refptr<dbus::Bus>& bus, 37 const string& path, 38 const string& service) 39 : proxy_( 40 new org::freedesktop::ModemManager1::ModemProxy( 41 bus, service, dbus::ObjectPath(path))) { 42 // Register signal handlers. 43 proxy_->RegisterStateChangedSignalHandler( 44 base::Bind(&ChromeosModemProxy::StateChanged, 45 weak_factory_.GetWeakPtr()), 46 base::Bind(&ChromeosModemProxy::OnSignalConnected, 47 weak_factory_.GetWeakPtr())); 48 } 49 50 ChromeosModemProxy::~ChromeosModemProxy() {} 51 52 void ChromeosModemProxy::Enable(bool enable, 53 Error* error, 54 const ResultCallback& callback, 55 int timeout) { 56 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << enable; 57 proxy_->EnableAsync(enable, 58 base::Bind(&ChromeosModemProxy::OnOperationSuccess, 59 weak_factory_.GetWeakPtr(), 60 callback, 61 __func__), 62 base::Bind(&ChromeosModemProxy::OnOperationFailure, 63 weak_factory_.GetWeakPtr(), 64 callback, 65 __func__)); 66 } 67 68 void ChromeosModemProxy::CreateBearer( 69 const KeyValueStore& properties, 70 Error* error, 71 const RpcIdentifierCallback& callback, 72 int timeout) { 73 SLOG(&proxy_->GetObjectPath(), 2) << __func__; 74 brillo::VariantDictionary properties_dict; 75 KeyValueStore::ConvertToVariantDictionary(properties, &properties_dict); 76 proxy_->CreateBearerAsync( 77 properties_dict, 78 base::Bind(&ChromeosModemProxy::OnCreateBearerSuccess, 79 weak_factory_.GetWeakPtr(), 80 callback), 81 base::Bind(&ChromeosModemProxy::OnCreateBearerFailure, 82 weak_factory_.GetWeakPtr(), 83 callback)); 84 } 85 86 void ChromeosModemProxy::DeleteBearer(const string& bearer, 87 Error* error, 88 const ResultCallback& callback, 89 int timeout) { 90 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << bearer; 91 proxy_->DeleteBearerAsync(dbus::ObjectPath(bearer), 92 base::Bind(&ChromeosModemProxy::OnOperationSuccess, 93 weak_factory_.GetWeakPtr(), 94 callback, 95 __func__), 96 base::Bind(&ChromeosModemProxy::OnOperationFailure, 97 weak_factory_.GetWeakPtr(), 98 callback, 99 __func__)); 100 } 101 102 void ChromeosModemProxy::Reset(Error* error, 103 const ResultCallback& callback, 104 int timeout) { 105 SLOG(&proxy_->GetObjectPath(), 2) << __func__; 106 proxy_->ResetAsync(base::Bind(&ChromeosModemProxy::OnOperationSuccess, 107 weak_factory_.GetWeakPtr(), 108 callback, 109 __func__), 110 base::Bind(&ChromeosModemProxy::OnOperationFailure, 111 weak_factory_.GetWeakPtr(), 112 callback, 113 __func__)); 114 } 115 116 void ChromeosModemProxy::FactoryReset(const std::string& code, 117 Error* error, 118 const ResultCallback& callback, 119 int timeout) { 120 SLOG(&proxy_->GetObjectPath(), 2) << __func__; 121 proxy_->FactoryResetAsync(code, 122 base::Bind(&ChromeosModemProxy::OnOperationSuccess, 123 weak_factory_.GetWeakPtr(), 124 callback, 125 __func__), 126 base::Bind(&ChromeosModemProxy::OnOperationFailure, 127 weak_factory_.GetWeakPtr(), 128 callback, 129 __func__)); 130 } 131 132 void ChromeosModemProxy::SetCurrentCapabilities(uint32_t capabilities, 133 Error* error, 134 const ResultCallback& callback, 135 int timeout) { 136 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << capabilities; 137 proxy_->SetCurrentCapabilitiesAsync( 138 capabilities, 139 base::Bind(&ChromeosModemProxy::OnOperationSuccess, 140 weak_factory_.GetWeakPtr(), 141 callback, 142 __func__), 143 base::Bind(&ChromeosModemProxy::OnOperationFailure, 144 weak_factory_.GetWeakPtr(), 145 callback, 146 __func__)); 147 } 148 149 void ChromeosModemProxy::SetCurrentModes(uint32_t allowed_modes, 150 uint32_t preferred_mode, 151 Error* error, 152 const ResultCallback& callback, 153 int timeout) { 154 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << allowed_modes 155 << " " << preferred_mode; 156 std::tuple<uint32_t, uint32_t> modes { allowed_modes, preferred_mode }; 157 proxy_->SetCurrentModesAsync( 158 modes, 159 base::Bind(&ChromeosModemProxy::OnOperationSuccess, 160 weak_factory_.GetWeakPtr(), 161 callback, 162 __func__), 163 base::Bind(&ChromeosModemProxy::OnOperationFailure, 164 weak_factory_.GetWeakPtr(), 165 callback, 166 __func__)); 167 } 168 169 void ChromeosModemProxy::SetCurrentBands(const std::vector<uint32_t>& bands, 170 Error* error, 171 const ResultCallback& callback, 172 int timeout) { 173 SLOG(&proxy_->GetObjectPath(), 2) << __func__; 174 proxy_->SetCurrentBandsAsync( 175 bands, 176 base::Bind(&ChromeosModemProxy::OnOperationSuccess, 177 weak_factory_.GetWeakPtr(), 178 callback, 179 __func__), 180 base::Bind(&ChromeosModemProxy::OnOperationFailure, 181 weak_factory_.GetWeakPtr(), 182 callback, 183 __func__)); 184 } 185 186 void ChromeosModemProxy::Command(const std::string& cmd, 187 uint32_t user_timeout, 188 Error* error, 189 const StringCallback& callback, 190 int timeout) { 191 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << cmd; 192 proxy_->CommandAsync(cmd, 193 user_timeout, 194 base::Bind(&ChromeosModemProxy::OnCommandSuccess, 195 weak_factory_.GetWeakPtr(), 196 callback), 197 base::Bind(&ChromeosModemProxy::OnCommandFailure, 198 weak_factory_.GetWeakPtr(), 199 callback)); 200 } 201 202 void ChromeosModemProxy::SetPowerState(uint32_t power_state, 203 Error* error, 204 const ResultCallback& callback, 205 int timeout) { 206 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << power_state; 207 proxy_->SetPowerStateAsync( 208 power_state, 209 base::Bind(&ChromeosModemProxy::OnOperationSuccess, 210 weak_factory_.GetWeakPtr(), 211 callback, 212 __func__), 213 base::Bind(&ChromeosModemProxy::OnOperationFailure, 214 weak_factory_.GetWeakPtr(), 215 callback, 216 __func__)); 217 } 218 219 void ChromeosModemProxy::StateChanged( 220 int32_t old, int32_t _new, uint32_t reason) { 221 SLOG(&proxy_->GetObjectPath(), 2) << __func__; 222 if (state_changed_callback_.is_null()) { 223 return; 224 } 225 state_changed_callback_.Run(old, _new, reason); 226 } 227 228 void ChromeosModemProxy::OnCreateBearerSuccess( 229 const RpcIdentifierCallback& callback, const dbus::ObjectPath& path) { 230 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << path.value(); 231 callback.Run(path.value(), Error()); 232 } 233 234 void ChromeosModemProxy::OnCreateBearerFailure( 235 const RpcIdentifierCallback& callback, brillo::Error* dbus_error) { 236 SLOG(&proxy_->GetObjectPath(), 2) << __func__; 237 Error error; 238 CellularError::FromMM1ChromeosDBusError(dbus_error, &error); 239 callback.Run("", error); 240 } 241 242 void ChromeosModemProxy::OnCommandSuccess(const StringCallback& callback, 243 const string& response) { 244 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << response; 245 callback.Run(response, Error()); 246 } 247 248 void ChromeosModemProxy::OnCommandFailure(const StringCallback& callback, 249 brillo::Error* dbus_error) { 250 SLOG(&proxy_->GetObjectPath(), 2) << __func__; 251 Error error; 252 CellularError::FromMM1ChromeosDBusError(dbus_error, &error); 253 callback.Run("", error); 254 } 255 256 void ChromeosModemProxy::OnOperationSuccess(const ResultCallback& callback, 257 const string& operation) { 258 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << operation; 259 callback.Run(Error()); 260 } 261 262 void ChromeosModemProxy::OnOperationFailure(const ResultCallback& callback, 263 const string& operation, 264 brillo::Error* dbus_error) { 265 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << operation; 266 Error error; 267 CellularError::FromMM1ChromeosDBusError(dbus_error, &error); 268 callback.Run(error); 269 } 270 271 void ChromeosModemProxy::OnSignalConnected( 272 const string& interface_name, const string& signal_name, bool success) { 273 SLOG(&proxy_->GetObjectPath(), 2) << __func__ 274 << "interface: " << interface_name 275 << " signal: " << signal_name << "success: " << success; 276 if (!success) { 277 LOG(ERROR) << "Failed to connect signal " << signal_name 278 << " to interface " << interface_name; 279 } 280 } 281 282 } // namespace mm1 283 } // namespace shill 284
