1/* 2 * Copyright (C) 2008 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 18package com.android.server.power; 19 20import android.app.ActivityManagerNative; 21import android.app.AlertDialog; 22import android.app.Dialog; 23import android.app.IActivityManager; 24import android.app.ProgressDialog; 25import android.bluetooth.BluetoothAdapter; 26import android.bluetooth.IBluetoothManager; 27import android.nfc.NfcAdapter; 28import android.nfc.INfcAdapter; 29import android.content.BroadcastReceiver; 30import android.content.Context; 31import android.content.DialogInterface; 32import android.content.Intent; 33import android.content.IntentFilter; 34import android.os.Handler; 35import android.os.PowerManager; 36import android.os.RemoteException; 37import android.os.ServiceManager; 38import android.os.SystemClock; 39import android.os.SystemProperties; 40import android.os.UserHandle; 41import android.os.Vibrator; 42import android.os.SystemVibrator; 43import android.os.storage.IMountService; 44import android.os.storage.IMountShutdownObserver; 45 46import com.android.internal.telephony.ITelephony; 47 48import android.util.Log; 49import android.view.WindowManager; 50 51public final class ShutdownThread extends Thread { 52 // constants 53 private static final String TAG = "ShutdownThread"; 54 private static final int PHONE_STATE_POLL_SLEEP_MSEC = 500; 55 // maximum time we wait for the shutdown broadcast before going on. 56 private static final int MAX_BROADCAST_TIME = 10*1000; 57 private static final int MAX_SHUTDOWN_WAIT_TIME = 20*1000; 58 private static final int MAX_RADIO_WAIT_TIME = 12*1000; 59 60 // length of vibration before shutting down 61 private static final int SHUTDOWN_VIBRATE_MS = 500; 62 63 // state tracking 64 private static Object sIsStartedGuard = new Object(); 65 private static boolean sIsStarted = false; 66 67 private static boolean mReboot; 68 private static boolean mRebootSafeMode; 69 private static String mRebootReason; 70 71 // Provides shutdown assurance in case the system_server is killed 72 public static final String SHUTDOWN_ACTION_PROPERTY = "sys.shutdown.requested"; 73 74 // Indicates whether we are rebooting into safe mode 75 public static final String REBOOT_SAFEMODE_PROPERTY = "persist.sys.safemode"; 76 77 // static instance of this thread 78 private static final ShutdownThread sInstance = new ShutdownThread(); 79 80 private final Object mActionDoneSync = new Object(); 81 private boolean mActionDone; 82 private Context mContext; 83 private PowerManager mPowerManager; 84 private PowerManager.WakeLock mCpuWakeLock; 85 private PowerManager.WakeLock mScreenWakeLock; 86 private Handler mHandler; 87 88 private static AlertDialog sConfirmDialog; 89 90 private ShutdownThread() { 91 } 92 93 /** 94 * Request a clean shutdown, waiting for subsystems to clean up their 95 * state etc. Must be called from a Looper thread in which its UI 96 * is shown. 97 * 98 * @param context Context used to display the shutdown progress dialog. 99 * @param confirm true if user confirmation is needed before shutting down. 100 */ 101 public static void shutdown(final Context context, boolean confirm) { 102 mReboot = false; 103 mRebootSafeMode = false; 104 shutdownInner(context, confirm); 105 } 106 107 static void shutdownInner(final Context context, boolean confirm) { 108 // ensure that only one thread is trying to power down. 109 // any additional calls are just returned 110 synchronized (sIsStartedGuard) { 111 if (sIsStarted) { 112 Log.d(TAG, "Request to shutdown already running, returning."); 113 return; 114 } 115 } 116 117 final int longPressBehavior = context.getResources().getInteger( 118 com.android.internal.R.integer.config_longPressOnPowerBehavior); 119 final int resourceId = mRebootSafeMode 120 ? com.android.internal.R.string.reboot_safemode_confirm 121 : (longPressBehavior == 2 122 ? com.android.internal.R.string.shutdown_confirm_question 123 : com.android.internal.R.string.shutdown_confirm); 124 125 Log.d(TAG, "Notifying thread to start shutdown longPressBehavior=" + longPressBehavior); 126 127 if (confirm) { 128 final CloseDialogReceiver closer = new CloseDialogReceiver(context); 129 if (sConfirmDialog != null) { 130 sConfirmDialog.dismiss(); 131 } 132 sConfirmDialog = new AlertDialog.Builder(context) 133 .setTitle(mRebootSafeMode 134 ? com.android.internal.R.string.reboot_safemode_title 135 : com.android.internal.R.string.power_off) 136 .setMessage(resourceId) 137 .setPositiveButton(com.android.internal.R.string.yes, new DialogInterface.OnClickListener() { 138 public void onClick(DialogInterface dialog, int which) { 139 beginShutdownSequence(context); 140 } 141 }) 142 .setNegativeButton(com.android.internal.R.string.no, null) 143 .create(); 144 closer.dialog = sConfirmDialog; 145 sConfirmDialog.setOnDismissListener(closer); 146 sConfirmDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG); 147 sConfirmDialog.show(); 148 } else { 149 beginShutdownSequence(context); 150 } 151 } 152 153 private static class CloseDialogReceiver extends BroadcastReceiver 154 implements DialogInterface.OnDismissListener { 155 private Context mContext; 156 public Dialog dialog; 157 158 CloseDialogReceiver(Context context) { 159 mContext = context; 160 IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS); 161 context.registerReceiver(this, filter); 162 } 163 164 @Override 165 public void onReceive(Context context, Intent intent) { 166 dialog.cancel(); 167 } 168 169 public void onDismiss(DialogInterface unused) { 170 mContext.unregisterReceiver(this); 171 } 172 } 173 174 /** 175 * Request a clean shutdown, waiting for subsystems to clean up their 176 * state etc. Must be called from a Looper thread in which its UI 177 * is shown. 178 * 179 * @param context Context used to display the shutdown progress dialog. 180 * @param reason code to pass to the kernel (e.g. "recovery"), or null. 181 * @param confirm true if user confirmation is needed before shutting down. 182 */ 183 public static void reboot(final Context context, String reason, boolean confirm) { 184 mReboot = true; 185 mRebootSafeMode = false; 186 mRebootReason = reason; 187 shutdownInner(context, confirm); 188 } 189 190 /** 191 * Request a reboot into safe mode. Must be called from a Looper thread in which its UI 192 * is shown. 193 * 194 * @param context Context used to display the shutdown progress dialog. 195 * @param confirm true if user confirmation is needed before shutting down. 196 */ 197 public static void rebootSafeMode(final Context context, boolean confirm) { 198 mReboot = true; 199 mRebootSafeMode = true; 200 mRebootReason = null; 201 shutdownInner(context, confirm); 202 } 203 204 private static void beginShutdownSequence(Context context) { 205 synchronized (sIsStartedGuard) { 206 if (sIsStarted) { 207 Log.d(TAG, "Shutdown sequence already running, returning."); 208 return; 209 } 210 sIsStarted = true; 211 } 212 213 // throw up an indeterminate system dialog to indicate radio is 214 // shutting down. 215 ProgressDialog pd = new ProgressDialog(context); 216 pd.setTitle(context.getText(com.android.internal.R.string.power_off)); 217 pd.setMessage(context.getText(com.android.internal.R.string.shutdown_progress)); 218 pd.setIndeterminate(true); 219 pd.setCancelable(false); 220 pd.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG); 221 222 pd.show(); 223 224 sInstance.mContext = context; 225 sInstance.mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE); 226 227 // make sure we never fall asleep again 228 sInstance.mCpuWakeLock = null; 229 try { 230 sInstance.mCpuWakeLock = sInstance.mPowerManager.newWakeLock( 231 PowerManager.PARTIAL_WAKE_LOCK, TAG + "-cpu"); 232 sInstance.mCpuWakeLock.setReferenceCounted(false); 233 sInstance.mCpuWakeLock.acquire(); 234 } catch (SecurityException e) { 235 Log.w(TAG, "No permission to acquire wake lock", e); 236 sInstance.mCpuWakeLock = null; 237 } 238 239 // also make sure the screen stays on for better user experience 240 sInstance.mScreenWakeLock = null; 241 if (sInstance.mPowerManager.isScreenOn()) { 242 try { 243 sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock( 244 PowerManager.FULL_WAKE_LOCK, TAG + "-screen"); 245 sInstance.mScreenWakeLock.setReferenceCounted(false); 246 sInstance.mScreenWakeLock.acquire(); 247 } catch (SecurityException e) { 248 Log.w(TAG, "No permission to acquire wake lock", e); 249 sInstance.mScreenWakeLock = null; 250 } 251 } 252 253 // start the thread that initiates shutdown 254 sInstance.mHandler = new Handler() { 255 }; 256 sInstance.start(); 257 } 258 259 void actionDone() { 260 synchronized (mActionDoneSync) { 261 mActionDone = true; 262 mActionDoneSync.notifyAll(); 263 } 264 } 265 266 /** 267 * Makes sure we handle the shutdown gracefully. 268 * Shuts off power regardless of radio and bluetooth state if the alloted time has passed. 269 */ 270 public void run() { 271 BroadcastReceiver br = new BroadcastReceiver() { 272 @Override public void onReceive(Context context, Intent intent) { 273 // We don't allow apps to cancel this, so ignore the result. 274 actionDone(); 275 } 276 }; 277 278 /* 279 * Write a system property in case the system_server reboots before we 280 * get to the actual hardware restart. If that happens, we'll retry at 281 * the beginning of the SystemServer startup. 282 */ 283 { 284 String reason = (mReboot ? "1" : "0") + (mRebootReason != null ? mRebootReason : ""); 285 SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason); 286 } 287 288 /* 289 * If we are rebooting into safe mode, write a system property 290 * indicating so. 291 */ 292 if (mRebootSafeMode) { 293 SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1"); 294 } 295 296 Log.i(TAG, "Sending shutdown broadcast..."); 297 298 // First send the high-level shut down broadcast. 299 mActionDone = false; 300 mContext.sendOrderedBroadcastAsUser(new Intent(Intent.ACTION_SHUTDOWN), 301 UserHandle.ALL, null, br, mHandler, 0, null, null); 302 303 final long endTime = SystemClock.elapsedRealtime() + MAX_BROADCAST_TIME; 304 synchronized (mActionDoneSync) { 305 while (!mActionDone) { 306 long delay = endTime - SystemClock.elapsedRealtime(); 307 if (delay <= 0) { 308 Log.w(TAG, "Shutdown broadcast timed out"); 309 break; 310 } 311 try { 312 mActionDoneSync.wait(delay); 313 } catch (InterruptedException e) { 314 } 315 } 316 } 317 318 Log.i(TAG, "Shutting down activity manager..."); 319 320 final IActivityManager am = 321 ActivityManagerNative.asInterface(ServiceManager.checkService("activity")); 322 if (am != null) { 323 try { 324 am.shutdown(MAX_BROADCAST_TIME); 325 } catch (RemoteException e) { 326 } 327 } 328 329 // Shutdown radios. 330 shutdownRadios(MAX_RADIO_WAIT_TIME); 331 332 // Shutdown MountService to ensure media is in a safe state 333 IMountShutdownObserver observer = new IMountShutdownObserver.Stub() { 334 public void onShutDownComplete(int statusCode) throws RemoteException { 335 Log.w(TAG, "Result code " + statusCode + " from MountService.shutdown"); 336 actionDone(); 337 } 338 }; 339 340 Log.i(TAG, "Shutting down MountService"); 341 342 // Set initial variables and time out time. 343 mActionDone = false; 344 final long endShutTime = SystemClock.elapsedRealtime() + MAX_SHUTDOWN_WAIT_TIME; 345 synchronized (mActionDoneSync) { 346 try { 347 final IMountService mount = IMountService.Stub.asInterface( 348 ServiceManager.checkService("mount")); 349 if (mount != null) { 350 mount.shutdown(observer); 351 } else { 352 Log.w(TAG, "MountService unavailable for shutdown"); 353 } 354 } catch (Exception e) { 355 Log.e(TAG, "Exception during MountService shutdown", e); 356 } 357 while (!mActionDone) { 358 long delay = endShutTime - SystemClock.elapsedRealtime(); 359 if (delay <= 0) { 360 Log.w(TAG, "Shutdown wait timed out"); 361 break; 362 } 363 try { 364 mActionDoneSync.wait(delay); 365 } catch (InterruptedException e) { 366 } 367 } 368 } 369 370 rebootOrShutdown(mReboot, mRebootReason); 371 } 372 373 private void shutdownRadios(int timeout) { 374 // If a radio is wedged, disabling it may hang so we do this work in another thread, 375 // just in case. 376 final long endTime = SystemClock.elapsedRealtime() + timeout; 377 final boolean[] done = new boolean[1]; 378 Thread t = new Thread() { 379 public void run() { 380 boolean nfcOff; 381 boolean bluetoothOff; 382 boolean radioOff; 383 384 final INfcAdapter nfc = 385 INfcAdapter.Stub.asInterface(ServiceManager.checkService("nfc")); 386 final ITelephony phone = 387 ITelephony.Stub.asInterface(ServiceManager.checkService("phone")); 388 final IBluetoothManager bluetooth = 389 IBluetoothManager.Stub.asInterface(ServiceManager.checkService( 390 BluetoothAdapter.BLUETOOTH_MANAGER_SERVICE)); 391 392 try { 393 nfcOff = nfc == null || 394 nfc.getState() == NfcAdapter.STATE_OFF; 395 if (!nfcOff) { 396 Log.w(TAG, "Turning off NFC..."); 397 nfc.disable(false); // Don't persist new state 398 } 399 } catch (RemoteException ex) { 400 Log.e(TAG, "RemoteException during NFC shutdown", ex); 401 nfcOff = true; 402 } 403 404 try { 405 bluetoothOff = bluetooth == null || !bluetooth.isEnabled(); 406 if (!bluetoothOff) { 407 Log.w(TAG, "Disabling Bluetooth..."); 408 bluetooth.disable(false); // disable but don't persist new state 409 } 410 } catch (RemoteException ex) { 411 Log.e(TAG, "RemoteException during bluetooth shutdown", ex); 412 bluetoothOff = true; 413 } 414 415 try { 416 radioOff = phone == null || !phone.isRadioOn(); 417 if (!radioOff) { 418 Log.w(TAG, "Turning off radio..."); 419 phone.setRadio(false); 420 } 421 } catch (RemoteException ex) { 422 Log.e(TAG, "RemoteException during radio shutdown", ex); 423 radioOff = true; 424 } 425 426 Log.i(TAG, "Waiting for NFC, Bluetooth and Radio..."); 427 428 while (SystemClock.elapsedRealtime() < endTime) { 429 if (!bluetoothOff) { 430 try { 431 bluetoothOff = !bluetooth.isEnabled(); 432 } catch (RemoteException ex) { 433 Log.e(TAG, "RemoteException during bluetooth shutdown", ex); 434 bluetoothOff = true; 435 } 436 if (bluetoothOff) { 437 Log.i(TAG, "Bluetooth turned off."); 438 } 439 } 440 if (!radioOff) { 441 try { 442 radioOff = !phone.isRadioOn(); 443 } catch (RemoteException ex) { 444 Log.e(TAG, "RemoteException during radio shutdown", ex); 445 radioOff = true; 446 } 447 if (radioOff) { 448 Log.i(TAG, "Radio turned off."); 449 } 450 } 451 if (!nfcOff) { 452 try { 453 nfcOff = nfc.getState() == NfcAdapter.STATE_OFF; 454 } catch (RemoteException ex) { 455 Log.e(TAG, "RemoteException during NFC shutdown", ex); 456 nfcOff = true; 457 } 458 if (radioOff) { 459 Log.i(TAG, "NFC turned off."); 460 } 461 } 462 463 if (radioOff && bluetoothOff && nfcOff) { 464 Log.i(TAG, "NFC, Radio and Bluetooth shutdown complete."); 465 done[0] = true; 466 break; 467 } 468 SystemClock.sleep(PHONE_STATE_POLL_SLEEP_MSEC); 469 } 470 } 471 }; 472 473 t.start(); 474 try { 475 t.join(timeout); 476 } catch (InterruptedException ex) { 477 } 478 if (!done[0]) { 479 Log.w(TAG, "Timed out waiting for NFC, Radio and Bluetooth shutdown."); 480 } 481 } 482 483 /** 484 * Do not call this directly. Use {@link #reboot(Context, String, boolean)} 485 * or {@link #shutdown(Context, boolean)} instead. 486 * 487 * @param reboot true to reboot or false to shutdown 488 * @param reason reason for reboot 489 */ 490 public static void rebootOrShutdown(boolean reboot, String reason) { 491 if (reboot) { 492 Log.i(TAG, "Rebooting, reason: " + reason); 493 try { 494 PowerManagerService.lowLevelReboot(reason); 495 } catch (Exception e) { 496 Log.e(TAG, "Reboot failed, will attempt shutdown instead", e); 497 } 498 } else if (SHUTDOWN_VIBRATE_MS > 0) { 499 // vibrate before shutting down 500 Vibrator vibrator = new SystemVibrator(); 501 try { 502 vibrator.vibrate(SHUTDOWN_VIBRATE_MS); 503 } catch (Exception e) { 504 // Failure to vibrate shouldn't interrupt shutdown. Just log it. 505 Log.w(TAG, "Failed to vibrate during shutdown.", e); 506 } 507 508 // vibrator is asynchronous so we need to wait to avoid shutting down too soon. 509 try { 510 Thread.sleep(SHUTDOWN_VIBRATE_MS); 511 } catch (InterruptedException unused) { 512 } 513 } 514 515 // Shutdown power 516 Log.i(TAG, "Performing low-level shutdown..."); 517 PowerManagerService.lowLevelShutdown(); 518 } 519} 520