Claude Code で Android / Kotlin アプリを Google Play 公開まで持っていく実装ノート

// domain/state/ProductListState.kt
sealed class ProductListState {
    data object Loading : ProductListState()
    data class Success(
        val products: List<Product>,
        val isRefreshing: Boolean = false
    ) : ProductListState()
    data class Error(val message: String, val retryable: Boolean) : ProductListState()
}

// feature/products/ProductListViewModel.kt
@HiltViewModel
class ProductListViewModel @Inject constructor(
    private val getProductsUseCase: GetProductsUseCase
) : ViewModel() {
 
    private val _uiState = MutableStateFlow<ProductListState>(ProductListState.Loading)
    val uiState: StateFlow<ProductListState> = _uiState.asStateFlow()
 
    init {
        loadProducts()
    }
 
    fun loadProducts(forceRefresh: Boolean = false) {
        viewModelScope.launch {
            if (!forceRefresh) _uiState.value = ProductListState.Loading
            else {
                // Pull-to-Refresh の場合は Success 状態を維持しつつ isRefreshing を true に
                (_uiState.value as? ProductListState.Success)?.let {
                    _uiState.value = it.copy(isRefreshing = true)
                }
            }
            getProductsUseCase()
                .onSuccess { products ->
                    _uiState.value = ProductListState.Success(products)
                }
                .onFailure { error ->
                    _uiState.value = ProductListState.Error(
                        message = error.localizedMessage ?: "不明なエラー",
                        retryable = error is NetworkException
                    )
                }
        }
    }
}

// feature/products/ProductListScreen.kt
@Composable
fun ProductListScreen(
    viewModel: ProductListViewModel = hiltViewModel(),
    onProductClick: (Product) -> Unit
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
 
    when (val state = uiState) {
        is ProductListState.Loading -> LoadingContent()
        is ProductListState.Success -> {
            ProductListContent(
                products = state.products,
                isRefreshing = state.isRefreshing,
                onRefresh = { viewModel.loadProducts(forceRefresh = true) },
                onProductClick = onProductClick
            )
        }
        is ProductListState.Error -> ErrorContent(
            message = state.message,
            onRetry = if (state.retryable) {
                { viewModel.loadProducts() }
            } else null
        )
    }
}
 
@Composable
private fun ProductListContent(
    products: List<Product>,
    isRefreshing: Boolean,
    onRefresh: () -> Unit,
    onProductClick: (Product) -> Unit
) {
    val pullRefreshState = rememberPullRefreshState(
        refreshing = isRefreshing,
        onRefresh = onRefresh
    )
 
    Box(modifier = Modifier.pullRefresh(pullRefreshState)) {
        LazyColumn(
            contentPadding = PaddingValues(16.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp)
        ) {
            items(products, key = { it.id }) { product ->
                ProductCard(
                    product = product,
                    onClick = { onProductClick(product) },
                    modifier = Modifier.animateItem() // Compose 1.7+ API
                )
            }
        }
        PullRefreshIndicator(
            refreshing = isRefreshing,
            state = pullRefreshState,
            modifier = Modifier.align(Alignment.TopCenter)
        )
    }
}

// app/di/NetworkModule.kt
@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
 
    @Provides
    @Singleton
    fun provideOkHttpClient(
        authInterceptor: AuthInterceptor,
        loggingInterceptor: HttpLoggingInterceptor
    ): OkHttpClient = OkHttpClient.Builder()
        .addInterceptor(authInterceptor)
        .addInterceptor(loggingInterceptor)
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .build()
 
    @Provides
    @Singleton
    fun provideRetrofit(okHttpClient: OkHttpClient): Retrofit =
        Retrofit.Builder()
            .baseUrl(BuildConfig.API_BASE_URL)
            .client(okHttpClient)
            .addConverterFactory(
                Json { ignoreUnknownKeys = true }.asConverterFactory(
                    "application/json".toMediaType()
                )
            )
            .build()
 
    @Provides
    @Singleton
    fun provideProductApi(retrofit: Retrofit): ProductApi =
        retrofit.create(ProductApi::class.java)
}

// app/di/DatabaseModule.kt
@Module
@InstallIn(SingletonComponent::class)
object DatabaseModule {
 
    @Provides
    @Singleton
    fun provideDatabase(@ApplicationContext context: Context): AppDatabase =
        Room.databaseBuilder(context, AppDatabase::class.java, "app_database")
            .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
            .build()
 
    @Provides
    fun provideProductDao(database: AppDatabase): ProductDao =
        database.productDao()
}

