Refactor daemon state and service async notification.
There are three supported IPC mechanism in this code: DBus, binder and
weave (over binder); which are mostly supported by all three platforms
Chrome OS, Brillo and Android. The exceptions are that Brillo and
Chrome OS still *require* DBus and support the others, while the new
Android daemon requires and supports only Binder.
This CL introduces two new interfaces: the ServiceObserverInterface and
the DaemonStateInterface.
The first one abstracts a service (or IPC service) into an interfcae
from the point of view of the daemon initialization and async
notifications of status changes. The second interface encapsulates the
state and main functionality of the update_engine daemon while leaving
the shared initialization in the main.cc and daemon.cc classes.
Bug: 25631949
TEST=`mmma system/update_engine` on edison-eng and aosp_arm-eng
TEST=FEATURES=test emerge-link update_engine
Change-Id: Ic15621031a153e14bdc4df8fcedbca1032e82c21
diff --git a/Android.mk b/Android.mk
index fe03b24..04ecfe5 100644
--- a/Android.mk
+++ b/Android.mk
@@ -224,7 +224,7 @@
LOCAL_SRC_FILES := $(ue_libpayload_consumer_src_files)
include $(BUILD_STATIC_LIBRARY)
-ifeq ($(local_use_dbus),1)
+ifdef BRILLO
# libupdate_engine (type: static_library)
# ========================================================
@@ -337,7 +337,7 @@
LOCAL_SRC_FILES += \
binder_bindings/android/brillo/IUpdateEngine.aidl \
binder_bindings/android/brillo/IUpdateEngineStatusCallback.aidl \
- binder_service.cc \
+ binder_service_brillo.cc \
parcelable_update_engine_status.cc
endif # local_use_binder == 1
ifeq ($(local_use_weave),1)
@@ -346,7 +346,50 @@
endif # local_use_weave == 1
include $(BUILD_STATIC_LIBRARY)
-endif # local_use_dbus == 1
+else # !defined(BRILLO)
+
+ifneq ($(local_use_binder),1)
+$(error USE_BINDER is disabled but is required in non-Brillo devices.)
+endif # local_use_binder == 1
+
+# libupdate_engine_android (type: static_library)
+# ========================================================
+# The main daemon static_library used in Android (non-Brillo). This only has a
+# loop to apply payloads provided by the upper layer via a Binder interface.
+ue_libupdate_engine_android_exported_static_libraries := \
+ libpayload_consumer \
+ $(ue_libpayload_consumer_exported_static_libraries)
+ue_libupdate_engine_android_exported_shared_libraries := \
+ $(ue_libpayload_consumer_exported_shared_libraries) \
+ libbinder \
+ libbinderwrapper \
+ libbrillo-binder \
+ libutils
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libupdate_engine_android
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_CLANG := true
+LOCAL_CFLAGS := $(ue_common_cflags)
+LOCAL_CPPFLAGS := $(ue_common_cppflags)
+LOCAL_LDFLAGS := $(ue_common_ldflags)
+LOCAL_C_INCLUDES := $(ue_common_c_includes)
+LOCAL_STATIC_LIBRARIES := \
+ $(ue_libupdate_engine_android_exported_static_libraries:-host=)
+LOCAL_SHARED_LIBRARIES += \
+ $(ue_common_shared_libraries) \
+ $(ue_libupdate_engine_android_exported_shared_libraries:-host=)
+LOCAL_AIDL_INCLUDES := $(LOCAL_PATH)/binder_bindings
+LOCAL_SRC_FILES += \
+ binder_bindings/android/os/IUpdateEngine.aidl \
+ binder_bindings/android/os/IUpdateEngineCallback.aidl \
+ binder_service_android.cc \
+ daemon.cc \
+ daemon_state_android.cc
+include $(BUILD_STATIC_LIBRARY)
+
+endif # !defined(BRILLO)
# update_engine (type: executable)
# ========================================================
@@ -381,28 +424,12 @@
LOCAL_SHARED_LIBRARIES += \
$(ue_libupdate_engine_exported_shared_libraries:-host=)
else # !defined(BRILLO)
-LOCAL_AIDL_INCLUDES := $(LOCAL_PATH)/binder_bindings
LOCAL_STATIC_LIBRARIES := \
- libpayload_consumer \
- $(ue_libpayload_consumer_exported_static_libraries:-host=)
+ libupdate_engine_android \
+ $(ue_libupdate_engine_android_exported_static_libraries:-host=)
LOCAL_SHARED_LIBRARIES += \
- $(ue_libpayload_consumer_exported_shared_libraries:-host=) \
- libbinder \
- libbrillo-binder \
- libutils
-LOCAL_SRC_FILES += \
- binder_bindings/android/os/IUpdateEngine.aidl \
- binder_bindings/android/os/IUpdateEngineCallback.aidl \
- binder_service_android.cc \
- daemon.cc
-endif # defined(BRILLO)
-
-ifeq ($(local_use_binder),1)
-LOCAL_SHARED_LIBRARIES += \
- libbinder \
- libbinderwrapper \
- libutils
-endif # local_use_binder == 1
+ $(ue_libupdate_engine_android_exported_shared_libraries:-host=)
+endif # !defined(BRILLO)
LOCAL_INIT_RC := update_engine.rc
include $(BUILD_EXECUTABLE)
diff --git a/binder_service.cc b/binder_service.cc
deleted file mode 100644
index 07ff22d..0000000
--- a/binder_service.cc
+++ /dev/null
@@ -1,212 +0,0 @@
-//
-// Copyright (C) 2015 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "update_engine/binder_service.h"
-
-#include <base/bind.h>
-
-#include <binderwrapper/binder_wrapper.h>
-
-#include <utils/String16.h>
-#include <utils/StrongPointer.h>
-
-using android::String16;
-using android::String8;
-using android::binder::Status;
-using android::brillo::IUpdateEngineStatusCallback;
-using android::brillo::ParcelableUpdateEngineStatus;
-using android::sp;
-using brillo::ErrorPtr;
-using std::string;
-
-namespace chromeos_update_engine {
-
-namespace {
-string NormalString(const String16& in) {
- return string{String8{in}.string()};
-}
-
-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 BinderUpdateEngineService::AttemptUpdate(const String16& app_version,
- const String16& omaha_url,
- int flags) {
- return CallCommonHandler(
- &UpdateEngineService::AttemptUpdate, NormalString(app_version),
- NormalString(omaha_url), flags);
-}
-
-Status BinderUpdateEngineService::AttemptRollback(bool powerwash) {
- return CallCommonHandler(&UpdateEngineService::AttemptRollback, powerwash);
-}
-
-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_,
- ¤t_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) {
- callbacks_.emplace_back(callback);
-
- auto binder_wrapper = android::BinderWrapper::Get();
-
- binder_wrapper->RegisterForDeathNotifications(
- IUpdateEngineStatusCallback::asBinder(callback),
- base::Bind(&BinderUpdateEngineService::UnregisterStatusCallback,
- base::Unretained(this), base::Unretained(callback.get())));
-
- return Status::ok();
-}
-
-void BinderUpdateEngineService::UnregisterStatusCallback(
- IUpdateEngineStatusCallback* callback) {
- auto it = callbacks_.begin();
-
- for (; it != callbacks_.end() && it->get() != callback; it++)
- ;
-
- if (it == callbacks_.end()) {
- LOG(ERROR) << "Got death notification for unknown callback.";
- return;
- }
-
- LOG(INFO) << "Erasing orphan callback";
- callbacks_.erase(it);
-}
-
-void BinderUpdateEngineService::SendStatusUpdate(
- int64_t in_last_checked_time, double in_progress,
- const std::string& in_current_operation, const std::string& in_new_version,
- int64_t in_new_size) {
- for (auto& callback : callbacks_) {
- callback->HandleStatusUpdate(in_last_checked_time, in_progress,
- String16{in_current_operation.c_str()},
- String16{in_new_version.c_str()}, in_new_size);
- }
-}
-
-} // namespace chromeos_update_engine
diff --git a/binder_service_android.cc b/binder_service_android.cc
index c512697..144836a 100644
--- a/binder_service_android.cc
+++ b/binder_service_android.cc
@@ -24,6 +24,20 @@
namespace chromeos_update_engine {
+BinderUpdateEngineAndroidService::BinderUpdateEngineAndroidService(
+ DaemonStateAndroid* /* daemon_state */) {
+ // TODO(deymo): Hook this interface calls to the daemon_state.
+}
+
+void BinderUpdateEngineAndroidService::SendStatusUpdate(
+ int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const std::string& new_version,
+ int64_t new_size) {
+ // TODO(deymo): Notify registered callers.
+}
+
Status BinderUpdateEngineAndroidService::bind(
const sp<IUpdateEngineCallback>& callback,
bool* return_value) {
diff --git a/binder_service_android.h b/binder_service_android.h
index 224ab07..2fb9ca1 100644
--- a/binder_service_android.h
+++ b/binder_service_android.h
@@ -25,14 +25,32 @@
#include "android/os/BnUpdateEngine.h"
#include "android/os/IUpdateEngineCallback.h"
+#include "update_engine/daemon_state_android.h"
+#include "update_engine/service_observer_interface.h"
namespace chromeos_update_engine {
-class BinderUpdateEngineAndroidService : public android::os::BnUpdateEngine {
+class BinderUpdateEngineAndroidService : public android::os::BnUpdateEngine,
+ public ServiceObserverInterface {
public:
- BinderUpdateEngineAndroidService() = default;
+ BinderUpdateEngineAndroidService(DaemonStateAndroid* daemon_state);
~BinderUpdateEngineAndroidService() override = default;
+ const char* ServiceName() const {
+ return "android.os.UpdateEngineService";
+ }
+
+ // ServiceObserverInterface overrides.
+ void SendStatusUpdate(int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const std::string& new_version,
+ int64_t new_size) override;
+
+ // Channel tracking changes are ignored.
+ void SendChannelChangeUpdate(const std::string& tracking_channel) override {}
+
+ // android::os::BnUpdateEngine overrides.
android::binder::Status applyPayload(
const android::String16& url,
const std::vector<android::String16>& header_kv_pairs) override;
diff --git a/binder_service_brillo.cc b/binder_service_brillo.cc
new file mode 100644
index 0000000..45ac343
--- /dev/null
+++ b/binder_service_brillo.cc
@@ -0,0 +1,221 @@
+//
+// Copyright (C) 2015 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "update_engine/binder_service_brillo.h"
+
+#include <base/bind.h>
+
+#include <binderwrapper/binder_wrapper.h>
+
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+
+#include "update_engine/update_status_utils.h"
+
+using android::String16;
+using android::String8;
+using android::binder::Status;
+using android::brillo::IUpdateEngineStatusCallback;
+using android::brillo::ParcelableUpdateEngineStatus;
+using android::sp;
+using brillo::ErrorPtr;
+using std::string;
+
+namespace chromeos_update_engine {
+
+namespace {
+string NormalString(const String16& in) {
+ return string{String8{in}.string()};
+}
+
+Status ToStatus(ErrorPtr* error) {
+ return Status::fromServiceSpecificError(
+ 1, String8{error->get()->GetMessage().c_str()});
+}
+} // namespace
+
+template <typename... Parameters, typename... Arguments>
+Status BinderUpdateEngineBrilloService::CallCommonHandler(
+ bool (UpdateEngineService::*Handler)(ErrorPtr*, Parameters...),
+ Arguments... arguments) {
+ ErrorPtr error;
+ if (((common_.get())->*Handler)(&error, arguments...))
+ return Status::ok();
+ return ToStatus(&error);
+}
+
+Status BinderUpdateEngineBrilloService::AttemptUpdate(
+ const String16& app_version, const String16& omaha_url, int flags) {
+ return CallCommonHandler(&UpdateEngineService::AttemptUpdate,
+ NormalString(app_version),
+ NormalString(omaha_url),
+ flags);
+}
+
+Status BinderUpdateEngineBrilloService::AttemptRollback(bool powerwash) {
+ return CallCommonHandler(&UpdateEngineService::AttemptRollback, powerwash);
+}
+
+Status BinderUpdateEngineBrilloService::CanRollback(bool* out_can_rollback) {
+ return CallCommonHandler(&UpdateEngineService::CanRollback, out_can_rollback);
+}
+
+Status BinderUpdateEngineBrilloService::ResetStatus() {
+ return CallCommonHandler(&UpdateEngineService::ResetStatus);
+}
+
+Status BinderUpdateEngineBrilloService::GetStatus(
+ ParcelableUpdateEngineStatus* status) {
+ string current_op;
+ string new_version;
+
+ auto ret = CallCommonHandler(&UpdateEngineService::GetStatus,
+ &status->last_checked_time_,
+ &status->progress_,
+ ¤t_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 BinderUpdateEngineBrilloService::RebootIfNeeded() {
+ return CallCommonHandler(&UpdateEngineService::RebootIfNeeded);
+}
+
+Status BinderUpdateEngineBrilloService::SetChannel(
+ const String16& target_channel, bool powerwash) {
+ return CallCommonHandler(&UpdateEngineService::SetChannel,
+ NormalString(target_channel),
+ powerwash);
+}
+
+Status BinderUpdateEngineBrilloService::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 BinderUpdateEngineBrilloService::SetP2PUpdatePermission(bool enabled) {
+ return CallCommonHandler(&UpdateEngineService::SetP2PUpdatePermission,
+ enabled);
+}
+
+Status BinderUpdateEngineBrilloService::GetP2PUpdatePermission(
+ bool* out_p2p_permission) {
+ return CallCommonHandler(&UpdateEngineService::GetP2PUpdatePermission,
+ out_p2p_permission);
+}
+
+Status BinderUpdateEngineBrilloService::SetUpdateOverCellularPermission(
+ bool enabled) {
+ return CallCommonHandler(
+ &UpdateEngineService::SetUpdateOverCellularPermission, enabled);
+}
+
+Status BinderUpdateEngineBrilloService::GetUpdateOverCellularPermission(
+ bool* out_cellular_permission) {
+ return CallCommonHandler(
+ &UpdateEngineService::GetUpdateOverCellularPermission,
+ out_cellular_permission);
+}
+
+Status BinderUpdateEngineBrilloService::GetDurationSinceUpdate(
+ int64_t* out_duration) {
+ return CallCommonHandler(&UpdateEngineService::GetDurationSinceUpdate,
+ out_duration);
+}
+
+Status BinderUpdateEngineBrilloService::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 BinderUpdateEngineBrilloService::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 BinderUpdateEngineBrilloService::RegisterStatusCallback(
+ const sp<IUpdateEngineStatusCallback>& callback) {
+ callbacks_.emplace_back(callback);
+
+ auto binder_wrapper = android::BinderWrapper::Get();
+
+ binder_wrapper->RegisterForDeathNotifications(
+ IUpdateEngineStatusCallback::asBinder(callback),
+ base::Bind(&BinderUpdateEngineBrilloService::UnregisterStatusCallback,
+ base::Unretained(this),
+ base::Unretained(callback.get())));
+
+ return Status::ok();
+}
+
+void BinderUpdateEngineBrilloService::UnregisterStatusCallback(
+ IUpdateEngineStatusCallback* callback) {
+ auto it = callbacks_.begin();
+
+ for (; it != callbacks_.end() && it->get() != callback; it++)
+ ;
+
+ if (it == callbacks_.end()) {
+ LOG(ERROR) << "Got death notification for unknown callback.";
+ return;
+ }
+
+ LOG(INFO) << "Erasing orphan callback";
+ callbacks_.erase(it);
+}
+
+void BinderUpdateEngineBrilloService::SendStatusUpdate(
+ int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const string& new_version,
+ int64_t new_size) {
+ const string str_status = UpdateStatusToString(status);
+ for (auto& callback : callbacks_) {
+ callback->HandleStatusUpdate(last_checked_time,
+ progress,
+ String16{str_status.c_str()},
+ String16{new_version.c_str()},
+ new_size);
+ }
+}
+
+} // namespace chromeos_update_engine
diff --git a/binder_service.h b/binder_service_brillo.h
similarity index 75%
rename from binder_service.h
rename to binder_service_brillo.h
index b9b2ea5..99aa76b 100644
--- a/binder_service.h
+++ b/binder_service_brillo.h
@@ -14,8 +14,8 @@
// limitations under the License.
//
-#ifndef UPDATE_ENGINE_BINDER_SERVICE_H_
-#define UPDATE_ENGINE_BINDER_SERVICE_H_
+#ifndef UPDATE_ENGINE_BINDER_SERVICE_BRILLO_H_
+#define UPDATE_ENGINE_BINDER_SERVICE_BRILLO_H_
#include <utils/Errors.h>
@@ -25,21 +25,32 @@
#include "update_engine/common_service.h"
#include "update_engine/parcelable_update_engine_status.h"
+#include "update_engine/service_observer_interface.h"
#include "android/brillo/BnUpdateEngine.h"
#include "android/brillo/IUpdateEngineStatusCallback.h"
namespace chromeos_update_engine {
-class BinderUpdateEngineService : public android::brillo::BnUpdateEngine {
+class BinderUpdateEngineBrilloService : public android::brillo::BnUpdateEngine,
+ public ServiceObserverInterface {
public:
- BinderUpdateEngineService(SystemState* system_state)
+ BinderUpdateEngineBrilloService(SystemState* system_state)
: common_(new UpdateEngineService(system_state)) {}
- virtual ~BinderUpdateEngineService() = default;
+ virtual ~BinderUpdateEngineBrilloService() = default;
- void SendStatusUpdate(int64_t in_last_checked_time, double in_progress,
- const std::string& in_current_operation,
- const std::string& in_new_version, int64_t in_new_size);
+ const char* ServiceName() const {
+ return "android.brillo.UpdateEngineService";
+ }
+
+ // ServiceObserverInterface overrides.
+ void SendStatusUpdate(int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const std::string& new_version,
+ int64_t new_size) override;
+ // Channel tracking changes are ignored.
+ void SendChannelChangeUpdate(const std::string& tracking_channel) override {}
// android::brillo::BnUpdateEngine overrides.
android::binder::Status AttemptUpdate(const android::String16& app_version,
@@ -74,7 +85,7 @@
private:
// Generic function for dispatching to the common service.
- template<typename... Parameters, typename... Arguments>
+ template <typename... Parameters, typename... Arguments>
android::binder::Status CallCommonHandler(
bool (UpdateEngineService::*Handler)(brillo::ErrorPtr*, Parameters...),
Arguments... arguments);
@@ -87,8 +98,8 @@
std::vector<android::sp<android::brillo::IUpdateEngineStatusCallback>>
callbacks_;
-}; // class BinderService
+};
} // namespace chromeos_update_engine
-#endif // UPDATE_ENGINE_BINDER_SERVICE_H_
+#endif // UPDATE_ENGINE_BINDER_SERVICE_BRILLO_H_
diff --git a/common_service.cc b/common_service.cc
index 77bdf7c..3c77c93 100644
--- a/common_service.cc
+++ b/common_service.cc
@@ -172,8 +172,7 @@
return false;
}
// Update the weave state because updated the target channel.
- if (system_state_->weave_service())
- system_state_->weave_service()->UpdateWeaveState();
+ system_state_->update_attempter()->BroadcastChannel();
return true;
}
diff --git a/daemon.cc b/daemon.cc
index ece151c..27000d5 100644
--- a/daemon.cc
+++ b/daemon.cc
@@ -26,14 +26,16 @@
#endif // USE_WEAVE || USE_BINDER
#if defined(__BRILLO__) || defined(__CHROMEOS__)
-#include "update_engine/update_attempter.h"
+#include "update_engine/real_system_state.h"
+#else // !(defined(__BRILLO__) || defined(__CHROMEOS__))
+#include "update_engine/daemon_state_android.h"
#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
#if USE_DBUS
namespace {
const int kDBusSystemMaxWaitSeconds = 2 * 60;
} // namespace
-#endif // USE_DBUS
+#endif // USE_DBUS
namespace chromeos_update_engine {
@@ -65,52 +67,51 @@
}
CHECK(bus->SetUpAsyncOperations());
-#endif // USE_DBUS
+#endif // USE_DBUS
#if defined(__BRILLO__) || defined(__CHROMEOS__)
// Initialize update engine global state but continue if something fails.
- real_system_state_.reset(new RealSystemState(bus));
- LOG_IF(ERROR, !real_system_state_->Initialize())
+ // TODO(deymo): Move the daemon_state_ initialization to a factory method
+ // avoiding the explicit re-usage of the |bus| instance, shared between
+ // D-Bus service and D-Bus client calls.
+ RealSystemState* real_system_state = new RealSystemState(bus);
+ daemon_state_.reset(real_system_state);
+ LOG_IF(ERROR, !real_system_state->Initialize())
<< "Failed to initialize system state.";
- UpdateAttempter* update_attempter = real_system_state_->update_attempter();
- CHECK(update_attempter);
#else // !(defined(__BRILLO__) || defined(__CHROMEOS__))
- //TODO(deymo): Initialize non-Brillo state.
-#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
+ DaemonStateAndroid* daemon_state_android = new DaemonStateAndroid();
+ daemon_state_.reset(daemon_state_android);
+ LOG_IF(ERROR, !daemon_state_android->Initialize())
+ << "Failed to initialize system state.";
+#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
#if USE_BINDER
// Create the Binder Service.
#if defined(__BRILLO__) || defined(__CHROMEOS__)
- service_ = new BinderUpdateEngineService{real_system_state_.get()};
+ binder_service_ = new BinderUpdateEngineBrilloService{real_system_state};
#else // !(defined(__BRILLO__) || defined(__CHROMEOS__))
- service_ = new BinderUpdateEngineAndroidService{};
-#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
+ binder_service_ = new BinderUpdateEngineAndroidService{daemon_state_android};
+#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
auto binder_wrapper = android::BinderWrapper::Get();
- if (!binder_wrapper->RegisterService("android.brillo.UpdateEngineService",
- service_)) {
+ if (!binder_wrapper->RegisterService(binder_service_->ServiceName(),
+ binder_service_)) {
LOG(ERROR) << "Failed to register binder service.";
}
-#if defined(__BRILLO__) || defined(__CHROMEOS__)
- update_attempter->set_binder_service(service_.get());
-#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
+ daemon_state_->AddObserver(binder_service_.get());
#endif // USE_BINDER
#if USE_DBUS
// Create the DBus service.
- dbus_adaptor_.reset(new UpdateEngineAdaptor(real_system_state_.get(), bus));
- update_attempter->set_dbus_adaptor(dbus_adaptor_.get());
+ dbus_adaptor_.reset(new UpdateEngineAdaptor(real_system_state, bus));
+ daemon_state_->AddObserver(dbus_adaptor_.get());
dbus_adaptor_->RegisterAsync(base::Bind(&UpdateEngineDaemon::OnDBusRegistered,
base::Unretained(this)));
LOG(INFO) << "Waiting for DBus object to be registered.";
#else // !USE_DBUS
-#if defined(__BRILLO__) || defined(__CHROMEOS__)
- real_system_state_->StartUpdater();
-#else // !(defined(__BRILLO__) || defined(__CHROMEOS__))
- // TODO(deymo): Start non-Brillo service.
-#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
-#endif // USE_DBUS
+ daemon_state_->StartUpdater();
+#endif // USE_DBUS
return EX_OK;
}
@@ -131,7 +132,7 @@
QuitWithExitCode(1);
return;
}
- real_system_state_->StartUpdater();
+ daemon_state_->StartUpdater();
}
#endif // USE_DBUS
diff --git a/daemon.h b/daemon.h
index 32437cb..8323e56 100644
--- a/daemon.h
+++ b/daemon.h
@@ -30,18 +30,16 @@
#if USE_BINDER
#if defined(__BRILLO__) || defined(__CHROMEOS__)
-#include "update_engine/binder_service.h"
+#include "update_engine/binder_service_brillo.h"
#else // !(defined(__BRILLO__) || defined(__CHROMEOS__))
#include "update_engine/binder_service_android.h"
#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
#endif // USE_BINDER
#include "update_engine/common/subprocess.h"
+#include "update_engine/daemon_state_interface.h"
#if USE_DBUS
#include "update_engine/dbus_service.h"
#endif // USE_DBUS
-#if defined(__BRILLO__) || defined(__CHROMEOS__)
-#include "update_engine/real_system_state.h"
-#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
namespace chromeos_update_engine {
@@ -75,18 +73,15 @@
#if USE_BINDER
#if defined(__BRILLO__) || defined(__CHROMEOS__)
- android::sp<BinderUpdateEngineService> service_;
+ android::sp<BinderUpdateEngineBrilloService> binder_service_;
#else // !(defined(__BRILLO__) || defined(__CHROMEOS__))
- android::sp<BinderUpdateEngineAndroidService> service_;
+ android::sp<BinderUpdateEngineAndroidService> binder_service_;
#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
#endif // USE_BINDER
-#if defined(__BRILLO__) || defined(__CHROMEOS__)
- // The RealSystemState uses the previous classes so it should be defined last.
- std::unique_ptr<RealSystemState> real_system_state_;
-#else // !(defined(__BRILLO__) || defined(__CHROMEOS__))
- //TODO(deymo): Define non-Brillo state.
-#endif // defined(__BRILLO__) || defined(__CHROMEOS__)
+ // The daemon state with all the required daemon classes for the configured
+ // platform.
+ std::unique_ptr<DaemonStateInterface> daemon_state_;
DISALLOW_COPY_AND_ASSIGN(UpdateEngineDaemon);
};
diff --git a/daemon_state_android.cc b/daemon_state_android.cc
new file mode 100644
index 0000000..3e89ad0
--- /dev/null
+++ b/daemon_state_android.cc
@@ -0,0 +1,38 @@
+//
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "update_engine/daemon_state_android.h"
+
+namespace chromeos_update_engine {
+
+bool DaemonStateAndroid::Initialize() {
+ // TODO(deymo): Implement the Android updater state.
+ return true;
+}
+
+bool DaemonStateAndroid::StartUpdater() {
+ return true;
+}
+
+void DaemonStateAndroid::AddObserver(ServiceObserverInterface* observer) {
+ service_observers_.insert(observer);
+}
+
+void DaemonStateAndroid::RemoveObserver(ServiceObserverInterface* observer) {
+ service_observers_.erase(observer);
+}
+
+} // namespace chromeos_update_engine
diff --git a/daemon_state_android.h b/daemon_state_android.h
new file mode 100644
index 0000000..2b8926c
--- /dev/null
+++ b/daemon_state_android.h
@@ -0,0 +1,44 @@
+//
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef UPDATE_ENGINE_DAEMON_STATE_ANDROID_H_
+#define UPDATE_ENGINE_DAEMON_STATE_ANDROID_H_
+
+#include <set>
+
+#include "update_engine/daemon_state_interface.h"
+#include "update_engine/service_observer_interface.h"
+
+namespace chromeos_update_engine {
+
+class DaemonStateAndroid : public DaemonStateInterface {
+ public:
+ DaemonStateAndroid() = default;
+
+ bool Initialize();
+
+ // DaemonStateInterface overrides.
+ bool StartUpdater() override;
+ void AddObserver(ServiceObserverInterface* observer) override;
+ void RemoveObserver(ServiceObserverInterface* observer) override;
+
+ protected:
+ std::set<ServiceObserverInterface*> service_observers_;
+};
+
+} // namespace chromeos_update_engine
+
+#endif // UPDATE_ENGINE_DAEMON_STATE_ANDROID_H_
diff --git a/daemon_state_interface.h b/daemon_state_interface.h
new file mode 100644
index 0000000..a0944aa
--- /dev/null
+++ b/daemon_state_interface.h
@@ -0,0 +1,45 @@
+//
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef UPDATE_ENGINE_DAEMON_STATE_INTERFACE_H_
+#define UPDATE_ENGINE_DAEMON_STATE_INTERFACE_H_
+
+#include "update_engine/service_observer_interface.h"
+
+#include <memory>
+
+namespace chromeos_update_engine {
+
+class DaemonStateInterface {
+ public:
+ virtual ~DaemonStateInterface() = default;
+
+ // Start the daemon loop. Should be called only once to start the daemon's
+ // main functionality.
+ virtual bool StartUpdater() = 0;
+
+ // Add and remove an observer. All the registered observers will be called
+ // whenever there's a new status to update.
+ virtual void AddObserver(ServiceObserverInterface* observer) = 0;
+ virtual void RemoveObserver(ServiceObserverInterface* observer) = 0;
+
+ protected:
+ DaemonStateInterface() = default;
+};
+
+} // namespace chromeos_update_engine
+
+#endif // UPDATE_ENGINE_DAEMON_STATE_INTERFACE_H_
diff --git a/dbus_service.cc b/dbus_service.cc
index 81a6efd..0ab0ac0 100644
--- a/dbus_service.cc
+++ b/dbus_service.cc
@@ -15,13 +15,15 @@
//
#include "update_engine/dbus_service.h"
+
#include "update_engine/dbus-constants.h"
+#include "update_engine/update_status_utils.h"
namespace chromeos_update_engine {
using brillo::ErrorPtr;
-using std::string;
using chromeos_update_engine::UpdateEngineService;
+using std::string;
DBusUpdateEngineService::DBusUpdateEngineService(SystemState* system_state)
: common_(new UpdateEngineService{system_state}) {
@@ -150,4 +152,14 @@
dbus::Bus::REQUIRE_PRIMARY);
}
+void UpdateEngineAdaptor::SendStatusUpdate(int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const string& new_version,
+ int64_t new_size) {
+ const string str_status = UpdateStatusToString(status);
+ SendStatusUpdateSignal(
+ last_checked_time, progress, str_status, new_version, new_size);
+}
+
} // namespace chromeos_update_engine
diff --git a/dbus_service.h b/dbus_service.h
index eb05a11..fe250c8 100644
--- a/dbus_service.h
+++ b/dbus_service.h
@@ -25,6 +25,7 @@
#include <brillo/errors/error.h>
#include "update_engine/common_service.h"
+#include "update_engine/service_observer_interface.h"
#include "update_engine/update_attempter.h"
#include "dbus_bindings/org.chromium.UpdateEngineInterface.h"
@@ -135,7 +136,8 @@
// The UpdateEngineAdaptor class runs the UpdateEngineInterface in the fixed
// object path, without an ObjectManager notifying the interfaces, since it is
// all static and clients don't expect it to be implemented.
-class UpdateEngineAdaptor : public org::chromium::UpdateEngineInterfaceAdaptor {
+class UpdateEngineAdaptor : public org::chromium::UpdateEngineInterfaceAdaptor,
+ public ServiceObserverInterface {
public:
UpdateEngineAdaptor(SystemState* system_state,
const scoped_refptr<dbus::Bus>& bus);
@@ -150,6 +152,16 @@
// succeeded.
bool RequestOwnership();
+ // ServiceObserverInterface overrides.
+ void SendStatusUpdate(int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const std::string& new_version,
+ int64_t new_size) override;
+
+ // Channel tracking changes are ignored.
+ void SendChannelChangeUpdate(const std::string& tracking_channel) override {}
+
private:
scoped_refptr<dbus::Bus> bus_;
DBusUpdateEngineService dbus_service_;
diff --git a/real_system_state.cc b/real_system_state.cc
index f415b90..bb697f6 100644
--- a/real_system_state.cc
+++ b/real_system_state.cc
@@ -49,7 +49,7 @@
// Prevent any DBus communication from UpdateAttempter when shutting down the
// daemon.
if (update_attempter_)
- update_attempter_->set_dbus_adaptor(nullptr);
+ update_attempter_->ClearObservers();
}
bool RealSystemState::Initialize() {
@@ -137,6 +137,8 @@
update_attempter_->Init();
weave_service_ = ConstructWeaveService(update_attempter_.get());
+ if (weave_service_)
+ update_attempter_->AddObserver(weave_service_.get());
// Initialize the Update Manager using the default state factory.
chromeos_update_manager::State* um_state =
@@ -165,7 +167,7 @@
return true;
}
-void RealSystemState::StartUpdater() {
+bool RealSystemState::StartUpdater() {
// Initiate update checks.
update_attempter_->ScheduleUpdates();
@@ -186,6 +188,17 @@
MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
&UpdateAttempter::UpdateEngineStarted,
base::Unretained(update_attempter_.get())));
+ return true;
+}
+
+void RealSystemState::AddObserver(ServiceObserverInterface* observer) {
+ CHECK(update_attempter_.get());
+ update_attempter_->AddObserver(observer);
+}
+
+void RealSystemState::RemoveObserver(ServiceObserverInterface* observer) {
+ CHECK(update_attempter_.get());
+ update_attempter_->RemoveObserver(observer);
}
} // namespace chromeos_update_engine
diff --git a/real_system_state.h b/real_system_state.h
index f65f706..071e3e0 100644
--- a/real_system_state.h
+++ b/real_system_state.h
@@ -33,6 +33,7 @@
#include "update_engine/common/hardware_interface.h"
#include "update_engine/common/prefs.h"
#include "update_engine/connection_manager.h"
+#include "update_engine/daemon_state_interface.h"
#include "update_engine/p2p_manager.h"
#include "update_engine/payload_state.h"
#include "update_engine/shill_proxy.h"
@@ -44,7 +45,7 @@
// A real implementation of the SystemStateInterface which is
// used by the actual product code.
-class RealSystemState : public SystemState {
+class RealSystemState : public SystemState, public DaemonStateInterface {
public:
// Constructs all system objects that do not require separate initialization;
// see Initialize() below for the remaining ones.
@@ -55,10 +56,15 @@
// separately from construction. Returns |true| on success.
bool Initialize();
+ // DaemonStateInterface overrides.
// Start the periodic update attempts. Must be called at the beginning of the
// program to start the periodic update check process.
- void StartUpdater();
+ bool StartUpdater() override;
+ void AddObserver(ServiceObserverInterface* observer) override;
+ void RemoveObserver(ServiceObserverInterface* observer) override;
+
+ // SystemState overrides.
inline void set_device_policy(
const policy::DevicePolicy* device_policy) override {
device_policy_ = device_policy;
diff --git a/service_observer_interface.h b/service_observer_interface.h
new file mode 100644
index 0000000..73d8350
--- /dev/null
+++ b/service_observer_interface.h
@@ -0,0 +1,48 @@
+//
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef UPDATE_ENGINE_SERVICE_OBSERVER_INTERFACE_H_
+#define UPDATE_ENGINE_SERVICE_OBSERVER_INTERFACE_H_
+
+#include <memory>
+#include <string>
+
+#include "update_engine/client_library/include/update_engine/update_status.h"
+
+namespace chromeos_update_engine {
+
+class ServiceObserverInterface {
+ public:
+ virtual ~ServiceObserverInterface() = default;
+
+ // Called whenever the value of these parameters changes. For |progress|
+ // value changes, this method will be called only if it changes significantly.
+ virtual void SendStatusUpdate(int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const std::string& new_version,
+ int64_t new_size) = 0;
+
+ // Called whenever the channel we are tracking changes.
+ virtual void SendChannelChangeUpdate(const std::string& tracking_channel) = 0;
+
+ protected:
+ ServiceObserverInterface() = default;
+};
+
+} // namespace chromeos_update_engine
+
+#endif // UPDATE_ENGINE_SERVICE_OBSERVER_INTERFACE_H_
diff --git a/update_attempter.cc b/update_attempter.cc
index d0c20d0..4e0b997 100644
--- a/update_attempter.cc
+++ b/update_attempter.cc
@@ -405,9 +405,8 @@
&error_message)) {
LOG(ERROR) << "Setting the channel failed: " << error_message;
}
- // Update the weave state because updated the target channel.
- if (system_state_->weave_service())
- system_state_->weave_service()->UpdateWeaveState();
+ // Notify observers the target channel change.
+ BroadcastChannel();
// Since this is the beginning of a new attempt, update the download
// channel. The download channel won't be updated until the next attempt,
@@ -1105,9 +1104,8 @@
error_message);
return false;
}
- // Update the weave state because updated the target channel.
- if (system_state_->weave_service())
- system_state_->weave_service()->UpdateWeaveState();
+ // Notify observers the target channel change.
+ BroadcastChannel();
return true;
}
@@ -1214,25 +1212,21 @@
}
void UpdateAttempter::BroadcastStatus() {
- if (system_state_->weave_service())
- system_state_->weave_service()->UpdateWeaveState();
-
-#if USE_BINDER
- if (binder_service_)
- binder_service_->SendStatusUpdate(last_checked_time_, download_progress_,
- UpdateStatusToString(status_),
- new_version_.c_str(), new_payload_size_);
-#endif // USE_BINDER
-
- if (!dbus_adaptor_)
- return;
+ for (const auto& observer : service_observers_) {
+ observer->SendStatusUpdate(last_checked_time_,
+ download_progress_,
+ status_,
+ new_version_,
+ new_payload_size_);
+ }
last_notify_time_ = TimeTicks::Now();
- dbus_adaptor_->SendStatusUpdateSignal(
- last_checked_time_,
- download_progress_,
- UpdateStatusToString(status_),
- new_version_.c_str(),
- new_payload_size_);
+}
+
+void UpdateAttempter::BroadcastChannel() {
+ for (const auto& observer : service_observers_) {
+ observer->SendChannelChangeUpdate(
+ system_state_->request_params()->target_channel());
+ }
}
uint32_t UpdateAttempter::GetErrorCodeFlags() {
diff --git a/update_attempter.h b/update_attempter.h
index 2401d60..2f53869 100644
--- a/update_attempter.h
+++ b/update_attempter.h
@@ -20,6 +20,7 @@
#include <time.h>
#include <memory>
+#include <set>
#include <string>
#include <utility>
#include <vector>
@@ -28,10 +29,6 @@
#include <base/time/time.h>
#include <gtest/gtest_prod.h> // for FRIEND_TEST
-#if USE_BINDER
-#include "update_engine/binder_service.h"
-#endif // USE_BINDER
-
#include "debugd/dbus-proxies.h"
#include "update_engine/chrome_browser_proxy_resolver.h"
#include "update_engine/client_library/include/update_engine/update_status.h"
@@ -42,6 +39,7 @@
#include "update_engine/omaha_response_handler_action.h"
#include "update_engine/payload_consumer/download_action.h"
#include "update_engine/proxy_resolver.h"
+#include "update_engine/service_observer_interface.h"
#include "update_engine/system_state.h"
#include "update_engine/update_manager/policy.h"
#include "update_engine/update_manager/update_manager.h"
@@ -138,16 +136,6 @@
int http_response_code() const { return http_response_code_; }
void set_http_response_code(int code) { http_response_code_ = code; }
- void set_dbus_adaptor(UpdateEngineAdaptor* dbus_adaptor) {
- dbus_adaptor_ = dbus_adaptor;
- }
-
-#if USE_BINDER
- void set_binder_service(BinderUpdateEngineService* service) {
- binder_service_ = service;
- }
-#endif
-
// This is the internal entry point for going through an
// update. If the current status is idle invokes Update.
// This is called by the DBus implementation.
@@ -184,9 +172,12 @@
void DownloadComplete() override;
- // Broadcasts the current status over D-Bus.
+ // Broadcasts the current status to all observers.
void BroadcastStatus();
+ // Broadcasts the current tracking channel to all observers.
+ void BroadcastChannel();
+
// Returns the special flags to be added to ErrorCode values based on the
// parameters used in the current update attempt.
uint32_t GetErrorCodeFlags();
@@ -239,6 +230,17 @@
// 'cros flash' to function properly).
virtual bool IsAnyUpdateSourceAllowed();
+ // Add and remove a service observer.
+ void AddObserver(ServiceObserverInterface* observer) {
+ service_observers_.insert(observer);
+ }
+ void RemoveObserver(ServiceObserverInterface* observer) {
+ service_observers_.erase(observer);
+ }
+
+ // Remove all the observers.
+ void ClearObservers() { service_observers_.clear(); }
+
private:
// Update server URL for automated lab test.
static const char* const kTestUpdateUrl;
@@ -421,15 +423,8 @@
// Pointer to the certificate checker instance to use.
CertificateChecker* cert_checker_;
- // If non-null, this UpdateAttempter will send status updates over this
- // dbus service.
- UpdateEngineAdaptor* dbus_adaptor_ = nullptr;
-
-#if USE_BINDER
- // If non-null, this UpdateAttempter will send status updates over this
- // binder interface.
- BinderUpdateEngineService* binder_service_ = nullptr;
-#endif // USE_BINDER
+ // The list of services observing changes in the updater.
+ std::set<ServiceObserverInterface*> service_observers_;
// Pointer to the OmahaResponseHandlerAction in the actions_ vector.
std::shared_ptr<OmahaResponseHandlerAction> response_handler_action_;
diff --git a/weave_service.cc b/weave_service.cc
index c6a67f2..b8ac174 100644
--- a/weave_service.cc
+++ b/weave_service.cc
@@ -62,6 +62,20 @@
UpdateWeaveState();
}
+void WeaveService::SendStatusUpdate(int64_t /* last_checked_time */,
+ double /* progress */,
+ update_engine::UpdateStatus /* status */,
+ const string& /* new_version */,
+ int64_t /* new_size */) {
+ // We query the Weave
+ UpdateWeaveState();
+}
+
+void WeaveService::SendChannelChangeUpdate(
+ const string& /* tracking_channel */) {
+ UpdateWeaveState();
+}
+
void WeaveService::UpdateWeaveState() {
auto weave_service = weave_service_.lock();
if (!weave_service || !delegate_)
diff --git a/weave_service.h b/weave_service.h
index 914777e..b1068e7 100644
--- a/weave_service.h
+++ b/weave_service.h
@@ -18,6 +18,7 @@
#define UPDATE_ENGINE_WEAVE_SERVICE_H_
#include <memory>
+#include <string>
#include <base/memory/weak_ptr.h>
#include <libweaved/command.h>
@@ -34,10 +35,18 @@
bool Init(DelegateInterface* delegate);
- // WeaveServiceInterface override.
- void UpdateWeaveState() override;
+ // ServiceObserverInterface overrides.
+ void SendStatusUpdate(int64_t last_checked_time,
+ double progress,
+ update_engine::UpdateStatus status,
+ const std::string& new_version,
+ int64_t new_size) override;
+ void SendChannelChangeUpdate(const std::string& tracking_channel) override;
private:
+ // Force a weave update.
+ void UpdateWeaveState();
+
void OnWeaveServiceConnected(const std::weak_ptr<weaved::Service>& service);
// Weave command handlers. These are called from the message loop whenever a
diff --git a/weave_service_interface.h b/weave_service_interface.h
index baaa9db..a7e603e 100644
--- a/weave_service_interface.h
+++ b/weave_service_interface.h
@@ -22,6 +22,7 @@
#include <brillo/errors/error.h>
#include "update_engine/client_library/include/update_engine/update_status.h"
+#include "update_engine/service_observer_interface.h"
namespace chromeos_update_engine {
@@ -30,7 +31,7 @@
// registration with weaved and the connection, the actual work to handle the
// commands is implemented by the DelegateInterface, which will be called from
// this class.
-class WeaveServiceInterface {
+class WeaveServiceInterface : public ServiceObserverInterface {
public:
// The delegate class that actually handles the command execution from
class DelegateInterface {
@@ -52,9 +53,6 @@
virtual ~WeaveServiceInterface() = default;
- // Force a weave state update.
- virtual void UpdateWeaveState() = 0;
-
protected:
WeaveServiceInterface() = default;
};