diff --git a/binder_service.cc b/binder_service.cc
index f412d42..19acf6e 100644
--- a/binder_service.cc
+++ b/binder_service.cc
@@ -16,37 +16,156 @@
 
 #include "update_engine/binder_service.h"
 
-using android::OK;
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+
 using android::String16;
-using android::os::IUpdateEngineCallback;
-using android::sp;
+using android::String8;
 using android::binder::Status;
-using std::vector;
+using android::brillo::IUpdateEngineStatusCallback;
+using android::brillo::ParcelableUpdateEngineStatus;
+using android::sp;
+using brillo::ErrorPtr;
+using std::string;
 
 namespace chromeos_update_engine {
 
-Status BinderService::bind(
-    const sp<IUpdateEngineCallback>& callback,
-    bool* return_value) {
-  *return_value = true;
-  return Status::ok();
+namespace {
+string NormalString(const String16& in) {
+  return string{String8{in}.string()};
 }
 
-Status BinderService::applyPayload(
-    const String16& url,
-    const vector<String16>& header_kv_pairs) {
-  return Status::ok();
+Status ToStatus(ErrorPtr* error) {
+  return Status::fromServiceSpecificError(
+      1, String8{error->get()->GetMessage().c_str()});
+}
+}  // namespace
+
+template<typename... Parameters, typename... Arguments>
+Status BinderUpdateEngineService::CallCommonHandler(
+    bool (UpdateEngineService::*Handler)(ErrorPtr*, Parameters...),
+    Arguments... arguments) {
+  ErrorPtr error;
+  if (((common_.get())->*Handler)(&error, arguments...)) return Status::ok();
+  return ToStatus(&error);
 }
 
-Status BinderService::suspend() {
-  return Status::ok();
+Status BinderUpdateEngineService::AttemptUpdate(const String16& app_version,
+                                                const String16& omaha_url,
+                                                int flags) {
+  return CallCommonHandler(
+      &UpdateEngineService::AttemptUpdate, NormalString(app_version),
+      NormalString(omaha_url), flags);
 }
 
-Status BinderService::resume() {
-  return Status::ok();
+Status BinderUpdateEngineService::AttemptRollback(bool powerwash) {
+  return CallCommonHandler(&UpdateEngineService::AttemptRollback, powerwash);
 }
 
-Status BinderService::cancel() {
+Status BinderUpdateEngineService::CanRollback(bool* out_can_rollback) {
+  return CallCommonHandler(&UpdateEngineService::CanRollback,
+                           out_can_rollback);
+}
+
+Status BinderUpdateEngineService::ResetStatus() {
+  return CallCommonHandler(&UpdateEngineService::ResetStatus);
+}
+
+Status BinderUpdateEngineService::GetStatus(
+    ParcelableUpdateEngineStatus* status) {
+  string current_op;
+  string new_version;
+
+  auto ret = CallCommonHandler(&UpdateEngineService::GetStatus,
+                      &status->last_checked_time_,
+                      &status->progress_,
+                      &current_op,
+                      &new_version,
+                      &status->new_size_);
+
+  if (ret.isOk()) {
+    status->current_operation_ = String16{current_op.c_str()};
+    status->new_version_ = String16{new_version.c_str()};
+  }
+
+  return ret;
+}
+
+Status BinderUpdateEngineService::RebootIfNeeded() {
+  return CallCommonHandler(&UpdateEngineService::RebootIfNeeded);
+}
+
+Status BinderUpdateEngineService::SetChannel(const String16& target_channel,
+                                             bool powerwash) {
+  return CallCommonHandler(&UpdateEngineService::SetChannel,
+                           NormalString(target_channel), powerwash);
+}
+
+Status BinderUpdateEngineService::GetChannel(bool get_current_channel,
+                                             String16* out_channel) {
+  string channel_string;
+  auto ret = CallCommonHandler(&UpdateEngineService::GetChannel,
+                               get_current_channel,
+                               &channel_string);
+
+  *out_channel = String16(channel_string.c_str());
+  return ret;
+}
+
+Status BinderUpdateEngineService::SetP2PUpdatePermission(bool enabled) {
+  return CallCommonHandler(&UpdateEngineService::SetP2PUpdatePermission,
+                           enabled);
+}
+
+Status BinderUpdateEngineService::GetP2PUpdatePermission(
+    bool* out_p2p_permission) {
+  return CallCommonHandler(&UpdateEngineService::GetP2PUpdatePermission,
+                           out_p2p_permission);
+}
+
+Status BinderUpdateEngineService::SetUpdateOverCellularPermission(
+    bool enabled) {
+  return CallCommonHandler(
+      &UpdateEngineService::SetUpdateOverCellularPermission, enabled);
+}
+
+Status BinderUpdateEngineService::GetUpdateOverCellularPermission(
+    bool* out_cellular_permission) {
+  return CallCommonHandler(
+      &UpdateEngineService::GetUpdateOverCellularPermission,
+      out_cellular_permission);
+}
+
+Status BinderUpdateEngineService::GetDurationSinceUpdate(
+    int64_t* out_duration) {
+  return CallCommonHandler(&UpdateEngineService::GetDurationSinceUpdate,
+                           out_duration);
+}
+
+Status BinderUpdateEngineService::GetPrevVersion(String16* out_prev_version) {
+  string version_string;
+  auto ret = CallCommonHandler(&UpdateEngineService::GetPrevVersion,
+                               &version_string);
+
+  *out_prev_version = String16(version_string.c_str());
+  return ret;
+}
+
+Status BinderUpdateEngineService::GetRollbackPartition(
+    String16* out_rollback_partition) {
+  string partition_string;
+  auto ret = CallCommonHandler(&UpdateEngineService::GetRollbackPartition,
+                               &partition_string);
+
+  if (ret.isOk()) {
+    *out_rollback_partition = String16(partition_string.c_str());
+  }
+
+  return ret;
+}
+
+Status BinderUpdateEngineService::RegisterStatusCallback(
+    const sp<IUpdateEngineStatusCallback>& callback) {
   return Status::ok();
 }