package com
.android
.server
.power;
19
20 import android
.app
.ActivityManagerInternal;
21 import android
.app
.AlertDialog;
22 import android
.app
.BroadcastOptions;
23 import android
.app
.Dialog;
24 import android
.app
.I
ActivityManager;
25 import android
.app
.ProgressDialog;
26 import android
.app
.admin
.SecurityLog;
27 import android
.content
.BroadcastReceiver;
28 import android
.content
.Context;
29 import android
.content
.DialogInterface;
30 import android
.content
.IIntentReceiver;
31 import android
.content
.Intent;
32 import android
.content
.IntentFilter;
33 import android
.content
.pm
.PackageManagerInternal;
34 import android
.content
.pm
.ActivityInfo;
35 import android
.os
.Bundle;
36 import android
.os
.FileUtils;
37 import android
.os
.Handler;
38 import android
.os
.PowerManager;
39 import android
.os
.RecoverySystem;
40 import android
.os
.RemoteException;
41 import android
.os
.ServiceManager;
42 import android
.os
.SystemClock;
43 import android
.os
.SystemProperties;
44 import android
.os
.SystemVibrator;
45 import android
.os
.Trace;
46 import android
.os
.UserHandle;
47 import android
.os
.UserManager;
48 import android
.os
.VibrationAttributes;
49 import android
.os
.VibrationEffect;
50 import android
.os
.Vibrator;
51 import android
.os
.vibrator
.persistence
.VibrationXmlParser;
52 import android
.telephony
.TelephonyManager;
53 import android
.text
.TextUtils;
54 import android
.util
.ArrayMap;
55 import android
.util
.Log;
56 import android
.util
.Slog;
57 import android
.util
.TimingsTraceLog;
58 import android
.view
.SurfaceControl;
59 import android
.view
.WindowManager;
60 import android
.view
.IWindowManager;
61 import android
.view
.Surface;
62 import com
.android
.server
.pm
.OplusDLCUtils;
63
64 //#ifdef OPLUS_FEATURE_SHUTDOWN_DETECT
65 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
66 import java
.io
.FileWriter;
67 import libcore
.io
.IoUtils;
68 //#endif /* OPLUS_FEATURE_SHUTDOWN_DETECT */
69
70 import com
.android
.internal
.annotations
.VisibleForTesting;
71 import com
.android
.server
.LocalServices;
72 import com
.android
.server
.RescueParty;
73 import com
.android
.server
.statusbar
.StatusBarManagerInternal;
74
75 import java
.io
.File;
76 import java
.io
.FileOutputStream;
77 import java
.io
.FileReader;
78 import java
.io
.IOException;
79 import java
.nio
.charset
.StandardCharsets;
80
81 public final class ShutdownThread extends Thread {
82 // constants
83 private static final boolean DEBUG = true;
84 private static final String TAG = "ShutdownThread";
85 private static final int ACTION_DONE_POLL_WAIT_MS = 500;
86 private static final int RADIOS_STATE_POLL_SLEEP_MS = 100;
87 // maximum time we wait for the shutdown broadcast before going on
.
88 private static final int MAX_BROADCAST_TIME = 10 * 1000;
89 private static final int MAX_CHECK_POINTS_DUMP_WAIT_TIME = 10 * 1000;
90 private static final int MAX_RADIO_WAIT_TIME = 12 * 1000;
91 private static final int MAX_UNCRYPT_WAIT_TIME = 15 * 60 * 1000;
92 // constants for progress bar
. the values are roughly estimated based on timeout
.
93 private static final int BROADCAST_STOP_PERCENT = 2;
94 private static final int
ACTIVITY_MANAGER_STOP_PERCENT = 4;
95 private static final int PACKAGE_MANAGER_STOP_PERCENT = 6;
96 private static final int RADIO_STOP_PERCENT = 18;
97 private static final int MOUNT_SERVICE_STOP_PERCENT = 20;
98 // Time we should wait for vendor subsystem shutdown
99 // Sleep times
(ms
) between checks
of the vendor subsystem state
100 private static final int VENDOR_SUBSYS_STATE_CHECK_INTERVAL_MS = 100;
101 // Max time we wait for vendor subsystems to shut down before resuming
102 // with full system shutdown
103 private static final int VENDOR_SUBSYS_MAX_WAIT_MS = 10000;
104
105 // length
of vibration before shutting down
106 @VisibleForTesting static final int DEFAULT_SHUTDOWN_VIBRATE_MS = 500;
107
108 // state tracking
109 private static final Object sIsStartedGuard = new Object
();
110 private static boolean sIsStarted = false;
111
112 private static boolean mReboot;
113 private static boolean mRebootSafeMode;
114 private static boolean mRebootHasProgressBar;
115 private static String mReason;
116
117 // Provides shutdown assurance in case the system_server is killed
118 public static final String SHUTDOWN_ACTION_PROPERTY = "sys
.shutdown
.requested";
119
120 // Indicates whether we are rebooting into safe mode
121 public static final String REBOOT_SAFEMODE_PROPERTY = "persist
.sys
.safemode";
122 public static final String RO_SAFEMODE_PROPERTY = "ro
.sys
.safemode";
123
124 // static instance
of this thread
125 private static final ShutdownThread sInstance = new ShutdownThread
();
126
127 // Metrics that will be reported to tron after reboot
128 private static final ArrayMap<String, Long> TRON_METRICS = new ArrayMap<>
();
129
130 // File to use for saving shutdown metrics
131 private static final String METRICS_FILE_BASENAME = "/data/system/shutdown-metrics";
132 // File to use for saving shutdown check points
133 private static final String CHECK_POINTS_FILE_BASENAME =
134 "/data/system/shutdown-checkpoints/checkpoints";
135
136 private static final int MIN_SHUTDOWN_ANIMATION_PLAY_TIME = 5*1000;
137 private static long beginAnimationTime = 0;
138 private static long endAnimationTime = 0;
139
140 // Metrics names to be persisted in shutdown-metrics file
141 private static String METRIC_SYSTEM_SERVER = "shutdown_system_server";
142 private static String METRIC_SEND_BROADCAST = "shutdown_send_shutdown_broadcast";
143 private static String METRIC_AM = "shutdown_
activity_manager";
144 private static String METRIC_PM = "shutdown_package_manager";
145 private static String METRIC_RADIOS = "shutdown_radios";
146 private static String METRIC_RADIO = "shutdown_radio";
147 private static String METRIC_SHUTDOWN_TIME_START = "begin_shutdown";
148
149 private final Injector mInjector;
150
151 private final Object mActionDoneSync = new Object
();
152 private boolean mActionDone;
153 private Context mContext;
154 private PowerManager mPowerManager;
155 private PowerManager
.WakeLock mCpuWakeLock;
156 private PowerManager
.WakeLock mScreenWakeLock;
157 private Handler mHandler;
158
159 private static
AlertDialog sConfirmDialog;
160 private ProgressDialog mProgressDialog;
161
162 private static final String PROP_IS_MONKEYKING_RUNNING = "oplus
.autotest
.monkeyRunning";
163 private static final String PROP_IS_MONKEY_RUNNING = "oppo
.autotest
.monkeyRunning";
164 private static final String PROP_IS_AGINGVERSION = "ro
.build
.aging_version";
165
166 private ShutdownThread
() {
167 this
(new Injector
());
168 }
169
170 @VisibleForTesting
171 ShutdownThread
(Injector injector
) {
172 mInjector = injector;
173 }
174
175 /**
176 * Request a clean shutdown, waiting for subsystems to clean up their
177 * state etc
. Must be called from a Looper thread in which its UI
178 * is shown
.
179 *
180 * @param context Context used to display the shutdown progress dialog
. This must be a context
181 * suitable for displaying UI
(aka Themable
).
182 * @param reason code to pass to android_reboot
() (e
.g
. "userrequested"
), or null
.
183 * @param confirm true if user confirmation is needed before shutting down
.
184 */
185 public static void shutdown
(final Context context, String reason, boolean confirm
) {
186 mReboot = false;
187 mRebootSafeMode = false;
188 mReason = reason;
189 shutdownInner
(context, confirm
);
190 }
191
192 private static void shutdownInner
(final Context context, boolean confirm
) {
193 // ShutdownThread is called from many places, so best to verify here that the context passed
194 // in is themed
.
195 context
.assertRuntimeOverlayThemable
();
196
197 // ensure that only one thread is trying to power down
.
198 // any additional calls are just returned
199 synchronized
(sIsStartedGuard
) {
200 if
(sIsStarted
) {
201 if
(DEBUG
) {
202 Log
.d
(TAG, "Request to shutdown already running, returning
."
);
203 }
204 return;
205 }
206 }
207
208 // Add checkpoint for this shutdown attempt
. The user might still cancel the dialog, but
209 // this point preserves the system trace
of the trigger point
of the ShutdownThread
.
210 ShutdownCheckPoints
.recordCheckPoint
(/* reason= */ null
);
211
212 //#ifdef ODM_WT_EDIT Gaohan
.Wang@ODM_WT
.AD, 2023/12/6 Add for Monkey call emergency, rebootPhone
.......
213 if
(isAgingTestNotAllowShutdown
(mReason
)) {
214 return;
215 }
216 //#endif ODM_WT_EDIT
217
218 final int longPressBehavior = context
.getResources
().getInteger
(
219 com
.android
.internal
.R
.integer
.config_longPressOnPowerBehavior
);
220 final int resourceId = mRebootSafeMode
221 ? com
.android
.internal
.R
.string
.reboot_safemode_confirm
222 :
(longPressBehavior == 2
223 ? com
.android
.internal
.R
.string
.shutdown_confirm_question
224 : com
.android
.internal
.R
.string
.shutdown_confirm
);
225
226 if
(DEBUG
) {
227 Log
.d
(TAG, "Notifying thread to start shutdown longPressBehavior=" + longPressBehavior
);
228 }
229
230 if
(confirm
) {
231 final CloseDialogReceiver closer = new CloseDialogReceiver
(context
);
232 if
(sConfirmDialog != null
) {
233 sConfirmDialog
.dismiss
();
234 }
235 sConfirmDialog = new
AlertDialog.Builder(context
)
236
.setTitle
(mRebootSafeMode
237 ? com
.android
.internal
.R
.string
.reboot_safemode_title
238 : com
.android
.internal
.R
.string
.power_
off
)
239
.setMessage
(resourceId
)
240
.setPositiveButton
(com
.android
.internal
.R
.string
.yes, new DialogInterface
.OnClickListener
() {
241 public void onClick
(DialogInterface dialog, int which
) {
242 beginShutdownSequence
(context
);
243 }
244 }
)
245
.setNegativeButton
(com
.android
.internal
.R
.string
.no, null
)
246
.create
();
247 closer
.dialog = sConfirmDialog;
248 sConfirmDialog
.setOnDismissListener
(closer
);
249 sConfirmDialog
.getWindow
().setType
(WindowManager
.LayoutParams
.TYPE_KEYGUARD_DIALOG
);
250 sConfirmDialog
.show
();
251 } else {
252 beginShutdownSequence
(context
);
253 }
254 }
255
256 public static boolean isAgingTestNotAllowShutdown
(String reason
) {
257 boolean isAgingTest = "yes"
.equals
(SystemProperties
.get
(PROP_IS_AGINGVERSION
));
258 boolean isMonkeyRunning = SystemProperties
.getBoolean
(PROP_IS_MONKEY_RUNNING, false
);
259 boolean isMonkeyKingRunning = SystemProperties
.getBoolean
(PROP_IS_MONKEYKING_RUNNING, false
);
260 Slog
.d
(TAG, " reason=" + reason
261 + ", isAgingTest=" + isAgingTest
262 + ", isMonkeyRunning=" + isMonkeyRunning
263 + ", isMonkeyKingRunning=" + isMonkeyKingRunning
);
264 if
(isAgingTest &&
(isMonkeyRunning || isMonkeyKingRunning
)
265 && !PowerManager
.SHUTDOWN_LOW_BATTERY
.equals
(reason
)) {
266 Slog
.d
(TAG, "AgingTestNotAllowShutdown"
);
267 return true;
268 }
269 if
(isAgingTest && "silent"
.equals
(reason
)) {
270 Slog
.d
(TAG, "AgingTestNotAllowShutdown silence reboot"
);
271 return true;
272 }
273 return false;
274 }
275
276 private static class CloseDialogReceiver extends BroadcastReceiver
277 implements DialogInterface
.OnDismissListener {
278 private Context mContext;
279 public Dialog dialog;
280
281 CloseDialogReceiver
(Context context
) {
282 mContext = context;
283 IntentFilter filter = new IntentFilter
(Intent
.ACTION_CLOSE_SYSTEM_DIALOGS
);
284 context
.registerReceiver
(this, filter, Context
.RECEIVER_EXPORTED
);
285 }
286
287 @Override
288 public void onReceive
(Context context, Intent intent
) {
289 dialog
.cancel
();
290 }
291
292 public void onDismiss
(DialogInterface unused
) {
293 mContext
.unregisterReceiver
(this
);
294 }
295 }
296
297 /**
298 * Request a clean shutdown, waiting for subsystems to clean up their
299 * state etc
. Must be called from a Looper thread in which its UI
300 * is shown
.
301 *
302 * @param context Context used to display the shutdown progress dialog
. This must be a context
303 * suitable for displaying UI
(aka Themable
).
304 * @param reason code to pass to the kernel
(e
.g
. "recovery"
), or null
.
305 * @param confirm true if user confirmation is needed before shutting down
.
306 */
307 public static void reboot
(final Context context, String reason, boolean confirm
) {
308 mReboot = true;
309 mRebootSafeMode = false;
310 mRebootHasProgressBar = false;
311 mReason = reason;
312 shutdownInner
(context, confirm
);
313 }
314
315 /**
316 * Request a reboot into safe mode
. Must be called from a Looper thread in which its UI
317 * is shown
.
318 *
319 * @param context Context used to display the shutdown progress dialog
. This must be a context
320 * suitable for displaying UI
(aka Themable
).
321 * @param confirm true if user confirmation is needed before shutting down
.
322 */
323 public static void rebootSafeMode
(final Context context, boolean confirm
) {
324 UserManager um =
(UserManager
) context
.getSystemService
(Context
.USER_SERVICE
);
325 if
(um
.hasUserRestriction
(UserManager
.DISALLOW_SAFE_BOOT
)) {
326 return;
327 }
328
329 // #ifdef dongzhenbo@ANDROID
.FRAMEWORK, modified for India DLC
330 if
(!isDeviceProvisioned
(context
) && OplusDLCUtils
.isDLCVersion
()) {
331 return;
332 }
333 // endif
334
335 mReboot = true;
336 mRebootSafeMode = true;
337 mRebootHasProgressBar = false;
338 mReason = null;
339 shutdownInner
(context, confirm
);
340 }
341
342 // #ifdef dongzhenbo@ANDROID
.FRAMEWORK, modified for India DLC
343 private static boolean isDeviceProvisioned
(Context context
) {
344 return android
.provider
.Settings
.Global
.getInt
(context
.getContentResolver
(),
345 android
.provider
.Settings
.Global
.DEVICE_PROVISIONED, 0
) != 0;
346 }
347 // endif
348
349 private static ProgressDialog showShutdownDialog
(Context context
) {
350 // Throw up a system dialog to indicate the device is rebooting / shutting down
.
351 ProgressDialog pd = new ProgressDialog
(context
);
352
353 // Path 1: Reboot to recovery for update
354 // Condition: mReason startswith REBOOT_RECOVERY_UPDATE
355 //
356 // Path 1a: uncrypt needed
357 // Condition: if /cache/recovery/uncrypt_file exists but
358 // /cache/recovery/block
.map doesn't
.
359 // UI: determinate progress bar
(mRebootHasProgressBar == True
)
360 //
361 // * Path 1a is expected to be removed once the GmsCore shipped on
362 // device always calls uncrypt prior to reboot
.
363 //
364 // Path 1b: uncrypt already done
365 // UI: spinning circle only
(no progress bar
)
366 //
367 // Path 2: Reboot to recovery for factory reset
368 // Condition: mReason == REBOOT_RECOVERY
369 // UI: spinning circle only
(no progress bar
)
370 //
371 // Path 3: Regular reboot / shutdown
372 // Condition: Otherwise
373 // UI: spinning circle only
(no progress bar
)
374
375 // mReason could be "recovery-update" or "recovery-update,quiescent"
.
376 if
(mReason != null && mReason
.startsWith
(PowerManager
.REBOOT_RECOVERY_UPDATE
)) {
377 // We need the progress bar if uncrypt will be invoked during the
378 // reboot, which might be time-consuming
.
379 mRebootHasProgressBar = RecoverySystem
.UNCRYPT_PACKAGE_FILE
.exists
()
380 && !
(RecoverySystem
.BLOCK_MAP_FILE
.exists
());
381 pd
.setTitle
(context
.getText
(com
.android
.internal
.R
.string
.reboot_to_update_title
));
382 if
(mRebootHasProgressBar
) {
383 pd
.setMax
(100
);
384 pd
.setProgress
(0
);
385 pd
.setIndeterminate
(false
);
386 boolean showPercent = context
.getResources
().getBoolean
(
387 com
.android
.internal
.R
.bool
.config_showPercentageTextDuringRebootToUpdate
);
388 if
(!showPercent
) {
389 pd
.setProgressPercentFormat
(null
);
390 }
391 pd
.setProgressNumberFormat
(null
);
392 pd
.setProgressStyle
(ProgressDialog
.STYLE_HORIZONTAL
);
393 pd
.setMessage
(context
.getText
(
394 com
.android
.internal
.R
.string
.reboot_to_update_prepare
));
395 } else {
396 if
(showSysuiReboot
()) {
397 return null;
398 }
399 pd
.setIndeterminate
(true
);
400 pd
.setMessage
(context
.getText
(
401 com
.android
.internal
.R
.string
.reboot_to_update_reboot
));
402 }
403 } else if
(mReason != null && mReason
.equals
(PowerManager
.REBOOT_RECOVERY
)) {
404 if
(RescueParty
.isRecoveryTriggeredReboot
()) {
405 // We're not actually doing a factory reset yet; we're rebooting
406 // to ask the user if they'd like to reset, so give them a less
407 // scary dialog message
.
408 pd
.setTitle
(context
.getText
(com
.android
.internal
.R
.string
.power_
off
));
409 pd
.setMessage
(context
.getText
(com
.android
.internal
.R
.string
.shutdown_progress
));
410 pd
.setIndeterminate
(true
);
411 } else if
(showSysuiReboot
()) {
412 return null;
413 } else {
414 // Factory reset path
. Set the dialog message accordingly
.
415 pd
.setTitle
(context
.getText
(com
.android
.internal
.R
.string
.reboot_to_reset_title
));
416 pd
.setMessage
(context
.getText
(
417 com
.android
.internal
.R
.string
.reboot_to_reset_message
));
418 pd
.setIndeterminate
(true
);
419 }
420 } else {
421 if
(showSysuiReboot
()) {
422 return null;
423 }
424 pd
.setTitle
(context
.getText
(com
.android
.internal
.R
.string
.power_
off
));
425 pd
.setMessage
(context
.getText
(com
.android
.internal
.R
.string
.shutdown_progress
));
426 pd
.setIndeterminate
(true
);
427 }
428 pd
.setCancelable
(false
);
429 pd
.getWindow
().setType
(WindowManager
.LayoutParams
.TYPE_KEYGUARD_DIALOG
);
430 if
(isPreVersion
()){
431 pd
.show
();
432 }
433 return pd;
434 }
435
436 private static void showShutdownAnimation
() {
437 Log
.w
(TAG, "showShutdownAnimation"
);
438 SystemProperties
.set
("service
.bootanim
.exit", "0"
);
439 SystemProperties
.set
("ctl
.start", "banim_shut"
);
440 }
441
442 private static boolean isPreVersion
(){
443 return "true"
.equals
(SystemProperties
.get
("ro
.build
.oplus
.pre_version"
));
444 }
445
446 private static void delayForPlayAnimation
() {
447 Log
.i
(TAG,"set service
.shutanim
.running to 1"
);
448 if
(beginAnimationTime <= 0
){
449 return;
450 }
451 endAnimationTime = beginAnimationTime-SystemClock
.elapsedRealtime
();
452 if
(endAnimationTime > 0
){
453 try {
454 Log
.w
(TAG, "sleep delayForPlayAnimation"
);
455 Thread
.currentThread
().sleep
(1500
);
456 } catch
(InterruptedException e
) {
457 Log
.e
(TAG, "Shutdown stop bootanimation Thread
.currentThread
().sleep exception!"
);
458 }
459 }
460 }
461
462 private static boolean showSysuiReboot
() {
463 if
(DEBUG
) {
464 Log
.d
(TAG, "Attempting to use SysUI shutdown UI"
);
465 }
466 try {
467 StatusBarManagerInternal service = LocalServices
.getService
(
468 StatusBarManagerInternal
.class
);
469 if
(service
.showShutdownUi
(mReboot, mReason
)) {
470 // Sysui will handle shutdown UI
.
471 if
(DEBUG
) {
472 Log
.d
(TAG, "SysUI handling shutdown UI"
);
473 }
474 return true;
475 }
476 } catch
(Exception e
) {
477 // If anything went wrong, ignore it and use fallback ui
478 }
479 if
(DEBUG
) {
480 Log
.d
(TAG, "SysUI is unavailable"
);
481 }
482 return false;
483 }
484
485 private static void beginShutdownSequence
(Context context
) {
486 synchronized
(sIsStartedGuard
) {
487 if
(sIsStarted
) {
488 if
(DEBUG
) {
489 Log
.d
(TAG, "Shutdown sequence already running, returning
."
);
490 }
491 return;
492 }
493 sIsStarted = true;
494 }
495 if
(isPreVersion
()){
496 sInstance
.mProgressDialog = showShutdownDialog
(context
);
497 } else {
498 beginAnimationTime = SystemClock
.elapsedRealtime
()+MIN_SHUTDOWN_ANIMATION_PLAY_TIME;
499 showShutdownAnimation
();
500 }
501
502 sInstance
.mContext = context;
503 sInstance
.mPowerManager =
(PowerManager
)context
.getSystemService
(Context
.POWER_SERVICE
);
504
505 // make sure we never fall asleep again
506 sInstance
.mCpuWakeLock = null;
507 try {
508 sInstance
.mCpuWakeLock = sInstance
.mPowerManager
.newWakeLock
(
509 PowerManager
.PARTIAL_WAKE_LOCK, TAG + "-cpu"
);
510 sInstance
.mCpuWakeLock
.setReferenceCounted
(false
);
511 sInstance
.mCpuWakeLock
.acquire
();
512 } catch
(SecurityException e
) {
513 Log
.w
(TAG, "No permission to acquire wake lock", e
);
514 sInstance
.mCpuWakeLock = null;
515 }
516
517 // also make sure the screen stays on for better user experience
518 sInstance
.mScreenWakeLock = null;
519 if
(sInstance
.mPowerManager
.isScreenOn
()) {
520 try {
521 sInstance
.mScreenWakeLock = sInstance
.mPowerManager
.newWakeLock
(
522 PowerManager
.FULL_WAKE_LOCK, TAG + "-screen"
);
523 sInstance
.mScreenWakeLock
.setReferenceCounted
(false
);
524 sInstance
.mScreenWakeLock
.acquire
();
525 } catch
(SecurityException e
) {
526 Log
.w
(TAG, "No permission to acquire wake lock", e
);
527 sInstance
.mScreenWakeLock = null;
528 }
529 }
530
531 if
(SecurityLog
.isLoggingEnabled
()) {
532 SecurityLog
.writeEvent
(SecurityLog
.TAG_OS_SHUTDOWN
);
533 }
534 delayForPlayAnimation
();
535
536 // start the thread that initiates shutdown
537 sInstance
.mHandler = new Handler
() {
538 };
539 sInstance
.start
();
540 }
541
542 void actionDone
() {
543 synchronized
(mActionDoneSync
) {
544 mActionDone = true;
545 mActionDoneSync
.notifyAll
();
546 }
547 }
548
549 //#ifdef OPLUS_FEATURE_SHUTDOWN_DETECT
550 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
551 /**
552 * @return void doShutdownDetect
553 */
554 private static void doShutdownDetect
(String count
) {
555 File procFile = null;
556 FileWriter shutdown_detect = null;
557 try {
558 Log
.e
(TAG, "doShutdownDetect " + count
);
559 procFile = new File
("/proc/shutdown_detect"
);
560 shutdown_detect = new FileWriter
(procFile
);
561 shutdown_detect
.write
(count
);
562 } catch
(java
.io
.IOException e
) {
563 Log
.w
(TAG, "Failed to write to /proc/shutdown_detect", e
);
564 } finally {
565 IoUtils
.closeQuietly
(shutdown_detect
);
566 }
567 }
568 //#endif /* OPLUS_FEATURE_SHUTDOWN_DETECT */
569
570 /**
571 * Makes sure we handle the shutdown gracefully
.
572 * Shuts
off power regardless
of radio state if the allotted time has passed
.
573 */
574 public void run
() {
575 TimingsTraceLog shutdownTimingLog = newTimingsLog
();
576 shutdownTimingLog
.traceBegin
("SystemServerShutdown"
);
577 metricShutdownStart
();
578 metricStarted
(METRIC_SYSTEM_SERVER
);
579
580 //#ifdef OPLUS_EXTENSION_HOOK
581 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
582 doShutdownDetect
("40"
);
583 //#endif /* OPLUS_EXTENSION_HOOK */
584
585 // Notify SurfaceFlinger that the device is shutting down
.
586 // Transaction traces should be captured at this stage
.
587 SurfaceControl
.notifyShutdown
();
588
589 // Start dumping check points for this shutdown in a separate thread
.
590 Thread dumpCheckPointsThread = ShutdownCheckPoints
.newDumpThread
(
591 new File
(CHECK_POINTS_FILE_BASENAME
));
592 dumpCheckPointsThread
.start
();
593
594 /*
595 * Write a system property in case the system_server reboots before we
596 * get to the actual hardware restart
. If that happens, we'll retry at
597 * the beginning
of the SystemServer startup
.
598 */
599 {
600 String reason =
(mReboot ? "1" : "0"
) +
(mReason != null ? mReason : ""
);
601 SystemProperties
.set
(SHUTDOWN_ACTION_PROPERTY, reason
);
602 }
603
604 /*
605 * If we are rebooting into safe mode, write a system property
606 * indicating so
.
607 */
608 if
(mRebootSafeMode
) {
609 SystemProperties
.set
(REBOOT_SAFEMODE_PROPERTY, "1"
);
610 }
611
612 shutdownTimingLog
.traceBegin
("DumpPreRebootInfo"
);
613 try {
614 Slog
.i
(TAG, "Logging pre-reboot information
..."
);
615 PreRebootLogger
.log
(mContext
);
616 } catch
(Exception e
) {
617 Slog
.e
(TAG, "Failed to log pre-reboot information", e
);
618 }
619 shutdownTimingLog
.traceEnd
(); // DumpPreRebootInfo
620
621 metricStarted
(METRIC_SEND_BROADCAST
);
622 shutdownTimingLog
.traceBegin
("SendShutdownBroadcast"
);
623 Log
.i
(TAG, "Sending shutdown broadcast
..."
);
624
625 // First send the high-level shut down broadcast
.
626 mActionDone = false;
627 Intent intent = new Intent
(Intent
.ACTION_SHUTDOWN
);
628 intent
.addFlags
(Intent
.FLAG_RECEIVER_FOREGROUND | Intent
.FLAG_RECEIVER_REGISTERED_ONLY
);
629 final Bundle opts = BroadcastOptions
.makeBasic
()
630
.setDeferralPolicy
(BroadcastOptions
.DEFERRAL_POLICY_UNTIL_ACTIVE
)
631
.toBundle
();
632 final
ActivityManagerInternal
activityManagerInternal = LocalServices
.getService
(
633
ActivityManagerInternal
.class
);
634
activityManagerInternal
.broadcastIntentWithCallback
(intent,
635 new IIntentReceiver
.Stub
() {
636 @Override
637 public void performReceive
(Intent intent, int resultCode, String data,
638 Bundle extras, boolean ordered, boolean sticky, int sendingUser
) {
639 mHandler
.post
(ShutdownThread
.this::actionDone
);
640 }
641 }, null, UserHandle
.USER_ALL, null, null, opts
);
642 final long endTime = SystemClock
.elapsedRealtime
() + MAX_BROADCAST_TIME;
643 synchronized
(mActionDoneSync
) {
644 while
(!mActionDone
) {
645 long delay = endTime - SystemClock
.elapsedRealtime
();
646 if
(delay <= 0
) {
647 Log
.w
(TAG, "Shutdown broadcast timed out"
);
648 //#ifdef OPLUS_EXTENSION_HOOK
649 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
650 doShutdownDetect
("47"
);
651 //#endif /* OPLUS_EXTENSION_HOOK */
652 break;
653 } else if
(mRebootHasProgressBar
) {
654 int status =
(int
)((MAX_BROADCAST_TIME - delay
) * 1
.0 *
655 BROADCAST_STOP_PERCENT / MAX_BROADCAST_TIME
);
656 sInstance
.setRebootProgress
(status, null
);
657 }
658 try {
659 mActionDoneSync
.wait
(Math
.min
(delay, ACTION_DONE_POLL_WAIT_MS
));
660 } catch
(InterruptedException e
) {
661 }
662 }
663 }
664 if
(mRebootHasProgressBar
) {
665 sInstance
.setRebootProgress
(BROADCAST_STOP_PERCENT, null
);
666 }
667 shutdownTimingLog
.traceEnd
(); // SendShutdownBroadcast
668 metricEnded
(METRIC_SEND_BROADCAST
);
669
670 Log
.i
(TAG, "Shutting down
activity manager
..."
);
671 shutdownTimingLog
.traceBegin
("Shutdown
ActivityManager"
);
672 metricStarted
(METRIC_AM
);
673 //#ifdef OPLUS_EXTENSION_HOOK
674 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
675 long startTime = SystemClock
.elapsedRealtime
();
676 //#endif /* OPLUS_EXTENSION_HOOK */
677
678 final I
ActivityManager am =
679 I
ActivityManager
.Stub
.asInterface
(ServiceManager
.checkService
("
activity"
));
680 if
(am != null
) {
681 try {
682 am
.shutdown
(MAX_BROADCAST_TIME
);
683 } catch
(RemoteException e
) {
684 }
685 }
686 if
(mRebootHasProgressBar
) {
687 sInstance
.setRebootProgress
(ACTIVITY_MANAGER_STOP_PERCENT, null
);
688 }
689 //#ifdef OPLUS_EXTENSION_HOOK
690 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
691 if
((SystemClock
.elapsedRealtime
() - startTime
) > MAX_BROADCAST_TIME
) {
692 doShutdownDetect
("46"
);
693 }
694 //#endif /* OPLUS_EXTENSION_HOOK */
695
696 shutdownTimingLog
.traceEnd
();// Shutdown
ActivityManager
697 metricEnded
(METRIC_AM
);
698
699 Log
.i
(TAG, "Shutting down package manager
..."
);
700 shutdownTimingLog
.traceBegin
("ShutdownPackageManager"
);
701 metricStarted
(METRIC_PM
);
702 //#ifdef OPLUS_EXTENSION_HOOK
703 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
704 startTime = SystemClock
.elapsedRealtime
();
705 //#endif /* OPLUS_EXTENSION_HOOK */
706
707 final PackageManagerInternal pm = LocalServices
.getService
(PackageManagerInternal
.class
);
708 if
(pm != null
) {
709 pm
.shutdown
();
710 }
711 if
(mRebootHasProgressBar
) {
712 sInstance
.setRebootProgress
(PACKAGE_MANAGER_STOP_PERCENT, null
);
713 }
714 //#ifdef OPLUS_EXTENSION_HOOK
715 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
716 if
((SystemClock
.elapsedRealtime
() - startTime
) > MAX_BROADCAST_TIME
) {
717 doShutdownDetect
("45"
);
718 }
719 //#endif /* OPLUS_EXTENSION_HOOK */
720
721 shutdownTimingLog
.traceEnd
(); // ShutdownPackageManager
722 metricEnded
(METRIC_PM
);
723
724 // Shutdown radios
.
725 shutdownTimingLog
.traceBegin
("ShutdownRadios"
);
726 metricStarted
(METRIC_RADIOS
);
727 shutdownRadios
(MAX_RADIO_WAIT_TIME
);
728 if
(mRebootHasProgressBar
) {
729 sInstance
.setRebootProgress
(RADIO_STOP_PERCENT, null
);
730 }
731 shutdownTimingLog
.traceEnd
(); // ShutdownRadios
732 metricEnded
(METRIC_RADIOS
);
733
734 if
(mRebootHasProgressBar
) {
735 sInstance
.setRebootProgress
(MOUNT_SERVICE_STOP_PERCENT, null
);
736
737 // If it's to reboot to install an update and uncrypt hasn't been
738 // done yet, trigger it now
.
739 uncrypt
();
740 }
741
742 // Wait for the check points dump thread to finish, or kill it if not finished in time
.
743 shutdownTimingLog
.traceBegin
("ShutdownCheckPointsDumpWait"
);
744 try {
745 dumpCheckPointsThread
.join
(MAX_CHECK_POINTS_DUMP_WAIT_TIME
);
746 } catch
(InterruptedException ex
) {
747 }
748 Log
.i
(TAG, "run
() shutdownAnimationService"
);
749
750 shutdownTimingLog
.traceEnd
(); // ShutdownCheckPointsDumpWait
751
752 shutdownTimingLog
.traceEnd
(); // SystemServerShutdown
753 metricEnded
(METRIC_SYSTEM_SERVER
);
754 saveMetrics
(mReboot, mReason
);
755 //#ifdef OPLUS_EXTENSION_HOOK
756 //ODM_WT
.AD
.Framework ZhangFei@BSP
.KERNEL
.STABILITY, 2020/04/17, Add for shutdown detect
.
757 //Shutdown from Systemserver, set timeout 120s, 4*30
.
758 doShutdownDetect
("4"
);
759 //#endif /* OPLUS_EXTENSION_HOOK */
760 // Remaining work will be done by init, including vold shutdown
761 rebootOrShutdown
(mContext, mReboot, mReason
);
762 }
763
764 private static TimingsTraceLog newTimingsLog
() {
765 return new TimingsTraceLog
("ShutdownTiming", Trace
.TRACE_TAG_SYSTEM_SERVER
);
766 }
767
768 private static void metricStarted
(String metricKey
) {
769 synchronized
(TRON_METRICS
) {
770 TRON_METRICS
.put
(metricKey, -1 * SystemClock
.elapsedRealtime
());
771 }
772 }
773
774 private static void metricEnded
(String metricKey
) {
775 synchronized
(TRON_METRICS
) {
776 TRON_METRICS
777
.put
(metricKey, SystemClock
.elapsedRealtime
() + TRON_METRICS
.get
(metricKey
));
778 }
779 }
780
781 private static void metricShutdownStart
() {
782 synchronized
(TRON_METRICS
) {
783 TRON_METRICS
.put
(METRIC_SHUTDOWN_TIME_START, System
.currentTimeMillis
());
784 }
785 }
786
787 private void setRebootProgress
(final int progress, final CharSequence message
) {
788 mHandler
.post
(new Runnable
() {
789 @Override
790 public void run
() {
791 if
(mProgressDialog != null
) {
792 mProgressDialog
.setProgress
(progress
);
793 if
(message != null
) {
794 mProgressDialog
.setMessage
(message
);
795 }
796 }
797 }
798 }
);
799 }
800
801 private void shutdownRadios
(final int timeout
) {
802 // If a radio is wedged, disabling it may hang so we do this work in another thread,
803 // just in case
.
804 final long endTime = SystemClock
.elapsedRealtime
() + timeout;
805 final boolean[] done = new boolean[1];
806 Thread t = new Thread
() {
807 public void run
() {
808 TimingsTraceLog shutdownTimingsTraceLog = newTimingsLog
();
809 boolean radio
Off;
810
811 TelephonyManager telephonyManager = mContext
.getSystemService
(
812 TelephonyManager
.class
);
813
814 radio
Off = telephonyManager == null
815 || !telephonyManager
.isAnyRadioPoweredOn
();
816 if
(!radio
Off
) {
817 Log
.w
(TAG, "Turning
off cellular radios
..."
);
818 metricStarted
(METRIC_RADIO
);
819 telephonyManager
.shutdownAllRadios
();
820 }
821
822 Log
.i
(TAG, "Waiting for Radio
..."
);
823
824 long delay = endTime - SystemClock
.elapsedRealtime
();
825 while
(delay > 0
) {
826 if
(mRebootHasProgressBar
) {
827 int status =
(int
)((timeout - delay
) * 1
.0 *
828
(RADIO_STOP_PERCENT - PACKAGE_MANAGER_STOP_PERCENT
) / timeout
);
829 status += PACKAGE_MANAGER_STOP_PERCENT;
830 sInstance
.setRebootProgress
(status, null
);
831 }
832
833 if
(!radio
Off
) {
834 radio
Off = !telephonyManager
.isAnyRadioPoweredOn
();
835 if
(radio
Off
) {
836 Log
.i
(TAG, "Radio turned
off
."
);
837 metricEnded
(METRIC_RADIO
);
838 shutdownTimingsTraceLog
839
.logDuration
("ShutdownRadio", TRON_METRICS
.get
(METRIC_RADIO
));
840 }
841 }
842
843 if
(radio
Off
) {
844 Log
.i
(TAG, "Radio shutdown complete
."
);
845 done[0] = true;
846 break;
847 }
848 SystemClock
.sleep
(RADIOS_STATE_POLL_SLEEP_MS
);
849 delay = endTime - SystemClock
.elapsedRealtime
();
850 }
851 }
852 };
853
854 t
.start
();
855 try {
856 t
.join
(timeout
);
857 } catch
(InterruptedException ex
) {
858 }
859 if
(!done[0]
) {
860 Log
.w
(TAG, "Timed out waiting for Radio shutdown
."
);
861 }
862 }
863
864 /**
865 * Do not call this directly
. Use {@link #reboot
(Context, String, boolean
)}
866 * or {@link #shutdown
(Context, String, boolean
)} instead
.
867 *
868 * @param context Context used to vibrate or null without vibration
869 * @param reboot true to reboot or false to shutdown
870 * @param reason reason for reboot/shutdown
871 */
872 public static void rebootOrShutdown
(final Context context, boolean reboot, String reason
) {
873 String subsysProp;
874 subsysProp = SystemProperties
.get
("vendor
.peripheral
.shutdown_critical_list",
875 "ERROR"
);
876 //If we don't have the shutdown critical subsystem list we can't
877 //really do anything
. Proceed with full system shutdown
.
878 if
(!subsysProp
.equals
("ERROR"
)) {
879 Log
.i
(TAG, "Shutdown critical subsyslist is :"+subsysProp+": "
);
880 Log
.i
(TAG, "Waiting for a maximum
of " +
881
(VENDOR_SUBSYS_MAX_WAIT_MS
) + "ms"
);
882 String[] subsysList = subsysProp
.split
(" "
);
883 int wait_count = 0;
884 boolean okToShutdown = true;
885 String subsysState;
886 int subsysListLength = subsysList
.length;
887 do {
888 okToShutdown = true;
889 for
(int i = 0; i < subsysListLength; i++
) {
890 subsysState =
891 SystemProperties
.get
(
892 "vendor
.peripheral
." +
893 subsysList[i] +
894 "
.state",
895 "ERROR"
);
896 if
(subsysState
.equals
("ONLINE"
)) {
897 //We only want to delay shutdown while
898 //one
of the shutdown critical
899 //subsystems still shows as 'ONLINE'
.
900 okToShutdown = false;
901 }
902 }
903 if
(okToShutdown == false
) {
904 SystemClock
.sleep
(VENDOR_SUBSYS_STATE_CHECK_INTERVAL_MS
);
905 wait_count++;
906 }
907 } while
(okToShutdown != true &&
908 wait_count <
(VENDOR_SUBSYS_MAX_WAIT_MS/VENDOR_SUBSYS_STATE_CHECK_INTERVAL_MS
));
909 if
(okToShutdown != true
) {
910 for
(int i = 0; i < subsysList
.length; i++
) {
911 subsysState =
912 SystemProperties
.get
(
913 "vendor
.peripheral
." +
914 subsysList[i] +
915 "
.state",
916 "ERROR"
);
917 if
(subsysState
.equals
("ONLINE"
)) {
918 Log
.w
(TAG, "Subsystem " + subsysList[i]+
919 "did not shut down within timeout"
);
920 }
921 }
922 //#ifdef OPLUS_EXTENSION_HOOK
923 //koulongfei@ODM_WT
.AD
.Framework, 2023/08/22, Add for shutdown detect
.
924 doShutdownDetect
("43"
);
925 //#endif /* OPLUS_EXTENSION_HOOK */
926 } else {
927 Log
.i
(TAG, "Vendor subsystem
(s
) shutdown successful"
);
928 }
929 }
930 if
(sInstance
.mPowerManager != null
){
931 Log
.i
(TAG, "mPowerManager
.goToSleep"
);
932 sInstance
.mPowerManager
.goToSleep
(SystemClock
.uptimeMillis
());
933 }
934 if
(reboot
) {
935 Log
.i
(TAG, "Rebooting, reason: " + reason
);
936 PowerManagerService
.lowLevelReboot
(reason
);
937 Log
.e
(TAG, "Reboot failed, will attempt shutdown instead"
);
938 reason = null;
939 } else if
(context != null
) {
940 // vibrate before shutting down
941 try {
942 sInstance
.playShutdownVibration
(context
);
943 } catch
(Exception e
) {
944 // Failure to vibrate shouldn't interrupt shutdown
. Just log it
.
945 Log
.w
(TAG, "Failed to vibrate during shutdown
.", e
);
946 }
947
948 }
949 // Shutdown power
950 Log
.i
(TAG, "Performing low-level shutdown
..."
);
951 PowerManagerService
.lowLevelShutdown
(reason
);
952 }
953
954 /**
955 * Plays a vibration for shutdown
. Along with playing a shutdown vibration, this method also
956 * sleeps the current Thread for some time, to allow the vibration to finish before the device
957 * shuts down
.
958 */
959 @VisibleForTesting // For testing vibrations without shutting down device
960 void playShutdownVibration
(Context context
) {
961 Vibrator vibrator = mInjector
.getVibrator
(context
);
962 if
(!vibrator
.hasVibrator
()) {
963 return;
964 }
965
966 VibrationEffect vibrationEffect = getValidShutdownVibration
(context, vibrator
);
967 vibrator
.vibrate
(
968 vibrationEffect,
969 VibrationAttributes
.createFor
Usage(VibrationAttributes
.USAGE_TOUCH
));
970
971 // vibrator is asynchronous so we have to wait to avoid shutting down too soon
.
972 long vibrationDuration = vibrationEffect
.getDuration
();
973 // A negative vibration duration may indicate a vibration effect whose duration is not
974 // known by the system
(e
.g
. pre-baked effects
). In that case, use the default shutdown
975 // vibration duration
.
976 mInjector
.sleep
(vibrationDuration < 0 ? DEFAULT_SHUTDOWN_VIBRATE_MS : vibrationDuration
);
977 }
978
979 private static void saveMetrics
(boolean reboot, String reason
) {
980 String
Builder metricValue = new String
Builder();
981 metricValue
.append
("reboot:"
);
982 metricValue
.append
(reboot ? "y" : "n"
);
983 metricValue
.append
(","
).append
("reason:"
).append
(reason
);
984 final int metricsSize = TRON_METRICS
.size
();
985 for
(int i = 0; i < metricsSize; i++
) {
986 final String name = TRON_METRICS
.keyAt
(i
);
987 final long value = TRON_METRICS
.valueAt
(i
);
988 if
(value < 0
) {
989 Log
.e
(TAG, "metricEnded wasn't called for " + name
);
990 continue;
991 }
992 metricValue
.append
(','
).append
(name
).append
(':'
).append
(value
);
993 }
994 File tmp = new File
(METRICS_FILE_BASENAME + "
.tmp"
);
995 boolean saved = false;
996 try
(FileOutputStream fos = new FileOutputStream
(tmp
)) {
997 fos
.write
(metricValue
.toString
().getBytes
(StandardCharsets
.UTF_8
));
998 saved = true;
999 } catch
(IOException e
) {
1000 Log
.e
(TAG,"Cannot save shutdown metrics", e
);
1001 }
1002 if
(saved
) {
1003 tmp
.renameTo
(new File
(METRICS_FILE_BASENAME + "
.txt"
));
1004 }
1005 }
1006
1007 private void uncrypt
() {
1008 Log
.i
(TAG, "Calling uncrypt and monitoring the progress
..."
);
1009
1010 final RecoverySystem
.ProgressListener progressListener =
1011 new RecoverySystem
.ProgressListener
() {
1012 @Override
1013 public void onProgress
(int status
) {
1014 if
(status >= 0 && status < 100
) {
1015 // Scale down to [MOUNT_SERVICE_STOP_PERCENT, 100
).
1016 status =
(int
)(status *
(100
.0 - MOUNT_SERVICE_STOP_PERCENT
) / 100
);
1017 status += MOUNT_SERVICE_STOP_PERCENT;
1018 CharSequence msg = mContext
.getText
(
1019 com
.android
.internal
.R
.string
.reboot_to_update_package
);
1020 sInstance
.setRebootProgress
(status, msg
);
1021 } else if
(status == 100
) {
1022 CharSequence msg = mContext
.getText
(
1023 com
.android
.internal
.R
.string
.reboot_to_update_reboot
);
1024 sInstance
.setRebootProgress
(status, msg
);
1025 } else {
1026 // Ignored
1027 }
1028 }
1029 };
1030
1031 final boolean[] done = new boolean[1];
1032 done[0] = false;
1033 Thread t = new Thread
() {
1034 @Override
1035 public void run
() {
1036 RecoverySystem rs =
(RecoverySystem
) mContext
.getSystemService
(
1037 Context
.RECOVERY_SERVICE
);
1038 String filename = null;
1039 try {
1040 filename = FileUtils
.readTextFile
(RecoverySystem
.UNCRYPT_PACKAGE_FILE, 0, null
);
1041 rs
.processPackage
(mContext, new File
(filename
), progressListener
);
1042 } catch
(IOException e
) {
1043 Log
.e
(TAG, "Error uncrypting file", e
);
1044 }
1045 done[0] = true;
1046 }
1047 };
1048 t
.start
();
1049
1050 try {
1051 t
.join
(MAX_UNCRYPT_WAIT_TIME
);
1052 } catch
(InterruptedException unused
) {
1053 }
1054 if
(!done[0]
) {
1055 Log
.w
(TAG, "Timed out waiting for uncrypt
."
);
1056 final int uncryptTimeoutError = 100;
1057 String timeoutMessage = String
.format
("uncrypt_time: %d\n" + "uncrypt_error: %d\n",
1058 MAX_UNCRYPT_WAIT_TIME / 1000, uncryptTimeoutError
);
1059 try {
1060 FileUtils
.stringT
oFile
(RecoverySystem
.UNCRYPT_STATUS_FILE, timeoutMessage
);
1061 } catch
(IOException e
) {
1062 Log
.e
(TAG, "Failed to write timeout message to uncrypt status", e
);
1063 }
1064 }
1065 }
1066
1067 /**
1068 * Provides a {@link VibrationEffect} to be used for shutdown
.
1069 *
1070 * <p>The vibration to be played is derived from the shutdown vibration file
(which the device
1071 * should specify at `com
.android
.internal
.R
.string
.config_defaultShutdownVibrationFile`
). A
1072 * fallback vibration maybe used in one
of these conditions:
1073 * <ul>
1074 * <li>A vibration file has not been specified, or if the specified file does not exist
1075 * <li>If the content
of the file does not represent a valid serialization
of a
1076 * {@link VibrationEffect}
1077 * <li>If the {@link VibrationEffect} specified in the file is not suitable for
1078 * a shutdown vibration
(such as indefinite vibrations
)
1079 * </ul>
1080 */
1081 private VibrationEffect getValidShutdownVibration
(Context context, Vibrator vibrator
) {
1082 VibrationEffect parsedEffect = parseVibrationEffectFromFile
(
1083 mInjector
.getDefaultShutdownVibrationEffectFilePath
(context
),
1084 vibrator
);
1085
1086 if
(parsedEffect == null
) {
1087 return createDefaultVibrationEffect
();
1088 }
1089
1090 long parsedEffectDuration = parsedEffect
.getDuration
();
1091 if
(parsedEffectDuration == Long
.MAX_VALUE
) {
1092 // This means that the effect does not have a defined end
.
1093 // Since we don't want to vibrate forever while trying to shutdown, we ignore this
1094 // parsed effect and use the default one instead
.
1095 Log
.w
(TAG, "The parsed shutdown vibration is indefinite
."
);
1096 return createDefaultVibrationEffect
();
1097 }
1098
1099 return parsedEffect;
1100 }
1101
1102 private static VibrationEffect parseVibrationEffectFromFile
(
1103 String filePath, Vibrator vibrator
) {
1104 if
(!TextUtils
.isEmpty
(filePath
)) {
1105 try {
1106 return VibrationXmlParser
.parseDocument
(new FileReader
(filePath
)).resolve
(vibrator
);
1107 } catch
(Exception e
) {
1108 Log
.e
(TAG, "Error parsing default shutdown vibration effect
.", e
);
1109 }
1110 }
1111 return null;
1112 }
1113
1114 private static VibrationEffect createDefaultVibrationEffect
() {
1115 return VibrationEffect
.createOneShot
(
1116 DEFAULT_SHUTDOWN_VIBRATE_MS, VibrationEffect
.DEFAULT_AMPLITUDE
);
1117 }
1118
1119 /** Utility class to inject instances, for easy testing
. */
1120 @VisibleForTesting
1121 static class Injector {
1122 public Vibrator getVibrator
(Context context
) {
1123 return new SystemVibrator
(context
);
1124 }
1125
1126 public void sleep
(long durationMs
) {
1127 try {
1128 Thread
.sleep
(durationMs
);
1129 } catch
(InterruptedException unused
) {
1130 // this is not critical and does not require logging
.
1131 }
1132 }
1133
1134 public String getDefaultShutdownVibrationEffectFilePath
(Context context
) {
1135 return context
.getResources
().getString
(
1136 com
.android
.internal
.R
.string
.config_defaultShutdownVibrationFile
);
1137 }
1138 }
1139 }
对话框组件使用教程
本文介绍了如何使用Android中的对话框组件AlertDialog。通过为按钮添加监听器并在其onClick方法中触发对话框，可以实现显示标题、消息及按钮的功能。具体包括设置对话框的标题、消息内容及确认按钮。
扫一扫
2779
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
