# Measure system_server startup time
adb shell time ps -A | grep system_server
# Typical startup: 200-400ms vs 2-3s for microservice approach

# Detailed boot timing analysis
adb shell dumpsys activity services | grep -A 10 "Boot timing"

# Monitor service startup sequence
adb logcat -v time | grep -E "SystemServiceManager.*Starting" | head -50

// Simplified illustration of Watchdog monitoring concept

// Actual class: public class Watchdog implements Dumpable (not extends Thread)
public class Watchdog implements Dumpable {
    private static final long DEFAULT_TIMEOUT = 60_000; // 60 seconds
    private final ArrayList<HandlerCheckerAndTimeout> mHandlerCheckers = new ArrayList<>();
    private final HandlerChecker mMonitorChecker;
    
    // Simplified illustration: Actual Watchdog runs in a separate thread
    // and monitors multiple handler threads using HandlerChecker mechanism
    private void run() {
        while (true) {
            // Actual implementation uses HandlerChecker.getCompletionStateLocked()
            // to check each handler's state (COMPLETED, WAITING, WAITED_UNTIL_PRE_WATCHDOG, OVERDUE)
            final int waitState = evaluateCheckerCompletionLocked();
            
            if (waitState == OVERDUE) {
                // Actual implementation: Calls doSysRq('c') to trigger kernel panic
                // or breakCrashLoop() to escape crash loops
                // Also collects thread dumps and logs to dropbox
                doSysRq('c'); // Triggers kernel panic for system recovery
                breakCrashLoop(); // Escape crash loops
            }
        }
    }
    
    // Evaluates all handler checkers and returns worst state
    private int evaluateCheckerCompletionLocked() {
        int state = COMPLETED;
        for (HandlerCheckerAndTimeout hc : mHandlerCheckers) {
            state = Math.max(state, hc.checker().getCompletionStateLocked());
        }
        return state;
    }
}

# SELinux policies provide service-level isolation
adb shell getenforce
adb shell ls -Z /system/bin/system_server
# system_server:system_server:s0:c512,c768

public static void main(String argv[]) {
    // ... initialization code ...
    
    if (startSystemServer) {
        Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
        if (r != null) {
            r.run();
            return;
        }
    }
}

private static Runnable forkSystemServer(String abiList, String socketName,
        ZygoteServer zygoteServer) {
    // Fork the system server process
    int pid = Zygote.forkSystemServer(
            parsedArgs.uid, parsedArgs.gid,
            parsedArgs.gids,
            parsedArgs.debugFlags,
            null,
            parsedArgs.permittedCapabilities,
            parsedArgs.effectiveCapabilities);
    
    if (pid == 0) {
        // Child process - system_server
        return new SystemServerRunnable();
    }
    return null;
}

// Simplified illustration - actual implementation contains extensive error handling, timing, and initialization

public static void main(String[] args) {
    new SystemServer().run();
}

private void run() {
    // Initialize timing and tracing (actual implementation)
    TimingsTraceAndSlog t = new TimingsTraceAndSlog();
    
    // Extensive initialization before services (simplified here):
    // - System properties setup
    // - Timezone initialization
    // - Locale management
    // - Binder configuration
    // - SQLite settings
    // - Native library loading
    // - Heap profiling setup
    // - And many more initialization steps...
    
    // Create Android context for system_server
    // This context provides access to system resources, services, and configuration
    createSystemContext();  // Actual method name
    
    // Initialize native services first
    // Native services must be ready before Java services start
    System.loadLibrary("android_servers");
    
    // Create the system service manager
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    mSystemServiceManager.setStartInfo(mRuntimeRestart,
            mRuntimeStartElapsedTime, mRuntimeStartUptime);
    
    // Start services in dependency order
    // Each phase depends on previous phases completing successfully
    // Actual implementation: All service methods take TimingsTraceAndSlog parameter
    try {
        startBootstrapServices(t);  // Phase 1: Critical services with no dependencies
        startCoreServices(t);        // Phase 2: Services depending on bootstrap services
        startOtherServices(t);       // Phase 3: Remaining services with complex dependencies
        startApexServices(t);        // Phase 4: Apex module services (not shown in simplified version)
    } catch (Throwable ex) {
        Slog.e(TAG, "Failure starting system services", ex);
        throw ex;
    }
    
    // Signal that system_server is ready
    // Zygote can now accept app process fork requests
    // Actual implementation: More complex callback chain with timing and error handling
    ActivityManagerService.self().systemReady(() -> {
        Slog.i(TAG, "System server ready");
    });
}

