aj-geddes/android-kotlin-development

O que android-kotlin-development faz?

Desenvolva aplicativos Android nativos com Kotlin. Abrange MVVM com Jetpack, Compose para UI moderna, Retrofit para chamadas de API, Room para armazenamento local e arquitetura de navegação.

Visão Geral

Esta skill orienta o desenvolvimento de aplicativos Android nativos usando a linguagem Kotlin, seguindo as melhores práticas e bibliotecas oficiais do ecossistema Android. Ela cobre a arquitetura MVVM com Android Jetpack, interface de usuário moderna com Jetpack Compose, comunicação com APIs via Retrofit, persistência de dados local com Room e navegação estruturada com Navigation Component.

Pré-requisitos

• Conhecimento básico de Kotlin
• Android Studio instalado
• SDK do Android configurado

Estrutura do Projeto

app/
├── src/
│   ├── main/
│   │   ├── java/com/example/app/
│   │   │   ├── data/          # Repositórios, DAOs, modelos de dados
│   │   │   ├── ui/            # Telas, ViewModels, componentes Compose
│   │   │   ├── navigation/    # Gráfico de navegação
│   │   │   ├── network/       # Interfaces Retrofit
│   │   │   └── di/            # Injeção de dependência (Hilt)
│   │   └── res/               # Recursos (layouts, strings, etc.)
│   └── test/                  # Testes unitários

Configuração Inicial

Adicione as dependências no arquivo build.gradle.kts do módulo app:

dependencies {
    // Jetpack Compose
    implementation("androidx.compose.ui:ui:1.5.0")
    implementation("androidx.compose.material3:material3:1.1.0")
    
    // ViewModel e LiveData
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.1")
    implementation("androidx.lifecycle:lifecycle-livedata-ktx:2.6.1")
    
    // Retrofit
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-gson:2.9.0")
    
    // Room
    implementation("androidx.room:room-runtime:2.5.0")
    kapt("androidx.room:room-compiler:2.5.0")
    
    // Navigation
    implementation("androidx.navigation:navigation-compose:2.7.0")
}

Padrão MVVM

A arquitetura MVVM é implementada com:

1. Model: classes de dados e repositórios
2. ViewModel: estado e lógica de negócio
3. View: telas Compose observando o estado

Exemplo de ViewModel

class MainViewModel : ViewModel() {
    private val _state = MutableStateFlow(MainState())
    val state: StateFlow<MainState> = _state.asStateFlow()
    
    fun loadData() {
        viewModelScope.launch {
            _state.update { it.copy(isLoading = true) }
            // chamada de API via Retrofit
            val result = repository.getData()
            _state.update { it.copy(data = result, isLoading = false) }
        }
    }
}

Exemplo de Tela Compose

@Composable
fun MainScreen(viewModel: MainViewModel = viewModel()) {
    val state by viewModel.state.collectAsState()
    
    when {
        state.isLoading -> CircularProgressIndicator()
        state.error != null -> Text("Erro: ${state.error}")
        else -> LazyColumn {
            items(state.data) { item ->
                Text(item.name)
            }
        }
    }
}

Chamadas de API com Retrofit

Defina uma interface para a API:

interface ApiService {
    @GET("users")
    suspend fun getUsers(): List<User>
}

Configure o cliente Retrofit:

val retrofit = Retrofit.Builder()
    .baseUrl("https://api.exemplo.com/")
    .addConverterFactory(GsonConverterFactory.create())
    .build()

Armazenamento Local com Room

Defina uma entidade e DAO:

@Entity
data class User(
    @PrimaryKey val id: Int,
    val name: String
)

@Dao
interface UserDao {
    @Query("SELECT * FROM user")
    suspend fun getAll(): List<User>
    
    @Insert
    suspend fun insert(user: User)
}

Navegação

Configure o gráfico de navegação:

NavHost(navController = navController, startDestination = "home") {
    composable("home") { HomeScreen(onNavigateToDetail = { id ->
        navController.navigate("detail/$id")
    })}
    composable("detail/{id}") { backStackEntry ->
        DetailScreen(id = backStackEntry.arguments?.getString("id") ?: "")
    }
}

Testes

Utilize JUnit, Mockito e kotlinx-coroutines-test para testar ViewModels e repositórios.

Recursos Adicionais

• Documentação Oficial do Android
• Guia de Arquitetura do Android
• Jetpack Compose