SuperAPI AI Directory
Partner with us中文AI newsFavorites
Skillsandroid-expert

android-expert

Coding & development

View repository

Updated 10-16 03:17

About this skill

Android Expert

You are an expert in Android development, Jetpack Compose, Kotlin, Material Design, and modern Android architecture.

Core Concepts

Android Architecture

  • MVVM (Model-View-ViewModel): Recommended architecture pattern
  • MVI (Model-View-Intent): Unidirectional data flow
  • Clean Architecture: Domain, data, presentation layers
  • Repository Pattern: Data source abstraction
  • Use Cases/Interactors: Business logic encapsulation
  • Dependency Injection: Hilt/Dagger for DI

Android Components

  • Activity: Single screen with UI, entry point
  • Fragment: Reusable UI portion within Activity
  • Service: Background operations
  • BroadcastReceiver: System-wide event notifications
  • ContentProvider: Manage shared app data
  • Intent: Messaging between components

Jetpack Compose

  • Declarative UI: Describe UI as functions of state
  • Composable Functions: Building blocks of UI
  • State Management: remember, mutableStateOf, StateFlow
  • Recomposition: UI updates when state changes
  • Side Effects: LaunchedEffect, DisposableEffect, SideEffect
  • Material Design 3: Modern design system

Jetpack Libraries

  • ViewModel: UI-related data holder, lifecycle-aware
  • LiveData: Observable data holder, lifecycle-aware
  • Room: SQLite abstraction layer
  • Navigation: Navigate between destinations
  • WorkManager: Deferrable background work
  • DataStore: Modern data storage (replaces SharedPreferences)
  • Paging: Load data in pages

Activity/Fragment Lifecycle

Activity: onCreate → onStart → onResume → onPause → onStop → onDestroy Fragment: onAttach → onCreate → onCreateView → onViewCreated → onStart → onResume

Best Practices

Jetpack Compose

  • Keep composables small and focused
  • Hoist state to make composables reusable
  • Use remember for objects created during composition
  • Use derivedStateOf for calculated values
  • Avoid side effects in composition
  • Use LaunchedEffect for one-time operations
  • Leverage collectAsState() for Flow/StateFlow

Architecture

  • Follow MVVM or MVI pattern
  • Separate concerns (UI, business logic, data)
  • Use dependency injection (Hilt)
  • Repository pattern for data sources
  • Use sealed classes for state representation
  • Prefer Kotlin Coroutines over callbacks
  • Use StateFlow/SharedFlow over LiveData in new code

Performance

  • Use LazyColumn/LazyRow for lists
  • Implement proper list keys in Compose
  • Profile with Android Profiler
  • Optimize database queries (indexes, pagination)
  • Use WorkManager for background tasks
  • Implement proper caching strategy
  • Avoid memory leaks (lifecycle awareness)

Security

  • Use encrypted SharedPreferences
  • Store sensitive data in Android Keystore
  • Implement certificate pinning
  • Validate all user input
  • Use ProGuard/R8 for code obfuscation
  • Follow security best practices
  • Request minimum required permissions

Anti-Patterns

Common Mistakes

  • Context leaks: Don't hold Activity context in long-lived objects
  • Blocking main thread: Use coroutines for I/O operations
  • Ignoring lifecycle: Use lifecycle-aware components
  • Not handling configuration changes: Use ViewModel
  • Memory leaks: Clean up observers, callbacks
  • Hardcoded strings: Use string resources
  • Not using dependency injection: Tightly coupled code
  • Ignoring accessibility: Support TalkBack, large text

Bad Code Example

// DON'T: Blocking main thread, context leak
class BadViewModel(private val context: Context) : ViewModel() {
    fun loadData(): List<User> {
        // Blocking I/O on main thread
        val response = URL("https://api.com/users").readText()
        return JSONArray(response).toList()
    }
}

// DO: Proper architecture with DI and coroutines
@HiltViewModel
class GoodViewModel @Inject constructor(
    private val userRepository: UserRepository
) : ViewModel() {
    private val _users = MutableStateFlow<List<User>>(emptyList())
    val users: StateFlow<List<User>> = _users.asStateFlow()

    init {
        loadUsers()
    }

    private fun loadUsers() {
        viewModelScope.launch {
            try {
                _users.value = userRepository.getUsers()
            } catch (e: Exception) {
                // Handle error
            }
        }
    }
}

Reference Documentation

Detailed material lives alongside this skill and is read on demand:

  • Code Examples — Jetpack Compose App Structure, MVVM with ViewModel and StateFlow, Room Database, Retrofit API Service, Navigation with Compose, WorkManager Background Task

Resources

Documentation

Tools

Libraries

Testing

Community