// Conceptual illustration - actual implementation is in Zygote.forkSystemServer()

// During fork, Zygote sets:
// - UID to SYSTEM_UID (1000)
// - GID to SYSTEM_GID (1000)
// - Capabilities are managed via SELinux policies

# Verify system_server privileges
adb shell ps -A | grep system_server
# system_server runs as UID 1000 (system user)
# Not root, but has elevated capabilities

# Check SELinux context
adb shell ls -Z /system/bin/system_server
# system_server:system_server:s0:c512,c768

// Simplified illustration - actual implementation contains many more services, error handling, and timing

private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    t.traceBegin("startBootstrapServices");
    
    // Start the watchdog as early as possible
    t.traceBegin("StartWatchdog");
    final Watchdog watchdog = Watchdog.getInstance();
    watchdog.start();
    t.traceEnd();
    
    // Installer service - handles package installation
    mInstaller = mSystemServiceManager.startService(Installer.class);
    
    // Device Identifiers service
    mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);
    
    // Device ID attestation service
    mSystemServiceManager.startService(DeviceIdAttestationService.class);
    
    // Activity Manager Service - CRITICAL
    // Manages application lifecycle, process management, and activity stacks
    mActivityManagerService = mSystemServiceManager.startService(
            ActivityManagerService.Lifecycle.class).getService();
    
    // Power Manager Service - CRITICAL
    // Controls device power states, wake locks, and screen management
    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
    
    // Recovery System Service
    mSystemServiceManager.startService(RecoverySystemService.class);
    
    // Lights Service
    mSystemServiceManager.startService(LightsService.class);
    
    // Display Manager Service
    mDisplayManagerService = mSystemServiceManager.startService(
            DisplayManagerService.class);
    
    // Package Manager Service - CRITICAL
    // Manages installed packages, permissions, and component resolution
    mPackageManagerService = PackageManagerService.main(mSystemContext, mInstaller,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
            mOnlyCore);
    
    // User Manager Service
    mSystemServiceManager.startService(UserManagerService.Lifecycle.class);
    
    // Initialize attribute cache used to cache resources from packages
    AttributeCache.init(mSystemContext);
    
    // Set up the Application instance for the system process
    mActivityManagerService.setSystemProcess();
    
    t.traceEnd(); // startBootstrapServices
}

// Simplified illustration - actual implementation contains many more services, error handling, and timing

private void startCoreServices(@NonNull TimingsTraceAndSlog t) {
    t.traceBegin("startCoreServices");
    
    // Battery Service - depends on PowerManagerService
    t.traceBegin("StartBatteryService");
    mBatteryService = mSystemServiceManager.startService(BatteryService.class);
    t.traceEnd();
    
    // Usage Stats Service - depends on ActivityManagerService
    mSystemServiceManager.startService(UsageStatsService.class);
    
    // WebView Update Service
    mSystemServiceManager.startService(WebViewUpdateService.class);
    
    // Job Scheduler Service - depends on ActivityManagerService
    mSystemServiceManager.startService(JobSchedulerService.class);
    
    // Network Time Update Service
    mSystemServiceManager.startService(NetworkTimeUpdateService.class);
    
    t.traceEnd(); // startCoreServices
}

// Simplified illustration - actual implementation contains many more services, error handling, and timing

private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
    t.traceBegin("startOtherServices");
    
    // Window Manager Service - depends on DisplayManagerService, ActivityManagerService
    mWindowManagerService = WindowManagerService.main(mSystemContext, mDisplayManagerService,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_LOW_LEVEL,
            mOnlyCore, mFirstBoot, mSystemServiceManager);
    
    // Input Manager Service - depends on WindowManagerService
    mInputManagerService = mSystemServiceManager.startService(InputManagerService.class);
    
    // Connectivity Service - depends on multiple services
    mSystemServiceManager.startService(ConnectivityService.class);
    
    // Location Manager Service
    mSystemServiceManager.startService(LocationManagerService.class);
    
    // Notification Manager Service - depends on ActivityManagerService
    mSystemServiceManager.startService(NotificationManagerService.class);
    
    // ... many more services ...
    
    t.traceEnd(); // startOtherServices
}

