cros: DBUS client to interact with fingerprint DBUS API.

chromeos/dbus/biod/biod_biometrics_manager_client.cc

+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chromeos/dbus/biod/biod_biometrics_manager_client.h"
+
+#include <stdint.h>
+
+#include "base/bind.h"
+#include "base/macros.h"
+#include "dbus/bus.h"
+#include "dbus/message.h"
+#include "dbus/object_path.h"
+#include "dbus/object_proxy.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+
+// The BiodBiometricsManagerClient implementation used in production.
+class BiodBiometricsManagerClientImpl : public BiodBiometricsManagerClient {
+ public:
+  BiodBiometricsManagerClientImpl()
+      : biometrics_manager_proxy_(nullptr), weak_ptr_factory_(this) {}
+
+  ~BiodBiometricsManagerClientImpl() override {}
+
+  // BiodBiometricsManagerClient overrides:
+  void AddObserver(Observer* observer) override {
+    observers_.AddObserver(observer);
+  }
+
+  void RemoveObserver(Observer* observer) override {
+    observers_.RemoveObserver(observer);
+  }
+
+  bool HasObserver(const Observer* observer) const override {
+    return observers_.HasObserver(observer);
+  }
+
+  void StartEnrollSession(const std::string& user_id,
+                          const std::string& label,
+                          const ObjectPathCallback& callback) override {
+    dbus::MethodCall method_call(
+        biod::kBiometricsManagerInterface,
+        biod::kBiometricsManagerStartEnrollSessionMethod);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(user_id);
+    writer.AppendString(label);
+
+    biometrics_manager_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BiodBiometricsManagerClientImpl::OnStartEnrollSession,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
+  void GetRecordsForUser(const std::string& user_id,
+                         const UserRecordsCallback& callback) override {
+    dbus::MethodCall method_call(
+        biod::kBiometricsManagerInterface,
+        biod::kBiometricsManagerGetRecordsForUserMethod);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(user_id);
+
+    biometrics_manager_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BiodBiometricsManagerClientImpl::OnGetRecordsForUser,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
+  void DestroyAllRecords() override {
+    dbus::MethodCall method_call(
+        biod::kBiometricsManagerInterface,
+        biod::kBiometricsManagerDestroyAllRecordsMethod);
+
+    biometrics_manager_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        dbus::ObjectProxy::EmptyResponseCallback());
+  }
+
+  void StartAuthSession(const ObjectPathCallback& callback) override {
+    dbus::MethodCall method_call(
+        biod::kBiometricsManagerInterface,
+        biod::kBiometricsManagerStartAuthSessionMethod);
+
+    biometrics_manager_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BiodBiometricsManagerClientImpl::OnStartAuthSession,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
+  void RequestType(const BiometricTypeCallback& callback) override {
+    dbus::MethodCall method_call(dbus::kDBusPropertiesInterface,
+                                 dbus::kDBusPropertiesGet);
+    dbus::MessageWriter writer(&method_call);
+    writer.AppendString(biod::kBiometricsManagerInterface);
+    writer.AppendString(biod::kBiometricsManagerBiometricTypeProperty);
+
+    biometrics_manager_proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&BiodBiometricsManagerClientImpl::OnRequestType,
+                   weak_ptr_factory_.GetWeakPtr(), callback));
+  }
+
+ protected:
+  void Init(dbus::Bus* bus) override {
+    biometrics_manager_proxy_ = bus->GetObjectProxy(
+        biod::kBiodServiceName, dbus::ObjectPath(biod::kBiodServicePath));

[Daniel Erat, 2017/03/29 22:11:57]

i think that this part is wrong. this class is supposed to communicate with an
individual BiometricsManager object exported by biod, not with the central biod
object.

[sammiequon, 2017/03/30 00:22:27]

If we are going with the possible single BiometricsManager instead of the
BiodManager is this still incorrect?

[Daniel Erat, 2017/03/30 00:25:38]

nope, it's correct then.

this class should probably also just be renamed to BiodClient in that case -- i
don't see any reason to retain the extra "manager" wordiness if there's just one
service.

i'd recommend figuring out the biod side of the interface before making any more
changes here, though -- any simplification you can do on the service side will
probably make this chrome code simpler too.

+
+    biometrics_manager_proxy_->SetNameOwnerChangedCallback(
+        base::Bind(&BiodBiometricsManagerClientImpl::NameOwnerChangedReceived,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    biometrics_manager_proxy_->ConnectToSignal(
+        biod::kBiometricsManagerInterface,
+        biod::kBiometricsManagerEnrollScanDoneSignal,
+        base::Bind(&BiodBiometricsManagerClientImpl::EnrollScanDoneReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&BiodBiometricsManagerClientImpl::OnSignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    biometrics_manager_proxy_->ConnectToSignal(
+        biod::kBiometricsManagerInterface,
+        biod::kBiometricsManagerAuthScanDoneSignal,
+        base::Bind(&BiodBiometricsManagerClientImpl::AuthScanDoneReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&BiodBiometricsManagerClientImpl::OnSignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+
+    biometrics_manager_proxy_->ConnectToSignal(
+        biod::kBiometricsManagerInterface,
+        biod::kBiometricsManagerSessionFailedSignal,
+        base::Bind(&BiodBiometricsManagerClientImpl::SessionFailedReceived,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&BiodBiometricsManagerClientImpl::OnSignalConnected,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
+ private:
+  void OnStartEnrollSession(const ObjectPathCallback& callback,
+                            dbus::Response* response) {
+    dbus::ObjectPath result;
+    if (!response) {
+      LOG(ERROR) << "Failed to get response for "

[Daniel Erat, 2017/03/28 00:14:34]

you can remove the LOG(ERROR)s in the response-is-null cases.
ObjectProxy::CallMethod will already log this for you.

[sammiequon, 2017/03/28 01:31:05]

Done.

+                 << biod::kBiometricsManagerStartEnrollSessionMethod
+                 << " request.";
+      callback.Run(result);
+      return;
+    }
+
+    dbus::MessageReader reader(response);
+    if (!reader.PopObjectPath(&result)) {
+      LOG(ERROR) << biod::kBiometricsManagerStartEnrollSessionMethod
+                 << " had incorrect response.";
+      callback.Run(result);
+      return;
+    }
+
+    callback.Run(result);
+  }
+
+  void OnGetRecordsForUser(const UserRecordsCallback& callback,
+                           dbus::Response* response) {
+    std::vector<dbus::ObjectPath> result;
+    if (!response) {
+      LOG(ERROR) << "Failed to get response for "
+                 << biod::kBiometricsManagerGetRecordsForUserMethod
+                 << " request.";
+      callback.Run(result);
+      return;
+    }
+
+    dbus::MessageReader reader(response);
+    if (!reader.PopArrayOfObjectPaths(&result)) {
+      LOG(ERROR) << biod::kBiometricsManagerGetRecordsForUserMethod
+                 << " had incorrect response.";
+      callback.Run(result);
+      return;
+    }
+
+    callback.Run(result);
+  }
+
+  void OnStartAuthSession(const ObjectPathCallback& callback,
+                          dbus::Response* response) {
+    dbus::ObjectPath result;
+    if (!response) {
+      LOG(ERROR) << "Failed to get response for "
+                 << biod::kBiometricsManagerStartAuthSessionMethod
+                 << " request.";
+      callback.Run(result);
+      return;
+    }
+
+    dbus::MessageReader reader(response);
+    if (!reader.PopObjectPath(&result)) {
+      LOG(ERROR) << biod::kBiometricsManagerStartAuthSessionMethod
+                 << " had incorrect response.";
+      callback.Run(result);
+      return;
+    }
+
+    callback.Run(result);
+  }
+
+  void OnRequestType(const BiometricTypeCallback& callback,
+                     dbus::Response* response) {
+    uint32_t result;
+    if (!response) {
+      LOG(ERROR) << "Failed to get response for "
+                 << biod::kBiometricsManagerBiometricTypeProperty
+                 << " request.";
+      callback.Run(biod::BiometricType::BIOMETRIC_TYPE_UNKNOWN);
+      return;
+    }
+
+    dbus::MessageReader reader(response);
+    if (!reader.PopVariantOfUint32(&result)) {
+      LOG(ERROR) << biod::kBiometricsManagerBiometricTypeProperty
+                 << " had incorrect response.";
+      callback.Run(biod::BiometricType::BIOMETRIC_TYPE_UNKNOWN);
+      return;
+    }
+
+    callback.Run(static_cast<biod::BiometricType>(result));
+  }
+
+  // Called when the biometrics signal is initially connected.
+  void OnSignalConnected(const std::string& interface_name,
+                         const std::string& signal_name,
+                         bool success) {
+    LOG_IF(ERROR, !success)
+        << "Failed to connect to biometrics signal:" << signal_name;
+  }
+
+  void NameOwnerChangedReceived(const std::string& /* old_owner */,
+                                const std::string& new_owner) {
+    if (!new_owner.empty()) {
+      for (auto& observer : observers_)
+        observer.BiodServiceRestarted();
+    }
+  }
+
+  void EnrollScanDoneReceived(dbus::Signal* signal) {
+    dbus::MessageReader reader(signal);
+    uint32_t scan_result;
+    bool is_complete;
+    if (!reader.PopUint32(&scan_result) || !reader.PopBool(&is_complete)) {
+      LOG(ERROR) << "Error reading signal from biometrics:"
+                 << signal->ToString();
+      return;
+    }
+
+    for (auto& observer : observers_) {
+      observer.BiodEnrollScanDoneReceived(
+          static_cast<biod::ScanResult>(scan_result), is_complete);
+    }
+  }
+
+  void AuthScanDoneReceived(dbus::Signal* signal) {
+    dbus::MessageReader signal_reader(signal);
+    dbus::MessageReader array_reader(nullptr);
+    uint32_t scan_result;
+    AuthScanMatches matches;
+    if (!signal_reader.PopUint32(&scan_result) ||
+        !signal_reader.PopArray(&array_reader)) {
+      LOG(ERROR) << "Error reading signal from biometrics:"
+                 << signal->ToString();
+      return;
+    }
+
+    while (array_reader.HasMoreData()) {
+      dbus::MessageReader entry_reader(nullptr);
+      std::string user_id;
+      std::vector<std::string> labels;
+      if (!array_reader.PopDictEntry(&entry_reader) ||
+          !entry_reader.PopString(&user_id) ||
+          !entry_reader.PopArrayOfStrings(&labels)) {
+        LOG(ERROR) << "Error reading signal from biometrics:"
+                   << signal->ToString();
+        return;
+      }
+
+      matches[user_id] = std::move(labels);
+    }
+
+    for (auto& observer : observers_) {
+      observer.BiodAuthScanDoneReceived(
+          static_cast<biod::ScanResult>(scan_result), matches);
+    }
+  }
+
+  void SessionFailedReceived(dbus::Signal* signal) {
+    for (auto& observer : observers_)
+      observer.BiodSessionFailedReceived();
+  }
+
+  dbus::ObjectProxy* biometrics_manager_proxy_;
+  base::ObserverList<Observer> observers_;
+
+  // Note: This should remain the last member so it'll be destroyed and
+  // invalidate its weak pointers before any other members are destroyed.
+  base::WeakPtrFactory<BiodBiometricsManagerClientImpl> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BiodBiometricsManagerClientImpl);
+};
+
+BiodBiometricsManagerClient::BiodBiometricsManagerClient() {}
+
+BiodBiometricsManagerClient::~BiodBiometricsManagerClient() {}
+
+// static
+BiodBiometricsManagerClient* BiodBiometricsManagerClient::Create(
+    DBusClientImplementationType /* type */) {
+  return new BiodBiometricsManagerClientImpl();
+}
+
+}  // namespace chromeos