blob: 221b9b4c815edaa57dd1e439762449eac46d75c0 [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;
Matthew Xie1dd01eb32013-04-26 12:37:54 -070026import android.content.pm.PackageManager;
Joe Onoratodc565f42010-10-04 15:27:22 -040027import android.content.res.Configuration;
Alan Viverettee54d2452015-05-06 10:41:43 -070028import android.content.res.Resources.Theme;
Jeff Sharkeyd136e512016-03-09 22:30:56 -070029import android.os.BaseBundle;
Jeff Sharkey0a17db12016-11-04 11:23:46 -060030import android.os.Binder;
Jeff Sharkey55687722014-04-09 18:07:19 -070031import android.os.Build;
Jeff Sharkey48749fc2013-04-19 13:25:04 -070032import android.os.Environment;
Jeff Brown6f357d32014-01-15 20:40:55 -080033import android.os.FactoryTest;
Tao Bao4fd6c262016-01-19 14:22:24 -080034import android.os.FileUtils;
Joe Onorato1754d742016-11-21 17:51:35 -080035import android.os.IIncidentManager;
Jeff Hamilton35eef702010-06-09 15:45:18 -050036import android.os.Looper;
Alison Cichowlasf0afd8c2017-07-31 11:24:34 -040037import android.os.Message;
Tao Bao4fd6c262016-01-19 14:22:24 -080038import android.os.PowerManager;
Narayan Kamath97780462017-02-06 20:24:08 +000039import android.os.Process;
Jeff Hamilton35eef702010-06-09 15:45:18 -050040import android.os.RemoteException;
41import android.os.ServiceManager;
Brad Fitzpatrickc74a1b442010-09-10 16:03:29 -070042import android.os.StrictMode;
Jeff Hamilton35eef702010-06-09 15:45:18 -050043import android.os.SystemClock;
44import android.os.SystemProperties;
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +090045import android.os.Trace;
Amith Yamasanicd757062012-10-19 18:23:52 -070046import android.os.UserHandle;
Sudheer Shanka2250d562016-11-07 15:41:02 -080047import android.os.storage.IStorageManager;
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -070048import android.util.TimingsTraceLog;
Joe Onoratodc565f42010-10-04 15:27:22 -040049import android.util.DisplayMetrics;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080050import android.util.EventLog;
Joe Onorato8a9b2202010-02-26 18:56:32 -080051import android.util.Slog;
Brad Fitzpatrick5fdc0c72010-10-12 13:12:18 -070052import android.view.WindowManager;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -080053
Dan Morrille4d9a012013-03-28 18:10:43 -070054import com.android.internal.R;
Justin Klaassen911e8892016-06-21 18:24:24 -070055import com.android.internal.app.NightDisplayController;
Fyodor Kupolov8d3e82b2016-11-10 17:58:50 -080056import com.android.internal.logging.MetricsLogger;
Geoffrey Pitschaf759c52017-02-15 09:35:38 -050057import com.android.internal.notification.SystemNotificationChannels;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -070058import com.android.internal.os.BinderInternal;
Jason Monk361915c2017-03-21 20:33:59 -040059import com.android.internal.util.EmergencyAffordanceManager;
Keun-young Parkd80e8942017-01-27 11:30:19 -080060import com.android.internal.util.ConcurrentUtils;
Jeff Sharkeyd136e512016-03-09 22:30:56 -070061import com.android.internal.widget.ILockSettings;
Adam Lesinski6c6cd502014-03-17 12:54:03 -070062import com.android.server.accessibility.AccessibilityManagerService;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -070063import com.android.server.am.ActivityManagerService;
John Spurlock61560172015-02-06 19:46:04 -050064import com.android.server.audio.AudioService;
Wei Wanged7f5482017-02-21 11:35:10 -080065import com.android.server.camera.CameraServiceProxy;
Keun-young Park067cf3e2017-06-05 12:20:41 -070066import com.android.server.car.CarServiceHelperService;
Amith Yamasani30f8eb42013-11-06 14:54:50 -080067import com.android.server.clipboard.ClipboardService;
Hugo Benichieab511b2016-09-09 09:23:47 +090068import com.android.server.connectivity.IpConnectivityMetrics;
Allen Hair1f556e32016-11-11 15:42:50 -080069import com.android.server.coverage.CoverageService;
Adam Lesinski2c8d67c2014-04-23 13:46:21 -070070import com.android.server.devicepolicy.DevicePolicyManagerService;
Jeff Brownfa25bf52012-07-23 19:26:30 -070071import com.android.server.display.DisplayManagerService;
Justin Klaassen911e8892016-06-21 18:24:24 -070072import com.android.server.display.NightDisplayService;
Jeff Browncef440f2012-09-25 18:58:48 -070073import com.android.server.dreams.DreamManagerService;
Selim Cinek705442f2016-09-13 16:02:33 -070074import com.android.server.emergency.EmergencyAffordanceService;
Jim Millera75961472014-06-06 15:00:49 -070075import com.android.server.fingerprint.FingerprintService;
Jungshik Jang0792d372014-04-23 17:57:26 +090076import com.android.server.hdmi.HdmiControlService;
Jeff Brown6ec6f792012-04-17 16:52:41 -070077import com.android.server.input.InputManagerService;
Christopher Tate7060b042014-06-09 19:50:00 -070078import com.android.server.job.JobSchedulerService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -080079import com.android.server.lights.LightsService;
Jeff Sharkeyd136e512016-03-09 22:30:56 -070080import com.android.server.media.MediaResourceMonitorService;
Jeff Brown69b07162013-11-07 00:30:16 -080081import com.android.server.media.MediaRouterService;
RoboErik01fe6612014-02-13 14:19:04 -080082import com.android.server.media.MediaSessionService;
Michael Wrightc39d47a2014-07-08 18:07:36 -070083import com.android.server.media.projection.MediaProjectionManagerService;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -070084import com.android.server.net.NetworkPolicyManagerService;
Jeff Sharkey75279902011-05-24 18:39:45 -070085import com.android.server.net.NetworkStatsService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -080086import com.android.server.notification.NotificationManagerService;
Andrew Scull5d7027d2017-04-12 11:46:27 +010087import com.android.server.oemlock.OemLockService;
MÃ¥rten Kongstad2e0d0f32016-06-02 09:35:31 +020088import com.android.server.om.OverlayManagerService;
Svet Ganov37e43272016-09-09 16:01:32 -070089import com.android.server.os.DeviceIdentifiersPolicyService;
Jeff Sharkey7a96c392012-11-15 14:01:46 -080090import com.android.server.os.SchedulingPolicyService;
Calin Juravle91d40f12017-03-15 18:38:57 -070091import com.android.server.pm.BackgroundDexOptService;
Jeff Brownf69c8122012-09-12 17:00:34 -070092import com.android.server.pm.Installer;
Amith Yamasani4f582632014-02-19 14:31:52 -080093import com.android.server.pm.LauncherAppsService;
Andreas Gampea8908752015-11-10 08:58:14 -080094import com.android.server.pm.OtaDexoptService;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -070095import com.android.server.pm.PackageManagerService;
Makoto Onuki6f7362d92016-03-04 13:39:41 -080096import com.android.server.pm.ShortcutService;
Amith Yamasani258848d2012-08-10 17:06:33 -070097import com.android.server.pm.UserManagerService;
Wale Ogunwaleb699ce02016-07-18 12:05:30 -070098import com.android.server.policy.PhoneWindowManager;
Jeff Brown4f8ecd82012-06-18 18:29:13 -070099import com.android.server.power.PowerManagerService;
100import com.android.server.power.ShutdownThread;
Tomasz Wasilczyk6b4b6462017-07-19 10:52:28 -0700101import com.android.server.broadcastradio.BroadcastRadioService;
Amith Yamasanif20d6402014-05-24 15:34:37 -0700102import com.android.server.restrictions.RestrictionsManagerService;
Janis Danisevskis8ff1e192016-06-03 11:31:55 -0700103import com.android.server.security.KeyAttestationApplicationIdProviderService;
Robin Lee13935492017-03-23 15:28:37 +0000104import com.android.server.security.KeyChainSystemService;
Arunesh Mishraa772e5f2016-01-25 10:33:11 -0800105import com.android.server.soundtrigger.SoundTriggerService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -0800106import com.android.server.statusbar.StatusBarManagerService;
107import com.android.server.storage.DeviceStorageMonitorService;
Santos Cordon5d2c1e62014-11-21 15:20:15 -0800108import com.android.server.telecom.TelecomLoaderService;
Adrian Roos82142c22014-03-27 14:56:59 +0100109import com.android.server.trust.TrustManagerService;
Jae Seo39570912014-02-20 18:23:25 -0800110import com.android.server.tv.TvInputManagerService;
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -0800111import com.android.server.tv.TvRemoteService;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -0800112import com.android.server.twilight.TwilightService;
Adam Lesinski0debc9a2014-07-16 19:09:13 -0700113import com.android.server.usage.UsageStatsService;
Ruben Brunkdd18a0b2015-12-04 16:16:31 -0800114import com.android.server.vr.VrManagerService;
Torne (Richard Coles)08cfaf62014-05-08 16:07:05 +0100115import com.android.server.webkit.WebViewUpdateService;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -0700116import com.android.server.wm.WindowManagerService;
117
118import dalvik.system.VMRuntime;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -0700119
Tao Bao4fd6c262016-01-19 14:22:24 -0800120import java.io.File;
121import java.io.IOException;
Narayan Kamathbf882052015-08-11 15:40:34 +0100122import java.util.Locale;
Bob Leee5408332009-09-04 18:31:17 -0700123import java.util.Timer;
Fyodor Kupolov311b9fa2016-12-02 16:24:35 -0800124import java.util.concurrent.CountDownLatch;
Keun-young Parkd80e8942017-01-27 11:30:19 -0800125import java.util.concurrent.Future;
Bob Leee5408332009-09-04 18:31:17 -0700126
Andrii Kulian5406e7a2016-10-21 11:55:23 -0700127import static android.view.Display.DEFAULT_DISPLAY;
128
Jeff Brown6f357d32014-01-15 20:40:55 -0800129public final class SystemServer {
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800130 private static final String TAG = "SystemServer";
Jeff Brown6f357d32014-01-15 20:40:55 -0800131
Keun-young Park9b73a542017-02-01 12:09:58 -0800132 // Tag for timing measurement of main thread.
133 private static final String SYSTEM_SERVER_TIMING_TAG = "SystemServerTiming";
134 // Tag for timing measurement of non-main asynchronous operations.
135 private static final String SYSTEM_SERVER_TIMING_ASYNC_TAG = SYSTEM_SERVER_TIMING_TAG + "Async";
136
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -0700137 private static final TimingsTraceLog BOOT_TIMINGS_TRACE_LOG
138 = new TimingsTraceLog(SYSTEM_SERVER_TIMING_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700139
Ben Komalo553acf02011-09-19 14:25:28 -0700140 private static final String ENCRYPTING_STATE = "trigger_restart_min_framework";
Ben Komalo3573d402011-09-23 15:08:24 -0700141 private static final String ENCRYPTED_STATE = "1";
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800142
Jeff Brown6f357d32014-01-15 20:40:55 -0800143 private static final long SNAPSHOT_INTERVAL = 60 * 60 * 1000; // 1hr
144
145 // The earliest supported time. We pick one day into 1970, to
146 // give any timezone code room without going into negative time.
147 private static final long EARLIEST_SUPPORTED_TIME = 86400 * 1000;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800148
Amith Yamasani817ec492013-12-20 13:27:30 -0800149 /*
150 * Implementation class names. TODO: Move them to a codegen class or load
151 * them from the build system somehow.
152 */
153 private static final String BACKUP_MANAGER_SERVICE_CLASS =
Jeff Brownb880d882014-02-10 19:47:07 -0800154 "com.android.server.backup.BackupManagerService$Lifecycle";
Amith Yamasani817ec492013-12-20 13:27:30 -0800155 private static final String APPWIDGET_SERVICE_CLASS =
156 "com.android.server.appwidget.AppWidgetService";
Dianne Hackborn91097de2014-04-04 18:02:06 -0700157 private static final String VOICE_RECOGNITION_MANAGER_SERVICE_CLASS =
158 "com.android.server.voiceinteraction.VoiceInteractionManagerService";
Amith Yamasani817ec492013-12-20 13:27:30 -0800159 private static final String PRINT_MANAGER_SERVICE_CLASS =
160 "com.android.server.print.PrintManagerService";
Eugene Susla6ed45d82017-01-22 13:52:51 -0800161 private static final String COMPANION_DEVICE_MANAGER_SERVICE_CLASS =
Eugene Susla0d3dd122017-04-18 10:56:37 -0700162 "com.android.server.companion.CompanionDeviceManagerService";
Adam Lesinski2cb6c602014-02-14 17:19:56 -0800163 private static final String USB_SERVICE_CLASS =
164 "com.android.server.usb.UsbService$Lifecycle";
Mike Lockwood5781cd52015-03-27 13:23:41 -0700165 private static final String MIDI_SERVICE_CLASS =
166 "com.android.server.midi.MidiService$Lifecycle";
Adam Lesinskif542a332014-02-19 12:29:58 -0800167 private static final String WIFI_SERVICE_CLASS =
168 "com.android.server.wifi.WifiService";
Etan Cohen04133272016-10-26 11:22:06 -0700169 private static final String WIFI_AWARE_SERVICE_CLASS =
170 "com.android.server.wifi.aware.WifiAwareService";
Adam Lesinskif542a332014-02-19 12:29:58 -0800171 private static final String WIFI_P2P_SERVICE_CLASS =
172 "com.android.server.wifi.p2p.WifiP2pService";
Robert Quattlebaum87a71042017-05-15 15:45:20 -0700173 private static final String LOWPAN_SERVICE_CLASS =
174 "com.android.server.lowpan.LowpanService";
Lorenzo Colittif9ff2c92014-05-21 16:32:11 -0700175 private static final String ETHERNET_SERVICE_CLASS =
176 "com.android.server.ethernet.EthernetService";
Christopher Tate7060b042014-06-09 19:50:00 -0700177 private static final String JOB_SCHEDULER_SERVICE_CLASS =
178 "com.android.server.job.JobSchedulerService";
Jim Miller4f93c582016-01-27 19:05:43 -0800179 private static final String LOCK_SETTINGS_SERVICE_CLASS =
Andrew Scull507d11c2017-05-03 17:19:01 +0100180 "com.android.server.locksettings.LockSettingsService$Lifecycle";
Sudheer Shanka2250d562016-11-07 15:41:02 -0800181 private static final String STORAGE_MANAGER_SERVICE_CLASS =
182 "com.android.server.StorageManagerService$Lifecycle";
Jeff Sharkeye8cece92017-01-04 11:33:33 -0700183 private static final String STORAGE_STATS_SERVICE_CLASS =
184 "com.android.server.usage.StorageStatsService$Lifecycle";
Jeff Sharkey4175be22016-01-09 14:57:45 -0700185 private static final String SEARCH_MANAGER_SERVICE_CLASS =
186 "com.android.server.search.SearchManagerService$Lifecycle";
Wei Liud699cf82016-03-25 16:32:10 -0700187 private static final String THERMAL_OBSERVER_CLASS =
188 "com.google.android.clockwork.ThermalObserver";
Calvin On5555bcc2017-02-21 16:41:43 -0800189 private static final String WEAR_CONNECTIVITY_SERVICE_CLASS =
190 "com.google.android.clockwork.connectivity.WearConnectivityService";
Julius D'souza069f46c2017-03-22 13:27:00 -0700191 private static final String WEAR_DISPLAY_SERVICE_CLASS =
192 "com.google.android.clockwork.display.WearDisplayService";
Ivan Podogovf9973822017-05-11 15:51:34 +0100193 private static final String WEAR_LEFTY_SERVICE_CLASS =
194 "com.google.android.clockwork.lefty.WearLeftyService";
Damien Bargiacchi2d92eeb2016-04-07 14:01:03 -0700195 private static final String WEAR_TIME_SERVICE_CLASS =
196 "com.google.android.clockwork.time.WearTimeService";
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600197 private static final String ACCOUNT_SERVICE_CLASS =
198 "com.android.server.accounts.AccountManagerService$Lifecycle";
Jeff Sharkeya3ebfec2016-04-04 08:58:04 -0600199 private static final String CONTENT_SERVICE_CLASS =
200 "com.android.server.content.ContentService$Lifecycle";
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600201 private static final String WALLPAPER_SERVICE_CLASS =
202 "com.android.server.wallpaper.WallpaperManagerService$Lifecycle";
Felipe Leme5381aa42016-10-13 09:02:32 -0700203 private static final String AUTO_FILL_MANAGER_SERVICE_CLASS =
Svet Ganov2f8fb1f2017-03-13 00:21:04 -0700204 "com.android.server.autofill.AutofillManagerService";
Neil Fuller328532a2017-03-16 18:32:21 +0000205 private static final String TIME_ZONE_RULES_MANAGER_SERVICE_CLASS =
206 "com.android.server.timezone.RulesManagerService$Lifecycle";
Jeff Sharkey4175be22016-01-09 14:57:45 -0700207
Andres Morales68d4acd2014-07-01 19:40:41 -0700208 private static final String PERSISTENT_DATA_BLOCK_PROP = "ro.frp.pst";
Amith Yamasani817ec492013-12-20 13:27:30 -0800209
Tao Bao4fd6c262016-01-19 14:22:24 -0800210 private static final String UNCRYPT_PACKAGE_FILE = "/cache/recovery/uncrypt_file";
211 private static final String BLOCK_MAP_FILE = "/cache/recovery/block.map";
212
Tim Murrayeef4a3d2016-04-19 14:14:20 -0700213 // maximum number of binder threads used for system_server
214 // will be higher than the system default
215 private static final int sMaxBinderThreads = 31;
216
Alan Viveretteba398ea2015-12-16 15:28:23 -0500217 /**
218 * Default theme used by the system context. This is used to style
219 * system-provided dialogs, such as the Power Off dialog, and other
220 * visual content.
221 */
222 private static final int DEFAULT_SYSTEM_THEME =
Michael Kwan9c7274c2016-06-13 12:48:55 -0700223 com.android.internal.R.style.Theme_DeviceDefault_System;
Alan Viveretteba398ea2015-12-16 15:28:23 -0500224
Jeff Brown6f357d32014-01-15 20:40:55 -0800225 private final int mFactoryTestMode;
226 private Timer mProfilerSnapshotTimer;
227
228 private Context mSystemContext;
229 private SystemServiceManager mSystemServiceManager;
230
Jeff Brown4ccb8232014-01-16 22:16:42 -0800231 // TODO: remove all of these references by improving dependency resolution and boot phases
Jeff Brown4ccb8232014-01-16 22:16:42 -0800232 private PowerManagerService mPowerManagerService;
233 private ActivityManagerService mActivityManagerService;
Gustav Sennton6258dcd2015-10-30 19:25:37 +0000234 private WebViewUpdateService mWebViewUpdateService;
Jeff Brown4ccb8232014-01-16 22:16:42 -0800235 private DisplayManagerService mDisplayManagerService;
Jeff Brown2c43c332014-06-12 22:38:59 -0700236 private PackageManagerService mPackageManagerService;
237 private PackageManager mPackageManager;
Jeff Brown6f357d32014-01-15 20:40:55 -0800238 private ContentResolver mContentResolver;
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600239 private EntropyMixer mEntropyMixer;
Jeff Brown6f357d32014-01-15 20:40:55 -0800240
Jeff Brown2c43c332014-06-12 22:38:59 -0700241 private boolean mOnlyCore;
242 private boolean mFirstBoot;
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800243 private final boolean mRuntimeRestart;
Jeff Brown2c43c332014-06-12 22:38:59 -0700244
Keun-young Park9b73a542017-02-01 12:09:58 -0800245 private static final String START_SENSOR_SERVICE = "StartSensorService";
Yifan Hong26b421f2017-03-10 13:41:11 -0800246 private static final String START_HIDL_SERVICES = "StartHidlServices";
247
248
Keun-young Park9b73a542017-02-01 12:09:58 -0800249 private Future<?> mSensorServiceStart;
Narayan Kamath97780462017-02-06 20:24:08 +0000250 private Future<?> mZygotePreload;
251
Jeff Brown6f357d32014-01-15 20:40:55 -0800252 /**
Keun-young Park9b73a542017-02-01 12:09:58 -0800253 * Start the sensor service. This is a blocking call and can take time.
Jeff Brown6f357d32014-01-15 20:40:55 -0800254 */
Svet Ganovb9d71a62015-04-30 10:38:13 -0700255 private static native void startSensorService();
Jeff Brown6f357d32014-01-15 20:40:55 -0800256
257 /**
Yifan Hong26b421f2017-03-10 13:41:11 -0800258 * Start all HIDL services that are run inside the system server. This
259 * may take some time.
260 */
261 private static native void startHidlServices();
262
263 /**
Jeff Brown6f357d32014-01-15 20:40:55 -0800264 * The main entry point from zygote.
265 */
266 public static void main(String[] args) {
267 new SystemServer().run();
268 }
269
270 public SystemServer() {
Jeff Brown2c43c332014-06-12 22:38:59 -0700271 // Check for factory test mode.
Jeff Brown6f357d32014-01-15 20:40:55 -0800272 mFactoryTestMode = FactoryTest.getMode();
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800273 // Remember if it's runtime restart(when sys.boot_completed is already set) or reboot
274 mRuntimeRestart = "1".equals(SystemProperties.get("sys.boot_completed"));
Jeff Brown6f357d32014-01-15 20:40:55 -0800275 }
276
277 private void run() {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900278 try {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700279 traceBeginAndSlog("InitBeforeStartServices");
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900280 // If a device's clock is before 1970 (before 0), a lot of
281 // APIs crash dealing with negative numbers, notably
282 // java.io.File#setLastModified, so instead we fake it and
283 // hope that time from cell towers or NTP fixes it shortly.
284 if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
285 Slog.w(TAG, "System clock is before 1970; setting to 1970.");
286 SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
287 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800288
Przemyslaw Szczepaniak20e02052017-03-22 15:13:17 +0000289 //
290 // Default the timezone property to GMT if not set.
291 //
292 String timezoneProperty = SystemProperties.get("persist.sys.timezone");
293 if (timezoneProperty == null || timezoneProperty.isEmpty()) {
294 Slog.w(TAG, "Timezone not set; setting to GMT.");
295 SystemProperties.set("persist.sys.timezone", "GMT");
296 }
297
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +0900298 // If the system has "persist.sys.language" and friends set, replace them with
299 // "persist.sys.locale". Note that the default locale at this point is calculated
300 // using the "-Duser.locale" command line flag. That flag is usually populated by
301 // AndroidRuntime using the same set of system properties, but only the system_server
302 // and system apps are allowed to set them.
303 //
304 // NOTE: Most changes made here will need an equivalent change to
305 // core/jni/AndroidRuntime.cpp
306 if (!SystemProperties.get("persist.sys.language").isEmpty()) {
307 final String languageTag = Locale.getDefault().toLanguageTag();
Narayan Kamathbf882052015-08-11 15:40:34 +0100308
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +0900309 SystemProperties.set("persist.sys.locale", languageTag);
310 SystemProperties.set("persist.sys.language", "");
311 SystemProperties.set("persist.sys.country", "");
312 SystemProperties.set("persist.sys.localevar", "");
313 }
Narayan Kamathbf882052015-08-11 15:40:34 +0100314
Jeff Sharkey0a17db12016-11-04 11:23:46 -0600315 // The system server should never make non-oneway calls
316 Binder.setWarnOnBlocking(true);
317
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900318 // Here we go!
319 Slog.i(TAG, "Entered the Android system server!");
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800320 int uptimeMillis = (int) SystemClock.elapsedRealtime();
Fyodor Kupolov8d3e82b2016-11-10 17:58:50 -0800321 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800322 if (!mRuntimeRestart) {
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800323 MetricsLogger.histogram(null, "boot_system_server_init", uptimeMillis);
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -0800324 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800325
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900326 // In case the runtime switched since last boot (such as when
327 // the old runtime was removed in an OTA), set the system
Eugene Suslaa38fbf62017-03-14 10:26:10 -0700328 // property so that it is in sync. We can | xq oqi't do this in
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900329 // libnativehelper's JniInvocation::Init code where we already
330 // had to fallback to a different runtime because it is
331 // running as root and we need to be the system user to set
332 // the property. http://b/11463182
333 SystemProperties.set("persist.sys.dalvik.vm.lib.2", VMRuntime.getRuntime().vmLibrary());
Jeff Brown6f357d32014-01-15 20:40:55 -0800334
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900335 // Mmmmmm... more memory!
336 VMRuntime.getRuntime().clearGrowthLimit();
Jeff Brown6f357d32014-01-15 20:40:55 -0800337
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900338 // The system server has to run all of the time, so it needs to be
339 // as efficient as possible with its memory usage.
340 VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
Jeff Brown6f357d32014-01-15 20:40:55 -0800341
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900342 // Some devices rely on runtime fingerprint generation, so make sure
343 // we've defined it before booting further.
344 Build.ensureFingerprintProperty();
Jeff Sharkey55687722014-04-09 18:07:19 -0700345
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900346 // Within the system server, it is an error to access Environment paths without
347 // explicitly specifying a user.
348 Environment.setUserRequired(true);
Jeff Brown6f357d32014-01-15 20:40:55 -0800349
Jeff Sharkeyd136e512016-03-09 22:30:56 -0700350 // Within the system server, any incoming Bundles should be defused
351 // to avoid throwing BadParcelableException.
352 BaseBundle.setShouldDefuse(true);
353
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900354 // Ensure binder calls into the system always run at foreground priority.
355 BinderInternal.disableBackgroundScheduling(true);
Jeff Brown6f357d32014-01-15 20:40:55 -0800356
Tim Murrayeef4a3d2016-04-19 14:14:20 -0700357 // Increase the number of binder threads in system_server
358 BinderInternal.setMaxThreads(sMaxBinderThreads);
359
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900360 // Prepare the main looper thread (this thread).
361 android.os.Process.setThreadPriority(
Jeff Brown6f357d32014-01-15 20:40:55 -0800362 android.os.Process.THREAD_PRIORITY_FOREGROUND);
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900363 android.os.Process.setCanSelfBackground(false);
364 Looper.prepareMainLooper();
Jeff Brown6f357d32014-01-15 20:40:55 -0800365
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900366 // Initialize native services.
367 System.loadLibrary("android_servers");
Jeff Brown6f357d32014-01-15 20:40:55 -0800368
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900369 // Check whether we failed to shut down last time we tried.
370 // This call may not return.
371 performPendingShutdown();
Jeff Brown6f357d32014-01-15 20:40:55 -0800372
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900373 // Initialize the system context.
374 createSystemContext();
Jeff Brown6f357d32014-01-15 20:40:55 -0800375
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900376 // Create the system service manager.
377 mSystemServiceManager = new SystemServiceManager(mSystemContext);
Fyodor Kupolov1d87e402017-01-10 18:34:10 -0800378 mSystemServiceManager.setRuntimeRestarted(mRuntimeRestart);
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900379 LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);
Fyodor Kupolove29a5a12016-12-16 16:14:17 -0800380 // Prepare the thread pool for init tasks that can be parallelized
381 SystemServerInitThreadPool.get();
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900382 } finally {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700383 traceEnd(); // InitBeforeStartServices
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900384 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800385
386 // Start services.
387 try {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700388 traceBeginAndSlog("StartServices");
Jeff Brown6f357d32014-01-15 20:40:55 -0800389 startBootstrapServices();
Jeff Brown4ccb8232014-01-16 22:16:42 -0800390 startCoreServices();
Jeff Brown6f357d32014-01-15 20:40:55 -0800391 startOtherServices();
Fyodor Kupolovcd824ef2017-02-07 11:25:14 -0800392 SystemServerInitThreadPool.shutdown();
Jeff Brown2c43c332014-06-12 22:38:59 -0700393 } catch (Throwable ex) {
Jeff Brown6f357d32014-01-15 20:40:55 -0800394 Slog.e("System", "******************************************");
395 Slog.e("System", "************ Failure starting system services", ex);
396 throw ex;
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900397 } finally {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700398 traceEnd();
Jeff Brown6f357d32014-01-15 20:40:55 -0800399 }
400
401 // For debug builds, log event loop stalls to dropbox for analysis.
402 if (StrictMode.conditionallyEnableDebugLogging()) {
403 Slog.i(TAG, "Enabled StrictMode for system server main thread.");
404 }
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800405 if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
Fyodor Kupolov24e12dc2017-01-17 12:20:36 -0800406 int uptimeMillis = (int) SystemClock.elapsedRealtime();
407 MetricsLogger.histogram(null, "boot_system_server_ready", uptimeMillis);
408 final int MAX_UPTIME_MILLIS = 60 * 1000;
409 if (uptimeMillis > MAX_UPTIME_MILLIS) {
Keun-young Park9b73a542017-02-01 12:09:58 -0800410 Slog.wtf(SYSTEM_SERVER_TIMING_TAG,
Fyodor Kupolov24e12dc2017-01-17 12:20:36 -0800411 "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
412 }
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800413 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800414
415 // Loop forever.
416 Looper.loop();
417 throw new RuntimeException("Main thread loop unexpectedly exited");
418 }
419
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800420 private boolean isFirstBootOrUpgrade() {
421 return mPackageManagerService.isFirstBoot() || mPackageManagerService.isUpgrade();
422 }
423
Jeff Brown6f357d32014-01-15 20:40:55 -0800424 private void reportWtf(String msg, Throwable e) {
Dianne Hackborn661cd522011-08-22 00:26:20 -0700425 Slog.w(TAG, "***********************************************");
Dianne Hackborn8d051722014-10-01 14:59:58 -0700426 Slog.wtf(TAG, "BOOT FAILURE " + msg, e);
Dianne Hackborn661cd522011-08-22 00:26:20 -0700427 }
428
Jeff Brown6f357d32014-01-15 20:40:55 -0800429 private void performPendingShutdown() {
430 final String shutdownAction = SystemProperties.get(
431 ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");
432 if (shutdownAction != null && shutdownAction.length() > 0) {
433 boolean reboot = (shutdownAction.charAt(0) == '1');
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800434
Jeff Brown6f357d32014-01-15 20:40:55 -0800435 final String reason;
436 if (shutdownAction.length() > 1) {
437 reason = shutdownAction.substring(1, shutdownAction.length());
438 } else {
439 reason = null;
Kenny Rootf547d672010-09-22 10:36:48 -0700440 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800441
Tao Bao4fd6c262016-01-19 14:22:24 -0800442 // If it's a pending reboot into recovery to apply an update,
443 // always make sure uncrypt gets executed properly when needed.
444 // If '/cache/recovery/block.map' hasn't been created, stop the
445 // reboot which will fail for sure, and get a chance to capture a
Tao Baoe8a403d2015-12-31 07:44:55 -0800446 // bugreport when that's still feasible. (Bug: 26444951)
Tianjie Xu3a66fc42017-06-09 15:50:14 -0700447 if (reason != null && reason.startsWith(PowerManager.REBOOT_RECOVERY_UPDATE)) {
Tao Bao4fd6c262016-01-19 14:22:24 -0800448 File packageFile = new File(UNCRYPT_PACKAGE_FILE);
449 if (packageFile.exists()) {
450 String filename = null;
451 try {
452 filename = FileUtils.readTextFile(packageFile, 0, null);
453 } catch (IOException e) {
454 Slog.e(TAG, "Error reading uncrypt package file", e);
455 }
456
457 if (filename != null && filename.startsWith("/data")) {
458 if (!new File(BLOCK_MAP_FILE).exists()) {
459 Slog.e(TAG, "Can't find block map file, uncrypt failed or " +
460 "unexpected runtime restart?");
461 return;
462 }
463 }
464 }
465 }
Alison Cichowlasf0afd8c2017-07-31 11:24:34 -0400466 Runnable runnable = new Runnable() {
467 @Override
468 public void run() {
469 synchronized (this) {
470 ShutdownThread.rebootOrShutdown(null, reboot, reason);
471 }
472 }
473 };
474
475 // ShutdownThread must run on a looper capable of displaying the UI.
476 Message msg = Message.obtain(UiThread.getHandler(), runnable);
477 msg.setAsynchronous(true);
478 UiThread.getHandler().sendMessage(msg);
479
Kenny Rootf547d672010-09-22 10:36:48 -0700480 }
Jeff Brown6f357d32014-01-15 20:40:55 -0800481 }
Kenny Rootf547d672010-09-22 10:36:48 -0700482
Jeff Brown6f357d32014-01-15 20:40:55 -0800483 private void createSystemContext() {
484 ActivityThread activityThread = ActivityThread.systemMain();
485 mSystemContext = activityThread.getSystemContext();
Alan Viveretteba398ea2015-12-16 15:28:23 -0500486 mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
Adam Lesinskia82b6262017-03-21 16:56:17 -0700487
488 final Context systemUiContext = activityThread.getSystemUiContext();
489 systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
Jeff Brown6f357d32014-01-15 20:40:55 -0800490 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800491
Jeff Brown2c43c332014-06-12 22:38:59 -0700492 /**
493 * Starts the small tangle of critical services that are needed to get
494 * the system off the ground. These services have complex mutual dependencies
495 * which is why we initialize them all in one place here. Unless your service
496 * is also entwined in these dependencies, it should be initialized in one of
497 * the other functions.
498 */
Jeff Brown6f357d32014-01-15 20:40:55 -0800499 private void startBootstrapServices() {
Fyodor Kupolovb76e0fd2017-01-30 13:28:25 -0800500 Slog.i(TAG, "Reading configuration...");
501 final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
502 traceBeginAndSlog(TAG_SYSTEM_CONFIG);
503 SystemServerInitThreadPool.get().submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);
504 traceEnd();
505
Jeff Brown6f357d32014-01-15 20:40:55 -0800506 // Wait for installd to finish starting up so that it has a chance to
507 // create critical directories such as /data/user with the appropriate
508 // permissions. We need this to complete before we initialize other services.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700509 traceBeginAndSlog("StartInstaller");
Narayan Kamath76a748e2014-11-10 14:23:41 +0000510 Installer installer = mSystemServiceManager.startService(Installer.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700511 traceEnd();
Jeff Brown6f357d32014-01-15 20:40:55 -0800512
Svet Ganov37e43272016-09-09 16:01:32 -0700513 // In some cases after launching an app we need to access device identifiers,
514 // therefore register the device identifier policy before the activity manager.
515 traceBeginAndSlog("DeviceIdentifiersPolicyService");
516 mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
517 traceEnd();
518
Jeff Brown6f357d32014-01-15 20:40:55 -0800519 // Activity manager runs the show.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700520 traceBeginAndSlog("StartActivityManager");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800521 mActivityManagerService = mSystemServiceManager.startService(
522 ActivityManagerService.Lifecycle.class).getService();
Dianne Hackborn91097de2014-04-04 18:02:06 -0700523 mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
Narayan Kamath76a748e2014-11-10 14:23:41 +0000524 mActivityManagerService.setInstaller(installer);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700525 traceEnd();
Jeff Brown4ccb8232014-01-16 22:16:42 -0800526
Jeff Brown2c43c332014-06-12 22:38:59 -0700527 // Power manager needs to be started early because other services need it.
528 // Native daemons may be watching for it to be registered so it must be ready
529 // to handle incoming binder calls immediately (including being able to verify
530 // the permissions for those calls).
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700531 traceBeginAndSlog("StartPowerManager");
Jeff Brown2c43c332014-06-12 22:38:59 -0700532 mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700533 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700534
535 // Now that the power manager has been started, let the activity manager
536 // initialize power management features.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700537 traceBeginAndSlog("InitPowerManagement");
Jeff Brown2c43c332014-06-12 22:38:59 -0700538 mActivityManagerService.initPowerManagement();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700539 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700540
Jeff Sharkeyfe6f85c2017-01-20 10:42:57 -0700541 // Bring up recovery system in case a rescue party needs a reboot
542 if (!SystemProperties.getBoolean("config.disable_noncore", false)) {
543 traceBeginAndSlog("StartRecoverySystemService");
544 mSystemServiceManager.startService(RecoverySystemService.class);
545 traceEnd();
546 }
547
548 // Now that we have the bare essentials of the OS up and running, take
549 // note that we just booted, which might send out a rescue party if
550 // we're stuck in a runtime restart loop.
551 RescueParty.noteBoot(mSystemContext);
552
Jeff Brown5d6443b2015-04-10 20:15:01 -0700553 // Manages LEDs and display backlight so we need it to bring up the display.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700554 traceBeginAndSlog("StartLightsService");
Jeff Brown5d6443b2015-04-10 20:15:01 -0700555 mSystemServiceManager.startService(LightsService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700556 traceEnd();
Jeff Brown5d6443b2015-04-10 20:15:01 -0700557
Jeff Brown4ccb8232014-01-16 22:16:42 -0800558 // Display manager is needed to provide display metrics before package manager
559 // starts up.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700560 traceBeginAndSlog("StartDisplayManager");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800561 mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700562 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700563
564 // We need the default display before we can initialize the package manager.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700565 traceBeginAndSlog("WaitForDisplay");
Jeff Brown2c43c332014-06-12 22:38:59 -0700566 mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700567 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700568
569 // Only run "core" apps if we're encrypting the device.
570 String cryptState = SystemProperties.get("vold.decrypt");
571 if (ENCRYPTING_STATE.equals(cryptState)) {
572 Slog.w(TAG, "Detected encryption in progress - only parsing core apps");
573 mOnlyCore = true;
574 } else if (ENCRYPTED_STATE.equals(cryptState)) {
575 Slog.w(TAG, "Device encrypted - only parsing core apps");
576 mOnlyCore = true;
577 }
578
579 // Start the package manager.
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800580 if (!mRuntimeRestart) {
581 MetricsLogger.histogram(null, "boot_package_manager_init_start",
582 (int) SystemClock.elapsedRealtime());
583 }
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900584 traceBeginAndSlog("StartPackageManagerService");
Narayan Kamath76a748e2014-11-10 14:23:41 +0000585 mPackageManagerService = PackageManagerService.main(mSystemContext, installer,
Jeff Brown2c43c332014-06-12 22:38:59 -0700586 mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
587 mFirstBoot = mPackageManagerService.isFirstBoot();
588 mPackageManager = mSystemContext.getPackageManager();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700589 traceEnd();
Fyodor Kupolov4ba91b92017-01-20 18:12:35 -0800590 if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
Fyodor Kupolov6733e6c2017-01-06 18:27:05 -0800591 MetricsLogger.histogram(null, "boot_package_manager_init_ready",
592 (int) SystemClock.elapsedRealtime());
593 }
Andreas Gampeabcbe2f2016-02-26 11:25:36 -0800594 // Manages A/B OTA dexopting. This is a bootstrap service as we need it to rename
595 // A/B artifacts after boot, before anything else might touch/need them.
596 // Note: this isn't needed during decryption (we don't have /data anyways).
597 if (!mOnlyCore) {
598 boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt",
599 false);
600 if (!disableOtaDexopt) {
601 traceBeginAndSlog("StartOtaDexOptService");
602 try {
603 OtaDexoptService.main(mSystemContext, mPackageManagerService);
604 } catch (Throwable e) {
605 reportWtf("starting OtaDexOptService", e);
606 } finally {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700607 traceEnd();
Andreas Gampeabcbe2f2016-02-26 11:25:36 -0800608 }
609 }
610 }
611
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900612 traceBeginAndSlog("StartUserManagerService");
Amith Yamasanid04aaa32016-06-13 12:09:36 -0700613 mSystemServiceManager.startService(UserManagerService.LifeCycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700614 traceEnd();
Adam Lesinski3c153512014-07-23 17:34:34 -0700615
Jeff Brown2c43c332014-06-12 22:38:59 -0700616 // Initialize attribute cache used to cache resources from packages.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700617 traceBeginAndSlog("InitAttributerCache");
Jeff Brown2c43c332014-06-12 22:38:59 -0700618 AttributeCache.init(mSystemContext);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700619 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700620
621 // Set up the Application instance for the system process and get started.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700622 traceBeginAndSlog("SetSystemProcess");
Jeff Brown2c43c332014-06-12 22:38:59 -0700623 mActivityManagerService.setSystemProcess();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700624 traceEnd();
Svet Ganovb9d71a62015-04-30 10:38:13 -0700625
Joel Fernandes2d314e12017-04-04 16:32:15 -0700626 // DisplayManagerService needs to setup android.display scheduling related policies
627 // since setSystemProcess() would have overridden policies due to setProcessGroup
628 mDisplayManagerService.setupSchedulerPolicies();
629
MÃ¥rten Kongstad2e0d0f32016-06-02 09:35:31 +0200630 // Manages Overlay packages
631 traceBeginAndSlog("StartOverlayManagerService");
632 mSystemServiceManager.startService(new OverlayManagerService(mSystemContext, installer));
633 traceEnd();
634
Svet Ganovb9d71a62015-04-30 10:38:13 -0700635 // The sensor service needs access to package manager service, app ops
636 // service, and permissions service, therefore we start it after them.
Keun-young Park9b73a542017-02-01 12:09:58 -0800637 // Start sensor service in a separate thread. Completion should be checked
638 // before using it.
639 mSensorServiceStart = SystemServerInitThreadPool.get().submit(() -> {
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -0700640 TimingsTraceLog traceLog = new TimingsTraceLog(
Keun-young Park9b73a542017-02-01 12:09:58 -0800641 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
642 traceLog.traceBegin(START_SENSOR_SERVICE);
643 startSensorService();
644 traceLog.traceEnd();
645 }, START_SENSOR_SERVICE);
Jeff Brown6f357d32014-01-15 20:40:55 -0800646 }
647
Jeff Brown2c43c332014-06-12 22:38:59 -0700648 /**
649 * Starts some essential services that are not tangled up in the bootstrap process.
650 */
651 private void startCoreServices() {
Jeff Sharkeyd79d2032016-08-23 13:39:07 -0600652 // Records errors and logs, for example wtf()
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700653 traceBeginAndSlog("StartDropBoxManager");
Jeff Sharkeyd79d2032016-08-23 13:39:07 -0600654 mSystemServiceManager.startService(DropBoxManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700655 traceEnd();
Jeff Sharkeyd79d2032016-08-23 13:39:07 -0600656
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700657 traceBeginAndSlog("StartBatteryService");
Jeff Brown21392762014-06-13 19:00:36 -0700658 // Tracks the battery level. Requires LightService.
659 mSystemServiceManager.startService(BatteryService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700660 traceEnd();
Adam Lesinski0debc9a2014-07-16 19:09:13 -0700661
662 // Tracks application usage stats.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700663 traceBeginAndSlog("StartUsageService");
Adam Lesinski0debc9a2014-07-16 19:09:13 -0700664 mSystemServiceManager.startService(UsageStatsService.class);
665 mActivityManagerService.setUsageStatsManager(
666 LocalServices.getService(UsageStatsManagerInternal.class));
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700667 traceEnd();
Torne (Richard Coles)4dbeb352014-07-29 19:14:24 +0100668
669 // Tracks whether the updatable WebView is in a ready state and watches for update installs.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700670 traceBeginAndSlog("StartWebViewUpdateService");
Gustav Sennton6258dcd2015-10-30 19:25:37 +0000671 mWebViewUpdateService = mSystemServiceManager.startService(WebViewUpdateService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700672 traceEnd();
Jeff Brown2c43c332014-06-12 22:38:59 -0700673 }
674
675 /**
676 * Starts a miscellaneous grab bag of stuff that has yet to be refactored
677 * and organized.
678 */
Jeff Brown6f357d32014-01-15 20:40:55 -0800679 private void startOtherServices() {
Jeff Brown6f357d32014-01-15 20:40:55 -0800680 final Context context = mSystemContext;
Jeff Brown7f6c2312012-04-13 20:38:38 -0700681 VibratorService vibrator = null;
Sudheer Shanka2250d562016-11-07 15:41:02 -0800682 IStorageManager storageManager = null;
Jeff Sharkeyc006f1a2011-05-19 17:12:49 -0700683 NetworkManagementService networkManagement = null;
Jeff Sharkey75279902011-05-24 18:39:45 -0700684 NetworkStatsService networkStats = null;
Jeff Sharkeya4620792011-05-20 15:29:23 -0700685 NetworkPolicyManagerService networkPolicy = null;
Mike Lockwood0f79b542009-08-14 14:18:49 -0400686 ConnectivityService connectivity = null;
Jeff Davidson6a4b2202014-04-16 17:29:40 -0700687 NetworkScoreService networkScore = null;
Irfan Sheriff7d024d32012-03-22 17:01:39 -0700688 NsdService serviceDiscovery= null;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800689 WindowManagerService wm = null;
Mike Lockwoodb01e8bf2011-08-29 20:11:07 -0400690 SerialService serial = null;
Amith Yamasani6734b9f2010-09-13 16:24:08 -0700691 NetworkTimeUpdateService networkTimeUpdater = null;
John Grossmanc1576732012-02-01 15:23:33 -0800692 CommonTimeManagementService commonTimeMgmtService = null;
Jeff Brown6ec6f792012-04-17 16:52:41 -0700693 InputManagerService inputManager = null;
Wink Savillea12a7b32012-09-20 10:09:45 -0700694 TelephonyRegistry telephonyRegistry = null;
Erik Gilling51e95df2013-06-26 11:06:51 -0700695 ConsumerIrService consumerIr = null;
Ye Wend97e1fd2014-07-24 12:56:45 -0700696 MmsServiceBroker mmsService = null;
Polina Bondarenkof8754ac2016-02-12 20:38:23 +0100697 HardwarePropertiesManagerService hardwarePropertiesService = null;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800698
Dan Morrille4d9a012013-03-28 18:10:43 -0700699 boolean disableStorage = SystemProperties.getBoolean("config.disable_storage", false);
Dan Morrille4d9a012013-03-28 18:10:43 -0700700 boolean disableBluetooth = SystemProperties.getBoolean("config.disable_bluetooth", false);
Dan Morrille4d9a012013-03-28 18:10:43 -0700701 boolean disableLocation = SystemProperties.getBoolean("config.disable_location", false);
702 boolean disableSystemUI = SystemProperties.getBoolean("config.disable_systemui", false);
703 boolean disableNonCoreServices = SystemProperties.getBoolean("config.disable_noncore", false);
704 boolean disableNetwork = SystemProperties.getBoolean("config.disable_network", false);
Chenjie Luo2cab8822014-10-16 13:31:39 -0700705 boolean disableNetworkTime = SystemProperties.getBoolean("config.disable_networktime", false);
Wei Liu9086b102016-02-03 16:57:31 -0800706 boolean disableRtt = SystemProperties.getBoolean("config.disable_rtt", false);
Wei Liu6aaabae2016-03-04 14:50:16 -0800707 boolean disableMediaProjection = SystemProperties.getBoolean("config.disable_mediaproj",
708 false);
709 boolean disableSerial = SystemProperties.getBoolean("config.disable_serial", false);
710 boolean disableSearchManager = SystemProperties.getBoolean("config.disable_searchmanager",
711 false);
712 boolean disableTrustManager = SystemProperties.getBoolean("config.disable_trustmanager",
713 false);
Ivan Podogov8adaec02016-09-14 18:14:31 +0100714 boolean disableTextServices = SystemProperties.getBoolean("config.disable_textservices",
715 false);
Wei Liu09de4192016-09-07 13:33:49 -0700716 boolean disableConsumerIr = SystemProperties.getBoolean("config.disable_consumerir", false);
Wei Liuef89d212016-09-19 15:10:33 -0700717 boolean disableVrManager = SystemProperties.getBoolean("config.disable_vrmanager", false);
Ivan Podogov8adaec02016-09-14 18:14:31 +0100718 boolean disableCameraService = SystemProperties.getBoolean("config.disable_cameraservice",
719 false);
Ivan Podogovf9973822017-05-11 15:51:34 +0100720 boolean enableLeftyService = SystemProperties.getBoolean("config.enable_lefty", false);
Wei Liu09de4192016-09-07 13:33:49 -0700721
Colin Cross039deed2017-02-18 20:05:47 +0000722 boolean isEmulator = SystemProperties.get("ro.kernel.qemu").equals("1");
723
Jeff Sharkeyfe6f85c2017-01-20 10:42:57 -0700724 // For debugging RescueParty
725 if (Build.IS_DEBUGGABLE && SystemProperties.getBoolean("debug.crash_system", false)) {
726 throw new RuntimeException();
727 }
728
Dan Morrille4d9a012013-03-28 18:10:43 -0700729 try {
Narayan Kamath97780462017-02-06 20:24:08 +0000730 final String SECONDARY_ZYGOTE_PRELOAD = "SecondaryZygotePreload";
731 // We start the preload ~1s before the webview factory preparation, to
732 // ensure that it completes before the 32 bit relro process is forked
733 // from the zygote. In the event that it takes too long, the webview
734 // RELRO process will block, but it will do so without holding any locks.
735 mZygotePreload = SystemServerInitThreadPool.get().submit(() -> {
736 try {
737 Slog.i(TAG, SECONDARY_ZYGOTE_PRELOAD);
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -0700738 TimingsTraceLog traceLog = new TimingsTraceLog(
Narayan Kamath97780462017-02-06 20:24:08 +0000739 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
740 traceLog.traceBegin(SECONDARY_ZYGOTE_PRELOAD);
741 if (!Process.zygoteProcess.preloadDefault(Build.SUPPORTED_32_BIT_ABIS[0])) {
742 Slog.e(TAG, "Unable to preload default resources");
743 }
744 traceLog.traceEnd();
745 } catch (Exception ex) {
746 Slog.e(TAG, "Exception preloading default resources", ex);
747 }
748 }, SECONDARY_ZYGOTE_PRELOAD);
749
Janis Danisevskis8ff1e192016-06-03 11:31:55 -0700750 traceBeginAndSlog("StartKeyAttestationApplicationIdProviderService");
751 ServiceManager.addService("sec_key_att_app_id_provider",
752 new KeyAttestationApplicationIdProviderService(context));
Vitalii Tomkivca68aca2016-09-23 10:58:43 -0700753 traceEnd();
Janis Danisevskis8ff1e192016-06-03 11:31:55 -0700754
Robin Lee13935492017-03-23 15:28:37 +0000755 traceBeginAndSlog("StartKeyChainSystemService");
756 mSystemServiceManager.startService(KeyChainSystemService.class);
757 traceEnd();
758
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900759 traceBeginAndSlog("StartSchedulingPolicyService");
Dianne Hackborn35f72be2013-09-16 10:57:39 -0700760 ServiceManager.addService("scheduling_policy", new SchedulingPolicyService());
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700761 traceEnd();
Glenn Kasten07b04652012-04-23 15:00:43 -0700762
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700763 traceBeginAndSlog("StartTelecomLoaderService");
Santos Cordon5d2c1e62014-11-21 15:20:15 -0800764 mSystemServiceManager.startService(TelecomLoaderService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700765 traceEnd();
Santos Cordon5d2c1e62014-11-21 15:20:15 -0800766
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900767 traceBeginAndSlog("StartTelephonyRegistry");
Jeff Brown2c43c332014-06-12 22:38:59 -0700768 telephonyRegistry = new TelephonyRegistry(context);
769 ServiceManager.addService("telephony.registry", telephonyRegistry);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700770 traceEnd();
Svetoslavb3038ec2013-02-13 14:39:30 -0800771
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900772 traceBeginAndSlog("StartEntropyMixer");
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600773 mEntropyMixer = new EntropyMixer(context);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700774 traceEnd();
Nick Kralevich79619dd2013-03-04 13:05:32 -0800775
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800776 mContentResolver = context.getContentResolver();
777
Fred Quintanae91ebe22009-09-29 20:44:30 -0700778 // The AccountManager must come before the ContentService
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900779 traceBeginAndSlog("StartAccountManagerService");
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600780 mSystemServiceManager.startService(ACCOUNT_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700781 traceEnd();
Fred Quintana60307342009-03-24 22:48:12 -0700782
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900783 traceBeginAndSlog("StartContentService");
Jeff Sharkeya3ebfec2016-04-04 08:58:04 -0600784 mSystemServiceManager.startService(CONTENT_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700785 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800786
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900787 traceBeginAndSlog("InstallSystemProviders");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800788 mActivityManagerService.installSystemProviders();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700789 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800790
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900791 traceBeginAndSlog("StartVibratorService");
Jeff Brown7f6c2312012-04-13 20:38:38 -0700792 vibrator = new VibratorService(context);
793 ServiceManager.addService("vibrator", vibrator);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700794 traceEnd();
The Android Open Source Project10592532009-03-18 17:39:46 -0700795
Wei Liu09de4192016-09-07 13:33:49 -0700796 if (!disableConsumerIr) {
797 traceBeginAndSlog("StartConsumerIrService");
798 consumerIr = new ConsumerIrService(context);
799 ServiceManager.addService(Context.CONSUMER_IR_SERVICE, consumerIr);
Colin Cross7af8c2a2016-09-12 21:12:49 -0700800 traceEnd();
Wei Liu09de4192016-09-07 13:33:49 -0700801 }
Erik Gilling51e95df2013-06-26 11:06:51 -0700802
Jeff Sharkey1cab76a2016-04-12 18:23:31 -0600803 traceBeginAndSlog("StartAlarmManagerService");
Jeff Brown6f357d32014-01-15 20:40:55 -0800804 mSystemServiceManager.startService(AlarmManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700805 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800806
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900807 traceBeginAndSlog("InitWatchdog");
Jeff Brown6f357d32014-01-15 20:40:55 -0800808 final Watchdog watchdog = Watchdog.getInstance();
Jeff Brown4ccb8232014-01-16 22:16:42 -0800809 watchdog.init(context, mActivityManagerService);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700810 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800811
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900812 traceBeginAndSlog("StartInputManagerService");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800813 inputManager = new InputManagerService(context);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700814 traceEnd();
Jeff Browna9d131c2012-09-20 16:48:17 -0700815
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900816 traceBeginAndSlog("StartWindowManagerService");
Keun-young Park9b73a542017-02-01 12:09:58 -0800817 // WMS needs sensor service ready
818 ConcurrentUtils.waitForFutureNoInterrupt(mSensorServiceStart, START_SENSOR_SERVICE);
819 mSensorServiceStart = null;
Jeff Brown4ccb8232014-01-16 22:16:42 -0800820 wm = WindowManagerService.main(context, inputManager,
Jeff Brown6f357d32014-01-15 20:40:55 -0800821 mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
Wale Ogunwaleb699ce02016-07-18 12:05:30 -0700822 !mFirstBoot, mOnlyCore, new PhoneWindowManager());
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800823 ServiceManager.addService(Context.WINDOW_SERVICE, wm);
Jeff Brown6ec6f792012-04-17 16:52:41 -0700824 ServiceManager.addService(Context.INPUT_SERVICE, inputManager);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700825 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800826
Yifan Hong604c12c2017-03-20 10:57:44 -0700827 // Start receiving calls from HIDL services. Start in in a separate thread
828 // because it need to connect to SensorManager. This have to start
829 // after START_SENSOR_SERVICE is done.
830 SystemServerInitThreadPool.get().submit(() -> {
Roger 1 Jönsson341b2c12017-05-17 14:21:55 +0200831 TimingsTraceLog traceLog = new TimingsTraceLog(
832 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
833 traceLog.traceBegin(START_HIDL_SERVICES);
Yifan Hong604c12c2017-03-20 10:57:44 -0700834 startHidlServices();
Roger 1 Jönsson341b2c12017-05-17 14:21:55 +0200835 traceLog.traceEnd();
Yifan Hong604c12c2017-03-20 10:57:44 -0700836 }, START_HIDL_SERVICES);
837
Wei Liuef89d212016-09-19 15:10:33 -0700838 if (!disableVrManager) {
839 traceBeginAndSlog("StartVrManagerService");
840 mSystemServiceManager.startService(VrManagerService.class);
Wei Liu03d0a362016-09-20 10:21:27 -0700841 traceEnd();
Wei Liuef89d212016-09-19 15:10:33 -0700842 }
Ruben Brunkdd18a0b2015-12-04 16:16:31 -0800843
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -0800844 traceBeginAndSlog("SetWindowManagerService");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800845 mActivityManagerService.setWindowManager(wm);
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -0800846 traceEnd();
Jeff Browna9d131c2012-09-20 16:48:17 -0700847
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700848 traceBeginAndSlog("StartInputManager");
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -0800849 inputManager.setWindowManagerCallbacks(wm.getInputMonitor());
Jeff Browna9d131c2012-09-20 16:48:17 -0700850 inputManager.start();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700851 traceEnd();
Jeff Browna9d131c2012-09-20 16:48:17 -0700852
Jeff Brown4ccb8232014-01-16 22:16:42 -0800853 // TODO: Use service dependencies instead.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700854 traceBeginAndSlog("DisplayManagerWindowManagerAndInputReady");
Jeff Brown4ccb8232014-01-16 22:16:42 -0800855 mDisplayManagerService.windowManagerAndInputReady();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700856 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800857
Colin Cross039deed2017-02-18 20:05:47 +0000858 // Skip Bluetooth if we have an emulator kernel
859 // TODO: Use a more reliable check to see if this product should
860 // support Bluetooth - see bug 988521
861 if (isEmulator) {
862 Slog.i(TAG, "No Bluetooth Service (emulator)");
863 } else if (mFactoryTestMode == FactoryTest.FACTORY_TEST_LOW_LEVEL) {
David 'Digit' Turnere2a5e862011-01-17 00:32:33 +0100864 Slog.i(TAG, "No Bluetooth Service (factory test)");
Matthew Xie1dd01eb32013-04-26 12:37:54 -0700865 } else if (!context.getPackageManager().hasSystemFeature
866 (PackageManager.FEATURE_BLUETOOTH)) {
867 Slog.i(TAG, "No Bluetooth Service (Bluetooth Hardware Not Present)");
Dan Morrille4d9a012013-03-28 18:10:43 -0700868 } else if (disableBluetooth) {
869 Slog.i(TAG, "Bluetooth Service disabled by config");
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800870 } else {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700871 traceBeginAndSlog("StartBluetoothService");
Miao Chou658bf2f2015-06-26 17:14:35 -0700872 mSystemServiceManager.startService(BluetoothService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700873 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800874 }
Pavel Zhamaitsiak02b3e6b2016-02-03 10:39:44 -0800875
Hugo Benichieab511b2016-09-09 09:23:47 +0900876 traceBeginAndSlog("IpConnectivityMetrics");
877 mSystemServiceManager.startService(IpConnectivityMetrics.class);
Keun-young Parkd340d8a2016-10-18 17:52:30 -0700878 traceEnd();
Hugo Benichieab511b2016-09-09 09:23:47 +0900879
Philip Cuadra7bd0fdd2016-04-28 15:26:49 -0700880 traceBeginAndSlog("PinnerService");
881 mSystemServiceManager.startService(PinnerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700882 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800883 } catch (RuntimeException e) {
Dianne Hackborn661cd522011-08-22 00:26:20 -0700884 Slog.e("System", "******************************************");
885 Slog.e("System", "************ Failure starting core service", e);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800886 }
887
Joe Onorato089de882010-04-12 08:18:45 -0700888 StatusBarManagerService statusBar = null;
Adam Lesinskief2ea1f2013-12-05 16:48:06 -0800889 INotificationManager notification = null;
Mike Lockwood46db5042010-02-22 16:36:44 -0500890 LocationManagerService location = null;
Bai Taoa58a8752010-07-13 15:32:16 +0800891 CountryDetectorService countryDetector = null;
Jim Miller4f93c582016-01-27 19:05:43 -0800892 ILockSettings lockSettings = null;
Jeff Brown69b07162013-11-07 00:30:16 -0800893 MediaRouterService mediaRouter = null;
The Android Open Source Project9066cfe2009-03-03 19:31:44 -0800894
Dianne Hackborn661cd522011-08-22 00:26:20 -0700895 // Bring up services needed for UI.
Jeff Brown6f357d32014-01-15 20:40:55 -0800896 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700897 traceBeginAndSlog("StartInputMethodManagerLifecycle");
Fyodor Kupolov1e33dc82016-01-21 12:02:58 -0800898 mSystemServiceManager.startService(InputMethodManagerService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700899 traceEnd();
Dianne Hackborn661cd522011-08-22 00:26:20 -0700900
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +0900901 traceBeginAndSlog("StartAccessibilityManagerService");
dcashman4e3f5d32014-11-25 15:33:26 -0800902 try {
dcashman4e3f5d32014-11-25 15:33:26 -0800903 ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,
904 new AccessibilityManagerService(context));
905 } catch (Throwable e) {
906 reportWtf("starting Accessibility Manager", e);
Dianne Hackborn661cd522011-08-22 00:26:20 -0700907 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700908 traceEnd();
Dianne Hackborn661cd522011-08-22 00:26:20 -0700909 }
910
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700911 traceBeginAndSlog("MakeDisplayReady");
Dianne Hackborn661cd522011-08-22 00:26:20 -0700912 try {
913 wm.displayReady();
914 } catch (Throwable e) {
915 reportWtf("making display ready", e);
916 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700917 traceEnd();
Dianne Hackborn8795b602011-08-25 13:30:53 -0700918
Jeff Brown6f357d32014-01-15 20:40:55 -0800919 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
Dan Morrille4d9a012013-03-28 18:10:43 -0700920 if (!disableStorage &&
Jeff Sharkeye8cece92017-01-04 11:33:33 -0700921 !"0".equals(SystemProperties.get("system_init.startmountservice"))) {
Sudheer Shanka2250d562016-11-07 15:41:02 -0800922 traceBeginAndSlog("StartStorageManagerService");
Kenny Root51a573c2012-05-17 13:30:28 -0700923 try {
924 /*
Sudheer Shanka2250d562016-11-07 15:41:02 -0800925 * NotificationManagerService is dependant on StorageManagerService,
926 * (for media / usb notifications) so we must start StorageManagerService first.
Kenny Root51a573c2012-05-17 13:30:28 -0700927 */
Sudheer Shanka2250d562016-11-07 15:41:02 -0800928 mSystemServiceManager.startService(STORAGE_MANAGER_SERVICE_CLASS);
929 storageManager = IStorageManager.Stub.asInterface(
Jeff Sharkey56e62932015-03-21 20:41:00 -0700930 ServiceManager.getService("mount"));
Kenny Root51a573c2012-05-17 13:30:28 -0700931 } catch (Throwable e) {
Jeff Sharkeye8cece92017-01-04 11:33:33 -0700932 reportWtf("starting StorageManagerService", e);
933 }
934 traceEnd();
935
936 traceBeginAndSlog("StartStorageStatsService");
937 try {
938 mSystemServiceManager.startService(STORAGE_STATS_SERVICE_CLASS);
939 } catch (Throwable e) {
940 reportWtf("starting StorageStatsService", e);
Kenny Root51a573c2012-05-17 13:30:28 -0700941 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700942 traceEnd();
Kenny Root51a573c2012-05-17 13:30:28 -0700943 }
padarshrada45412014-11-05 16:54:50 +0530944 }
Kenny Root51a573c2012-05-17 13:30:28 -0700945
Adam Lesinski05199e82015-03-19 14:37:11 -0700946 // We start this here so that we update our configuration to set watch or television
947 // as appropriate.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700948 traceBeginAndSlog("StartUiModeManager");
Adam Lesinski05199e82015-03-19 14:37:11 -0700949 mSystemServiceManager.startService(UiModeManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700950 traceEnd();
Adam Lesinski05199e82015-03-19 14:37:11 -0700951
David Brazdil89c80bb2016-06-02 15:31:30 +0100952 if (!mOnlyCore) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700953 traceBeginAndSlog("UpdatePackagesIfNeeded");
David Brazdil89c80bb2016-06-02 15:31:30 +0100954 try {
955 mPackageManagerService.updatePackagesIfNeeded();
956 } catch (Throwable e) {
957 reportWtf("update packages", e);
958 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700959 traceEnd();
David Brazdilf5c444f2016-03-30 11:45:52 +0100960 }
David Brazdilf5c444f2016-03-30 11:45:52 +0100961
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700962 traceBeginAndSlog("PerformFstrimIfNeeded");
padarshrada45412014-11-05 16:54:50 +0530963 try {
Nicolas Geoffray27c07372015-11-05 16:54:09 +0000964 mPackageManagerService.performFstrimIfNeeded();
padarshrada45412014-11-05 16:54:50 +0530965 } catch (Throwable e) {
Nicolas Geoffray27c07372015-11-05 16:54:09 +0000966 reportWtf("performing fstrim", e);
padarshrada45412014-11-05 16:54:50 +0530967 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700968 traceEnd();
padarshrada45412014-11-05 16:54:50 +0530969
padarshrada45412014-11-05 16:54:50 +0530970 if (mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
Dan Morrille4d9a012013-03-28 18:10:43 -0700971 if (!disableNonCoreServices) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +0900972 traceBeginAndSlog("StartLockSettingsService");
Dan Morrille4d9a012013-03-28 18:10:43 -0700973 try {
Jim Miller4f93c582016-01-27 19:05:43 -0800974 mSystemServiceManager.startService(LOCK_SETTINGS_SERVICE_CLASS);
975 lockSettings = ILockSettings.Stub.asInterface(
976 ServiceManager.getService("lock_settings"));
Dan Morrille4d9a012013-03-28 18:10:43 -0700977 } catch (Throwable e) {
978 reportWtf("starting LockSettingsService service", e);
979 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700980 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -0700981
Andrew Scull5d7027d2017-04-12 11:46:27 +0100982 final boolean hasPdb = !SystemProperties.get(PERSISTENT_DATA_BLOCK_PROP).equals("");
983 if (hasPdb) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700984 traceBeginAndSlog("StartPersistentDataBlock");
Andres Morales68d4acd2014-07-01 19:40:41 -0700985 mSystemServiceManager.startService(PersistentDataBlockService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700986 traceEnd();
Andrew Scull5d7027d2017-04-12 11:46:27 +0100987 }
Andrew Scull3b8b46f2017-02-13 18:12:15 +0000988
Andrew Scull5d7027d2017-04-12 11:46:27 +0100989 if (hasPdb || OemLockService.isHalPresent()) {
990 // Implementation depends on pdb or the OemLock HAL
Andrew Scull3b8b46f2017-02-13 18:12:15 +0000991 traceBeginAndSlog("StartOemLockService");
992 mSystemServiceManager.startService(OemLockService.class);
993 traceEnd();
Andres Morales68d4acd2014-07-01 19:40:41 -0700994 }
995
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700996 traceBeginAndSlog("StartDeviceIdleController");
Dianne Hackborn0b4daca2015-04-27 09:47:32 -0700997 mSystemServiceManager.startService(DeviceIdleController.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -0700998 traceEnd();
Dianne Hackborn0b4daca2015-04-27 09:47:32 -0700999
Jeff Brown2c43c332014-06-12 22:38:59 -07001000 // Always start the Device Policy Manager, so that the API is compatible with
1001 // API8.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001002 traceBeginAndSlog("StartDevicePolicyManager");
Jeff Brown2c43c332014-06-12 22:38:59 -07001003 mSystemServiceManager.startService(DevicePolicyManagerService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001004 traceEnd();
Amith Yamasani52c489c2012-03-28 11:42:42 -07001005 }
1006
Dan Morrille4d9a012013-03-28 18:10:43 -07001007 if (!disableSystemUI) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001008 traceBeginAndSlog("StartStatusBarManagerService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001009 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001010 statusBar = new StatusBarManagerService(context, wm);
1011 ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
1012 } catch (Throwable e) {
1013 reportWtf("starting StatusBarManagerService", e);
1014 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001015 traceEnd();
Dianne Hackbornd6847842010-01-12 18:14:19 -08001016 }
1017
Dan Morrille4d9a012013-03-28 18:10:43 -07001018 if (!disableNonCoreServices) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001019 traceBeginAndSlog("StartClipboardService");
Sudheer Shankaad70bc62016-09-29 12:58:04 -07001020 mSystemServiceManager.startService(ClipboardService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001021 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001022 }
1023
Dan Morrille4d9a012013-03-28 18:10:43 -07001024 if (!disableNetwork) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001025 traceBeginAndSlog("StartNetworkManagementService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001026 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001027 networkManagement = NetworkManagementService.create(context);
1028 ServiceManager.addService(Context.NETWORKMANAGEMENT_SERVICE, networkManagement);
1029 } catch (Throwable e) {
1030 reportWtf("starting NetworkManagement Service", e);
1031 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001032 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001033 }
1034
Wei Liu6aaabae2016-03-04 14:50:16 -08001035 if (!disableNonCoreServices && !disableTextServices) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001036 traceBeginAndSlog("StartTextServicesManager");
Yohei Yukawaa6a152e2016-03-07 13:41:15 -08001037 mSystemServiceManager.startService(TextServicesManagerService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001038 traceEnd();
San Mehatd1df8ac2010-01-26 06:17:26 -08001039 }
1040
Dan Morrille4d9a012013-03-28 18:10:43 -07001041 if (!disableNetwork) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001042 traceBeginAndSlog("StartNetworkScoreService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001043 try {
vandwalle7c3606c2014-03-31 19:12:07 -07001044 networkScore = new NetworkScoreService(context);
1045 ServiceManager.addService(Context.NETWORK_SCORE_SERVICE, networkScore);
1046 } catch (Throwable e) {
1047 reportWtf("starting Network Score Service", e);
1048 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001049 traceEnd();
vandwalle7c3606c2014-03-31 19:12:07 -07001050
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001051 traceBeginAndSlog("StartNetworkStatsService");
vandwalle7c3606c2014-03-31 19:12:07 -07001052 try {
Antonio Cansadocd42acd2016-02-17 13:03:38 -08001053 networkStats = NetworkStatsService.create(context, networkManagement);
Dan Morrille4d9a012013-03-28 18:10:43 -07001054 ServiceManager.addService(Context.NETWORK_STATS_SERVICE, networkStats);
1055 } catch (Throwable e) {
1056 reportWtf("starting NetworkStats Service", e);
1057 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001058 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001059
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001060 traceBeginAndSlog("StartNetworkPolicyManagerService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001061 try {
Felipe Leme88f40ad2016-08-10 13:00:32 -07001062 networkPolicy = new NetworkPolicyManagerService(context,
1063 mActivityManagerService, networkStats, networkManagement);
Dan Morrille4d9a012013-03-28 18:10:43 -07001064 ServiceManager.addService(Context.NETWORK_POLICY_SERVICE, networkPolicy);
1065 } catch (Throwable e) {
1066 reportWtf("starting NetworkPolicy Service", e);
1067 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001068 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001069
Rebecca Silberstein9e40b802017-01-07 01:59:16 -08001070 // Wifi Service must be started first for wifi-related services.
1071 traceBeginAndSlog("StartWifi");
1072 mSystemServiceManager.startService(WIFI_SERVICE_CLASS);
1073 traceEnd();
1074 traceBeginAndSlog("StartWifiScanning");
1075 mSystemServiceManager.startService(
1076 "com.android.server.wifi.scanner.WifiScanningService");
1077 traceEnd();
1078
1079 if (!disableRtt) {
1080 traceBeginAndSlog("StartWifiRtt");
1081 mSystemServiceManager.startService("com.android.server.wifi.RttService");
1082 traceEnd();
1083 }
1084
Etan Cohen04133272016-10-26 11:22:06 -07001085 if (context.getPackageManager().hasSystemFeature(
1086 PackageManager.FEATURE_WIFI_AWARE)) {
1087 traceBeginAndSlog("StartWifiAware");
1088 mSystemServiceManager.startService(WIFI_AWARE_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001089 traceEnd();
Etan Cohen20d329b2015-09-29 13:49:02 -07001090 } else {
Etan Cohen04133272016-10-26 11:22:06 -07001091 Slog.i(TAG, "No Wi-Fi Aware Service (Aware support Not Present)");
Etan Cohen20d329b2015-09-29 13:49:02 -07001092 }
Wei Liu4e62ac52016-05-23 15:12:49 -07001093
1094 if (context.getPackageManager().hasSystemFeature(
1095 PackageManager.FEATURE_WIFI_DIRECT)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001096 traceBeginAndSlog("StartWifiP2P");
Wei Liu4e62ac52016-05-23 15:12:49 -07001097 mSystemServiceManager.startService(WIFI_P2P_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001098 traceEnd();
Wei Liu4e62ac52016-05-23 15:12:49 -07001099 }
Vinit Deshpandec4272f32014-07-25 17:46:14 -07001100
Robert Quattlebaum87a71042017-05-15 15:45:20 -07001101 if (context.getPackageManager().hasSystemFeature(
1102 PackageManager.FEATURE_LOWPAN)) {
1103 traceBeginAndSlog("StartLowpan");
1104 mSystemServiceManager.startService(LOWPAN_SERVICE_CLASS);
1105 traceEnd();
1106 }
1107
Lorenzo Colitti0ea7b1b2014-11-25 21:52:12 +09001108 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_ETHERNET) ||
1109 mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001110 traceBeginAndSlog("StartEthernet");
Jeff Brown2c43c332014-06-12 22:38:59 -07001111 mSystemServiceManager.startService(ETHERNET_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001112 traceEnd();
Lorenzo Colittif9ff2c92014-05-21 16:32:11 -07001113 }
1114
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001115 traceBeginAndSlog("StartConnectivityService");
Lorenzo Colittif9ff2c92014-05-21 16:32:11 -07001116 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001117 connectivity = new ConnectivityService(
1118 context, networkManagement, networkStats, networkPolicy);
1119 ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);
1120 networkStats.bindConnectivityManager(connectivity);
1121 networkPolicy.bindConnectivityManager(connectivity);
Dan Morrille4d9a012013-03-28 18:10:43 -07001122 } catch (Throwable e) {
1123 reportWtf("starting Connectivity Service", e);
1124 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001125 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001126
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001127 traceBeginAndSlog("StartNsdService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001128 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001129 serviceDiscovery = NsdService.create(context);
1130 ServiceManager.addService(
1131 Context.NSD_SERVICE, serviceDiscovery);
1132 } catch (Throwable e) {
1133 reportWtf("starting Service Discovery Service", e);
1134 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001135 traceEnd();
satok988323c2011-06-22 16:38:13 +09001136 }
1137
Dan Morrille4d9a012013-03-28 18:10:43 -07001138 if (!disableNonCoreServices) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001139 traceBeginAndSlog("StartUpdateLockService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001140 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001141 ServiceManager.addService(Context.UPDATE_LOCK_SERVICE,
1142 new UpdateLockService(context));
1143 } catch (Throwable e) {
1144 reportWtf("starting UpdateLockService", e);
1145 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001146 traceEnd();
Christopher Tate8662cab52012-02-23 14:59:36 -08001147 }
1148
Kenny Root51a573c2012-05-17 13:30:28 -07001149 /*
Sudheer Shanka2250d562016-11-07 15:41:02 -08001150 * StorageManagerService has a few dependencies: Notification Manager and
1151 * AppWidget Provider. Make sure StorageManagerService is completely started
Kenny Root51a573c2012-05-17 13:30:28 -07001152 * first before continuing.
1153 */
Sudheer Shanka2250d562016-11-07 15:41:02 -08001154 if (storageManager != null && !mOnlyCore) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001155 traceBeginAndSlog("WaitForAsecScan");
Jeff Sharkey56e62932015-03-21 20:41:00 -07001156 try {
Sudheer Shanka2250d562016-11-07 15:41:02 -08001157 storageManager.waitForAsecScan();
Jeff Sharkey56e62932015-03-21 20:41:00 -07001158 } catch (RemoteException ignored) {
1159 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001160 traceEnd();
San Mehat1bf3f8b2010-02-03 14:43:09 -08001161 }
1162
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001163 traceBeginAndSlog("StartNotificationManager");
Jeff Brown6f357d32014-01-15 20:40:55 -08001164 mSystemServiceManager.startService(NotificationManagerService.class);
Geoffrey Pitschaf759c52017-02-15 09:35:38 -05001165 SystemNotificationChannels.createAll(context);
Adam Lesinskief2ea1f2013-12-05 16:48:06 -08001166 notification = INotificationManager.Stub.asInterface(
1167 ServiceManager.getService(Context.NOTIFICATION_SERVICE));
1168 networkPolicy.bindNotificationManager(notification);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001169 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001170
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001171 traceBeginAndSlog("StartDeviceMonitor");
Jeff Brown6f357d32014-01-15 20:40:55 -08001172 mSystemServiceManager.startService(DeviceStorageMonitorService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001173 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001174
Dan Morrille4d9a012013-03-28 18:10:43 -07001175 if (!disableLocation) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001176 traceBeginAndSlog("StartLocationManagerService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001177 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001178 location = new LocationManagerService(context);
1179 ServiceManager.addService(Context.LOCATION_SERVICE, location);
1180 } catch (Throwable e) {
1181 reportWtf("starting Location Manager", e);
1182 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001183 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001184
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001185 traceBeginAndSlog("StartCountryDetectorService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001186 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001187 countryDetector = new CountryDetectorService(context);
1188 ServiceManager.addService(Context.COUNTRY_DETECTOR, countryDetector);
1189 } catch (Throwable e) {
1190 reportWtf("starting Country Detector", e);
1191 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001192 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001193 }
1194
Wei Liu6aaabae2016-03-04 14:50:16 -08001195 if (!disableNonCoreServices && !disableSearchManager) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001196 traceBeginAndSlog("StartSearchManagerService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001197 try {
Jeff Sharkey4175be22016-01-09 14:57:45 -07001198 mSystemServiceManager.startService(SEARCH_MANAGER_SERVICE_CLASS);
Dan Morrille4d9a012013-03-28 18:10:43 -07001199 } catch (Throwable e) {
1200 reportWtf("starting Search Service", e);
1201 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001202 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001203 }
1204
Dan Morrille4d9a012013-03-28 18:10:43 -07001205 if (!disableNonCoreServices && context.getResources().getBoolean(
1206 R.bool.config_enableWallpaperService)) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001207 traceBeginAndSlog("StartWallpaperManagerService");
Jeff Sharkey1cab76a2016-04-12 18:23:31 -06001208 mSystemServiceManager.startService(WALLPAPER_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001209 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001210 }
1211
Neil Fuller3e9ee482017-07-26 11:59:34 +01001212 // timezone.RulesManagerService will prevent a device starting up if the chain of trust
1213 // required for safe time zone updates might be broken. RuleManagerService cannot do
1214 // this check when mOnlyCore == true, so we don't enable the service in this case.
1215 final boolean startRulesManagerService =
1216 !mOnlyCore && context.getResources().getBoolean(
1217 R.bool.config_enableUpdateableTimeZoneRules);
1218 if (startRulesManagerService) {
Neil Fuller328532a2017-03-16 18:32:21 +00001219 traceBeginAndSlog("StartTimeZoneRulesManagerService");
1220 mSystemServiceManager.startService(TIME_ZONE_RULES_MANAGER_SERVICE_CLASS);
Neil Fullerab608e52017-07-28 17:16:11 +01001221 traceEnd();
Neil Fuller328532a2017-03-16 18:32:21 +00001222 }
1223
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +09001224 traceBeginAndSlog("StartAudioService");
Makoto Onukie1aef852015-10-15 17:28:35 -07001225 mSystemServiceManager.startService(AudioService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001226 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001227
Tomasz Wasilczyk05392d62017-07-10 19:33:22 -07001228 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BROADCAST_RADIO)) {
1229 traceBeginAndSlog("StartBroadcastRadioService");
Tomasz Wasilczyk6b4b6462017-07-19 10:52:28 -07001230 mSystemServiceManager.startService(BroadcastRadioService.class);
Tomasz Wasilczyk347192e2017-04-04 11:13:44 -07001231 traceEnd();
1232 }
1233
Dan Morrille4d9a012013-03-28 18:10:43 -07001234 if (!disableNonCoreServices) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001235 traceBeginAndSlog("StartDockObserver");
Jeff Brown010e5612014-05-29 17:48:33 -07001236 mSystemServiceManager.startService(DockObserver.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001237 traceEnd();
Bryce Leebc58f592015-09-25 16:43:01 -07001238
Wei Liu48d3b632016-03-29 15:26:48 -07001239 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001240 traceBeginAndSlog("StartThermalObserver");
Wei Liud699cf82016-03-25 16:32:10 -07001241 mSystemServiceManager.startService(THERMAL_OBSERVER_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001242 traceEnd();
Bryce Leebc58f592015-09-25 16:43:01 -07001243 }
Dan Murphyc9f4eaf2009-08-12 15:15:43 -05001244 }
1245
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +09001246 traceBeginAndSlog("StartWiredAccessoryManager");
John Spurlockb4f01b92015-03-24 12:40:15 -04001247 try {
John Spurlockb4f01b92015-03-24 12:40:15 -04001248 // Listen for wired headset changes
1249 inputManager.setWiredAccessoryCallbacks(
1250 new WiredAccessoryManager(context, inputManager));
1251 } catch (Throwable e) {
1252 reportWtf("starting WiredAccessoryManager", e);
Praveen Bharathi21e941b2010-10-06 15:23:14 -05001253 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001254 traceEnd();
Praveen Bharathi21e941b2010-10-06 15:23:14 -05001255
Dan Morrille4d9a012013-03-28 18:10:43 -07001256 if (!disableNonCoreServices) {
Mike Lockwood5781cd52015-03-27 13:23:41 -07001257 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_MIDI)) {
1258 // Start MIDI Manager service
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001259 traceBeginAndSlog("StartMidiManager");
Mike Lockwood5781cd52015-03-27 13:23:41 -07001260 mSystemServiceManager.startService(MIDI_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001261 traceEnd();
Mike Lockwood5781cd52015-03-27 13:23:41 -07001262 }
1263
Jeff Brown2c43c332014-06-12 22:38:59 -07001264 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_USB_HOST)
1265 || mPackageManager.hasSystemFeature(
1266 PackageManager.FEATURE_USB_ACCESSORY)) {
1267 // Manage USB host and device support
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001268 traceBeginAndSlog("StartUsbService");
Jeff Brown2c43c332014-06-12 22:38:59 -07001269 mSystemServiceManager.startService(USB_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001270 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001271 }
Mike Lockwood57c798a2010-06-23 17:36:36 -04001272
Wei Liu6aaabae2016-03-04 14:50:16 -08001273 if (!disableSerial) {
1274 traceBeginAndSlog("StartSerialService");
1275 try {
1276 // Serial port support
1277 serial = new SerialService(context);
1278 ServiceManager.addService(Context.SERIAL_SERVICE, serial);
1279 } catch (Throwable e) {
1280 Slog.e(TAG, "Failure starting SerialService", e);
1281 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001282 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001283 }
Polina Bondarenkof8754ac2016-02-12 20:38:23 +01001284
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001285 traceBeginAndSlog("StartHardwarePropertiesManagerService");
Polina Bondarenkof8754ac2016-02-12 20:38:23 +01001286 try {
1287 hardwarePropertiesService = new HardwarePropertiesManagerService(context);
1288 ServiceManager.addService(Context.HARDWARE_PROPERTIES_SERVICE,
1289 hardwarePropertiesService);
1290 } catch (Throwable e) {
1291 Slog.e(TAG, "Failure starting HardwarePropertiesManagerService", e);
1292 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001293 traceEnd();
Mike Lockwoodb01e8bf2011-08-29 20:11:07 -04001294 }
1295
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001296 traceBeginAndSlog("StartTwilightService");
Jeff Brown6f357d32014-01-15 20:40:55 -08001297 mSystemServiceManager.startService(TwilightService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001298 traceEnd();
Jeff Brown2416e092012-08-21 22:12:20 -07001299
Justin Klaassen911e8892016-06-21 18:24:24 -07001300 if (NightDisplayController.isAvailable(context)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001301 traceBeginAndSlog("StartNightDisplay");
Justin Klaassen911e8892016-06-21 18:24:24 -07001302 mSystemServiceManager.startService(NightDisplayService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001303 traceEnd();
Justin Klaassen911e8892016-06-21 18:24:24 -07001304 }
1305
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001306 traceBeginAndSlog("StartJobScheduler");
Christopher Tate7060b042014-06-09 19:50:00 -07001307 mSystemServiceManager.startService(JobSchedulerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001308 traceEnd();
Christopher Tatefa380e92014-05-19 13:46:29 -07001309
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001310 traceBeginAndSlog("StartSoundTrigger");
Arunesh Mishraa772e5f2016-01-25 10:33:11 -08001311 mSystemServiceManager.startService(SoundTriggerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001312 traceEnd();
Arunesh Mishraa772e5f2016-01-25 10:33:11 -08001313
Dan Morrille4d9a012013-03-28 18:10:43 -07001314 if (!disableNonCoreServices) {
Jeff Sharkey73ea0ae2016-08-10 17:30:38 -06001315 if (!disableTrustManager) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001316 traceBeginAndSlog("StartTrustManager");
Jeff Sharkey73ea0ae2016-08-10 17:30:38 -06001317 mSystemServiceManager.startService(TrustManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001318 traceEnd();
Jeff Sharkey73ea0ae2016-08-10 17:30:38 -06001319 }
1320
Jeff Brown2c43c332014-06-12 22:38:59 -07001321 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_BACKUP)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001322 traceBeginAndSlog("StartBackupManager");
Jeff Brown2c43c332014-06-12 22:38:59 -07001323 mSystemServiceManager.startService(BACKUP_MANAGER_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001324 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001325 }
Christopher Tate487529a2009-04-29 14:03:25 -07001326
Dmitri Plotnikov0a3e1732016-03-25 17:24:57 -07001327 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_APP_WIDGETS)
1328 || context.getResources().getBoolean(R.bool.config_enableAppWidgetService)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001329 traceBeginAndSlog("StartAppWidgerService");
Jeff Brown2c43c332014-06-12 22:38:59 -07001330 mSystemServiceManager.startService(APPWIDGET_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001331 traceEnd();
Dan Morrille4d9a012013-03-28 18:10:43 -07001332 }
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001333
Jeff Brown2c43c332014-06-12 22:38:59 -07001334 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_VOICE_RECOGNIZERS)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001335 traceBeginAndSlog("StartVoiceRecognitionManager");
Jeff Brown2c43c332014-06-12 22:38:59 -07001336 mSystemServiceManager.startService(VOICE_RECOGNITION_MANAGER_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001337 traceEnd();
Dianne Hackborn91097de2014-04-04 18:02:06 -07001338 }
Zhentao Sunc6cd1f92015-07-21 17:43:53 -07001339
1340 if (GestureLauncherService.isGestureLauncherEnabled(context.getResources())) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001341 traceBeginAndSlog("StartGestureLauncher");
Zhentao Sunc6cd1f92015-07-21 17:43:53 -07001342 mSystemServiceManager.startService(GestureLauncherService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001343 traceEnd();
Zhentao Sunc6cd1f92015-07-21 17:43:53 -07001344 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001345 traceBeginAndSlog("StartSensorNotification");
Peng Xua35b5532016-01-20 00:05:45 -08001346 mSystemServiceManager.startService(SensorNotificationService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001347 traceEnd();
1348
1349 traceBeginAndSlog("StartContextHubSystemService");
Peng Xu9ff7d222016-02-11 13:02:05 -08001350 mSystemServiceManager.startService(ContextHubSystemService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001351 traceEnd();
Dianne Hackborn21f1bd12010-02-19 17:02:21 -08001352 }
Jaikumar Ganesh7d0548d2010-10-18 15:29:09 -07001353
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001354 traceBeginAndSlog("StartDiskStatsService");
Nick Pelly038cabe2010-09-23 16:12:11 -07001355 try {
Dan Egnor621bc542010-03-25 16:20:14 -07001356 ServiceManager.addService("diskstats", new DiskStatsService(context));
1357 } catch (Throwable e) {
Dianne Hackborn661cd522011-08-22 00:26:20 -07001358 reportWtf("starting DiskStats Service", e);
Dan Egnor621bc542010-03-25 16:20:14 -07001359 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001360 traceEnd();
Sen Hubde75702010-05-28 01:54:03 -07001361
Chenjie Luo2cab8822014-10-16 13:31:39 -07001362 if (!disableNetwork && !disableNetworkTime) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001363 traceBeginAndSlog("StartNetworkTimeUpdateService");
Dan Morrille4d9a012013-03-28 18:10:43 -07001364 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001365 networkTimeUpdater = new NetworkTimeUpdateService(context);
Fyodor Kupolov32af07a2016-02-26 16:54:25 -08001366 ServiceManager.addService("network_time_update_service", networkTimeUpdater);
Dan Morrille4d9a012013-03-28 18:10:43 -07001367 } catch (Throwable e) {
1368 reportWtf("starting NetworkTimeUpdate service", e);
1369 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001370 traceEnd();
Amith Yamasani6734b9f2010-09-13 16:24:08 -07001371 }
John Grossmanc1576732012-02-01 15:23:33 -08001372
Yasuhiro Matsudaebf94652015-09-02 22:48:13 +09001373 traceBeginAndSlog("StartCommonTimeManagementService");
John Spurlockb4f01b92015-03-24 12:40:15 -04001374 try {
John Spurlockb4f01b92015-03-24 12:40:15 -04001375 commonTimeMgmtService = new CommonTimeManagementService(context);
1376 ServiceManager.addService("commontime_management", commonTimeMgmtService);
1377 } catch (Throwable e) {
1378 reportWtf("starting CommonTimeManagementService service", e);
John Grossmanc1576732012-02-01 15:23:33 -08001379 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001380 traceEnd();
Geremy Condra3d33c262012-05-06 18:32:19 -07001381
Dan Morrille4d9a012013-03-28 18:10:43 -07001382 if (!disableNetwork) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001383 traceBeginAndSlog("CertBlacklister");
Dan Morrille4d9a012013-03-28 18:10:43 -07001384 try {
Dan Morrille4d9a012013-03-28 18:10:43 -07001385 CertBlacklister blacklister = new CertBlacklister(context);
1386 } catch (Throwable e) {
1387 reportWtf("starting CertBlacklister", e);
1388 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001389 traceEnd();
Geremy Condra3d33c262012-05-06 18:32:19 -07001390 }
Jim Miller5ecd8112013-01-09 18:50:26 -08001391
Selim Cinek705442f2016-09-13 16:02:33 -07001392 if (!disableNetwork && !disableNonCoreServices && EmergencyAffordanceManager.ENABLED) {
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001393 // EmergencyMode service
1394 traceBeginAndSlog("StartEmergencyAffordanceService");
Selim Cinek705442f2016-09-13 16:02:33 -07001395 mSystemServiceManager.startService(EmergencyAffordanceService.class);
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001396 traceEnd();
Selim Cinek705442f2016-09-13 16:02:33 -07001397 }
1398
Jeff Browne0dd3ca82014-02-24 13:57:53 -08001399 if (!disableNonCoreServices) {
1400 // Dreams (interactive idle-time views, a/k/a screen savers, and doze mode)
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001401 traceBeginAndSlog("StartDreamManager");
Jeff Brown567f7ca2014-01-30 23:38:03 -08001402 mSystemServiceManager.startService(DreamManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001403 traceEnd();
Daniel Sandler7d276c32012-01-30 14:33:52 -05001404 }
Svetoslavb3038ec2013-02-13 14:39:30 -08001405
John Reckedc524c2015-03-18 15:24:33 -07001406 if (!disableNonCoreServices) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001407 traceBeginAndSlog("AddGraphicsStatsService");
John Reckedc524c2015-03-18 15:24:33 -07001408 ServiceManager.addService(GraphicsStatsService.GRAPHICS_STATS_SERVICE,
1409 new GraphicsStatsService(context));
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001410 traceEnd();
John Reckedc524c2015-03-18 15:24:33 -07001411 }
1412
Allen Hair1f556e32016-11-11 15:42:50 -08001413 if (!disableNonCoreServices && CoverageService.ENABLED) {
1414 traceBeginAndSlog("AddCoverageService");
1415 ServiceManager.addService(CoverageService.COVERAGE_SERVICE, new CoverageService());
1416 traceEnd();
1417 }
1418
Jeff Brown2c43c332014-06-12 22:38:59 -07001419 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PRINTING)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001420 traceBeginAndSlog("StartPrintManager");
Jeff Brown2c43c332014-06-12 22:38:59 -07001421 mSystemServiceManager.startService(PRINT_MANAGER_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001422 traceEnd();
Svetoslav Ganov4b9a4d12013-06-11 15:20:06 -07001423 }
Jeff Brown69b07162013-11-07 00:30:16 -08001424
Eugene Susla7c3eef22017-03-10 14:25:58 -08001425 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_COMPANION_DEVICE_SETUP)) {
1426 traceBeginAndSlog("StartCompanionDeviceManager");
1427 mSystemServiceManager.startService(COMPANION_DEVICE_MANAGER_SERVICE_CLASS);
1428 traceEnd();
1429 }
Eugene Susla6ed45d82017-01-22 13:52:51 -08001430
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001431 traceBeginAndSlog("StartRestrictionManager");
Jeff Brown2c43c332014-06-12 22:38:59 -07001432 mSystemServiceManager.startService(RestrictionsManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001433 traceEnd();
Amith Yamasanif20d6402014-05-24 15:34:37 -07001434
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001435 traceBeginAndSlog("StartMediaSessionService");
Jeff Brown2c43c332014-06-12 22:38:59 -07001436 mSystemServiceManager.startService(MediaSessionService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001437 traceEnd();
RoboErik01fe6612014-02-13 14:19:04 -08001438
Yuncheol Heoa0c4a062014-07-10 20:49:27 +09001439 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_HDMI_CEC)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001440 traceBeginAndSlog("StartHdmiControlService");
Yuncheol Heoa0c4a062014-07-10 20:49:27 +09001441 mSystemServiceManager.startService(HdmiControlService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001442 traceEnd();
Yuncheol Heoa0c4a062014-07-10 20:49:27 +09001443 }
Jungshik Jang0792d372014-04-23 17:57:26 +09001444
Conrad Chen558acf92017-04-05 17:31:01 -07001445 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LIVE_TV)
1446 || mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001447 traceBeginAndSlog("StartTvInputManager");
Dongwon Kang0fdcb742014-07-24 16:28:35 +09001448 mSystemServiceManager.startService(TvInputManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001449 traceEnd();
Dongwon Kang0fdcb742014-07-24 16:28:35 +09001450 }
Jae Seo39570912014-02-20 18:23:25 -08001451
Dongwon Kangd8b81b32016-03-23 18:04:19 -07001452 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001453 traceBeginAndSlog("StartMediaResourceMonitor");
Dongwon Kangd8b81b32016-03-23 18:04:19 -07001454 mSystemServiceManager.startService(MediaResourceMonitorService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001455 traceEnd();
Dongwon Kangd8b81b32016-03-23 18:04:19 -07001456 }
Dongwon Kang2034a4c2015-12-14 21:57:34 +09001457
Sujith Ramakrishnanb5b86c12016-01-28 16:53:16 -08001458 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_LEANBACK)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001459 traceBeginAndSlog("StartTvRemoteService");
Sujith Ramakrishnanb5b86c12016-01-28 16:53:16 -08001460 mSystemServiceManager.startService(TvRemoteService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001461 traceEnd();
Sujith Ramakrishnanb5b86c12016-01-28 16:53:16 -08001462 }
1463
Jeff Brown69b07162013-11-07 00:30:16 -08001464 if (!disableNonCoreServices) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001465 traceBeginAndSlog("StartMediaRouterService");
Jeff Brown69b07162013-11-07 00:30:16 -08001466 try {
Jeff Brown69b07162013-11-07 00:30:16 -08001467 mediaRouter = new MediaRouterService(context);
1468 ServiceManager.addService(Context.MEDIA_ROUTER_SERVICE, mediaRouter);
1469 } catch (Throwable e) {
1470 reportWtf("starting MediaRouterService", e);
1471 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001472 traceEnd();
Adrian Roos82142c22014-03-27 14:56:59 +01001473
Wei Liueac5a802016-02-03 14:31:37 -08001474 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001475 traceBeginAndSlog("StartFingerprintSensor");
Wei Liueac5a802016-02-03 14:31:37 -08001476 mSystemServiceManager.startService(FingerprintService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001477 traceEnd();
Wei Liueac5a802016-02-03 14:31:37 -08001478 }
Jim Millera75961472014-06-06 15:00:49 -07001479
Calin Juravle91d40f12017-03-15 18:38:57 -07001480 traceBeginAndSlog("StartBackgroundDexOptService");
Jim Millera75961472014-06-06 15:00:49 -07001481 try {
Calin Juravle91d40f12017-03-15 18:38:57 -07001482 BackgroundDexOptService.schedule(context);
Brian Carlstrom7395a8a2014-04-28 22:11:01 -07001483 } catch (Throwable e) {
Calin Juravle91d40f12017-03-15 18:38:57 -07001484 reportWtf("starting StartBackgroundDexOptService", e);
Svetoslav Ganov096d3042017-01-30 16:34:13 -08001485 }
1486 traceEnd();
1487
1488 traceBeginAndSlog("StartPruneInstantAppsJobService");
1489 try {
1490 PruneInstantAppsJobService.schedule(context);
1491 } catch (Throwable e) {
1492 reportWtf("StartPruneInstantAppsJobService", e);
Brian Carlstrom7395a8a2014-04-28 22:11:01 -07001493 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001494 traceEnd();
Jeff Brown69b07162013-11-07 00:30:16 -08001495 }
Makoto Onuki55046222016-03-08 10:49:47 -08001496 // LauncherAppsService uses ShortcutService.
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001497 traceBeginAndSlog("StartShortcutServiceLifecycle");
Makoto Onuki55046222016-03-08 10:49:47 -08001498 mSystemServiceManager.startService(ShortcutService.Lifecycle.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001499 traceEnd();
Amith Yamasani4f582632014-02-19 14:31:52 -08001500
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001501 traceBeginAndSlog("StartLauncherAppsService");
Jeff Brown2c43c332014-06-12 22:38:59 -07001502 mSystemServiceManager.startService(LauncherAppsService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001503 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001504 }
1505
Wei Liu6aaabae2016-03-04 14:50:16 -08001506 if (!disableNonCoreServices && !disableMediaProjection) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001507 traceBeginAndSlog("StartMediaProjectionManager");
Michael Wrightc39d47a2014-07-08 18:07:36 -07001508 mSystemServiceManager.startService(MediaProjectionManagerService.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001509 traceEnd();
Michael Wrightc39d47a2014-07-08 18:07:36 -07001510 }
1511
Wei Liu48d3b632016-03-29 15:26:48 -07001512 if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH)) {
Calvin Ona91e5362017-02-22 15:16:42 -08001513 traceBeginAndSlog("StartWearConnectivityService");
Calvin On5555bcc2017-02-21 16:41:43 -08001514 mSystemServiceManager.startService(WEAR_CONNECTIVITY_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001515 traceEnd();
Zach Johnsonb82f3b02017-01-16 15:15:25 -08001516
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001517 if (!disableNonCoreServices) {
1518 traceBeginAndSlog("StartWearTimeService");
Julius D'souza069f46c2017-03-22 13:27:00 -07001519 mSystemServiceManager.startService(WEAR_DISPLAY_SERVICE_CLASS);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001520 mSystemServiceManager.startService(WEAR_TIME_SERVICE_CLASS);
1521 traceEnd();
Ivan Podogovf9973822017-05-11 15:51:34 +01001522
1523 if (enableLeftyService) {
1524 traceBeginAndSlog("StartWearLeftyService");
1525 mSystemServiceManager.startService(WEAR_LEFTY_SERVICE_CLASS);
1526 traceEnd();
1527 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001528 }
Wei Liu48d3b632016-03-29 15:26:48 -07001529 }
1530
Eino-Ville Talvalae91012b2017-07-10 15:27:24 -07001531 if (!disableCameraService) {
1532 traceBeginAndSlog("StartCameraServiceProxy");
1533 mSystemServiceManager.startService(CameraServiceProxy.class);
1534 traceEnd();
1535 }
1536
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001537 // Before things start rolling, be sure we have decided whether
1538 // we are in safe mode.
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001539 final boolean safeMode = wm.detectSafeMode();
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001540 if (safeMode) {
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001541 traceBeginAndSlog("EnterSafeModeAndDisableJitCompilation");
Jeff Brown4ccb8232014-01-16 22:16:42 -08001542 mActivityManagerService.enterSafeMode();
Jeff Brownb09abc12011-01-13 21:08:27 -08001543 // Disable the JIT for the system_server process
1544 VMRuntime.getRuntime().disableJitCompilation();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001545 traceEnd();
Ben Cheng6c0afff2010-02-14 16:18:56 -08001546 } else {
1547 // Enable the JIT for the system_server process
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001548 traceBeginAndSlog("StartJitCompilation");
Ben Cheng6c0afff2010-02-14 16:18:56 -08001549 VMRuntime.getRuntime().startJitCompilation();
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001550 traceEnd();
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001551 }
Doug Zongkerab5c49c2009-12-04 10:31:43 -08001552
Ye Wend97e1fd2014-07-24 12:56:45 -07001553 // MMS service broker
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001554 traceBeginAndSlog("StartMmsService");
Ye Wend97e1fd2014-07-24 12:56:45 -07001555 mmsService = mSystemServiceManager.startService(MmsServiceBroker.class);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001556 traceEnd();
Ye Wend97e1fd2014-07-24 12:56:45 -07001557
Svet Ganov43574b02017-04-12 09:25:20 -07001558 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOFILL)) {
1559 traceBeginAndSlog("StartAutoFillService");
1560 mSystemServiceManager.startService(AUTO_FILL_MANAGER_SERVICE_CLASS);
1561 traceEnd();
1562 }
Felipe Leme5381aa42016-10-13 09:02:32 -07001563
Dianne Hackborn6af0d502009-09-28 13:25:46 -07001564 // It is now time to start up the app processes...
Joe Onorato30275482009-07-08 17:09:14 -07001565
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001566 traceBeginAndSlog("MakeVibratorServiceReady");
Jeff Brown7f6c2312012-04-13 20:38:38 -07001567 try {
1568 vibrator.systemReady();
1569 } catch (Throwable e) {
1570 reportWtf("making Vibrator Service ready", e);
1571 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001572 traceEnd();
Jeff Brown7f6c2312012-04-13 20:38:38 -07001573
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001574 traceBeginAndSlog("MakeLockSettingsServiceReady");
Dan Morrille4d9a012013-03-28 18:10:43 -07001575 if (lockSettings != null) {
1576 try {
1577 lockSettings.systemReady();
1578 } catch (Throwable e) {
1579 reportWtf("making Lock Settings Service ready", e);
1580 }
Felipe Ramosf35df5b2012-09-18 18:26:27 -03001581 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001582 traceEnd();
Felipe Ramosf35df5b2012-09-18 18:26:27 -03001583
Amith Yamasani817ec492013-12-20 13:27:30 -08001584 // Needed by DevicePolicyManager for initialization
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001585 traceBeginAndSlog("StartBootPhaseLockSettingsReady");
Jeff Brown6f357d32014-01-15 20:40:55 -08001586 mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001587 traceEnd();
Dianne Hackbornd6847842010-01-12 18:14:19 -08001588
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001589 traceBeginAndSlog("StartBootPhaseSystemServicesReady");
Jeff Brown6f357d32014-01-15 20:40:55 -08001590 mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001591 traceEnd();
Joe Onorato30275482009-07-08 17:09:14 -07001592
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001593 traceBeginAndSlog("MakeWindowManagerServiceReady");
Dianne Hackborn661cd522011-08-22 00:26:20 -07001594 try {
1595 wm.systemReady();
1596 } catch (Throwable e) {
1597 reportWtf("making Window Manager Service ready", e);
1598 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001599 traceEnd();
Joe Onoratodc565f42010-10-04 15:27:22 -04001600
Jeff Brownb09abc12011-01-13 21:08:27 -08001601 if (safeMode) {
Jeff Brown4ccb8232014-01-16 22:16:42 -08001602 mActivityManagerService.showSafeModeOverlay();
Jeff Brownb09abc12011-01-13 21:08:27 -08001603 }
1604
Joe Onoratodc565f42010-10-04 15:27:22 -04001605 // Update the configuration for this context by hand, because we're going
1606 // to start using it before the config change done in wm.systemReady() will
1607 // propagate to it.
Andrii Kulian5406e7a2016-10-21 11:55:23 -07001608 final Configuration config = wm.computeNewConfiguration(DEFAULT_DISPLAY);
Joe Onoratodc565f42010-10-04 15:27:22 -04001609 DisplayMetrics metrics = new DisplayMetrics();
1610 WindowManager w = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
1611 w.getDefaultDisplay().getMetrics(metrics);
1612 context.getResources().updateConfiguration(config, metrics);
1613
Alan Viverette395cd012015-08-11 17:27:04 -04001614 // The system context's theme may be configuration-dependent.
1615 final Theme systemTheme = context.getTheme();
1616 if (systemTheme.getChangingConfigurations() != 0) {
1617 systemTheme.rebase();
1618 }
1619
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001620 traceBeginAndSlog("MakePowerManagerServiceReady");
Jeff Brownaa202a62012-08-21 22:14:26 -07001621 try {
Jeff Brown6f357d32014-01-15 20:40:55 -08001622 // TODO: use boot phase
Jeff Brown21392762014-06-13 19:00:36 -07001623 mPowerManagerService.systemReady(mActivityManagerService.getAppOpsService());
Jeff Brownaa202a62012-08-21 22:14:26 -07001624 } catch (Throwable e) {
1625 reportWtf("making Power Manager Service ready", e);
1626 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001627 traceEnd();
Jeff Brownaa202a62012-08-21 22:14:26 -07001628
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001629 traceBeginAndSlog("MakePackageManagerServiceReady");
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001630 try {
Jeff Brown2c43c332014-06-12 22:38:59 -07001631 mPackageManagerService.systemReady();
Dianne Hackborn661cd522011-08-22 00:26:20 -07001632 } catch (Throwable e) {
1633 reportWtf("making Package Manager Service ready", e);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001634 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001635 traceEnd();
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001636
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001637 traceBeginAndSlog("MakeDisplayManagerServiceReady");
Jeff Brownbd6e1502012-08-28 03:27:37 -07001638 try {
Jeff Brown4ccb8232014-01-16 22:16:42 -08001639 // TODO: use boot phase and communicate these flags some other way
Jeff Brown2c43c332014-06-12 22:38:59 -07001640 mDisplayManagerService.systemReady(safeMode, mOnlyCore);
Jeff Brownbd6e1502012-08-28 03:27:37 -07001641 } catch (Throwable e) {
1642 reportWtf("making Display Manager Service ready", e);
1643 }
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001644 traceEnd();
Jeff Brownbd6e1502012-08-28 03:27:37 -07001645
joonyoung.cho2f30cc12015-04-08 13:56:34 +09001646 mSystemServiceManager.setSafeMode(safeMode);
1647
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001648 // These are needed to propagate to the runnable below.
Jeff Sharkey350083e2011-06-29 10:45:16 -07001649 final NetworkManagementService networkManagementF = networkManagement;
Jeff Sharkey75279902011-05-24 18:39:45 -07001650 final NetworkStatsService networkStatsF = networkStats;
Jeff Sharkeya4620792011-05-20 15:29:23 -07001651 final NetworkPolicyManagerService networkPolicyF = networkPolicy;
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001652 final ConnectivityService connectivityF = connectivity;
Jeff Davidson6a4b2202014-04-16 17:29:40 -07001653 final NetworkScoreService networkScoreF = networkScore;
Mike Lockwood46db5042010-02-22 16:36:44 -05001654 final LocationManagerService locationF = location;
Bai Taoa58a8752010-07-13 15:32:16 +08001655 final CountryDetectorService countryDetectorF = countryDetector;
Amith Yamasani6734b9f2010-09-13 16:24:08 -07001656 final NetworkTimeUpdateService networkTimeUpdaterF = networkTimeUpdater;
John Grossmanc1576732012-02-01 15:23:33 -08001657 final CommonTimeManagementService commonTimeMgmtServiceF = commonTimeMgmtService;
Jeff Brown6ec6f792012-04-17 16:52:41 -07001658 final InputManagerService inputManagerF = inputManager;
Wink Savillea12a7b32012-09-20 10:09:45 -07001659 final TelephonyRegistry telephonyRegistryF = telephonyRegistry;
Jeff Brown69b07162013-11-07 00:30:16 -08001660 final MediaRouterService mediaRouterF = mediaRouter;
Ye Wend97e1fd2014-07-24 12:56:45 -07001661 final MmsServiceBroker mmsServiceF = mmsService;
Keun-young Park4136d2d2017-05-08 14:51:59 -07001662 final WindowManagerService windowManagerF = wm;
Doug Zongkerab5c49c2009-12-04 10:31:43 -08001663
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001664 // We now tell the activity manager it is okay to run third party
1665 // code. It will call back into us once it has gotten to the state
1666 // where third party code can really run (but before it has actually
1667 // started launching the initial applications), for us to complete our
1668 // initialization.
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001669 mActivityManagerService.systemReady(() -> {
1670 Slog.i(TAG, "Making services ready");
1671 traceBeginAndSlog("StartActivityManagerReadyPhase");
1672 mSystemServiceManager.startBootPhase(
1673 SystemService.PHASE_ACTIVITY_MANAGER_READY);
1674 traceEnd();
1675 traceBeginAndSlog("StartObservingNativeCrashes");
1676 try {
1677 mActivityManagerService.startObservingNativeCrashes();
1678 } catch (Throwable e) {
1679 reportWtf("observing native crashes", e);
Dianne Hackborna34f1ad2009-09-02 13:26:28 -07001680 }
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001681 traceEnd();
1682
Keun-young Parkd80e8942017-01-27 11:30:19 -08001683 // No dependency on Webview preparation in system server. But this should
1684 // be completed before allowring 3rd party
1685 final String WEBVIEW_PREPARATION = "WebViewFactoryPreparation";
1686 Future<?> webviewPrep = null;
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001687 if (!mOnlyCore) {
Keun-young Parkd80e8942017-01-27 11:30:19 -08001688 webviewPrep = SystemServerInitThreadPool.get().submit(() -> {
1689 Slog.i(TAG, WEBVIEW_PREPARATION);
Fyodor Kupolov6e3461b2017-08-10 17:00:43 -07001690 TimingsTraceLog traceLog = new TimingsTraceLog(
Keun-young Park9b73a542017-02-01 12:09:58 -08001691 SYSTEM_SERVER_TIMING_ASYNC_TAG, Trace.TRACE_TAG_SYSTEM_SERVER);
Keun-young Parkd80e8942017-01-27 11:30:19 -08001692 traceLog.traceBegin(WEBVIEW_PREPARATION);
Narayan Kamath97780462017-02-06 20:24:08 +00001693 ConcurrentUtils.waitForFutureNoInterrupt(mZygotePreload, "Zygote preload");
1694 mZygotePreload = null;
Keun-young Parkd80e8942017-01-27 11:30:19 -08001695 mWebViewUpdateService.prepareWebViewInSystemServer();
1696 traceLog.traceEnd();
1697 }, WEBVIEW_PREPARATION);
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001698 }
1699
Keun-young Park067cf3e2017-06-05 12:20:41 -07001700 if (mPackageManager.hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE)) {
1701 traceBeginAndSlog("StartCarServiceHelperService");
1702 mSystemServiceManager.startService(CarServiceHelperService.class);
1703 traceEnd();
1704 }
1705
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001706 traceBeginAndSlog("StartSystemUI");
1707 try {
Keun-young Park4136d2d2017-05-08 14:51:59 -07001708 startSystemUi(context, windowManagerF);
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001709 } catch (Throwable e) {
1710 reportWtf("starting System UI", e);
1711 }
1712 traceEnd();
1713 traceBeginAndSlog("MakeNetworkScoreReady");
1714 try {
1715 if (networkScoreF != null) networkScoreF.systemReady();
1716 } catch (Throwable e) {
1717 reportWtf("making Network Score Service ready", e);
1718 }
1719 traceEnd();
1720 traceBeginAndSlog("MakeNetworkManagementServiceReady");
1721 try {
1722 if (networkManagementF != null) networkManagementF.systemReady();
1723 } catch (Throwable e) {
1724 reportWtf("making Network Managment Service ready", e);
1725 }
1726 CountDownLatch networkPolicyInitReadySignal = null;
1727 if (networkPolicyF != null) {
1728 networkPolicyInitReadySignal = networkPolicyF
1729 .networkScoreAndNetworkManagementServiceReady();
1730 }
1731 traceEnd();
1732 traceBeginAndSlog("MakeNetworkStatsServiceReady");
1733 try {
1734 if (networkStatsF != null) networkStatsF.systemReady();
1735 } catch (Throwable e) {
1736 reportWtf("making Network Stats Service ready", e);
1737 }
1738 traceEnd();
1739 traceBeginAndSlog("MakeConnectivityServiceReady");
1740 try {
1741 if (connectivityF != null) connectivityF.systemReady();
1742 } catch (Throwable e) {
1743 reportWtf("making Connectivity Service ready", e);
1744 }
1745 traceEnd();
1746 traceBeginAndSlog("MakeNetworkPolicyServiceReady");
1747 try {
1748 if (networkPolicyF != null) {
1749 networkPolicyF.systemReady(networkPolicyInitReadySignal);
1750 }
1751 } catch (Throwable e) {
1752 reportWtf("making Network Policy Service ready", e);
1753 }
1754 traceEnd();
1755
1756 traceBeginAndSlog("StartWatchdog");
1757 Watchdog.getInstance().start();
1758 traceEnd();
1759
Fyodor Kupolovcd824ef2017-02-07 11:25:14 -08001760 // Wait for all packages to be prepared
1761 mPackageManagerService.waitForAppDataPrepared();
1762
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001763 // It is now okay to let the various system services start their
1764 // third party code...
1765 traceBeginAndSlog("PhaseThirdPartyAppsCanStart");
Keun-young Park9b73a542017-02-01 12:09:58 -08001766 // confirm webview completion before starting 3rd party
1767 if (webviewPrep != null) {
1768 ConcurrentUtils.waitForFutureNoInterrupt(webviewPrep, WEBVIEW_PREPARATION);
1769 }
Fyodor Kupolov6dd2ba22016-12-07 13:03:17 -08001770 mSystemServiceManager.startBootPhase(
1771 SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
1772 traceEnd();
1773
1774 traceBeginAndSlog("MakeLocationServiceReady");
1775 try {
1776 if (locationF != null) locationF.systemRunning();
1777 } catch (Throwable e) {
1778 reportWtf("Notifying Location Service running", e);
1779 }
1780 traceEnd();
1781 traceBeginAndSlog("MakeCountryDetectionServiceReady");
1782 try {
1783 if (countryDetectorF != null) countryDetectorF.systemRunning();
1784 } catch (Throwable e) {
1785 reportWtf("Notifying CountryDetectorService running", e);
1786 }
1787 traceEnd();
1788 traceBeginAndSlog("MakeNetworkTimeUpdateReady");
1789 try {
1790 if (networkTimeUpdaterF != null) networkTimeUpdaterF.systemRunning();
1791 } catch (Throwable e) {
1792 reportWtf("Notifying NetworkTimeService running", e);
1793 }
1794 traceEnd();
1795 traceBeginAndSlog("MakeCommonTimeManagementServiceReady");
1796 try {
1797 if (commonTimeMgmtServiceF != null) {
1798 commonTimeMgmtServiceF.systemRunning();
1799 }
1800 } catch (Throwable e) {
1801 reportWtf("Notifying CommonTimeManagementService running", e);
1802 }
1803 traceEnd();
1804 traceBeginAndSlog("MakeInputManagerServiceReady");
1805 try {
1806 // TODO(BT) Pass parameter to input manager
1807 if (inputManagerF != null) inputManagerF.systemRunning();
1808 } catch (Throwable e) {
1809 reportWtf("Notifying InputManagerService running", e);
1810 }
1811 traceEnd();
1812 traceBeginAndSlog("MakeTelephonyRegistryReady");
1813 try {
1814 if (telephonyRegistryF != null) telephonyRegistryF.systemRunning();
1815 } catch (Throwable e) {
1816 reportWtf("Notifying TelephonyRegistry running", e);
1817 }
1818 traceEnd();
1819 traceBeginAndSlog("MakeMediaRouterServiceReady");
1820 try {
1821 if (mediaRouterF != null) mediaRouterF.systemRunning();
1822 } catch (Throwable e) {
1823 reportWtf("Notifying MediaRouterService running", e);
1824 }
1825 traceEnd();
1826 traceBeginAndSlog("MakeMmsServiceReady");
1827 try {
1828 if (mmsServiceF != null) mmsServiceF.systemRunning();
1829 } catch (Throwable e) {
1830 reportWtf("Notifying MmsService running", e);
1831 }
1832 traceEnd();
1833
1834 traceBeginAndSlog("MakeNetworkScoreServiceReady");
1835 try {
1836 if (networkScoreF != null) networkScoreF.systemRunning();
1837 } catch (Throwable e) {
1838 reportWtf("Notifying NetworkScoreService running", e);
1839 }
1840 traceEnd();
1841 traceBeginAndSlog("IncidentDaemonReady");
1842 try {
1843 // TODO: Switch from checkService to getService once it's always
1844 // in the build and should reliably be there.
1845 final IIncidentManager incident = IIncidentManager.Stub.asInterface(
1846 ServiceManager.checkService("incident"));
1847 if (incident != null) incident.systemRunning();
1848 } catch (Throwable e) {
1849 reportWtf("Notifying incident daemon running", e);
1850 }
1851 traceEnd();
1852 }, BOOT_TIMINGS_TRACE_LOG);
The Android Open Source Project9066cfe2009-03-03 19:31:44 -08001853 }
Joe Onoratof3c3c4f2010-10-21 11:09:02 -04001854
Keun-young Park4136d2d2017-05-08 14:51:59 -07001855 static final void startSystemUi(Context context, WindowManagerService windowManager) {
Joe Onoratof3c3c4f2010-10-21 11:09:02 -04001856 Intent intent = new Intent();
1857 intent.setComponent(new ComponentName("com.android.systemui",
1858 "com.android.systemui.SystemUIService"));
Jeff Sharkey2f3e3532015-12-21 14:16:43 -07001859 intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING);
Dianne Hackborn40e9f292012-11-27 19:12:23 -08001860 //Slog.d(TAG, "Starting service: " + intent);
Xiaohui Chen70f6c382015-04-28 14:21:43 -07001861 context.startServiceAsUser(intent, UserHandle.SYSTEM);
Keun-young Park4136d2d2017-05-08 14:51:59 -07001862 windowManager.onSystemUiStarted();
Joe Onoratof3c3c4f2010-10-21 11:09:02 -04001863 }
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001864
1865 private static void traceBeginAndSlog(String name) {
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001866 Slog.i(TAG, name);
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -08001867 BOOT_TIMINGS_TRACE_LOG.traceBegin(name);
Vitalii Tomkiv4887e672016-07-21 15:58:24 -07001868 }
1869
1870 private static void traceEnd() {
Fyodor Kupolov3235e0c2016-11-17 11:44:49 -08001871 BOOT_TIMINGS_TRACE_LOG.traceEnd();
Yasuhiro Matsuda1ab43d52015-06-30 17:07:32 +09001872 }
Nicolas Geoffray27c07372015-11-05 16:54:09 +00001873}