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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
|
/*
* Copyright (C) 2012 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.server;
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.location.Criteria;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.text.format.DateUtils;
import android.text.format.Time;
import android.util.Slog;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import libcore.util.Objects;
/**
* Figures out whether it's twilight time based on the user's location.
*
* Used by the UI mode manager and other components to adjust night mode
* effects based on sunrise and sunset.
*/
public final class TwilightService {
private static final String TAG = "TwilightService";
private static final boolean DEBUG = false;
private static final String ACTION_UPDATE_TWILIGHT_STATE =
"com.android.server.action.UPDATE_TWILIGHT_STATE";
private final Context mContext;
private final AlarmManager mAlarmManager;
private final LocationManager mLocationManager;
private final LocationHandler mLocationHandler;
private final Object mLock = new Object();
private final ArrayList<TwilightListenerRecord> mListeners =
new ArrayList<TwilightListenerRecord>();
private boolean mSystemReady;
private TwilightState mTwilightState;
public TwilightService(Context context) {
mContext = context;
mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
mLocationManager = (LocationManager)mContext.getSystemService(Context.LOCATION_SERVICE);
mLocationHandler = new LocationHandler();
}
void systemReady() {
synchronized (mLock) {
mSystemReady = true;
IntentFilter filter = new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED);
filter.addAction(Intent.ACTION_TIME_CHANGED);
filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
filter.addAction(ACTION_UPDATE_TWILIGHT_STATE);
mContext.registerReceiver(mUpdateLocationReceiver, filter);
if (!mListeners.isEmpty()) {
mLocationHandler.enableLocationUpdates();
}
}
}
/**
* Gets the current twilight state.
*
* @return The current twilight state, or null if no information is available.
*/
public TwilightState getCurrentState() {
synchronized (mLock) {
return mTwilightState;
}
}
/**
* Listens for twilight time.
*
* @param listener The listener.
* @param handler The handler on which to post calls into the listener.
*/
public void registerListener(TwilightListener listener, Handler handler) {
synchronized (mLock) {
mListeners.add(new TwilightListenerRecord(listener, handler));
if (mSystemReady && mListeners.size() == 1) {
mLocationHandler.enableLocationUpdates();
}
}
}
private void setTwilightState(TwilightState state) {
synchronized (mLock) {
if (!Objects.equal(mTwilightState, state)) {
if (DEBUG) {
Slog.d(TAG, "Twilight state changed: " + state);
}
mTwilightState = state;
int count = mListeners.size();
for (int i = 0; i < count; i++) {
mListeners.get(i).post();
}
}
}
}
// The user has moved if the accuracy circles of the two locations don't overlap.
private static boolean hasMoved(Location from, Location to) {
if (to == null) {
return false;
}
if (from == null) {
return true;
}
// if new location is older than the current one, the device hasn't moved.
if (to.getElapsedRealtimeNanos() < from.getElapsedRealtimeNanos()) {
return false;
}
// Get the distance between the two points.
float distance = from.distanceTo(to);
// Get the total accuracy radius for both locations.
float totalAccuracy = from.getAccuracy() + to.getAccuracy();
// If the distance is greater than the combined accuracy of the two
// points then they can't overlap and hence the user has moved.
return distance >= totalAccuracy;
}
/**
* Describes whether it is day or night.
* This object is immutable.
*/
public static final class TwilightState {
private final boolean mIsNight;
private final long mYesterdaySunset;
private final long mTodaySunrise;
private final long mTodaySunset;
private final long mTomorrowSunrise;
TwilightState(boolean isNight,
long yesterdaySunset,
long todaySunrise, long todaySunset,
long tomorrowSunrise) {
mIsNight = isNight;
mYesterdaySunset = yesterdaySunset;
mTodaySunrise = todaySunrise;
mTodaySunset = todaySunset;
mTomorrowSunrise = tomorrowSunrise;
}
/**
* Returns true if it is currently night time.
*/
public boolean isNight() {
return mIsNight;
}
/**
* Returns the time of yesterday's sunset in the System.currentTimeMillis() timebase,
* or -1 if the sun never sets.
*/
public long getYesterdaySunset() {
return mYesterdaySunset;
}
/**
* Returns the time of today's sunrise in the System.currentTimeMillis() timebase,
* or -1 if the sun never rises.
*/
public long getTodaySunrise() {
return mTodaySunrise;
}
/**
* Returns the time of today's sunset in the System.currentTimeMillis() timebase,
* or -1 if the sun never sets.
*/
public long getTodaySunset() {
return mTodaySunset;
}
/**
* Returns the time of tomorrow's sunrise in the System.currentTimeMillis() timebase,
* or -1 if the sun never rises.
*/
public long getTomorrowSunrise() {
return mTomorrowSunrise;
}
@Override
public boolean equals(Object o) {
return o instanceof TwilightState && equals((TwilightState)o);
}
public boolean equals(TwilightState other) {
return other != null
&& mIsNight == other.mIsNight
&& mYesterdaySunset == other.mYesterdaySunset
&& mTodaySunrise == other.mTodaySunrise
&& mTodaySunset == other.mTodaySunset
&& mTomorrowSunrise == other.mTomorrowSunrise;
}
@Override
public int hashCode() {
return 0; // don't care
}
@Override
public String toString() {
DateFormat f = DateFormat.getDateTimeInstance();
return "{TwilightState: isNight=" + mIsNight
+ ", mYesterdaySunset=" + f.format(new Date(mYesterdaySunset))
+ ", mTodaySunrise=" + f.format(new Date(mTodaySunrise))
+ ", mTodaySunset=" + f.format(new Date(mTodaySunset))
+ ", mTomorrowSunrise=" + f.format(new Date(mTomorrowSunrise))
+ "}";
}
}
/**
* Listener for changes in twilight state.
*/
public interface TwilightListener {
public void onTwilightStateChanged();
}
private static final class TwilightListenerRecord implements Runnable {
private final TwilightListener mListener;
private final Handler mHandler;
public TwilightListenerRecord(TwilightListener listener, Handler handler) {
mListener = listener;
mHandler = handler;
}
public void post() {
mHandler.post(this);
}
@Override
public void run() {
mListener.onTwilightStateChanged();
}
}
private final class LocationHandler extends Handler {
private static final int MSG_ENABLE_LOCATION_UPDATES = 1;
private static final int MSG_GET_NEW_LOCATION_UPDATE = 2;
private static final int MSG_PROCESS_NEW_LOCATION = 3;
private static final int MSG_DO_TWILIGHT_UPDATE = 4;
private static final long LOCATION_UPDATE_MS = 24 * DateUtils.HOUR_IN_MILLIS;
private static final long MIN_LOCATION_UPDATE_MS = 30 * DateUtils.MINUTE_IN_MILLIS;
private static final float LOCATION_UPDATE_DISTANCE_METER = 1000 * 20;
private static final long LOCATION_UPDATE_ENABLE_INTERVAL_MIN = 5000;
private static final long LOCATION_UPDATE_ENABLE_INTERVAL_MAX =
15 * DateUtils.MINUTE_IN_MILLIS;
private static final double FACTOR_GMT_OFFSET_LONGITUDE =
1000.0 * 360.0 / DateUtils.DAY_IN_MILLIS;
private boolean mPassiveListenerEnabled;
private boolean mNetworkListenerEnabled;
private boolean mDidFirstInit;
private long mLastNetworkRegisterTime = -MIN_LOCATION_UPDATE_MS;
private long mLastUpdateInterval;
private Location mLocation;
private final TwilightCalculator mTwilightCalculator = new TwilightCalculator();
public void processNewLocation(Location location) {
Message msg = obtainMessage(MSG_PROCESS_NEW_LOCATION, location);
sendMessage(msg);
}
public void enableLocationUpdates() {
sendEmptyMessage(MSG_ENABLE_LOCATION_UPDATES);
}
public void requestLocationUpdate() {
sendEmptyMessage(MSG_GET_NEW_LOCATION_UPDATE);
}
public void requestTwilightUpdate() {
sendEmptyMessage(MSG_DO_TWILIGHT_UPDATE);
}
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_PROCESS_NEW_LOCATION: {
final Location location = (Location)msg.obj;
final boolean hasMoved = hasMoved(mLocation, location);
final boolean hasBetterAccuracy = mLocation == null
|| location.getAccuracy() < mLocation.getAccuracy();
if (DEBUG) {
Slog.d(TAG, "Processing new location: " + location
+ ", hasMoved=" + hasMoved
+ ", hasBetterAccuracy=" + hasBetterAccuracy);
}
if (hasMoved || hasBetterAccuracy) {
setLocation(location);
}
break;
}
case MSG_GET_NEW_LOCATION_UPDATE:
if (!mNetworkListenerEnabled) {
// Don't do anything -- we are still trying to get a
// location.
return;
}
if ((mLastNetworkRegisterTime + MIN_LOCATION_UPDATE_MS) >=
SystemClock.elapsedRealtime()) {
// Don't do anything -- it hasn't been long enough
// since we last requested an update.
return;
}
// Unregister the current location monitor, so we can
// register a new one for it to get an immediate update.
mNetworkListenerEnabled = false;
mLocationManager.removeUpdates(mEmptyLocationListener);
// Fall through to re-register listener.
case MSG_ENABLE_LOCATION_UPDATES:
// enable network provider to receive at least location updates for a given
// distance.
boolean networkLocationEnabled;
try {
networkLocationEnabled =
mLocationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
} catch (Exception e) {
// we may get IllegalArgumentException if network location provider
// does not exist or is not yet installed.
networkLocationEnabled = false;
}
if (!mNetworkListenerEnabled && networkLocationEnabled) {
mNetworkListenerEnabled = true;
mLastNetworkRegisterTime = SystemClock.elapsedRealtime();
mLocationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,
LOCATION_UPDATE_MS, 0, mEmptyLocationListener);
if (!mDidFirstInit) {
mDidFirstInit = true;
if (mLocation == null) {
retrieveLocation();
}
}
}
// enable passive provider to receive updates from location fixes (gps
// and network).
boolean passiveLocationEnabled;
try {
passiveLocationEnabled =
mLocationManager.isProviderEnabled(LocationManager.PASSIVE_PROVIDER);
} catch (Exception e) {
// we may get IllegalArgumentException if passive location provider
// does not exist or is not yet installed.
passiveLocationEnabled = false;
}
if (!mPassiveListenerEnabled && passiveLocationEnabled) {
mPassiveListenerEnabled = true;
mLocationManager.requestLocationUpdates(LocationManager.PASSIVE_PROVIDER,
0, LOCATION_UPDATE_DISTANCE_METER , mLocationListener);
}
if (!(mNetworkListenerEnabled && mPassiveListenerEnabled)) {
mLastUpdateInterval *= 1.5;
if (mLastUpdateInterval == 0) {
mLastUpdateInterval = LOCATION_UPDATE_ENABLE_INTERVAL_MIN;
} else if (mLastUpdateInterval > LOCATION_UPDATE_ENABLE_INTERVAL_MAX) {
mLastUpdateInterval = LOCATION_UPDATE_ENABLE_INTERVAL_MAX;
}
sendEmptyMessageDelayed(MSG_ENABLE_LOCATION_UPDATES, mLastUpdateInterval);
}
break;
case MSG_DO_TWILIGHT_UPDATE:
updateTwilightState();
break;
}
}
private void retrieveLocation() {
Location location = null;
final Iterator<String> providers =
mLocationManager.getProviders(new Criteria(), true).iterator();
while (providers.hasNext()) {
final Location lastKnownLocation =
mLocationManager.getLastKnownLocation(providers.next());
// pick the most recent location
if (location == null || (lastKnownLocation != null &&
location.getElapsedRealtimeNanos() <
lastKnownLocation.getElapsedRealtimeNanos())) {
location = lastKnownLocation;
}
}
// In the case there is no location available (e.g. GPS fix or network location
// is not available yet), the longitude of the location is estimated using the timezone,
// latitude and accuracy are set to get a good average.
if (location == null) {
Time currentTime = new Time();
currentTime.set(System.currentTimeMillis());
double lngOffset = FACTOR_GMT_OFFSET_LONGITUDE *
(currentTime.gmtoff - (currentTime.isDst > 0 ? 3600 : 0));
location = new Location("fake");
location.setLongitude(lngOffset);
location.setLatitude(0);
location.setAccuracy(417000.0f);
location.setTime(System.currentTimeMillis());
location.setElapsedRealtimeNanos(SystemClock.elapsedRealtimeNanos());
if (DEBUG) {
Slog.d(TAG, "Estimated location from timezone: " + location);
}
}
setLocation(location);
}
private void setLocation(Location location) {
mLocation = location;
updateTwilightState();
}
private void updateTwilightState() {
if (mLocation == null) {
setTwilightState(null);
return;
}
final long now = System.currentTimeMillis();
// calculate yesterday's twilight
mTwilightCalculator.calculateTwilight(now - DateUtils.DAY_IN_MILLIS,
mLocation.getLatitude(), mLocation.getLongitude());
final long yesterdaySunset = mTwilightCalculator.mSunset;
// calculate today's twilight
mTwilightCalculator.calculateTwilight(now,
mLocation.getLatitude(), mLocation.getLongitude());
final boolean isNight = (mTwilightCalculator.mState == TwilightCalculator.NIGHT);
final long todaySunrise = mTwilightCalculator.mSunrise;
final long todaySunset = mTwilightCalculator.mSunset;
// calculate tomorrow's twilight
mTwilightCalculator.calculateTwilight(now + DateUtils.DAY_IN_MILLIS,
mLocation.getLatitude(), mLocation.getLongitude());
final long tomorrowSunrise = mTwilightCalculator.mSunrise;
// set twilight state
TwilightState state = new TwilightState(isNight, yesterdaySunset,
todaySunrise, todaySunset, tomorrowSunrise);
if (DEBUG) {
Slog.d(TAG, "Updating twilight state: " + state);
}
setTwilightState(state);
// schedule next update
long nextUpdate = 0;
if (todaySunrise == -1 || todaySunset == -1) {
// In the case the day or night never ends the update is scheduled 12 hours later.
nextUpdate = now + 12 * DateUtils.HOUR_IN_MILLIS;
} else {
// add some extra time to be on the safe side.
nextUpdate += DateUtils.MINUTE_IN_MILLIS;
if (now > todaySunset) {
nextUpdate += tomorrowSunrise;
} else if (now > todaySunrise) {
nextUpdate += todaySunset;
} else {
nextUpdate += todaySunrise;
}
}
if (DEBUG) {
Slog.d(TAG, "Next update in " + (nextUpdate - now) + " ms");
}
Intent updateIntent = new Intent(ACTION_UPDATE_TWILIGHT_STATE);
PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, updateIntent, 0);
mAlarmManager.cancel(pendingIntent);
mAlarmManager.setExact(AlarmManager.RTC, nextUpdate, pendingIntent);
}
};
private final BroadcastReceiver mUpdateLocationReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
if (Intent.ACTION_AIRPLANE_MODE_CHANGED.equals(intent.getAction())
&& !intent.getBooleanExtra("state", false)) {
// Airplane mode is now off!
mLocationHandler.requestLocationUpdate();
return;
}
// Time zone has changed or alarm expired.
mLocationHandler.requestTwilightUpdate();
}
};
// A LocationListener to initialize the network location provider. The location updates
// are handled through the passive location provider.
private final LocationListener mEmptyLocationListener = new LocationListener() {
public void onLocationChanged(Location location) {
}
public void onProviderDisabled(String provider) {
}
public void onProviderEnabled(String provider) {
}
public void onStatusChanged(String provider, int status, Bundle extras) {
}
};
private final LocationListener mLocationListener = new LocationListener() {
public void onLocationChanged(Location location) {
mLocationHandler.processNewLocation(location);
}
public void onProviderDisabled(String provider) {
}
public void onProviderEnabled(String provider) {
}
public void onStatusChanged(String provider, int status, Bundle extras) {
}
};
}
|