Android Performance Optimization: Complete Guide for Modern Architecture#

Performance optimization is crucial for creating exceptional Android user experiences. This comprehensive guide explores advanced performance optimization techniques for modern Android applications using MVVM architecture, Jetpack Compose, and contemporary development practices.

Performance Monitoring Foundation#

Performance Metrics Collection#

1
// Custom performance monitoring system
2
@Singleton
3
class PerformanceMonitor @Inject constructor(
4
    private val analytics: Analytics,
5
    private val preferences: SharedPreferences
6
) {
7
    private val performanceMetrics = mutableMapOf<String, PerformanceMetric>()
8

9
    fun startMeasurement(operation: String): PerformanceToken {
10
        val startTime = System.nanoTime()
11
        val memoryBefore = getMemoryUsage()
12

13
        return PerformanceToken(
14
            operation = operation,
15
            startTime = startTime,
16
            memoryBefore = memoryBefore
17
        )
18
    }
19

20
    fun endMeasurement(token: PerformanceToken) {
21
        val endTime = System.nanoTime()
22
        val memoryAfter = getMemoryUsage()
23
        val duration = (endTime - token.startTime) / 1_000_000 // Convert to ms
24

25
        val metric = PerformanceMetric(
26
            operation = token.operation,
27
            durationMs = duration,
28
            memoryUsedMB = (memoryAfter - token.memoryBefore) / (1024 * 1024),
29
            timestamp = System.currentTimeMillis()
30
        )
31

32
        recordMetric(metric)
33
    }
34

35
    private fun recordMetric(metric: PerformanceMetric) {
36
        performanceMetrics[metric.operation] = metric
37

38
        // Log performance issues
39
        when {
40
            metric.durationMs > 1000 -> {
41
                Timber.w("Slow operation detected: ${metric.operation} took ${metric.durationMs}ms")
42
                analytics.track("performance_slow_operation", mapOf(
43
                    "operation" to metric.operation,
44
                    "duration_ms" to metric.durationMs
45
                ))
46
            }
47
            metric.memoryUsedMB > 50 -> {
48
                Timber.w("High memory usage: ${metric.operation} used ${metric.memoryUsedMB}MB")
49
                analytics.track("performance_high_memory", mapOf(
50
                    "operation" to metric.operation,
51
                    "memory_mb" to metric.memoryUsedMB
52
                ))
53
            }
54
        }
55
    }
56

57
    private fun getMemoryUsage(): Long {
58
        val runtime = Runtime.getRuntime()
59
        return runtime.totalMemory() - runtime.freeMemory()
60
    }
61
}
62

63
data class PerformanceToken(
64
    val operation: String,
65
    val startTime: Long,
66
    val memoryBefore: Long
67
)
68

69
data class PerformanceMetric(
70
    val operation: String,
71
    val durationMs: Long,
72
    val memoryUsedMB: Long,
73
    val timestamp: Long
74
)

ViewModel Performance Optimization#

Efficient State Management#

