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 18 package com.android.server.power; 19 20 import android.app.AlertDialog; 21 import android.app.Dialog; 22 import android.app.IActivityManager; 23 import android.app.KeyguardManager; 24 import android.app.ProgressDialog; 25 import android.app.WallpaperColors; 26 import android.app.WallpaperManager; 27 import android.bluetooth.BluetoothAdapter; 28 import android.bluetooth.IBluetoothManager; 29 import android.content.BroadcastReceiver; 30 import android.content.Context; 31 import android.content.DialogInterface; 32 import android.content.Intent; 33 import android.content.IntentFilter; 34 import android.graphics.Color; 35 import android.graphics.drawable.ColorDrawable; 36 import android.media.AudioAttributes; 37 import android.nfc.INfcAdapter; 38 import android.nfc.NfcAdapter; 39 import android.os.FileUtils; 40 import android.os.Handler; 41 import android.os.PowerManager; 42 import android.os.RecoverySystem; 43 import android.os.RemoteException; 44 import android.os.ServiceManager; 45 import android.os.SystemClock; 46 import android.os.SystemProperties; 47 import android.os.SystemVibrator; 48 import android.os.Trace; 49 import android.os.UserHandle; 50 import android.os.UserManager; 51 import android.os.Vibrator; 52 import android.os.storage.IStorageManager; 53 import android.os.storage.IStorageShutdownObserver; 54 import android.util.ArrayMap; 55 import android.util.Log; 56 import android.util.TimingsTraceLog; 57 import android.view.WindowManager; 58 59 import com.android.internal.telephony.ITelephony; 60 import com.android.server.RescueParty; 61 import com.android.server.LocalServices; 62 import com.android.server.pm.PackageManagerService; 63 import com.android.server.statusbar.StatusBarManagerInternal; 64 65 import java.io.File; 66 import java.io.FileOutputStream; 67 import java.io.IOException; 68 import java.nio.charset.StandardCharsets; 69 70 public final class ShutdownThread extends Thread { 71 // constants 72 private static final String TAG = "ShutdownThread"; 73 private static final int PHONE_STATE_POLL_SLEEP_MSEC = 500; 74 // maximum time we wait for the shutdown broadcast before going on. 75 private static final int MAX_BROADCAST_TIME = 10*1000; 76 private static final int MAX_SHUTDOWN_WAIT_TIME = 20*1000; 77 private static final int MAX_RADIO_WAIT_TIME = 12*1000; 78 private static final int MAX_UNCRYPT_WAIT_TIME = 15*60*1000; 79 // constants for progress bar. the values are roughly estimated based on timeout. 80 private static final int BROADCAST_STOP_PERCENT = 2; 81 private static final int ACTIVITY_MANAGER_STOP_PERCENT = 4; 82 private static final int PACKAGE_MANAGER_STOP_PERCENT = 6; 83 private static final int RADIO_STOP_PERCENT = 18; 84 private static final int MOUNT_SERVICE_STOP_PERCENT = 20; 85 86 // length of vibration before shutting down 87 private static final int SHUTDOWN_VIBRATE_MS = 500; 88 89 // state tracking 90 private static final Object sIsStartedGuard = new Object(); 91 private static boolean sIsStarted = false; 92 93 private static boolean mReboot; 94 private static boolean mRebootSafeMode; 95 private static boolean mRebootHasProgressBar; 96 private static String mReason; 97 98 // Provides shutdown assurance in case the system_server is killed 99 public static final String SHUTDOWN_ACTION_PROPERTY = "sys.shutdown.requested"; 100 101 // Indicates whether we are rebooting into safe mode 102 public static final String REBOOT_SAFEMODE_PROPERTY = "persist.sys.safemode"; 103 public static final String RO_SAFEMODE_PROPERTY = "ro.sys.safemode"; 104 105 // static instance of this thread 106 private static final ShutdownThread sInstance = new ShutdownThread(); 107 108 private static final AudioAttributes VIBRATION_ATTRIBUTES = new AudioAttributes.Builder() 109 .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION) 110 .setUsage(AudioAttributes.USAGE_ASSISTANCE_SONIFICATION) 111 .build(); 112 113 // Metrics that will be reported to tron after reboot 114 private static final ArrayMap<String, Long> TRON_METRICS = new ArrayMap<>(); 115 116 // File to use for save metrics 117 private static final String METRICS_FILE_BASENAME = "/data/system/shutdown-metrics"; 118 119 // Metrics names to be persisted in shutdown-metrics file 120 private static String METRIC_SYSTEM_SERVER = "shutdown_system_server"; 121 private static String METRIC_SEND_BROADCAST = "shutdown_send_shutdown_broadcast"; 122 private static String METRIC_AM = "shutdown_activity_manager"; 123 private static String METRIC_PM = "shutdown_package_manager"; 124 private static String METRIC_RADIOS = "shutdown_radios"; 125 private static String METRIC_BT = "shutdown_bt"; 126 private static String METRIC_RADIO = "shutdown_radio"; 127 private static String METRIC_NFC = "shutdown_nfc"; 128 private static String METRIC_SM = "shutdown_storage_manager"; 129 130 private final Object mActionDoneSync = new Object(); 131 private boolean mActionDone; 132 private Context mContext; 133 private PowerManager mPowerManager; 134 private PowerManager.WakeLock mCpuWakeLock; 135 private PowerManager.WakeLock mScreenWakeLock; 136 private Handler mHandler; 137 138 private static AlertDialog sConfirmDialog; 139 private ProgressDialog mProgressDialog; 140 141 private ShutdownThread() { 142 } 143 144 /** 145 * Request a clean shutdown, waiting for subsystems to clean up their 146 * state etc. Must be called from a Looper thread in which its UI 147 * is shown. 148 * 149 * @param context Context used to display the shutdown progress dialog. This must be a context 150 * suitable for displaying UI (aka Themable). 151 * @param reason code to pass to android_reboot() (e.g. "userrequested"), or null. 152 * @param confirm true if user confirmation is needed before shutting down. 153 */ 154 public static void shutdown(final Context context, String reason, boolean confirm) { 155 mReboot = false; 156 mRebootSafeMode = false; 157 mReason = reason; 158 shutdownInner(context, confirm); 159 } 160 161 private static void shutdownInner(final Context context, boolean confirm) { 162 // ShutdownThread is called from many places, so best to verify here that the context passed 163 // in is themed. 164 context.assertRuntimeOverlayThemable(); 165 166 // ensure that only one thread is trying to power down. 167 // any additional calls are just returned 168 synchronized (sIsStartedGuard) { 169 if (sIsStarted) { 170 Log.d(TAG, "Request to shutdown already running, returning."); 171 return; 172 } 173 } 174 175 final int longPressBehavior = context.getResources().getInteger( 176 com.android.internal.R.integer.config_longPressOnPowerBehavior); 177 final int resourceId = mRebootSafeMode 178 ? com.android.internal.R.string.reboot_safemode_confirm 179 : (longPressBehavior == 2 180 ? com.android.internal.R.string.shutdown_confirm_question 181 : com.android.internal.R.string.shutdown_confirm); 182 183 Log.d(TAG, "Notifying thread to start shutdown longPressBehavior=" + longPressBehavior); 184 185 if (confirm) { 186 final CloseDialogReceiver closer = new CloseDialogReceiver(context); 187 if (sConfirmDialog != null) { 188 sConfirmDialog.dismiss(); 189 } 190 sConfirmDialog = new AlertDialog.Builder(context) 191 .setTitle(mRebootSafeMode 192 ? com.android.internal.R.string.reboot_safemode_title 193 : com.android.internal.R.string.power_off) 194 .setMessage(resourceId) 195 .setPositiveButton(com.android.internal.R.string.yes, new DialogInterface.OnClickListener() { 196 public void onClick(DialogInterface dialog, int which) { 197 beginShutdownSequence(context); 198 } 199 }) 200 .setNegativeButton(com.android.internal.R.string.no, null) 201 .create(); 202 closer.dialog = sConfirmDialog; 203 sConfirmDialog.setOnDismissListener(closer); 204 sConfirmDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG); 205 sConfirmDialog.show(); 206 } else { 207 beginShutdownSequence(context); 208 } 209 } 210 211 private static class CloseDialogReceiver extends BroadcastReceiver 212 implements DialogInterface.OnDismissListener { 213 private Context mContext; 214 public Dialog dialog; 215 216 CloseDialogReceiver(Context context) { 217 mContext = context; 218 IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS); 219 context.registerReceiver(this, filter); 220 } 221 222 @Override 223 public void onReceive(Context context, Intent intent) { 224 dialog.cancel(); 225 } 226 227 public void onDismiss(DialogInterface unused) { 228 mContext.unregisterReceiver(this); 229 } 230 } 231 232 /** 233 * Request a clean shutdown, waiting for subsystems to clean up their 234 * state etc. Must be called from a Looper thread in which its UI 235 * is shown. 236 * 237 * @param context Context used to display the shutdown progress dialog. This must be a context 238 * suitable for displaying UI (aka Themable). 239 * @param reason code to pass to the kernel (e.g. "recovery"), or null. 240 * @param confirm true if user confirmation is needed before shutting down. 241 */ 242 public static void reboot(final Context context, String reason, boolean confirm) { 243 mReboot = true; 244 mRebootSafeMode = false; 245 mRebootHasProgressBar = false; 246 mReason = reason; 247 shutdownInner(context, confirm); 248 } 249 250 /** 251 * Request a reboot into safe mode. Must be called from a Looper thread in which its UI 252 * is shown. 253 * 254 * @param context Context used to display the shutdown progress dialog. This must be a context 255 * suitable for displaying UI (aka Themable). 256 * @param confirm true if user confirmation is needed before shutting down. 257 */ 258 public static void rebootSafeMode(final Context context, boolean confirm) { 259 UserManager um = (UserManager) context.getSystemService(Context.USER_SERVICE); 260 if (um.hasUserRestriction(UserManager.DISALLOW_SAFE_BOOT)) { 261 return; 262 } 263 264 mReboot = true; 265 mRebootSafeMode = true; 266 mRebootHasProgressBar = false; 267 mReason = null; 268 shutdownInner(context, confirm); 269 } 270 271 private static ProgressDialog showShutdownDialog(Context context) { 272 // Throw up a system dialog to indicate the device is rebooting / shutting down. 273 ProgressDialog pd = new ProgressDialog(context); 274 275 // Path 1: Reboot to recovery for update 276 // Condition: mReason startswith REBOOT_RECOVERY_UPDATE 277 // 278 // Path 1a: uncrypt needed 279 // Condition: if /cache/recovery/uncrypt_file exists but 280 // /cache/recovery/block.map doesn't. 281 // UI: determinate progress bar (mRebootHasProgressBar == True) 282 // 283 // * Path 1a is expected to be removed once the GmsCore shipped on 284 // device always calls uncrypt prior to reboot. 285 // 286 // Path 1b: uncrypt already done 287 // UI: spinning circle only (no progress bar) 288 // 289 // Path 2: Reboot to recovery for factory reset 290 // Condition: mReason == REBOOT_RECOVERY 291 // UI: spinning circle only (no progress bar) 292 // 293 // Path 3: Regular reboot / shutdown 294 // Condition: Otherwise 295 // UI: spinning circle only (no progress bar) 296 297 // mReason could be "recovery-update" or "recovery-update,quiescent". 298 if (mReason != null && mReason.startsWith(PowerManager.REBOOT_RECOVERY_UPDATE)) { 299 // We need the progress bar if uncrypt will be invoked during the 300 // reboot, which might be time-consuming. 301 mRebootHasProgressBar = RecoverySystem.UNCRYPT_PACKAGE_FILE.exists() 302 && !(RecoverySystem.BLOCK_MAP_FILE.exists()); 303 pd.setTitle(context.getText(com.android.internal.R.string.reboot_to_update_title)); 304 if (mRebootHasProgressBar) { 305 pd.setMax(100); 306 pd.setProgress(0); 307 pd.setIndeterminate(false); 308 pd.setProgressNumberFormat(null); 309 pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); 310 pd.setMessage(context.getText( 311 com.android.internal.R.string.reboot_to_update_prepare)); 312 } else { 313 if (showSysuiReboot()) { 314 return null; 315 } 316 pd.setIndeterminate(true); 317 pd.setMessage(context.getText( 318 com.android.internal.R.string.reboot_to_update_reboot)); 319 } 320 } else if (mReason != null && mReason.equals(PowerManager.REBOOT_RECOVERY)) { 321 if (RescueParty.isAttemptingFactoryReset()) { 322 // We're not actually doing a factory reset yet; we're rebooting 323 // to ask the user if they'd like to reset, so give them a less 324 // scary dialog message. 325 pd.setTitle(context.getText(com.android.internal.R.string.power_off)); 326 pd.setMessage(context.getText(com.android.internal.R.string.shutdown_progress)); 327 pd.setIndeterminate(true); 328 } else { 329 // Factory reset path. Set the dialog message accordingly. 330 pd.setTitle(context.getText(com.android.internal.R.string.reboot_to_reset_title)); 331 pd.setMessage(context.getText( 332 com.android.internal.R.string.reboot_to_reset_message)); 333 pd.setIndeterminate(true); 334 } 335 } else { 336 if (showSysuiReboot()) { 337 return null; 338 } 339 pd.setTitle(context.getText(com.android.internal.R.string.power_off)); 340 pd.setMessage(context.getText(com.android.internal.R.string.shutdown_progress)); 341 pd.setIndeterminate(true); 342 } 343 pd.setCancelable(false); 344 pd.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG); 345 346 pd.show(); 347 return pd; 348 } 349 350 private static boolean showSysuiReboot() { 351 Log.d(TAG, "Attempting to use SysUI shutdown UI"); 352 try { 353 StatusBarManagerInternal service = LocalServices.getService( 354 StatusBarManagerInternal.class); 355 if (service.showShutdownUi(mReboot, mReason)) { 356 // Sysui will handle shutdown UI. 357 Log.d(TAG, "SysUI handling shutdown UI"); 358 return true; 359 } 360 } catch (Exception e) { 361 // If anything went wrong, ignore it and use fallback ui 362 } 363 Log.d(TAG, "SysUI is unavailable"); 364 return false; 365 } 366 367 private static void beginShutdownSequence(Context context) { 368 synchronized (sIsStartedGuard) { 369 if (sIsStarted) { 370 Log.d(TAG, "Shutdown sequence already running, returning."); 371 return; 372 } 373 sIsStarted = true; 374 } 375 376 sInstance.mProgressDialog = showShutdownDialog(context); 377 sInstance.mContext = context; 378 sInstance.mPowerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE); 379 380 // make sure we never fall asleep again 381 sInstance.mCpuWakeLock = null; 382 try { 383 sInstance.mCpuWakeLock = sInstance.mPowerManager.newWakeLock( 384 PowerManager.PARTIAL_WAKE_LOCK, TAG + "-cpu"); 385 sInstance.mCpuWakeLock.setReferenceCounted(false); 386 sInstance.mCpuWakeLock.acquire(); 387 } catch (SecurityException e) { 388 Log.w(TAG, "No permission to acquire wake lock", e); 389 sInstance.mCpuWakeLock = null; 390 } 391 392 // also make sure the screen stays on for better user experience 393 sInstance.mScreenWakeLock = null; 394 if (sInstance.mPowerManager.isScreenOn()) { 395 try { 396 sInstance.mScreenWakeLock = sInstance.mPowerManager.newWakeLock( 397 PowerManager.FULL_WAKE_LOCK, TAG + "-screen"); 398 sInstance.mScreenWakeLock.setReferenceCounted(false); 399 sInstance.mScreenWakeLock.acquire(); 400 } catch (SecurityException e) { 401 Log.w(TAG, "No permission to acquire wake lock", e); 402 sInstance.mScreenWakeLock = null; 403 } 404 } 405 406 // start the thread that initiates shutdown 407 sInstance.mHandler = new Handler() { 408 }; 409 sInstance.start(); 410 } 411 412 void actionDone() { 413 synchronized (mActionDoneSync) { 414 mActionDone = true; 415 mActionDoneSync.notifyAll(); 416 } 417 } 418 419 /** 420 * Makes sure we handle the shutdown gracefully. 421 * Shuts off power regardless of radio and bluetooth state if the alloted time has passed. 422 */ 423 public void run() { 424 TimingsTraceLog shutdownTimingLog = newTimingsLog(); 425 shutdownTimingLog.traceBegin("SystemServerShutdown"); 426 metricStarted(METRIC_SYSTEM_SERVER); 427 428 BroadcastReceiver br = new BroadcastReceiver() { 429 @Override public void onReceive(Context context, Intent intent) { 430 // We don't allow apps to cancel this, so ignore the result. 431 actionDone(); 432 } 433 }; 434 435 /* 436 * Write a system property in case the system_server reboots before we 437 * get to the actual hardware restart. If that happens, we'll retry at 438 * the beginning of the SystemServer startup. 439 */ 440 { 441 String reason = (mReboot ? "1" : "0") + (mReason != null ? mReason : ""); 442 SystemProperties.set(SHUTDOWN_ACTION_PROPERTY, reason); 443 } 444 445 /* 446 * If we are rebooting into safe mode, write a system property 447 * indicating so. 448 */ 449 if (mRebootSafeMode) { 450 SystemProperties.set(REBOOT_SAFEMODE_PROPERTY, "1"); 451 } 452 453 metricStarted(METRIC_SEND_BROADCAST); 454 shutdownTimingLog.traceBegin("SendShutdownBroadcast"); 455 Log.i(TAG, "Sending shutdown broadcast..."); 456 457 // First send the high-level shut down broadcast. 458 mActionDone = false; 459 Intent intent = new Intent(Intent.ACTION_SHUTDOWN); 460 intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND 461 | Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND); 462 mContext.sendOrderedBroadcastAsUser(intent, 463 UserHandle.ALL, null, br, mHandler, 0, null, null); 464 465 final long endTime = SystemClock.elapsedRealtime() + MAX_BROADCAST_TIME; 466 synchronized (mActionDoneSync) { 467 while (!mActionDone) { 468 long delay = endTime - SystemClock.elapsedRealtime(); 469 if (delay <= 0) { 470 Log.w(TAG, "Shutdown broadcast timed out"); 471 break; 472 } else if (mRebootHasProgressBar) { 473 int status = (int)((MAX_BROADCAST_TIME - delay) * 1.0 * 474 BROADCAST_STOP_PERCENT / MAX_BROADCAST_TIME); 475 sInstance.setRebootProgress(status, null); 476 } 477 try { 478 mActionDoneSync.wait(Math.min(delay, PHONE_STATE_POLL_SLEEP_MSEC)); 479 } catch (InterruptedException e) { 480 } 481 } 482 } 483 if (mRebootHasProgressBar) { 484 sInstance.setRebootProgress(BROADCAST_STOP_PERCENT, null); 485 } 486 shutdownTimingLog.traceEnd(); // SendShutdownBroadcast 487 metricEnded(METRIC_SEND_BROADCAST); 488 489 Log.i(TAG, "Shutting down activity manager..."); 490 shutdownTimingLog.traceBegin("ShutdownActivityManager"); 491 metricStarted(METRIC_AM); 492 493 final IActivityManager am = 494 IActivityManager.Stub.asInterface(ServiceManager.checkService("activity")); 495 if (am != null) { 496 try { 497 am.shutdown(MAX_BROADCAST_TIME); 498 } catch (RemoteException e) { 499 } 500 } 501 if (mRebootHasProgressBar) { 502 sInstance.setRebootProgress(ACTIVITY_MANAGER_STOP_PERCENT, null); 503 } 504 shutdownTimingLog.traceEnd();// ShutdownActivityManager 505 metricEnded(METRIC_AM); 506 507 Log.i(TAG, "Shutting down package manager..."); 508 shutdownTimingLog.traceBegin("ShutdownPackageManager"); 509 metricStarted(METRIC_PM); 510 511 final PackageManagerService pm = (PackageManagerService) 512 ServiceManager.getService("package"); 513 if (pm != null) { 514 pm.shutdown(); 515 } 516 if (mRebootHasProgressBar) { 517 sInstance.setRebootProgress(PACKAGE_MANAGER_STOP_PERCENT, null); 518 } 519 shutdownTimingLog.traceEnd(); // ShutdownPackageManager 520 metricEnded(METRIC_PM); 521 522 // Shutdown radios. 523 shutdownTimingLog.traceBegin("ShutdownRadios"); 524 metricStarted(METRIC_RADIOS); 525 shutdownRadios(MAX_RADIO_WAIT_TIME); 526 if (mRebootHasProgressBar) { 527 sInstance.setRebootProgress(RADIO_STOP_PERCENT, null); 528 } 529 shutdownTimingLog.traceEnd(); // ShutdownRadios 530 metricEnded(METRIC_RADIOS); 531 532 // Shutdown StorageManagerService to ensure media is in a safe state 533 IStorageShutdownObserver observer = new IStorageShutdownObserver.Stub() { 534 public void onShutDownComplete(int statusCode) throws RemoteException { 535 Log.w(TAG, "Result code " + statusCode + " from StorageManagerService.shutdown"); 536 actionDone(); 537 } 538 }; 539 540 Log.i(TAG, "Shutting down StorageManagerService"); 541 shutdownTimingLog.traceBegin("ShutdownStorageManager"); 542 metricStarted(METRIC_SM); 543 544 // Set initial variables and time out time. 545 mActionDone = false; 546 final long endShutTime = SystemClock.elapsedRealtime() + MAX_SHUTDOWN_WAIT_TIME; 547 synchronized (mActionDoneSync) { 548 try { 549 final IStorageManager storageManager = IStorageManager.Stub.asInterface( 550 ServiceManager.checkService("mount")); 551 if (storageManager != null) { 552 storageManager.shutdown(observer); 553 } else { 554 Log.w(TAG, "StorageManagerService unavailable for shutdown"); 555 } 556 } catch (Exception e) { 557 Log.e(TAG, "Exception during StorageManagerService shutdown", e); 558 } 559 while (!mActionDone) { 560 long delay = endShutTime - SystemClock.elapsedRealtime(); 561 if (delay <= 0) { 562 Log.w(TAG, "StorageManager shutdown wait timed out"); 563 break; 564 } else if (mRebootHasProgressBar) { 565 int status = (int)((MAX_SHUTDOWN_WAIT_TIME - delay) * 1.0 * 566 (MOUNT_SERVICE_STOP_PERCENT - RADIO_STOP_PERCENT) / 567 MAX_SHUTDOWN_WAIT_TIME); 568 status += RADIO_STOP_PERCENT; 569 sInstance.setRebootProgress(status, null); 570 } 571 try { 572 mActionDoneSync.wait(Math.min(delay, PHONE_STATE_POLL_SLEEP_MSEC)); 573 } catch (InterruptedException e) { 574 } 575 } 576 } 577 shutdownTimingLog.traceEnd(); // ShutdownStorageManager 578 metricEnded(METRIC_SM); 579 580 if (mRebootHasProgressBar) { 581 sInstance.setRebootProgress(MOUNT_SERVICE_STOP_PERCENT, null); 582 583 // If it's to reboot to install an update and uncrypt hasn't been 584 // done yet, trigger it now. 585 uncrypt(); 586 } 587 588 shutdownTimingLog.traceEnd(); // SystemServerShutdown 589 metricEnded(METRIC_SYSTEM_SERVER); 590 saveMetrics(mReboot); 591 rebootOrShutdown(mContext, mReboot, mReason); 592 } 593 594 private static TimingsTraceLog newTimingsLog() { 595 return new TimingsTraceLog("ShutdownTiming", Trace.TRACE_TAG_SYSTEM_SERVER); 596 } 597 598 private static void metricStarted(String metricKey) { 599 synchronized (TRON_METRICS) { 600 TRON_METRICS.put(metricKey, -1 * SystemClock.elapsedRealtime()); 601 } 602 } 603 604 private static void metricEnded(String metricKey) { 605 synchronized (TRON_METRICS) { 606 TRON_METRICS 607 .put(metricKey, SystemClock.elapsedRealtime() + TRON_METRICS.get(metricKey)); 608 } 609 } 610 611 private void setRebootProgress(final int progress, final CharSequence message) { 612 mHandler.post(new Runnable() { 613 @Override 614 public void run() { 615 if (mProgressDialog != null) { 616 mProgressDialog.setProgress(progress); 617 if (message != null) { 618 mProgressDialog.setMessage(message); 619 } 620 } 621 } 622 }); 623 } 624 625 private void shutdownRadios(final int timeout) { 626 // If a radio is wedged, disabling it may hang so we do this work in another thread, 627 // just in case. 628 final long endTime = SystemClock.elapsedRealtime() + timeout; 629 final boolean[] done = new boolean[1]; 630 Thread t = new Thread() { 631 public void run() { 632 TimingsTraceLog shutdownTimingsTraceLog = newTimingsLog(); 633 boolean nfcOff; 634 boolean bluetoothReadyForShutdown; 635 boolean radioOff; 636 637 final INfcAdapter nfc = 638 INfcAdapter.Stub.asInterface(ServiceManager.checkService("nfc")); 639 final ITelephony phone = 640 ITelephony.Stub.asInterface(ServiceManager.checkService("phone")); 641 final IBluetoothManager bluetooth = 642 IBluetoothManager.Stub.asInterface(ServiceManager.checkService( 643 BluetoothAdapter.BLUETOOTH_MANAGER_SERVICE)); 644 try { 645 nfcOff = nfc == null || 646 nfc.getState() == NfcAdapter.STATE_OFF; 647 if (!nfcOff) { 648 Log.w(TAG, "Turning off NFC..."); 649 metricStarted(METRIC_NFC); 650 nfc.disable(false); // Don't persist new state 651 } 652 } catch (RemoteException ex) { 653 Log.e(TAG, "RemoteException during NFC shutdown", ex); 654 nfcOff = true; 655 } 656 657 try { 658 bluetoothReadyForShutdown = bluetooth == null || 659 bluetooth.getState() == BluetoothAdapter.STATE_OFF; 660 if (!bluetoothReadyForShutdown) { 661 Log.w(TAG, "Disabling Bluetooth..."); 662 metricStarted(METRIC_BT); 663 bluetooth.disable(mContext.getPackageName(), false); // disable but don't persist new state 664 } 665 } catch (RemoteException ex) { 666 Log.e(TAG, "RemoteException during bluetooth shutdown", ex); 667 bluetoothReadyForShutdown = true; 668 } 669 670 try { 671 radioOff = phone == null || !phone.needMobileRadioShutdown(); 672 if (!radioOff) { 673 Log.w(TAG, "Turning off cellular radios..."); 674 metricStarted(METRIC_RADIO); 675 phone.shutdownMobileRadios(); 676 } 677 } catch (RemoteException ex) { 678 Log.e(TAG, "RemoteException during radio shutdown", ex); 679 radioOff = true; 680 } 681 682 Log.i(TAG, "Waiting for NFC, Bluetooth and Radio..."); 683 684 long delay = endTime - SystemClock.elapsedRealtime(); 685 while (delay > 0) { 686 if (mRebootHasProgressBar) { 687 int status = (int)((timeout - delay) * 1.0 * 688 (RADIO_STOP_PERCENT - PACKAGE_MANAGER_STOP_PERCENT) / timeout); 689 status += PACKAGE_MANAGER_STOP_PERCENT; 690 sInstance.setRebootProgress(status, null); 691 } 692 693 if (!bluetoothReadyForShutdown) { 694 try { 695 // BLE only mode can happen when BT is turned off 696 // We will continue shutting down in such case 697 bluetoothReadyForShutdown = 698 bluetooth.getState() == BluetoothAdapter.STATE_OFF || 699 bluetooth.getState() == BluetoothAdapter.STATE_BLE_TURNING_OFF || 700 bluetooth.getState() == BluetoothAdapter.STATE_BLE_ON; 701 } catch (RemoteException ex) { 702 Log.e(TAG, "RemoteException during bluetooth shutdown", ex); 703 bluetoothReadyForShutdown = true; 704 } 705 if (bluetoothReadyForShutdown) { 706 Log.i(TAG, "Bluetooth turned off."); 707 metricEnded(METRIC_BT); 708 shutdownTimingsTraceLog 709 .logDuration("ShutdownBt", TRON_METRICS.get(METRIC_BT)); 710 } 711 } 712 if (!radioOff) { 713 try { 714 radioOff = !phone.needMobileRadioShutdown(); 715 } catch (RemoteException ex) { 716 Log.e(TAG, "RemoteException during radio shutdown", ex); 717 radioOff = true; 718 } 719 if (radioOff) { 720 Log.i(TAG, "Radio turned off."); 721 metricEnded(METRIC_RADIO); 722 shutdownTimingsTraceLog 723 .logDuration("ShutdownRadio", TRON_METRICS.get(METRIC_RADIO)); 724 } 725 } 726 if (!nfcOff) { 727 try { 728 nfcOff = nfc.getState() == NfcAdapter.STATE_OFF; 729 } catch (RemoteException ex) { 730 Log.e(TAG, "RemoteException during NFC shutdown", ex); 731 nfcOff = true; 732 } 733 if (nfcOff) { 734 Log.i(TAG, "NFC turned off."); 735 metricEnded(METRIC_NFC); 736 shutdownTimingsTraceLog 737 .logDuration("ShutdownNfc", TRON_METRICS.get(METRIC_NFC)); 738 } 739 } 740 741 if (radioOff && bluetoothReadyForShutdown && nfcOff) { 742 Log.i(TAG, "NFC, Radio and Bluetooth shutdown complete."); 743 done[0] = true; 744 break; 745 } 746 SystemClock.sleep(PHONE_STATE_POLL_SLEEP_MSEC); 747 748 delay = endTime - SystemClock.elapsedRealtime(); 749 } 750 } 751 }; 752 753 t.start(); 754 try { 755 t.join(timeout); 756 } catch (InterruptedException ex) { 757 } 758 if (!done[0]) { 759 Log.w(TAG, "Timed out waiting for NFC, Radio and Bluetooth shutdown."); 760 } 761 } 762 763 /** 764 * Do not call this directly. Use {@link #reboot(Context, String, boolean)} 765 * or {@link #shutdown(Context, String, boolean)} instead. 766 * 767 * @param context Context used to vibrate or null without vibration 768 * @param reboot true to reboot or false to shutdown 769 * @param reason reason for reboot/shutdown 770 */ 771 public static void rebootOrShutdown(final Context context, boolean reboot, String reason) { 772 if (reboot) { 773 Log.i(TAG, "Rebooting, reason: " + reason); 774 PowerManagerService.lowLevelReboot(reason); 775 Log.e(TAG, "Reboot failed, will attempt shutdown instead"); 776 reason = null; 777 } else if (SHUTDOWN_VIBRATE_MS > 0 && context != null) { 778 // vibrate before shutting down 779 Vibrator vibrator = new SystemVibrator(context); 780 try { 781 vibrator.vibrate(SHUTDOWN_VIBRATE_MS, VIBRATION_ATTRIBUTES); 782 } catch (Exception e) { 783 // Failure to vibrate shouldn't interrupt shutdown. Just log it. 784 Log.w(TAG, "Failed to vibrate during shutdown.", e); 785 } 786 787 // vibrator is asynchronous so we need to wait to avoid shutting down too soon. 788 try { 789 Thread.sleep(SHUTDOWN_VIBRATE_MS); 790 } catch (InterruptedException unused) { 791 } 792 } 793 // Shutdown power 794 Log.i(TAG, "Performing low-level shutdown..."); 795 PowerManagerService.lowLevelShutdown(reason); 796 } 797 798 private static void saveMetrics(boolean reboot) { 799 StringBuilder metricValue = new StringBuilder(); 800 metricValue.append("reboot:"); 801 metricValue.append(reboot ? "y" : "n"); 802 final int metricsSize = TRON_METRICS.size(); 803 for (int i = 0; i < metricsSize; i++) { 804 final String name = TRON_METRICS.keyAt(i); 805 final long value = TRON_METRICS.valueAt(i); 806 if (value < 0) { 807 Log.e(TAG, "metricEnded wasn't called for " + name); 808 continue; 809 } 810 metricValue.append(',').append(name).append(':').append(value); 811 } 812 File tmp = new File(METRICS_FILE_BASENAME + ".tmp"); 813 boolean saved = false; 814 try (FileOutputStream fos = new FileOutputStream(tmp)) { 815 fos.write(metricValue.toString().getBytes(StandardCharsets.UTF_8)); 816 saved = true; 817 } catch (IOException e) { 818 Log.e(TAG,"Cannot save shutdown metrics", e); 819 } 820 if (saved) { 821 tmp.renameTo(new File(METRICS_FILE_BASENAME + ".txt")); 822 } 823 } 824 825 private void uncrypt() { 826 Log.i(TAG, "Calling uncrypt and monitoring the progress..."); 827 828 final RecoverySystem.ProgressListener progressListener = 829 new RecoverySystem.ProgressListener() { 830 @Override 831 public void onProgress(int status) { 832 if (status >= 0 && status < 100) { 833 // Scale down to [MOUNT_SERVICE_STOP_PERCENT, 100). 834 status = (int)(status * (100.0 - MOUNT_SERVICE_STOP_PERCENT) / 100); 835 status += MOUNT_SERVICE_STOP_PERCENT; 836 CharSequence msg = mContext.getText( 837 com.android.internal.R.string.reboot_to_update_package); 838 sInstance.setRebootProgress(status, msg); 839 } else if (status == 100) { 840 CharSequence msg = mContext.getText( 841 com.android.internal.R.string.reboot_to_update_reboot); 842 sInstance.setRebootProgress(status, msg); 843 } else { 844 // Ignored 845 } 846 } 847 }; 848 849 final boolean[] done = new boolean[1]; 850 done[0] = false; 851 Thread t = new Thread() { 852 @Override 853 public void run() { 854 RecoverySystem rs = (RecoverySystem) mContext.getSystemService( 855 Context.RECOVERY_SERVICE); 856 String filename = null; 857 try { 858 filename = FileUtils.readTextFile(RecoverySystem.UNCRYPT_PACKAGE_FILE, 0, null); 859 rs.processPackage(mContext, new File(filename), progressListener); 860 } catch (IOException e) { 861 Log.e(TAG, "Error uncrypting file", e); 862 } 863 done[0] = true; 864 } 865 }; 866 t.start(); 867 868 try { 869 t.join(MAX_UNCRYPT_WAIT_TIME); 870 } catch (InterruptedException unused) { 871 } 872 if (!done[0]) { 873 Log.w(TAG, "Timed out waiting for uncrypt."); 874 final int uncryptTimeoutError = 100; 875 String timeoutMessage = String.format("uncrypt_time: %d\n" + "uncrypt_error: %d\n", 876 MAX_UNCRYPT_WAIT_TIME / 1000, uncryptTimeoutError); 877 try { 878 FileUtils.stringToFile(RecoverySystem.UNCRYPT_STATUS_FILE, timeoutMessage); 879 } catch (IOException e) { 880 Log.e(TAG, "Failed to write timeout message to uncrypt status", e); 881 } 882 } 883 } 884 } 885
