App Startup Optimization for Mobile

// Use Trace API for method-level startup profiling
class MyApplication : Application() {
    override fun onCreate() {
        Trace.beginSection("App.onCreate")
        super.onCreate()

        Trace.beginSection("DI Setup")
        setupDependencyInjection()
        Trace.endSection()

        Trace.beginSection("Config Init")
        initializeConfiguration()
        Trace.endSection()

        Trace.endSection() // App.onCreate
    }
}

// Use os_signpost for precise startup measurement
import os.signpost

let startupLog = OSLog(subsystem: "com.myapp", category: "startup")

// In your AppDelegate
func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
    let signpostID = OSSignpostID(log: startupLog)
    os_signpost(.begin, log: startupLog, name: "AppStartup", signpostID: signpostID)

    // ... your initialization code ...

    os_signpost(.end, log: startupLog, name: "AppStartup", signpostID: signpostID)
    return true
}

// BAD: Eager initialization — everything blocks the main thread
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        AnalyticsManager.initialize(this)   // 120ms
        CrashReporter.initialize(this)      // 80ms
        FeatureFlagClient.sync()            // blocks until network response
        PushManager.register(this)          // 50ms
        DatabaseProvider.initialize(this)   // 200ms
        ImageLoader.warmDiskCache()         // 150ms
    }
}

// BAD: Eager initialization — everything blocks the main thread
func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
    AnalyticsManager.shared.initialize()      // 120ms
    CrashReporter.shared.start()              // 80ms
    FeatureFlagService.shared.fetchFlags()     // blocks until network response
    PushNotificationManager.shared.register()  // 50ms
    DatabaseManager.shared.runMigrations()     // 200ms
    ImageCacheManager.shared.warmCache()       // 150ms
    ABTestingFramework.shared.sync()           // blocks until network response
    return true
}

// GOOD: Deferred initialization — only block on what's truly needed for first frame
func application(
    _ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
    // Only these are needed before showing the first screen
    DatabaseManager.shared.runMigrations()
    CrashReporter.shared.start()

    // Defer everything else
    DispatchQueue.main.async {
        // Runs after the first frame is drawn
        AnalyticsManager.shared.initialize()
        PushNotificationManager.shared.register()
    }

    DispatchQueue.global(qos: .utility).async {
        // Background work — no rush
        FeatureFlagService.shared.fetchFlags()
        ImageCacheManager.shared.warmCache()
        ABTestingFramework.shared.sync()
    }

    return true
}

// GOOD: Deferred initialization on Android
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // Must happen before first Activity
        DatabaseProvider.initialize(this)
        CrashReporter.initialize(this)

        // Defer to after first frame
        val mainHandler = Handler(Looper.getMainLooper())
        mainHandler.post {
            AnalyticsManager.initialize(this)
            PushManager.register(this)
        }

        // Background thread for non-urgent work
        Executors.newSingleThreadExecutor().execute {
            FeatureFlagClient.sync()
            ImageLoader.warmDiskCache()
        }
    }
}

// BAD: Sequential requests — each waits for the previous one
suspend fun loadAppData() {
    val config = api.fetchRemoteConfig()          // 300ms
    val user = api.fetchUserProfile(config.userId) // 250ms
    val feed = api.fetchFeed(user.preferences)     // 400ms
    // Total: ~950ms of blocking network time
}

// BAD: Sequential requests — each waits for the previous one
func loadAppData() async throws {
    let config = try await api.fetchRemoteConfig()                     // 300ms
    let user = try await api.fetchUserProfile(userId: config.userId)  // 250ms
    let feed = try await api.fetchFeed(preferences: user.preferences) // 400ms
    // Total: ~950ms of blocking network time
}

// GOOD: Parallel requests with structured concurrency
suspend fun loadAppData() = coroutineScope {
    val configDeferred = async { api.fetchRemoteConfig() }
    val userDeferred = async { api.fetchUserProfile() }
    val feedDeferred = async { api.fetchFeed() }

    val config = configDeferred.await()
    val user = userDeferred.await()
    val feed = feedDeferred.await()
    // Total: ~400ms (bounded by the slowest request)
}

// GOOD: Parallel requests with Swift concurrency
func loadAppData() async throws -> AppData {
    async let config = api.fetchRemoteConfig()
    async let user = api.fetchUserProfile()
    async let feed = api.fetchFeed()

    return try await AppData(
        config: config,
        user: user,
        feed: feed
    )
}

