/*
|
* 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.power;
|
|
import android.annotation.Nullable;
|
import android.annotation.UserIdInt;
|
import android.app.ActivityManagerInternal;
|
import android.app.AppOpsManager;
|
import android.app.trust.TrustManager;
|
import android.content.BroadcastReceiver;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.hardware.input.InputManagerInternal;
|
import android.media.AudioAttributes;
|
import android.media.AudioManager;
|
import android.media.Ringtone;
|
import android.media.RingtoneManager;
|
import android.metrics.LogMaker;
|
import android.net.Uri;
|
import android.os.BatteryStats;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.os.Message;
|
import android.os.PowerManager;
|
import android.os.PowerManager.WakeReason;
|
import android.os.PowerManagerInternal;
|
import android.os.Process;
|
import android.os.RemoteException;
|
import android.os.SystemClock;
|
import android.os.UserHandle;
|
import android.os.VibrationEffect;
|
import android.os.Vibrator;
|
import android.os.WorkSource;
|
import android.provider.Settings;
|
import android.util.EventLog;
|
import android.util.Slog;
|
import android.util.StatsLog;
|
import android.view.WindowManagerPolicyConstants.OnReason;
|
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.app.IBatteryStats;
|
import com.android.internal.logging.MetricsLogger;
|
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
|
import com.android.server.EventLogTags;
|
import com.android.server.LocalServices;
|
import com.android.server.inputmethod.InputMethodManagerInternal;
|
import com.android.server.policy.WindowManagerPolicy;
|
import com.android.server.statusbar.StatusBarManagerInternal;
|
|
/**
|
* Sends broadcasts about important power state changes.
|
* <p>
|
* This methods of this class may be called by the power manager service while
|
* its lock is being held. Internally it takes care of sending broadcasts to
|
* notify other components of the system or applications asynchronously.
|
* </p><p>
|
* The notifier is designed to collapse unnecessary broadcasts when it is not
|
* possible for the system to have observed an intermediate state.
|
* </p><p>
|
* For example, if the device wakes up, goes to sleep, wakes up again and goes to
|
* sleep again before the wake up notification is sent, then the system will
|
* be told about only one wake up and sleep. However, we always notify the
|
* fact that at least one transition occurred. It is especially important to
|
* tell the system when we go to sleep so that it can lock the keyguard if needed.
|
* </p>
|
*/
|
@VisibleForTesting
|
public class Notifier {
|
private static final String TAG = "PowerManagerNotifier";
|
|
private static final boolean DEBUG = false;
|
|
private static final int INTERACTIVE_STATE_UNKNOWN = 0;
|
private static final int INTERACTIVE_STATE_AWAKE = 1;
|
private static final int INTERACTIVE_STATE_ASLEEP = 2;
|
|
private static final int MSG_USER_ACTIVITY = 1;
|
private static final int MSG_BROADCAST = 2;
|
private static final int MSG_WIRELESS_CHARGING_STARTED = 3;
|
private static final int MSG_SCREEN_BRIGHTNESS_BOOST_CHANGED = 4;
|
private static final int MSG_PROFILE_TIMED_OUT = 5;
|
private static final int MSG_WIRED_CHARGING_STARTED = 6;
|
|
private static final long[] WIRELESS_VIBRATION_TIME = {
|
40, 40, 40, 40, 40, 40, 40, 40, 40, // ramp-up sampling rate = 40ms
|
40, 40, 40, 40, 40, 40, 40 // ramp-down sampling rate = 40ms
|
};
|
private static final int[] WIRELESS_VIBRATION_AMPLITUDE = {
|
1, 4, 11, 25, 44, 67, 91, 114, 123, // ramp-up amplitude (from 0 to 50%)
|
103, 79, 55, 34, 17, 7, 2 // ramp-up amplitude
|
};
|
private static final VibrationEffect WIRELESS_CHARGING_VIBRATION_EFFECT =
|
VibrationEffect.createWaveform(WIRELESS_VIBRATION_TIME, WIRELESS_VIBRATION_AMPLITUDE,
|
-1);
|
private static final AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder()
|
.setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
|
.build();
|
|
private final Object mLock = new Object();
|
|
private final Context mContext;
|
private final IBatteryStats mBatteryStats;
|
private final AppOpsManager mAppOps;
|
private final SuspendBlocker mSuspendBlocker;
|
private final WindowManagerPolicy mPolicy;
|
private final ActivityManagerInternal mActivityManagerInternal;
|
private final InputManagerInternal mInputManagerInternal;
|
private final InputMethodManagerInternal mInputMethodManagerInternal;
|
@Nullable private final StatusBarManagerInternal mStatusBarManagerInternal;
|
private final TrustManager mTrustManager;
|
private final Vibrator mVibrator;
|
|
private final NotifierHandler mHandler;
|
private final Intent mScreenOnIntent;
|
private final Intent mScreenOffIntent;
|
private final Intent mScreenBrightnessBoostIntent;
|
|
// True if the device should suspend when the screen is off due to proximity.
|
private final boolean mSuspendWhenScreenOffDueToProximityConfig;
|
|
// The current interactive state. This is set as soon as an interactive state
|
// transition begins so as to capture the reason that it happened. At some point
|
// this state will propagate to the pending state then eventually to the
|
// broadcasted state over the course of reporting the transition asynchronously.
|
private boolean mInteractive = true;
|
private int mInteractiveChangeReason;
|
private long mInteractiveChangeStartTime; // In SystemClock.uptimeMillis()
|
private boolean mInteractiveChanging;
|
|
// The pending interactive state that we will eventually want to broadcast.
|
// This is designed so that we can collapse redundant sequences of awake/sleep
|
// transition pairs while still guaranteeing that at least one transition is observed
|
// whenever this happens.
|
private int mPendingInteractiveState;
|
private boolean mPendingWakeUpBroadcast;
|
private boolean mPendingGoToSleepBroadcast;
|
|
// The currently broadcasted interactive state. This reflects what other parts of the
|
// system have observed.
|
private int mBroadcastedInteractiveState;
|
private boolean mBroadcastInProgress;
|
private long mBroadcastStartTime;
|
|
// True if a user activity message should be sent.
|
private boolean mUserActivityPending;
|
|
public Notifier(Looper looper, Context context, IBatteryStats batteryStats,
|
SuspendBlocker suspendBlocker, WindowManagerPolicy policy) {
|
mContext = context;
|
mBatteryStats = batteryStats;
|
mAppOps = mContext.getSystemService(AppOpsManager.class);
|
mSuspendBlocker = suspendBlocker;
|
mPolicy = policy;
|
mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);
|
mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);
|
mInputMethodManagerInternal = LocalServices.getService(InputMethodManagerInternal.class);
|
mStatusBarManagerInternal = LocalServices.getService(StatusBarManagerInternal.class);
|
mTrustManager = mContext.getSystemService(TrustManager.class);
|
mVibrator = mContext.getSystemService(Vibrator.class);
|
|
mHandler = new NotifierHandler(looper);
|
mScreenOnIntent = new Intent(Intent.ACTION_SCREEN_ON);
|
mScreenOnIntent.addFlags(
|
Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND
|
| Intent.FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS);
|
mScreenOffIntent = new Intent(Intent.ACTION_SCREEN_OFF);
|
mScreenOffIntent.addFlags(
|
Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND
|
| Intent.FLAG_RECEIVER_VISIBLE_TO_INSTANT_APPS);
|
mScreenBrightnessBoostIntent =
|
new Intent(PowerManager.ACTION_SCREEN_BRIGHTNESS_BOOST_CHANGED);
|
mScreenBrightnessBoostIntent.addFlags(
|
Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
|
|
mSuspendWhenScreenOffDueToProximityConfig = context.getResources().getBoolean(
|
com.android.internal.R.bool.config_suspendWhenScreenOffDueToProximity);
|
|
// Initialize interactive state for battery stats.
|
try {
|
mBatteryStats.noteInteractive(true);
|
} catch (RemoteException ex) { }
|
StatsLog.write(StatsLog.INTERACTIVE_STATE_CHANGED,
|
StatsLog.INTERACTIVE_STATE_CHANGED__STATE__ON);
|
}
|
|
/**
|
* Called when a wake lock is acquired.
|
*/
|
public void onWakeLockAcquired(int flags, String tag, String packageName,
|
int ownerUid, int ownerPid, WorkSource workSource, String historyTag) {
|
if (DEBUG) {
|
Slog.d(TAG, "onWakeLockAcquired: flags=" + flags + ", tag=\"" + tag
|
+ "\", packageName=" + packageName
|
+ ", ownerUid=" + ownerUid + ", ownerPid=" + ownerPid
|
+ ", workSource=" + workSource);
|
}
|
|
final int monitorType = getBatteryStatsWakeLockMonitorType(flags);
|
if (monitorType >= 0) {
|
try {
|
final boolean unimportantForLogging = ownerUid == Process.SYSTEM_UID
|
&& (flags & PowerManager.UNIMPORTANT_FOR_LOGGING) != 0;
|
if (workSource != null) {
|
mBatteryStats.noteStartWakelockFromSource(workSource, ownerPid, tag,
|
historyTag, monitorType, unimportantForLogging);
|
} else {
|
mBatteryStats.noteStartWakelock(ownerUid, ownerPid, tag, historyTag,
|
monitorType, unimportantForLogging);
|
// XXX need to deal with disabled operations.
|
mAppOps.startOpNoThrow(AppOpsManager.OP_WAKE_LOCK, ownerUid, packageName);
|
}
|
} catch (RemoteException ex) {
|
// Ignore
|
}
|
}
|
}
|
|
public void onLongPartialWakeLockStart(String tag, int ownerUid, WorkSource workSource,
|
String historyTag) {
|
if (DEBUG) {
|
Slog.d(TAG, "onLongPartialWakeLockStart: ownerUid=" + ownerUid
|
+ ", workSource=" + workSource);
|
}
|
|
try {
|
if (workSource != null) {
|
mBatteryStats.noteLongPartialWakelockStartFromSource(tag, historyTag, workSource);
|
StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, workSource,
|
tag, historyTag, StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED__STATE__ON);
|
} else {
|
mBatteryStats.noteLongPartialWakelockStart(tag, historyTag, ownerUid);
|
StatsLog.write_non_chained(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED,
|
ownerUid, null, tag, historyTag,
|
StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED__STATE__ON);
|
}
|
} catch (RemoteException ex) {
|
// Ignore
|
}
|
}
|
|
public void onLongPartialWakeLockFinish(String tag, int ownerUid, WorkSource workSource,
|
String historyTag) {
|
if (DEBUG) {
|
Slog.d(TAG, "onLongPartialWakeLockFinish: ownerUid=" + ownerUid
|
+ ", workSource=" + workSource);
|
}
|
|
try {
|
if (workSource != null) {
|
mBatteryStats.noteLongPartialWakelockFinishFromSource(tag, historyTag, workSource);
|
StatsLog.write(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED, workSource,
|
tag, historyTag, StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED__STATE__OFF);
|
} else {
|
mBatteryStats.noteLongPartialWakelockFinish(tag, historyTag, ownerUid);
|
StatsLog.write_non_chained(StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED,
|
ownerUid, null, tag, historyTag,
|
StatsLog.LONG_PARTIAL_WAKELOCK_STATE_CHANGED__STATE__OFF);
|
}
|
} catch (RemoteException ex) {
|
// Ignore
|
}
|
}
|
|
/**
|
* Called when a wake lock is changing.
|
*/
|
public void onWakeLockChanging(int flags, String tag, String packageName,
|
int ownerUid, int ownerPid, WorkSource workSource, String historyTag,
|
int newFlags, String newTag, String newPackageName, int newOwnerUid,
|
int newOwnerPid, WorkSource newWorkSource, String newHistoryTag) {
|
|
final int monitorType = getBatteryStatsWakeLockMonitorType(flags);
|
final int newMonitorType = getBatteryStatsWakeLockMonitorType(newFlags);
|
if (workSource != null && newWorkSource != null
|
&& monitorType >= 0 && newMonitorType >= 0) {
|
if (DEBUG) {
|
Slog.d(TAG, "onWakeLockChanging: flags=" + newFlags + ", tag=\"" + newTag
|
+ "\", packageName=" + newPackageName
|
+ ", ownerUid=" + newOwnerUid + ", ownerPid=" + newOwnerPid
|
+ ", workSource=" + newWorkSource);
|
}
|
|
final boolean unimportantForLogging = newOwnerUid == Process.SYSTEM_UID
|
&& (newFlags & PowerManager.UNIMPORTANT_FOR_LOGGING) != 0;
|
try {
|
mBatteryStats.noteChangeWakelockFromSource(workSource, ownerPid, tag, historyTag,
|
monitorType, newWorkSource, newOwnerPid, newTag, newHistoryTag,
|
newMonitorType, unimportantForLogging);
|
} catch (RemoteException ex) {
|
// Ignore
|
}
|
} else {
|
onWakeLockReleased(flags, tag, packageName, ownerUid, ownerPid, workSource, historyTag);
|
onWakeLockAcquired(newFlags, newTag, newPackageName, newOwnerUid, newOwnerPid,
|
newWorkSource, newHistoryTag);
|
}
|
}
|
|
/**
|
* Called when a wake lock is released.
|
*/
|
public void onWakeLockReleased(int flags, String tag, String packageName,
|
int ownerUid, int ownerPid, WorkSource workSource, String historyTag) {
|
if (DEBUG) {
|
Slog.d(TAG, "onWakeLockReleased: flags=" + flags + ", tag=\"" + tag
|
+ "\", packageName=" + packageName
|
+ ", ownerUid=" + ownerUid + ", ownerPid=" + ownerPid
|
+ ", workSource=" + workSource);
|
}
|
|
final int monitorType = getBatteryStatsWakeLockMonitorType(flags);
|
if (monitorType >= 0) {
|
try {
|
if (workSource != null) {
|
mBatteryStats.noteStopWakelockFromSource(workSource, ownerPid, tag,
|
historyTag, monitorType);
|
} else {
|
mBatteryStats.noteStopWakelock(ownerUid, ownerPid, tag,
|
historyTag, monitorType);
|
mAppOps.finishOp(AppOpsManager.OP_WAKE_LOCK, ownerUid, packageName);
|
}
|
} catch (RemoteException ex) {
|
// Ignore
|
}
|
}
|
}
|
|
private int getBatteryStatsWakeLockMonitorType(int flags) {
|
switch (flags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
|
case PowerManager.PARTIAL_WAKE_LOCK:
|
return BatteryStats.WAKE_TYPE_PARTIAL;
|
|
case PowerManager.SCREEN_DIM_WAKE_LOCK:
|
case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
|
return BatteryStats.WAKE_TYPE_FULL;
|
|
case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:
|
if (mSuspendWhenScreenOffDueToProximityConfig) {
|
return -1;
|
}
|
return BatteryStats.WAKE_TYPE_PARTIAL;
|
|
case PowerManager.DRAW_WAKE_LOCK:
|
return BatteryStats.WAKE_TYPE_DRAW;
|
|
case PowerManager.DOZE_WAKE_LOCK:
|
// Doze wake locks are an internal implementation detail of the
|
// communication between dream manager service and power manager
|
// service. They have no additive battery impact.
|
return -1;
|
|
default:
|
return -1;
|
}
|
}
|
|
/**
|
* Notifies that the device is changing wakefulness.
|
* This function may be called even if the previous change hasn't finished in
|
* which case it will assume that the state did not fully converge before the
|
* next transition began and will recover accordingly.
|
*/
|
public void onWakefulnessChangeStarted(final int wakefulness, int reason, long eventTime) {
|
final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);
|
if (DEBUG) {
|
Slog.d(TAG, "onWakefulnessChangeStarted: wakefulness=" + wakefulness
|
+ ", reason=" + reason + ", interactive=" + interactive);
|
}
|
|
// Tell the activity manager about changes in wakefulness, not just interactivity.
|
// It needs more granularity than other components.
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mActivityManagerInternal.onWakefulnessChanged(wakefulness);
|
}
|
});
|
|
// Handle any early interactive state changes.
|
// Finish pending incomplete ones from a previous cycle.
|
if (mInteractive != interactive) {
|
// Finish up late behaviors if needed.
|
if (mInteractiveChanging) {
|
handleLateInteractiveChange();
|
}
|
|
// Start input as soon as we start waking up or going to sleep.
|
mInputManagerInternal.setInteractive(interactive);
|
mInputMethodManagerInternal.setInteractive(interactive);
|
|
// Notify battery stats.
|
try {
|
mBatteryStats.noteInteractive(interactive);
|
} catch (RemoteException ex) { }
|
StatsLog.write(StatsLog.INTERACTIVE_STATE_CHANGED,
|
interactive ? StatsLog.INTERACTIVE_STATE_CHANGED__STATE__ON :
|
StatsLog.INTERACTIVE_STATE_CHANGED__STATE__OFF);
|
|
// Handle early behaviors.
|
mInteractive = interactive;
|
mInteractiveChangeReason = reason;
|
mInteractiveChangeStartTime = eventTime;
|
mInteractiveChanging = true;
|
handleEarlyInteractiveChange();
|
}
|
}
|
|
/**
|
* Notifies that the device has finished changing wakefulness.
|
*/
|
public void onWakefulnessChangeFinished() {
|
if (DEBUG) {
|
Slog.d(TAG, "onWakefulnessChangeFinished");
|
}
|
|
if (mInteractiveChanging) {
|
mInteractiveChanging = false;
|
handleLateInteractiveChange();
|
}
|
}
|
|
/**
|
* Handle early interactive state changes such as getting applications or the lock
|
* screen running and ready for the user to see (such as when turning on the screen).
|
*/
|
private void handleEarlyInteractiveChange() {
|
synchronized (mLock) {
|
if (mInteractive) {
|
// Waking up...
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
final int why = translateOnReason(mInteractiveChangeReason);
|
mPolicy.startedWakingUp(why);
|
}
|
});
|
|
// Send interactive broadcast.
|
mPendingInteractiveState = INTERACTIVE_STATE_AWAKE;
|
mPendingWakeUpBroadcast = true;
|
updatePendingBroadcastLocked();
|
} else {
|
// Going to sleep...
|
// Tell the policy that we started going to sleep.
|
final int why = translateOffReason(mInteractiveChangeReason);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
mPolicy.startedGoingToSleep(why);
|
}
|
});
|
}
|
}
|
}
|
|
/**
|
* Handle late interactive state changes once they are finished so that the system can
|
* finish pending transitions (such as turning the screen off) before causing
|
* applications to change state visibly.
|
*/
|
private void handleLateInteractiveChange() {
|
synchronized (mLock) {
|
final int interactiveChangeLatency =
|
(int) (SystemClock.uptimeMillis() - mInteractiveChangeStartTime);
|
if (mInteractive) {
|
// Finished waking up...
|
final int why = translateOnReason(mInteractiveChangeReason);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
LogMaker log = new LogMaker(MetricsEvent.SCREEN);
|
log.setType(MetricsEvent.TYPE_OPEN);
|
log.setSubtype(why);
|
log.setLatency(interactiveChangeLatency);
|
log.addTaggedData(
|
MetricsEvent.FIELD_SCREEN_WAKE_REASON, mInteractiveChangeReason);
|
MetricsLogger.action(log);
|
EventLogTags.writePowerScreenState(1, 0, 0, 0, interactiveChangeLatency);
|
mPolicy.finishedWakingUp(why);
|
}
|
});
|
} else {
|
// Finished going to sleep...
|
// This is a good time to make transitions that we don't want the user to see,
|
// such as bringing the key guard to focus. There's no guarantee for this
|
// however because the user could turn the device on again at any time.
|
// Some things may need to be protected by other mechanisms that defer screen on.
|
|
// Cancel pending user activity.
|
if (mUserActivityPending) {
|
mUserActivityPending = false;
|
mHandler.removeMessages(MSG_USER_ACTIVITY);
|
}
|
|
// Tell the policy we finished going to sleep.
|
final int why = translateOffReason(mInteractiveChangeReason);
|
mHandler.post(new Runnable() {
|
@Override
|
public void run() {
|
LogMaker log = new LogMaker(MetricsEvent.SCREEN);
|
log.setType(MetricsEvent.TYPE_CLOSE);
|
log.setSubtype(why);
|
log.setLatency(interactiveChangeLatency);
|
log.addTaggedData(
|
MetricsEvent.FIELD_SCREEN_SLEEP_REASON, mInteractiveChangeReason);
|
MetricsLogger.action(log);
|
EventLogTags.writePowerScreenState(0, why, 0, 0, interactiveChangeLatency);
|
mPolicy.finishedGoingToSleep(why);
|
}
|
});
|
|
// Send non-interactive broadcast.
|
mPendingInteractiveState = INTERACTIVE_STATE_ASLEEP;
|
mPendingGoToSleepBroadcast = true;
|
updatePendingBroadcastLocked();
|
}
|
}
|
}
|
|
private static int translateOffReason(int reason) {
|
switch (reason) {
|
case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:
|
return WindowManagerPolicy.OFF_BECAUSE_OF_ADMIN;
|
case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT:
|
return WindowManagerPolicy.OFF_BECAUSE_OF_TIMEOUT;
|
default:
|
return WindowManagerPolicy.OFF_BECAUSE_OF_USER;
|
}
|
}
|
|
private static @OnReason int translateOnReason(@WakeReason int reason) {
|
switch (reason) {
|
case PowerManager.WAKE_REASON_POWER_BUTTON:
|
case PowerManager.WAKE_REASON_PLUGGED_IN:
|
case PowerManager.WAKE_REASON_GESTURE:
|
case PowerManager.WAKE_REASON_CAMERA_LAUNCH:
|
case PowerManager.WAKE_REASON_WAKE_KEY:
|
case PowerManager.WAKE_REASON_WAKE_MOTION:
|
case PowerManager.WAKE_REASON_LID:
|
return WindowManagerPolicy.ON_BECAUSE_OF_USER;
|
case PowerManager.WAKE_REASON_APPLICATION:
|
return WindowManagerPolicy.ON_BECAUSE_OF_APPLICATION;
|
default:
|
return WindowManagerPolicy.ON_BECAUSE_OF_UNKNOWN;
|
}
|
}
|
|
/**
|
* Called when screen brightness boost begins or ends.
|
*/
|
public void onScreenBrightnessBoostChanged() {
|
if (DEBUG) {
|
Slog.d(TAG, "onScreenBrightnessBoostChanged");
|
}
|
|
mSuspendBlocker.acquire();
|
Message msg = mHandler.obtainMessage(MSG_SCREEN_BRIGHTNESS_BOOST_CHANGED);
|
msg.setAsynchronous(true);
|
mHandler.sendMessage(msg);
|
}
|
|
/**
|
* Called when there has been user activity.
|
*/
|
public void onUserActivity(int event, int uid) {
|
if (DEBUG) {
|
Slog.d(TAG, "onUserActivity: event=" + event + ", uid=" + uid);
|
}
|
|
try {
|
mBatteryStats.noteUserActivity(uid, event);
|
} catch (RemoteException ex) {
|
// Ignore
|
}
|
|
synchronized (mLock) {
|
if (!mUserActivityPending) {
|
mUserActivityPending = true;
|
Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY);
|
msg.setAsynchronous(true);
|
mHandler.sendMessage(msg);
|
}
|
}
|
}
|
|
/**
|
* Called when the screen has turned on.
|
*/
|
public void onWakeUp(int reason, String details, int reasonUid, String opPackageName,
|
int opUid) {
|
if (DEBUG) {
|
Slog.d(TAG, "onWakeUp: reason=" + PowerManager.wakeReasonToString(reason)
|
+ ", details=" + details + ", reasonUid=" + reasonUid
|
+ " opPackageName=" + opPackageName + " opUid=" + opUid);
|
}
|
|
try {
|
mBatteryStats.noteWakeUp(details, reasonUid);
|
if (opPackageName != null) {
|
mAppOps.noteOpNoThrow(AppOpsManager.OP_TURN_SCREEN_ON, opUid, opPackageName);
|
}
|
} catch (RemoteException ex) {
|
// Ignore
|
}
|
}
|
|
/**
|
* Called when profile screen lock timeout has expired.
|
*/
|
public void onProfileTimeout(@UserIdInt int userId) {
|
final Message msg = mHandler.obtainMessage(MSG_PROFILE_TIMED_OUT);
|
msg.setAsynchronous(true);
|
msg.arg1 = userId;
|
mHandler.sendMessage(msg);
|
}
|
|
/**
|
* Called when wireless charging has started - to provide user feedback (sound and visual).
|
*/
|
public void onWirelessChargingStarted(int batteryLevel, @UserIdInt int userId) {
|
if (DEBUG) {
|
Slog.d(TAG, "onWirelessChargingStarted");
|
}
|
|
mSuspendBlocker.acquire();
|
Message msg = mHandler.obtainMessage(MSG_WIRELESS_CHARGING_STARTED);
|
msg.setAsynchronous(true);
|
msg.arg1 = batteryLevel;
|
msg.arg2 = userId;
|
mHandler.sendMessage(msg);
|
}
|
|
/**
|
* Called when wired charging has started - to provide user feedback
|
*/
|
public void onWiredChargingStarted(@UserIdInt int userId) {
|
if (DEBUG) {
|
Slog.d(TAG, "onWiredChargingStarted");
|
}
|
|
mSuspendBlocker.acquire();
|
Message msg = mHandler.obtainMessage(MSG_WIRED_CHARGING_STARTED);
|
msg.setAsynchronous(true);
|
msg.arg1 = userId;
|
mHandler.sendMessage(msg);
|
}
|
|
private void updatePendingBroadcastLocked() {
|
if (!mBroadcastInProgress
|
&& mPendingInteractiveState != INTERACTIVE_STATE_UNKNOWN
|
&& (mPendingWakeUpBroadcast || mPendingGoToSleepBroadcast
|
|| mPendingInteractiveState != mBroadcastedInteractiveState)) {
|
mBroadcastInProgress = true;
|
mSuspendBlocker.acquire();
|
Message msg = mHandler.obtainMessage(MSG_BROADCAST);
|
msg.setAsynchronous(true);
|
mHandler.sendMessage(msg);
|
}
|
}
|
|
private void finishPendingBroadcastLocked() {
|
mBroadcastInProgress = false;
|
mSuspendBlocker.release();
|
}
|
|
private void sendUserActivity() {
|
synchronized (mLock) {
|
if (!mUserActivityPending) {
|
return;
|
}
|
mUserActivityPending = false;
|
}
|
mPolicy.userActivity();
|
}
|
|
private void sendNextBroadcast() {
|
final int powerState;
|
synchronized (mLock) {
|
if (mBroadcastedInteractiveState == INTERACTIVE_STATE_UNKNOWN) {
|
// Broadcasted power state is unknown. Send wake up.
|
mPendingWakeUpBroadcast = false;
|
mBroadcastedInteractiveState = INTERACTIVE_STATE_AWAKE;
|
} else if (mBroadcastedInteractiveState == INTERACTIVE_STATE_AWAKE) {
|
// Broadcasted power state is awake. Send asleep if needed.
|
if (mPendingWakeUpBroadcast || mPendingGoToSleepBroadcast
|
|| mPendingInteractiveState == INTERACTIVE_STATE_ASLEEP) {
|
mPendingGoToSleepBroadcast = false;
|
mBroadcastedInteractiveState = INTERACTIVE_STATE_ASLEEP;
|
} else {
|
finishPendingBroadcastLocked();
|
return;
|
}
|
} else {
|
// Broadcasted power state is asleep. Send awake if needed.
|
if (mPendingWakeUpBroadcast || mPendingGoToSleepBroadcast
|
|| mPendingInteractiveState == INTERACTIVE_STATE_AWAKE) {
|
mPendingWakeUpBroadcast = false;
|
mBroadcastedInteractiveState = INTERACTIVE_STATE_AWAKE;
|
} else {
|
finishPendingBroadcastLocked();
|
return;
|
}
|
}
|
|
mBroadcastStartTime = SystemClock.uptimeMillis();
|
powerState = mBroadcastedInteractiveState;
|
}
|
|
EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_SEND, 1);
|
|
if (powerState == INTERACTIVE_STATE_AWAKE) {
|
sendWakeUpBroadcast();
|
} else {
|
sendGoToSleepBroadcast();
|
}
|
}
|
|
private void sendBrightnessBoostChangedBroadcast() {
|
if (DEBUG) {
|
Slog.d(TAG, "Sending brightness boost changed broadcast.");
|
}
|
|
mContext.sendOrderedBroadcastAsUser(mScreenBrightnessBoostIntent, UserHandle.ALL, null,
|
mScreeBrightnessBoostChangedDone, mHandler, 0, null, null);
|
}
|
|
private final BroadcastReceiver mScreeBrightnessBoostChangedDone = new BroadcastReceiver() {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
mSuspendBlocker.release();
|
}
|
};
|
|
private void sendWakeUpBroadcast() {
|
if (DEBUG) {
|
Slog.d(TAG, "Sending wake up broadcast.");
|
}
|
|
if (mActivityManagerInternal.isSystemReady()) {
|
mContext.sendOrderedBroadcastAsUser(mScreenOnIntent, UserHandle.ALL, null,
|
mWakeUpBroadcastDone, mHandler, 0, null, null);
|
} else {
|
EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_STOP, 2, 1);
|
sendNextBroadcast();
|
}
|
}
|
|
private final BroadcastReceiver mWakeUpBroadcastDone = new BroadcastReceiver() {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_DONE, 1,
|
SystemClock.uptimeMillis() - mBroadcastStartTime, 1);
|
sendNextBroadcast();
|
}
|
};
|
|
private void sendGoToSleepBroadcast() {
|
if (DEBUG) {
|
Slog.d(TAG, "Sending go to sleep broadcast.");
|
}
|
|
if (mActivityManagerInternal.isSystemReady()) {
|
mContext.sendOrderedBroadcastAsUser(mScreenOffIntent, UserHandle.ALL, null,
|
mGoToSleepBroadcastDone, mHandler, 0, null, null);
|
} else {
|
EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_STOP, 3, 1);
|
sendNextBroadcast();
|
}
|
}
|
|
private final BroadcastReceiver mGoToSleepBroadcastDone = new BroadcastReceiver() {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_DONE, 0,
|
SystemClock.uptimeMillis() - mBroadcastStartTime, 1);
|
sendNextBroadcast();
|
}
|
};
|
|
/**
|
* If enabled, plays a sound and/or vibration when wireless or non-wireless charging has started
|
*/
|
private void playChargingStartedFeedback(@UserIdInt int userId) {
|
playChargingStartedVibration(userId);
|
final String soundPath = Settings.Global.getString(mContext.getContentResolver(),
|
Settings.Global.CHARGING_STARTED_SOUND);
|
if (isChargingFeedbackEnabled(userId) && soundPath != null) {
|
final Uri soundUri = Uri.parse("file://" + soundPath);
|
if (soundUri != null) {
|
final Ringtone sfx = RingtoneManager.getRingtone(mContext, soundUri);
|
if (sfx != null) {
|
sfx.setStreamType(AudioManager.STREAM_SYSTEM);
|
sfx.play();
|
}
|
}
|
}
|
}
|
|
private void showWirelessChargingStarted(int batteryLevel, @UserIdInt int userId) {
|
playChargingStartedFeedback(userId);
|
if (mStatusBarManagerInternal != null) {
|
mStatusBarManagerInternal.showChargingAnimation(batteryLevel);
|
}
|
mSuspendBlocker.release();
|
}
|
|
private void showWiredChargingStarted(@UserIdInt int userId) {
|
playChargingStartedFeedback(userId);
|
mSuspendBlocker.release();
|
}
|
|
private void lockProfile(@UserIdInt int userId) {
|
mTrustManager.setDeviceLockedForUser(userId, true /*locked*/);
|
}
|
|
private void playChargingStartedVibration(@UserIdInt int userId) {
|
final boolean vibrateEnabled = Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.CHARGING_VIBRATION_ENABLED, 1, userId) != 0;
|
if (vibrateEnabled && isChargingFeedbackEnabled(userId)) {
|
mVibrator.vibrate(WIRELESS_CHARGING_VIBRATION_EFFECT, VIBRATION_ATTRIBUTES);
|
}
|
}
|
|
private boolean isChargingFeedbackEnabled(@UserIdInt int userId) {
|
final boolean enabled = Settings.Secure.getIntForUser(mContext.getContentResolver(),
|
Settings.Secure.CHARGING_SOUNDS_ENABLED, 1, userId) != 0;
|
final boolean dndOff = Settings.Global.getInt(mContext.getContentResolver(),
|
Settings.Global.ZEN_MODE, Settings.Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS)
|
== Settings.Global.ZEN_MODE_OFF;
|
return enabled && dndOff;
|
}
|
|
private final class NotifierHandler extends Handler {
|
|
public NotifierHandler(Looper looper) {
|
super(looper, null, true /*async*/);
|
}
|
@Override
|
public void handleMessage(Message msg) {
|
switch (msg.what) {
|
case MSG_USER_ACTIVITY:
|
sendUserActivity();
|
break;
|
case MSG_BROADCAST:
|
sendNextBroadcast();
|
break;
|
case MSG_WIRELESS_CHARGING_STARTED:
|
showWirelessChargingStarted(msg.arg1, msg.arg2);
|
break;
|
case MSG_SCREEN_BRIGHTNESS_BOOST_CHANGED:
|
sendBrightnessBoostChangedBroadcast();
|
break;
|
case MSG_PROFILE_TIMED_OUT:
|
lockProfile(msg.arg1);
|
break;
|
case MSG_WIRED_CHARGING_STARTED:
|
showWiredChargingStarted(msg.arg1);
|
break;
|
}
|
}
|
}
|
}
|
