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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
// Copyright (c) 2012 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 CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_
#define CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_
#include <string>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/time.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_client_implementation_type.h"
#include "chromeos/dbus/power_supply_status.h"
namespace dbus {
class Bus;
}
namespace chromeos {
// Callback used for processing the idle time. The int64 param is the number of
// seconds the user has been idle.
typedef base::Callback<void(int64)> CalculateIdleTimeCallback;
typedef base::Callback<void(void)> IdleNotificationCallback;
typedef base::Callback<void(uint32)> PowerStateRequestIdCallback;
// Callback used for getting the current screen brightness. The param is in the
// range [0.0, 100.0].
typedef base::Callback<void(double)> GetScreenBrightnessPercentCallback;
// PowerManagerClient is used to communicate with the power manager.
class CHROMEOS_EXPORT PowerManagerClient {
public:
// Interface for observing changes from the power manager.
class Observer {
public:
enum ScreenDimmingState {
SCREEN_DIMMING_NONE = 0,
SCREEN_DIMMING_IDLE,
};
virtual ~Observer() {}
// Called when the brightness is changed.
// |level| is of the range [0, 100].
// |user_initiated| is true if the action is initiated by the user.
virtual void BrightnessChanged(int level, bool user_initiated) {}
// Called when a screen is turned on or off to request that Chrome enable or
// disable the corresponding CRTC for the output.
// |power_on| The new state of the power setting.
// |all_displays| True if this applies to all displays or false if it is
// the internal display only.
virtual void ScreenPowerSet(bool power_on, bool all_displays) {}
// Called when power supply polling takes place. |status| is a data
// structure that contains the current state of the power supply.
virtual void PowerChanged(const PowerSupplyStatus& status) {}
// Called when the system resumes from suspend.
virtual void SystemResumed() {}
// Called when the power button is pressed or released.
virtual void PowerButtonStateChanged(bool down,
const base::TimeTicks& timestamp) {}
// Called when the lock button is pressed or released.
virtual void LockButtonStateChanged(bool down,
const base::TimeTicks& timestamp) {}
// Called when we go idle for threshold time.
virtual void IdleNotify(int64 threshold_secs) {}
// Called when a request is received to dim or undim the screen in software
// (as opposed to the more-common method of adjusting the backlight).
virtual void ScreenDimmingRequested(ScreenDimmingState state) {}
};
enum UpdateRequestType {
UPDATE_INITIAL, // Initial update request.
UPDATE_USER, // User initialted update request.
UPDATE_POLL // Update requested by poll signal.
};
enum PowerStateOverrideType {
DISABLE_IDLE_DIM = 1 << 0, // Disable screen dimming on idle.
DISABLE_IDLE_BLANK = 1 << 1, // Disable screen blanking on idle.
DISABLE_IDLE_SUSPEND = 1 << 2, // Disable suspend on idle.
DISABLE_IDLE_LID_SUSPEND = 1 << 3, // Disable suspend on lid closed.
};
// Adds and removes the observer.
virtual void AddObserver(Observer* observer) = 0;
virtual void RemoveObserver(Observer* observer) = 0;
virtual bool HasObserver(Observer* observer) = 0;
// Decreases the screen brightness. |allow_off| controls whether or not
// it's allowed to turn off the back light.
virtual void DecreaseScreenBrightness(bool allow_off) = 0;
// Increases the screen brightness.
virtual void IncreaseScreenBrightness() = 0;
// Set the screen brightness to |percent|, in the range [0.0, 100.0].
// If |gradual| is true, the transition will be animated.
virtual void SetScreenBrightnessPercent(double percent, bool gradual) = 0;
// Asynchronously gets the current screen brightness, in the range
// [0.0, 100.0].
virtual void GetScreenBrightnessPercent(
const GetScreenBrightnessPercentCallback& callback) = 0;
// Decreases the keyboard brightness.
virtual void DecreaseKeyboardBrightness() = 0;
// Increases the keyboard brightness.
virtual void IncreaseKeyboardBrightness() = 0;
// Request for power supply status update.
virtual void RequestStatusUpdate(UpdateRequestType update_type) = 0;
// Requests restart of the system.
virtual void RequestRestart() = 0;
// Requests shutdown of the system.
virtual void RequestShutdown() = 0;
// Idle management functions:
// Calculates idle time asynchronously, after the idle time request has
// replied. It passes the idle time in seconds to |callback|. If it
// encounters some error, it passes -1 to |callback|.
virtual void CalculateIdleTime(const CalculateIdleTimeCallback& callback) = 0;
// Requests notification for Idle at a certain threshold.
// NOTE: This notification is one shot, once the machine has been idle for
// threshold time, a notification will be sent and then that request will be
// removed from the notification queue. If you wish notifications the next
// time the machine goes idle for that much time, request again.
virtual void RequestIdleNotification(int64 threshold_secs) = 0;
// Notifies the power manager that the user is active (i.e. generating input
// events).
virtual void NotifyUserActivity(
const base::TimeTicks& last_activity_time) = 0;
// Notifies the power manager that a video is currently playing. It also
// includes whether or not the containing window for the video is fullscreen.
virtual void NotifyVideoActivity(
const base::TimeTicks& last_activity_time,
bool is_fullscreen) = 0;
// Override the current power state on the machine. The overrides will be
// applied to the request ID specified. To specify a new request; use 0 as the
// request id and the method will call the provided callback with the new
// request ID for use with further calls. |duration| will be rounded down to
// the nearest second. The overrides parameter will & out the
// PowerStateOverrideType types to allow specific selection of overrides. For
// example, to override just dim and suspending but leaving blanking in, set
// overrides to, DISABLE_IDLE_DIM | DISABLE_IDLE_SUSPEND.
virtual void RequestPowerStateOverrides(
uint32 request_id,
base::TimeDelta duration,
int overrides,
const PowerStateRequestIdCallback& callback) = 0;
// Cancels the power state override request specified by request_id.
virtual void CancelPowerStateOverrides(uint32 request_id) = 0;
// Tells powerd whether or not we are in a projecting mode. This is used to
// adjust idleness thresholds and derived, on this side, from the number of
// video outputs attached.
virtual void SetIsProjecting(bool is_projecting) = 0;
// Creates the instance.
static PowerManagerClient* Create(DBusClientImplementationType type,
dbus::Bus* bus);
virtual ~PowerManagerClient();
protected:
// Create() should be used instead.
PowerManagerClient();
private:
DISALLOW_COPY_AND_ASSIGN(PowerManagerClient);
};
} // namespace chromeos
#endif // CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_
|