// data/repository/ProductRepositoryImpl.kt
class ProductRepositoryImpl @Inject constructor(
    private val productApi: ProductApi,
    private val productDao: ProductDao,
    private val networkMonitor: NetworkMonitor
) : ProductRepository {
 
    override fun getProducts(): Flow<Result<List<Product>>> = flow {
        // キャッシュを先にエミット（楽観的 UI 更新）
        val cachedProducts = productDao.getAllProducts().first()
        if (cachedProducts.isNotEmpty()) {
            emit(Result.success(cachedProducts.map { it.toDomain() }))
        }
 
        // ネットワーク接続時のみ API 取得
        if (networkMonitor.isConnected) {
            runCatching { productApi.getProducts() }
                .onSuccess { response ->
                    productDao.upsertProducts(response.map { it.toEntity() })
                    emit(Result.success(response.map { it.toDomain() }))
                }
                .onFailure { error ->
                    if (cachedProducts.isEmpty()) {
                        emit(Result.failure(error))
                    }
                    // キャッシュがある場合はエラーをサイレントに処理
                }
        }
    }.catch { emit(Result.failure(it)) }
}

// feature/products/ProductListViewModelTest.kt
@ExtendWith(CoroutinesTestExtension::class)
class ProductListViewModelTest {
 
    @MockK private lateinit var getProductsUseCase: GetProductsUseCase
    private lateinit var viewModel: ProductListViewModel
 
    @BeforeEach
    fun setUp() {
        MockKAnnotations.init(this)
        viewModel = ProductListViewModel(getProductsUseCase)
    }
 
    @Test
    fun `初期状態はローディング`() = runTest {
        // ローディング状態がすぐにエミットされる前にテスト
        coEvery { getProductsUseCase() } coAnswers {
            delay(1000) // API 遅延をシミュレート
            Result.success(emptyList())
        }
 
        val states = mutableListOf<ProductListState>()
        val job = launch { viewModel.uiState.collect { states.add(it) } }
 
        assertTrue(states.first() is ProductListState.Loading)
        job.cancel()
    }
 
    @Test
    fun `成功時は商品リストが表示される`() = runTest {
        val products = listOf(
            Product(id = "1", name = "商品A", price = 1000),
            Product(id = "2", name = "商品B", price = 2000)
        )
        coEvery { getProductsUseCase() } returns Result.success(products)
 
        val finalState = viewModel.uiState
            .filter { it is ProductListState.Success }
            .first()
 
        assertThat(finalState).isInstanceOf(ProductListState.Success::class.java)
        assertThat((finalState as ProductListState.Success).products).isEqualTo(products)
    }
}

// feature/products/ProductListScreenTest.kt
@RunWith(AndroidJUnit4::class)
class ProductListScreenTest {
 
    @get:Rule
    val composeTestRule = createComposeRule()
 
    @Test
    fun 商品一覧が正常表示される() {
        val products = createSampleProducts(count = 5)
        composeTestRule.setContent {
            MaterialTheme {
                ProductListContent(
                    products = products,
                    isRefreshing = false,
                    onRefresh = {},
                    onProductClick = {}
                )
            }
        }
 
        composeTestRule
            .onNodeWithText("商品A")
            .assertIsDisplayed()
        composeTestRule
            .onAllNodesWithTag("product_card")
            .assertCountEquals(5)
    }
}