private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    t.traceBegin("startBootstrapServices");
    
    try {
        t.traceBegin("StartActivityManagerService");
        mActivityManagerService = mSystemServiceManager.startService(
                ActivityManagerService.Lifecycle.class).getService();
        t.traceEnd();
    } catch (Throwable e) {
        Slog.e(TAG, "Failure starting ActivityManagerService", e);
        // Critical service failure - may need to restart system_server
        throw new RuntimeException("Failed to start ActivityManagerService", e);
    }
    
    // Non-critical services can fail without crashing system_server
    try {
        mSystemServiceManager.startService(LightsService.class);
    } catch (Throwable e) {
        Slog.w(TAG, "Failure starting LightsService", e);
        // Continue with other services
    }
}

static void preload() {
    // Preload framework classes
    preloadClasses();
    
    // Preload resources
    preloadResources();
    
    // Preload OpenGL
    preloadOpenGL();
    
    // Preload shared libraries
    preloadSharedLibraries();
}

# Monitor system_server startup with timestamps
adb logcat -v time | grep -E "(SystemServer|ActivityManager|PackageManager)"

# Check service registration
adb shell service list | grep -E "(activity|package|power|display|window|battery)"

# Monitor memory usage during startup
adb shell dumpsys meminfo system_server

# Track service startup order
adb logcat | grep "SystemServiceManager.*Starting"

# Check for service startup failures
adb logcat | grep -E "(SystemServer.*Failure|SystemServer.*Error)"

# Monitor boot phases
adb logcat | grep "SystemServiceManager.*phase"

// Step 1: SystemServiceManager starts service
SystemServiceManager.startService(ActivityManagerService.class);

// Step 2: Service registers with native ServiceManager for external access
ServiceManager.addService("activity", mActivityManagerService);

// Step 3: External process discovers service
IBinder binder = ServiceManager.getService("activity");
IActivityManager am = IActivityManager.Stub.asInterface(binder);

// External process calls system_server via Binder
public class ActivityManagerProxy implements IActivityManager {
    private final IBinder mRemote;
    
    public void startActivity(Intent intent) {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        try {
            data.writeInterfaceToken(IActivityManager.descriptor);
            intent.writeToParcel(data, 0);
            // Binder IPC call - involves marshaling, kernel transition
            mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);
        } finally {
            data.recycle();
            reply.recycle();
        }
    }
}

# Measure internal vs external call performance
# Internal call: ~0.001ms (direct method call)
# External call: ~2-5ms (Binder IPC with marshaling)

# Profile Binder transactions
adb shell dumpsys activity services | grep -A 5 "Binder"

