chromeos_mm1_modem_proxy.cc revision c0beca55d290fe0b1c96d78cbbcf94b05c23f5a5 
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  chromeos::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, chromeos::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                                          chromeos::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                                            chromeos::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