1
// Optimized ViewModel with performance considerations
2
@HiltViewModel
3
class OptimizedTasksViewModel @Inject constructor(
4
    private val repository: TasksRepository,
5
    private val performanceMonitor: PerformanceMonitor,
6
    @IoDispatcher private val ioDispatcher: CoroutineDispatcher
7
) : ViewModel() {
8

9
    // Use StateFlow for better performance than LiveData
10
    private val _uiState = MutableStateFlow(TasksUiState())
11
    val uiState: StateFlow<TasksUiState> = _uiState.asStateFlow()
12

13
    // Cached computed properties to avoid recalculation
14
    private val _filteredTasks = MutableStateFlow<List<Task>>(emptyList())
15
    val filteredTasks: StateFlow<List<Task>> = _filteredTasks.asStateFlow()
16

17
    // Debounced search to prevent excessive API calls
18
    private val searchQuery = MutableStateFlow("")
19

20
    init {
21
        setupTasksObservation()
22
        setupSearchDebouncing()
23
    }
24

25
    private fun setupTasksObservation() {
26
        viewModelScope.launch {
27
            combine(
28
                repository.tasks,
29
                _uiState.map { it.currentFilter },
30
                searchQuery.debounce(300) // Debounce search queries
31
            ) { tasks, filter, query ->
32
                val token = performanceMonitor.startMeasurement("filter_tasks")
33

34
                val filtered = tasks
35
                    .asSequence() // Use sequence for lazy evaluation
36
                    .filter { task ->
37
                        when (filter) {
38
                            TasksFilterType.ACTIVE_TASKS -> !task.isCompleted
39
                            TasksFilterType.COMPLETED_TASKS -> task.isCompleted
40
                            TasksFilterType.ALL_TASKS -> true
41
                        }
42
                    }
43
                    .filter { task ->
44
                        if (query.isBlank()) true
45
                        else task.title.contains(query, ignoreCase = true) ||
46
                             task.description.contains(query, ignoreCase = true)
47
                    }
48
                    .toList()
49

50
                performanceMonitor.endMeasurement(token)
51
                filtered
52
            }.collect { tasks ->
53
                _filteredTasks.value = tasks
54
                _uiState.value = _uiState.value.copy(
55
                    tasks = tasks,
56
                    isLoading = false,
57
                    isEmpty = tasks.isEmpty()
58
                )
59
            }
60
        }
61
    }
62

63
    private fun setupSearchDebouncing() {
64
        viewModelScope.launch {
65
            searchQuery
66
                .debounce(300) // Wait 300ms after user stops typing
67
                .distinctUntilChanged() // Only emit when query actually changes
68
                .collect { query ->
69
                    // Search logic is handled in setupTasksObservation()
70
                    Timber.d("Search query: $query")
71
                }
72
        }
73
    }
74

75
    fun setFilter(filter: TasksFilterType) {
76
        _uiState.value = _uiState.value.copy(currentFilter = filter)
77
    }
78

79
    fun searchTasks(query: String) {
80
        searchQuery.value = query
81
    }
82

83
    // Optimized task completion with batching
84
    private val pendingTaskUpdates = mutableSetOf<String>()
85
    private var updateJob: Job? = null
86

87
    fun completeTask(taskId: String, completed: Boolean = true) {
88
        // Add to pending updates
89
        pendingTaskUpdates.add(taskId)
90

91
        // Cancel previous update job and start a new one
92
        updateJob?.cancel()
93
        updateJob = viewModelScope.launch {
94
            delay(100) // Wait for potential batch updates
95

96
            val tasksToUpdate = pendingTaskUpdates.toSet()
97
            pendingTaskUpdates.clear()
98

99
            withContext(ioDispatcher) {
100
                val token = performanceMonitor.startMeasurement("batch_update_tasks")
101

102
                try {
103
                    // Batch update tasks
104
                    repository.updateTasksCompletion(tasksToUpdate, completed)
105
                } catch (e: Exception) {
106
                    Timber.e(e, "Failed to update tasks")
107
                    _uiState.value = _uiState.value.copy(
108
                        errorMessage = "Failed to update tasks"
109
                    )
110
                } finally {
111
                    performanceMonitor.endMeasurement(token)
112
                }
113
            }
114
        }
115
    }
116

117
    override fun onCleared() {
118
        super.onCleared()
119
        updateJob?.cancel()
120
    }
121
}

Memory-Efficient Repository#

