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_modem_cdma_proxy.h"
18
19#include <memory>
20
21#if defined(__ANDROID__)
22#include <dbus/service_constants.h>
23#else
24#include <chromeos/dbus/service_constants.h>
25#endif  // __ANDROID__
26
27#include "shill/cellular/cellular_error.h"
28#include "shill/logging.h"
29
30using std::string;
31
32namespace shill {
33
34namespace Logging {
35static auto kModuleLogScope = ScopeLogger::kDBus;
36static string ObjectID(const dbus::ObjectPath* p) { return p->value(); }
37}  // namespace Logging
38
39// static.
40const char ChromeosModemCDMAProxy::kPropertyMeid[] = "Meid";
41
42ChromeosModemCDMAProxy::PropertySet::PropertySet(
43    dbus::ObjectProxy* object_proxy,
44    const std::string& interface_name,
45    const PropertyChangedCallback& callback)
46    : dbus::PropertySet(object_proxy, interface_name, callback) {
47  RegisterProperty(kPropertyMeid, &meid);
48}
49
50ChromeosModemCDMAProxy::ChromeosModemCDMAProxy(
51    const scoped_refptr<dbus::Bus>& bus,
52    const string& path,
53    const string& service)
54    : proxy_(
55        new org::freedesktop::ModemManager::Modem::CdmaProxy(
56            bus, service, dbus::ObjectPath(path))) {
57  // Register signal handlers.
58  proxy_->RegisterActivationStateChangedSignalHandler(
59      base::Bind(&ChromeosModemCDMAProxy::ActivationStateChanged,
60                 weak_factory_.GetWeakPtr()),
61      base::Bind(&ChromeosModemCDMAProxy::OnSignalConnected,
62                 weak_factory_.GetWeakPtr()));
63  proxy_->RegisterSignalQualitySignalHandler(
64      base::Bind(&ChromeosModemCDMAProxy::SignalQuality,
65                 weak_factory_.GetWeakPtr()),
66      base::Bind(&ChromeosModemCDMAProxy::OnSignalConnected,
67                 weak_factory_.GetWeakPtr()));
68  proxy_->RegisterRegistrationStateChangedSignalHandler(
69      base::Bind(&ChromeosModemCDMAProxy::RegistrationStateChanged,
70                 weak_factory_.GetWeakPtr()),
71      base::Bind(&ChromeosModemCDMAProxy::OnSignalConnected,
72                 weak_factory_.GetWeakPtr()));
73
74  // Register properties.
75  properties_.reset(
76      new PropertySet(
77          proxy_->GetObjectProxy(),
78          cromo::kModemCdmaInterface,
79          base::Bind(&ChromeosModemCDMAProxy::OnPropertyChanged,
80                     weak_factory_.GetWeakPtr())));
81
82  // Connect property signals and initialize cached value. Based on
83  // recommendations from src/dbus/property.h.
84  properties_->ConnectSignals();
85  properties_->GetAll();
86}
87
88ChromeosModemCDMAProxy::~ChromeosModemCDMAProxy() {}
89
90void ChromeosModemCDMAProxy::Activate(const string& carrier,
91                                      Error* error,
92                                      const ActivationResultCallback& callback,
93                                      int timeout) {
94  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << carrier;
95  proxy_->ActivateAsync(
96      carrier,
97      base::Bind(&ChromeosModemCDMAProxy::OnActivateSuccess,
98                 weak_factory_.GetWeakPtr(),
99                 callback),
100      base::Bind(&ChromeosModemCDMAProxy::OnActivateFailure,
101                 weak_factory_.GetWeakPtr(),
102                 callback));
103}
104
105void ChromeosModemCDMAProxy::GetRegistrationState(
106    Error* error,
107    const RegistrationStateCallback& callback,
108    int timeout) {
109  SLOG(&proxy_->GetObjectPath(), 2) << __func__;
110  proxy_->GetRegistrationStateAsync(
111      base::Bind(&ChromeosModemCDMAProxy::OnGetRegistrationStateSuccess,
112                 weak_factory_.GetWeakPtr(),
113                 callback),
114      base::Bind(&ChromeosModemCDMAProxy::OnGetRegistrationStateFailure,
115                 weak_factory_.GetWeakPtr(),
116                 callback));
117}
118
119void ChromeosModemCDMAProxy::GetSignalQuality(
120    Error* error, const SignalQualityCallback& callback, int timeout) {
121  SLOG(&proxy_->GetObjectPath(), 2) << __func__;
122  proxy_->GetSignalQualityAsync(
123      base::Bind(&ChromeosModemCDMAProxy::OnGetSignalQualitySuccess,
124                 weak_factory_.GetWeakPtr(),
125                 callback),
126      base::Bind(&ChromeosModemCDMAProxy::OnGetSignalQualityFailure,
127                 weak_factory_.GetWeakPtr(),
128                 callback));
129}
130
131const string ChromeosModemCDMAProxy::MEID() {
132  SLOG(&proxy_->GetObjectPath(), 2) << __func__;
133  if (!properties_->meid.GetAndBlock()) {
134    LOG(ERROR) << "Failed to get MEID";
135    return string();
136  }
137  return properties_->meid.value();
138}
139
140void ChromeosModemCDMAProxy::ActivationStateChanged(
141    uint32_t activation_state,
142    uint32_t activation_error,
143    const brillo::VariantDictionary& status_changes) {
144  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << activation_state
145                                    << ", " << activation_error << ")";
146  if (activation_state_callback_.is_null()) {
147    return;
148  }
149  KeyValueStore status_changes_store;
150  KeyValueStore::ConvertFromVariantDictionary(status_changes,
151                                              &status_changes_store);
152  activation_state_callback_.Run(activation_state,
153                                 activation_error,
154                                 status_changes_store);
155}
156
157void ChromeosModemCDMAProxy::SignalQuality(uint32_t quality) {
158  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << quality << ")";
159  if (signal_quality_callback_.is_null()) {
160    return;
161  }
162  signal_quality_callback_.Run(quality);
163}
164
165void ChromeosModemCDMAProxy::RegistrationStateChanged(
166    uint32_t cdma_1x_state,
167    uint32_t evdo_state) {
168  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << cdma_1x_state << ", "
169                                    << evdo_state << ")";
170  if (registration_state_callback_.is_null()) {
171    return;
172  }
173  registration_state_callback_.Run(cdma_1x_state, evdo_state);
174}
175
176void ChromeosModemCDMAProxy::OnActivateSuccess(
177    const ActivationResultCallback& callback, uint32_t status) {
178  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << status << ")";
179  callback.Run(status, Error());
180}
181
182void ChromeosModemCDMAProxy::OnActivateFailure(
183    const ActivationResultCallback& callback, brillo::Error* dbus_error) {
184  SLOG(&proxy_->GetObjectPath(), 2) << __func__;
185  Error error;
186  CellularError::FromChromeosDBusError(dbus_error, &error);
187  callback.Run(0, error);
188}
189
190void ChromeosModemCDMAProxy::OnGetRegistrationStateSuccess(
191    const RegistrationStateCallback& callback,
192    uint32_t state_1x,
193    uint32_t state_evdo) {
194  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << state_1x
195                                    << ", " << state_evdo << ")";
196  callback.Run(state_1x, state_evdo, Error());
197}
198
199void ChromeosModemCDMAProxy::OnGetRegistrationStateFailure(
200    const RegistrationStateCallback& callback, brillo::Error* dbus_error) {
201  SLOG(&proxy_->GetObjectPath(), 2) << __func__;
202  Error error;
203  CellularError::FromChromeosDBusError(dbus_error, &error);
204  callback.Run(0, 0, error);
205}
206
207void ChromeosModemCDMAProxy::OnGetSignalQualitySuccess(
208    const SignalQualityCallback& callback, uint32_t quality) {
209  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << quality << ")";
210  callback.Run(quality, Error());
211}
212
213void ChromeosModemCDMAProxy::OnGetSignalQualityFailure(
214    const SignalQualityCallback& callback, brillo::Error* dbus_error) {
215  SLOG(&proxy_->GetObjectPath(), 2) << __func__;
216  Error error;
217  CellularError::FromChromeosDBusError(dbus_error, &error);
218  callback.Run(0, error);
219}
220
221void ChromeosModemCDMAProxy::OnSignalConnected(
222    const string& interface_name, const string& signal_name, bool success) {
223  SLOG(&proxy_->GetObjectPath(), 2) << __func__
224      << "interface: " << interface_name
225             << " signal: " << signal_name << "success: " << success;
226  if (!success) {
227    LOG(ERROR) << "Failed to connect signal " << signal_name
228        << " to interface " << interface_name;
229  }
230}
231
232void ChromeosModemCDMAProxy::OnPropertyChanged(
233    const string& property_name) {
234  SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << property_name;
235}
236
237}  // namespace shill
238