Android Studio × Antigravity Android Dev Guide — Accelerate Kotlin/Jetpack Compose with AI

Create a Jetpack Compose home screen with:
 
- Material 3 theme
- TopAppBar with app title and avatar icon
- LazyColumn displaying cards
- Each card: thumbnail image, title, description (2 lines max), favorite button
- Pull-to-refresh support
- Loading, error, and empty states
- Navigation Compose integration
- MVVM pattern with Hilt

// ui/screens/home/HomeScreen.kt
package com.example.myapp.ui.screens.home
 
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.AccountCircle
import androidx.compose.material3.*
import androidx.compose.material3.pulltorefresh.PullToRefreshBox
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun HomeScreen(
    onNavigateToDetail: (String) -> Unit,
    onNavigateToProfile: () -> Unit,
    viewModel: HomeViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsState()
 
    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("My App") },
                actions = {
                    IconButton(onClick = onNavigateToProfile) {
                        Icon(
                            imageVector = Icons.Default.AccountCircle,
                            contentDescription = "Profile"
                        )
                    }
                }
            )
        }
    ) { paddingValues ->
        PullToRefreshBox(
            isRefreshing = uiState is HomeUiState.Loading,
            onRefresh = { viewModel.refresh() },
            modifier = Modifier
                .fillMaxSize()
                .padding(paddingValues)
        ) {
            when (val state = uiState) {
                is HomeUiState.Loading -> {
                    Box(
                        modifier = Modifier.fillMaxSize(),
                        contentAlignment = Alignment.Center
                    ) {
                        CircularProgressIndicator()
                    }
                }
 
                is HomeUiState.Success -> {
                    if (state.items.isEmpty()) {
                        EmptyState()
                    } else {
                        LazyColumn(
                            contentPadding = PaddingValues(16.dp),
                            verticalArrangement = Arrangement.spacedBy(12.dp)
                        ) {
                            items(
                                items = state.items,
                                key = { it.id }
                            ) { item ->
                                ItemCard(
                                    item = item,
                                    onItemClick = { onNavigateToDetail(item.id) },
                                    onFavoriteClick = {
                                        viewModel.toggleFavorite(item.id)
                                    }
                                )
                            }
                        }
                    }
                }
 
                is HomeUiState.Error -> {
                    ErrorState(
                        message = state.message,
                        onRetry = { viewModel.refresh() }
                    )
                }
            }
        }
    }
}

// ui/components/ItemCard.kt
package com.example.myapp.ui.components
 
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Favorite
import androidx.compose.material.icons.outlined.FavoriteBorder
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage
import com.example.myapp.data.model.Item
 
@Composable
fun ItemCard(
    item: Item,
    onItemClick: () -> Unit,
    onFavoriteClick: () -> Unit,
    modifier: Modifier = Modifier
) {
    Card(
        modifier = modifier
            .fillMaxWidth()
            .clickable(onClick = onItemClick),
        elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
    ) {
        Row(
            modifier = Modifier
                .padding(12.dp)
                .fillMaxWidth(),
            verticalAlignment = Alignment.CenterVertically
        ) {
            AsyncImage(
                model = item.thumbnailUrl,
                contentDescription = item.title,
                contentScale = ContentScale.Crop,
                modifier = Modifier
                    .size(80.dp)
                    .clip(MaterialTheme.shapes.medium)
            )
 
            Spacer(modifier = Modifier.width(12.dp))
 
            Column(modifier = Modifier.weight(1f)) {
                Text(
                    text = item.title,
                    style = MaterialTheme.typography.titleSmall,
                    maxLines = 1,
                    overflow = TextOverflow.Ellipsis
                )
                Spacer(modifier = Modifier.height(4.dp))
                Text(
                    text = item.description,
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
                    maxLines = 2,
                    overflow = TextOverflow.Ellipsis
                )
            }
 
            IconButton(onClick = onFavoriteClick) {
                Icon(
                    imageVector = if (item.isFavorite) {
                        Icons.Filled.Favorite
                    } else {
                        Icons.Outlined.FavoriteBorder
                    },
                    contentDescription = "Favorite",
                    tint = if (item.isFavorite) {
                        MaterialTheme.colorScheme.error
                    } else {
                        MaterialTheme.colorScheme.onSurfaceVariant
                    }
                )
            }
        }
    }
}
 