1
// Repository with caching and memory management
2
@Singleton
3
class OptimizedTasksRepository @Inject constructor(
4
    private val localDataSource: TasksLocalDataSource,
5
    private val remoteDataSource: TasksRemoteDataSource,
6
    private val performanceMonitor: PerformanceMonitor,
7
    @IoDispatcher private val dispatcher: CoroutineDispatcher
8
) {
9

10
    // LRU Cache for frequently accessed tasks
11
    private val taskCache = LruCache<String, Task>(maxSize = 100)
12

13
    // In-memory cache with TTL
14
    private val tasksCache = CacheEntry<List<Task>>()
15
    private val cacheValidityMs = TimeUnit.MINUTES.toMillis(5)
16

17
    private val _tasks = MutableStateFlow<List<Task>>(emptyList())
18
    val tasks: StateFlow<List<Task>> = _tasks.asStateFlow()
19

20
    suspend fun loadTasks(forceRefresh: Boolean = false): Result<List<Task>> {
21
        return withContext(dispatcher) {
22
            val token = performanceMonitor.startMeasurement("load_tasks")
23

24
            try {
25
                // Check cache first
26
                if (!forceRefresh && tasksCache.isValid(cacheValidityMs)) {
27
                    tasksCache.data?.let { cachedTasks ->
28
                        _tasks.value = cachedTasks
29
                        return@withContext Result.success(cachedTasks)
30
                    }
31
                }
32

33
                // Load from local database first (faster)
34
                val localTasks = localDataSource.getTasks()
35
                _tasks.value = localTasks
36
                tasksCache.updateData(localTasks)
37

38
                // Sync with remote in background if needed
39
                if (shouldSyncWithRemote()) {
40
                    launch {
41
                        syncWithRemote()
42
                    }
43
                }
44

45
                Result.success(localTasks)
46
            } catch (e: Exception) {
47
                Timber.e(e, "Failed to load tasks")
48
                Result.failure(e)
49
            } finally {
50
                performanceMonitor.endMeasurement(token)
51
            }
52
        }
53
    }
54

55
    suspend fun getTask(taskId: String): Task? {
56
        return withContext(dispatcher) {
57
            // Check memory cache first
58
            taskCache[taskId]?.let { return@withContext it }
59

60
            // Check local database
61
            val task = localDataSource.getTask(taskId)
62
            task?.let { taskCache.put(taskId, it) }
63

64
            task
65
        }
66
    }
67

68
    suspend fun updateTasksCompletion(taskIds: Set<String>, completed: Boolean) {
69
        withContext(dispatcher) {
70
            val token = performanceMonitor.startMeasurement("batch_update_tasks")
71

72
            try {
73
                // Batch database update
74
                localDataSource.updateTasksCompletion(taskIds, completed)
75

76
                // Update memory cache
77
                taskIds.forEach { taskId ->
78
                    taskCache[taskId]?.let { task ->
79
                        taskCache.put(taskId, task.copy(isCompleted = completed))
80
                    }
81
                }
82

83
                // Refresh tasks list
84
                loadTasks()
85

86
                // Queue remote sync
87
                queueRemoteSync(taskIds.map { UpdateOperation(it, completed) })
88

89
            } finally {
90
                performanceMonitor.endMeasurement(token)
91
            }
92
        }
93
    }
94

95
    private suspend fun syncWithRemote() {
96
        try {
97
            val remoteTasks = remoteDataSource.getTasks()
98
            localDataSource.saveTasks(remoteTasks)
99

100
            // Update in-memory state
101
            _tasks.value = remoteTasks
102
            tasksCache.updateData(remoteTasks)
103

104
            // Clear individual task cache to avoid inconsistencies
105
            taskCache.evictAll()
106

107
        } catch (e: Exception) {
108
            Timber.e(e, "Failed to sync with remote")
109
        }
110
    }
111

112
    private fun shouldSyncWithRemote(): Boolean {
113
        // Implement smart sync logic based on network conditions, battery, etc.
114
        return true
115
    }
116

117
    private fun queueRemoteSync(operations: List<UpdateOperation>) {
118
        // Queue operations for background sync when network is available
119
        // Implementation depends on your sync strategy (WorkManager, etc.)
120
    }
121
}
122

123
// Cache helper class
124
private class CacheEntry<T> {
125
    var data: T? = null
126
        private set
127
    private var timestamp: Long = 0
128

129
    fun updateData(newData: T) {
130
        data = newData
131
        timestamp = System.currentTimeMillis()
132
    }
133

134
    fun isValid(validityMs: Long): Boolean {
135
        return data != null && (System.currentTimeMillis() - timestamp) < validityMs
136
    }
137
}

Jetpack Compose Performance Optimization#

Recomposition Optimization#

1
// Stable data classes to prevent unnecessary recompositions
2
@Immutable
3
data class TasksUiState(
4
    val tasks: List<Task> = emptyList(),
5
    val isLoading: Boolean = false,
6
    val errorMessage: String? = null,
7
    val currentFilter: TasksFilterType = TasksFilterType.ALL_TASKS,
8
    val searchQuery: String = ""
9
)
10

11
// Optimized Compose components
12
@Composable
13
fun OptimizedTasksList(
14
    tasks: List<Task>,
15
    onTaskClick: (String) -> Unit,
16
    onTaskLongClick: (String) -> Unit,
17
    modifier: Modifier = Modifier
18
) {
19
    // Use key parameter to help Compose identify items efficiently
20
    LazyColumn(
21
        modifier = modifier,
22
        contentPadding = PaddingValues(16.dp),
23
        verticalArrangement = Arrangement.spacedBy(8.dp)
24
    ) {
25
        items(
26
            items = tasks,
27
            key = { task -> task.id } // Crucial for performance
28
        ) { task ->
29
            // Wrap in derivedStateOf for computed properties
30
            val isHighPriority by remember(task.priority) {
31
                derivedStateOf { task.priority == TaskPriority.HIGH }
32
            }
33

34
            OptimizedTaskItem(
35
                task = task,
36
                isHighPriority = isHighPriority,
37
                onTaskClick = onTaskClick,
38
                onTaskLongClick = onTaskLongClick
39
            )
40
        }
41
    }
42
}
43

