1/*
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
19import com.android.server.am.ActivityManagerService;
20import com.android.server.usb.UsbService;
21import com.android.internal.app.ShutdownThread;
22import com.android.internal.os.BinderInternal;
23import com.android.internal.os.SamplingProfilerIntegration;
24
25import dalvik.system.VMRuntime;
26import dalvik.system.Zygote;
27
28import android.app.ActivityManagerNative;
29import android.bluetooth.BluetoothAdapter;
30import android.content.ComponentName;
31import android.content.ContentResolver;
32import android.content.ContentService;
33import android.content.Context;
34import android.content.Intent;
35import android.content.pm.IPackageManager;
36import android.database.ContentObserver;
37import android.database.Cursor;
38import android.media.AudioService;
39import android.os.Looper;
40import android.os.RemoteException;
41import android.os.ServiceManager;
42import android.os.StrictMode;
43import android.os.SystemClock;
44import android.os.SystemProperties;
45import android.provider.Contacts.People;
46import android.provider.Settings;
47import android.server.BluetoothA2dpService;
48import android.server.BluetoothService;
49import android.server.search.SearchManagerService;
50import android.util.EventLog;
51import android.util.Log;
52import android.util.Slog;
53import android.accounts.AccountManagerService;
54
55import java.io.File;
56import java.util.Timer;
57import java.util.TimerTask;
58
59class ServerThread extends Thread {
60    private static final String TAG = "SystemServer";
61    private final static boolean INCLUDE_DEMO = false;
62
63    private static final int LOG_BOOT_PROGRESS_SYSTEM_RUN = 3010;
64
65    private ContentResolver mContentResolver;
66
67    private class AdbSettingsObserver extends ContentObserver {
68        public AdbSettingsObserver() {
69            super(null);
70        }
71        @Override
72        public void onChange(boolean selfChange) {
73            boolean enableAdb = (Settings.Secure.getInt(mContentResolver,
74                Settings.Secure.ADB_ENABLED, 0) > 0);
75            // setting this secure property will start or stop adbd
76           SystemProperties.set("persist.service.adb.enable", enableAdb ? "1" : "0");
77        }
78    }
79
80    @Override
81    public void run() {
82        EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN,
83            SystemClock.uptimeMillis());
84
85        Looper.prepare();
86
87        android.os.Process.setThreadPriority(
88                android.os.Process.THREAD_PRIORITY_FOREGROUND);
89
90        BinderInternal.disableBackgroundScheduling(true);
91        android.os.Process.setCanSelfBackground(false);
92
93        // Check whether we failed to shut down last time we tried.
94        {
95            final String shutdownAction = SystemProperties.get(
96                    ShutdownThread.SHUTDOWN_ACTION_PROPERTY, "");
97            if (shutdownAction != null && shutdownAction.length() > 0) {
98                boolean reboot = (shutdownAction.charAt(0) == '1');
99
100                final String reason;
101                if (shutdownAction.length() > 1) {
102                    reason = shutdownAction.substring(1, shutdownAction.length());
103                } else {
104                    reason = null;
105                }
106
107                ShutdownThread.rebootOrShutdown(reboot, reason);
108            }
109        }
110
111        String factoryTestStr = SystemProperties.get("ro.factorytest");
112        int factoryTest = "".equals(factoryTestStr) ? SystemServer.FACTORY_TEST_OFF
113                : Integer.parseInt(factoryTestStr);
114
115        LightsService lights = null;
116        PowerManagerService power = null;
117        BatteryService battery = null;
118        ConnectivityService connectivity = null;
119        IPackageManager pm = null;
120        Context context = null;
121        WindowManagerService wm = null;
122        BluetoothService bluetooth = null;
123        BluetoothA2dpService bluetoothA2dp = null;
124        HeadsetObserver headset = null;
125        DockObserver dock = null;
126        UsbService usb = null;
127        UiModeManagerService uiMode = null;
128        RecognitionManagerService recognition = null;
129        ThrottleService throttle = null;
130
131        // Critical services...
132        try {
133            Slog.i(TAG, "Entropy Service");
134            ServiceManager.addService("entropy", new EntropyService());
135
136            Slog.i(TAG, "Power Manager");
137            power = new PowerManagerService();
138            ServiceManager.addService(Context.POWER_SERVICE, power);
139
140            Slog.i(TAG, "Activity Manager");
141            context = ActivityManagerService.main(factoryTest);
142
143            Slog.i(TAG, "Telephony Registry");
144            ServiceManager.addService("telephony.registry", new TelephonyRegistry(context));
145
146            AttributeCache.init(context);
147
148            Slog.i(TAG, "Package Manager");
149            pm = PackageManagerService.main(context,
150                    factoryTest != SystemServer.FACTORY_TEST_OFF);
151
152            ActivityManagerService.setSystemProcess();
153
154            mContentResolver = context.getContentResolver();
155
156            // The AccountManager must come before the ContentService
157            try {
158                Slog.i(TAG, "Account Manager");
159                ServiceManager.addService(Context.ACCOUNT_SERVICE,
160                        new AccountManagerService(context));
161            } catch (Throwable e) {
162                Slog.e(TAG, "Failure starting Account Manager", e);
163            }
164
165            Slog.i(TAG, "Content Manager");
166            ContentService.main(context,
167                    factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL);
168
169            Slog.i(TAG, "System Content Providers");
170            ActivityManagerService.installSystemProviders();
171
172            Slog.i(TAG, "Battery Service");
173            battery = new BatteryService(context);
174            ServiceManager.addService("battery", battery);
175
176            Slog.i(TAG, "Lights Service");
177            lights = new LightsService(context);
178
179            Slog.i(TAG, "Vibrator Service");
180            ServiceManager.addService("vibrator", new VibratorService(context));
181
182            // only initialize the power service after we have started the
183            // lights service, content providers and the battery service.
184            power.init(context, lights, ActivityManagerService.getDefault(), battery);
185
186            Slog.i(TAG, "Alarm Manager");
187            AlarmManagerService alarm = new AlarmManagerService(context);
188            ServiceManager.addService(Context.ALARM_SERVICE, alarm);
189
190            Slog.i(TAG, "Init Watchdog");
191            Watchdog.getInstance().init(context, battery, power, alarm,
192                    ActivityManagerService.self());
193
194            Slog.i(TAG, "Window Manager");
195            wm = WindowManagerService.main(context, power,
196                    factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL);
197            ServiceManager.addService(Context.WINDOW_SERVICE, wm);
198
199            ((ActivityManagerService)ServiceManager.getService("activity"))
200                    .setWindowManager(wm);
201
202            // Skip Bluetooth if we have an emulator kernel
203            // TODO: Use a more reliable check to see if this product should
204            // support Bluetooth - see bug 988521
205            if (SystemProperties.get("ro.kernel.qemu").equals("1")) {
206                Slog.i(TAG, "Registering null Bluetooth Service (emulator)");
207                ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null);
208            } else if (factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) {
209                Slog.i(TAG, "Registering null Bluetooth Service (factory test)");
210                ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, null);
211            } else {
212                Slog.i(TAG, "Bluetooth Service");
213                bluetooth = new BluetoothService(context);
214                ServiceManager.addService(BluetoothAdapter.BLUETOOTH_SERVICE, bluetooth);
215                bluetooth.initAfterRegistration();
216                bluetoothA2dp = new BluetoothA2dpService(context, bluetooth);
217                ServiceManager.addService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE,
218                                          bluetoothA2dp);
219
220                int bluetoothOn = Settings.Secure.getInt(mContentResolver,
221                    Settings.Secure.BLUETOOTH_ON, 0);
222                if (bluetoothOn > 0) {
223                    bluetooth.enable();
224                }
225            }
226
227        } catch (RuntimeException e) {
228            Slog.e("System", "Failure starting core service", e);
229        }
230
231        DevicePolicyManagerService devicePolicy = null;
232        StatusBarManagerService statusBar = null;
233        InputMethodManagerService imm = null;
234        AppWidgetService appWidget = null;
235        NotificationManagerService notification = null;
236        WallpaperManagerService wallpaper = null;
237        LocationManagerService location = null;
238
239        if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
240            try {
241                Slog.i(TAG, "Device Policy");
242                devicePolicy = new DevicePolicyManagerService(context);
243                ServiceManager.addService(Context.DEVICE_POLICY_SERVICE, devicePolicy);
244            } catch (Throwable e) {
245                Slog.e(TAG, "Failure starting DevicePolicyService", e);
246            }
247
248            try {
249                Slog.i(TAG, "Status Bar");
250                statusBar = new StatusBarManagerService(context);
251                ServiceManager.addService(Context.STATUS_BAR_SERVICE, statusBar);
252            } catch (Throwable e) {
253                Slog.e(TAG, "Failure starting StatusBarManagerService", e);
254            }
255
256            try {
257                Slog.i(TAG, "Clipboard Service");
258                ServiceManager.addService(Context.CLIPBOARD_SERVICE,
259                        new ClipboardService(context));
260            } catch (Throwable e) {
261                Slog.e(TAG, "Failure starting Clipboard Service", e);
262            }
263
264            try {
265                Slog.i(TAG, "Input Method Service");
266                imm = new InputMethodManagerService(context, statusBar);
267                ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm);
268            } catch (Throwable e) {
269                Slog.e(TAG, "Failure starting Input Manager Service", e);
270            }
271
272            try {
273                Slog.i(TAG, "NetStat Service");
274                ServiceManager.addService("netstat", new NetStatService(context));
275            } catch (Throwable e) {
276                Slog.e(TAG, "Failure starting NetStat Service", e);
277            }
278
279            try {
280                Slog.i(TAG, "NetworkManagement Service");
281                ServiceManager.addService(
282                        Context.NETWORKMANAGEMENT_SERVICE,
283                        NetworkManagementService.create(context));
284            } catch (Throwable e) {
285                Slog.e(TAG, "Failure starting NetworkManagement Service", e);
286            }
287
288            try {
289                Slog.i(TAG, "Connectivity Service");
290                connectivity = ConnectivityService.getInstance(context);
291                ServiceManager.addService(Context.CONNECTIVITY_SERVICE, connectivity);
292            } catch (Throwable e) {
293                Slog.e(TAG, "Failure starting Connectivity Service", e);
294            }
295
296            try {
297                Slog.i(TAG, "Throttle Service");
298                throttle = new ThrottleService(context);
299                ServiceManager.addService(
300                        Context.THROTTLE_SERVICE, throttle);
301            } catch (Throwable e) {
302                Slog.e(TAG, "Failure starting ThrottleService", e);
303            }
304
305            try {
306              Slog.i(TAG, "Accessibility Manager");
307              ServiceManager.addService(Context.ACCESSIBILITY_SERVICE,
308                      new AccessibilityManagerService(context));
309            } catch (Throwable e) {
310              Slog.e(TAG, "Failure starting Accessibility Manager", e);
311            }
312
313            try {
314                /*
315                 * NotificationManagerService is dependant on MountService,
316                 * (for media / usb notifications) so we must start MountService first.
317                 */
318                Slog.i(TAG, "Mount Service");
319                ServiceManager.addService("mount", new MountService(context));
320            } catch (Throwable e) {
321                Slog.e(TAG, "Failure starting Mount Service", e);
322            }
323
324            try {
325                Slog.i(TAG, "Notification Manager");
326                notification = new NotificationManagerService(context, statusBar, lights);
327                ServiceManager.addService(Context.NOTIFICATION_SERVICE, notification);
328            } catch (Throwable e) {
329                Slog.e(TAG, "Failure starting Notification Manager", e);
330            }
331
332            try {
333                Slog.i(TAG, "Device Storage Monitor");
334                ServiceManager.addService(DeviceStorageMonitorService.SERVICE,
335                        new DeviceStorageMonitorService(context));
336            } catch (Throwable e) {
337                Slog.e(TAG, "Failure starting DeviceStorageMonitor service", e);
338            }
339
340            try {
341                Slog.i(TAG, "Location Manager");
342                location = new LocationManagerService(context);
343                ServiceManager.addService(Context.LOCATION_SERVICE, location);
344            } catch (Throwable e) {
345                Slog.e(TAG, "Failure starting Location Manager", e);
346            }
347
348            try {
349                Slog.i(TAG, "Search Service");
350                ServiceManager.addService(Context.SEARCH_SERVICE,
351                        new SearchManagerService(context));
352            } catch (Throwable e) {
353                Slog.e(TAG, "Failure starting Search Service", e);
354            }
355
356            if (INCLUDE_DEMO) {
357                Slog.i(TAG, "Installing demo data...");
358                (new DemoThread(context)).start();
359            }
360
361            try {
362                Slog.i(TAG, "DropBox Service");
363                ServiceManager.addService(Context.DROPBOX_SERVICE,
364                        new DropBoxManagerService(context, new File("/data/system/dropbox")));
365            } catch (Throwable e) {
366                Slog.e(TAG, "Failure starting DropBoxManagerService", e);
367            }
368
369            try {
370                Slog.i(TAG, "Wallpaper Service");
371                wallpaper = new WallpaperManagerService(context);
372                ServiceManager.addService(Context.WALLPAPER_SERVICE, wallpaper);
373            } catch (Throwable e) {
374                Slog.e(TAG, "Failure starting Wallpaper Service", e);
375            }
376
377            try {
378                Slog.i(TAG, "Audio Service");
379                ServiceManager.addService(Context.AUDIO_SERVICE, new AudioService(context));
380            } catch (Throwable e) {
381                Slog.e(TAG, "Failure starting Audio Service", e);
382            }
383
384            try {
385                Slog.i(TAG, "Headset Observer");
386                // Listen for wired headset changes
387                headset = new HeadsetObserver(context);
388            } catch (Throwable e) {
389                Slog.e(TAG, "Failure starting HeadsetObserver", e);
390            }
391
392            try {
393                Slog.i(TAG, "Dock Observer");
394                // Listen for dock station changes
395                dock = new DockObserver(context, power);
396            } catch (Throwable e) {
397                Slog.e(TAG, "Failure starting DockObserver", e);
398            }
399
400            try {
401                Slog.i(TAG, "USB Service");
402                // Listen for USB changes
403                usb = new UsbService(context);
404                ServiceManager.addService(Context.USB_SERVICE, usb);
405            } catch (Throwable e) {
406                Slog.e(TAG, "Failure starting UsbService", e);
407            }
408
409            try {
410                Slog.i(TAG, "UI Mode Manager Service");
411                // Listen for UI mode changes
412                uiMode = new UiModeManagerService(context);
413            } catch (Throwable e) {
414                Slog.e(TAG, "Failure starting UiModeManagerService", e);
415            }
416
417            try {
418                Slog.i(TAG, "Backup Service");
419                ServiceManager.addService(Context.BACKUP_SERVICE,
420                        new BackupManagerService(context));
421            } catch (Throwable e) {
422                Slog.e(TAG, "Failure starting Backup Service", e);
423            }
424
425            try {
426                Slog.i(TAG, "AppWidget Service");
427                appWidget = new AppWidgetService(context);
428                ServiceManager.addService(Context.APPWIDGET_SERVICE, appWidget);
429            } catch (Throwable e) {
430                Slog.e(TAG, "Failure starting AppWidget Service", e);
431            }
432
433            try {
434                Slog.i(TAG, "Recognition Service");
435                recognition = new RecognitionManagerService(context);
436            } catch (Throwable e) {
437                Slog.e(TAG, "Failure starting Recognition Service", e);
438            }
439
440            try {
441                Slog.i(TAG, "DiskStats Service");
442                ServiceManager.addService("diskstats", new DiskStatsService(context));
443            } catch (Throwable e) {
444                Slog.e(TAG, "Failure starting DiskStats Service", e);
445            }
446        }
447
448        // make sure the ADB_ENABLED setting value matches the secure property value
449        Settings.Secure.putInt(mContentResolver, Settings.Secure.ADB_ENABLED,
450                "1".equals(SystemProperties.get("persist.service.adb.enable")) ? 1 : 0);
451
452        // register observer to listen for settings changes
453        mContentResolver.registerContentObserver(Settings.Secure.getUriFor(Settings.Secure.ADB_ENABLED),
454                false, new AdbSettingsObserver());
455
456        // Before things start rolling, be sure we have decided whether
457        // we are in safe mode.
458        final boolean safeMode = wm.detectSafeMode();
459        if (safeMode) {
460            try {
461                ActivityManagerNative.getDefault().enterSafeMode();
462                // Post the safe mode state in the Zygote class
463                Zygote.systemInSafeMode = true;
464                // Disable the JIT for the system_server process
465                VMRuntime.getRuntime().disableJitCompilation();
466            } catch (RemoteException e) {
467            }
468        } else {
469            // Enable the JIT for the system_server process
470            VMRuntime.getRuntime().startJitCompilation();
471        }
472
473        // It is now time to start up the app processes...
474
475        if (devicePolicy != null) {
476            devicePolicy.systemReady();
477        }
478
479        if (notification != null) {
480            notification.systemReady();
481        }
482
483        if (statusBar != null) {
484            statusBar.systemReady();
485        }
486        wm.systemReady();
487        power.systemReady();
488        try {
489            pm.systemReady();
490        } catch (RemoteException e) {
491        }
492
493        // These are needed to propagate to the runnable below.
494        final StatusBarManagerService statusBarF = statusBar;
495        final BatteryService batteryF = battery;
496        final ConnectivityService connectivityF = connectivity;
497        final DockObserver dockF = dock;
498        final UsbService usbF = usb;
499        final ThrottleService throttleF = throttle;
500        final UiModeManagerService uiModeF = uiMode;
501        final AppWidgetService appWidgetF = appWidget;
502        final WallpaperManagerService wallpaperF = wallpaper;
503        final InputMethodManagerService immF = imm;
504        final RecognitionManagerService recognitionF = recognition;
505        final LocationManagerService locationF = location;
506
507        // We now tell the activity manager it is okay to run third party
508        // code.  It will call back into us once it has gotten to the state
509        // where third party code can really run (but before it has actually
510        // started launching the initial applications), for us to complete our
511        // initialization.
512        ((ActivityManagerService)ActivityManagerNative.getDefault())
513                .systemReady(new Runnable() {
514            public void run() {
515                Slog.i(TAG, "Making services ready");
516
517                if (statusBarF != null) statusBarF.systemReady2();
518                if (batteryF != null) batteryF.systemReady();
519                if (connectivityF != null) connectivityF.systemReady();
520                if (dockF != null) dockF.systemReady();
521                if (usbF != null) usbF.systemReady();
522                if (uiModeF != null) uiModeF.systemReady();
523                if (recognitionF != null) recognitionF.systemReady();
524                Watchdog.getInstance().start();
525
526                // It is now okay to let the various system services start their
527                // third party code...
528
529                if (appWidgetF != null) appWidgetF.systemReady(safeMode);
530                if (wallpaperF != null) wallpaperF.systemReady();
531                if (immF != null) immF.systemReady();
532                if (locationF != null) locationF.systemReady();
533                if (throttleF != null) throttleF.systemReady();
534            }
535        });
536
537        // For debug builds, log event loop stalls to dropbox for analysis.
538        if (StrictMode.conditionallyEnableDebugLogging()) {
539            Slog.i(TAG, "Enabled StrictMode for system server main thread.");
540        }
541
542        Looper.loop();
543        Slog.d(TAG, "System ServerThread is exiting!");
544    }
545}
546
547class DemoThread extends Thread
548{
549    DemoThread(Context context)
550    {
551        mContext = context;
552    }
553
554    @Override
555    public void run()
556    {
557        try {
558            Cursor c = mContext.getContentResolver().query(People.CONTENT_URI, null, null, null, null);
559            boolean hasData = c != null && c.moveToFirst();
560            if (c != null) {
561                c.deactivate();
562            }
563            if (!hasData) {
564                DemoDataSet dataset = new DemoDataSet();
565                dataset.add(mContext);
566            }
567        } catch (Throwable e) {
568            Slog.e("SystemServer", "Failure installing demo data", e);
569        }
570
571    }
572
573    Context mContext;
574}
575
576public class SystemServer
577{
578    private static final String TAG = "SystemServer";
579
580    public static final int FACTORY_TEST_OFF = 0;
581    public static final int FACTORY_TEST_LOW_LEVEL = 1;
582    public static final int FACTORY_TEST_HIGH_LEVEL = 2;
583
584    static Timer timer;
585    static final long SNAPSHOT_INTERVAL = 60 * 60 * 1000; // 1hr
586
587    // The earliest supported time.  We pick one day into 1970, to
588    // give any timezone code room without going into negative time.
589    private static final long EARLIEST_SUPPORTED_TIME = 86400 * 1000;
590
591    /**
592     * This method is called from Zygote to initialize the system. This will cause the native
593     * services (SurfaceFlinger, AudioFlinger, etc..) to be started. After that it will call back
594     * up into init2() to start the Android services.
595     */
596    native public static void init1(String[] args);
597
598    public static void main(String[] args) {
599        if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) {
600            // If a device's clock is before 1970 (before 0), a lot of
601            // APIs crash dealing with negative numbers, notably
602            // java.io.File#setLastModified, so instead we fake it and
603            // hope that time from cell towers or NTP fixes it
604            // shortly.
605            Slog.w(TAG, "System clock is before 1970; setting to 1970.");
606            SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
607        }
608
609        if (SamplingProfilerIntegration.isEnabled()) {
610            SamplingProfilerIntegration.start();
611            timer = new Timer();
612            timer.schedule(new TimerTask() {
613                @Override
614                public void run() {
615                    SamplingProfilerIntegration.writeSnapshot("system_server");
616                }
617            }, SNAPSHOT_INTERVAL, SNAPSHOT_INTERVAL);
618        }
619
620        // The system server has to run all of the time, so it needs to be
621        // as efficient as possible with its memory usage.
622        VMRuntime.getRuntime().setTargetHeapUtilization(0.8f);
623
624        System.loadLibrary("android_servers");
625        init1(args);
626    }
627
628    public static final void init2() {
629        Slog.i(TAG, "Entered the Android system server!");
630        Thread thr = new ServerThread();
631        thr.setName("android.server.ServerThread");
632        thr.start();
633    }
634}
635