public class ActivityManagerService extends IActivityManager.Stub
        implements Watchdog.Monitor, BatteryStatsImpl.BatteryCallback {
    
    // Main handler thread - handles core AMS operations
    // Created with THREAD_PRIORITY_FOREGROUND priority
    public final ServiceThread mHandlerThread;
    final MainHandler mHandler;
    
    // UI handler - handles UI-related operations (ANR dialogs, error dialogs)
    // Uses shared UiThread.get().getLooper() for UI operations
    final Handler mUiHandler;
    
    // Process start handler thread - dedicated thread for process creation
    // Prevents blocking main handler during process startup
    final ServiceThread mProcStartHandlerThread;
    final ProcStartHandler mProcStartHandler;
    
    // Constructor - initializes all threads
    public ActivityManagerService(Context systemContext, ActivityTaskManagerService atm) {
        // Create main handler thread
        mHandlerThread = new ServiceThread(TAG,
                THREAD_PRIORITY_FOREGROUND, false /*allowIo*/);
        mHandlerThread.start();
        mHandler = new MainHandler(mHandlerThread.getLooper());
        
        // Create UI handler (uses shared UiThread)
        mUiHandler = new UiHandler();
        
        // Create process start handler thread
        mProcStartHandlerThread = new ServiceThread(TAG + ":procStart",
                THREAD_PRIORITY_FOREGROUND, false /* allowIo */);
        mProcStartHandlerThread.start();
        mProcStartHandler = new ProcStartHandler(this, mProcStartHandlerThread.getLooper());
        
        // AppProfiler uses BackgroundThread for memory profiling
        mAppProfiler = new AppProfiler(this, BackgroundThread.getHandler().getLooper(),
                new LowMemDetector(this));
    }
    
    // MainHandler - handles core AMS operations
    final class MainHandler extends Handler {
        public MainHandler(Looper looper) {
            super(looper, null, true);
        }
        
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case GC_BACKGROUND_PROCESSES_MSG:
                    // Perform garbage collection on background processes
                    mAppProfiler.performAppGcsIfAppropriateLocked();
                    break;
                case SERVICE_TIMEOUT_MSG:
                    // Handle service timeout (ANR detection)
                    mServices.serviceTimeout((ProcessRecord) msg.obj);
                    break;
                case PROC_START_TIMEOUT_MSG:
                    // Handle process start timeout
                    handleProcessStartOrKillTimeoutLocked((ProcessRecord) msg.obj, false);
                    break;
                case KILL_APPLICATION_MSG:
                    // Force stop application
                    forceStopPackageLocked(...);
                    break;
                case SERVICE_FOREGROUND_TIMEOUT_MSG:
                    // Handle foreground service timeout
                    mServices.serviceForegroundTimeout((ServiceRecord) msg.obj);
                    break;
                // ... many more message types
            }
        }
    }
    
    // UiHandler - handles UI-related operations
    final class UiHandler extends Handler {
        public UiHandler() {
            super(com.android.server.UiThread.get().getLooper(), null, true);
        }
        
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case SHOW_ERROR_UI_MSG:
                    // Show application crash dialog
                    mAppErrors.handleShowAppErrorUi(msg);
                    break;
                case SHOW_NOT_RESPONDING_UI_MSG:
                    // Show ANR dialog
                    mAppErrors.handleShowAnrUi(msg);
                    break;
                case SHOW_STRICT_MODE_VIOLATION_UI_MSG:
                    // Show strict mode violation dialog
                    proc.mErrorState.getDialogController().showViolationDialogs(res);
                    break;
                case DISPATCH_PROCESSES_CHANGED_UI_MSG:
                    // Notify observers of process state changes
                    mProcessList.dispatchProcessesChanged();
                    break;
                // ... more UI message types
            }
        }
    }
    
    // ProcStartHandler - handles process creation operations
    // Defined in ProcessList.java as inner class
    static final class ProcStartHandler extends Handler {
        static final int MSG_PROCESS_DIED = 1;
        static final int MSG_PROCESS_KILL_TIMEOUT = 2;
        
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_PROCESS_DIED:
                    // Handle predecessor process death
                    mService.mProcessList.handlePredecessorProcDied((ProcessRecord) msg.obj);
                    break;
                case MSG_PROCESS_KILL_TIMEOUT:
                    // Handle process kill timeout
                    mService.handleProcessStartOrKillTimeoutLocked((ProcessRecord) msg.obj, true);
                    break;
            }
        }
    }
    
    // Binder threads - automatically created by kernel
    // Handle incoming Binder transactions from other processes
    // Named: Binder:XXXX (typically 15-16 threads)
    // Managed by Binder driver, not explicitly created in code
}

public <T extends SystemService> T startService(Class<T> serviceClass) {
    // Instantiate service
    T service = serviceClass.newInstance();
    
    // Add to service list
    mServices.add(service);
    
    // Call onStart() lifecycle method
    service.onStart();
    
    return service;
}

public void startBootPhase(int phase) {
    // Notify all services of boot phase progression
    for (SystemService service : mServices) {
        service.onBootPhase(phase);
    }
}

# View all threads in system_server
adb shell ps -T -p $(pidof system_server)

# Check service registration
adb shell service list

# Monitor boot phases
adb logcat | grep "SystemServiceManager.*phase"

# View service dependencies
adb shell dumpsys activity services | grep -A 5 "Service dependencies"

# Check native ServiceManager
adb shell ps -A | grep servicemanager

# List all registered Binder services
adb shell service list | wc -l  # Count total services