44
@Composable
45
fun OptimizedTaskItem(
46
    task: Task,
47
    isHighPriority: Boolean,
48
    onTaskClick: (String) -> Unit,
49
    onTaskLongClick: (String) -> Unit,
50
    modifier: Modifier = Modifier
51
) {
52
    // Memoize expensive calculations
53
    val titleStyle by remember(task.isCompleted) {
54
        derivedStateOf {
55
            if (task.isCompleted) {
56
                MaterialTheme.typography.bodyLarge.copy(
57
                    textDecoration = TextDecoration.LineThrough,
58
                    color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
59
                )
60
            } else {
61
                MaterialTheme.typography.bodyLarge
62
            }
63
        }
64
    }
65

66
    // Use stable callbacks to prevent recomposition
67
    val onClickCallback = remember { { onTaskClick(task.id) } }
68
    val onLongClickCallback = remember { { onTaskLongClick(task.id) } }
69

70
    Card(
71
        modifier = modifier
72
            .fillMaxWidth()
73
            .combinedClickable(
74
                onClick = onClickCallback,
75
                onLongClick = onLongClickCallback
76
            ),
77
        elevation = CardDefaults.cardElevation(
78
            defaultElevation = if (isHighPriority) 4.dp else 2.dp
79
        )
80
    ) {
81
        Column(
82
            modifier = Modifier.padding(16.dp)
83
        ) {
84
            Text(
85
                text = task.title,
86
                style = titleStyle,
87
                maxLines = 1,
88
                overflow = TextOverflow.Ellipsis
89
            )
90

91
            if (task.description.isNotBlank()) {
92
                Spacer(modifier = Modifier.height(4.dp))
93
                Text(
94
                    text = task.description,
95
                    style = MaterialTheme.typography.bodyMedium,
96
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
97
                    maxLines = 2,
98
                    overflow = TextOverflow.Ellipsis
99
                )
100
            }
101

102
            // Conditional rendering for performance
103
            if (isHighPriority) {
104
                Spacer(modifier = Modifier.height(8.dp))
105
                PriorityIndicator(priority = task.priority)
106
            }
107
        }
108
    }
109
}
110

111
// Separate component for complex UI elements
112
@Composable
113
private fun PriorityIndicator(
114
    priority: TaskPriority,
115
    modifier: Modifier = Modifier
116
) {
117
    val (color, text) = remember(priority) {
118
        when (priority) {
119
            TaskPriority.HIGH -> MaterialTheme.colorScheme.error to "High Priority"
120
            TaskPriority.MEDIUM -> MaterialTheme.colorScheme.primary to "Medium Priority"
121
            TaskPriority.LOW -> MaterialTheme.colorScheme.secondary to "Low Priority"
122
        }
123
    }
124

125
    Surface(
126
        modifier = modifier,
127
        color = color.copy(alpha = 0.1f),
128
        shape = RoundedCornerShape(4.dp)
129
    ) {
130
        Text(
131
            text = text,
132
            style = MaterialTheme.typography.labelSmall,
133
            color = color,
134
            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)
135
        )
136
    }
137
}

Custom Modifiers for Performance#

1
// Reusable performance-optimized modifiers
2
object PerformanceModifiers {
3

4
    fun Modifier.optimizedClickable(
5
        onClick: () -> Unit,
6
        onLongClick: (() -> Unit)? = null
7
    ): Modifier = composed {
8
        val interactionSource = remember { MutableInteractionSource() }
9

10
        this.combinedClickable(
11
            interactionSource = interactionSource,
12
            indication = rememberRipple(),
13
            onClick = onClick,
14
            onLongClick = onLongClick
15
        )
16
    }
17

18
    fun Modifier.conditionalModifier(
19
        condition: Boolean,
20
        modifier: Modifier
21
    ): Modifier = if (condition) this.then(modifier) else this
22

23
    fun Modifier.animateContentSizeOptimized(
24
        animationSpec: FiniteAnimationSpec<IntSize> = tween(300)
25
    ): Modifier = composed {
26
        var sizeAnimation by remember { mutableStateOf<Animatable<IntSize, AnimationVector2D>?>(null) }
27

28
        this.layout { measurable, constraints ->
29
            val placeable = measurable.measure(constraints)
30
            val currentSize = IntSize(placeable.width, placeable.height)
31

32
            val animation = sizeAnimation ?: Animatable(currentSize, IntSize.VectorConverter).also {
33
                sizeAnimation = it
34
            }
35

36
            if (animation.targetValue != currentSize) {
37
                animation.animateTo(currentSize, animationSpec)
38
            }
39

40
            layout(animation.value.width, animation.value.height) {
41
                placeable.placeRelative(0, 0)
42
            }
43
        }
44
    }
45
}
46

47
// Usage example
48
@Composable
49
fun PerformantTaskCard(
50
    task: Task,
51
    isExpanded: Boolean,
52
    onClick: () -> Unit
53
) {
54
    Card(
55
        modifier = Modifier
56
            .fillMaxWidth()
57
            .optimizedClickable(onClick = onClick)
58
            .conditionalModifier(
59
                condition = isExpanded,
60
                modifier = Modifier.animateContentSizeOptimized()
61
            )
62
    ) {
63
        // Card content
64
    }
65
}

