/* * Copyright (C) 2008 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.Activity; import android.app.ActivityManagerNative; import android.app.AlarmManager; import android.app.IUiModeManager; import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; import android.app.StatusBarManager; import android.app.UiModeManager; import android.content.ActivityNotFoundException; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.pm.PackageManager; import android.content.res.Configuration; import android.location.Criteria; import android.location.Location; import android.location.LocationListener; import android.location.LocationManager; import android.os.BatteryManager; import android.os.Binder; import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.os.PowerManager; import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemClock; import android.provider.Settings; import android.text.format.DateUtils; import android.text.format.Time; import android.util.Slog; import java.io.FileDescriptor; import java.io.PrintWriter; import java.util.Iterator; import com.android.internal.R; import com.android.internal.app.DisableCarModeActivity; class UiModeManagerService extends IUiModeManager.Stub { private static final String TAG = UiModeManager.class.getSimpleName(); private static final boolean LOG = false; private static final String KEY_LAST_UPDATE_INTERVAL = "LAST_UPDATE_INTERVAL"; private static final int MSG_UPDATE_TWILIGHT = 0; private static final int MSG_ENABLE_LOCATION_UPDATES = 1; private static final int MSG_GET_NEW_LOCATION_UPDATE = 2; 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 static final String ACTION_UPDATE_NIGHT_MODE = "com.android.server.action.UPDATE_NIGHT_MODE"; private final Context mContext; final Object mLock = new Object(); private int mDockState = Intent.EXTRA_DOCK_STATE_UNDOCKED; private int mLastBroadcastState = Intent.EXTRA_DOCK_STATE_UNDOCKED; private int mNightMode = UiModeManager.MODE_NIGHT_NO; private boolean mCarModeEnabled = false; private boolean mCharging = false; private final boolean mCarModeKeepsScreenOn; private final boolean mDeskModeKeepsScreenOn; private boolean mComputedNightMode; private int mCurUiMode = 0; private int mSetUiMode = 0; private boolean mHoldingConfiguration = false; private Configuration mConfiguration = new Configuration(); private boolean mSystemReady; private NotificationManager mNotificationManager; private AlarmManager mAlarmManager; private LocationManager mLocationManager; private Location mLocation; private StatusBarManager mStatusBarManager; private final PowerManager.WakeLock mWakeLock; static Intent buildHomeIntent(String category) { Intent intent = new Intent(Intent.ACTION_MAIN); intent.addCategory(category); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); return intent; } // The broadcast receiver which receives the result of the ordered broadcast sent when // the dock state changes. The original ordered broadcast is sent with an initial result // code of RESULT_OK. If any of the registered broadcast receivers changes this value, e.g., // to RESULT_CANCELED, then the intent to start a dock app will not be sent. private final BroadcastReceiver mResultReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if (getResultCode() != Activity.RESULT_OK) { return; } final int enableFlags = intent.getIntExtra("enableFlags", 0); final int disableFlags = intent.getIntExtra("disableFlags", 0); synchronized (mLock) { // Launch a dock activity String category = null; if (UiModeManager.ACTION_ENTER_CAR_MODE.equals(intent.getAction())) { // Only launch car home when car mode is enabled and the caller // has asked us to switch to it. if ((enableFlags&UiModeManager.ENABLE_CAR_MODE_GO_CAR_HOME) != 0) { category = Intent.CATEGORY_CAR_DOCK; } } else if (UiModeManager.ACTION_ENTER_DESK_MODE.equals(intent.getAction())) { // Only launch car home when desk mode is enabled and the caller // has asked us to switch to it. Currently re-using the car // mode flag since we don't have a formal API for "desk mode". if ((enableFlags&UiModeManager.ENABLE_CAR_MODE_GO_CAR_HOME) != 0) { category = Intent.CATEGORY_DESK_DOCK; } } else { // Launch the standard home app if requested. if ((disableFlags&UiModeManager.DISABLE_CAR_MODE_GO_HOME) != 0) { category = Intent.CATEGORY_HOME; } } if (category != null) { // This is the new activity that will serve as home while // we are in care mode. Intent homeIntent = buildHomeIntent(category); // Now we are going to be careful about switching the // configuration and starting the activity -- we need to // do this in a specific order under control of the // activity manager, to do it cleanly. So compute the // new config, but don't set it yet, and let the // activity manager take care of both the start and config // change. Configuration newConfig = null; if (mHoldingConfiguration) { mHoldingConfiguration = false; updateConfigurationLocked(false); newConfig = mConfiguration; } try { ActivityManagerNative.getDefault().startActivityWithConfig( null, homeIntent, null, null, 0, null, null, 0, false, false, newConfig); mHoldingConfiguration = false; } catch (RemoteException e) { Slog.w(TAG, e.getCause()); } } if (mHoldingConfiguration) { mHoldingConfiguration = false; updateConfigurationLocked(true); } } } }; private final BroadcastReceiver mTwilightUpdateReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if (isDoingNightMode() && mNightMode == UiModeManager.MODE_NIGHT_AUTO) { mHandler.sendEmptyMessage(MSG_UPDATE_TWILIGHT); } } }; private final BroadcastReceiver mDockModeReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { int state = intent.getIntExtra(Intent.EXTRA_DOCK_STATE, Intent.EXTRA_DOCK_STATE_UNDOCKED); updateDockState(state); } }; private final BroadcastReceiver mBatteryReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { mCharging = (intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) != 0); synchronized (mLock) { if (mSystemReady) { updateLocked(0, 0); } } } }; private final BroadcastReceiver mUpdateLocationReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { if (Intent.ACTION_AIRPLANE_MODE_CHANGED.equals(intent.getAction())) { if (!intent.getBooleanExtra("state", false)) { // Airplane mode is now off! mHandler.sendEmptyMessage(MSG_GET_NEW_LOCATION_UPDATE); } } else { // Time zone has changed! mHandler.sendEmptyMessage(MSG_GET_NEW_LOCATION_UPDATE); } } }; // 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) { final boolean hasMoved = hasMoved(location); final boolean hasBetterAccuracy = mLocation == null || location.getAccuracy() < mLocation.getAccuracy(); if (hasMoved || hasBetterAccuracy) { synchronized (mLock) { mLocation = location; if (hasMoved && isDoingNightMode() && mNightMode == UiModeManager.MODE_NIGHT_AUTO) { mHandler.sendEmptyMessage(MSG_UPDATE_TWILIGHT); } } } } public void onProviderDisabled(String provider) { } public void onProviderEnabled(String provider) { } public void onStatusChanged(String provider, int status, Bundle extras) { } /* * The user has moved if the accuracy circles of the two locations * don't overlap. */ private boolean hasMoved(Location location) { if (location == null) { return false; } if (mLocation == null) { return true; } /* if new location is older than the current one, the devices hasn't * moved. */ if (location.getTime() < mLocation.getTime()) { return false; } /* Get the distance between the two points */ float distance = mLocation.distanceTo(location); /* Get the total accuracy radius for both locations */ float totalAccuracy = mLocation.getAccuracy() + location.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; } }; public UiModeManagerService(Context context) { mContext = context; ServiceManager.addService(Context.UI_MODE_SERVICE, this); mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE); mLocationManager = (LocationManager)mContext.getSystemService(Context.LOCATION_SERVICE); mContext.registerReceiver(mTwilightUpdateReceiver, new IntentFilter(ACTION_UPDATE_NIGHT_MODE)); mContext.registerReceiver(mDockModeReceiver, new IntentFilter(Intent.ACTION_DOCK_EVENT)); mContext.registerReceiver(mBatteryReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED)); IntentFilter filter = new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED); filter.addAction(Intent.ACTION_TIMEZONE_CHANGED); mContext.registerReceiver(mUpdateLocationReceiver, filter); PowerManager powerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE); mWakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG); mConfiguration.setToDefaults(); mCarModeKeepsScreenOn = (context.getResources().getInteger( com.android.internal.R.integer.config_carDockKeepsScreenOn) == 1); mDeskModeKeepsScreenOn = (context.getResources().getInteger( com.android.internal.R.integer.config_deskDockKeepsScreenOn) == 1); mNightMode = Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.UI_NIGHT_MODE, UiModeManager.MODE_NIGHT_AUTO); } public void disableCarMode(int flags) { synchronized (mLock) { setCarModeLocked(false); if (mSystemReady) { updateLocked(0, flags); } } } public void enableCarMode(int flags) { synchronized (mLock) { setCarModeLocked(true); if (mSystemReady) { updateLocked(flags, 0); } } } public int getCurrentModeType() { synchronized (mLock) { return mCurUiMode & Configuration.UI_MODE_TYPE_MASK; } } public void setNightMode(int mode) throws RemoteException { synchronized (mLock) { switch (mode) { case UiModeManager.MODE_NIGHT_NO: case UiModeManager.MODE_NIGHT_YES: case UiModeManager.MODE_NIGHT_AUTO: break; default: throw new IllegalArgumentException("Unknown mode: " + mode); } if (!isDoingNightMode()) { return; } if (mNightMode != mode) { long ident = Binder.clearCallingIdentity(); Settings.Secure.putInt(mContext.getContentResolver(), Settings.Secure.UI_NIGHT_MODE, mode); Binder.restoreCallingIdentity(ident); mNightMode = mode; updateLocked(0, 0); } } } public int getNightMode() throws RemoteException { return mNightMode; } void systemReady() { synchronized (mLock) { mSystemReady = true; mCarModeEnabled = mDockState == Intent.EXTRA_DOCK_STATE_CAR; updateLocked(0, 0); mHandler.sendEmptyMessage(MSG_ENABLE_LOCATION_UPDATES); } } boolean isDoingNightMode() { return mCarModeEnabled || mDockState != Intent.EXTRA_DOCK_STATE_UNDOCKED; } void setCarModeLocked(boolean enabled) { if (mCarModeEnabled != enabled) { mCarModeEnabled = enabled; } } void updateDockState(int newState) { synchronized (mLock) { if (newState != mDockState) { mDockState = newState; setCarModeLocked(mDockState == Intent.EXTRA_DOCK_STATE_CAR); if (mSystemReady) { updateLocked(UiModeManager.ENABLE_CAR_MODE_GO_CAR_HOME, 0); } } } } final void updateConfigurationLocked(boolean sendIt) { int uiMode = Configuration.UI_MODE_TYPE_NORMAL; if (mCarModeEnabled) { uiMode = Configuration.UI_MODE_TYPE_CAR; } else if (mDockState == Intent.EXTRA_DOCK_STATE_DESK) { uiMode = Configuration.UI_MODE_TYPE_DESK; } if (mCarModeEnabled) { if (mNightMode == UiModeManager.MODE_NIGHT_AUTO) { updateTwilightLocked(); uiMode |= mComputedNightMode ? Configuration.UI_MODE_NIGHT_YES : Configuration.UI_MODE_NIGHT_NO; } else { uiMode |= mNightMode << 4; } } else { // Disabling the car mode clears the night mode. uiMode = (uiMode & ~Configuration.UI_MODE_NIGHT_MASK) | Configuration.UI_MODE_NIGHT_NO; } if (LOG) { Slog.d(TAG, "updateConfigurationLocked: mDockState=" + mDockState + "; mCarMode=" + mCarModeEnabled + "; mNightMode=" + mNightMode + "; uiMode=" + uiMode); } mCurUiMode = uiMode; if (!mHoldingConfiguration && uiMode != mSetUiMode) { mSetUiMode = uiMode; mConfiguration.uiMode = uiMode; if (sendIt) { try { ActivityManagerNative.getDefault().updateConfiguration(mConfiguration); } catch (RemoteException e) { Slog.w(TAG, "Failure communicating with activity manager", e); } } } } final void updateLocked(int enableFlags, int disableFlags) { long ident = Binder.clearCallingIdentity(); try { String action = null; String oldAction = null; if (mLastBroadcastState == Intent.EXTRA_DOCK_STATE_CAR) { adjustStatusBarCarModeLocked(); oldAction = UiModeManager.ACTION_EXIT_CAR_MODE; } else if (mLastBroadcastState == Intent.EXTRA_DOCK_STATE_DESK) { oldAction = UiModeManager.ACTION_EXIT_DESK_MODE; } if (mCarModeEnabled) { if (mLastBroadcastState != Intent.EXTRA_DOCK_STATE_CAR) { adjustStatusBarCarModeLocked(); if (oldAction != null) { mContext.sendBroadcast(new Intent(oldAction)); } mLastBroadcastState = Intent.EXTRA_DOCK_STATE_CAR; action = UiModeManager.ACTION_ENTER_CAR_MODE; } } else if (mDockState == Intent.EXTRA_DOCK_STATE_DESK) { if (mLastBroadcastState != Intent.EXTRA_DOCK_STATE_DESK) { if (oldAction != null) { mContext.sendBroadcast(new Intent(oldAction)); } mLastBroadcastState = Intent.EXTRA_DOCK_STATE_DESK; action = UiModeManager.ACTION_ENTER_DESK_MODE; } } else { mLastBroadcastState = Intent.EXTRA_DOCK_STATE_UNDOCKED; action = oldAction; } if (action != null) { // Send the ordered broadcast; the result receiver will receive after all // broadcasts have been sent. If any broadcast receiver changes the result // code from the initial value of RESULT_OK, then the result receiver will // not launch the corresponding dock application. This gives apps a chance // to override the behavior and stay in their app even when the device is // placed into a dock. Intent intent = new Intent(action); intent.putExtra("enableFlags", enableFlags); intent.putExtra("disableFlags", disableFlags); mContext.sendOrderedBroadcast(intent, null, mResultReceiver, null, Activity.RESULT_OK, null, null); // Attempting to make this transition a little more clean, we are going // to hold off on doing a configuration change until we have finished // the broadcast and started the home activity. mHoldingConfiguration = true; } else { Intent homeIntent = null; if (mCarModeEnabled) { if ((enableFlags&UiModeManager.ENABLE_CAR_MODE_GO_CAR_HOME) != 0) { homeIntent = buildHomeIntent(Intent.CATEGORY_CAR_DOCK); } } else if (mDockState == Intent.EXTRA_DOCK_STATE_DESK) { if ((enableFlags&UiModeManager.ENABLE_CAR_MODE_GO_CAR_HOME) != 0) { homeIntent = buildHomeIntent(Intent.CATEGORY_DESK_DOCK); } } else { if ((disableFlags&UiModeManager.DISABLE_CAR_MODE_GO_HOME) != 0) { homeIntent = buildHomeIntent(Intent.CATEGORY_HOME); } } if (homeIntent != null) { try { mContext.startActivity(homeIntent); } catch (ActivityNotFoundException e) { } } } updateConfigurationLocked(true); // keep screen on when charging and in car mode boolean keepScreenOn = mCharging && ((mCarModeEnabled && mCarModeKeepsScreenOn) || (mCurUiMode == Configuration.UI_MODE_TYPE_DESK && mDeskModeKeepsScreenOn)); if (keepScreenOn != mWakeLock.isHeld()) { if (keepScreenOn) { mWakeLock.acquire(); } else { mWakeLock.release(); } } } finally { Binder.restoreCallingIdentity(ident); } } private void adjustStatusBarCarModeLocked() { if (mStatusBarManager == null) { mStatusBarManager = (StatusBarManager) mContext.getSystemService(Context.STATUS_BAR_SERVICE); } // Fear not: StatusBarManagerService manages a list of requests to disable // features of the status bar; these are ORed together to form the // active disabled list. So if (for example) the device is locked and // the status bar should be totally disabled, the calls below will // have no effect until the device is unlocked. if (mStatusBarManager != null) { mStatusBarManager.disable(mCarModeEnabled ? StatusBarManager.DISABLE_NOTIFICATION_TICKER : StatusBarManager.DISABLE_NONE); } if (mNotificationManager == null) { mNotificationManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE); } if (mNotificationManager != null) { if (mCarModeEnabled) { Intent carModeOffIntent = new Intent(mContext, DisableCarModeActivity.class); Notification n = new Notification(); n.icon = R.drawable.stat_notify_car_mode; n.defaults = Notification.DEFAULT_LIGHTS; n.flags = Notification.FLAG_ONGOING_EVENT; n.when = 0; n.setLatestEventInfo( mContext, mContext.getString(R.string.car_mode_disable_notification_title), mContext.getString(R.string.car_mode_disable_notification_message), PendingIntent.getActivity(mContext, 0, carModeOffIntent, 0)); mNotificationManager.notify(0, n); } else { mNotificationManager.cancel(0); } } } private final Handler mHandler = new Handler() { boolean mPassiveListenerEnabled; boolean mNetworkListenerEnabled; boolean mDidFirstInit; long mLastNetworkRegisterTime = -MIN_LOCATION_UPDATE_MS; @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_UPDATE_TWILIGHT: synchronized (mLock) { if (isDoingNightMode() && mLocation != null && mNightMode == UiModeManager.MODE_NIGHT_AUTO) { updateTwilightLocked(); updateLocked(0, 0); } } 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(); } synchronized (mLock) { if (isDoingNightMode() && mLocation != null && mNightMode == UiModeManager.MODE_NIGHT_AUTO) { updateTwilightLocked(); updateLocked(0, 0); } } } } // 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)) { long interval = msg.getData().getLong(KEY_LAST_UPDATE_INTERVAL); interval *= 1.5; if (interval == 0) { interval = LOCATION_UPDATE_ENABLE_INTERVAL_MIN; } else if (interval > LOCATION_UPDATE_ENABLE_INTERVAL_MAX) { interval = LOCATION_UPDATE_ENABLE_INTERVAL_MAX; } Bundle bundle = new Bundle(); bundle.putLong(KEY_LAST_UPDATE_INTERVAL, interval); Message newMsg = mHandler.obtainMessage(MSG_ENABLE_LOCATION_UPDATES); newMsg.setData(bundle); mHandler.sendMessageDelayed(newMsg, interval); } break; } } private void retrieveLocation() { Location location = null; final Iterator 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.getTime() < lastKnownLocation.getTime())) { 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()); } synchronized (mLock) { mLocation = location; } } }; void updateTwilightLocked() { if (mLocation == null) { return; } final long currentTime = System.currentTimeMillis(); boolean nightMode; // calculate current twilight TwilightCalculator tw = new TwilightCalculator(); tw.calculateTwilight(currentTime, mLocation.getLatitude(), mLocation.getLongitude()); if (tw.mState == TwilightCalculator.DAY) { nightMode = false; } else { nightMode = true; } // schedule next update long nextUpdate = 0; if (tw.mSunrise == -1 || tw.mSunset == -1) { // In the case the day or night never ends the update is scheduled 12 hours later. nextUpdate = currentTime + 12 * DateUtils.HOUR_IN_MILLIS; } else { final int mLastTwilightState = tw.mState; // add some extra time to be on the save side. nextUpdate += DateUtils.MINUTE_IN_MILLIS; if (currentTime > tw.mSunset) { // next update should be on the following day tw.calculateTwilight(currentTime + DateUtils.DAY_IN_MILLIS, mLocation.getLatitude(), mLocation.getLongitude()); } if (mLastTwilightState == TwilightCalculator.NIGHT) { nextUpdate += tw.mSunrise; } else { nextUpdate += tw.mSunset; } } Intent updateIntent = new Intent(ACTION_UPDATE_NIGHT_MODE); PendingIntent pendingIntent = PendingIntent.getBroadcast(mContext, 0, updateIntent, 0); mAlarmManager.cancel(pendingIntent); mAlarmManager.set(AlarmManager.RTC_WAKEUP, nextUpdate, pendingIntent); mComputedNightMode = nightMode; } @Override protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) != PackageManager.PERMISSION_GRANTED) { pw.println("Permission Denial: can't dump uimode service from from pid=" + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid()); return; } synchronized (mLock) { pw.println("Current UI Mode Service state:"); pw.print(" mDockState="); pw.print(mDockState); pw.print(" mLastBroadcastState="); pw.println(mLastBroadcastState); pw.print(" mNightMode="); pw.print(mNightMode); pw.print(" mCarModeEnabled="); pw.print(mCarModeEnabled); pw.print(" mComputedNightMode="); pw.println(mComputedNightMode); pw.print(" mCurUiMode=0x"); pw.print(Integer.toHexString(mCurUiMode)); pw.print(" mSetUiMode=0x"); pw.println(Integer.toHexString(mSetUiMode)); pw.print(" mHoldingConfiguration="); pw.print(mHoldingConfiguration); pw.print(" mSystemReady="); pw.println(mSystemReady); if (mLocation != null) { pw.print(" mLocation="); pw.println(mLocation); } } } }