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
30 using std::string;
31
32 namespace shill {
33
34 namespace Logging {
35 static auto kModuleLogScope = ScopeLogger::kDBus;
ObjectID(const dbus::ObjectPath * p)36 static string ObjectID(const dbus::ObjectPath* p) { return p->value(); }
37 } // namespace Logging
38
39 // static.
40 const char ChromeosModemCDMAProxy::kPropertyMeid[] = "Meid";
41
PropertySet(dbus::ObjectProxy * object_proxy,const std::string & interface_name,const PropertyChangedCallback & callback)42 ChromeosModemCDMAProxy::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
ChromeosModemCDMAProxy(const scoped_refptr<dbus::Bus> & bus,const string & path,const string & service)50 ChromeosModemCDMAProxy::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
~ChromeosModemCDMAProxy()88 ChromeosModemCDMAProxy::~ChromeosModemCDMAProxy() {}
89
Activate(const string & carrier,Error * error,const ActivationResultCallback & callback,int timeout)90 void 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
GetRegistrationState(Error * error,const RegistrationStateCallback & callback,int timeout)105 void 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
GetSignalQuality(Error * error,const SignalQualityCallback & callback,int timeout)119 void 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
MEID()131 const 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
ActivationStateChanged(uint32_t activation_state,uint32_t activation_error,const brillo::VariantDictionary & status_changes)140 void 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
SignalQuality(uint32_t quality)157 void 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
RegistrationStateChanged(uint32_t cdma_1x_state,uint32_t evdo_state)165 void 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
OnActivateSuccess(const ActivationResultCallback & callback,uint32_t status)176 void ChromeosModemCDMAProxy::OnActivateSuccess(
177 const ActivationResultCallback& callback, uint32_t status) {
178 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << status << ")";
179 callback.Run(status, Error());
180 }
181
OnActivateFailure(const ActivationResultCallback & callback,brillo::Error * dbus_error)182 void 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
OnGetRegistrationStateSuccess(const RegistrationStateCallback & callback,uint32_t state_1x,uint32_t state_evdo)190 void 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
OnGetRegistrationStateFailure(const RegistrationStateCallback & callback,brillo::Error * dbus_error)199 void 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
OnGetSignalQualitySuccess(const SignalQualityCallback & callback,uint32_t quality)207 void ChromeosModemCDMAProxy::OnGetSignalQualitySuccess(
208 const SignalQualityCallback& callback, uint32_t quality) {
209 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << "(" << quality << ")";
210 callback.Run(quality, Error());
211 }
212
OnGetSignalQualityFailure(const SignalQualityCallback & callback,brillo::Error * dbus_error)213 void 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
OnSignalConnected(const string & interface_name,const string & signal_name,bool success)221 void 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
OnPropertyChanged(const string & property_name)232 void ChromeosModemCDMAProxy::OnPropertyChanged(
233 const string& property_name) {
234 SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << property_name;
235 }
236
237 } // namespace shill
238