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 25using std::string; 26 27namespace shill { 28 29namespace Logging { 30static auto kModuleLogScope = ScopeLogger::kDBus; 31static string ObjectID(const dbus::ObjectPath* p) { return p->value(); } 32} // namespace Logging 33 34namespace mm1 { 35 36ChromeosModemProxy::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 50ChromeosModemProxy::~ChromeosModemProxy() {} 51 52void 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 68void 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 86void 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 102void 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 116void 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 132void 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 149void 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 169void 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 186void 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 202void 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 219void 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 228void 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 234void 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 242void ChromeosModemProxy::OnCommandSuccess(const StringCallback& callback, 243 const string& response) { 244 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << response; 245 callback.Run(response, Error()); 246} 247 248void 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 256void ChromeosModemProxy::OnOperationSuccess(const ResultCallback& callback, 257 const string& operation) { 258 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << operation; 259 callback.Run(Error()); 260} 261 262void 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 271void 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