@Preview(showBackground = true)
@Composable
private fun ItemCardPreview() {
    ItemCard(
        item = Item(
            id = "1",
            title = "Sample Item",
            description = "This is a sample description that can span up to two lines.",
            thumbnailUrl = "https://example.com/image.jpg",
            isFavorite = false
        ),
        onItemClick = {},
        onFavoriteClick = {}
    )
}

// ui/screens/home/HomeUiState.kt
package com.example.myapp.ui.screens.home
 
import com.example.myapp.data.model.Item
 
sealed interface HomeUiState {
    data object Loading : HomeUiState
    data class Success(val items: List<Item>) : HomeUiState
    data class Error(val message: String) : HomeUiState
}

// viewmodel/HomeViewModel.kt
package com.example.myapp.viewmodel
 
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.myapp.data.repository.ItemRepository
import com.example.myapp.ui.screens.home.HomeUiState
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
import javax.inject.Inject
 
@HiltViewModel
class HomeViewModel @Inject constructor(
    private val itemRepository: ItemRepository
) : ViewModel() {
 
    private val _uiState = MutableStateFlow<HomeUiState>(HomeUiState.Loading)
    val uiState: StateFlow<HomeUiState> = _uiState.asStateFlow()
 
    init {
        loadItems()
    }
 
    private fun loadItems() {
        viewModelScope.launch {
            _uiState.value = HomeUiState.Loading
            itemRepository.getItems()
                .catch { e ->
                    _uiState.value = HomeUiState.Error(
                        e.localizedMessage ?: "An unexpected error occurred"
                    )
                }
                .collect { items ->
                    _uiState.value = HomeUiState.Success(items)
                }
        }
    }
 
    fun refresh() {
        loadItems()
    }
 
    fun toggleFavorite(itemId: String) {
        viewModelScope.launch {
            itemRepository.toggleFavorite(itemId)
        }
    }
}

// data/model/Item.kt
package com.example.myapp.data.model
 
import kotlinx.serialization.Serializable
 
@Serializable
data class Item(
    val id: String,
    val title: String,
    val description: String,
    val thumbnailUrl: String,
    val isFavorite: Boolean = false
)

// data/remote/ApiService.kt
package com.example.myapp.data.remote
 
import com.example.myapp.data.model.Item
import retrofit2.http.GET
import retrofit2.http.POST
import retrofit2.http.Path
import retrofit2.http.Query
 
interface ApiService {
    @GET("items")
    suspend fun getItems(
        @Query("page") page: Int = 1,
        @Query("limit") limit: Int = 20
    ): List<Item>
 
    @GET("items/{id}")
    suspend fun getItem(@Path("id") id: String): Item
 
    @POST("items/{id}/favorite")
    suspend fun toggleFavorite(@Path("id") id: String): Item
}

// data/repository/ItemRepository.kt
package com.example.myapp.data.repository
 
import com.example.myapp.data.local.ItemDao
import com.example.myapp.data.model.Item
import com.example.myapp.data.remote.ApiService
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import javax.inject.Inject
import javax.inject.Singleton
 
@Singleton
class ItemRepository @Inject constructor(
    private val apiService: ApiService,
    private val itemDao: ItemDao
) {
    fun getItems(): Flow<List<Item>> = flow {
        // Emit cached data first
        val cachedItems = itemDao.getAllItems()
        if (cachedItems.isNotEmpty()) {
            emit(cachedItems.map { it.toItem() })
        }
 
        // Fetch fresh data from API
        try {
            val remoteItems = apiService.getItems()
            itemDao.insertAll(remoteItems.map { it.toEntity() })
            emit(remoteItems)
        } catch (e: Exception) {
            if (cachedItems.isEmpty()) throw e
        }
    }
 
    suspend fun toggleFavorite(itemId: String) {
        try {
            val updatedItem = apiService.toggleFavorite(itemId)
            itemDao.update(updatedItem.toEntity())
        } catch (e: Exception) {
            itemDao.toggleFavorite(itemId)
        }
    }
}

// data/local/AppDatabase.kt
package com.example.myapp.data.local
 
import androidx.room.*
 
@Entity(tableName = "items")
data class ItemEntity(
    @PrimaryKey val id: String,
    val title: String,
    val description: String,
    val thumbnailUrl: String,
    val isFavorite: Boolean = false
)
 
