Android Studio × Antigravity Android 開発ガイド — Kotlin/Jetpack Compose を AI で加速する

Jetpack Compose で以下のホーム画面を実装してください
 
仕様:
- Material 3 テーマ
- TopAppBar にアプリ名とアバターアイコン
- LazyColumn でカードリスト表示
- 各カードに: サムネイル画像、タイトル、説明文（2行まで）、お気に入りボタン
- Pull-to-refresh 対応
- ローディング・エラー・空状態の3つの状態を表現
- Navigation Compose で画面遷移
- MVVM パターン（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 = "プロフィール"
                        )
                    }
                }
            )
        }
    ) { 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() }
                    )
                }
            }
        }
    }
}
 
@Composable
private fun EmptyState() {
    Box(
        modifier = Modifier.fillMaxSize(),
        contentAlignment = Alignment.Center
    ) {
        Column(horizontalAlignment = Alignment.CenterHorizontally) {
            Text(
                text = "コンテンツがありません",
                style = MaterialTheme.typography.titleMedium
            )
            Spacer(modifier = Modifier.height(8.dp))
            Text(
                text = "新しいアイテムを追加してみましょう",
                style = MaterialTheme.typography.bodyMedium,
                color = MaterialTheme.colorScheme.onSurfaceVariant
            )
        }
    }
}
 
@Composable
private fun ErrorState(
    message: String,
    onRetry: () -> Unit
) {
    Box(
        modifier = Modifier.fillMaxSize(),
        contentAlignment = Alignment.Center
    ) {
        Column(horizontalAlignment = Alignment.CenterHorizontally) {
            Text(
                text = "エラーが発生しました",
                style = MaterialTheme.typography.titleMedium
            )
            Spacer(modifier = Modifier.height(8.dp))
            Text(
                text = message,
                style = MaterialTheme.typography.bodySmall,
                color = MaterialTheme.colorScheme.error
            )
            Spacer(modifier = Modifier.height(16.dp))
            Button(onClick = onRetry) {
                Text("再試行")
            }
        }
    }
}

// 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 = "お気に入り",
                    tint = if (item.isFavorite) {
                        MaterialTheme.colorScheme.error
                    } else {
                        MaterialTheme.colorScheme.onSurfaceVariant
                    }
                )
            }
        }
    }
}
 
@Preview(showBackground = true)
@Composable
private fun ItemCardPreview() {
    ItemCard(
        item = Item(
            id = "1",
            title = "サンプルアイテム",
            description = "これはサンプルの説明文です。2行まで表示されます。",
            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 ?: "不明なエラーが発生しました"
                    )
                }
                .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 {
        // まずキャッシュを返す
        val cachedItems = itemDao.getAllItems()
        if (cachedItems.isNotEmpty()) {
            emit(cachedItems.map { it.toItem() })
        }
 
        // 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>
 
    @Query("SELECT * FROM items WHERE id = :id")
    suspend fun getItemById(id: String): 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 `初期ロード成功時にSuccess状態になる`() = runTest {
        // Arrange
        val items = listOf(
            Item("1", "Item 1", "Desc 1", "url1"),
            Item("2", "Item 2", "Desc 2", "url2")
        )
        every { repository.getItems() } returns flowOf(items)
 
        // Act
        viewModel = HomeViewModel(repository)
 
        // Assert
        viewModel.uiState.test {
            val state = awaitItem()
            assertInstanceOf(HomeUiState.Success::class.java, state)
            assertEquals(2, (state as HomeUiState.Success).items.size)
        }
    }
 
    @Test
    fun `ロード失敗時にError状態になる`() = runTest {
        // Arrange
        every { repository.getItems() } returns flow {
            throw RuntimeException("ネットワークエラー")
        }
 
        // Act
        viewModel = HomeViewModel(repository)
 
        // Assert
        viewModel.uiState.test {
            val state = awaitItem()
            assertInstanceOf(HomeUiState.Error::class.java, state)
            assertTrue((state as HomeUiState.Error).message.contains("ネットワークエラー"))
        }
    }
 
    @Test
    fun `お気に入り切り替えがリポジトリに委譲される`() = runTest {
        // Arrange
        every { repository.getItems() } returns flowOf(emptyList())
        coEvery { repository.toggleFavorite("1") } just runs
 
        viewModel = HomeViewModel(repository)
 
        // Act
        viewModel.toggleFavorite("1")
 
        // Assert
        coVerify { repository.toggleFavorite("1") }
    }
 
    @Test
    fun `refresh呼び出しでアイテムが再取得される`() = runTest {
        // Arrange
        every { repository.getItems() } returns flowOf(emptyList())
 
        viewModel = HomeViewModel(repository)
 
        // Act
        viewModel.refresh()
 
        // Assert
        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 ローディング状態でプログレスが表示される() {
        composeTestRule.setContent {
            // ローディング状態のモックを設定
        }
        composeTestRule.onNode(hasProgressBarRangeInfo(ProgressBarRangeInfo.Indeterminate))
            .assertIsDisplayed()
    }
 
    @Test
    fun アイテムリストが正しく表示される() {
        val testItems = listOf(
            Item("1", "テストアイテム1", "説明1", "url1"),
            Item("2", "テストアイテム2", "説明2", "url2")
        )
 
        composeTestRule.setContent {
            // Success 状態のモックを設定
        }
 
        composeTestRule.onNodeWithText("テストアイテム1").assertIsDisplayed()
        composeTestRule.onNodeWithText("テストアイテム2").assertIsDisplayed()
    }
 
    @Test
    fun お気に入りボタンをタップするとアイコンが変化する() {
        val testItem = Item("1", "テスト", "説明", "url1", isFavorite = false)
 
        composeTestRule.setContent {
            ItemCard(
                item = testItem,
                onItemClick = {},
                onFavoriteClick = {}
            )
        }
 
        composeTestRule
            .onNodeWithContentDescription("お気に入り")
            .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. リリースキーストアの作成（初回のみ）
keytool -genkey -v -keystore release-keystore.jks \
  -keyalg RSA -keysize 2048 -validity 10000 \
  -alias myapp
 
# 2. AAB (Android App Bundle) のビルド
./gradlew bundleRelease
 
# 3. APK のビルド（直接配布用）
./gradlew assembleRelease

以下のクラッシュログを分析して、原因と修正方法を教えてください：
 
java.lang.IllegalStateException: LifecycleOwner is attempting to register
while current state is RESUMED. LifecycleOwners must call register before
they are STARTED.

以下の Compose コンポーネントを最適化してください。
不要な再コンポジションを避け、remember や derivedStateOf を適切に使ってください。
 
[コードを貼り付け]

// Compose コンパイラレポートを有効化
// build.gradle.kts (app)
composeCompiler {
    reportsDestination = layout.buildDirectory.dir("compose_reports")
    metricsDestination = layout.buildDirectory.dir("compose_metrics")
}

// 共通の UI State 型を先に確定させ、全画面の生成プロンプトに添付する
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>
}