Database Performance Optimization#

Optimized Room Queries#

1
@Dao
2
interface OptimizedTasksDao {
3

4
    // Use specific columns instead of SELECT *
5
    @Query("""
6
        SELECT id, title, is_completed, priority, created_at
7
        FROM tasks
8
        WHERE is_completed = :isCompleted
9
        ORDER BY
10
            CASE priority
11
                WHEN 'HIGH' THEN 0
12
                WHEN 'MEDIUM' THEN 1
13
                WHEN 'LOW' THEN 2
14
            END,
15
            created_at DESC
16
    """)
17
    fun getTasksByCompletion(isCompleted: Boolean): Flow<List<TaskSummary>>
18

19
    // Paginated queries for large datasets
20
    @Query("""
21
        SELECT * FROM tasks
22
        WHERE title LIKE :searchQuery OR description LIKE :searchQuery
23
        ORDER BY created_at DESC
24
        LIMIT :limit OFFSET :offset
25
    """)
26
    suspend fun searchTasks(searchQuery: String, limit: Int, offset: Int): List<Task>
27

28
    // Batch operations for better performance
29
    @Insert(onConflict = OnConflictStrategy.REPLACE)
30
    suspend fun insertTasks(tasks: List<Task>)
31

32
    @Update
33
    suspend fun updateTasks(tasks: List<Task>)
34

35
    // Efficient count queries
36
    @Query("SELECT COUNT(*) FROM tasks WHERE is_completed = :isCompleted")
37
    suspend fun getTaskCount(isCompleted: Boolean): Int
38

39
    // Use indexes for better query performance
40
    @Query("""
41
        CREATE INDEX IF NOT EXISTS index_tasks_completion_priority
42
        ON tasks(is_completed, priority, created_at)
43
    """)
44
    suspend fun createPerformanceIndexes()
45

46
    // Efficient bulk updates
47
    @Query("UPDATE tasks SET is_completed = :isCompleted WHERE id IN (:taskIds)")
48
    suspend fun updateTasksCompletion(taskIds: List<String>, isCompleted: Boolean)
49

50
    // Clean up old data periodically
51
    @Query("DELETE FROM tasks WHERE created_at < :cutoffTime AND is_completed = 1")
52
    suspend fun deleteOldCompletedTasks(cutoffTime: Long)
53
}
54

55
// Data classes optimized for queries
56
@Entity(
57
    tableName = "tasks",
58
    indices = [
59
        Index(value = ["is_completed", "priority", "created_at"]),
60
        Index(value = ["title"]), // For search queries
61
        Index(value = ["created_at"]) // For date range queries
62
    ]
63
)
64
data class Task(
65
    @PrimaryKey val id: String,
66
    val title: String,
67
    val description: String,
68
    @ColumnInfo(name = "is_completed") val isCompleted: Boolean,
69
    val priority: TaskPriority,
70
    @ColumnInfo(name = "created_at") val createdAt: Long,
71
    @ColumnInfo(name = "updated_at") val updatedAt: Long
72
)
73

74
// Lightweight data class for list queries
75
data class TaskSummary(
76
    val id: String,
77
    val title: String,
78
    @ColumnInfo(name = "is_completed") val isCompleted: Boolean,
79
    val priority: TaskPriority,
80
    @ColumnInfo(name = "created_at") val createdAt: Long
81
)

Database Migration Performance#

1
// Optimized database migrations
2
@Database(
3
    entities = [Task::class],
4
    version = 3,
5
    exportSchema = true
6
)
7
abstract class OptimizedTodoDatabase : RoomDatabase() {
8

9
    abstract fun taskDao(): OptimizedTasksDao
10

11
    companion object {
12
        // Efficient migration that preserves performance
13
        val MIGRATION_2_3 = object : Migration(2, 3) {
14
            override fun migrate(database: SupportSQLiteDatabase) {
15
                // Create new table with better structure
16
                database.execSQL("""
17
                    CREATE TABLE tasks_new (
18
                        id TEXT PRIMARY KEY NOT NULL,
19
                        title TEXT NOT NULL,
20
                        description TEXT NOT NULL DEFAULT '',
21
                        is_completed INTEGER NOT NULL DEFAULT 0,
22
                        priority TEXT NOT NULL DEFAULT 'MEDIUM',
23
                        created_at INTEGER NOT NULL DEFAULT 0,
24
                        updated_at INTEGER NOT NULL DEFAULT 0
25
                    )
26
                """)
27

28
                // Copy data efficiently
29
                database.execSQL("""
30
                    INSERT INTO tasks_new (id, title, description, is_completed, created_at, updated_at)
31
                    SELECT id, title, description, is_completed,
32
                           COALESCE(created_at, ${System.currentTimeMillis()}),
33
                           ${System.currentTimeMillis()}
34
                    FROM tasks
35
                """)
36

37
                // Drop old table and rename new one
38
                database.execSQL("DROP TABLE tasks")
39
                database.execSQL("ALTER TABLE tasks_new RENAME TO tasks")
40

41
                // Create indexes for optimal performance
42
                database.execSQL("""
43
                    CREATE INDEX index_tasks_completion_priority
44
                    ON tasks(is_completed, priority, created_at)
45
                """)
46
                database.execSQL("CREATE INDEX index_tasks_title ON tasks(title)")
47
                database.execSQL("CREATE INDEX index_tasks_created_at ON tasks(created_at)")
48
            }
49
        }
50
    }
51
}

