ledflasher: Switch to Binder-based weaved library

Weave daemon now uses Binder as the underlying transport and its
client library has been updated. Update ledflasher to support the
new APIs.

BUG: 23782171
Change-Id: I19b2a6699f39f9f621ab201fab4ec89da20e71ff

3 files changed, 56 insertions, 37 deletions

diff --git a/sepolicy/ledflasher.te b/sepolicy/ledflasher.te
index 232aa34..9a3f2c9 100644
--- a/sepolicy/ledflasher.te
+++ b/sepolicy/ledflasher.te
@@ -4,3 +4,4 @@ type ledflasher_exec, exec_type, file_type;
 
 brillo_domain(ledflasher)
 allow_crash_reporter(ledflasher)
+allow_weave_service(ledflasher)
diff --git a/src/ledflasher/Android.mk b/src/ledflasher/Android.mk
index eea3ac9..8c21934 100644
--- a/src/ledflasher/Android.mk
+++ b/src/ledflasher/Android.mk
@@ -26,7 +26,9 @@ LOCAL_SRC_FILES := \
 	ledflasher.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
+	libbinder \
 	libbrillo \
+	libbrillo-binder \
 	libbrillo-dbus \
 	libbrillo-stream \
 	libchrome \
diff --git a/src/ledflasher/ledflasher.cpp b/src/ledflasher/ledflasher.cpp
index 7c60a4d..fb46bcf 100644
--- a/src/ledflasher/ledflasher.cpp
+++ b/src/ledflasher/ledflasher.cpp
@@ -20,9 +20,11 @@
 #include <base/bind.h>
 #include <base/command_line.h>
 #include <base/macros.h>
+#include <base/memory/weak_ptr.h>
+#include <brillo/binder_watcher.h>
 #include <brillo/daemons/dbus_daemon.h>
 #include <brillo/syslog_logging.h>
-#include <libweaved/device.h>
+#include <libweaved/service.h>
 
 #include "animation.h"
 #include "ledservice/dbus-proxies.h"