# .github/workflows/android_ci.yml
name: Android CI
 
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
 
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
 
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
 
      - name: Cache Gradle packages
        uses: actions/cache@v4
        with:
          path: |
            ~/.gradle/caches
            ~/.gradle/wrapper
          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
 
      - name: Run unit tests
        run: ./gradlew testDebugUnitTest --stacktrace
 
      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: test-results
          path: '**/build/reports/tests/'
 
  build_release:
    runs-on: ubuntu-latest
    needs: test
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
 
      - name: Set up JDK 17
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'
 
      - name: Build release APK
        env:
          KEYSTORE_FILE: ${{ secrets.KEYSTORE_FILE }}
          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
        run: |
          echo "$KEYSTORE_FILE" | base64 -d > app/keystore.jks
          ./gradlew bundleRelease \
            -Pandroid.injected.signing.store.file=keystore.jks \
            -Pandroid.injected.signing.store.password="$KEYSTORE_PASSWORD" \
            -Pandroid.injected.signing.key.alias="$KEY_ALIAS" \
            -Pandroid.injected.signing.key.password="$KEY_PASSWORD"
 
      - name: Upload AAB to Google Play
        uses: r0adkll/upload-google-play@v1
        with:
          serviceAccountJsonPlainText: ${{ secrets.SERVICE_ACCOUNT_JSON }}
          packageName: com.example.myapp
          releaseFiles: app/build/outputs/bundle/release/*.aab
          track: internal
          status: completed

// .claude/hooks/post-commit.json
{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Write|Edit",
      "hooks": [{
        "type": "command",
        "command": "if [[ \"$CLAUDE_TOOL_OUTPUT\" == *'.kt'* ]]; then ./gradlew testDebugUnitTest 2>&1 | tail -20; fi"
      }]
    }]
  }
}

// app/build.gradle.kts
android {
    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
            signingConfig = signingConfigs.getByName("release")
        }
    }
 
    flavorDimensions += "environment"
    productFlavors {
        create("staging") {
            dimension = "environment"
            applicationIdSuffix = ".staging"
            versionNameSuffix = "-staging"
            buildConfigField("String", "API_BASE_URL", "\"https://staging-api.example.com/\"")
        }
        create("production") {
            dimension = "environment"
            buildConfigField("String", "API_BASE_URL", "\"https://api.example.com/\"")
        }
    }
}

// コンポーズ回数を視覚化するデバッグモード
@Composable
fun DebugRecompositionHighlight(
    enabled: Boolean = BuildConfig.DEBUG,
    content: @Composable () -> Unit
) {
    if (enabled) {
        val recompositionCount = remember { mutableIntStateOf(0) }
        val color by animateColorAsState(
            targetValue = if (recompositionCount.intValue % 2 == 0) {
                Color.Transparent
            } else {
                Color.Red.copy(alpha = 0.1f)
            },
            label = "recompose_highlight"
        )
        LaunchedEffect(recompositionCount.intValue) {
            // 再コンポーズ時に色が変化する視覚的インジケータ
        }
        recompositionCount.intValue++
        Box(modifier = Modifier.background(color)) { content() }
    } else {
        content()
    }
}

// app/src/main/kotlin/com/example/myapp/MyApplication.kt
@HiltAndroidApp
class MyApplication : Application() {
 
    override fun onCreate() {
        super.onCreate()
 
        // Crashlytics 初期化
        if (!BuildConfig.DEBUG) {
            FirebaseCrashlytics.getInstance().apply {
                setCrashlyticsCollectionEnabled(true)
            }
        }
 
        // Performance Monitoring のカスタムトレース
        setupPerformanceMonitoring()
    }
 
    private fun setupPerformanceMonitoring() {
        FirebasePerformance.getInstance().isPerformanceCollectionEnabled = !BuildConfig.DEBUG
    }
}

// feature/products/ProductListViewModel.kt への追加
fun loadProducts() {
    val trace = Firebase.performance.newTrace("load_products")
    trace.start()
 
    viewModelScope.launch {
        try {
            // ... 既存のロード処理 ...
            trace.putAttribute("product_count", products.size.toString())
            trace.stop()
        } catch (e: Exception) {
            trace.putAttribute("error", e.javaClass.simpleName)
            trace.stop()
            FirebaseCrashlytics.getInstance().recordException(e)
        }
    }
}

// ❌ Bad: パラメータが多くて Compose コンパイラが Stable 判定を諦める
data class ProductUiState(
    val id: String,
    val title: String,
    val tags: List<String>,
    val downloads: Int,
    val previewUrls: List<String>,
    val isFavorite: Boolean,
)
 
// ✅ Good: @Immutable を明示し、List は ImmutableList に置換
@Immutable
data class ProductUiState(
    val id: String,
    val title: String,
    val tags: ImmutableList<String>,        // kotlinx.collections.immutable
    val downloads: Int,
    val previewUrls: ImmutableList<String>,
    val isFavorite: Boolean,
)

// 1. グローバルハンドラ（最後の砦）
class App : Application() {
    override fun onCreate() {
        super.onCreate()
        Thread.setDefaultUncaughtExceptionHandler { _, throwable ->
            FirebaseCrashlytics.getInstance().recordException(throwable)
        }
    }
}
 
// 2. ViewModel 側で握る
private val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
    FirebaseCrashlytics.getInstance().recordException(throwable)
    _uiState.update { it.copy(error = throwable.toUiError()) }
}
 
fun loadProducts() {
    viewModelScope.launch(exceptionHandler) {
        runCatching { repository.getProducts() }
            .onSuccess { products -> _uiState.update { it.copy(products = products) } }
            .onFailure { e -> FirebaseCrashlytics.getInstance().recordException(e) }
    }
}
 
// 3. RxJava 互換層が残っている場合の Plugin（旧モジュール混在で必須）
RxJavaPlugins.setErrorHandler { e ->
    if (e is UndeliverableException) {
        FirebaseCrashlytics.getInstance().recordException(e.cause ?: e)
        return@setErrorHandler
    }
    Thread.currentThread().uncaughtExceptionHandler?.uncaughtException(Thread.currentThread(), e)
}

# ✅ Good: データクラスのフィールドだけ守る
-keepclassmembers class com.example.myapp.data.dto.** {
    <fields>;
}
 
# ❌ Bad: メソッド含めて全部 keep（APK サイズが膨らむ）
-keep class com.example.myapp.data.dto.** { *; }