Network Performance Optimization#

Optimized API Client#

1
// High-performance HTTP client configuration
2
@Module
3
@InstallIn(SingletonComponent::class)
4
object NetworkModule {
5

6
    @Provides
7
    @Singleton
8
    fun provideOkHttpClient(
9
        @ApplicationContext context: Context
10
    ): OkHttpClient {
11
        return OkHttpClient.Builder()
12
            .connectTimeout(10, TimeUnit.SECONDS)
13
            .readTimeout(30, TimeUnit.SECONDS)
14
            .writeTimeout(30, TimeUnit.SECONDS)
15
            .connectionPool(ConnectionPool(5, 5, TimeUnit.MINUTES))
16
            .addInterceptor(HttpLoggingInterceptor().apply {
17
                level = if (BuildConfig.DEBUG) {
18
                    HttpLoggingInterceptor.Level.BODY
19
                } else {
20
                    HttpLoggingInterceptor.Level.NONE
21
                }
22
            })
23
            .addInterceptor(CacheInterceptor())
24
            .cache(Cache(File(context.cacheDir, "http-cache"), 50L * 1024L * 1024L)) // 50MB cache
25
            .build()
26
    }
27

28
    @Provides
29
    @Singleton
30
    fun provideRetrofit(okHttpClient: OkHttpClient): Retrofit {
31
        return Retrofit.Builder()
32
            .baseUrl(BuildConfig.API_BASE_URL)
33
            .client(okHttpClient)
34
            .addConverterFactory(MoshiConverterFactory.create())
35
            .build()
36
    }
37
}
38

39
// Smart caching interceptor
40
class CacheInterceptor : Interceptor {
41
    override fun intercept(chain: Interceptor.Chain): Response {
42
        val request = chain.request()
43
        val response = chain.proceed(request)
44

45
        // Apply different caching strategies based on endpoint
46
        val cacheControl = when {
47
            request.url.pathSegments.contains("tasks") -> {
48
                CacheControl.Builder()
49
                    .maxAge(5, TimeUnit.MINUTES) // Cache tasks for 5 minutes
50
                    .build()
51
            }
52
            request.url.pathSegments.contains("user") -> {
53
                CacheControl.Builder()
54
                    .maxAge(1, TimeUnit.HOURS) // Cache user info for 1 hour
55
                    .build()
56
            }
57
            else -> {
58
                CacheControl.Builder()
59
                    .maxAge(1, TimeUnit.MINUTES)
60
                    .build()
61
            }
62
        }
63

64
        return response.newBuilder()
65
            .header("Cache-Control", cacheControl.toString())
66
            .build()
67
    }
68
}

Efficient Data Synchronization#

1
// Optimized sync service
2
@HiltWorker
3
class OptimizedSyncWorker @AssistedInject constructor(
4
    @Assisted appContext: Context,
5
    @Assisted workerParams: WorkerParameters,
6
    private val repository: TasksRepository,
7
    private val performanceMonitor: PerformanceMonitor
8
) : CoroutineWorker(appContext, workerParams) {
9

10
    override suspend fun doWork(): Result {
11
        val token = performanceMonitor.startMeasurement("background_sync")
12

13
        return try {
14
            withContext(Dispatchers.IO) {
15
                val lastSyncTime = getLastSyncTime()
16

17
                // Only sync changes since last sync
18
                val deltaChanges = repository.getChangesSince(lastSyncTime)
19

20
                if (deltaChanges.isNotEmpty()) {
21
                    // Batch API calls for efficiency
22
                    val results = deltaChanges.chunked(50).map { batch ->
23
                        async { repository.syncBatch(batch) }
24
                    }.awaitAll()
25

26
                    if (results.all { it.isSuccess }) {
27
                        updateLastSyncTime()
28
                        Result.success()
29
                    } else {
30
                        Result.retry()
31
                    }
32
                } else {
33
                    Result.success() // No changes to sync
34
                }
35
            }
36
        } catch (e: Exception) {
37
            Timber.e(e, "Sync failed")
38
            Result.failure()
39
        } finally {
40
            performanceMonitor.endMeasurement(token)
41
        }
42
    }
43

44
    private suspend fun getLastSyncTime(): Long {
45
        // Get from preferences or database
46
        return 0L
47
    }
48

49
    private suspend fun updateLastSyncTime() {
50
        // Update sync timestamp
51
    }
52
}