@Dao
interface ItemDao {
    @Query("SELECT * FROM items ORDER BY title ASC")
    suspend fun getAllItems(): List<ItemEntity>
 
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAll(items: List<ItemEntity>)
 
    @Update
    suspend fun update(item: ItemEntity)
 
    @Query("UPDATE items SET isFavorite = NOT isFavorite WHERE id = :id")
    suspend fun toggleFavorite(id: String)
}
 
@Database(entities = [ItemEntity::class], version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun itemDao(): ItemDao
}

// di/AppModule.kt
package com.example.myapp.di
 
import android.content.Context
import androidx.room.Room
import com.example.myapp.data.local.AppDatabase
import com.example.myapp.data.local.ItemDao
import com.example.myapp.data.remote.ApiService
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.qualifiers.ApplicationContext
import dagger.hilt.components.SingletonComponent
import kotlinx.serialization.json.Json
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.kotlinx.serialization.asConverterFactory
import java.util.concurrent.TimeUnit
import javax.inject.Singleton
 
@Module
@InstallIn(SingletonComponent::class)
object AppModule {
 
    @Provides
    @Singleton
    fun provideOkHttpClient(): OkHttpClient {
        return OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .addInterceptor(
                HttpLoggingInterceptor().apply {
                    level = HttpLoggingInterceptor.Level.BODY
                }
            )
            .build()
    }
 
    @Provides
    @Singleton
    fun provideApiService(okHttpClient: OkHttpClient): ApiService {
        val json = Json { ignoreUnknownKeys = true }
        return Retrofit.Builder()
            .baseUrl("https://api.example.com/")
            .client(okHttpClient)
            .addConverterFactory(
                json.asConverterFactory("application/json".toMediaType())
            )
            .build()
            .create(ApiService::class.java)
    }
 
    @Provides
    @Singleton
    fun provideDatabase(
        @ApplicationContext context: Context
    ): AppDatabase {
        return Room.databaseBuilder(
            context,
            AppDatabase::class.java,
            "myapp-database"
        ).build()
    }
 
    @Provides
    fun provideItemDao(database: AppDatabase): ItemDao {
        return database.itemDao()
    }
}

// test/viewmodel/HomeViewModelTest.kt
package com.example.myapp.viewmodel
 
import app.cash.turbine.test
import com.example.myapp.data.model.Item
import com.example.myapp.data.repository.ItemRepository
import com.example.myapp.ui.screens.home.HomeUiState
import io.mockk.*
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.*
import org.junit.jupiter.api.*
import org.junit.jupiter.api.Assertions.*
 
@OptIn(ExperimentalCoroutinesApi::class)
class HomeViewModelTest {
 
    private lateinit var viewModel: HomeViewModel
    private val repository: ItemRepository = mockk()
    private val testDispatcher = UnconfinedTestDispatcher()
 
    @BeforeEach
    fun setUp() {
        Dispatchers.setMain(testDispatcher)
    }
 
    @AfterEach
    fun tearDown() {
        Dispatchers.resetMain()
    }
 
    @Test
    fun `initial load success emits Success state`() = runTest {
        val items = listOf(
            Item("1", "Item 1", "Description 1", "url1"),
            Item("2", "Item 2", "Description 2", "url2")
        )
        every { repository.getItems() } returns flowOf(items)
 
        viewModel = HomeViewModel(repository)
 
        viewModel.uiState.test {
            val state = awaitItem()
            assertInstanceOf(HomeUiState.Success::class.java, state)
            assertEquals(2, (state as HomeUiState.Success).items.size)
        }
    }
 
    @Test
    fun `initial load failure emits Error state`() = runTest {
        every { repository.getItems() } returns flow {
            throw RuntimeException("Network error")
        }
 
        viewModel = HomeViewModel(repository)
 
        viewModel.uiState.test {
            val state = awaitItem()
            assertInstanceOf(HomeUiState.Error::class.java, state)
            assertTrue((state as HomeUiState.Error).message.contains("Network error"))
        }
    }
 
    @Test
    fun `toggleFavorite delegates to repository`() = runTest {
        every { repository.getItems() } returns flowOf(emptyList())
        coEvery { repository.toggleFavorite("1") } just runs
 
        viewModel = HomeViewModel(repository)
        viewModel.toggleFavorite("1")
 
        coVerify { repository.toggleFavorite("1") }
    }
 
