OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "chromeos/dbus/biod_biometrics_manager_client.h" | |
6 | |
7 #include <stdint.h> | |
8 | |
9 #include "base/bind.h" | |
10 #include "base/macros.h" | |
11 #include "dbus/bus.h" | |
12 #include "dbus/message.h" | |
13 #include "dbus/object_path.h" | |
14 #include "dbus/object_proxy.h" | |
15 #include "third_party/cros_system_api/dbus/service_constants.h" | |
16 | |
17 namespace chromeos { | |
18 | |
19 // The BiodBiometricsManagerClient implementation used in production. | |
20 class BiodBiometricsManagerClientImpl : public BiodBiometricsManagerClient { | |
21 public: | |
22 BiodBiometricsManagerClientImpl() | |
23 : biometrics_manager_proxy_(NULL), weak_ptr_factory_(this) {} | |
stevenjb
2017/03/21 18:46:16
s/NULL/nullptr throughout
sammiequon
2017/03/21 20:50:18
Done.
| |
24 | |
25 ~BiodBiometricsManagerClientImpl() override {} | |
26 | |
27 // BiodBiometricsManagerClient overrides: | |
28 void AddObserver(Observer* observer) override { | |
29 observers_.AddObserver(observer); | |
30 } | |
31 | |
32 void RemoveObserver(Observer* observer) override { | |
33 observers_.RemoveObserver(observer); | |
34 } | |
35 | |
36 bool HasObserver(const Observer* observer) const override { | |
37 return observers_.HasObserver(observer); | |
38 } | |
39 | |
40 void StartEnrollSession(const std::string& user_id, | |
41 const std::string& label, | |
42 const ObjectPathCallback& callback) override { | |
43 dbus::MethodCall method_call( | |
44 biod::kBiometricsManagerInterface, | |
45 biod::kBiometricsManagerStartEnrollSessionMethod); | |
46 dbus::MessageWriter writer(&method_call); | |
47 writer.AppendString(user_id); | |
48 writer.AppendString(label); | |
49 | |
50 biometrics_manager_proxy_->CallMethod( | |
51 &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, | |
52 base::Bind(&BiodBiometricsManagerClientImpl::OnStartEnrollSession, | |
53 weak_ptr_factory_.GetWeakPtr(), callback)); | |
54 } | |
55 | |
56 void GetRecordsForUser(const std::string& user_id, | |
57 const ObjectPathArrayCallback& callback) override { | |
58 dbus::MethodCall method_call( | |
59 biod::kBiometricsManagerInterface, | |
60 biod::kBiometricsManagerGetRecordsForUserMethod); | |
61 dbus::MessageWriter writer(&method_call); | |
62 writer.AppendString(user_id); | |
63 | |
64 biometrics_manager_proxy_->CallMethod( | |
65 &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, | |
66 base::Bind(&BiodBiometricsManagerClientImpl::OnGetRecordsForUser, | |
67 weak_ptr_factory_.GetWeakPtr(), callback)); | |
68 } | |
69 | |
70 void DestroyAllRecords() override { | |
71 dbus::MethodCall method_call( | |
72 biod::kBiometricsManagerInterface, | |
73 biod::kBiometricsManagerDestroyAllRecordsMethod); | |
74 | |
75 biometrics_manager_proxy_->CallMethod( | |
76 &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, | |
77 dbus::ObjectProxy::EmptyResponseCallback()); | |
78 } | |
79 | |
80 void StartAuthSession(const ObjectPathCallback& callback) override { | |
81 dbus::MethodCall method_call( | |
82 biod::kBiometricsManagerInterface, | |
83 biod::kBiometricsManagerStartAuthSessionMethod); | |
84 | |
85 biometrics_manager_proxy_->CallMethod( | |
86 &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, | |
87 base::Bind(&BiodBiometricsManagerClientImpl::OnStartAuthSession, | |
88 weak_ptr_factory_.GetWeakPtr(), callback)); | |
89 } | |
90 | |
91 void GetType(const BiometricTypeCallback& callback) override { | |
92 dbus::MethodCall method_call(dbus::kDBusPropertiesInterface, | |
93 dbus::kDBusPropertiesGet); | |
94 dbus::MessageWriter writer(&method_call); | |
95 writer.AppendString(biod::kBiometricsManagerInterface); | |
96 writer.AppendString(biod::kBiometricsManagerBiometricTypeProperty); | |
97 | |
98 biometrics_manager_proxy_->CallMethod( | |
99 &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, | |
100 base::Bind(&BiodBiometricsManagerClientImpl::OnGetType, | |
101 weak_ptr_factory_.GetWeakPtr(), callback)); | |
102 } | |
103 | |
104 biod::BiometricType GetTypeBlocking() override { | |
105 dbus::MethodCall method_call(dbus::kDBusPropertiesInterface, | |
106 dbus::kDBusPropertiesGet); | |
107 dbus::MessageWriter writer(&method_call); | |
108 writer.AppendString(biod::kBiometricsManagerInterface); | |
109 writer.AppendString(biod::kBiometricsManagerBiometricTypeProperty); | |
110 | |
111 std::unique_ptr<dbus::Response> response = | |
112 biometrics_manager_proxy_->CallMethodAndBlock( | |
113 &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT); | |
114 | |
115 dbus::MessageReader reader(response.get()); | |
116 uint32_t result; | |
117 if (reader.PopVariantOfUint32(&result)) | |
118 return static_cast<biod::BiometricType>(result); | |
119 | |
120 return biod::BiometricType::BIOMETRIC_FINGERPRINT; | |
121 } | |
122 | |
123 protected: | |
124 void Init(dbus::Bus* bus) override { | |
125 biometrics_manager_proxy_ = bus->GetObjectProxy( | |
126 biod::kBiodServiceName, dbus::ObjectPath(biod::kBiodServicePath)); | |
127 | |
128 // Monitor the NameOwnerChanged signal. | |
129 biometrics_manager_proxy_->SetNameOwnerChangedCallback( | |
130 base::Bind(&BiodBiometricsManagerClientImpl::NameOwnerChangedReceived, | |
131 weak_ptr_factory_.GetWeakPtr())); | |
132 | |
133 // Monitor the D-Bus signal for enroll scans. | |
134 biometrics_manager_proxy_->ConnectToSignal( | |
135 biod::kBiometricsManagerInterface, | |
136 biod::kBiometricsManagerEnrollScanDoneSignal, | |
137 base::Bind(&BiodBiometricsManagerClientImpl::EnrollScanDoneReceived, | |
138 weak_ptr_factory_.GetWeakPtr()), | |
139 base::Bind(&BiodBiometricsManagerClientImpl::SignalConnected, | |
140 weak_ptr_factory_.GetWeakPtr())); | |
141 | |
142 // Monitor the D-Bus signal for auth scans. | |
143 biometrics_manager_proxy_->ConnectToSignal( | |
144 biod::kBiometricsManagerInterface, | |
145 biod::kBiometricsManagerAuthScanDoneSignal, | |
146 base::Bind(&BiodBiometricsManagerClientImpl::AuthScanDoneReceived, | |
147 weak_ptr_factory_.GetWeakPtr()), | |
148 base::Bind(&BiodBiometricsManagerClientImpl::SignalConnected, | |
149 weak_ptr_factory_.GetWeakPtr())); | |
150 | |
151 // Monitor the D-Bus signal for scan failures. | |
152 biometrics_manager_proxy_->ConnectToSignal( | |
153 biod::kBiometricsManagerInterface, | |
154 biod::kBiometricsManagerScanFailedSignal, | |
155 base::Bind(&BiodBiometricsManagerClientImpl::ScanFailedReceived, | |
156 weak_ptr_factory_.GetWeakPtr()), | |
157 base::Bind(&BiodBiometricsManagerClientImpl::SignalConnected, | |
158 weak_ptr_factory_.GetWeakPtr())); | |
159 } | |
160 | |
161 private: | |
162 void OnStartEnrollSession(const ObjectPathCallback& callback, | |
163 dbus::Response* response) { | |
164 dbus::MessageReader reader(response); | |
165 dbus::ObjectPath result; | |
166 if (reader.PopObjectPath(&result)) | |
167 callback.Run(result); | |
168 } | |
169 | |
170 void OnGetRecordsForUser(const ObjectPathArrayCallback& callback, | |
171 dbus::Response* response) { | |
172 dbus::MessageReader reader(response); | |
173 std::vector<dbus::ObjectPath> result; | |
174 if (reader.PopArrayOfObjectPaths(&result)) | |
175 callback.Run(result); | |
176 } | |
177 | |
178 void OnStartAuthSession(const ObjectPathCallback& callback, | |
179 dbus::Response* response) { | |
180 dbus::MessageReader reader(response); | |
181 dbus::ObjectPath result; | |
182 if (reader.PopObjectPath(&result)) | |
183 callback.Run(result); | |
184 } | |
185 | |
186 void OnGetType(const BiometricTypeCallback& callback, | |
187 dbus::Response* response) { | |
188 dbus::MessageReader reader(response); | |
189 uint32_t result; | |
190 if (reader.PopVariantOfUint32(&result)) | |
191 callback.Run(static_cast<biod::BiometricType>(result)); | |
192 } | |
193 | |
194 // Called when the biometrics signal is initially connected. | |
195 void SignalConnected(const std::string& interface_name, | |
stevenjb
2017/03/21 18:46:16
nit: OnSignalConnected
sammiequon
2017/03/21 20:50:18
Done.
| |
196 const std::string& signal_name, | |
197 bool success) { | |
198 LOG_IF(ERROR, !success) | |
199 << "Failed to connect to biometrics signal:" << signal_name; | |
200 } | |
201 | |
202 void NameOwnerChangedReceived(const std::string& old_owner, | |
203 const std::string& new_owner) { | |
204 for (auto& observer : observers_) | |
205 observer.ClientRestarted(); | |
206 } | |
207 | |
208 void EnrollScanDoneReceived(dbus::Signal* signal) { | |
209 dbus::MessageReader reader(signal); | |
210 uint32_t scan_result; | |
211 bool is_complete; | |
212 if (!reader.PopUint32(&scan_result) || !reader.PopBool(&is_complete)) { | |
213 LOG(ERROR) << "Error reading signal from biometrics:" | |
214 << signal->ToString(); | |
215 return; | |
216 } | |
217 | |
218 for (auto& observer : observers_) | |
219 observer.EnrollScanDoneReceived(scan_result, is_complete); | |
220 } | |
221 | |
222 void AuthScanDoneReceived(dbus::Signal* signal) { | |
223 dbus::MessageReader signal_reader(signal); | |
224 dbus::MessageReader array_reader(NULL); | |
225 uint32_t scan_result; | |
226 AuthScanMatches matches; | |
227 if (!signal_reader.PopUint32(&scan_result) || | |
228 !signal_reader.PopArray(&array_reader)) { | |
229 LOG(ERROR) << "Error reading signal from biometrics:" | |
230 << signal->ToString(); | |
231 return; | |
232 } | |
233 | |
234 while (array_reader.HasMoreData()) { | |
235 dbus::MessageReader entry_reader(NULL); | |
236 std::string user_id; | |
237 std::vector<std::string> labels; | |
238 if (!array_reader.PopDictEntry(&entry_reader) || | |
239 !entry_reader.PopString(&user_id) || | |
240 !entry_reader.PopArrayOfStrings(&labels)) { | |
241 LOG(ERROR) << "Error reading signal from biometrics:" | |
242 << signal->ToString(); | |
243 return; | |
244 } | |
245 | |
246 matches[user_id] = labels; | |
stevenjb
2017/03/21 18:46:16
I think you can use std::move(labels) here to avoi
sammiequon
2017/03/21 20:50:18
Done.
| |
247 } | |
248 | |
249 for (auto& observer : observers_) | |
250 observer.AuthScanDoneReceived(scan_result, matches); | |
251 } | |
252 | |
253 void ScanFailedReceived(dbus::Signal* signal) { | |
254 for (auto& observer : observers_) | |
255 observer.ScanFailedReceived(); | |
256 } | |
257 | |
258 dbus::ObjectProxy* biometrics_manager_proxy_; | |
259 base::ObserverList<Observer> observers_; | |
260 | |
261 // Note: This should remain the last member so it'll be destroyed and | |
262 // invalidate its weak pointers before any other members are destroyed. | |
263 base::WeakPtrFactory<BiodBiometricsManagerClientImpl> weak_ptr_factory_; | |
264 | |
265 DISALLOW_COPY_AND_ASSIGN(BiodBiometricsManagerClientImpl); | |
266 }; | |
267 | |
268 BiodBiometricsManagerClient::BiodBiometricsManagerClient() {} | |
269 | |
270 BiodBiometricsManagerClient::~BiodBiometricsManagerClient() {} | |
271 | |
272 // static | |
273 BiodBiometricsManagerClient* BiodBiometricsManagerClient::Create( | |
274 DBusClientImplementationType /* type */) { | |
275 return new BiodBiometricsManagerClientImpl(); | |
276 } | |
277 | |
278 } // namespace chromeos | |
OLD | NEW |