services/core/java/com/android/server/power/Notifier.java

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.server.power;
  18
  19 import android.app.ActivityManagerInternal;
  20 import android.app.AppOpsManager;
  21
  22 import com.android.internal.app.IAppOpsService;
  23 import com.android.internal.app.IBatteryStats;
  24 import com.android.server.EventLogTags;
  25 import com.android.server.LocalServices;
  26
  27 import android.app.ActivityManagerNative;
  28 import android.content.BroadcastReceiver;
  29 import android.content.Context;
  30 import android.content.Intent;
  31 import android.hardware.input.InputManagerInternal;
  32 import android.media.AudioManager;
  33 import android.media.Ringtone;
  34 import android.media.RingtoneManager;
  35 import android.net.Uri;
  36 import android.os.BatteryStats;
  37 import android.os.Handler;
  38 import android.os.Looper;
  39 import android.os.Message;
  40 import android.os.PowerManager;
  41 import android.os.PowerManagerInternal;
  42 import android.os.Process;
  43 import android.os.RemoteException;
  44 import android.os.SystemClock;
  45 import android.os.UserHandle;
  46 import android.os.WorkSource;
  47 import android.provider.Settings;
  48 import android.util.EventLog;
  49 import android.util.Slog;
  50 import android.view.WindowManagerPolicy;
  51
  52 /**
  53  * Sends broadcasts about important power state changes.
  54  * <p>
  55  * This methods of this class may be called by the power manager service while
  56  * its lock is being held.  Internally it takes care of sending broadcasts to
  57  * notify other components of the system or applications asynchronously.
  58  * </p><p>
  59  * The notifier is designed to collapse unnecessary broadcasts when it is not
  60  * possible for the system to have observed an intermediate state.
  61  * </p><p>
  62  * For example, if the device wakes up, goes to sleep, wakes up again and goes to
  63  * sleep again before the wake up notification is sent, then the system will
  64  * be told about only one wake up and sleep.  However, we always notify the
  65  * fact that at least one transition occurred.  It is especially important to
  66  * tell the system when we go to sleep so that it can lock the keyguard if needed.
  67  * </p>
  68  */
  69 final class Notifier {
  70     private static final String TAG = "PowerManagerNotifier";
  71
  72     private static final boolean DEBUG = false;
  73
  74     private static final int INTERACTIVE_STATE_UNKNOWN = 0;
  75     private static final int INTERACTIVE_STATE_AWAKE = 1;
  76     private static final int INTERACTIVE_STATE_ASLEEP = 2;
  77
  78     private static final int MSG_USER_ACTIVITY = 1;
  79     private static final int MSG_BROADCAST = 2;
  80     private static final int MSG_WIRELESS_CHARGING_STARTED = 3;
  81
  82     private final Object mLock = new Object();
  83
  84     private final Context mContext;
  85     private final IBatteryStats mBatteryStats;
  86     private final IAppOpsService mAppOps;
  87     private final SuspendBlocker mSuspendBlocker;
  88     private final WindowManagerPolicy mPolicy;
  89     private final ActivityManagerInternal mActivityManagerInternal;
  90     private final InputManagerInternal mInputManagerInternal;
  91
  92     private final NotifierHandler mHandler;
  93     private final Intent mScreenOnIntent;
  94     private final Intent mScreenOffIntent;
  95
  96     // The current interactive state.
  97     private int mActualInteractiveState;
  98     private int mLastReason;
  99
 100     // True if there is a pending transition that needs to be reported.
 101     private boolean mPendingWakeUpBroadcast;
 102     private boolean mPendingGoToSleepBroadcast;
 103
 104     // The currently broadcasted interactive state.  This reflects what other parts of the
 105     // system have observed.
 106     private int mBroadcastedInteractiveState;
 107     private boolean mBroadcastInProgress;
 108     private long mBroadcastStartTime;
 109
 110     // True if a user activity message should be sent.
 111     private boolean mUserActivityPending;
 112
 113     public Notifier(Looper looper, Context context, IBatteryStats batteryStats,
 114             IAppOpsService appOps, SuspendBlocker suspendBlocker,
 115             WindowManagerPolicy policy) {
 116         mContext = context;
 117         mBatteryStats = batteryStats;
 118         mAppOps = appOps;
 119         mSuspendBlocker = suspendBlocker;
 120         mPolicy = policy;
 121         mActivityManagerInternal = LocalServices.getService(ActivityManagerInternal.class);
 122         mInputManagerInternal = LocalServices.getService(InputManagerInternal.class);
 123
 124         mHandler = new NotifierHandler(looper);
 125         mScreenOnIntent = new Intent(Intent.ACTION_SCREEN_ON);
 126         mScreenOnIntent.addFlags(
 127                 Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
 128         mScreenOffIntent = new Intent(Intent.ACTION_SCREEN_OFF);
 129         mScreenOffIntent.addFlags(
 130                 Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
 131
 132         // Initialize interactive state for battery stats.
 133         try {
 134             mBatteryStats.noteInteractive(true);
 135         } catch (RemoteException ex) { }
 136     }
 137
 138     /**
 139      * Called when a wake lock is acquired.
 140      */
 141     public void onWakeLockAcquired(int flags, String tag, String packageName,
 142             int ownerUid, int ownerPid, WorkSource workSource, String historyTag) {
 143         if (DEBUG) {
 144             Slog.d(TAG, "onWakeLockAcquired: flags=" + flags + ", tag=\"" + tag
 145                     + "\", packageName=" + packageName
 146                     + ", ownerUid=" + ownerUid + ", ownerPid=" + ownerPid
 147                     + ", workSource=" + workSource);
 148         }
 149
 150         try {
 151             final int monitorType = getBatteryStatsWakeLockMonitorType(flags);
 152             boolean unimportantForLogging = (flags&PowerManager.UNIMPORTANT_FOR_LOGGING) != 0
 153                     && ownerUid == Process.SYSTEM_UID;
 154             if (workSource != null) {
 155                 mBatteryStats.noteStartWakelockFromSource(workSource, ownerPid, tag, historyTag,
 156                         monitorType, unimportantForLogging);
 157             } else {
 158                 mBatteryStats.noteStartWakelock(ownerUid, ownerPid, tag, historyTag,
 159                         monitorType, unimportantForLogging);
 160                 // XXX need to deal with disabled operations.
 161                 mAppOps.startOperation(AppOpsManager.getToken(mAppOps),
 162                         AppOpsManager.OP_WAKE_LOCK, ownerUid, packageName);
 163             }
 164         } catch (RemoteException ex) {
 165             // Ignore
 166         }
 167     }
 168
 169     /**
 170      * Called when a wake lock is changing.
 171      */
 172     public void onWakeLockChanging(int flags, String tag, String packageName,
 173             int ownerUid, int ownerPid, WorkSource workSource, String historyTag,
 174             int newFlags, String newTag, String newPackageName, int newOwnerUid,
 175             int newOwnerPid, WorkSource newWorkSource, String newHistoryTag) {
 176
 177         if (workSource != null && newWorkSource != null) {
 178             final int monitorType = getBatteryStatsWakeLockMonitorType(flags);
 179             final int newMonitorType = getBatteryStatsWakeLockMonitorType(newFlags);
 180             boolean unimportantForLogging = (newFlags&PowerManager.UNIMPORTANT_FOR_LOGGING) != 0
 181                     && newOwnerUid == Process.SYSTEM_UID;
 182             if (DEBUG) {
 183                 Slog.d(TAG, "onWakeLockChanging: flags=" + newFlags + ", tag=\"" + newTag
 184                         + "\", packageName=" + newPackageName
 185                         + ", ownerUid=" + newOwnerUid + ", ownerPid=" + newOwnerPid
 186                         + ", workSource=" + newWorkSource);
 187             }
 188             try {
 189                 mBatteryStats.noteChangeWakelockFromSource(workSource, ownerPid, tag, historyTag,
 190                         monitorType, newWorkSource, newOwnerPid, newTag, newHistoryTag,
 191                         newMonitorType, unimportantForLogging);
 192             } catch (RemoteException ex) {
 193                 // Ignore
 194             }
 195         } else {
 196             onWakeLockReleased(flags, tag, packageName, ownerUid, ownerPid, workSource, historyTag);
 197             onWakeLockAcquired(newFlags, newTag, newPackageName, newOwnerUid, newOwnerPid,
 198                     newWorkSource, newHistoryTag);
 199         }
 200     }
 201
 202     /**
 203      * Called when a wake lock is released.
 204      */
 205     public void onWakeLockReleased(int flags, String tag, String packageName,
 206             int ownerUid, int ownerPid, WorkSource workSource, String historyTag) {
 207         if (DEBUG) {
 208             Slog.d(TAG, "onWakeLockReleased: flags=" + flags + ", tag=\"" + tag
 209                     + "\", packageName=" + packageName
 210                     + ", ownerUid=" + ownerUid + ", ownerPid=" + ownerPid
 211                     + ", workSource=" + workSource);
 212         }
 213
 214         try {
 215             final int monitorType = getBatteryStatsWakeLockMonitorType(flags);
 216             if (workSource != null) {
 217                 mBatteryStats.noteStopWakelockFromSource(workSource, ownerPid, tag, historyTag,
 218                         monitorType);
 219             } else {
 220                 mBatteryStats.noteStopWakelock(ownerUid, ownerPid, tag, historyTag, monitorType);
 221                 mAppOps.finishOperation(AppOpsManager.getToken(mAppOps),
 222                         AppOpsManager.OP_WAKE_LOCK, ownerUid, packageName);
 223             }
 224         } catch (RemoteException ex) {
 225             // Ignore
 226         }
 227     }
 228
 229     private static int getBatteryStatsWakeLockMonitorType(int flags) {
 230         switch (flags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
 231             case PowerManager.PARTIAL_WAKE_LOCK:
 232             case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:
 233                 return BatteryStats.WAKE_TYPE_PARTIAL;
 234             default:
 235                 return BatteryStats.WAKE_TYPE_FULL;
 236         }
 237     }
 238
 239     /**
 240      * Notifies that the device is changing wakefulness.
 241      */
 242     public void onWakefulnessChangeStarted(int wakefulness, int reason) {
 243         if (DEBUG) {
 244             Slog.d(TAG, "onWakefulnessChangeStarted: wakefulness=" + wakefulness
 245                     + ", reason=" + reason);
 246         }
 247
 248         // We handle interactive state changes once they start so that the system can
 249         // set everything up or the user to begin interacting with applications.
 250         final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);
 251         if (interactive) {
 252             handleWakefulnessChange(wakefulness, interactive, reason);
 253         } else {
 254             mLastReason = reason;
 255         }
 256
 257         // Start input as soon as we start waking up or going to sleep.
 258         mInputManagerInternal.setInteractive(interactive);
 259     }
 260
 261     /**
 262      * Notifies that the device has finished changing wakefulness.
 263      */
 264     public void onWakefulnessChangeFinished(int wakefulness) {
 265         if (DEBUG) {
 266             Slog.d(TAG, "onWakefulnessChangeFinished: wakefulness=" + wakefulness);
 267         }
 268
 269         // Handle interactive state changes once they are finished so that the system can
 270         // finish pending transitions (such as turning the screen off) before causing
 271         // applications to change state visibly.
 272         final boolean interactive = PowerManagerInternal.isInteractive(wakefulness);
 273         if (!interactive) {
 274             handleWakefulnessChange(wakefulness, interactive, mLastReason);
 275         }
 276     }
 277
 278     private void handleWakefulnessChange(final int wakefulness, boolean interactive,
 279             final int reason) {
 280         // Tell the activity manager about changes in wakefulness, not just interactivity.
 281         // It needs more granularity than other components.
 282         mHandler.post(new Runnable() {
 283             @Override
 284             public void run() {
 285                 mActivityManagerInternal.onWakefulnessChanged(wakefulness);
 286             }
 287         });
 288
 289         // Handle changes in the overall interactive state.
 290         boolean interactiveChanged = false;
 291         synchronized (mLock) {
 292             // Broadcast interactive state changes.
 293             if (interactive) {
 294                 // Waking up...
 295                 interactiveChanged = (mActualInteractiveState != INTERACTIVE_STATE_AWAKE);
 296                 if (interactiveChanged) {
 297                     mActualInteractiveState = INTERACTIVE_STATE_AWAKE;
 298                     mPendingWakeUpBroadcast = true;
 299                     mHandler.post(new Runnable() {
 300                         @Override
 301                         public void run() {
 302                             EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 1, 0, 0, 0);
 303                             mPolicy.wakingUp();
 304                         }
 305                     });
 306                     updatePendingBroadcastLocked();
 307                 }
 308             } else {
 309                 // Going to sleep...
 310                 // This is a good time to make transitions that we don't want the user to see,
 311                 // such as bringing the key guard to focus.  There's no guarantee for this,
 312                 // however because the user could turn the device on again at any time.
 313                 // Some things may need to be protected by other mechanisms that defer screen on.
 314                 interactiveChanged = (mActualInteractiveState != INTERACTIVE_STATE_ASLEEP);
 315                 if (interactiveChanged) {
 316                     mActualInteractiveState = INTERACTIVE_STATE_ASLEEP;
 317                     mPendingGoToSleepBroadcast = true;
 318                     if (mUserActivityPending) {
 319                         mUserActivityPending = false;
 320                         mHandler.removeMessages(MSG_USER_ACTIVITY);
 321                     }
 322                     mHandler.post(new Runnable() {
 323                         @Override
 324                         public void run() {
 325                             int why = WindowManagerPolicy.OFF_BECAUSE_OF_USER;
 326                             switch (reason) {
 327                                 case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:
 328                                     why = WindowManagerPolicy.OFF_BECAUSE_OF_ADMIN;
 329                                     break;
 330                                 case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT:
 331                                     why = WindowManagerPolicy.OFF_BECAUSE_OF_TIMEOUT;
 332                                     break;
 333                             }
 334                             EventLog.writeEvent(EventLogTags.POWER_SCREEN_STATE, 0, why, 0, 0);
 335                             mPolicy.goingToSleep(why);
 336                         }
 337                     });
 338                     updatePendingBroadcastLocked();
 339                 }
 340             }
 341         }
 342
 343         // Notify battery stats.
 344         if (interactiveChanged) {
 345             try {
 346                 mBatteryStats.noteInteractive(interactive);
 347             } catch (RemoteException ex) { }
 348         }
 349     }
 350
 351     /**
 352      * Called when there has been user activity.
 353      */
 354     public void onUserActivity(int event, int uid) {
 355         if (DEBUG) {
 356             Slog.d(TAG, "onUserActivity: event=" + event + ", uid=" + uid);
 357         }
 358
 359         try {
 360             mBatteryStats.noteUserActivity(uid, event);
 361         } catch (RemoteException ex) {
 362             // Ignore
 363         }
 364
 365         synchronized (mLock) {
 366             if (!mUserActivityPending) {
 367                 mUserActivityPending = true;
 368                 Message msg = mHandler.obtainMessage(MSG_USER_ACTIVITY);
 369                 msg.setAsynchronous(true);
 370                 mHandler.sendMessage(msg);
 371             }
 372         }
 373     }
 374
 375     /**
 376      * Called when wireless charging has started so as to provide user feedback.
 377      */
 378     public void onWirelessChargingStarted() {
 379         if (DEBUG) {
 380             Slog.d(TAG, "onWirelessChargingStarted");
 381         }
 382
 383         mSuspendBlocker.acquire();
 384         Message msg = mHandler.obtainMessage(MSG_WIRELESS_CHARGING_STARTED);
 385         msg.setAsynchronous(true);
 386         mHandler.sendMessage(msg);
 387     }
 388
 389     private void updatePendingBroadcastLocked() {
 390         if (!mBroadcastInProgress
 391                 && mActualInteractiveState != INTERACTIVE_STATE_UNKNOWN
 392                 && (mPendingWakeUpBroadcast || mPendingGoToSleepBroadcast
 393                         || mActualInteractiveState != mBroadcastedInteractiveState)) {
 394             mBroadcastInProgress = true;
 395             mSuspendBlocker.acquire();
 396             Message msg = mHandler.obtainMessage(MSG_BROADCAST);
 397             msg.setAsynchronous(true);
 398             mHandler.sendMessage(msg);
 399         }
 400     }
 401
 402     private void finishPendingBroadcastLocked() {
 403         mBroadcastInProgress = false;
 404         mSuspendBlocker.release();
 405     }
 406
 407     private void sendUserActivity() {
 408         synchronized (mLock) {
 409             if (!mUserActivityPending) {
 410                 return;
 411             }
 412             mUserActivityPending = false;
 413         }
 414
 415         mPolicy.userActivity();
 416     }
 417
 418     private void sendNextBroadcast() {
 419         final int powerState;
 420         synchronized (mLock) {
 421             if (mBroadcastedInteractiveState == INTERACTIVE_STATE_UNKNOWN) {
 422                 // Broadcasted power state is unknown.  Send wake up.
 423                 mPendingWakeUpBroadcast = false;
 424                 mBroadcastedInteractiveState = INTERACTIVE_STATE_AWAKE;
 425             } else if (mBroadcastedInteractiveState == INTERACTIVE_STATE_AWAKE) {
 426                 // Broadcasted power state is awake.  Send asleep if needed.
 427                 if (mPendingWakeUpBroadcast || mPendingGoToSleepBroadcast
 428                         || mActualInteractiveState == INTERACTIVE_STATE_ASLEEP) {
 429                     mPendingGoToSleepBroadcast = false;
 430                     mBroadcastedInteractiveState = INTERACTIVE_STATE_ASLEEP;
 431                 } else {
 432                     finishPendingBroadcastLocked();
 433                     return;
 434                 }
 435             } else {
 436                 // Broadcasted power state is asleep.  Send awake if needed.
 437                 if (mPendingWakeUpBroadcast || mPendingGoToSleepBroadcast
 438                         || mActualInteractiveState == INTERACTIVE_STATE_AWAKE) {
 439                     mPendingWakeUpBroadcast = false;
 440                     mBroadcastedInteractiveState = INTERACTIVE_STATE_AWAKE;
 441                 } else {
 442                     finishPendingBroadcastLocked();
 443                     return;
 444                 }
 445             }
 446
 447             mBroadcastStartTime = SystemClock.uptimeMillis();
 448             powerState = mBroadcastedInteractiveState;
 449         }
 450
 451         EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_SEND, 1);
 452
 453         if (powerState == INTERACTIVE_STATE_AWAKE) {
 454             sendWakeUpBroadcast();
 455         } else {
 456             sendGoToSleepBroadcast();
 457         }
 458     }
 459
 460     private void sendWakeUpBroadcast() {
 461         if (DEBUG) {
 462             Slog.d(TAG, "Sending wake up broadcast.");
 463         }
 464
 465         if (ActivityManagerNative.isSystemReady()) {
 466             mContext.sendOrderedBroadcastAsUser(mScreenOnIntent, UserHandle.ALL, null,
 467                     mWakeUpBroadcastDone, mHandler, 0, null, null);
 468         } else {
 469             EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_STOP, 2, 1);
 470             sendNextBroadcast();
 471         }
 472     }
 473
 474     private final BroadcastReceiver mWakeUpBroadcastDone = new BroadcastReceiver() {
 475         @Override
 476         public void onReceive(Context context, Intent intent) {
 477             EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_DONE, 1,
 478                     SystemClock.uptimeMillis() - mBroadcastStartTime, 1);
 479             sendNextBroadcast();
 480         }
 481     };
 482
 483     private void sendGoToSleepBroadcast() {
 484         if (DEBUG) {
 485             Slog.d(TAG, "Sending go to sleep broadcast.");
 486         }
 487
 488         if (ActivityManagerNative.isSystemReady()) {
 489             mContext.sendOrderedBroadcastAsUser(mScreenOffIntent, UserHandle.ALL, null,
 490                     mGoToSleepBroadcastDone, mHandler, 0, null, null);
 491         } else {
 492             EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_STOP, 3, 1);
 493             sendNextBroadcast();
 494         }
 495     }
 496
 497     private final BroadcastReceiver mGoToSleepBroadcastDone = new BroadcastReceiver() {
 498         @Override
 499         public void onReceive(Context context, Intent intent) {
 500             EventLog.writeEvent(EventLogTags.POWER_SCREEN_BROADCAST_DONE, 0,
 501                     SystemClock.uptimeMillis() - mBroadcastStartTime, 1);
 502             sendNextBroadcast();
 503         }
 504     };
 505
 506     private void playWirelessChargingStartedSound() {
 507         final String soundPath = Settings.Global.getString(mContext.getContentResolver(),
 508                 Settings.Global.WIRELESS_CHARGING_STARTED_SOUND);
 509         if (soundPath != null) {
 510             final Uri soundUri = Uri.parse("file://" + soundPath);
 511             if (soundUri != null) {
 512                 final Ringtone sfx = RingtoneManager.getRingtone(mContext, soundUri);
 513                 if (sfx != null) {
 514                     sfx.setStreamType(AudioManager.STREAM_SYSTEM);
 515                     sfx.play();
 516                 }
 517             }
 518         }
 519
 520         mSuspendBlocker.release();
 521     }
 522
 523     private final class NotifierHandler extends Handler {
 524         public NotifierHandler(Looper looper) {
 525             super(looper, null, true /*async*/);
 526         }
 527
 528         @Override
 529         public void handleMessage(Message msg) {
 530             switch (msg.what) {
 531                 case MSG_USER_ACTIVITY:
 532                     sendUserActivity();
 533                     break;
 534
 535                 case MSG_BROADCAST:
 536                     sendNextBroadcast();
 537                     break;
 538
 539                 case MSG_WIRELESS_CHARGING_STARTED:
 540                     playWirelessChargingStartedSound();
 541                     break;
 542             }
 543         }
 544     }
 545 }