Memory Management#

Memory-Efficient Image Loading#

1
// Optimized image loading with Coil
2
@Composable
3
fun OptimizedTaskImage(
4
    imageUrl: String?,
5
    contentDescription: String?,
6
    modifier: Modifier = Modifier
7
) {
8
    if (imageUrl != null) {
9
        AsyncImage(
10
            model = ImageRequest.Builder(LocalContext.current)
11
                .data(imageUrl)
12
                .crossfade(true)
13
                .memoryCachePolicy(CachePolicy.ENABLED)
14
                .diskCachePolicy(CachePolicy.ENABLED)
15
                .size(Size.ORIGINAL) // Let Coil handle sizing
16
                .build(),
17
            contentDescription = contentDescription,
18
            modifier = modifier,
19
            contentScale = ContentScale.Crop,
20
            error = painterResource(R.drawable.ic_error_placeholder),
21
            placeholder = painterResource(R.drawable.ic_loading_placeholder)
22
        )
23
    } else {
24
        // Placeholder for missing images
25
        Box(
26
            modifier = modifier.background(MaterialTheme.colorScheme.surfaceVariant),
27
            contentAlignment = Alignment.Center
28
        ) {
29
            Icon(
30
                imageVector = Icons.Default.Image,
31
                contentDescription = contentDescription,
32
                tint = MaterialTheme.colorScheme.onSurfaceVariant
33
            )
34
        }
35
    }
36
}
37

38
// Image cache configuration
39
@Module
40
@InstallIn(SingletonComponent::class)
41
object ImageModule {
42

43
    @Provides
44
    @Singleton
45
    fun provideImageLoader(
46
        @ApplicationContext context: Context,
47
        okHttpClient: OkHttpClient
48
    ): ImageLoader {
49
        return ImageLoader.Builder(context)
50
            .okHttpClient(okHttpClient)
51
            .memoryCache {
52
                MemoryCache.Builder(context)
53
                    .maxSizePercent(0.25) // Use 25% of available memory
54
                    .build()
55
            }
56
            .diskCache {
57
                DiskCache.Builder()
58
                    .directory(context.cacheDir.resolve("image_cache"))
59
                    .maxSizeBytes(100 * 1024 * 1024) // 100MB
60
                    .build()
61
            }
62
            .respectCacheHeaders(false) // Handle caching manually
63
            .build()
64
    }
65
}

Memory Leak Prevention#

1
// Memory-safe ViewModel base class
2
abstract class LeakSafeViewModel : ViewModel() {
3

4
    // Use weak references for context-dependent operations
5
    private val contextRefs = mutableSetOf<WeakReference<Context>>()
6

7
    protected fun addContextReference(context: Context) {
8
        contextRefs.add(WeakReference(context))
9
    }
10

11
    protected fun getValidContext(): Context? {
12
        return contextRefs.firstOrNull { it.get() != null }?.get()
13
    }
14

15
    override fun onCleared() {
16
        super.onCleared()
17
        contextRefs.clear()
18
    }
19

20
    // Safe coroutine launching
21
    protected fun launchSafely(
22
        block: suspend CoroutineScope.() -> Unit
23
    ): Job {
24
        return viewModelScope.launch {
25
            try {
26
                block()
27
            } catch (e: CancellationException) {
28
                throw e // Re-throw cancellation
29
            } catch (e: Exception) {
30
                Timber.e(e, "Coroutine failed in ${this@LeakSafeViewModel::class.simpleName}")
31
            }
32
        }
33
    }
34
}
35

36
// Memory monitoring utility
37
class MemoryMonitor @Inject constructor() {
38

39
    fun getCurrentMemoryUsage(): MemoryInfo {
40
        val runtime = Runtime.getRuntime()
41
        val activityManager = getSystemService<ActivityManager>()
42

43
        return MemoryInfo(
44
            heapUsedMB = (runtime.totalMemory() - runtime.freeMemory()) / (1024 * 1024),
45
            heapMaxMB = runtime.maxMemory() / (1024 * 1024),
46
            isLowMemory = activityManager?.isLowMemory ?: false
47
        )
48
    }
49

50
    fun logMemoryWarnings() {
51
        val memInfo = getCurrentMemoryUsage()
52

53
        if (memInfo.heapUsedMB > memInfo.heapMaxMB * 0.8) {
54
            Timber.w("High memory usage: ${memInfo.heapUsedMB}MB / ${memInfo.heapMaxMB}MB")
55
        }
56

57
        if (memInfo.isLowMemory) {
58
            Timber.w("System is in low memory state")
59
        }
60
    }
61
}
62

