When using `startForegroundService()`, the system creates a service but expects the app to call `startForeground()` within a short timeframe (a few seconds) to promote it to a foreground state. If the app’s process is killed (e.g., swiped away) before this call is made, the system will consider the service to have misbehaved and may cause an ANR. The fix is to ensure `startForeground()` is called promptly in the service’s `onCreate()` or `onStartCommand()`.

While the Navigation component can auto-handle deep links when the app is launched from a cold state, it requires explicit handling if the app is already running or in certain scenarios. The most reliable approach is to call `navController.handleDeepLink(intent)` in your main Activity’s `onCreate()` (or `onNewIntent()`). This ensures the deep link intent is processed and navigates to the correct destination, regardless of the app’s previous state.

The recommended and most efficient approach for paging from a local Room database is to use the built-in integration. By defining your DAO method to return a `PagingSource`, or more commonly, using a `Flow` construction with `Pager.flow`, Room automatically manages invalidation. When the observed tables are updated via an `@Insert`, `@Update`, or `@Delete` method, Room internally invalidates the relevant `PagingSource`, triggering a new query and a smooth, differential update to the UI without manual intervention or unnecessary full refreshes.

Following clean architecture principles, complex business logic should be isolated in a domain layer. Use Cases (or Interactors) are classes that encapsulate a single, specific business rule or operation. The `ViewModel`’s role is to orchestrate data flow: it requests data from Use Cases, which in turn get data from Repositories. The Use Case executes the business logic (validation, transformation, etc.) and returns a result to the `ViewModel`. This keeps the `ViewModel` focused on UI state management and makes the business logic independently testable without Android dependencies.

Battery saver mode (and Doze mode on Android 6+) are primary culprits for deferred background work. When battery saver is active, the system restricts network access and defers all background job execution, including WorkManager jobs, to conserve power. Periodic work scheduled with WorkManager will not run until the device exits this state. Your app should handle this gracefully, perhaps by informing the user or checking for the condition and using foreground services for critical tasks if appropriate.

For Android 13’s granular media permissions, the `RECORD_AUDIO` permission was moved from the runtime ‘Microphone’ group to a new, separate ‘Audio’ permission group. The permission name itself (`android.permission.RECORD_AUDIO`) does not change in the manifest. The key difference is in how the system presents the dialog and the default one-time grant behavior. Your app’s manifest declaration remains the same, but you must ensure your runtime permission request logic targets the correct API levels and handles the new grant types (one-time, while-in-use).

Object allocation during drawing (`onDraw()`) is a major performance killer because `onDraw()` can be called very frequently (e.g., during scrolling, animation). The correct pattern is to allocate all needed objects (like `Paint`, `Path`, `RectF`) once, during view initialization (in the constructor or an `init {}` block), and store them as member fields. You then simply configure (e.g., `path.reset()`) and use these pre-allocated objects in `onDraw()`. This avoids the garbage collection overhead that causes UI stutter.

The `Application` context is a singleton that lives for the duration of the app process. It is safe to hold a reference to it from a long-lived object like a `ViewModel`. Passing an `Activity` context creates a strong reference from the `ViewModel` (which survives configuration changes) to the `Activity`, preventing the `Activity` from being garbage collected when it’s destroyed, causing a leak. The standard practice is to have the `ViewModel` take `Application` as a parameter (or retrieve it via `AndroidViewModel` if using the Jetpack ViewModel component).

While a classic Singleton (`object`) works, Dependency Injection (DI) is the modern, recommended architectural pattern for managing dependencies like `ImageLoader`. Using a framework like Hilt, you would annotate the `ImageLoader` class with `@Singleton` and inject it into your `ViewModels`, `Fragments`, or other classes. This provides the single shared instance you need, makes the code more testable (you can easily provide a mock), clarifies dependencies, and is the standard practice outlined in Android’s official guides for app architecture.

When using `startForegroundService()`, the system creates a service but expects the app to call `startForeground()` within a short timeframe (a few seconds) to promote it to a foreground state. If the app’s process is killed (e.g., swiped away) before this call is made, the system will consider the service to have misbehaved and may cause an ANR. The fix is to ensure `startForeground()` is called promptly in the service’s `onCreate()` or `onStartCommand()`.0