// Hybrid: parallel where possible, sequential where needed
suspend fun loadAppData(): AppData = coroutineScope {
    // These two can run in parallel
    val configDeferred = async { api.fetchRemoteConfig() }
    val userDeferred = async { api.fetchUserProfile() }

    val config = configDeferred.await()
    val user = userDeferred.await()

    // This one needs the user's preferences
    val feed = api.fetchFeed(user.preferences)

    AppData(config = config, user = user, feed = feed)
}

// Hybrid: parallel where possible, sequential where needed
func loadAppData() async throws -> AppData {
    // These two can run in parallel
    async let config = api.fetchRemoteConfig()
    async let user = api.fetchUserProfile()

    let resolvedConfig = try await config
    let resolvedUser = try await user

    // This one needs the user's preferences
    let feed = try await api.fetchFeed(preferences: resolvedUser.preferences)

    return AppData(config: resolvedConfig, user: resolvedUser, feed: feed)
}

// Cache the feed data for instant startup display
class FeedRepository(
    private val api: FeedApi,
    private val cache: FeedCache
) {
    suspend fun getFeed(): Flow<FeedState> = flow {
        // Step 1: Emit cached data immediately
        val cached = cache.getLastFeed()
        if (cached != null) {
            emit(FeedState.Cached(cached))
        } else {
            emit(FeedState.Loading)
        }

        // Step 2: Fetch fresh data in the background
        try {
            val fresh = api.fetchFeed()
            cache.saveFeed(fresh)
            emit(FeedState.Fresh(fresh))
        } catch (e: Exception) {
            if (cached == null) {
                emit(FeedState.Error(e))
            }
            // If we already showed cached data, the user has something to look at.
            // Log the error but don't disrupt the experience.
        }
    }
}

sealed class FeedState {
    object Loading : FeedState()
    data class Cached(val data: Feed) : FeedState()
    data class Fresh(val data: Feed) : FeedState()
    data class Error(val exception: Exception) : FeedState()
}

// Cache the feed data for instant startup display
class FeedRepository {
    private let api: FeedApi
    private let cache: FeedCache

    init(api: FeedApi, cache: FeedCache) {
        self.api = api
        self.cache = cache
    }

    func getFeed() -> AsyncStream<FeedState> {
        AsyncStream { continuation in
            Task {
                // Step 1: Emit cached data immediately
                let cached = cache.getLastFeed()
                if let cached {
                    continuation.yield(.cached(cached))
                } else {
                    continuation.yield(.loading)
                }

                // Step 2: Fetch fresh data in the background
                do {
                    let fresh = try await api.fetchFeed()
                    cache.saveFeed(fresh)
                    continuation.yield(.fresh(fresh))
                } catch {
                    if cached == nil {
                        continuation.yield(.error(error))
                    }
                    // If we already showed cached data, the user has something to look at.
                    // Log the error but don't disrupt the experience.
                }
                continuation.finish()
            }
        }
    }
}

enum FeedState {
    case loading
    case cached(Feed)
    case fresh(Feed)
    case error(Error)
}

// Decode images off the main thread
suspend fun prepareImage(context: Context, @DrawableRes resId: Int): Bitmap =
    withContext(Dispatchers.Default) {
        // BitmapFactory does the expensive decode here, on a background
        // thread — not on the main thread during layout.
        // Coil and Glide already do this for you for network images.
        BitmapFactory.decodeResource(context.resources, resId)
    }

// Decode images off the main thread
func prepareImage(_ image: UIImage) async -> UIImage {
    return await withCheckedContinuation { continuation in
        DispatchQueue.global(qos: .userInitiated).async {
            let renderer = UIGraphicsImageRenderer(size: image.size)
            let decoded = renderer.image { context in
                image.draw(at: .zero)
            }
            continuation.resume(returning: decoded)
        }
    }
}

// BAD: Eager initialization of everything through DI
@HiltAndroidApp
class MyApplication : Application() {
    // Hilt eagerly constructs the entire SingletonComponent at startup.
    // If you have 50+ bindings with @Singleton scope, this adds up.
}

@Module
@InstallIn(SingletonComponent::class)
object AppModule {
    @Provides
    @Singleton
    fun provideHeavyService(): HeavyService {
        // This runs at app startup even if HeavyService
        // isn't needed until 3 screens deep
        return HeavyService.Builder()
            .loadModels()    // 200ms
            .configure()     // 100ms
            .build()
    }
}

// BAD: Eager creation of every dependency in a shared container
final class AppContainer {
    static let shared = AppContainer()