    @Test
    fun `refresh reloads items from repository`() = runTest {
        every { repository.getItems() } returns flowOf(emptyList())
 
        viewModel = HomeViewModel(repository)
        viewModel.refresh()
 
        verify(exactly = 2) { repository.getItems() }
    }
}

// androidTest/ui/screens/home/HomeScreenTest.kt
package com.example.myapp.ui.screens.home
 
import androidx.compose.ui.test.*
import androidx.compose.ui.test.junit4.createComposeRule
import com.example.myapp.data.model.Item
import org.junit.Rule
import org.junit.Test
 
class HomeScreenTest {
 
    @get:Rule
    val composeTestRule = createComposeRule()
 
    @Test
    fun loadingState_showsProgressIndicator() {
        composeTestRule.setContent {
            // Set up loading state mock
        }
        composeTestRule
            .onNode(hasProgressBarRangeInfo(ProgressBarRangeInfo.Indeterminate))
            .assertIsDisplayed()
    }
 
    @Test
    fun successState_displaysItemList() {
        val testItems = listOf(
            Item("1", "Test Item 1", "Description 1", "url1"),
            Item("2", "Test Item 2", "Description 2", "url2")
        )
 
        composeTestRule.setContent {
            // Set up success state with testItems
        }
 
        composeTestRule.onNodeWithText("Test Item 1").assertIsDisplayed()
        composeTestRule.onNodeWithText("Test Item 2").assertIsDisplayed()
    }
 
    @Test
    fun favoriteButton_respondsToClick() {
        val testItem = Item("1", "Test", "Desc", "url1", isFavorite = false)
 
        composeTestRule.setContent {
            ItemCard(
                item = testItem,
                onItemClick = {},
                onFavoriteClick = {}
            )
        }
 
        composeTestRule
            .onNodeWithContentDescription("Favorite")
            .performClick()
    }
}

// ui/navigation/AppNavigation.kt
package com.example.myapp.ui.navigation
 
import androidx.compose.runtime.Composable
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.example.myapp.ui.screens.detail.DetailScreen
import com.example.myapp.ui.screens.home.HomeScreen
import com.example.myapp.ui.screens.profile.ProfileScreen
 
@Composable
fun AppNavigation(
    navController: NavHostController = rememberNavController()
) {
    NavHost(
        navController = navController,
        startDestination = "home"
    ) {
        composable("home") {
            HomeScreen(
                onNavigateToDetail = { itemId ->
                    navController.navigate("detail/$itemId")
                },
                onNavigateToProfile = {
                    navController.navigate("profile")
                }
            )
        }
 
        composable("detail/{itemId}") { backStackEntry ->
            val itemId = backStackEntry.arguments?.getString("itemId") ?: return@composable
            DetailScreen(
                itemId = itemId,
                onNavigateBack = { navController.popBackStack() }
            )
        }
 
        composable("profile") {
            ProfileScreen(
                onNavigateBack = { navController.popBackStack() }
            )
        }
    }
}

# 1. Generate a release keystore (first time only)
keytool -genkey -v -keystore release-keystore.jks \
  -keyalg RSA -keysize 2048 -validity 10000 \
  -alias myapp
 
# 2. Build Android App Bundle (recommended)
./gradlew bundleRelease
 
# 3. Build APK (for direct distribution)
./gradlew assembleRelease

Analyze this crash log and suggest a fix:
 
java.lang.IllegalStateException: LifecycleOwner is attempting to register
while current state is RESUMED. LifecycleOwners must call register before
they are STARTED.

Optimize this Compose component. Eliminate unnecessary recompositions
using remember, derivedStateOf, and stable types where appropriate.
 
[paste your code]

// build.gradle.kts (app module)
composeCompiler {
    reportsDestination = layout.buildDirectory.dir("compose_reports")
    metricsDestination = layout.buildDirectory.dir("compose_metrics")
}

// Lock the shared UI State type first; attach it to every screen's generation prompt
sealed interface UiState<out T> {
    data object Loading : UiState<Nothing>
    data class Success<T>(val data: T) : UiState<T>
    data class Error(val message: String, val retryable: Boolean) : UiState<Nothing>
}