blob: ce52f9fbdd07f628912443d1ddecfb0042238a01 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/battery/battery_status_manager_linux.h"
#include <stddef.h>
#include <stdint.h>
#include <limits>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/macros.h"
#include "base/metrics/histogram.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread.h"
#include "base/values.h"
#include "base/version.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_path.h"
#include "dbus/object_proxy.h"
#include "dbus/property.h"
#include "dbus/values_util.h"
#include "device/battery/battery_status_manager_linux-inl.h"
namespace device {
namespace {
const char kBatteryNotifierThreadName[] = "BatteryStatusNotifier";
class UPowerProperties : public dbus::PropertySet {
public:
UPowerProperties(dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback callback);
~UPowerProperties() override;
base::Version daemon_version();
private:
dbus::Property<std::string> daemon_version_;
DISALLOW_COPY_AND_ASSIGN(UPowerProperties);
};
UPowerProperties::UPowerProperties(dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback callback)
: dbus::PropertySet(object_proxy, kUPowerInterfaceName, callback) {
RegisterProperty(kUPowerPropertyDaemonVersion, &daemon_version_);
}
UPowerProperties::~UPowerProperties() {}
base::Version UPowerProperties::daemon_version() {
return (daemon_version_.is_valid() || daemon_version_.GetAndBlock())
? base::Version(daemon_version_.value())
: base::Version();
}
class UPowerObject {
public:
typedef dbus::PropertySet::PropertyChangedCallback PropertyChangedCallback;
UPowerObject(dbus::Bus* dbus,
const PropertyChangedCallback property_changed_callback);
~UPowerObject();
std::vector<dbus::ObjectPath> EnumerateDevices();
dbus::ObjectPath GetDisplayDevice();
dbus::ObjectProxy* proxy() { return proxy_; }
UPowerProperties* properties() { return properties_.get(); }
private:
dbus::Bus* dbus_; // Owned by the BatteryStatusNotificationThread.
dbus::ObjectProxy* proxy_; // Owned by the dbus.
std::unique_ptr<UPowerProperties> properties_;
DISALLOW_COPY_AND_ASSIGN(UPowerObject);
};
UPowerObject::UPowerObject(
dbus::Bus* dbus,
const PropertyChangedCallback property_changed_callback)
: dbus_(dbus),
proxy_(dbus_->GetObjectProxy(kUPowerServiceName,
dbus::ObjectPath(kUPowerPath))),
properties_(new UPowerProperties(proxy_, property_changed_callback)) {}
UPowerObject::~UPowerObject() {
properties_.reset(); // before the proxy is deleted.
dbus_->RemoveObjectProxy(kUPowerServiceName, proxy_->object_path(),
base::Bind(&base::DoNothing));
}
std::vector<dbus::ObjectPath> UPowerObject::EnumerateDevices() {
std::vector<dbus::ObjectPath> paths;
dbus::MethodCall method_call(kUPowerServiceName,
kUPowerMethodEnumerateDevices);
std::unique_ptr<dbus::Response> response(proxy_->CallMethodAndBlock(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
if (response) {
dbus::MessageReader reader(response.get());
reader.PopArrayOfObjectPaths(&paths);
}
return paths;
}
dbus::ObjectPath UPowerObject::GetDisplayDevice() {
dbus::ObjectPath display_device_path;
if (!proxy_)
return display_device_path;
dbus::MethodCall method_call(kUPowerServiceName,
kUPowerMethodGetDisplayDevice);
std::unique_ptr<dbus::Response> response(proxy_->CallMethodAndBlock(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT));
if (response) {
dbus::MessageReader reader(response.get());
reader.PopObjectPath(&display_device_path);
}
return display_device_path;
}
void UpdateNumberBatteriesHistogram(int count) {
UMA_HISTOGRAM_CUSTOM_COUNTS(
"BatteryStatus.NumberBatteriesLinux", count, 1, 5, 6);
}
class BatteryProperties : public dbus::PropertySet {
public:
BatteryProperties(dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback callback);
~BatteryProperties() override;
void ConnectSignals() override;
void Invalidate();
bool is_present(bool default_value = false);
double percentage(double default_value = 100);
uint32_t state(uint32_t default_value = UPOWER_DEVICE_STATE_UNKNOWN);
int64_t time_to_empty(int64_t default_value = 0);
int64_t time_to_full(int64_t default_value = 0);
uint32_t type(uint32_t default_value = UPOWER_DEVICE_TYPE_UNKNOWN);
private:
bool connected_ = false;
dbus::Property<bool> is_present_;
dbus::Property<double> percentage_;
dbus::Property<uint32_t> state_;
dbus::Property<int64_t> time_to_empty_;
dbus::Property<int64_t> time_to_full_;
dbus::Property<uint32_t> type_;
DISALLOW_COPY_AND_ASSIGN(BatteryProperties);
};
BatteryProperties::BatteryProperties(dbus::ObjectProxy* object_proxy,
const PropertyChangedCallback callback)
: dbus::PropertySet(object_proxy, kUPowerDeviceInterfaceName, callback) {
RegisterProperty(kUPowerDevicePropertyIsPresent, &is_present_);
RegisterProperty(kUPowerDevicePropertyPercentage, &percentage_);
RegisterProperty(kUPowerDevicePropertyState, &state_);
RegisterProperty(kUPowerDevicePropertyTimeToEmpty, &time_to_empty_);
RegisterProperty(kUPowerDevicePropertyTimeToFull, &time_to_full_);
RegisterProperty(kUPowerDevicePropertyType, &type_);
}
BatteryProperties::~BatteryProperties() {}
void BatteryProperties::ConnectSignals() {
if (!connected_) {
connected_ = true;
dbus::PropertySet::ConnectSignals();
}
}
void BatteryProperties::Invalidate() {
is_present_.set_valid(false);
percentage_.set_valid(false);
state_.set_valid(false);
time_to_empty_.set_valid(false);
time_to_full_.set_valid(false);
type_.set_valid(false);
}
bool BatteryProperties::is_present(bool default_value) {
return (is_present_.is_valid() || is_present_.GetAndBlock())
? is_present_.value()
: default_value;
}
double BatteryProperties::percentage(double default_value) {
return (percentage_.is_valid() || percentage_.GetAndBlock())
? percentage_.value()
: default_value;
}
uint32_t BatteryProperties::state(uint32_t default_value) {
return (state_.is_valid() || state_.GetAndBlock()) ? state_.value()
: default_value;
}
int64_t BatteryProperties::time_to_empty(int64_t default_value) {
return (time_to_empty_.is_valid() || time_to_empty_.GetAndBlock())
? time_to_empty_.value()
: default_value;
}
int64_t BatteryProperties::time_to_full(int64_t default_value) {
return (time_to_full_.is_valid() || time_to_full_.GetAndBlock())
? time_to_full_.value()
: default_value;
}
uint32_t BatteryProperties::type(uint32_t default_value) {
return (type_.is_valid() || type_.GetAndBlock()) ? type_.value()
: default_value;
}
class BatteryObject {
public:
typedef dbus::PropertySet::PropertyChangedCallback PropertyChangedCallback;
BatteryObject(dbus::Bus* dbus,
const dbus::ObjectPath& device_path,
const PropertyChangedCallback& property_changed_callback);
~BatteryObject();
bool IsValid();
dbus::ObjectProxy* proxy() { return proxy_; }
BatteryProperties* properties() { return properties_.get(); }
private:
dbus::Bus* dbus_; // Owned by the BatteryStatusNotificationThread,
dbus::ObjectProxy* proxy_; // Owned by the dbus.
std::unique_ptr<BatteryProperties> properties_;
DISALLOW_COPY_AND_ASSIGN(BatteryObject);
};
BatteryObject::BatteryObject(
dbus::Bus* dbus,
const dbus::ObjectPath& device_path,
const PropertyChangedCallback& property_changed_callback)
: dbus_(dbus),
proxy_(dbus_->GetObjectProxy(kUPowerServiceName, device_path)),
properties_(new BatteryProperties(proxy_, property_changed_callback)) {}
BatteryObject::~BatteryObject() {
properties_.reset(); // before the proxy is deleted.
dbus_->RemoveObjectProxy(kUPowerServiceName, proxy_->object_path(),
base::Bind(&base::DoNothing));
}
bool BatteryObject::IsValid() {
return properties_->is_present() &&
properties_->type() == UPOWER_DEVICE_TYPE_BATTERY;
}
BatteryStatus ComputeWebBatteryStatus(BatteryProperties* properties) {
BatteryStatus status;
uint32_t state = properties->state();
status.charging = state != UPOWER_DEVICE_STATE_DISCHARGING &&
state != UPOWER_DEVICE_STATE_EMPTY;
// Convert percentage to a value between 0 and 1 with 2 digits of precision.
// This is to bring it in line with other platforms like Mac and Android where
// we report level with 1% granularity. It also serves the purpose of reducing
// the possibility of fingerprinting and triggers less level change events on
// the blink side.
// TODO(timvolodine): consider moving this rounding to the blink side.
status.level = round(properties->percentage()) / 100.f;
switch (state) {
case UPOWER_DEVICE_STATE_CHARGING: {
int64_t time_to_full = properties->time_to_full();
status.charging_time = (time_to_full > 0)
? time_to_full
: std::numeric_limits<double>::infinity();
break;
}
case UPOWER_DEVICE_STATE_DISCHARGING: {
int64_t time_to_empty = properties->time_to_empty();
// Set dischargingTime if it's available. Otherwise leave the default
// value which is +infinity.
if (time_to_empty > 0)
status.discharging_time = time_to_empty;
status.charging_time = std::numeric_limits<double>::infinity();
break;
}
case UPOWER_DEVICE_STATE_FULL: {
break;
}
default: { status.charging_time = std::numeric_limits<double>::infinity(); }
}
return status;
}
} // namespace
// Class that represents a dedicated thread which communicates with DBus to
// obtain battery information and receives battery change notifications.
class BatteryStatusManagerLinux::BatteryStatusNotificationThread
: public base::Thread {
public:
BatteryStatusNotificationThread(
const BatteryStatusService::BatteryUpdateCallback& callback)
: base::Thread(kBatteryNotifierThreadName), callback_(callback) {}
~BatteryStatusNotificationThread() override {
// Make sure to shutdown the dbus connection if it is still open in the very
// end. It needs to happen on the BatteryStatusNotificationThread.
message_loop()->task_runner()->PostTask(
FROM_HERE,
base::Bind(&BatteryStatusNotificationThread::ShutdownDBusConnection,
base::Unretained(this)));
// Drain the message queue of the BatteryStatusNotificationThread and stop.
Stop();
}
void StartListening() {
DCHECK(OnWatcherThread());
if (upower_)
return;
if (!system_bus_)
InitDBus();
upower_.reset(new UPowerObject(system_bus_.get(),
UPowerObject::PropertyChangedCallback()));
upower_->proxy()->ConnectToSignal(
kUPowerServiceName, kUPowerSignalDeviceAdded,
base::Bind(&BatteryStatusNotificationThread::DeviceAdded,
base::Unretained(this)),
base::Bind(&BatteryStatusNotificationThread::OnSignalConnected,
base::Unretained(this)));
upower_->proxy()->ConnectToSignal(
kUPowerServiceName, kUPowerSignalDeviceRemoved,
base::Bind(&BatteryStatusNotificationThread::DeviceRemoved,
base::Unretained(this)),
base::Bind(&BatteryStatusNotificationThread::OnSignalConnected,
base::Unretained(this)));
FindBatteryDevice();
}
void StopListening() {
DCHECK(OnWatcherThread());
ShutdownDBusConnection();
}
void SetDBusForTesting(dbus::Bus* bus) { system_bus_ = bus; }
private:
bool OnWatcherThread() {
return task_runner()->BelongsToCurrentThread();
}
void InitDBus() {
DCHECK(OnWatcherThread());
dbus::Bus::Options options;
options.bus_type = dbus::Bus::SYSTEM;
options.connection_type = dbus::Bus::PRIVATE;
system_bus_ = new dbus::Bus(options);
}
bool IsDaemonVersionBelow_0_99() {
base::Version daemon_version = upower_->properties()->daemon_version();
return daemon_version.IsValid() &&
daemon_version.CompareTo(base::Version("0.99")) < 0;
}
void FindBatteryDevice() {
// Move the currently watched battery_ device to a stack-local variable such
// that we can enumerate all devices (once more):
// first testing the display device, then testing all devices from
// EnumerateDevices. We will monitor the first battery device we find.
// - That may be the same device we did monitor on entering this method;
// then we'll use the same BatteryObject instance, that was moved to
// current - see UseCurrentOrCreateBattery().
// - Or it may be a new device; then the previously monitored BatteryObject
// instance (if any) is released on leaving this function.
// - Or we may not find a battery device; then on leaving this function
// battery_ will be nullptr and the previously monitored BatteryObject
// instance (if any) is no longer a battery and will be released.
std::unique_ptr<BatteryObject> current = std::move(battery_);
auto UseCurrentOrCreateBattery =
[&current, this](const dbus::ObjectPath& device_path) {
if (current && current->proxy()->object_path() == device_path)
return std::move(current);
else
return CreateBattery(device_path);
};
dbus::ObjectPath display_device_path = upower_->GetDisplayDevice();
if (display_device_path.IsValid()) {
std::unique_ptr<BatteryObject> battery =
UseCurrentOrCreateBattery(display_device_path);
if (battery->IsValid())
battery_ = std::move(battery);
}
if (!battery_) {
int num_batteries = 0;
for (const auto& device_path : upower_->EnumerateDevices()) {
std::unique_ptr<BatteryObject> battery =
UseCurrentOrCreateBattery(device_path);
if (!battery->IsValid())
continue;
if (battery_) {
// TODO(timvolodine): add support for multiple batteries. Currently we
// only collect information from the first battery we encounter
// (crbug.com/400780).
LOG(WARNING) << "multiple batteries found, "
<< "using status data of the first battery only.";
} else {
battery_ = std::move(battery);
}
num_batteries++;
}
UpdateNumberBatteriesHistogram(num_batteries);
}
if (battery_) {
battery_->properties()->ConnectSignals();
NotifyBatteryStatus();
} else {
callback_.Run(BatteryStatus());
return;
}
if (IsDaemonVersionBelow_0_99()) {
// UPower Version 0.99 replaced the Changed signal with the
// PropertyChanged signal. For older versions we need to listen
// to the Changed signal.
battery_->proxy()->ConnectToSignal(
kUPowerDeviceInterfaceName, kUPowerDeviceSignalChanged,
base::Bind(&BatteryStatusNotificationThread::BatteryChanged,
base::Unretained(this)),
base::Bind(&BatteryStatusNotificationThread::OnSignalConnected,
base::Unretained(this)));
}
}
void ShutdownDBusConnection() {
DCHECK(OnWatcherThread());
if (!system_bus_.get())
return;
battery_.reset(); // before the system_bus_ is shut down.
upower_.reset();
// Shutdown DBus connection later because there may be pending tasks on
// this thread.
message_loop()->task_runner()->PostTask(
FROM_HERE, base::Bind(&dbus::Bus::ShutdownAndBlock, system_bus_));
system_bus_ = NULL;
}
void OnSignalConnected(const std::string& interface_name,
const std::string& signal_name,
bool success) {}
std::unique_ptr<BatteryObject> CreateBattery(
const dbus::ObjectPath& device_path) {
std::unique_ptr<BatteryObject> battery(new BatteryObject(
system_bus_.get(), device_path,
base::Bind(&BatteryStatusNotificationThread::BatteryPropertyChanged,
base::Unretained(this))));
return battery;
}
void DeviceAdded(dbus::Signal* signal /* unused */) {
// Re-iterate all devices to see if we need to monitor the added battery
// instead of the currently monitored battery.
FindBatteryDevice();
}
void DeviceRemoved(dbus::Signal* signal) {
if (!battery_)
return;
// UPower specifies that the DeviceRemoved signal has an object-path as
// argument, however IRL that signal was observed with a string argument,
// so cover both cases (argument as string, as object-path and neither of
// these) and call FindBatteryDevice() if either we couldn't get the
// argument or the removed device-path is the battery_.
dbus::MessageReader reader(signal);
dbus::ObjectPath removed_device_path;
switch (reader.GetDataType()) {
case dbus::Message::DataType::STRING: {
std::string removed_device_path_string;
if (reader.PopString(&removed_device_path_string))
removed_device_path = dbus::ObjectPath(removed_device_path_string);
break;
}
case dbus::Message::DataType::OBJECT_PATH:
reader.PopObjectPath(&removed_device_path);
break;
default:
break;
}
if (!removed_device_path.IsValid() ||
battery_->proxy()->object_path() == removed_device_path)
FindBatteryDevice();
}
void BatteryPropertyChanged(const std::string& property_name) {
NotifyBatteryStatus();
}
void BatteryChanged(dbus::Signal* signal /* unsused */) {
DCHECK(battery_);
battery_->properties()->Invalidate();
NotifyBatteryStatus();
}
void NotifyBatteryStatus() {
DCHECK(OnWatcherThread());
if (!system_bus_.get() || !battery_ || notifying_battery_status_)
return;
// If the system uses a UPower daemon older than version 0.99
// (see IsDaemonVersionBelow_0_99), then we are notified about changed
// battery_ properties through the 'Changed' signal of the battery_
// device (see BatteryChanged()). That is implemented to invalidate all
// battery_ properties (so they are re-fetched from the dbus). Getting
// the new property-value triggers a callback to BatteryPropertyChanged().
// notifying_battery_status_ is set to avoid recursion and computing the
// status too often.
notifying_battery_status_ = true;
callback_.Run(ComputeWebBatteryStatus(battery_->properties()));
notifying_battery_status_ = false;
}
BatteryStatusService::BatteryUpdateCallback callback_;
scoped_refptr<dbus::Bus> system_bus_;
std::unique_ptr<UPowerObject> upower_;
std::unique_ptr<BatteryObject> battery_;
bool notifying_battery_status_ = false;
DISALLOW_COPY_AND_ASSIGN(BatteryStatusNotificationThread);
};
BatteryStatusManagerLinux::BatteryStatusManagerLinux(
const BatteryStatusService::BatteryUpdateCallback& callback)
: callback_(callback) {}
BatteryStatusManagerLinux::~BatteryStatusManagerLinux() {}
bool BatteryStatusManagerLinux::StartListeningBatteryChange() {
if (!StartNotifierThreadIfNecessary())
return false;
notifier_thread_->task_runner()->PostTask(
FROM_HERE, base::Bind(&BatteryStatusNotificationThread::StartListening,
base::Unretained(notifier_thread_.get())));
return true;
}
void BatteryStatusManagerLinux::StopListeningBatteryChange() {
if (!notifier_thread_)
return;
notifier_thread_->task_runner()->PostTask(
FROM_HERE, base::Bind(&BatteryStatusNotificationThread::StopListening,
base::Unretained(notifier_thread_.get())));
}
bool BatteryStatusManagerLinux::StartNotifierThreadIfNecessary() {
if (notifier_thread_)
return true;
base::Thread::Options thread_options(base::MessageLoop::TYPE_IO, 0);
notifier_thread_.reset(new BatteryStatusNotificationThread(callback_));
if (!notifier_thread_->StartWithOptions(thread_options)) {
notifier_thread_.reset();
LOG(ERROR) << "Could not start the " << kBatteryNotifierThreadName
<< " thread";
return false;
}
return true;
}
base::Thread* BatteryStatusManagerLinux::GetNotifierThreadForTesting() {
return notifier_thread_.get();
}
// static
std::unique_ptr<BatteryStatusManagerLinux>
BatteryStatusManagerLinux::CreateForTesting(
const BatteryStatusService::BatteryUpdateCallback& callback,
dbus::Bus* bus) {
std::unique_ptr<BatteryStatusManagerLinux> manager(
new BatteryStatusManagerLinux(callback));
if (manager->StartNotifierThreadIfNecessary())
manager->notifier_thread_->SetDBusForTesting(bus);
else
manager.reset();
return manager;
}
// static
std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
const BatteryStatusService::BatteryUpdateCallback& callback) {
return std::unique_ptr<BatteryStatusManager>(
new BatteryStatusManagerLinux(callback));
}
} // namespace device