blob: b1b5a7a49b0100f5c03d8c7474e60b0d8afc7530 [file] [log] [blame]
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2006 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
17package com.android.server;
18
Jeff Brown6f357d32014-01-15 20:40:55 -080019import android.app.ActivityThread;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -080020import android.app.INotificationManager;
Adam Lesinski0debc9a2014-07-16 19:09:13 -070021import android.app.usage.UsageStatsManagerInternal;
Joe Onoratof3c3c4f2010-10-21 11:09:02 -040022import android.content.ComponentName;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080023import android.content.ContentResolver;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080024import android.content.Context;
Joe Onoratof3c3c4f2010-10-21 11:09:02 -040025import android.content.Intent;
Jeff Sharkeyb0613dc2018-02-27 14:38:04 -070026import android.content.pm.PackageItemInfo;
Matthew Xie1dd01eb32013-04-26 12:37:54 -070027import android.content.pm.PackageManager;
Joe Onoratodc565f42010-10-04 15:27:22 -040028import android.content.res.Configuration;
Alan Viverettee54d2452015-05-06 10:41:43 -070029import android.content.res.Resources.Theme;
Fyodor Kupolov7fcd6592017-12-15 11:56:36 -080030import android.database.sqlite.SQLiteCompatibilityWalFlags;
Makoto Onuki50e00c82018-08-07 15:57:13 -070031import android.database.sqlite.SQLiteGlobal;
Adrian Roos9ee5dff2018-08-22 20:19:49 +020032import android.hardware.display.DisplayManagerInternal;
Jeff Sharkeyd136e512016-03-09 22:30:56 -070033import android.os.BaseBundle;
Jeff Sharkey0a17db12016-11-04 11:23:46 -060034import android.os.Binder;
Jeff Sharkey55687722014-04-09 18:07:19 -070035import android.os.Build;
Jeff Sharkey48749fc2013-04-19 13:25:04 -070036import android.os.Environment;
Jeff Brown6f357d32014-01-15 20:40:55 -080037import android.os.FactoryTest;
Tao Bao4fd6c262016-01-19 14:22:24 -080038import android.os.FileUtils;
Joe Onorato1754d742016-11-21 17:51:35 -080039import android.os.IIncidentManager;
Jeff Hamilton35eef702010-06-09 15:45:18 -050040import android.os.Looper;
Alison Cichowlasf0afd8c2017-07-31 11:24:34 -040041import android.os.Message;
Fyodor Kupolova81b8c02017-11-13 15:51:03 -080042import android.os.Parcel;
Tao Bao4fd6c262016-01-19 14:22:24 -080043import android.os.PowerManager;
Narayan Kamath97780462017-02-06 20:24:08 +000044import android.os.Process;
Jeff Hamilton35eef702010-06-09 15:45:18 -050045import android.os.ServiceManager;
Brad Fitzpatrickc74a1b442010-09-10 16:03:29 -070046import android.os.StrictMode;
Jeff Hamilton35eef702010-06-09 15:45:18 -050047import android.os.SystemClock;
48import android.os.SystemProperties;
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +090049import android.os.Trace;
Amith Yamasanicd757062012-10-19 18:23:52 -070050import android.os.UserHandle;
Sudheer Shanka2250d562016-11-07 15:41:02 -080051import android.os.storage.IStorageManager;
Joe Onoratodc565f42010-10-04 15:27:22 -040052import android.util.DisplayMetrics;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080053import android.util.EventLog;
Joe Onorato8a9b2202010-02-26 18:56:32 -080054import android.util.Slog;
Tony Makb0d22622018-01-18 12:49:49 +000055import android.util.TimingsTraceLog;
Brad Fitzpatrick5fdc0c72010-10-12 13:12:18 -070056import android.view.WindowManager;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080057
Dan Morrille4d9a012013-03-28 18:10:43 -070058import com.android.internal.R;
Christine Franks5397f032017-11-01 18:35:16 -070059import com.android.internal.app.ColorDisplayController;
Fyodor Kupolov8d3e82b2016-11-10 17:58:50 -080060import com.android.internal.logging.MetricsLogger;
Geoffrey Pitschaf759c52017-02-15 09:35:38 -050061import com.android.internal.notification.SystemNotificationChannels;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -070062import com.android.internal.os.BinderInternal;
Keun-young Parkd80e8942017-01-27 11:30:19 -080063import com.android.internal.util.ConcurrentUtils;
Tony Makb0d22622018-01-18 12:49:49 +000064import com.android.internal.util.EmergencyAffordanceManager;
Jeff Sharkeyd136e512016-03-09 22:30:56 -070065import com.android.internal.widget.ILockSettings;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -070066import com.android.server.am.ActivityManagerService;
Wale Ogunwale65ebd952018-04-25 15:41:44 -070067import com.android.server.am.ActivityTaskManagerService;
Makoto Onukidf7e4812018-09-24 14:31:25 -070068import com.android.server.appbinding.AppBindingService;
John Spurlock61560172015-02-06 19:46:04 -050069import com.android.server.audio.AudioService;
Kevin Chyn352adfe2018-09-20 22:28:50 -070070import com.android.server.biometrics.BiometricService;
Tony Makb0d22622018-01-18 12:49:49 +000071import com.android.server.broadcastradio.BroadcastRadioService;
Wei Wanged7f5482017-02-21 11:35:10 -080072import com.android.server.camera.CameraServiceProxy;
Amith Yamasani30f8eb42013-11-06 14:54:50 -080073import com.android.server.clipboard.ClipboardService;
Hugo Benichieab511b2016-09-09 09:23:47 +090074import com.android.server.connectivity.IpConnectivityMetrics;
Allen Hair1f556e32016-11-11 15:42:50 -080075import com.android.server.coverage.CoverageService;
Adam Lesinski2c8d67c2014-04-23 13:46:21 -070076import com.android.server.devicepolicy.DevicePolicyManagerService;
Christine Franks5397f032017-11-01 18:35:16 -070077import com.android.server.display.ColorDisplayService;
Tony Makb0d22622018-01-18 12:49:49 +000078import com.android.server.display.DisplayManagerService;
Jeff Browncef440f2012-09-25 18:58:48 -070079import com.android.server.dreams.DreamManagerService;
Selim Cinek705442f2016-09-13 16:02:33 -070080import com.android.server.emergency.EmergencyAffordanceService;
Kevin Chyn2ffadb32018-06-19 11:29:38 -070081import com.android.server.biometrics.face.FaceService;
Kevin Chyn95d628e2018-06-11 11:58:15 -070082import com.android.server.biometrics.fingerprint.FingerprintService;
Jungshik Jang0792d372014-04-23 17:57:26 +090083import com.android.server.hdmi.HdmiControlService;
Jeff Brown6ec6f792012-04-17 16:52:41 -070084import com.android.server.input.InputManagerService;
Yohei Yukawa603f4d02018-09-11 15:04:58 -070085import com.android.server.inputmethod.InputMethodManagerService;
Christopher Tate7060b042014-06-09 19:50:00 -070086import com.android.server.job.JobSchedulerService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -080087import com.android.server.lights.LightsService;
Jeff Sharkeyd136e512016-03-09 22:30:56 -070088import com.android.server.media.MediaResourceMonitorService;
Jeff Brown69b07162013-11-07 00:30:16 -080089import com.android.server.media.MediaRouterService;
Dongwon Kang569da9f2017-11-06 09:53:52 -080090import com.android.server.media.MediaUpdateService;
RoboErik01fe6612014-02-13 14:19:04 -080091import com.android.server.media.MediaSessionService;
Michael Wrightc39d47a2014-07-08 18:07:36 -070092import com.android.server.media.projection.MediaProjectionManagerService;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -070093import com.android.server.net.NetworkPolicyManagerService;
Jeff Sharkey75279902011-05-24 18:39:45 -070094import com.android.server.net.NetworkStatsService;
Ricky Wai1a6e6672017-10-27 14:46:01 +010095import com.android.server.net.watchlist.NetworkWatchlistService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -080096import com.android.server.notification.NotificationManagerService;
Andrew Scull5d7027d2017-04-12 11:46:27 +010097import com.android.server.oemlock.OemLockService;
MÃ¥rten Kongstad2e0d0f32016-06-02 09:35:31 +020098import com.android.server.om.OverlayManagerService;
Svet Ganov37e43272016-09-09 16:01:32 -070099import com.android.server.os.DeviceIdentifiersPolicyService;
Jeff Sharkey7a96c392012-11-15 14:01:46 -0800100import com.android.server.os.SchedulingPolicyService;
Calin Juravle91d40f12017-03-15 18:38:57 -0700101import com.android.server.pm.BackgroundDexOptService;
Tony Makb0d22622018-01-18 12:49:49 +0000102import com.android.server.pm.CrossProfileAppsService;
Jeff Brownf69c8122012-09-12 17:00:34 -0700103import com.android.server.pm.Installer;
Amith Yamasani4f582632014-02-19 14:31:52 -0800104import com.android.server.pm.LauncherAppsService;
Andreas Gampea8908752015-11-10 08:58:14 -0800105import com.android.server.pm.OtaDexoptService;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -0700106import com.android.server.pm.PackageManagerService;
Makoto Onuki6f7362d92016-03-04 13:39:41 -0800107import com.android.server.pm.ShortcutService;
Amith Yamasani258848d2012-08-10 17:06:33 -0700108import com.android.server.pm.UserManagerService;
Wale Ogunwaleb699ce02016-07-18 12:05:30 -0700109import com.android.server.policy.PhoneWindowManager;
Jeff Brown4f8ecd82012-06-18 18:29:13 -0700110import com.android.server.power.PowerManagerService;
111import com.android.server.power.ShutdownThread;
Amith Yamasanif20d6402014-05-24 15:34:37 -0700112import com.android.server.restrictions.RestrictionsManagerService;
Janis Danisevskis8ff1e192016-06-03 11:31:55 -0700113import com.android.server.security.KeyAttestationApplicationIdProviderService;
Robin Lee13935492017-03-23 15:28:37 +0000114import com.android.server.security.KeyChainSystemService;
Arunesh Mishraa772e5f2016-01-25 10:33:11 -0800115import com.android.server.soundtrigger.SoundTriggerService;
Bookatz94726412017-08-31 09:26:15 -0700116import com.android.server.stats.StatsCompanionService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -0800117import com.android.server.statusbar.StatusBarManagerService;
118import com.android.server.storage.DeviceStorageMonitorService;
Santos Cordon5d2c1e62014-11-21 15:20:15 -0800119import com.android.server.telecom.TelecomLoaderService;
Abodunrinwa Tokid32906c2018-01-18 04:34:44 -0800120import com.android.server.textclassifier.TextClassificationManagerService;
Yohei Yukawaeb1e8042018-09-12 14:02:00 -0700121import com.android.server.textservices.TextServicesManagerService;
Adrian Roos82142c22014-03-27 14:56:59 +0100122import com.android.server.trust.TrustManagerService;
Jae Seo39570912014-02-20 18:23:25 -0800123import com.android.server.tv.TvInputManagerService;
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -0800124import com.android.server.tv.TvRemoteService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -0800125import com.android.server.twilight.TwilightService;
Wale Ogunwale6d50dcc2018-07-21 23:00:40 -0700126import com.android.server.uri.UriGrantsManagerService;
Adam Lesinski0debc9a2014-07-16 19:09:13 -0700127import com.android.server.usage.UsageStatsService;
Ruben Brunkdd18a0b2015-12-04 16:16:31 -0800128import com.android.server.vr.VrManagerService;
Torne (Richard Coles)08cfaf62014-05-08 16:07:05 +0100129import com.android.server.webkit.WebViewUpdateService;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -0700130import com.android.server.wm.WindowManagerService;
131
132import dalvik.system.VMRuntime;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -0700133
Tao Bao4fd6c262016-01-19 14:22:24 -0800134import java.io.File;
135import java.io.IOException;
Narayan Kamathbf882052015-08-11 15:40:34 +0100136import java.util.Locale;
Bob Leee5408332009-09-04 18:31:17 -0700137import java.util.Timer;
Fyodor Kupolov311b9fa2016-12-02 16:24:35 -0800138import java.util.concurrent.CountDownLatch;
Keun-young Parkd80e8942017-01-27 11:30:19 -0800139import java.util.concurrent.Future;
Bob Leee5408332009-09-04 18:31:17 -0700140
Vishnu Naire78b01a2017-10-26 10:11:54 -0700141import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_CRITICAL;
142import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_HIGH;
143import static android.os.IServiceManager.DUMP_FLAG_PRIORITY_NORMAL;
144import static android.os.IServiceManager.DUMP_FLAG_PROTO;
Andrii Kulian5406e7a2016-10-21 11:55:23 -0700145import static android.view.Display.DEFAULT_DISPLAY;
146
Jeff Brown6f357d32014-01-15 20:40:55 -0800147public final class SystemServer {
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800148 private static final String TAG = "SystemServer";
Jeff Brown6f357d32014-01-15 20:40:55 -0800149
Keun-young Park9b73a542017-02-01 12:09:58 -0800150 // Tag for timing measurement of main thread.
151 private static final String SYSTEM_SERVER_TIMING_TAG = "SystemServerTiming";
152 // Tag for timing measurement of non-main asynchronous operations.
153 private static final String SYSTEM_SERVER_TIMING_ASYNC_TAG = SYSTEM_SERVER_TIMING_TAG + "Async";
154
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -0700155 private static final TimingsTraceLog BOOT_TIMINGS_TRACE_LOG
156 = new TimingsTraceLog(SYSTEM_SERVER_TIMING_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700157
Ben Komalo553acf02011-09-19 14:25:28 -0700158 private static final String ENCRYPTING_STATE = "trigger_restart_min_framework";
Ben Komalo3573d402011-09-23 15:08:24 -0700159 private static final String ENCRYPTED_STATE = "1";
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800160
Jeff Brown6f357d32014-01-15 20:40:55 -0800161 private static final long SNAPSHOT_INTERVAL = 60 * 60 * 1000; // 1hr
162
163 // The earliest supported time. We pick one day into 1970, to
164 // give any timezone code room without going into negative time.
165 private static final long EARLIEST_SUPPORTED_TIME = 86400 * 1000;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800166
Makoto Onuki712886f2018-04-27 15:22:50 -0700167 private static final long SLOW_DISPATCH_THRESHOLD_MS = 100;
168 private static final long SLOW_DELIVERY_THRESHOLD_MS = 200;
169
Amith Yamasani817ec492013-12-20 13:27:30 -0800170 /*
171 * Implementation class names. TODO: Move them to a codegen class or load
172 * them from the build system somehow.
173 */
174 private static final String BACKUP_MANAGER_SERVICE_CLASS =
Michal Karpinskife4ae0c2018-01-25 15:24:00 +0000175 "com.android.server.backup.BackupManagerService$Lifecycle";
Amith Yamasani817ec492013-12-20 13:27:30 -0800176 private static final String APPWIDGET_SERVICE_CLASS =
177 "com.android.server.appwidget.AppWidgetService";
Dianne Hackborn91097de2014-04-04 18:02:06 -0700178 private static final String VOICE_RECOGNITION_MANAGER_SERVICE_CLASS =
179 "com.android.server.voiceinteraction.VoiceInteractionManagerService";
Amith Yamasani817ec492013-12-20 13:27:30 -0800180 private static final String PRINT_MANAGER_SERVICE_CLASS =
181 "com.android.server.print.PrintManagerService";
Eugene Susla6ed45d82017-01-22 13:52:51 -0800182 private static final String COMPANION_DEVICE_MANAGER_SERVICE_CLASS =
Eugene Susla0d3dd122017-04-18 10:56:37 -0700183 "com.android.server.companion.CompanionDeviceManagerService";
Adam Lesinski2cb6c602014-02-14 17:19:56 -0800184 private static final String USB_SERVICE_CLASS =
185 "com.android.server.usb.UsbService$Lifecycle";
Mike Lockwood5781cd52015-03-27 13:23:41 -0700186 private static final String MIDI_SERVICE_CLASS =
187 "com.android.server.midi.MidiService$Lifecycle";
Adam Lesinskif542a332014-02-19 12:29:58 -0800188 private static final String WIFI_SERVICE_CLASS =
189 "com.android.server.wifi.WifiService";
Etan Cohen04133272016-10-26 11:22:06 -0700190 private static final String WIFI_AWARE_SERVICE_CLASS =
191 "com.android.server.wifi.aware.WifiAwareService";
Adam Lesinskif542a332014-02-19 12:29:58 -0800192 private static final String WIFI_P2P_SERVICE_CLASS =
193 "com.android.server.wifi.p2p.WifiP2pService";
Robert Quattlebaum87a71042017-05-15 15:45:20 -0700194 private static final String LOWPAN_SERVICE_CLASS =
195 "com.android.server.lowpan.LowpanService";
Lorenzo Colittif9ff2c92014-05-21 16:32:11 -0700196 private static final String ETHERNET_SERVICE_CLASS =
197 "com.android.server.ethernet.EthernetService";
Christopher Tate7060b042014-06-09 19:50:00 -0700198 private static final String JOB_SCHEDULER_SERVICE_CLASS =
199 "com.android.server.job.JobSchedulerService";
Jim Miller4f93c582016-01-27 19:05:43 -0800200 private static final String LOCK_SETTINGS_SERVICE_CLASS =
Andrew Scull507d11c2017-05-03 17:19:01 +0100201 "com.android.server.locksettings.LockSettingsService$Lifecycle";
Sudheer Shanka2250d562016-11-07 15:41:02 -0800202 private static final String STORAGE_MANAGER_SERVICE_CLASS =
203 "com.android.server.StorageManagerService$Lifecycle";
Jeff Sharkeye8cece92017-01-04 11:33:33 -0700204 private static final String STORAGE_STATS_SERVICE_CLASS =
205 "com.android.server.usage.StorageStatsService$Lifecycle";
Jeff Sharkey4175be22016-01-09 14:57:45 -0700206 private static final String SEARCH_MANAGER_SERVICE_CLASS =
207 "com.android.server.search.SearchManagerService$Lifecycle";
Wei Liud699cf82016-03-25 16:32:10 -0700208 private static final String THERMAL_OBSERVER_CLASS =
209 "com.google.android.clockwork.ThermalObserver";
Calvin On5555bcc2017-02-21 16:41:43 -0800210 private static final String WEAR_CONNECTIVITY_SERVICE_CLASS =
Calvin On3cda1cf2018-02-14 13:57:07 -0800211 "com.android.clockwork.connectivity.WearConnectivityService";
Damien Bargiacchiae4cb672018-05-30 13:28:15 -0700212 private static final String WEAR_POWER_SERVICE_CLASS =
213 "com.android.clockwork.power.WearPowerService";
Chris Phoenixbc839a32017-10-21 14:46:15 -0700214 private static final String WEAR_SIDEKICK_SERVICE_CLASS =
215 "com.google.android.clockwork.sidekick.SidekickService";
Julius D'souza069f46c2017-03-22 13:27:00 -0700216 private static final String WEAR_DISPLAY_SERVICE_CLASS =
217 "com.google.android.clockwork.display.WearDisplayService";
Ivan Podogovf9973822017-05-11 15:51:34 +0100218 private static final String WEAR_LEFTY_SERVICE_CLASS =
219 "com.google.android.clockwork.lefty.WearLeftyService";
Damien Bargiacchi2d92eeb2016-04-07 14:01:03 -0700220 private static final String WEAR_TIME_SERVICE_CLASS =
221 "com.google.android.clockwork.time.WearTimeService";
Michael Kwan01ad0aa2018-02-28 15:19:04 -0800222 private static final String WEAR_GLOBAL_ACTIONS_SERVICE_CLASS =
223 "com.android.clockwork.globalactions.GlobalActionsService";
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600224 private static final String ACCOUNT_SERVICE_CLASS =
225 "com.android.server.accounts.AccountManagerService$Lifecycle";
Jeff Sharkeya3ebfec2016-04-04 08:58:04 -0600226 private static final String CONTENT_SERVICE_CLASS =
227 "com.android.server.content.ContentService$Lifecycle";
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600228 private static final String WALLPAPER_SERVICE_CLASS =
229 "com.android.server.wallpaper.WallpaperManagerService$Lifecycle";
Felipe Leme5381aa42016-10-13 09:02:32 -0700230 private static final String AUTO_FILL_MANAGER_SERVICE_CLASS =
Svet Ganov2f8fb1f2017-03-13 00:21:04 -0700231 "com.android.server.autofill.AutofillManagerService";
Neil Fuller328532a2017-03-16 18:32:21 +0000232 private static final String TIME_ZONE_RULES_MANAGER_SERVICE_CLASS =
233 "com.android.server.timezone.RulesManagerService$Lifecycle";
Nick Felker1bfe59d2017-10-12 13:27:02 -0700234 private static final String IOT_SERVICE_CLASS =
Ralph Nathan090c2c32018-04-19 22:19:03 -0700235 "com.android.things.server.IoTSystemService";
Jason Monk8f5f7ff2017-10-17 14:12:42 -0400236 private static final String SLICE_MANAGER_SERVICE_CLASS =
237 "com.android.server.slice.SliceManagerService$Lifecycle";
Steve Paik94292a32018-01-26 17:16:53 -0800238 private static final String CAR_SERVICE_HELPER_SERVICE_CLASS =
239 "com.android.internal.car.CarServiceHelperService";
Neil Fullerfeeee682018-05-30 14:35:24 +0100240 private static final String TIME_DETECTOR_SERVICE_CLASS =
241 "com.android.server.timedetector.TimeDetectorService$Lifecycle";
Neil Fuller7fb88c32018-06-19 12:53:47 +0100242 private static final String TIME_ZONE_DETECTOR_SERVICE_CLASS =
243 "com.android.server.timezonedetector.TimeZoneDetectorService$Lifecycle";
Rhed Jao8a39cef2018-07-18 11:43:33 +0800244 private static final String ACCESSIBILITY_MANAGER_SERVICE_CLASS =
245 "com.android.server.accessibility.AccessibilityManagerService$Lifecycle";
Kenny Rootf74bfde2018-01-18 15:42:48 -0800246 private static final String ADB_SERVICE_CLASS =
247 "com.android.server.adb.AdbService$Lifecycle";
Jason Monk8f5f7ff2017-10-17 14:12:42 -0400248
Andres Morales68d4acd2014-07-01 19:40:41 -0700249 private static final String PERSISTENT_DATA_BLOCK_PROP = "ro.frp.pst";
Amith Yamasani817ec492013-12-20 13:27:30 -0800250
Tao Bao4fd6c262016-01-19 14:22:24 -0800251 private static final String UNCRYPT_PACKAGE_FILE = "/cache/recovery/uncrypt_file";
252 private static final String BLOCK_MAP_FILE = "/cache/recovery/block.map";
253
Tim Murrayeef4a3d2016-04-19 14:14:20 -0700254 // maximum number of binder threads used for system_server
255 // will be higher than the system default
256 private static final int sMaxBinderThreads = 31;
257
Alan Viveretteba398ea2015-12-16 15:28:23 -0500258 /**
259 * Default theme used by the system context. This is used to style
260 * system-provided dialogs, such as the Power Off dialog, and other
261 * visual content.
262 */
263 private static final int DEFAULT_SYSTEM_THEME =
Michael Kwan9c7274c2016-06-13 12:48:55 -0700264 com.android.internal.R.style.Theme_DeviceDefault_System;
Alan Viveretteba398ea2015-12-16 15:28:23 -0500265
Jeff Brown6f357d32014-01-15 20:40:55 -0800266 private final int mFactoryTestMode;
267 private Timer mProfilerSnapshotTimer;
268
269 private Context mSystemContext;
270 private SystemServiceManager mSystemServiceManager;
271
Jeff Brown4ccb8232014-01-16 22:16:42 -0800272 // TODO: remove all of these references by improving dependency resolution and boot phases
Jeff Brown4ccb8232014-01-16 22:16:42 -0800273 private PowerManagerService mPowerManagerService;
274 private ActivityManagerService mActivityManagerService;
Gustav Sennton6258dcd2015-10-30 19:25:37 +0000275 private WebViewUpdateService mWebViewUpdateService;
Jeff Brown4ccb8232014-01-16 22:16:42 -0800276 private DisplayManagerService mDisplayManagerService;
Jeff Brown2c43c332014-06-12 22:38:59 -0700277 private PackageManagerService mPackageManagerService;
278 private PackageManager mPackageManager;
Jeff Brown6f357d32014-01-15 20:40:55 -0800279 private ContentResolver mContentResolver;
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600280 private EntropyMixer mEntropyMixer;
Jeff Brown6f357d32014-01-15 20:40:55 -0800281
Jeff Brown2c43c332014-06-12 22:38:59 -0700282 private boolean mOnlyCore;
283 private boolean mFirstBoot;
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800284 private final boolean mRuntimeRestart;
Makoto Onukie8edbcf2018-03-02 16:49:29 -0800285 private final long mRuntimeStartElapsedTime;
286 private final long mRuntimeStartUptime;
Jeff Brown2c43c332014-06-12 22:38:59 -0700287
Keun-young Park9b73a542017-02-01 12:09:58 -0800288 private static final String START_SENSOR_SERVICE = "StartSensorService";
Yifan Hong26b421f2017-03-10 13:41:11 -0800289 private static final String START_HIDL_SERVICES = "StartHidlServices";
290
291
Keun-young Park9b73a542017-02-01 12:09:58 -0800292 private Future<?> mSensorServiceStart;
Narayan Kamath97780462017-02-06 20:24:08 +0000293 private Future<?> mZygotePreload;
294
Jeff Brown6f357d32014-01-15 20:40:55 -0800295 /**
Keun-young Park9b73a542017-02-01 12:09:58 -0800296 * Start the sensor service. This is a blocking call and can take time.
Jeff Brown6f357d32014-01-15 20:40:55 -0800297 */
Svet Ganovb9d71a62015-04-30 10:38:13 -0700298 private static native void startSensorService();
Jeff Brown6f357d32014-01-15 20:40:55 -0800299
300 /**
Yifan Hong26b421f2017-03-10 13:41:11 -0800301 * Start all HIDL services that are run inside the system server. This
302 * may take some time.
303 */
304 private static native void startHidlServices();
305
306 /**
Jeff Brown6f357d32014-01-15 20:40:55 -0800307 * The main entry point from zygote.
308 */
309 public static void main(String[] args) {
310 new SystemServer().run();
311 }
312
313 public SystemServer() {
Jeff Brown2c43c332014-06-12 22:38:59 -0700314 // Check for factory test mode.
Jeff Brown6f357d32014-01-15 20:40:55 -0800315 mFactoryTestMode = FactoryTest.getMode();
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800316 // Remember if it's runtime restart(when sys.boot_completed is already set) or reboot
317 mRuntimeRestart = "1".equals(SystemProperties.get("sys.boot_completed"));
Makoto Onukie8edbcf2018-03-02 16:49:29 -0800318
319 mRuntimeStartElapsedTime = SystemClock.elapsedRealtime();
320 mRuntimeStartUptime = SystemClock.uptimeMillis();
Jeff Brown6f357d32014-01-15 20:40:55 -0800321 }
322
323 private void run() {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900324 try {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700325 traceBeginAndSlog("InitBeforeStartServices");
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900326 // If a device's clock is before 1970 (before 0), a lot of
327 // APIs crash dealing with negative numbers, notably
328 // java.io.File#setLastModified, so instead we fake it and
329 // hope that time from cell towers or NTP fixes it shortly.
330 if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
331 Slog.w(TAG, "System clock is before 1970; setting to 1970.");
332 SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
333 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800334
Przemyslaw Szczepaniakfbe00fa2017-07-28 13:21:48 +0000335 //
336 // Default the timezone property to GMT if not set.
337 //
338 String timezoneProperty = SystemProperties.get("persist.sys.timezone");
339 if (timezoneProperty == null || timezoneProperty.isEmpty()) {
340 Slog.w(TAG, "Timezone not set; setting to GMT.");
341 SystemProperties.set("persist.sys.timezone", "GMT");
342 }
343
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +0900344 // If the system has "persist.sys.language" and friends set, replace them with
345 // "persist.sys.locale". Note that the default locale at this point is calculated
346 // using the "-Duser.locale" command line flag. That flag is usually populated by
347 // AndroidRuntime using the same set of system properties, but only the system_server
348 // and system apps are allowed to set them.
349 //
350 // NOTE: Most changes made here will need an equivalent change to
351 // core/jni/AndroidRuntime.cpp
352 if (!SystemProperties.get("persist.sys.language").isEmpty()) {
353 final String languageTag = Locale.getDefault().toLanguageTag();
Narayan Kamathbf882052015-08-11 15:40:34 +0100354
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +0900355 SystemProperties.set("persist.sys.locale", languageTag);
356 SystemProperties.set("persist.sys.language", "");
357 SystemProperties.set("persist.sys.country", "");
358 SystemProperties.set("persist.sys.localevar", "");
359 }
Narayan Kamathbf882052015-08-11 15:40:34 +0100360
Jeff Sharkey0a17db12016-11-04 11:23:46 -0600361 // The system server should never make non-oneway calls
362 Binder.setWarnOnBlocking(true);
Jeff Sharkeyb0613dc2018-02-27 14:38:04 -0700363 // The system server should always load safe labels
Philip P. Moltmann20dd4312018-10-08 16:56:49 -0700364 PackageItemInfo.forceSafeLabels();
Makoto Onuki50e00c82018-08-07 15:57:13 -0700365
366 // Default to FULL within the system server.
367 SQLiteGlobal.sDefaultSyncMode = SQLiteGlobal.SYNC_MODE_FULL;
368
Fyodor Kupolov7fcd6592017-12-15 11:56:36 -0800369 // Deactivate SQLiteCompatibilityWalFlags until settings provider is initialized
370 SQLiteCompatibilityWalFlags.init(null);
Jeff Sharkey0a17db12016-11-04 11:23:46 -0600371
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900372 // Here we go!
373 Slog.i(TAG, "Entered the Android system server!");
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800374 int uptimeMillis = (int) SystemClock.elapsedRealtime();
Fyodor Kupolov8d3e82b2016-11-10 17:58:50 -0800375 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800376 if (!mRuntimeRestart) {
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800377 MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -0800378 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800379
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900380 // In case the runtime switched since last boot (such as when
381 // the old runtime was removed in an OTA), set the system
Eugene Suslaa38fbf62017-03-14 10:26:10 -0700382 // property so that it is in sync. We can | xq oqi't do this in
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900383 // libnativehelper's JniInvocation::Init code where we already
384 // had to fallback to a different runtime because it is
385 // running as root and we need to be the system user to set
386 // the property. http://b/11463182
387 SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
Jeff Brown6f357d32014-01-15 20:40:55 -0800388
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900389 // Mmmmmm... more memory!
390 VMRuntime.getRuntime().clearGrowthLimit();
Jeff Brown6f357d32014-01-15 20:40:55 -0800391
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900392 // The system server has to run all of the time, so it needs to be
393 // as efficient as possible with its memory usage.
394 VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
Jeff Brown6f357d32014-01-15 20:40:55 -0800395
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900396 // Some devices rely on runtime fingerprint generation, so make sure
397 // we've defined it before booting further.
398 Build.ensureFingerprintProperty();
Jeff Sharkey55687722014-04-09 18:07:19 -0700399
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900400 // Within the system server, it is an error to access Environment paths without
401 // explicitly specifying a user.
402 Environment.setUserRequired(true);
Jeff Brown6f357d32014-01-15 20:40:55 -0800403
Jeff Sharkeyd136e512016-03-09 22:30:56 -0700404 // Within the system server, any incoming Bundles should be defused
405 // to avoid throwing BadParcelableException.
406 BaseBundle.setShouldDefuse(true);
407
Fyodor Kupolova81b8c02017-11-13 15:51:03 -0800408 // Within the system server, when parceling exceptions, include the stack trace
409 Parcel.setStackTraceParceling(true);
410
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900411 // Ensure binder calls into the system always run at foreground priority.
412 BinderInternal.disableBackgroundScheduling(true);
Jeff Brown6f357d32014-01-15 20:40:55 -0800413
Tim Murrayeef4a3d2016-04-19 14:14:20 -0700414 // Increase the number of binder threads in system_server
415 BinderInternal.setMaxThreads(sMaxBinderThreads);
416
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900417 // Prepare the main looper thread (this thread).
418 android.os.Process.setThreadPriority(
Jeff Brown6f357d32014-01-15 20:40:55 -0800419 android.os.Process.THREAD_PRIORITY_FOREGROUND);
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900420 android.os.Process.setCanSelfBackground(false);
421 Looper.prepareMainLooper();
Makoto Onuki712886f2018-04-27 15:22:50 -0700422 Looper.getMainLooper().setSlowLogThresholdMs(
423 SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
Jeff Brown6f357d32014-01-15 20:40:55 -0800424
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900425 // Initialize native services.
426 System.loadLibrary("android_servers");
Jeff Brown6f357d32014-01-15 20:40:55 -0800427
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900428 // Check whether we failed to shut down last time we tried.
429 // This call may not return.
430 performPendingShutdown();
Jeff Brown6f357d32014-01-15 20:40:55 -0800431
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900432 // Initialize the system context.
433 createSystemContext();
Jeff Brown6f357d32014-01-15 20:40:55 -0800434
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900435 // Create the system service manager.
436 mSystemServiceManager = new SystemServiceManager(mSystemContext);
Makoto Onukie8edbcf2018-03-02 16:49:29 -0800437 mSystemServiceManager.setStartInfo(mRuntimeRestart,
438 mRuntimeStartElapsedTime, mRuntimeStartUptime);
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900439 LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
Fyodor Kupolove29a5a12016-12-16 16:14:17 -0800440 // Prepare the thread pool for init tasks that can be parallelized
441 SystemServerInitThreadPool.get();
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900442 } finally {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700443 traceEnd(); // InitBeforeStartServices
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900444 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800445
446 // Start services.
447 try {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700448 traceBeginAndSlog("StartServices");
Jeff Brown6f357d32014-01-15 20:40:55 -0800449 startBootstrapServices();
Jeff Brown4ccb8232014-01-16 22:16:42 -0800450 startCoreServices();
Jeff Brown6f357d32014-01-15 20:40:55 -0800451 startOtherServices();
Fyodor Kupolovcd824ef2017-02-07 11:25:14 -0800452 SystemServerInitThreadPool.shutdown();
Jeff Brown2c43c332014-06-12 22:38:59 -0700453 } catch (Throwable ex) {
Jeff Brown6f357d32014-01-15 20:40:55 -0800454 Slog.e("System", "******************************************");
455 Slog.e("System", "************ Failure starting system services", ex);
456 throw ex;
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900457 } finally {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700458 traceEnd();
Jeff Brown6f357d32014-01-15 20:40:55 -0800459 }
460
Jeff Sharkey89182982017-11-01 19:02:56 -0600461 StrictMode.initVmDefaults(null);
462
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800463 if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
Fyodor Kupolov24e12dc2017-01-17 12:20:36 -0800464 int uptimeMillis = (int) SystemClock.elapsedRealtime();
465 MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
466 final int MAX_UPTIME_MILLIS = 60 * 1000;
467 if (uptimeMillis > MAX_UPTIME_MILLIS) {
Keun-young Park9b73a542017-02-01 12:09:58 -0800468 Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
Fyodor Kupolov24e12dc2017-01-17 12:20:36 -0800469 "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
470 }
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800471 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800472
Andreas Gampee697a4f2018-10-09 10:40:52 -0700473 // Diagnostic to ensure that the system is in a base healthy state. Done here as a common
474 // non-zygote process.
475 if (!VMRuntime.hasBootImageSpaces()) {
476 Slog.wtf(TAG, "Runtime is not running with a boot image!");
477 }
478
Jeff Brown6f357d32014-01-15 20:40:55 -0800479 // Loop forever.
480 Looper.loop();
481 throw new RuntimeException("Main thread loop unexpectedly exited");
482 }
483
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800484 private boolean isFirstBootOrUpgrade() {
485 return mPackageManagerService.isFirstBoot() || mPackageManagerService.isUpgrade();
486 }
487
Jeff Brown6f357d32014-01-15 20:40:55 -0800488 private void reportWtf(String msg, Throwable e) {
Dianne Hackborn661cd522011-08-22 00:26:20 -0700489 Slog.w(TAG, "***********************************************");
Dianne Hackborn8d051722014-10-01 14:59:58 -0700490 Slog.wtf(TAG, "BOOT FAILURE " + msg, e);
Dianne Hackborn661cd522011-08-22 00:26:20 -0700491 }
492
Jeff Brown6f357d32014-01-15 20:40:55 -0800493 private void performPendingShutdown() {
494 final String shutdownAction = SystemProperties.get(
495 ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");
496 if (shutdownAction != null && shutdownAction.length() > 0) {
497 boolean reboot = (shutdownAction.charAt(0) == '1');
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800498
Jeff Brown6f357d32014-01-15 20:40:55 -0800499 final String reason;
500 if (shutdownAction.length() > 1) {
501 reason = shutdownAction.substring(1, shutdownAction.length());
502 } else {
503 reason = null;
Kenny Rootf547d672010-09-22 10:36:48 -0700504 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800505
Tao Bao4fd6c262016-01-19 14:22:24 -0800506 // If it's a pending reboot into recovery to apply an update,
507 // always make sure uncrypt gets executed properly when needed.
508 // If '/cache/recovery/block.map' hasn't been created, stop the
509 // reboot which will fail for sure, and get a chance to capture a
Tao Baoe8a403d2015-12-31 07:44:55 -0800510 // bugreport when that's still feasible. (Bug: 26444951)
Tianjie Xu3a66fc42017-06-09 15:50:14 -0700511 if (reason != null && reason.startsWith(PowerManager.REBOOT_RECOVERY_UPDATE)) {
Tao Bao4fd6c262016-01-19 14:22:24 -0800512 File packageFile = new File(UNCRYPT_PACKAGE_FILE);
513 if (packageFile.exists()) {
514 String filename = null;
515 try {
516 filename = FileUtils.readTextFile(packageFile, 0, null);
517 } catch (IOException e) {
518 Slog.e(TAG, "Error reading uncrypt package file", e);
519 }
520
521 if (filename != null && filename.startsWith("/data")) {
522 if (!new File(BLOCK_MAP_FILE).exists()) {
523 Slog.e(TAG, "Can't find block map file, uncrypt failed or " +
524 "unexpected runtime restart?");
525 return;
526 }
527 }
528 }
529 }
Alison Cichowlasf0afd8c2017-07-31 11:24:34 -0400530 Runnable runnable = new Runnable() {
531 @Override
532 public void run() {
533 synchronized (this) {
534 ShutdownThread.rebootOrShutdown(null, reboot, reason);
535 }
536 }
537 };
538
539 // ShutdownThread must run on a looper capable of displaying the UI.
540 Message msg = Message.obtain(UiThread.getHandler(), runnable);
541 msg.setAsynchronous(true);
542 UiThread.getHandler().sendMessage(msg);
543
Kenny Rootf547d672010-09-22 10:36:48 -0700544 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800545 }
Kenny Rootf547d672010-09-22 10:36:48 -0700546
Jeff Brown6f357d32014-01-15 20:40:55 -0800547 private void createSystemContext() {
548 ActivityThread activityThread = ActivityThread.systemMain();
549 mSystemContext = activityThread.getSystemContext();
Alan Viveretteba398ea2015-12-16 15:28:23 -0500550 mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
Adam Lesinskia82b6262017-03-21 16:56:17 -0700551
552 final Context systemUiContext = activityThread.getSystemUiContext();
553 systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
Jeff Brown6f357d32014-01-15 20:40:55 -0800554 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800555
Jeff Brown2c43c332014-06-12 22:38:59 -0700556 /**
557 * Starts the small tangle of critical services that are needed to get
558 * the system off the ground. These services have complex mutual dependencies
559 * which is why we initialize them all in one place here. Unless your service
560 * is also entwined in these dependencies, it should be initialized in one of
561 * the other functions.
562 */
Jeff Brown6f357d32014-01-15 20:40:55 -0800563 private void startBootstrapServices() {
Fyodor Kupolovb76e0fd2017-01-30 13:28:25 -0800564 Slog.i(TAG, "Reading configuration...");
565 final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
566 traceBeginAndSlog(TAG_SYSTEM_CONFIG);
567 SystemServerInitThreadPool.get().submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
568 traceEnd();
569
Jeff Brown6f357d32014-01-15 20:40:55 -0800570 // Wait for installd to finish starting up so that it has a chance to
571 // create critical directories such as /data/user with the appropriate
572 // permissions. We need this to complete before we initialize other services.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700573 traceBeginAndSlog("StartInstaller");
Narayan Kamath76a748e2014-11-10 14:23:41 +0000574 Installer installer = mSystemServiceManager.startService(Installer.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700575 traceEnd();
Jeff Brown6f357d32014-01-15 20:40:55 -0800576
Svet Ganov37e43272016-09-09 16:01:32 -0700577 // In some cases after launching an app we need to access device identifiers,
578 // therefore register the device identifier policy before the activity manager.
579 traceBeginAndSlog("DeviceIdentifiersPolicyService");
580 mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
581 traceEnd();
582
Wale Ogunwale6d50dcc2018-07-21 23:00:40 -0700583 // Uri Grants Manager.
584 traceBeginAndSlog("UriGrantsManagerService");
585 mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class);
586 traceEnd();
587
Jeff Brown6f357d32014-01-15 20:40:55 -0800588 // Activity manager runs the show.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700589 traceBeginAndSlog("StartActivityManager");
Wale Ogunwale16e505a2018-05-07 15:00:49 -0700590 // TODO: Might need to move after migration to WM.
591 ActivityTaskManagerService atm = mSystemServiceManager.startService(
592 ActivityTaskManagerService.Lifecycle.class).getService();
Wale Ogunwale9e4f3e02018-05-17 09:35:39 -0700593 mActivityManagerService = ActivityManagerService.Lifecycle.startService(
594 mSystemServiceManager, atm);
Dianne Hackborn91097de2014-04-04 18:02:06 -0700595 mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
Narayan Kamath76a748e2014-11-10 14:23:41 +0000596 mActivityManagerService.setInstaller(installer);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700597 traceEnd();
Jeff Brown4ccb8232014-01-16 22:16:42 -0800598
Jeff Brown2c43c332014-06-12 22:38:59 -0700599 // Power manager needs to be started early because other services need it.
600 // Native daemons may be watching for it to be registered so it must be ready
601 // to handle incoming binder calls immediately (including being able to verify
602 // the permissions for those calls).
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700603 traceBeginAndSlog("StartPowerManager");
Jeff Brown2c43c332014-06-12 22:38:59 -0700604 mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700605 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700606
607 // Now that the power manager has been started, let the activity manager
608 // initialize power management features.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700609 traceBeginAndSlog("InitPowerManagement");
Jeff Brown2c43c332014-06-12 22:38:59 -0700610 mActivityManagerService.initPowerManagement();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700611 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700612
Jeff Sharkeyfe6f85c2017-01-20 10:42:57 -0700613 // Bring up recovery system in case a rescue party needs a reboot
Narayan Kamath1c888f62017-10-30 14:35:15 +0000614 traceBeginAndSlog("StartRecoverySystemService");
615 mSystemServiceManager.startService(RecoverySystemService.class);
616 traceEnd();
Jeff Sharkeyfe6f85c2017-01-20 10:42:57 -0700617
618 // Now that we have the bare essentials of the OS up and running, take
619 // note that we just booted, which might send out a rescue party if
620 // we're stuck in a runtime restart loop.
621 RescueParty.noteBoot(mSystemContext);
622
Jeff Brown5d6443b2015-04-10 20:15:01 -0700623 // Manages LEDs and display backlight so we need it to bring up the display.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700624 traceBeginAndSlog("StartLightsService");
Jeff Brown5d6443b2015-04-10 20:15:01 -0700625 mSystemServiceManager.startService(LightsService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700626 traceEnd();
Jeff Brown5d6443b2015-04-10 20:15:01 -0700627
Chris Phoenixbc839a32017-10-21 14:46:15 -0700628 traceBeginAndSlog("StartSidekickService");
629 // Package manager isn't started yet; need to use SysProp not hardware feature
630 if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false)) {
631 mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS);
632 }
633 traceEnd();
634
Jeff Brown4ccb8232014-01-16 22:16:42 -0800635 // Display manager is needed to provide display metrics before package manager
636 // starts up.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700637 traceBeginAndSlog("StartDisplayManager");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800638 mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700639 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700640
641 // We need the default display before we can initialize the package manager.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700642 traceBeginAndSlog("WaitForDisplay");
Jeff Brown2c43c332014-06-12 22:38:59 -0700643 mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700644 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700645
646 // Only run "core" apps if we're encrypting the device.
647 String cryptState = SystemProperties.get("vold.decrypt");
648 if (ENCRYPTING_STATE.equals(cryptState)) {
649 Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
650 mOnlyCore = true;
651 } else if (ENCRYPTED_STATE.equals(cryptState)) {
652 Slog.w(TAG, "Device encrypted - only parsing core apps");
653 mOnlyCore = true;
654 }
655
656 // Start the package manager.
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800657 if (!mRuntimeRestart) {
658 MetricsLogger.histogram(null, "boot_package_manager_init_start",
659 (int) SystemClock.elapsedRealtime());
660 }
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900661 traceBeginAndSlog("StartPackageManagerService");
Narayan Kamath76a748e2014-11-10 14:23:41 +0000662 mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
Jeff Brown2c43c332014-06-12 22:38:59 -0700663 mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
664 mFirstBoot = mPackageManagerService.isFirstBoot();
665 mPackageManager = mSystemContext.getPackageManager();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700666 traceEnd();
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800667 if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800668 MetricsLogger.histogram(null, "boot_package_manager_init_ready",
669 (int) SystemClock.elapsedRealtime());
670 }
Andreas Gampeabcbe2f2016-02-26 11:25:36 -0800671 // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
672 // A/B artifacts after boot, before anything else might touch/need them.
673 // Note: this isn't needed during decryption (we don't have /data anyways).
674 if (!mOnlyCore) {
675 boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
676 false);
677 if (!disableOtaDexopt) {
678 traceBeginAndSlog("StartOtaDexOptService");
679 try {
680 OtaDexoptService.main(mSystemContext, mPackageManagerService);
681 } catch (Throwable e) {
682 reportWtf("starting OtaDexOptService", e);
683 } finally {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700684 traceEnd();
Andreas Gampeabcbe2f2016-02-26 11:25:36 -0800685 }
686 }
687 }
688
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900689 traceBeginAndSlog("StartUserManagerService");
Amith Yamasanid04aaa32016-06-13 12:09:36 -0700690 mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700691 traceEnd();
Adam Lesinski3c153512014-07-23 17:34:34 -0700692
Jeff Brown2c43c332014-06-12 22:38:59 -0700693 // Initialize attribute cache used to cache resources from packages.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700694 traceBeginAndSlog("InitAttributerCache");
Jeff Brown2c43c332014-06-12 22:38:59 -0700695 AttributeCache.init(mSystemContext);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700696 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700697
698 // Set up the Application instance for the system process and get started.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700699 traceBeginAndSlog("SetSystemProcess");
Jeff Brown2c43c332014-06-12 22:38:59 -0700700 mActivityManagerService.setSystemProcess();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700701 traceEnd();
Svet Ganovb9d71a62015-04-30 10:38:13 -0700702
Joel Fernandes2d314e12017-04-04 16:32:15 -0700703 // DisplayManagerService needs to setup android.display scheduling related policies
704 // since setSystemProcess() would have overridden policies due to setProcessGroup
705 mDisplayManagerService.setupSchedulerPolicies();
706
MÃ¥rten Kongstad2e0d0f32016-06-02 09:35:31 +0200707 // Manages Overlay packages
708 traceBeginAndSlog("StartOverlayManagerService");
Adrian Roos9ee5dff2018-08-22 20:19:49 +0200709 OverlayManagerService overlayManagerService = new OverlayManagerService(
710 mSystemContext, installer);
711 mSystemServiceManager.startService(overlayManagerService);
MÃ¥rten Kongstad2e0d0f32016-06-02 09:35:31 +0200712 traceEnd();
713
Adrian Roos9ee5dff2018-08-22 20:19:49 +0200714 if (SystemProperties.getInt("persist.sys.displayinset.top", 0) > 0) {
715 // DisplayManager needs the overlay immediately.
716 overlayManagerService.updateSystemUiContext();
717 LocalServices.getService(DisplayManagerInternal.class).onOverlayChanged();
718 }
719
Svet Ganovb9d71a62015-04-30 10:38:13 -0700720 // The sensor service needs access to package manager service, app ops
721 // service, and permissions service, therefore we start it after them.
Keun-young Park9b73a542017-02-01 12:09:58 -0800722 // Start sensor service in a separate thread. Completion should be checked
723 // before using it.
724 mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -0700725 TimingsTraceLog traceLog = new TimingsTraceLog(
Keun-young Park9b73a542017-02-01 12:09:58 -0800726 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
727 traceLog.traceBegin(START_SENSOR_SERVICE);
728 startSensorService();
729 traceLog.traceEnd();
730 }, START_SENSOR_SERVICE);
Jeff Brown6f357d32014-01-15 20:40:55 -0800731 }
732
Jeff Brown2c43c332014-06-12 22:38:59 -0700733 /**
734 * Starts some essential services that are not tangled up in the bootstrap process.
735 */
736 private void startCoreServices() {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700737 traceBeginAndSlog("StartBatteryService");
Jeff Brown21392762014-06-13 19:00:36 -0700738 // Tracks the battery level. Requires LightService.
739 mSystemServiceManager.startService(BatteryService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700740 traceEnd();
Adam Lesinski0debc9a2014-07-16 19:09:13 -0700741
742 // Tracks application usage stats.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700743 traceBeginAndSlog("StartUsageService");
Adam Lesinski0debc9a2014-07-16 19:09:13 -0700744 mSystemServiceManager.startService(UsageStatsService.class);
745 mActivityManagerService.setUsageStatsManager(
746 LocalServices.getService(UsageStatsManagerInternal.class));
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700747 traceEnd();
Torne (Richard Coles)4dbeb352014-07-29 19:14:24 +0100748
749 // Tracks whether the updatable WebView is in a ready state and watches for update installs.
Torne (Richard Coles)ff937ac2017-10-02 17:09:32 -0400750 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_WEBVIEW)) {
751 traceBeginAndSlog("StartWebViewUpdateService");
752 mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
753 traceEnd();
754 }
Fyodor Kupolovca348512018-01-10 18:05:53 -0800755
Marcin Oczeretkoc80c81a2018-08-30 20:15:52 +0100756 // Tracks and caches the device state.
757 traceBeginAndSlog("StartCachedDeviceStateService");
758 mSystemServiceManager.startService(CachedDeviceStateService.class);
759 traceEnd();
760
Fyodor Kupolovca348512018-01-10 18:05:53 -0800761 // Tracks cpu time spent in binder calls
762 traceBeginAndSlog("StartBinderCallsStatsService");
Olivier Gaillard1d7f6152018-07-03 13:57:58 +0100763 mSystemServiceManager.startService(BinderCallsStatsService.LifeCycle.class);
Fyodor Kupolovca348512018-01-10 18:05:53 -0800764 traceEnd();
Marcin Oczeretkod8cc8592018-08-22 16:07:36 +0100765
766 // Tracks time spent in handling messages in handlers.
767 traceBeginAndSlog("StartLooperStatsService");
768 mSystemServiceManager.startService(LooperStatsService.Lifecycle.class);
769 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700770 }
771
772 /**
773 * Starts a miscellaneous grab bag of stuff that has yet to be refactored
774 * and organized.
775 */
Jeff Brown6f357d32014-01-15 20:40:55 -0800776 private void startOtherServices() {
Jeff Brown6f357d32014-01-15 20:40:55 -0800777 final Context context = mSystemContext;
Jeff Brown7f6c2312012-04-13 20:38:38 -0700778 VibratorService vibrator = null;
Sudheer Shanka2250d562016-11-07 15:41:02 -0800779 IStorageManager storageManager = null;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -0700780 NetworkManagementService networkManagement = null;
Nathan Haroldb7282172017-09-11 19:50:19 -0700781 IpSecService ipSecService = null;
Jeff Sharkey75279902011-05-24 18:39:45 -0700782 NetworkStatsService networkStats = null;
Jeff Sharkeya4620792011-05-20 15:29:23 -0700783 NetworkPolicyManagerService networkPolicy = null;
Mike Lockwood0f79b542009-08-14 14:18:49 -0400784 ConnectivityService connectivity = null;
Irfan Sheriff7d024d32012-03-22 17:01:39 -0700785 NsdService serviceDiscovery= null;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800786 WindowManagerService wm = null;
Mike Lockwoodb01e8bf2011-08-29 20:11:07 -0400787 SerialService serial = null;
Amith Yamasani6734b9f2010-09-13 16:24:08 -0700788 NetworkTimeUpdateService networkTimeUpdater = null;
Jeff Brown6ec6f792012-04-17 16:52:41 -0700789 InputManagerService inputManager = null;
Wink Savillea12a7b32012-09-20 10:09:45 -0700790 TelephonyRegistry telephonyRegistry = null;
Erik Gilling51e95df2013-06-26 11:06:51 -0700791 ConsumerIrService consumerIr = null;
Ye Wend97e1fd2014-07-24 12:56:45 -0700792 MmsServiceBroker mmsService = null;
Polina Bondarenkof8754ac2016-02-12 20:38:23 +0100793 HardwarePropertiesManagerService hardwarePropertiesService = null;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800794
Abodunrinwa Tokid32906c2018-01-18 04:34:44 -0800795 boolean disableSystemTextClassifier = SystemProperties.getBoolean(
796 "config.disable_systemtextclassifier", false);
Steve Paik117fcb02018-09-13 09:43:54 -0700797 boolean disableNetworkTime = SystemProperties.getBoolean("config.disable_networktime",
798 false);
Ivan Podogov8adaec02016-09-14 18:14:31 +0100799 boolean disableCameraService = SystemProperties.getBoolean("config.disable_cameraservice",
800 false);
Jason Monk8f5f7ff2017-10-17 14:12:42 -0400801 boolean disableSlices = SystemProperties.getBoolean("config.disable_slices", false);
Ivan Podogovf9973822017-05-11 15:51:34 +0100802 boolean enableLeftyService = SystemProperties.getBoolean("config.enable_lefty", false);
Wei Liu09de4192016-09-07 13:33:49 -0700803
Colin Cross039deed2017-02-18 20:05:47 +0000804 boolean isEmulator = SystemProperties.get("ro.kernel.qemu").equals("1");
805
Erik Wolsheimer640734f2018-01-29 13:57:44 -0800806 boolean isWatch = context.getPackageManager().hasSystemFeature(
807 PackageManager.FEATURE_WATCH);
808
Rick Yiub2875922018-09-12 11:07:25 +0000809 boolean enableVrService = context.getPackageManager().hasSystemFeature(
810 PackageManager.FEATURE_VR_MODE_HIGH_PERFORMANCE);
811
Jeff Sharkeyfe6f85c2017-01-20 10:42:57 -0700812 // For debugging RescueParty
813 if (Build.IS_DEBUGGABLE && SystemProperties.getBoolean("debug.crash_system", false)) {
814 throw new RuntimeException();
815 }
816
Dan Morrille4d9a012013-03-28 18:10:43 -0700817 try {
Narayan Kamath97780462017-02-06 20:24:08 +0000818 final String SECONDARY_ZYGOTE_PRELOAD = "SecondaryZygotePreload";
819 // We start the preload ~1s before the webview factory preparation, to
820 // ensure that it completes before the 32 bit relro process is forked
821 // from the zygote. In the event that it takes too long, the webview
822 // RELRO process will block, but it will do so without holding any locks.
823 mZygotePreload = SystemServerInitThreadPool.get().submit(() -> {
824 try {
825 Slog.i(TAG, SECONDARY_ZYGOTE_PRELOAD);
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -0700826 TimingsTraceLog traceLog = new TimingsTraceLog(
Narayan Kamath97780462017-02-06 20:24:08 +0000827 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
828 traceLog.traceBegin(SECONDARY_ZYGOTE_PRELOAD);
829 if (!Process.zygoteProcess.preloadDefault(Build.SUPPORTED_32_BIT_ABIS[0])) {
830 Slog.e(TAG, "Unable to preload default resources");
831 }
832 traceLog.traceEnd();
833 } catch (Exception ex) {
834 Slog.e(TAG, "Exception preloading default resources", ex);
835 }
836 }, SECONDARY_ZYGOTE_PRELOAD);
837
Janis Danisevskis8ff1e192016-06-03 11:31:55 -0700838 traceBeginAndSlog("StartKeyAttestationApplicationIdProviderService");
839 ServiceManager.addService("sec_key_att_app_id_provider",
840 new KeyAttestationApplicationIdProviderService(context));
Vitalii Tomkivca68aca2016-09-23 10:58:43 -0700841 traceEnd();
Janis Danisevskis8ff1e192016-06-03 11:31:55 -0700842
Robin Lee13935492017-03-23 15:28:37 +0000843 traceBeginAndSlog("StartKeyChainSystemService");
844 mSystemServiceManager.startService(KeyChainSystemService.class);
845 traceEnd();
846
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900847 traceBeginAndSlog("StartSchedulingPolicyService");
Dianne Hackborn35f72be2013-09-16 10:57:39 -0700848 ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700849 traceEnd();
Glenn Kasten07b04652012-04-23 15:00:43 -0700850
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700851 traceBeginAndSlog("StartTelecomLoaderService");
Santos Cordon5d2c1e62014-11-21 15:20:15 -0800852 mSystemServiceManager.startService(TelecomLoaderService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700853 traceEnd();
Santos Cordon5d2c1e62014-11-21 15:20:15 -0800854
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900855 traceBeginAndSlog("StartTelephonyRegistry");
Jeff Brown2c43c332014-06-12 22:38:59 -0700856 telephonyRegistry = new TelephonyRegistry(context);
857 ServiceManager.addService("telephony.registry", telephonyRegistry);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700858 traceEnd();
Svetoslavb3038ec2013-02-13 14:39:30 -0800859
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900860 traceBeginAndSlog("StartEntropyMixer");
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600861 mEntropyMixer = new EntropyMixer(context);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700862 traceEnd();
Nick Kralevich79619dd2013-03-04 13:05:32 -0800863
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800864 mContentResolver = context.getContentResolver();
865
Fred Quintanae91ebe22009-09-29 20:44:30 -0700866 // The AccountManager must come before the ContentService
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900867 traceBeginAndSlog("StartAccountManagerService");
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600868 mSystemServiceManager.startService(ACCOUNT_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700869 traceEnd();
Fred Quintana60307342009-03-24 22:48:12 -0700870
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900871 traceBeginAndSlog("StartContentService");
Jeff Sharkeya3ebfec2016-04-04 08:58:04 -0600872 mSystemServiceManager.startService(CONTENT_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700873 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800874
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900875 traceBeginAndSlog("InstallSystemProviders");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800876 mActivityManagerService.installSystemProviders();
Fyodor Kupolov7fcd6592017-12-15 11:56:36 -0800877 // Now that SettingsProvider is ready, reactivate SQLiteCompatibilityWalFlags
878 SQLiteCompatibilityWalFlags.reset();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700879 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800880
Yohei Yukawab8bbdaf2018-03-14 18:04:52 -0700881 // Records errors and logs, for example wtf()
882 // Currently this service indirectly depends on SettingsProvider so do this after
883 // InstallSystemProviders.
884 traceBeginAndSlog("StartDropBoxManager");
885 mSystemServiceManager.startService(DropBoxManagerService.class);
886 traceEnd();
887
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900888 traceBeginAndSlog("StartVibratorService");
Jeff Brown7f6c2312012-04-13 20:38:38 -0700889 vibrator = new VibratorService(context);
890 ServiceManager.addService("vibrator", vibrator);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700891 traceEnd();
The Android Open Source Project10592532009-03-18 17:39:46 -0700892
Erik Wolsheimer640734f2018-01-29 13:57:44 -0800893 if (!isWatch) {
Wei Liu09de4192016-09-07 13:33:49 -0700894 traceBeginAndSlog("StartConsumerIrService");
895 consumerIr = new ConsumerIrService(context);
896 ServiceManager.addService(Context.CONSUMER_IR_SERVICE, consumerIr);
Colin Cross7af8c2a2016-09-12 21:12:49 -0700897 traceEnd();
Wei Liu09de4192016-09-07 13:33:49 -0700898 }
Erik Gilling51e95df2013-06-26 11:06:51 -0700899
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600900 traceBeginAndSlog("StartAlarmManagerService");
Suprabh Shukla6226c2f2018-08-22 18:15:04 -0700901 mSystemServiceManager.startService(new AlarmManagerService(context));
902
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700903 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800904
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900905 traceBeginAndSlog("InitWatchdog");
Jeff Brown6f357d32014-01-15 20:40:55 -0800906 final Watchdog watchdog = Watchdog.getInstance();
Jeff Brown4ccb8232014-01-16 22:16:42 -0800907 watchdog.init(context, mActivityManagerService);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700908 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800909
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900910 traceBeginAndSlog("StartInputManagerService");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800911 inputManager = new InputManagerService(context);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700912 traceEnd();
Jeff Browna9d131c2012-09-20 16:48:17 -0700913
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900914 traceBeginAndSlog("StartWindowManagerService");
Keun-young Park9b73a542017-02-01 12:09:58 -0800915 // WMS needs sensor service ready
916 ConcurrentUtils.waitForFutureNoInterrupt(mSensorServiceStart, START_SENSOR_SERVICE);
917 mSensorServiceStart = null;
Yohei Yukawae24ed792018-08-28 19:10:32 -0700918 wm = WindowManagerService.main(context, inputManager, !mFirstBoot, mOnlyCore,
919 new PhoneWindowManager());
Vishnu Naire9852f52017-10-11 18:09:55 -0700920 ServiceManager.addService(Context.WINDOW_SERVICE, wm, /* allowIsolated= */ false,
Vishnu Naire78b01a2017-10-26 10:11:54 -0700921 DUMP_FLAG_PRIORITY_CRITICAL | DUMP_FLAG_PROTO);
Vishnu Nair3764f4e2018-03-02 07:56:44 -0800922 ServiceManager.addService(Context.INPUT_SERVICE, inputManager,
923 /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700924 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800925
Bryce Leef19cbe22018-02-02 15:09:21 -0800926 traceBeginAndSlog("SetWindowManagerService");
927 mActivityManagerService.setWindowManager(wm);
928 traceEnd();
929
930 traceBeginAndSlog("WindowManagerServiceOnInitReady");
931 wm.onInitReady();
932 traceEnd();
933
Yifan Hong604c12c2017-03-20 10:57:44 -0700934 // Start receiving calls from HIDL services. Start in in a separate thread
935 // because it need to connect to SensorManager. This have to start
936 // after START_SENSOR_SERVICE is done.
937 SystemServerInitThreadPool.get().submit(() -> {
Roger 1 Jönsson341b2c12017-05-17 14:21:55 +0200938 TimingsTraceLog traceLog = new TimingsTraceLog(
939 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
940 traceLog.traceBegin(START_HIDL_SERVICES);
Yifan Hong604c12c2017-03-20 10:57:44 -0700941 startHidlServices();
Roger 1 Jönsson341b2c12017-05-17 14:21:55 +0200942 traceLog.traceEnd();
Yifan Hong604c12c2017-03-20 10:57:44 -0700943 }, START_HIDL_SERVICES);
944
Rick Yiub2875922018-09-12 11:07:25 +0000945 if (!isWatch && enableVrService) {
Wei Liuef89d212016-09-19 15:10:33 -0700946 traceBeginAndSlog("StartVrManagerService");
947 mSystemServiceManager.startService(VrManagerService.class);
Wei Liu03d0a362016-09-20 10:21:27 -0700948 traceEnd();
Wei Liuef89d212016-09-19 15:10:33 -0700949 }
Ruben Brunkdd18a0b2015-12-04 16:16:31 -0800950
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700951 traceBeginAndSlog("StartInputManager");
Arthur Hung95b38a92018-07-20 18:56:12 +0800952 inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());
Jeff Browna9d131c2012-09-20 16:48:17 -0700953 inputManager.start();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700954 traceEnd();
Jeff Browna9d131c2012-09-20 16:48:17 -0700955
Jeff Brown4ccb8232014-01-16 22:16:42 -0800956 // TODO: Use service dependencies instead.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700957 traceBeginAndSlog("DisplayManagerWindowManagerAndInputReady");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800958 mDisplayManagerService.windowManagerAndInputReady();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700959 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800960
Colin Cross039deed2017-02-18 20:05:47 +0000961 // Skip Bluetooth if we have an emulator kernel
962 // TODO: Use a more reliable check to see if this product should
963 // support Bluetooth - see bug 988521
964 if (isEmulator) {
965 Slog.i(TAG, "No Bluetooth Service (emulator)");
966 } else if (mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL) {
David 'Digit' Turnere2a5e862011-01-17 00:32:33 +0100967 Slog.i(TAG, "No Bluetooth Service (factory test)");
Matthew Xie1dd01eb32013-04-26 12:37:54 -0700968 } else if (!context.getPackageManager().hasSystemFeature
969 (PackageManager.FEATURE_BLUETOOTH)) {
970 Slog.i(TAG, "No Bluetooth Service (Bluetooth Hardware Not Present)");
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800971 } else {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700972 traceBeginAndSlog("StartBluetoothService");
Miao Chou658bf2f2015-06-26 17:14:35 -0700973 mSystemServiceManager.startService(BluetoothService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700974 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800975 }
Pavel Zhamaitsiak02b3e6b2016-02-03 10:39:44 -0800976
Hugo Benichieab511b2016-09-09 09:23:47 +0900977 traceBeginAndSlog("IpConnectivityMetrics");
978 mSystemServiceManager.startService(IpConnectivityMetrics.class);
Keun-young Parkd340d8a2016-10-18 17:52:30 -0700979 traceEnd();
Hugo Benichieab511b2016-09-09 09:23:47 +0900980
Ricky Wai1a6e6672017-10-27 14:46:01 +0100981 traceBeginAndSlog("NetworkWatchlistService");
982 mSystemServiceManager.startService(NetworkWatchlistService.Lifecycle.class);
983 traceEnd();
984
Philip Cuadra7bd0fdd2016-04-28 15:26:49 -0700985 traceBeginAndSlog("PinnerService");
986 mSystemServiceManager.startService(PinnerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700987 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800988 } catch (RuntimeException e) {
Dianne Hackborn661cd522011-08-22 00:26:20 -0700989 Slog.e("System", "******************************************");
990 Slog.e("System", "************ Failure starting core service", e);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800991 }
992
Joe Onorato089de882010-04-12 08:18:45 -0700993 StatusBarManagerService statusBar = null;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -0800994 INotificationManager notification = null;
Mike Lockwood46db5042010-02-22 16:36:44 -0500995 LocationManagerService location = null;
Bai Taoa58a8752010-07-13 15:32:16 +0800996 CountryDetectorService countryDetector = null;
Jim Miller4f93c582016-01-27 19:05:43 -0800997 ILockSettings lockSettings = null;
Jeff Brown69b07162013-11-07 00:30:16 -0800998 MediaRouterService mediaRouter = null;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800999
Dianne Hackborn661cd522011-08-22 00:26:20 -07001000 // Bring up services needed for UI.
Jeff Brown6f357d32014-01-15 20:40:55 -08001001 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001002 traceBeginAndSlog("StartInputMethodManagerLifecycle");
Fyodor Kupolov1e33dc82016-01-21 12:02:58 -08001003 mSystemServiceManager.startService(InputMethodManagerService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001004 traceEnd();
Dianne Hackborn661cd522011-08-22 00:26:20 -07001005
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +09001006 traceBeginAndSlog("StartAccessibilityManagerService");
dcashman4e3f5d32014-11-25 15:33:26 -08001007 try {
Rhed Jao8a39cef2018-07-18 11:43:33 +08001008 mSystemServiceManager.startService(ACCESSIBILITY_MANAGER_SERVICE_CLASS);
dcashman4e3f5d32014-11-25 15:33:26 -08001009 } catch (Throwable e) {
1010 reportWtf("starting Accessibility Manager", e);
Dianne Hackborn661cd522011-08-22 00:26:20 -07001011 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001012 traceEnd();
Dianne Hackborn661cd522011-08-22 00:26:20 -07001013 }
1014
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001015 traceBeginAndSlog("MakeDisplayReady");
Dianne Hackborn661cd522011-08-22 00:26:20 -07001016 try {
1017 wm.displayReady();
1018 } catch (Throwable e) {
1019 reportWtf("making display ready", e);
1020 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001021 traceEnd();
Dianne Hackborn8795b602011-08-25 13:30:53 -07001022
Jeff Brown6f357d32014-01-15 20:40:55 -08001023 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001024 if (!"0".equals(SystemProperties.get("system_init.startmountservice"))) {
Sudheer Shanka2250d562016-11-07 15:41:02 -08001025 traceBeginAndSlog("StartStorageManagerService");
Kenny Root51a573c2012-05-17 13:30:28 -07001026 try {
1027 /*
Sudheer Shanka2250d562016-11-07 15:41:02 -08001028 * NotificationManagerService is dependant on StorageManagerService,
1029 * (for media / usb notifications) so we must start StorageManagerService first.
Kenny Root51a573c2012-05-17 13:30:28 -07001030 */
Sudheer Shanka2250d562016-11-07 15:41:02 -08001031 mSystemServiceManager.startService(STORAGE_MANAGER_SERVICE_CLASS);
1032 storageManager = IStorageManager.Stub.asInterface(
Jeff Sharkey56e62932015-03-21 20:41:00 -07001033 ServiceManager.getService("mount"));
Kenny Root51a573c2012-05-17 13:30:28 -07001034 } catch (Throwable e) {
Jeff Sharkeye8cece92017-01-04 11:33:33 -07001035 reportWtf("starting StorageManagerService", e);
1036 }
1037 traceEnd();
1038
1039 traceBeginAndSlog("StartStorageStatsService");
1040 try {
1041 mSystemServiceManager.startService(STORAGE_STATS_SERVICE_CLASS);
1042 } catch (Throwable e) {
1043 reportWtf("starting StorageStatsService", e);
Kenny Root51a573c2012-05-17 13:30:28 -07001044 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001045 traceEnd();
Kenny Root51a573c2012-05-17 13:30:28 -07001046 }
padarshrada45412014-11-05 16:54:50 +05301047 }
Kenny Root51a573c2012-05-17 13:30:28 -07001048
Adam Lesinski05199e82015-03-19 14:37:11 -07001049 // We start this here so that we update our configuration to set watch or television
1050 // as appropriate.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001051 traceBeginAndSlog("StartUiModeManager");
Adam Lesinski05199e82015-03-19 14:37:11 -07001052 mSystemServiceManager.startService(UiModeManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001053 traceEnd();
Adam Lesinski05199e82015-03-19 14:37:11 -07001054
David Brazdil89c80bb2016-06-02 15:31:30 +01001055 if (!mOnlyCore) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001056 traceBeginAndSlog("UpdatePackagesIfNeeded");
David Brazdil89c80bb2016-06-02 15:31:30 +01001057 try {
1058 mPackageManagerService.updatePackagesIfNeeded();
1059 } catch (Throwable e) {
1060 reportWtf("update packages", e);
1061 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001062 traceEnd();
David Brazdilf5c444f2016-03-30 11:45:52 +01001063 }
David Brazdilf5c444f2016-03-30 11:45:52 +01001064
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001065 traceBeginAndSlog("PerformFstrimIfNeeded");
padarshrada45412014-11-05 16:54:50 +05301066 try {
Nicolas Geoffray27c07372015-11-05 16:54:09 +00001067 mPackageManagerService.performFstrimIfNeeded();
padarshrada45412014-11-05 16:54:50 +05301068 } catch (Throwable e) {
Nicolas Geoffray27c07372015-11-05 16:54:09 +00001069 reportWtf("performing fstrim", e);
padarshrada45412014-11-05 16:54:50 +05301070 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001071 traceEnd();
padarshrada45412014-11-05 16:54:50 +05301072
padarshrada45412014-11-05 16:54:50 +05301073 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001074 traceBeginAndSlog("StartLockSettingsService");
1075 try {
1076 mSystemServiceManager.startService(LOCK_SETTINGS_SERVICE_CLASS);
1077 lockSettings = ILockSettings.Stub.asInterface(
1078 ServiceManager.getService("lock_settings"));
1079 } catch (Throwable e) {
1080 reportWtf("starting LockSettingsService service", e);
1081 }
1082 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001083
Narayan Kamath1c888f62017-10-30 14:35:15 +00001084 final boolean hasPdb = !SystemProperties.get(PERSISTENT_DATA_BLOCK_PROP).equals("");
1085 if (hasPdb) {
1086 traceBeginAndSlog("StartPersistentDataBlock");
1087 mSystemServiceManager.startService(PersistentDataBlockService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001088 traceEnd();
Amith Yamasani52c489c2012-03-28 11:42:42 -07001089 }
1090
Narayan Kamath1c888f62017-10-30 14:35:15 +00001091 if (hasPdb || OemLockService.isHalPresent()) {
1092 // Implementation depends on pdb or the OemLock HAL
1093 traceBeginAndSlog("StartOemLockService");
1094 mSystemServiceManager.startService(OemLockService.class);
1095 traceEnd();
1096 }
1097
1098 traceBeginAndSlog("StartDeviceIdleController");
1099 mSystemServiceManager.startService(DeviceIdleController.class);
1100 traceEnd();
1101
1102 // Always start the Device Policy Manager, so that the API is compatible with
1103 // API8.
1104 traceBeginAndSlog("StartDevicePolicyManager");
1105 mSystemServiceManager.startService(DevicePolicyManagerService.Lifecycle.class);
1106 traceEnd();
1107
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001108 if (!isWatch) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001109 traceBeginAndSlog("StartStatusBarManagerService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001110 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001111 statusBar = new StatusBarManagerService(context, wm);
1112 ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
1113 } catch (Throwable e) {
1114 reportWtf("starting StatusBarManagerService", e);
1115 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001116 traceEnd();
Dianne Hackbornd6847842010-01-12 18:14:19 -08001117 }
1118
Narayan Kamath1c888f62017-10-30 14:35:15 +00001119 traceBeginAndSlog("StartClipboardService");
1120 mSystemServiceManager.startService(ClipboardService.class);
1121 traceEnd();
1122
1123 traceBeginAndSlog("StartNetworkManagementService");
1124 try {
1125 networkManagement = NetworkManagementService.create(context);
1126 ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
1127 } catch (Throwable e) {
1128 reportWtf("starting NetworkManagement Service", e);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001129 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001130 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001131
Narayan Kamath1c888f62017-10-30 14:35:15 +00001132 traceBeginAndSlog("StartIpSecService");
1133 try {
1134 ipSecService = IpSecService.create(context);
1135 ServiceManager.addService(Context.IPSEC_SERVICE, ipSecService);
1136 } catch (Throwable e) {
1137 reportWtf("starting IpSec Service", e);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001138 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001139 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001140
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001141 traceBeginAndSlog("StartTextServicesManager");
1142 mSystemServiceManager.startService(TextServicesManagerService.Lifecycle.class);
1143 traceEnd();
San Mehatd1df8ac2010-01-26 06:17:26 -08001144
Abodunrinwa Tokid32906c2018-01-18 04:34:44 -08001145 if (!disableSystemTextClassifier) {
1146 traceBeginAndSlog("StartTextClassificationManagerService");
1147 mSystemServiceManager.startService(TextClassificationManagerService.Lifecycle.class);
1148 traceEnd();
1149 }
1150
Narayan Kamath1c888f62017-10-30 14:35:15 +00001151 traceBeginAndSlog("StartNetworkScoreService");
Mehdi Alizadehce2d9632018-03-28 17:34:24 -07001152 mSystemServiceManager.startService(NetworkScoreService.Lifecycle.class);
Narayan Kamath1c888f62017-10-30 14:35:15 +00001153 traceEnd();
vandwalle7c3606c2014-03-31 19:12:07 -07001154
Narayan Kamath1c888f62017-10-30 14:35:15 +00001155 traceBeginAndSlog("StartNetworkStatsService");
1156 try {
1157 networkStats = NetworkStatsService.create(context, networkManagement);
1158 ServiceManager.addService(Context.NETWORK_STATS_SERVICE, networkStats);
1159 } catch (Throwable e) {
1160 reportWtf("starting NetworkStats Service", e);
1161 }
1162 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001163
Narayan Kamath1c888f62017-10-30 14:35:15 +00001164 traceBeginAndSlog("StartNetworkPolicyManagerService");
1165 try {
Jeff Sharkeye0c29952018-02-20 17:24:55 -07001166 networkPolicy = new NetworkPolicyManagerService(context, mActivityManagerService,
1167 networkManagement);
Narayan Kamath1c888f62017-10-30 14:35:15 +00001168 ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy);
1169 } catch (Throwable e) {
1170 reportWtf("starting NetworkPolicy Service", e);
1171 }
1172 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001173
Paul Lawrence54271902018-04-13 12:31:22 -07001174 if (!mOnlyCore) {
1175 if (context.getPackageManager().hasSystemFeature(
1176 PackageManager.FEATURE_WIFI)) {
1177 // Wifi Service must be started first for wifi-related services.
1178 traceBeginAndSlog("StartWifi");
1179 mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
1180 traceEnd();
1181 traceBeginAndSlog("StartWifiScanning");
1182 mSystemServiceManager.startService(
1183 "com.android.server.wifi.scanner.WifiScanningService");
1184 traceEnd();
1185 }
Rebecca Silberstein9e40b802017-01-07 01:59:16 -08001186
Paul Lawrence54271902018-04-13 12:31:22 -07001187 if (context.getPackageManager().hasSystemFeature(
1188 PackageManager.FEATURE_WIFI_RTT)) {
1189 traceBeginAndSlog("StartRttService");
1190 mSystemServiceManager.startService(
1191 "com.android.server.wifi.rtt.RttService");
1192 traceEnd();
1193 }
Wei Liu4e62ac52016-05-23 15:12:49 -07001194
Paul Lawrence54271902018-04-13 12:31:22 -07001195 if (context.getPackageManager().hasSystemFeature(
1196 PackageManager.FEATURE_WIFI_AWARE)) {
1197 traceBeginAndSlog("StartWifiAware");
1198 mSystemServiceManager.startService(WIFI_AWARE_SERVICE_CLASS);
1199 traceEnd();
1200 }
Vinit Deshpandec4272f32014-07-25 17:46:14 -07001201
Paul Lawrence54271902018-04-13 12:31:22 -07001202 if (context.getPackageManager().hasSystemFeature(
1203 PackageManager.FEATURE_WIFI_DIRECT)) {
1204 traceBeginAndSlog("StartWifiP2P");
1205 mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS);
1206 traceEnd();
1207 }
Robert Quattlebaum87a71042017-05-15 15:45:20 -07001208
Paul Lawrence54271902018-04-13 12:31:22 -07001209 if (context.getPackageManager().hasSystemFeature(
1210 PackageManager.FEATURE_LOWPAN)) {
1211 traceBeginAndSlog("StartLowpan");
1212 mSystemServiceManager.startService(LOWPAN_SERVICE_CLASS);
1213 traceEnd();
1214 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001215 }
Lorenzo Colittif9ff2c92014-05-21 16:32:11 -07001216
Narayan Kamath1c888f62017-10-30 14:35:15 +00001217 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_ETHERNET) ||
1218 mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {
1219 traceBeginAndSlog("StartEthernet");
1220 mSystemServiceManager.startService(ETHERNET_SERVICE_CLASS);
1221 traceEnd();
1222 }
1223
1224 traceBeginAndSlog("StartConnectivityService");
1225 try {
1226 connectivity = new ConnectivityService(
1227 context, networkManagement, networkStats, networkPolicy);
1228 ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity,
Vishnu Nair5c010902017-10-26 10:08:50 -07001229 /* allowIsolated= */ false,
Narayan Kamath1c888f62017-10-30 14:35:15 +00001230 DUMP_FLAG_PRIORITY_HIGH | DUMP_FLAG_PRIORITY_NORMAL);
1231 networkStats.bindConnectivityManager(connectivity);
1232 networkPolicy.bindConnectivityManager(connectivity);
1233 } catch (Throwable e) {
1234 reportWtf("starting Connectivity Service", e);
satok988323c2011-06-22 16:38:13 +09001235 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001236 traceEnd();
satok988323c2011-06-22 16:38:13 +09001237
Narayan Kamath1c888f62017-10-30 14:35:15 +00001238 traceBeginAndSlog("StartNsdService");
1239 try {
1240 serviceDiscovery = NsdService.create(context);
1241 ServiceManager.addService(
1242 Context.NSD_SERVICE, serviceDiscovery);
1243 } catch (Throwable e) {
1244 reportWtf("starting Service Discovery Service", e);
Christopher Tate8662cab52012-02-23 14:59:36 -08001245 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001246 traceEnd();
1247
Tao Bao07342dc2017-01-24 15:08:21 -08001248 traceBeginAndSlog("StartSystemUpdateManagerService");
1249 try {
1250 ServiceManager.addService(Context.SYSTEM_UPDATE_SERVICE,
1251 new SystemUpdateManagerService(context));
1252 } catch (Throwable e) {
1253 reportWtf("starting SystemUpdateManagerService", e);
1254 }
1255 traceEnd();
1256
Narayan Kamath1c888f62017-10-30 14:35:15 +00001257 traceBeginAndSlog("StartUpdateLockService");
1258 try {
1259 ServiceManager.addService(Context.UPDATE_LOCK_SERVICE,
1260 new UpdateLockService(context));
1261 } catch (Throwable e) {
1262 reportWtf("starting UpdateLockService", e);
1263 }
1264 traceEnd();
Christopher Tate8662cab52012-02-23 14:59:36 -08001265
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001266 traceBeginAndSlog("StartNotificationManager");
Jeff Brown6f357d32014-01-15 20:40:55 -08001267 mSystemServiceManager.startService(NotificationManagerService.class);
Geoffrey Pitschaf759c52017-02-15 09:35:38 -05001268 SystemNotificationChannels.createAll(context);
Adam Lesinskief2ea1f2013-12-05 16:48:06 -08001269 notification = INotificationManager.Stub.asInterface(
1270 ServiceManager.getService(Context.NOTIFICATION_SERVICE));
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001271 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001272
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001273 traceBeginAndSlog("StartDeviceMonitor");
Jeff Brown6f357d32014-01-15 20:40:55 -08001274 mSystemServiceManager.startService(DeviceStorageMonitorService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001275 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001276
Narayan Kamath1c888f62017-10-30 14:35:15 +00001277 traceBeginAndSlog("StartLocationManagerService");
1278 try {
1279 location = new LocationManagerService(context);
1280 ServiceManager.addService(Context.LOCATION_SERVICE, location);
1281 } catch (Throwable e) {
1282 reportWtf("starting Location Manager", e);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001283 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001284 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001285
Narayan Kamath1c888f62017-10-30 14:35:15 +00001286 traceBeginAndSlog("StartCountryDetectorService");
1287 try {
1288 countryDetector = new CountryDetectorService(context);
1289 ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
1290 } catch (Throwable e) {
1291 reportWtf("starting Country Detector", e);
1292 }
1293 traceEnd();
1294
Neil Fuller0e44c662018-06-21 15:16:36 +01001295 final boolean useNewTimeServices = true;
1296 if (useNewTimeServices) {
1297 traceBeginAndSlog("StartTimeDetectorService");
1298 try {
1299 mSystemServiceManager.startService(TIME_DETECTOR_SERVICE_CLASS);
1300 } catch (Throwable e) {
1301 reportWtf("starting StartTimeDetectorService service", e);
1302 }
1303 traceEnd();
Neil Fullerfeeee682018-05-30 14:35:24 +01001304
Neil Fuller0e44c662018-06-21 15:16:36 +01001305 traceBeginAndSlog("StartTimeZoneDetectorService");
1306 try {
1307 mSystemServiceManager.startService(TIME_ZONE_DETECTOR_SERVICE_CLASS);
1308 } catch (Throwable e) {
1309 reportWtf("starting StartTimeZoneDetectorService service", e);
1310 }
1311 traceEnd();
Neil Fuller7fb88c32018-06-19 12:53:47 +01001312 }
Neil Fuller7fb88c32018-06-19 12:53:47 +01001313
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001314 if (!isWatch) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001315 traceBeginAndSlog("StartSearchManagerService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001316 try {
Jeff Sharkey4175be22016-01-09 14:57:45 -07001317 mSystemServiceManager.startService(SEARCH_MANAGER_SERVICE_CLASS);
Dan Morrille4d9a012013-03-28 18:10:43 -07001318 } catch (Throwable e) {
1319 reportWtf("starting Search Service", e);
1320 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001321 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001322 }
1323
Narayan Kamath1c888f62017-10-30 14:35:15 +00001324 if (context.getResources().getBoolean(R.bool.config_enableWallpaperService)) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001325 traceBeginAndSlog("StartWallpaperManagerService");
Jeff Sharkey1cab76a2016-04-12 18:23:31 -06001326 mSystemServiceManager.startService(WALLPAPER_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001327 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001328 }
1329
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +09001330 traceBeginAndSlog("StartAudioService");
Makoto Onukie1aef852015-10-15 17:28:35 -07001331 mSystemServiceManager.startService(AudioService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001332 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001333
Tomasz Wasilczyk05392d62017-07-10 19:33:22 -07001334 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BROADCAST_RADIO)) {
1335 traceBeginAndSlog("StartBroadcastRadioService");
Tomasz Wasilczyk6b4b6462017-07-19 10:52:28 -07001336 mSystemServiceManager.startService(BroadcastRadioService.class);
Tomasz Wasilczyk347192e2017-04-04 11:13:44 -07001337 traceEnd();
1338 }
1339
Narayan Kamath1c888f62017-10-30 14:35:15 +00001340 traceBeginAndSlog("StartDockObserver");
1341 mSystemServiceManager.startService(DockObserver.class);
1342 traceEnd();
Bryce Leebc58f592015-09-25 16:43:01 -07001343
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001344 if (isWatch) {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001345 traceBeginAndSlog("StartThermalObserver");
1346 mSystemServiceManager.startService(THERMAL_OBSERVER_CLASS);
1347 traceEnd();
Dan Murphyc9f4eaf2009-08-12 15:15:43 -05001348 }
1349
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +09001350 traceBeginAndSlog("StartWiredAccessoryManager");
John Spurlockb4f01b92015-03-24 12:40:15 -04001351 try {
John Spurlockb4f01b92015-03-24 12:40:15 -04001352 // Listen for wired headset changes
1353 inputManager.setWiredAccessoryCallbacks(
1354 new WiredAccessoryManager(context, inputManager));
1355 } catch (Throwable e) {
1356 reportWtf("starting WiredAccessoryManager", e);
Praveen Bharathi21e941b2010-10-06 15:23:14 -05001357 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001358 traceEnd();
Praveen Bharathi21e941b2010-10-06 15:23:14 -05001359
Narayan Kamath1c888f62017-10-30 14:35:15 +00001360 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_MIDI)) {
1361 // Start MIDI Manager service
1362 traceBeginAndSlog("StartMidiManager");
1363 mSystemServiceManager.startService(MIDI_SERVICE_CLASS);
1364 traceEnd();
1365 }
Mike Lockwood5781cd52015-03-27 13:23:41 -07001366
Narayan Kamath1c888f62017-10-30 14:35:15 +00001367 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)
1368 || mPackageManager.hasSystemFeature(
Yahan Zhou25d49462017-03-15 16:04:58 -07001369 PackageManager.FEATURE_USB_ACCESSORY)
1370 || isEmulator) {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001371 // Manage USB host and device support
1372 traceBeginAndSlog("StartUsbService");
1373 mSystemServiceManager.startService(USB_SERVICE_CLASS);
1374 traceEnd();
1375 }
Mike Lockwood57c798a2010-06-23 17:36:36 -04001376
Kenny Rootf74bfde2018-01-18 15:42:48 -08001377 // Start ADB Debugging Service
1378 traceBeginAndSlog("StartAdbService");
1379 try {
1380 mSystemServiceManager.startService(ADB_SERVICE_CLASS);
1381 } catch (Throwable e) {
1382 Slog.e(TAG, "Failure starting AdbService");
1383 }
1384 traceEnd();
1385
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001386 if (!isWatch) {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001387 traceBeginAndSlog("StartSerialService");
Polina Bondarenkof8754ac2016-02-12 20:38:23 +01001388 try {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001389 // Serial port support
1390 serial = new SerialService(context);
1391 ServiceManager.addService(Context.SERIAL_SERVICE, serial);
Polina Bondarenkof8754ac2016-02-12 20:38:23 +01001392 } catch (Throwable e) {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001393 Slog.e(TAG, "Failure starting SerialService", e);
Polina Bondarenkof8754ac2016-02-12 20:38:23 +01001394 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001395 traceEnd();
Mike Lockwoodb01e8bf2011-08-29 20:11:07 -04001396 }
1397
Narayan Kamath1c888f62017-10-30 14:35:15 +00001398 traceBeginAndSlog("StartHardwarePropertiesManagerService");
1399 try {
1400 hardwarePropertiesService = new HardwarePropertiesManagerService(context);
1401 ServiceManager.addService(Context.HARDWARE_PROPERTIES_SERVICE,
1402 hardwarePropertiesService);
1403 } catch (Throwable e) {
1404 Slog.e(TAG, "Failure starting HardwarePropertiesManagerService", e);
1405 }
1406 traceEnd();
1407
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001408 traceBeginAndSlog("StartTwilightService");
Jeff Brown6f357d32014-01-15 20:40:55 -08001409 mSystemServiceManager.startService(TwilightService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001410 traceEnd();
Jeff Brown2416e092012-08-21 22:12:20 -07001411
Christine Franks5397f032017-11-01 18:35:16 -07001412 if (ColorDisplayController.isAvailable(context)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001413 traceBeginAndSlog("StartNightDisplay");
Christine Franks5397f032017-11-01 18:35:16 -07001414 mSystemServiceManager.startService(ColorDisplayService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001415 traceEnd();
Justin Klaassen911e8892016-06-21 18:24:24 -07001416 }
1417
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001418 traceBeginAndSlog("StartJobScheduler");
Christopher Tate7060b042014-06-09 19:50:00 -07001419 mSystemServiceManager.startService(JobSchedulerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001420 traceEnd();
Christopher Tatefa380e92014-05-19 13:46:29 -07001421
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001422 traceBeginAndSlog("StartSoundTrigger");
Arunesh Mishraa772e5f2016-01-25 10:33:11 -08001423 mSystemServiceManager.startService(SoundTriggerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001424 traceEnd();
Arunesh Mishraa772e5f2016-01-25 10:33:11 -08001425
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001426 traceBeginAndSlog("StartTrustManager");
1427 mSystemServiceManager.startService(TrustManagerService.class);
1428 traceEnd();
Jaikumar Ganesh7d0548d2010-10-18 15:29:09 -07001429
Narayan Kamath1c888f62017-10-30 14:35:15 +00001430 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BACKUP)) {
1431 traceBeginAndSlog("StartBackupManager");
1432 mSystemServiceManager.startService(BACKUP_MANAGER_SERVICE_CLASS);
1433 traceEnd();
1434 }
1435
1436 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS)
1437 || context.getResources().getBoolean(R.bool.config_enableAppWidgetService)) {
Ng Zhi Anda44a062018-05-09 22:34:53 -07001438 traceBeginAndSlog("StartAppWidgetService");
Narayan Kamath1c888f62017-10-30 14:35:15 +00001439 mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS);
1440 traceEnd();
1441 }
1442
1443 // We need to always start this service, regardless of whether the
1444 // FEATURE_VOICE_RECOGNIZERS feature is set, because it needs to take care
1445 // of initializing various settings. It will internally modify its behavior
1446 // based on that feature.
1447 traceBeginAndSlog("StartVoiceRecognitionManager");
1448 mSystemServiceManager.startService(VOICE_RECOGNITION_MANAGER_SERVICE_CLASS);
1449 traceEnd();
1450
1451 if (GestureLauncherService.isGestureLauncherEnabled(context.getResources())) {
1452 traceBeginAndSlog("StartGestureLauncher");
1453 mSystemServiceManager.startService(GestureLauncherService.class);
1454 traceEnd();
1455 }
1456 traceBeginAndSlog("StartSensorNotification");
1457 mSystemServiceManager.startService(SensorNotificationService.class);
1458 traceEnd();
1459
1460 traceBeginAndSlog("StartContextHubSystemService");
1461 mSystemServiceManager.startService(ContextHubSystemService.class);
1462 traceEnd();
1463
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001464 traceBeginAndSlog("StartDiskStatsService");
Nick Pelly038cabe2010-09-23 16:12:11 -07001465 try {
Dan Egnor621bc542010-03-25 16:20:14 -07001466 ServiceManager.addService("diskstats", new DiskStatsService(context));
1467 } catch (Throwable e) {
Dianne Hackborn661cd522011-08-22 00:26:20 -07001468 reportWtf("starting DiskStats Service", e);
Dan Egnor621bc542010-03-25 16:20:14 -07001469 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001470 traceEnd();
Sen Hubde75702010-05-28 01:54:03 -07001471
Neil Fullercd1a1092017-09-13 21:59:59 +01001472 // timezone.RulesManagerService will prevent a device starting up if the chain of trust
1473 // required for safe time zone updates might be broken. RuleManagerService cannot do
1474 // this check when mOnlyCore == true, so we don't enable the service in this case.
1475 // This service requires that JobSchedulerService is already started when it starts.
1476 final boolean startRulesManagerService =
1477 !mOnlyCore && context.getResources().getBoolean(
1478 R.bool.config_enableUpdateableTimeZoneRules);
1479 if (startRulesManagerService) {
1480 traceBeginAndSlog("StartTimeZoneRulesManagerService");
1481 mSystemServiceManager.startService(TIME_ZONE_RULES_MANAGER_SERVICE_CLASS);
1482 traceEnd();
1483 }
1484
Steve Paik117fcb02018-09-13 09:43:54 -07001485 if (!isWatch && !disableNetworkTime) {
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001486 traceBeginAndSlog("StartNetworkTimeUpdateService");
1487 try {
Neil Fuller0e44c662018-06-21 15:16:36 +01001488 if (useNewTimeServices) {
1489 networkTimeUpdater = new NewNetworkTimeUpdateService(context);
1490 } else {
1491 networkTimeUpdater = new OldNetworkTimeUpdateService(context);
1492 }
1493 Slog.d(TAG, "Using networkTimeUpdater class=" + networkTimeUpdater.getClass());
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001494 ServiceManager.addService("network_time_update_service", networkTimeUpdater);
1495 } catch (Throwable e) {
1496 reportWtf("starting NetworkTimeUpdate service", e);
1497 }
1498 traceEnd();
Amith Yamasani6734b9f2010-09-13 16:24:08 -07001499 }
John Grossmanc1576732012-02-01 15:23:33 -08001500
Narayan Kamath1c888f62017-10-30 14:35:15 +00001501 traceBeginAndSlog("CertBlacklister");
1502 try {
1503 CertBlacklister blacklister = new CertBlacklister(context);
1504 } catch (Throwable e) {
1505 reportWtf("starting CertBlacklister", e);
Geremy Condra3d33c262012-05-06 18:32:19 -07001506 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001507 traceEnd();
Jim Miller5ecd8112013-01-09 18:50:26 -08001508
Narayan Kamath1c888f62017-10-30 14:35:15 +00001509 if (EmergencyAffordanceManager.ENABLED) {
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001510 // EmergencyMode service
1511 traceBeginAndSlog("StartEmergencyAffordanceService");
Selim Cinek705442f2016-09-13 16:02:33 -07001512 mSystemServiceManager.startService(EmergencyAffordanceService.class);
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001513 traceEnd();
Selim Cinek705442f2016-09-13 16:02:33 -07001514 }
1515
Narayan Kamath1c888f62017-10-30 14:35:15 +00001516 // Dreams (interactive idle-time views, a/k/a screen savers, and doze mode)
1517 traceBeginAndSlog("StartDreamManager");
1518 mSystemServiceManager.startService(DreamManagerService.class);
1519 traceEnd();
Svetoslavb3038ec2013-02-13 14:39:30 -08001520
Narayan Kamath1c888f62017-10-30 14:35:15 +00001521 traceBeginAndSlog("AddGraphicsStatsService");
1522 ServiceManager.addService(GraphicsStatsService.GRAPHICS_STATS_SERVICE,
1523 new GraphicsStatsService(context));
1524 traceEnd();
John Reckedc524c2015-03-18 15:24:33 -07001525
Narayan Kamath1c888f62017-10-30 14:35:15 +00001526 if (CoverageService.ENABLED) {
Allen Hair1f556e32016-11-11 15:42:50 -08001527 traceBeginAndSlog("AddCoverageService");
1528 ServiceManager.addService(CoverageService.COVERAGE_SERVICE, new CoverageService());
1529 traceEnd();
1530 }
1531
Jeff Brown2c43c332014-06-12 22:38:59 -07001532 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PRINTING)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001533 traceBeginAndSlog("StartPrintManager");
Jeff Brown2c43c332014-06-12 22:38:59 -07001534 mSystemServiceManager.startService(PRINT_MANAGER_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001535 traceEnd();
Svetoslav Ganov4b9a4d12013-06-11 15:20:06 -07001536 }
Jeff Brown69b07162013-11-07 00:30:16 -08001537
Eugene Susla7c3eef22017-03-10 14:25:58 -08001538 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_COMPANION_DEVICE_SETUP)) {
1539 traceBeginAndSlog("StartCompanionDeviceManager");
1540 mSystemServiceManager.startService(COMPANION_DEVICE_MANAGER_SERVICE_CLASS);
1541 traceEnd();
1542 }
Eugene Susla6ed45d82017-01-22 13:52:51 -08001543
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001544 traceBeginAndSlog("StartRestrictionManager");
Jeff Brown2c43c332014-06-12 22:38:59 -07001545 mSystemServiceManager.startService(RestrictionsManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001546 traceEnd();
Amith Yamasanif20d6402014-05-24 15:34:37 -07001547
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001548 traceBeginAndSlog("StartMediaSessionService");
Jeff Brown2c43c332014-06-12 22:38:59 -07001549 mSystemServiceManager.startService(MediaSessionService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001550 traceEnd();
RoboErik01fe6612014-02-13 14:19:04 -08001551
Dongwon Kang569da9f2017-11-06 09:53:52 -08001552 traceBeginAndSlog("StartMediaUpdateService");
1553 mSystemServiceManager.startService(MediaUpdateService.class);
1554 traceEnd();
1555
Yuncheol Heoa0c4a062014-07-10 20:49:27 +09001556 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_HDMI_CEC)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001557 traceBeginAndSlog("StartHdmiControlService");
Yuncheol Heoa0c4a062014-07-10 20:49:27 +09001558 mSystemServiceManager.startService(HdmiControlService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001559 traceEnd();
Yuncheol Heoa0c4a062014-07-10 20:49:27 +09001560 }
Jungshik Jang0792d372014-04-23 17:57:26 +09001561
Conrad Chen558acf92017-04-05 17:31:01 -07001562 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LIVE_TV)
1563 || mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001564 traceBeginAndSlog("StartTvInputManager");
Dongwon Kang0fdcb742014-07-24 16:28:35 +09001565 mSystemServiceManager.startService(TvInputManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001566 traceEnd();
Dongwon Kang0fdcb742014-07-24 16:28:35 +09001567 }
Jae Seo39570912014-02-20 18:23:25 -08001568
Dongwon Kangd8b81b32016-03-23 18:04:19 -07001569 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001570 traceBeginAndSlog("StartMediaResourceMonitor");
Dongwon Kangd8b81b32016-03-23 18:04:19 -07001571 mSystemServiceManager.startService(MediaResourceMonitorService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001572 traceEnd();
Dongwon Kangd8b81b32016-03-23 18:04:19 -07001573 }
Dongwon Kang2034a4c2015-12-14 21:57:34 +09001574
Sujith Ramakrishnanb5b86c12016-01-28 16:53:16 -08001575 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001576 traceBeginAndSlog("StartTvRemoteService");
Sujith Ramakrishnanb5b86c12016-01-28 16:53:16 -08001577 mSystemServiceManager.startService(TvRemoteService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001578 traceEnd();
Sujith Ramakrishnanb5b86c12016-01-28 16:53:16 -08001579 }
1580
Narayan Kamath1c888f62017-10-30 14:35:15 +00001581 traceBeginAndSlog("StartMediaRouterService");
1582 try {
1583 mediaRouter = new MediaRouterService(context);
1584 ServiceManager.addService(Context.MEDIA_ROUTER_SERVICE, mediaRouter);
1585 } catch (Throwable e) {
1586 reportWtf("starting MediaRouterService", e);
1587 }
1588 traceEnd();
Adrian Roos82142c22014-03-27 14:56:59 +01001589
Kevin Chyna24e9fd2018-08-27 12:39:17 -07001590 final boolean hasFeatureFace
1591 = mPackageManager.hasSystemFeature(PackageManager.FEATURE_FACE);
1592 final boolean hasFeatureFingerprint
1593 = mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT);
1594
1595 if (hasFeatureFace) {
Gilad Brettercb51b8b2018-03-22 17:04:51 +02001596 traceBeginAndSlog("StartFaceSensor");
1597 mSystemServiceManager.startService(FaceService.class);
1598 traceEnd();
1599 }
1600
Kevin Chyna24e9fd2018-08-27 12:39:17 -07001601 if (hasFeatureFingerprint) {
Narayan Kamath1c888f62017-10-30 14:35:15 +00001602 traceBeginAndSlog("StartFingerprintSensor");
1603 mSystemServiceManager.startService(FingerprintService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001604 traceEnd();
Jeff Brown69b07162013-11-07 00:30:16 -08001605 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001606
Kevin Chyna24e9fd2018-08-27 12:39:17 -07001607 if (hasFeatureFace || hasFeatureFingerprint) {
1608 // Start this service after all biometric services.
1609 traceBeginAndSlog("StartBiometricPromptService");
Kevin Chyn352adfe2018-09-20 22:28:50 -07001610 mSystemServiceManager.startService(BiometricService.class);
Kevin Chyna24e9fd2018-08-27 12:39:17 -07001611 traceEnd();
1612 }
1613
Narayan Kamath1c888f62017-10-30 14:35:15 +00001614 traceBeginAndSlog("StartBackgroundDexOptService");
1615 try {
1616 BackgroundDexOptService.schedule(context);
1617 } catch (Throwable e) {
1618 reportWtf("starting StartBackgroundDexOptService", e);
1619 }
1620 traceEnd();
1621
Michael Kwan7f70fc72018-07-20 16:12:19 -07001622 if (!isWatch) {
1623 traceBeginAndSlog("StartPruneInstantAppsJobService");
1624 try {
1625 PruneInstantAppsJobService.schedule(context);
1626 } catch (Throwable e) {
1627 reportWtf("StartPruneInstantAppsJobService", e);
1628 }
1629 traceEnd();
Narayan Kamath1c888f62017-10-30 14:35:15 +00001630 }
Narayan Kamath1c888f62017-10-30 14:35:15 +00001631
Makoto Onuki55046222016-03-08 10:49:47 -08001632 // LauncherAppsService uses ShortcutService.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001633 traceBeginAndSlog("StartShortcutServiceLifecycle");
Makoto Onuki55046222016-03-08 10:49:47 -08001634 mSystemServiceManager.startService(ShortcutService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001635 traceEnd();
Amith Yamasani4f582632014-02-19 14:31:52 -08001636
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001637 traceBeginAndSlog("StartLauncherAppsService");
Jeff Brown2c43c332014-06-12 22:38:59 -07001638 mSystemServiceManager.startService(LauncherAppsService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001639 traceEnd();
Tony Mak1b708e62017-10-12 10:59:11 +01001640
1641 traceBeginAndSlog("StartCrossProfileAppsService");
1642 mSystemServiceManager.startService(CrossProfileAppsService.class);
1643 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001644 }
1645
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001646 if (!isWatch) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001647 traceBeginAndSlog("StartMediaProjectionManager");
Michael Wrightc39d47a2014-07-08 18:07:36 -07001648 mSystemServiceManager.startService(MediaProjectionManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001649 traceEnd();
Michael Wrightc39d47a2014-07-08 18:07:36 -07001650 }
1651
Erik Wolsheimer640734f2018-01-29 13:57:44 -08001652 if (isWatch) {
Damien Bargiacchiae4cb672018-05-30 13:28:15 -07001653 // Must be started before services that depend it, e.g. WearConnectivityService
1654 traceBeginAndSlog("StartWearPowerService");
1655 mSystemServiceManager.startService(WEAR_POWER_SERVICE_CLASS);
1656 traceEnd();
1657
Calvin Ona91e5362017-02-22 15:16:42 -08001658 traceBeginAndSlog("StartWearConnectivityService");
Calvin On5555bcc2017-02-21 16:41:43 -08001659 mSystemServiceManager.startService(WEAR_CONNECTIVITY_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001660 traceEnd();
Zach Johnsonb82f3b02017-01-16 15:15:25 -08001661
Damien Bargiacchiae4cb672018-05-30 13:28:15 -07001662 traceBeginAndSlog("StartWearDisplayService");
Narayan Kamath1c888f62017-10-30 14:35:15 +00001663 mSystemServiceManager.startService(WEAR_DISPLAY_SERVICE_CLASS);
Damien Bargiacchiae4cb672018-05-30 13:28:15 -07001664 traceEnd();
1665
1666 traceBeginAndSlog("StartWearTimeService");
Narayan Kamath1c888f62017-10-30 14:35:15 +00001667 mSystemServiceManager.startService(WEAR_TIME_SERVICE_CLASS);
1668 traceEnd();
Ivan Podogovf9973822017-05-11 15:51:34 +01001669
Narayan Kamath1c888f62017-10-30 14:35:15 +00001670 if (enableLeftyService) {
1671 traceBeginAndSlog("StartWearLeftyService");
1672 mSystemServiceManager.startService(WEAR_LEFTY_SERVICE_CLASS);
1673 traceEnd();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001674 }
Michael Kwan01ad0aa2018-02-28 15:19:04 -08001675
1676 traceBeginAndSlog("StartWearGlobalActionsService");
1677 mSystemServiceManager.startService(WEAR_GLOBAL_ACTIONS_SERVICE_CLASS);
1678 traceEnd();
Wei Liu48d3b632016-03-29 15:26:48 -07001679 }
1680
Jason Monk8f5f7ff2017-10-17 14:12:42 -04001681 if (!disableSlices) {
1682 traceBeginAndSlog("StartSliceManagerService");
1683 mSystemServiceManager.startService(SLICE_MANAGER_SERVICE_CLASS);
1684 traceEnd();
1685 }
1686
Eino-Ville Talvalae91012b2017-07-10 15:27:24 -07001687 if (!disableCameraService) {
1688 traceBeginAndSlog("StartCameraServiceProxy");
1689 mSystemServiceManager.startService(CameraServiceProxy.class);
1690 traceEnd();
1691 }
1692
Nick Felker1bfe59d2017-10-12 13:27:02 -07001693 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_EMBEDDED)) {
1694 traceBeginAndSlog("StartIoTSystemService");
1695 mSystemServiceManager.startService(IOT_SERVICE_CLASS);
1696 traceEnd();
1697 }
1698
Max Biresffac7722017-10-23 22:59:10 +00001699 // Statsd helper
1700 traceBeginAndSlog("StartStatsCompanionService");
1701 mSystemServiceManager.startService(StatsCompanionService.Lifecycle.class);
1702 traceEnd();
1703
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001704 // Before things start rolling, be sure we have decided whether
1705 // we are in safe mode.
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001706 final boolean safeMode = wm.detectSafeMode();
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001707 if (safeMode) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001708 traceBeginAndSlog("EnterSafeModeAndDisableJitCompilation");
Jeff Brown4ccb8232014-01-16 22:16:42 -08001709 mActivityManagerService.enterSafeMode();
Jeff Brownb09abc12011-01-13 21:08:27 -08001710 // Disable the JIT for the system_server process
1711 VMRuntime.getRuntime().disableJitCompilation();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001712 traceEnd();
Ben Cheng6c0afff2010-02-14 16:18:56 -08001713 } else {
1714 // Enable the JIT for the system_server process
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001715 traceBeginAndSlog("StartJitCompilation");
Ben Cheng6c0afff2010-02-14 16:18:56 -08001716 VMRuntime.getRuntime().startJitCompilation();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001717 traceEnd();
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001718 }
Doug Zongkerab5c49c2009-12-04 10:31:43 -08001719
Ye Wend97e1fd2014-07-24 12:56:45 -07001720 // MMS service broker
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001721 traceBeginAndSlog("StartMmsService");
Ye Wend97e1fd2014-07-24 12:56:45 -07001722 mmsService = mSystemServiceManager.startService(MmsServiceBroker.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001723 traceEnd();
Ye Wend97e1fd2014-07-24 12:56:45 -07001724
Svet Ganov43574b02017-04-12 09:25:20 -07001725 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOFILL)) {
1726 traceBeginAndSlog("StartAutoFillService");
1727 mSystemServiceManager.startService(AUTO_FILL_MANAGER_SERVICE_CLASS);
1728 traceEnd();
1729 }
Felipe Leme5381aa42016-10-13 09:02:32 -07001730
Makoto Onukidf7e4812018-09-24 14:31:25 -07001731 traceBeginAndSlog("AppServiceManager");
1732 mSystemServiceManager.startService(AppBindingService.Lifecycle.class);
1733 traceEnd();
1734
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001735 // It is now time to start up the app processes...
Joe Onorato30275482009-07-08 17:09:14 -07001736
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001737 traceBeginAndSlog("MakeVibratorServiceReady");
Jeff Brown7f6c2312012-04-13 20:38:38 -07001738 try {
1739 vibrator.systemReady();
1740 } catch (Throwable e) {
1741 reportWtf("making Vibrator Service ready", e);
1742 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001743 traceEnd();
Jeff Brown7f6c2312012-04-13 20:38:38 -07001744
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001745 traceBeginAndSlog("MakeLockSettingsServiceReady");
Dan Morrille4d9a012013-03-28 18:10:43 -07001746 if (lockSettings != null) {
1747 try {
1748 lockSettings.systemReady();
1749 } catch (Throwable e) {
1750 reportWtf("making Lock Settings Service ready", e);
1751 }
Felipe Ramosf35df5b2012-09-18 18:26:27 -03001752 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001753 traceEnd();
Felipe Ramosf35df5b2012-09-18 18:26:27 -03001754
Amith Yamasani817ec492013-12-20 13:27:30 -08001755 // Needed by DevicePolicyManager for initialization
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001756 traceBeginAndSlog("StartBootPhaseLockSettingsReady");
Jeff Brown6f357d32014-01-15 20:40:55 -08001757 mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001758 traceEnd();
Dianne Hackbornd6847842010-01-12 18:14:19 -08001759
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001760 traceBeginAndSlog("StartBootPhaseSystemServicesReady");
Jeff Brown6f357d32014-01-15 20:40:55 -08001761 mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001762 traceEnd();
Joe Onorato30275482009-07-08 17:09:14 -07001763
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001764 traceBeginAndSlog("MakeWindowManagerServiceReady");
Dianne Hackborn661cd522011-08-22 00:26:20 -07001765 try {
1766 wm.systemReady();
1767 } catch (Throwable e) {
1768 reportWtf("making Window Manager Service ready", e);
1769 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001770 traceEnd();
Joe Onoratodc565f42010-10-04 15:27:22 -04001771
Jeff Brownb09abc12011-01-13 21:08:27 -08001772 if (safeMode) {
Jeff Brown4ccb8232014-01-16 22:16:42 -08001773 mActivityManagerService.showSafeModeOverlay();
Jeff Brownb09abc12011-01-13 21:08:27 -08001774 }
1775
Joe Onoratodc565f42010-10-04 15:27:22 -04001776 // Update the configuration for this context by hand, because we're going
1777 // to start using it before the config change done in wm.systemReady() will
1778 // propagate to it.
Andrii Kulian5406e7a2016-10-21 11:55:23 -07001779 final Configuration config = wm.computeNewConfiguration(DEFAULT_DISPLAY);
Joe Onoratodc565f42010-10-04 15:27:22 -04001780 DisplayMetrics metrics = new DisplayMetrics();
1781 WindowManager w = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
1782 w.getDefaultDisplay().getMetrics(metrics);
1783 context.getResources().updateConfiguration(config, metrics);
1784
Alan Viverette395cd012015-08-11 17:27:04 -04001785 // The system context's theme may be configuration-dependent.
1786 final Theme systemTheme = context.getTheme();
1787 if (systemTheme.getChangingConfigurations() != 0) {
1788 systemTheme.rebase();
1789 }
1790
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001791 traceBeginAndSlog("MakePowerManagerServiceReady");
Jeff Brownaa202a62012-08-21 22:14:26 -07001792 try {
Jeff Brown6f357d32014-01-15 20:40:55 -08001793 // TODO: use boot phase
Jeff Brown21392762014-06-13 19:00:36 -07001794 mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
Jeff Brownaa202a62012-08-21 22:14:26 -07001795 } catch (Throwable e) {
1796 reportWtf("making Power Manager Service ready", e);
1797 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001798 traceEnd();
Jeff Brownaa202a62012-08-21 22:14:26 -07001799
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001800 traceBeginAndSlog("MakePackageManagerServiceReady");
Fyodor Kupolovc56106a2017-10-06 17:02:21 -07001801 mPackageManagerService.systemReady();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001802 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001803
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001804 traceBeginAndSlog("MakeDisplayManagerServiceReady");
Jeff Brownbd6e1502012-08-28 03:27:37 -07001805 try {
Jeff Brown4ccb8232014-01-16 22:16:42 -08001806 // TODO: use boot phase and communicate these flags some other way
Jeff Brown2c43c332014-06-12 22:38:59 -07001807 mDisplayManagerService.systemReady(safeMode, mOnlyCore);
Jeff Brownbd6e1502012-08-28 03:27:37 -07001808 } catch (Throwable e) {
1809 reportWtf("making Display Manager Service ready", e);
1810 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001811 traceEnd();
Jeff Brownbd6e1502012-08-28 03:27:37 -07001812
joonyoung.cho2f30cc12015-04-08 13:56:34 +09001813 mSystemServiceManager.setSafeMode(safeMode);
1814
Daichi Hironoedfcb002017-10-10 17:22:58 +09001815 // Start device specific services
1816 traceBeginAndSlog("StartDeviceSpecificServices");
1817 final String[] classes = mSystemContext.getResources().getStringArray(
1818 R.array.config_deviceSpecificSystemServices);
1819 for (final String className : classes) {
1820 traceBeginAndSlog("StartDeviceSpecificServices " + className);
1821 try {
1822 mSystemServiceManager.startService(className);
1823 } catch (Throwable e) {
1824 reportWtf("starting " + className, e);
1825 }
1826 traceEnd();
1827 }
1828 traceEnd();
1829
1830 traceBeginAndSlog("StartBootPhaseDeviceSpecificServicesReady");
1831 mSystemServiceManager.startBootPhase(SystemService.PHASE_DEVICE_SPECIFIC_SERVICES_READY);
1832 traceEnd();
1833
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001834 // These are needed to propagate to the runnable below.
Jeff Sharkey350083e2011-06-29 10:45:16 -07001835 final NetworkManagementService networkManagementF = networkManagement;
Jeff Sharkey75279902011-05-24 18:39:45 -07001836 final NetworkStatsService networkStatsF = networkStats;
Jeff Sharkeya4620792011-05-20 15:29:23 -07001837 final NetworkPolicyManagerService networkPolicyF = networkPolicy;
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001838 final ConnectivityService connectivityF = connectivity;
Mike Lockwood46db5042010-02-22 16:36:44 -05001839 final LocationManagerService locationF = location;
Bai Taoa58a8752010-07-13 15:32:16 +08001840 final CountryDetectorService countryDetectorF = countryDetector;
Amith Yamasani6734b9f2010-09-13 16:24:08 -07001841 final NetworkTimeUpdateService networkTimeUpdaterF = networkTimeUpdater;
Jeff Brown6ec6f792012-04-17 16:52:41 -07001842 final InputManagerService inputManagerF = inputManager;
Wink Savillea12a7b32012-09-20 10:09:45 -07001843 final TelephonyRegistry telephonyRegistryF = telephonyRegistry;
Jeff Brown69b07162013-11-07 00:30:16 -08001844 final MediaRouterService mediaRouterF = mediaRouter;
Ye Wend97e1fd2014-07-24 12:56:45 -07001845 final MmsServiceBroker mmsServiceF = mmsService;
Nathan Haroldb7282172017-09-11 19:50:19 -07001846 final IpSecService ipSecServiceF = ipSecService;
Keun-young Park4136d2d2017-05-08 14:51:59 -07001847 final WindowManagerService windowManagerF = wm;
Doug Zongkerab5c49c2009-12-04 10:31:43 -08001848
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001849 // We now tell the activity manager it is okay to run third party
1850 // code. It will call back into us once it has gotten to the state
1851 // where third party code can really run (but before it has actually
1852 // started launching the initial applications), for us to complete our
1853 // initialization.
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001854 mActivityManagerService.systemReady(() -> {
1855 Slog.i(TAG, "Making services ready");
1856 traceBeginAndSlog("StartActivityManagerReadyPhase");
1857 mSystemServiceManager.startBootPhase(
1858 SystemService.PHASE_ACTIVITY_MANAGER_READY);
1859 traceEnd();
1860 traceBeginAndSlog("StartObservingNativeCrashes");
1861 try {
1862 mActivityManagerService.startObservingNativeCrashes();
1863 } catch (Throwable e) {
1864 reportWtf("observing native crashes", e);
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001865 }
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001866 traceEnd();
1867
Keun-young Parkd80e8942017-01-27 11:30:19 -08001868 // No dependency on Webview preparation in system server. But this should
Torne (Richard Coles)ff937ac2017-10-02 17:09:32 -04001869 // be completed before allowing 3rd party
Keun-young Parkd80e8942017-01-27 11:30:19 -08001870 final String WEBVIEW_PREPARATION = "WebViewFactoryPreparation";
1871 Future<?> webviewPrep = null;
Torne (Richard Coles)ff937ac2017-10-02 17:09:32 -04001872 if (!mOnlyCore && mWebViewUpdateService != null) {
Keun-young Parkd80e8942017-01-27 11:30:19 -08001873 webviewPrep = SystemServerInitThreadPool.get().submit(() -> {
1874 Slog.i(TAG, WEBVIEW_PREPARATION);
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -07001875 TimingsTraceLog traceLog = new TimingsTraceLog(
Keun-young Park9b73a542017-02-01 12:09:58 -08001876 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
Keun-young Parkd80e8942017-01-27 11:30:19 -08001877 traceLog.traceBegin(WEBVIEW_PREPARATION);
Narayan Kamath97780462017-02-06 20:24:08 +00001878 ConcurrentUtils.waitForFutureNoInterrupt(mZygotePreload, "Zygote preload");
1879 mZygotePreload = null;
Keun-young Parkd80e8942017-01-27 11:30:19 -08001880 mWebViewUpdateService.prepareWebViewInSystemServer();
1881 traceLog.traceEnd();
1882 }, WEBVIEW_PREPARATION);
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001883 }
1884
Keun-young Park067cf3e2017-06-05 12:20:41 -07001885 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
1886 traceBeginAndSlog("StartCarServiceHelperService");
Steve Paik94292a32018-01-26 17:16:53 -08001887 mSystemServiceManager.startService(CAR_SERVICE_HELPER_SERVICE_CLASS);
Keun-young Park067cf3e2017-06-05 12:20:41 -07001888 traceEnd();
1889 }
1890
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001891 traceBeginAndSlog("StartSystemUI");
1892 try {
Keun-young Park4136d2d2017-05-08 14:51:59 -07001893 startSystemUi(context, windowManagerF);
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001894 } catch (Throwable e) {
1895 reportWtf("starting System UI", e);
1896 }
1897 traceEnd();
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001898 traceBeginAndSlog("MakeNetworkManagementServiceReady");
1899 try {
1900 if (networkManagementF != null) networkManagementF.systemReady();
1901 } catch (Throwable e) {
1902 reportWtf("making Network Managment Service ready", e);
1903 }
1904 CountDownLatch networkPolicyInitReadySignal = null;
1905 if (networkPolicyF != null) {
1906 networkPolicyInitReadySignal = networkPolicyF
1907 .networkScoreAndNetworkManagementServiceReady();
1908 }
1909 traceEnd();
Nathan Haroldb7282172017-09-11 19:50:19 -07001910 traceBeginAndSlog("MakeIpSecServiceReady");
1911 try {
1912 if (ipSecServiceF != null) ipSecServiceF.systemReady();
1913 } catch (Throwable e) {
1914 reportWtf("making IpSec Service ready", e);
1915 }
1916 traceEnd();
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001917 traceBeginAndSlog("MakeNetworkStatsServiceReady");
1918 try {
1919 if (networkStatsF != null) networkStatsF.systemReady();
1920 } catch (Throwable e) {
1921 reportWtf("making Network Stats Service ready", e);
1922 }
1923 traceEnd();
1924 traceBeginAndSlog("MakeConnectivityServiceReady");
1925 try {
1926 if (connectivityF != null) connectivityF.systemReady();
1927 } catch (Throwable e) {
1928 reportWtf("making Connectivity Service ready", e);
1929 }
1930 traceEnd();
1931 traceBeginAndSlog("MakeNetworkPolicyServiceReady");
1932 try {
1933 if (networkPolicyF != null) {
1934 networkPolicyF.systemReady(networkPolicyInitReadySignal);
1935 }
1936 } catch (Throwable e) {
1937 reportWtf("making Network Policy Service ready", e);
1938 }
1939 traceEnd();
1940
1941 traceBeginAndSlog("StartWatchdog");
1942 Watchdog.getInstance().start();
1943 traceEnd();
1944
Fyodor Kupolovcd824ef2017-02-07 11:25:14 -08001945 // Wait for all packages to be prepared
1946 mPackageManagerService.waitForAppDataPrepared();
1947
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001948 // It is now okay to let the various system services start their
1949 // third party code...
1950 traceBeginAndSlog("PhaseThirdPartyAppsCanStart");
Keun-young Park9b73a542017-02-01 12:09:58 -08001951 // confirm webview completion before starting 3rd party
1952 if (webviewPrep != null) {
1953 ConcurrentUtils.waitForFutureNoInterrupt(webviewPrep, WEBVIEW_PREPARATION);
1954 }
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001955 mSystemServiceManager.startBootPhase(
1956 SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
1957 traceEnd();
1958
1959 traceBeginAndSlog("MakeLocationServiceReady");
1960 try {
1961 if (locationF != null) locationF.systemRunning();
1962 } catch (Throwable e) {
1963 reportWtf("Notifying Location Service running", e);
1964 }
1965 traceEnd();
1966 traceBeginAndSlog("MakeCountryDetectionServiceReady");
1967 try {
1968 if (countryDetectorF != null) countryDetectorF.systemRunning();
1969 } catch (Throwable e) {
1970 reportWtf("Notifying CountryDetectorService running", e);
1971 }
1972 traceEnd();
1973 traceBeginAndSlog("MakeNetworkTimeUpdateReady");
1974 try {
1975 if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
1976 } catch (Throwable e) {
1977 reportWtf("Notifying NetworkTimeService running", e);
1978 }
1979 traceEnd();
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001980 traceBeginAndSlog("MakeInputManagerServiceReady");
1981 try {
1982 // TODO(BT) Pass parameter to input manager
1983 if (inputManagerF != null) inputManagerF.systemRunning();
1984 } catch (Throwable e) {
1985 reportWtf("Notifying InputManagerService running", e);
1986 }
1987 traceEnd();
1988 traceBeginAndSlog("MakeTelephonyRegistryReady");
1989 try {
1990 if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();
1991 } catch (Throwable e) {
1992 reportWtf("Notifying TelephonyRegistry running", e);
1993 }
1994 traceEnd();
1995 traceBeginAndSlog("MakeMediaRouterServiceReady");
1996 try {
1997 if (mediaRouterF != null) mediaRouterF.systemRunning();
1998 } catch (Throwable e) {
1999 reportWtf("Notifying MediaRouterService running", e);
2000 }
2001 traceEnd();
2002 traceBeginAndSlog("MakeMmsServiceReady");
2003 try {
2004 if (mmsServiceF != null) mmsServiceF.systemRunning();
2005 } catch (Throwable e) {
2006 reportWtf("Notifying MmsService running", e);
2007 }
2008 traceEnd();
2009
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08002010 traceBeginAndSlog("IncidentDaemonReady");
2011 try {
2012 // TODO: Switch from checkService to getService once it's always
2013 // in the build and should reliably be there.
2014 final IIncidentManager incident = IIncidentManager.Stub.asInterface(
Yi Jinf32af482017-08-11 15:00:49 -07002015 ServiceManager.getService(Context.INCIDENT_SERVICE));
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08002016 if (incident != null) incident.systemRunning();
2017 } catch (Throwable e) {
2018 reportWtf("Notifying incident daemon running", e);
2019 }
2020 traceEnd();
2021 }, BOOT_TIMINGS_TRACE_LOG);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08002022 }
Joe Onoratof3c3c4f2010-10-21 11:09:02 -04002023
Keun-young Park4136d2d2017-05-08 14:51:59 -07002024 static final void startSystemUi(Context context, WindowManagerService windowManager) {
Joe Onoratof3c3c4f2010-10-21 11:09:02 -04002025 Intent intent = new Intent();
2026 intent.setComponent(new ComponentName("com.android.systemui",
2027 "com.android.systemui.SystemUIService"));
Jeff Sharkey2f3e3532015-12-21 14:16:43 -07002028 intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
Dianne Hackborn40e9f292012-11-27 19:12:23 -08002029 //Slog.d(TAG, "Starting service: " + intent);
Xiaohui Chen70f6c382015-04-28 14:21:43 -07002030 context.startServiceAsUser(intent, UserHandle.SYSTEM);
Keun-young Park4136d2d2017-05-08 14:51:59 -07002031 windowManager.onSystemUiStarted();
Joe Onoratof3c3c4f2010-10-21 11:09:02 -04002032 }
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09002033
2034 private static void traceBeginAndSlog(String name) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09002035 Slog.i(TAG, name);
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -08002036 BOOT_TIMINGS_TRACE_LOG.traceBegin(name);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07002037 }
2038
2039 private static void traceEnd() {
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -08002040 BOOT_TIMINGS_TRACE_LOG.traceEnd();
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09002041 }
Nicolas Geoffray27c07372015-11-05 16:54:09 +00002042}