63
data class MemoryInfo(
64
    val heapUsedMB: Long,
65
    val heapMaxMB: Long,
66
    val isLowMemory: Boolean
67
)

Performance Testing and Monitoring#

Automated Performance Testing#

1
// Performance benchmark tests
2
@RunWith(AndroidJUnit4::class)
3
class TasksPerformanceBenchmark {
4

5
    @get:Rule
6
    val benchmarkRule = BenchmarkRule()
7

8
    @Test
9
    fun benchmarkTaskListScrolling() {
10
        benchmarkRule.measureRepeated {
11
            composeTestRule.setContent {
12
                val tasks = remember { generateTestTasks(1000) }
13
                TasksList(tasks = tasks, onTaskClick = {})
14
            }
15

16
            // Measure scrolling performance
17
            composeTestRule.onRoot()
18
                .performGesture { swipeUp() }
19
        }
20
    }
21

22
    @Test
23
    fun benchmarkDatabaseOperations() = runTest {
24
        benchmarkRule.measureRepeated {
25
            val tasks = generateTestTasks(100)
26

27
            runBlocking {
28
                tasks.forEach { task ->
29
                    repository.saveTask(task)
30
                }
31

32
                repository.getTasks()
33
            }
34
        }
35
    }
36

37
    private fun generateTestTasks(count: Int): List<Task> {
38
        return (1..count).map { index ->
39
            Task(
40
                id = "task_$index",
41
                title = "Task $index",
42
                description = "Description for task $index",
43
                isCompleted = index % 3 == 0,
44
                priority = TaskPriority.values()[index % 3],
45
                createdAt = System.currentTimeMillis() - (index * 1000),
46
                updatedAt = System.currentTimeMillis()
47
            )
48
        }
49
    }
50
}
51

52
// Custom performance assertions
53
object PerformanceAssertions {
54

55
    fun assertExecutionTime(maxTimeMs: Long, operation: () -> Unit) {
56
        val startTime = System.nanoTime()
57
        operation()
58
        val endTime = System.nanoTime()
59

60
        val actualTimeMs = (endTime - startTime) / 1_000_000
61

62
        if (actualTimeMs > maxTimeMs) {
63
            throw AssertionError(
64
                "Operation took ${actualTimeMs}ms, expected maximum ${maxTimeMs}ms"
65
            )
66
        }
67
    }
68

69
    fun assertMemoryUsage(maxMemoryMB: Long, operation: () -> Unit) {
70
        System.gc() // Suggest garbage collection
71
        Thread.sleep(100) // Wait for GC
72

73
        val runtime = Runtime.getRuntime()
74
        val memoryBefore = runtime.totalMemory() - runtime.freeMemory()
75

76
        operation()
77

78
        System.gc()
79
        Thread.sleep(100)
80

81
        val memoryAfter = runtime.totalMemory() - runtime.freeMemory()
82
        val memoryUsedMB = (memoryAfter - memoryBefore) / (1024 * 1024)
83

84
        if (memoryUsedMB > maxMemoryMB) {
85
            throw AssertionError(
86
                "Operation used ${memoryUsedMB}MB, expected maximum ${maxMemoryMB}MB"
87
            )
88
        }
89
    }
90
}

Conclusion#

Android performance optimization requires a holistic approach covering all layers of your application:

Monitoring Foundation: Implement comprehensive performance metrics collection
ViewModel Optimization: Use StateFlow, debouncing, and efficient state management
Repository Performance: Implement caching, batching, and smart sync strategies
Compose Optimization: Optimize recomposition with stable data and efficient modifiers
Database Performance: Use optimized queries, indexing, and batch operations
Memory Management: Prevent leaks and optimize image loading
Network Efficiency: Implement smart caching and efficient synchronization
Performance Testing: Create automated benchmarks and assertions

Key principles for high-performance Android apps:

Measure First: Always profile before optimizing
Optimize Lazily: Use lazy evaluation and on-demand loading
Cache Wisely: Implement multi-level caching strategies
Batch Operations: Group related operations for efficiency
Monitor Continuously: Track performance in production

By following these optimization strategies, you’ll create Android applications that provide smooth, responsive user experiences while maintaining clean, maintainable code architecture.

Remember: premature optimization can be counterproductive. Always measure performance impact and optimize the most critical paths first.