    // Every stored `let` property is constructed the moment
    // AppContainer.shared is first touched — typically at startup,
    // even if HeavyService isn't needed until 3 screens deep
    let heavyService = HeavyService.Builder()
        .loadModels()    // 200ms
        .configure()     // 100ms
        .build()
}

// GOOD: Lazy injection — created on first access, not at startup
class ProfileViewModel @Inject constructor(
    private val heavyService: Lazy<HeavyService>
) {
    fun onProfileAction() {
        // HeavyService is only created now, when actually needed
        heavyService.get().doWork()
    }
}

// GOOD: Lazy property — created on first access, not at startup
final class AppContainer {
    static let shared = AppContainer()

    lazy var heavyService: HeavyService = HeavyService.Builder()
        .loadModels()
        .configure()
        .build()
}

class ProfileViewModel {
    func onProfileAction() {
        // HeavyService is only created now, when actually needed
        AppContainer.shared.heavyService.doWork()
    }
}

// BAD: Singleton that does network + disk IO in its init block
object ConfigManager {
    private val config: Config
    private val remoteConfig: Config

    init {
        config = loadConfigFromDisk()    // 80ms
        remoteConfig = fetchRemoteSync() // 300ms — blocks!
    }
}

// BAD: Singleton that does network + disk IO in init
class ConfigManager {
    static let shared = ConfigManager()

    private init() {
        self.config = loadConfigFromDisk()   // 80ms
        self.remoteConfig = fetchRemoteSync() // 300ms — blocks!
    }
}

// GOOD: Lightweight creation, explicit async setup
object ConfigManager {
    private var config: Config? = null
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)

    // No heavy work in the init block

    suspend fun setup() {
        config = withContext(Dispatchers.IO) { loadConfigFromDisk() }
        // Remote fetch happens in background, doesn't block startup
        scope.launch {
            runCatching { fetchRemoteConfig() }
                .onSuccess { config = it }
        }
    }
}

// GOOD: Lightweight creation, explicit async setup
class ConfigManager {
    static let shared = ConfigManager()
    private var config: Config?

    private init() {
        // No heavy work here
    }

    func setup() async {
        self.config = loadConfigFromDisk()
        // Remote fetch happens in background, doesn't block startup
        Task {
            self.config = try? await fetchRemoteConfig()
        }
    }
}

// Production startup time tracking
object StartupTracker {
    private var processStartTime: Long = 0L
    private var firstFrameTime: Long = 0L

    fun markProcessStart() {
        processStartTime = SystemClock.elapsedRealtime()
    }

    fun markFirstFrame() {
        firstFrameTime = SystemClock.elapsedRealtime()
        val startupDuration = firstFrameTime - processStartTime

        // Report to your analytics backend
        Analytics.track("app_cold_start", mapOf(
            "duration_ms" to startupDuration,
            "device_model" to Build.MODEL,
            "os_version" to Build.VERSION.SDK_INT,
            "available_ram_mb" to getAvailableRam()
        ))
    }

    // Call this from your first Activity's onResume after the view tree is laid out
    fun trackFromActivity(activity: Activity) {
        activity.window.decorView.viewTreeObserver.addOnGlobalLayoutListener(
            object : ViewTreeObserver.OnGlobalLayoutListener {
                override fun onGlobalLayout() {
                    markFirstFrame()
                    activity.window.decorView.viewTreeObserver
                        .removeOnGlobalLayoutListener(this)
                }
            }
        )
    }
}

// Production startup time tracking
enum StartupTracker {
    private static var processStartTime: CFTimeInterval = 0
    private static var firstFrameTime: CFTimeInterval = 0

    static func markProcessStart() {
        processStartTime = CACurrentMediaTime()
    }

    static func markFirstFrame() {
        firstFrameTime = CACurrentMediaTime()
        let startupDurationMs = Int((firstFrameTime - processStartTime) * 1000)

        // Report to your analytics backend
        Analytics.track("app_cold_start", [
            "duration_ms": startupDurationMs,
            "device_model": UIDevice.current.model,
            "os_version": UIDevice.current.systemVersion,
            "available_ram_mb": availableRam()
        ])
    }

    // Call this from your first view controller's viewDidLoad.
    // A block dispatched to the main queue here runs after the
    // first frame has been committed to the render server.
    static func trackFirstFrame() {
        DispatchQueue.main.async {
            guard firstFrameTime == 0 else { return }
            markFirstFrame()
        }
    }
}