@@ -41,19 +43,20 @@ class Daemon final : public brillo::DBusDaemon {
   int OnInit() override;
 
  private:
+  void OnWeaveServiceConnected(const std::weak_ptr<weaved::Service>& service);
   void OnLEDServiceConnected(ServiceProxyInterface* service);
   void OnLEDServiceDisconnected(const dbus::ObjectPath& object_path);
 
   // Particular command handlers for various commands.
-  void OnSet(const std::weak_ptr<weaved::Command>& cmd);
-  void OnToggle(const std::weak_ptr<weaved::Command>& cmd);
-  void OnAnimate(const std::weak_ptr<weaved::Command>& cmd);
+  void OnSet(std::unique_ptr<weaved::Command> command);
+  void OnToggle(std::unique_ptr<weaved::Command> command);
+  void OnAnimate(std::unique_ptr<weaved::Command> command);
 
   // Helper methods to propagate device state changes to Buffet and hence to
   // the cloud server or local clients.
   void UpdateDeviceState();
 
-  std::unique_ptr<weaved::Device> device_;
+  std::weak_ptr<weaved::Service> service_;
 
   // LEDService's D-Bus object manager.
   std::unique_ptr<com::android::LEDService::ObjectManagerProxy> led_object_mgr_;
@@ -67,6 +70,10 @@ class Daemon final : public brillo::DBusDaemon {
   // Current animation;
   std::unique_ptr<Animation> animation_;
 
+  brillo::BinderWatcher binder_watcher_;
+  std::unique_ptr<weaved::Service::Subscription> weave_service_subscription_;
+
+  base::WeakPtrFactory<Daemon> weak_ptr_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(Daemon);
 };
 
@@ -75,21 +82,13 @@ int Daemon::OnInit() {
   if (return_code != EX_OK)
     return return_code;
 
-  device_ = weaved::Device::CreateInstance(
-      bus_, base::Bind(&Daemon::UpdateDeviceState, base::Unretained(this)));
-  device_->AddComponent(kWeaveComponent, {"_ledflasher"});
-  device_->AddCommandHandler(
-      kWeaveComponent,
-      "_ledflasher.set",
-      base::Bind(&Daemon::OnSet, base::Unretained(this)));
-  device_->AddCommandHandler(
-      kWeaveComponent,
-      "_ledflasher.toggle",
-      base::Bind(&Daemon::OnToggle, base::Unretained(this)));
-  device_->AddCommandHandler(
-      kWeaveComponent,
-      "_ledflasher.animate",
-      base::Bind(&Daemon::OnAnimate, base::Unretained(this)));
+  if (!binder_watcher_.Init())
+    return EX_OSERR;
+
+  weave_service_subscription_ = weaved::Service::Connect(
+      brillo::MessageLoop::current(),
+      base::Bind(&Daemon::OnWeaveServiceConnected,
+                 weak_ptr_factory_.GetWeakPtr()));
 
   led_object_mgr_.reset(new com::android::LEDService::ObjectManagerProxy{bus_});
   led_object_mgr_->SetServiceAddedCallback(
@@ -101,21 +100,42 @@ int Daemon::OnInit() {
   return EX_OK;
 }
 
+void Daemon::OnWeaveServiceConnected(
+    const std::weak_ptr<weaved::Service>& service) {
+  LOG(INFO) << "Daemon::OnWeaveServiceConnected";
+  service_ = service;
+  auto weave_service = service.lock();
+  if (!weave_service)
+    return;
+
+  weave_service->AddComponent(kWeaveComponent, {"_ledflasher"}, nullptr);
+  weave_service->AddCommandHandler(
+      kWeaveComponent,
+      "_ledflasher.set",
+      base::Bind(&Daemon::OnSet, weak_ptr_factory_.GetWeakPtr()));
+  weave_service->AddCommandHandler(
+      kWeaveComponent,
+      "_ledflasher.toggle",
+      base::Bind(&Daemon::OnToggle, weak_ptr_factory_.GetWeakPtr()));
+  weave_service->AddCommandHandler(
+      kWeaveComponent,
+      "_ledflasher.animate",
+      base::Bind(&Daemon::OnAnimate, weak_ptr_factory_.GetWeakPtr()));
+
+  UpdateDeviceState();
+}
+
 void Daemon::OnLEDServiceConnected(ServiceProxyInterface* service) {
   led_service_ = service;
   UpdateDeviceState();
 }
 
-void Daemon::OnLEDServiceDisconnected(const dbus::ObjectPath& object_path) {
+void Daemon::OnLEDServiceDisconnected(const dbus::ObjectPath& /*object_path*/) {
   animation_.reset();
   led_service_ = nullptr;
 }
 
-void Daemon::OnSet(const std::weak_ptr<weaved::Command>& cmd) {
-  auto command = cmd.lock();
-  if (!command)
-    return;
-
+void Daemon::OnSet(std::unique_ptr<weaved::Command> command) {
   if (!led_service_) {
     command->Abort("system_error", "ledservice unavailable", nullptr);
     return;
@@ -138,11 +158,7 @@ void Daemon::OnSet(const std::weak_ptr<weaved::Command>& cmd) {
   command->Complete({}, nullptr);
 }
 
-void Daemon::OnToggle(const std::weak_ptr<weaved::Command>& cmd) {
-  auto command = cmd.lock();
-  if (!command)
-    return;
-
+void Daemon::OnToggle(std::unique_ptr<weaved::Command> command) {
   if (!led_service_) {
     command->Abort("system_error", "ledservice unavailable", nullptr);
     return;
@@ -167,11 +183,7 @@ void Daemon::OnToggle(const std::weak_ptr<weaved::Command>& cmd) {
   command->Complete({}, nullptr);
 }
 
-void Daemon::OnAnimate(const std::weak_ptr<weaved::Command>& cmd) {
-  auto command = cmd.lock();
-  if (!command)
-    return;
-
+void Daemon::OnAnimate(std::unique_ptr<weaved::Command> command) {
   if (!led_service_) {
     command->Abort("system_error", "ledservice unavailable", nullptr);
     return;
@@ -203,13 +215,17 @@ void Daemon::UpdateDeviceState() {
   if (!led_service_->GetAllLEDs(&leds, nullptr))
     return;
 
+  auto weave_service = service_.lock();
+  if (!weave_service)
+    return;
+
   brillo::VariantDictionary state_change{
     {"_ledflasher.status", status_},
     {"_ledflasher.leds", leds},
   };
   // TODO: Come up with a design for ledflasher.cpp such that this call never
   // fails.
-  device_->SetStateProperties(kWeaveComponent, state_change, nullptr);
+  weave_service->SetStateProperties(kWeaveComponent, state_change, nullptr);
 }
 
 int main(int argc, char* argv[]) {