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
|
/*
* Copyright (C) 2014 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.
*/
package com.android.dreams.dozetest;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Handler;
import android.os.PowerManager;
import android.service.dreams.DreamService;
import android.text.format.DateFormat;
import android.util.Log;
import android.view.Display;
import android.widget.TextView;
import java.util.Date;
/**
* Simple test for doze mode.
* <p>
* adb shell setprop debug.doze.component com.android.dreams.dozetest/.DozeTestDream
* </p>
*/
public class DozeTestDream extends DreamService {
private static final String TAG = DozeTestDream.class.getSimpleName();
private static final boolean DEBUG = false;
// Amount of time to allow to update the time shown on the screen before releasing
// the wakelock. This timeout is design to compensate for the fact that we don't
// currently have a way to know when time display contents have actually been
// refreshed once the dream has finished rendering a new frame.
private static final int UPDATE_TIME_TIMEOUT = 100;
// Not all hardware supports dozing. We should use Display.STATE_DOZE but
// for testing purposes it is convenient to use Display.STATE_ON so the
// test still works on hardware that does not support dozing.
private static final int DISPLAY_STATE_WHEN_DOZING = Display.STATE_ON;
private PowerManager mPowerManager;
private PowerManager.WakeLock mWakeLock;
private AlarmManager mAlarmManager;
private PendingIntent mAlarmIntent;
private Handler mHandler = new Handler();
private TextView mAlarmClock;
private final Date mTime = new Date();
private java.text.DateFormat mTimeFormat;
private boolean mDreaming;
private long mLastTime = Long.MIN_VALUE;
@Override
public void onCreate() {
super.onCreate();
mPowerManager = (PowerManager)getSystemService(Context.POWER_SERVICE);
mWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
mAlarmManager = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent("com.android.dreams.dozetest.ACTION_ALARM");
intent.setPackage(getPackageName());
IntentFilter filter = new IntentFilter();
filter.addAction(intent.getAction());
registerReceiver(mAlarmReceiver, filter);
mAlarmIntent = PendingIntent.getBroadcast(this, 0, intent,
PendingIntent.FLAG_CANCEL_CURRENT);
setDozeScreenState(DISPLAY_STATE_WHEN_DOZING);
}
@Override
public void onDestroy() {
super.onDestroy();
unregisterReceiver(mAlarmReceiver);
mAlarmIntent.cancel();
}
@Override
public void onAttachedToWindow() {
super.onAttachedToWindow();
setInteractive(false);
setLowProfile(true);
setFullscreen(true);
setContentView(R.layout.dream);
setScreenBright(false);
mAlarmClock = (TextView)findViewById(R.id.alarm_clock);
mTimeFormat = DateFormat.getTimeFormat(this);
}
@Override
public void onDreamingStarted() {
super.onDreamingStarted();
mDreaming = true;
Log.d(TAG, "Dream started: canDoze=" + canDoze());
performTimeUpdate();
startDozing();
}
@Override
public void onDreamingStopped() {
super.onDreamingStopped();
mDreaming = false;
Log.d(TAG, "Dream ended: isDozing=" + isDozing());
stopDozing();
cancelTimeUpdate();
}
private void performTimeUpdate() {
if (mDreaming) {
long now = System.currentTimeMillis();
now -= now % 60000; // back up to last minute boundary
if (mLastTime == now) {
return;
}
mLastTime = now;
mTime.setTime(now);
mAlarmClock.setText(mTimeFormat.format(mTime));
mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, now + 60000, mAlarmIntent);
mWakeLock.acquire(UPDATE_TIME_TIMEOUT + 5000 /*for testing brightness*/);
// flash the screen a bit to test these functions
setDozeScreenState(DISPLAY_STATE_WHEN_DOZING);
setDozeScreenBrightness(200);
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
setDozeScreenBrightness(50);
}
}, 2000);
mHandler.postDelayed(new Runnable() {
@Override
public void run() {
setDozeScreenState(Display.STATE_OFF);
}
}, 5000);
}
}
private void cancelTimeUpdate() {
mAlarmManager.cancel(mAlarmIntent);
}
private final BroadcastReceiver mAlarmReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
performTimeUpdate();
}
};
}
|
