blob: 7eee09ddf29a2d300d3da12a7bdc0fd44953cb06 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// Copyright (c) 2008 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.
#ifndef BASE_SYSTEM_MONITOR_H_
#define BASE_SYSTEM_MONITOR_H_
#include "build/build_config.h"
// Windows HiRes timers drain the battery faster so we need to know the battery
// status. This isn't true for other platforms.
#if defined(OS_WIN)
#define ENABLE_BATTERY_MONITORING 1
#else
#undef ENABLE_BATTERY_MONITORING
#endif // !OS_WIN
#include "base/observer_list_threadsafe.h"
#include "base/singleton.h"
#if defined(ENABLE_BATTERY_MONITORING)
#include "base/timer.h"
#endif // defined(ENABLE_BATTERY_MONITORING)
namespace base {
// Class for monitoring various system-related subsystems
// such as power management, network status, etc.
// TODO(mbelshe): Add support beyond just power management.
class SystemMonitor {
public:
// Access to the Singleton
static SystemMonitor* Get() {
// Uses the LeakySingletonTrait because cleanup is optional.
return
Singleton<SystemMonitor, LeakySingletonTraits<SystemMonitor> >::get();
}
// Start the System Monitor within a process. This method
// is provided so that the battery check can be deferred.
// The MessageLoop must be started before calling this
// method.
// This is a no-op on platforms for which ENABLE_BATTERY_MONITORING is
// disabled.
static void Start();
//
// Power-related APIs
//
// Is the computer currently on battery power.
// Can be called on any thread.
bool BatteryPower() {
// Using a lock here is not necessary for just a bool.
return battery_in_use_;
}
// Normalized list of power events.
enum PowerEvent {
POWER_STATE_EVENT, // The Power status of the system has changed.
SUSPEND_EVENT, // The system is being suspended.
RESUME_EVENT // The system is being resumed.
};
// Callbacks will be called on the thread which creates the SystemMonitor.
// During the callback, Add/RemoveObserver will block until the callbacks
// are finished. Observers should implement quick callback functions; if
// lengthy operations are needed, the observer should take care to invoke
// the operation on an appropriate thread.
class PowerObserver {
public:
// Notification of a change in power status of the computer, such
// as from switching between battery and A/C power.
virtual void OnPowerStateChange(SystemMonitor*) = 0;
// Notification that the system is suspending.
virtual void OnSuspend(SystemMonitor*) = 0;
// Notification that the system is resuming.
virtual void OnResume(SystemMonitor*) = 0;
};
// Add a new observer.
// Can be called from any thread.
// Must not be called from within a notification callback.
void AddObserver(PowerObserver* obs);
// Remove an existing observer.
// Can be called from any thread.
// Must not be called from within a notification callback.
void RemoveObserver(PowerObserver* obs);
#if defined(OS_WIN)
// Windows-specific handling of a WM_POWERBROADCAST message.
// Embedders of this API should hook their top-level window
// message loop and forward WM_POWERBROADCAST through this call.
void ProcessWmPowerBroadcastMessage(int event_id);
#endif
// Cross-platform handling of a power event.
void ProcessPowerMessage(PowerEvent event_id);
// Constructor.
// Don't use this; access SystemMonitor via the Singleton.
SystemMonitor();
private:
// Platform-specific method to check whether the system is currently
// running on battery power. Returns true if running on batteries,
// false otherwise.
bool IsBatteryPower();
// Checks the battery status and notifies observers if the battery
// status has changed.
void BatteryCheck();
// Functions to trigger notifications.
void NotifyPowerStateChange();
void NotifySuspend();
void NotifyResume();
scoped_refptr<ObserverListThreadSafe<PowerObserver> > observer_list_;
bool battery_in_use_;
bool suspended_;
#if defined(ENABLE_BATTERY_MONITORING)
base::OneShotTimer<SystemMonitor> delayed_battery_check_;
#endif
DISALLOW_COPY_AND_ASSIGN(SystemMonitor);
};
}
#endif // BASE_SYSTEM_MONITOR_H_
|
