1280 lines
48 KiB
C++
1280 lines
48 KiB
C++
// Automatic generation of D-Bus interfaces:
|
|
// - org.chromium.PowerManager
|
|
#ifndef ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H
|
|
#define ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H
|
|
#include <memory>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <base/bind.h>
|
|
#include <base/callback.h>
|
|
#include <base/logging.h>
|
|
#include <base/macros.h>
|
|
#include <base/memory/ref_counted.h>
|
|
#include <brillo/any.h>
|
|
#include <brillo/dbus/dbus_method_invoker.h>
|
|
#include <brillo/dbus/dbus_property.h>
|
|
#include <brillo/dbus/dbus_signal_handler.h>
|
|
#include <brillo/errors/error.h>
|
|
#include <brillo/variant_dictionary.h>
|
|
#include <dbus/bus.h>
|
|
#include <dbus/message.h>
|
|
#include <dbus/object_manager.h>
|
|
#include <dbus/object_path.h>
|
|
#include <dbus/object_proxy.h>
|
|
|
|
namespace org {
|
|
namespace chromium {
|
|
|
|
// Abstract interface proxy for org::chromium::PowerManager.
|
|
class PowerManagerProxyInterface {
|
|
public:
|
|
virtual ~PowerManagerProxyInterface() = default;
|
|
|
|
virtual bool RequestShutdown(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RequestShutdownAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |reason| arg is a power_manager::RequestRestartReason value.
|
|
virtual bool RequestRestart(
|
|
int32_t in_reason,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |reason| arg is a power_manager::RequestRestartReason value.
|
|
virtual void RequestRestartAsync(
|
|
int32_t in_reason,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |external_wakeup_count| arg is optional, and it will call two
|
|
// different methods in the backend. This can't be expressed in the DBus
|
|
// Introspection XML file.
|
|
virtual bool RequestSuspend(
|
|
uint64_t in_external_wakeup_count,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |external_wakeup_count| arg is optional, and it will call two
|
|
// different methods in the backend. This can't be expressed in the DBus
|
|
// Introspection XML file.
|
|
virtual void RequestSuspendAsync(
|
|
uint64_t in_external_wakeup_count,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool DecreaseScreenBrightness(
|
|
bool in_allow_off,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void DecreaseScreenBrightnessAsync(
|
|
bool in_allow_off,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool IncreaseScreenBrightness(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void IncreaseScreenBrightnessAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool GetScreenBrightnessPercent(
|
|
double* out_percent,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void GetScreenBrightnessPercentAsync(
|
|
const base::Callback<void(double /*percent*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |style| arg must be one of the values:
|
|
// power_manager::kBrightnessTransitionGradual or
|
|
// power_manager::kBrightnessTransitionInstant.
|
|
virtual bool SetScreenBrightnessPercent(
|
|
double in_percent,
|
|
int32_t in_style,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |style| arg must be one of the values:
|
|
// power_manager::kBrightnessTransitionGradual or
|
|
// power_manager::kBrightnessTransitionInstant.
|
|
virtual void SetScreenBrightnessPercentAsync(
|
|
double in_percent,
|
|
int32_t in_style,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool DecreaseKeyboardBrightness(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void DecreaseKeyboardBrightnessAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool IncreaseKeyboardBrightness(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void IncreaseKeyboardBrightnessAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerSupplyProperties protobuf.
|
|
virtual bool GetPowerSupplyProperties(
|
|
std::vector<uint8_t>* out_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerSupplyProperties protobuf.
|
|
virtual void GetPowerSupplyPropertiesAsync(
|
|
const base::Callback<void(const std::vector<uint8_t>& /*serialized_proto*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool HandleVideoActivity(
|
|
bool in_fullscreen,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void HandleVideoActivityAsync(
|
|
bool in_fullscreen,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |type| arg is a power_manager::UserActivityType.
|
|
virtual bool HandleUserActivity(
|
|
int32_t in_type,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |type| arg is a power_manager::UserActivityType.
|
|
virtual void HandleUserActivityAsync(
|
|
int32_t in_type,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool SetIsProjecting(
|
|
bool in_is_projecting,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void SetIsProjectingAsync(
|
|
bool in_is_projecting,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerManagementPolicy protobuf.
|
|
virtual bool SetPolicy(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerManagementPolicy protobuf.
|
|
virtual void SetPolicyAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual bool SetPowerSource(
|
|
const std::string& in_id,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void SetPowerSourceAsync(
|
|
const std::string& in_id,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |timestamp_internal| arg is represented as the return value of
|
|
// base::TimeTicks::ToInternalValue().
|
|
virtual bool HandlePowerButtonAcknowledgment(
|
|
int64_t in_timestamp_internal,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |timestamp_internal| arg is represented as the return value of
|
|
// base::TimeTicks::ToInternalValue().
|
|
virtual void HandlePowerButtonAcknowledgmentAsync(
|
|
int64_t in_timestamp_internal,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
virtual bool RegisterSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
std::vector<uint8_t>* out_serialized_reply_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
virtual void RegisterSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
virtual bool UnregisterSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
virtual void UnregisterSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
virtual bool HandleSuspendReadiness(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
virtual void HandleSuspendReadinessAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
virtual bool RegisterDarkSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
std::vector<uint8_t>* out_serialized_reply_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
virtual void RegisterDarkSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
virtual bool UnregisterDarkSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
virtual void UnregisterDarkSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
virtual bool HandleDarkSuspendReadiness(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
virtual void HandleDarkSuspendReadinessAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::DarkResumeWakeReason protobuf.
|
|
virtual bool RecordDarkResumeWakeReason(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::DarkResumeWakeReason protobuf.
|
|
virtual void RecordDarkResumeWakeReasonAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) = 0;
|
|
|
|
virtual void RegisterBrightnessChangedSignalHandler(
|
|
const base::Callback<void(int32_t,
|
|
bool)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterKeyboardBrightnessChangedSignalHandler(
|
|
const base::Callback<void(int32_t,
|
|
bool)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterPeripheralBatteryStatusSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterPowerSupplyPollSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterSuspendImminentSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterSuspendDoneSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterDarkSuspendImminentSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterInputEventSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterIdleActionImminentSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
|
|
virtual void RegisterIdleActionDeferredSignalHandler(
|
|
const base::Closure& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) = 0;
|
|
};
|
|
|
|
} // namespace chromium
|
|
} // namespace org
|
|
|
|
namespace org {
|
|
namespace chromium {
|
|
|
|
// Interface proxy for org::chromium::PowerManager.
|
|
class PowerManagerProxy final : public PowerManagerProxyInterface {
|
|
public:
|
|
PowerManagerProxy(const scoped_refptr<dbus::Bus>& bus) :
|
|
bus_{bus},
|
|
dbus_object_proxy_{
|
|
bus_->GetObjectProxy(service_name_, object_path_)} {
|
|
}
|
|
|
|
~PowerManagerProxy() override {
|
|
bus_->RemoveObjectProxy(
|
|
service_name_, object_path_, base::Bind(&base::DoNothing));
|
|
}
|
|
|
|
void RegisterBrightnessChangedSignalHandler(
|
|
const base::Callback<void(int32_t,
|
|
bool)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"BrightnessChanged",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterKeyboardBrightnessChangedSignalHandler(
|
|
const base::Callback<void(int32_t,
|
|
bool)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"KeyboardBrightnessChanged",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterPeripheralBatteryStatusSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"PeripheralBatteryStatus",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterPowerSupplyPollSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"PowerSupplyPoll",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterSuspendImminentSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SuspendImminent",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterSuspendDoneSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SuspendDone",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterDarkSuspendImminentSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"DarkSuspendImminent",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterInputEventSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"InputEvent",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterIdleActionImminentSignalHandler(
|
|
const base::Callback<void(const std::vector<uint8_t>&)>& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"IdleActionImminent",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void RegisterIdleActionDeferredSignalHandler(
|
|
const base::Closure& signal_callback,
|
|
dbus::ObjectProxy::OnConnectedCallback on_connected_callback) override {
|
|
brillo::dbus_utils::ConnectToSignal(
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"IdleActionDeferred",
|
|
signal_callback,
|
|
on_connected_callback);
|
|
}
|
|
|
|
void ReleaseObjectProxy(const base::Closure& callback) {
|
|
bus_->RemoveObjectProxy(service_name_, object_path_, callback);
|
|
}
|
|
|
|
const dbus::ObjectPath& GetObjectPath() const {
|
|
return object_path_;
|
|
}
|
|
|
|
dbus::ObjectProxy* GetObjectProxy() const { return dbus_object_proxy_; }
|
|
|
|
bool RequestShutdown(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RequestShutdown",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void RequestShutdownAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RequestShutdown",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
// The |reason| arg is a power_manager::RequestRestartReason value.
|
|
bool RequestRestart(
|
|
int32_t in_reason,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RequestRestart",
|
|
error,
|
|
in_reason);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |reason| arg is a power_manager::RequestRestartReason value.
|
|
void RequestRestartAsync(
|
|
int32_t in_reason,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RequestRestart",
|
|
success_callback,
|
|
error_callback,
|
|
in_reason);
|
|
}
|
|
|
|
// The |external_wakeup_count| arg is optional, and it will call two
|
|
// different methods in the backend. This can't be expressed in the DBus
|
|
// Introspection XML file.
|
|
bool RequestSuspend(
|
|
uint64_t in_external_wakeup_count,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RequestSuspend",
|
|
error,
|
|
in_external_wakeup_count);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |external_wakeup_count| arg is optional, and it will call two
|
|
// different methods in the backend. This can't be expressed in the DBus
|
|
// Introspection XML file.
|
|
void RequestSuspendAsync(
|
|
uint64_t in_external_wakeup_count,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RequestSuspend",
|
|
success_callback,
|
|
error_callback,
|
|
in_external_wakeup_count);
|
|
}
|
|
|
|
bool DecreaseScreenBrightness(
|
|
bool in_allow_off,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"DecreaseScreenBrightness",
|
|
error,
|
|
in_allow_off);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void DecreaseScreenBrightnessAsync(
|
|
bool in_allow_off,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"DecreaseScreenBrightness",
|
|
success_callback,
|
|
error_callback,
|
|
in_allow_off);
|
|
}
|
|
|
|
bool IncreaseScreenBrightness(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"IncreaseScreenBrightness",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void IncreaseScreenBrightnessAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"IncreaseScreenBrightness",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool GetScreenBrightnessPercent(
|
|
double* out_percent,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"GetScreenBrightnessPercent",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_percent);
|
|
}
|
|
|
|
void GetScreenBrightnessPercentAsync(
|
|
const base::Callback<void(double /*percent*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"GetScreenBrightnessPercent",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
// The |style| arg must be one of the values:
|
|
// power_manager::kBrightnessTransitionGradual or
|
|
// power_manager::kBrightnessTransitionInstant.
|
|
bool SetScreenBrightnessPercent(
|
|
double in_percent,
|
|
int32_t in_style,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetScreenBrightnessPercent",
|
|
error,
|
|
in_percent,
|
|
in_style);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |style| arg must be one of the values:
|
|
// power_manager::kBrightnessTransitionGradual or
|
|
// power_manager::kBrightnessTransitionInstant.
|
|
void SetScreenBrightnessPercentAsync(
|
|
double in_percent,
|
|
int32_t in_style,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetScreenBrightnessPercent",
|
|
success_callback,
|
|
error_callback,
|
|
in_percent,
|
|
in_style);
|
|
}
|
|
|
|
bool DecreaseKeyboardBrightness(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"DecreaseKeyboardBrightness",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void DecreaseKeyboardBrightnessAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"DecreaseKeyboardBrightness",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool IncreaseKeyboardBrightness(
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"IncreaseKeyboardBrightness",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void IncreaseKeyboardBrightnessAsync(
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"IncreaseKeyboardBrightness",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerSupplyProperties protobuf.
|
|
bool GetPowerSupplyProperties(
|
|
std::vector<uint8_t>* out_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"GetPowerSupplyProperties",
|
|
error);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_serialized_proto);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerSupplyProperties protobuf.
|
|
void GetPowerSupplyPropertiesAsync(
|
|
const base::Callback<void(const std::vector<uint8_t>& /*serialized_proto*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"GetPowerSupplyProperties",
|
|
success_callback,
|
|
error_callback);
|
|
}
|
|
|
|
bool HandleVideoActivity(
|
|
bool in_fullscreen,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleVideoActivity",
|
|
error,
|
|
in_fullscreen);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void HandleVideoActivityAsync(
|
|
bool in_fullscreen,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleVideoActivity",
|
|
success_callback,
|
|
error_callback,
|
|
in_fullscreen);
|
|
}
|
|
|
|
// The |type| arg is a power_manager::UserActivityType.
|
|
bool HandleUserActivity(
|
|
int32_t in_type,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleUserActivity",
|
|
error,
|
|
in_type);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |type| arg is a power_manager::UserActivityType.
|
|
void HandleUserActivityAsync(
|
|
int32_t in_type,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleUserActivity",
|
|
success_callback,
|
|
error_callback,
|
|
in_type);
|
|
}
|
|
|
|
bool SetIsProjecting(
|
|
bool in_is_projecting,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetIsProjecting",
|
|
error,
|
|
in_is_projecting);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void SetIsProjectingAsync(
|
|
bool in_is_projecting,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetIsProjecting",
|
|
success_callback,
|
|
error_callback,
|
|
in_is_projecting);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerManagementPolicy protobuf.
|
|
bool SetPolicy(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetPolicy",
|
|
error,
|
|
in_serialized_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::PowerManagementPolicy protobuf.
|
|
void SetPolicyAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetPolicy",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_proto);
|
|
}
|
|
|
|
bool SetPowerSource(
|
|
const std::string& in_id,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetPowerSource",
|
|
error,
|
|
in_id);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
void SetPowerSourceAsync(
|
|
const std::string& in_id,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"SetPowerSource",
|
|
success_callback,
|
|
error_callback,
|
|
in_id);
|
|
}
|
|
|
|
// The |timestamp_internal| arg is represented as the return value of
|
|
// base::TimeTicks::ToInternalValue().
|
|
bool HandlePowerButtonAcknowledgment(
|
|
int64_t in_timestamp_internal,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandlePowerButtonAcknowledgment",
|
|
error,
|
|
in_timestamp_internal);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |timestamp_internal| arg is represented as the return value of
|
|
// base::TimeTicks::ToInternalValue().
|
|
void HandlePowerButtonAcknowledgmentAsync(
|
|
int64_t in_timestamp_internal,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandlePowerButtonAcknowledgment",
|
|
success_callback,
|
|
error_callback,
|
|
in_timestamp_internal);
|
|
}
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
bool RegisterSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
std::vector<uint8_t>* out_serialized_reply_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RegisterSuspendDelay",
|
|
error,
|
|
in_serialized_request_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_serialized_reply_proto);
|
|
}
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
void RegisterSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RegisterSuspendDelay",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_request_proto);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
bool UnregisterSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"UnregisterSuspendDelay",
|
|
error,
|
|
in_serialized_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
void UnregisterSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"UnregisterSuspendDelay",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_proto);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
bool HandleSuspendReadiness(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleSuspendReadiness",
|
|
error,
|
|
in_serialized_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
void HandleSuspendReadinessAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleSuspendReadiness",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_proto);
|
|
}
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
bool RegisterDarkSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
std::vector<uint8_t>* out_serialized_reply_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RegisterDarkSuspendDelay",
|
|
error,
|
|
in_serialized_request_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error, out_serialized_reply_proto);
|
|
}
|
|
|
|
// The |serialized_request_proto| arg is a serialized
|
|
// power_manager::RegisterSuspendDelayRequest protobuf.
|
|
// The |serialized_reply_proto| arg is a serialized
|
|
// RegisterSuspendDelayReply protobuf.
|
|
void RegisterDarkSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_request_proto,
|
|
const base::Callback<void(const std::vector<uint8_t>& /*serialized_reply_proto*/)>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RegisterDarkSuspendDelay",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_request_proto);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
bool UnregisterDarkSuspendDelay(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"UnregisterDarkSuspendDelay",
|
|
error,
|
|
in_serialized_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::UnregisterSuspendDelayRequest protobuf.
|
|
void UnregisterDarkSuspendDelayAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"UnregisterDarkSuspendDelay",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_proto);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
bool HandleDarkSuspendReadiness(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleDarkSuspendReadiness",
|
|
error,
|
|
in_serialized_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::SuspendReadinessInfo protobuf.
|
|
void HandleDarkSuspendReadinessAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"HandleDarkSuspendReadiness",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_proto);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::DarkResumeWakeReason protobuf.
|
|
bool RecordDarkResumeWakeReason(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
brillo::ErrorPtr* error,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
auto response = brillo::dbus_utils::CallMethodAndBlockWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RecordDarkResumeWakeReason",
|
|
error,
|
|
in_serialized_proto);
|
|
return response && brillo::dbus_utils::ExtractMethodCallResults(
|
|
response.get(), error);
|
|
}
|
|
|
|
// The |serialized_proto| arg is a serialized
|
|
// power_manager::DarkResumeWakeReason protobuf.
|
|
void RecordDarkResumeWakeReasonAsync(
|
|
const std::vector<uint8_t>& in_serialized_proto,
|
|
const base::Callback<void()>& success_callback,
|
|
const base::Callback<void(brillo::Error*)>& error_callback,
|
|
int timeout_ms = dbus::ObjectProxy::TIMEOUT_USE_DEFAULT) override {
|
|
brillo::dbus_utils::CallMethodWithTimeout(
|
|
timeout_ms,
|
|
dbus_object_proxy_,
|
|
"org.chromium.PowerManager",
|
|
"RecordDarkResumeWakeReason",
|
|
success_callback,
|
|
error_callback,
|
|
in_serialized_proto);
|
|
}
|
|
|
|
private:
|
|
scoped_refptr<dbus::Bus> bus_;
|
|
const std::string service_name_{"org.chromium.PowerManager"};
|
|
const dbus::ObjectPath object_path_{"/org/chromium/PowerManager"};
|
|
dbus::ObjectProxy* dbus_object_proxy_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(PowerManagerProxy);
|
|
};
|
|
|
|
} // namespace chromium
|
|
} // namespace org
|
|
|
|
#endif // ____CHROMEOS_DBUS_BINDING____________________BUILD_LINK_TMP_PORTAGE_CHROMEOS_BASE_POWER_MANAGER_9999_WORK_BUILD_OUT_DEFAULT_GEN_INCLUDE_POWER_MANAGER_DBUS_PROXIES_H
|