Gemini API × Android Jetpack Compose 完全統合ガイド — Kotlin ネイティブ AI アプリの本番設計パターン

// data/repository/GeminiRepository.kt
interface GeminiRepository {
    fun sendMessage(messages: List<ChatMessage>, imageUri: Uri? = null): Flow<GenerationResult>
    suspend fun getChatHistory(sessionId: String): List<ChatMessage>
    suspend fun saveChatMessage(message: ChatMessage)
}
 
data class GenerationResult(
    val text: String = "",
    val isComplete: Boolean = false,
    val error: String? = null
)

// data/datasource/GeminiDataSource.kt
class GeminiDataSource @Inject constructor() {
 
    // マルチモーダル対応：テキスト + 画像
    private fun buildGenerativeModel(modelName: String = "gemini-2.0-flash"): GenerativeModel {
        return GenerativeModel(
            modelName = modelName,
            apiKey = BuildConfig.GEMINI_API_KEY,
            generationConfig = generationConfig {
                temperature = 0.7f
                maxOutputTokens = 8192
                topP = 0.95f
            },
            safetySettings = listOf(
                SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE),
                SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE)
            )
        )
    }
 
    fun streamChatResponse(
        chatHistory: List<ChatMessage>,
        newMessage: String,
        imageBitmap: Bitmap? = null
    ): Flow<GenerationResult> = flow {
        val model = buildGenerativeModel()
        val chat = model.startChat(
            history = chatHistory.dropLast(1).map { it.toContent() }
        )
 
        // 最後のメッセージ（マルチモーダル対応）
        val content = content("user") {
            if (imageBitmap != null) {
                image(imageBitmap)
            }
            text(newMessage)
        }
 
        try {
            chat.sendMessageStream(content).collect { chunk ->
                chunk.text?.let { text ->
                    emit(GenerationResult(text = text, isComplete = false))
                }
            }
            emit(GenerationResult(text = "", isComplete = true))
        } catch (e: GoogleGenerativeAIException) {
            emit(GenerationResult(error = "API エラー: ${e.message}", isComplete = true))
        }
    }.flowOn(Dispatchers.IO)
}

// ui/chat/ChatViewModel.kt
@HiltViewModel
class ChatViewModel @Inject constructor(
    private val geminiRepository: GeminiRepository
) : ViewModel() {
 
    private val _uiState = MutableStateFlow(ChatUiState())
    val uiState: StateFlow<ChatUiState> = _uiState.asStateFlow()
 
    // 選択された画像URI
    private val _selectedImageUri = MutableStateFlow<Uri?>(null)
    val selectedImageUri: StateFlow<Uri?> = _selectedImageUri.asStateFlow()
 
    fun sendMessage(userInput: String, imageBitmap: Bitmap? = null) {
        if (userInput.isBlank() && imageBitmap == null) return
 
        val userMessage = ChatMessage(
            text = userInput,
            role = Role.USER,
            imageUri = _selectedImageUri.value,
            timestamp = System.currentTimeMillis()
        )
 
        // ユーザーメッセージをUIに即時反映
        _uiState.update { current ->
            current.copy(
                messages = current.messages + userMessage,
                isLoading = true,
                pendingBotText = ""
            )
        }
        _selectedImageUri.value = null
 
        viewModelScope.launch {
            val currentMessages = _uiState.value.messages
 
            geminiRepository.sendMessage(currentMessages, imageBitmap = imageBitmap)
                .collect { result ->
                    when {
                        result.error != null -> {
                            _uiState.update { it.copy(
                                isLoading = false,
                                errorMessage = result.error
                            )}
                        }
                        result.isComplete -> {
                            // ストリーミング完了 → pending テキストを確定メッセージへ
                            val finalText = _uiState.value.pendingBotText
                            val botMessage = ChatMessage(
                                text = finalText,
                                role = Role.MODEL,
                                timestamp = System.currentTimeMillis()
                            )
                            _uiState.update { current ->
                                current.copy(
                                    messages = current.messages + botMessage,
                                    isLoading = false,
                                    pendingBotText = ""
                                )
                            }
                            // DBに保存
                            geminiRepository.saveChatMessage(botMessage)
                        }
                        else -> {
                            // ストリーミング中：リアルタイムに文字を追加
                            _uiState.update { current ->
                                current.copy(pendingBotText = current.pendingBotText + result.text)
                            }
                        }
                    }
                }
        }
    }
}
 
data class ChatUiState(
    val messages: List<ChatMessage> = emptyList(),
    val isLoading: Boolean = false,
    val pendingBotText: String = "",
    val errorMessage: String? = null
)

// ui/chat/ChatScreen.kt
@Composable
fun ChatScreen(
    viewModel: ChatViewModel = hiltViewModel()
) {
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
    val selectedImageUri by viewModel.selectedImageUri.collectAsStateWithLifecycle()
    val listState = rememberLazyListState()
    var inputText by remember { mutableStateOf("") }
 
    // 新しいメッセージが来たら自動スクロール
    LaunchedEffect(uiState.messages.size, uiState.pendingBotText) {
        if (uiState.messages.isNotEmpty()) {
            listState.animateScrollToItem(
                index = uiState.messages.size + if (uiState.pendingBotText.isNotEmpty()) 1 else 0
            )
        }
    }
 
    Scaffold(
        bottomBar = {
            ChatInputBar(
                inputText = inputText,
                selectedImageUri = selectedImageUri,
                isLoading = uiState.isLoading,
                onInputChange = { inputText = it },
                onSend = {
                    viewModel.sendMessage(inputText)
                    inputText = ""
                },
                onImageSelected = { uri -> viewModel.setSelectedImage(uri) }
            )
        }
    ) { paddingValues ->
        LazyColumn(
            state = listState,
            modifier = Modifier
                .fillMaxSize()
                .padding(paddingValues),
            contentPadding = PaddingValues(16.dp),
            verticalArrangement = Arrangement.spacedBy(8.dp)
        ) {
            items(uiState.messages) { message ->
                ChatBubble(message = message)
            }
 
            // ストリーミング中の「入力中」バブル
            if (uiState.pendingBotText.isNotEmpty()) {
                item {
                    StreamingBubble(text = uiState.pendingBotText)
                }
            }
        }
    }
}
 
@Composable
fun StreamingBubble(text: String) {
    Box(
        modifier = Modifier
            .fillMaxWidth(0.85f)
            .clip(RoundedCornerShape(12.dp))
            .background(MaterialTheme.colorScheme.secondaryContainer)
            .padding(12.dp)
    ) {
        // ストリーミング中はカーソル（|）を末尾に点滅表示
        val cursor by rememberInfiniteTransition(label = "cursor").animateFloat(
            initialValue = 0f,
            targetValue = 1f,
            animationSpec = infiniteRepeatable(
                animation = tween(600),
                repeatMode = RepeatMode.Reverse
            ),
            label = "cursorAlpha"
        )
        Text(
            text = text + if (cursor > 0.5f) "│" else " ",
            style = MaterialTheme.typography.bodyMedium
        )
    }
}

// data/local/ChatEntity.kt
@Entity(tableName = "chat_messages")
data class ChatEntity(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val sessionId: String,
    val text: String,
    val role: String,     // "user" or "model"
    val imageUri: String?,
    val timestamp: Long,
    val tokenCount: Int = 0
)
 
// data/local/ChatDao.kt
@Dao
interface ChatDao {
    @Query("SELECT * FROM chat_messages WHERE sessionId = :sessionId ORDER BY timestamp ASC")
    fun observeSessionMessages(sessionId: String): Flow<List<ChatEntity>>
 
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertMessage(entity: ChatEntity)
 
    @Query("DELETE FROM chat_messages WHERE sessionId = :sessionId")
    suspend fun clearSession(sessionId: String)
 
    // 古いセッションの自動削除（ストレージ管理）
    @Query("DELETE FROM chat_messages WHERE timestamp < :cutoffMs")
    suspend fun deleteOlderThan(cutoffMs: Long)
}

// worker/SummarizeWorker.kt
@HiltWorker
class SummarizeWorker @AssistedInject constructor(
    @Assisted context: Context,
    @Assisted params: WorkerParameters,
    private val geminiRepository: GeminiRepository
) : CoroutineWorker(context, params) {
 
    override suspend fun doWork(): Result {
        val sessionId = inputData.getString(KEY_SESSION_ID) ?: return Result.failure()
 
        return try {
            val messages = geminiRepository.getChatHistory(sessionId)
            val summaryRequest = "以下の会話を3行で要約してください：\n" +
                messages.joinToString("\n") { "${it.role}: ${it.text}" }
 
            var summaryText = ""
            geminiRepository.sendMessage(
                listOf(ChatMessage(text = summaryRequest, role = Role.USER))
            ).collect { result ->
                if (result.isComplete) {
                    summaryText = result.text
                }
            }
 
            val outputData = workDataOf(KEY_SUMMARY to summaryText)
            Result.success(outputData)
        } catch (e: Exception) {
            if (runAttemptCount < 3) Result.retry() else Result.failure()
        }
    }
 
    companion object {
        const val KEY_SESSION_ID = "session_id"
        const val KEY_SUMMARY = "summary"
 
        fun buildRequest(sessionId: String): OneTimeWorkRequest {
            val inputData = workDataOf(KEY_SESSION_ID to sessionId)
            val constraints = Constraints.Builder()
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .build()
 
            return OneTimeWorkRequestBuilder<SummarizeWorker>()
                .setInputData(inputData)
                .setConstraints(constraints)
                .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
                .build()
        }
    }
}

// 開発・プロトタイプ段階での BuildConfig 利用（本番は要検討）
class GeminiDataSource @Inject constructor() {
    private val apiKey: String
        get() = if (BuildConfig.DEBUG) {
            BuildConfig.GEMINI_API_KEY  // 開発時のみ直接使用
        } else {
            ""  // 本番では空文字→プロキシ経由に切り替え
        }
}

// test/ChatViewModelTest.kt
@OptIn(ExperimentalCoroutinesApi::class)
class ChatViewModelTest {
 
    @get:Rule
    val mainDispatcherRule = MainDispatcherRule()
 
    private val fakeRepository = FakeGeminiRepository()
    private lateinit var viewModel: ChatViewModel
 
    @Before
    fun setup() {
        viewModel = ChatViewModel(fakeRepository)
    }
 
    @Test
    fun `sendMessage updates messages and clears loading state`() = runTest {
        // Given
        fakeRepository.streamResponse = flowOf(
            GenerationResult(text = "Hello", isComplete = false),
            GenerationResult(text = " World", isComplete = false),
            GenerationResult(text = "", isComplete = true)
        )
 
        // When
        viewModel.sendMessage("こんにちは")
        advanceUntilIdle()
 
        // Then
        val state = viewModel.uiState.value
        assertEquals(2, state.messages.size)  // user + bot
        assertEquals("Hello World", state.messages.last().text)
        assertFalse(state.isLoading)
    }
}

// androidTest/ChatScreenTest.kt
@HiltAndroidTest
class ChatScreenTest {
 
    @get:Rule(order = 0)
    val hiltRule = HiltAndroidRule(this)
 
    @get:Rule(order = 1)
    val composeTestRule = createAndroidComposeRule<MainActivity>()
 
    @Test
    fun chatInput_sendMessage_displaysInList() {
        composeTestRule.onNodeWithTag("ChatInput")
            .performTextInput("Gemini について教えてください")
        composeTestRule.onNodeWithTag("SendButton")
            .performClick()
 
        // ユーザーメッセージが表示されていることを確認
        composeTestRule.onNodeWithText("Gemini について教えてください")
            .assertIsDisplayed()
    }
}

// GeminiFailure.kt — 失敗を運用可能なカテゴリへ正規化する
enum class GeminiFailureType {
    RATE_LIMIT, SAFETY_BLOCKED, RECITATION, TIMEOUT, AUTH, NETWORK, UNKNOWN
}
 
fun classifyGeminiFailure(t: Throwable): GeminiFailureType = when {
    t is com.google.ai.client.generativeai.type.PromptBlockedException -> GeminiFailureType.SAFETY_BLOCKED
    t is com.google.ai.client.generativeai.type.ServerException &&
        t.message?.contains("429") == true -> GeminiFailureType.RATE_LIMIT
    t.message?.contains("RECITATION") == true -> GeminiFailureType.RECITATION
    t is java.net.SocketTimeoutException -> GeminiFailureType.TIMEOUT
    t is com.google.ai.client.generativeai.type.InvalidAPIKeyException -> GeminiFailureType.AUTH
    t is java.io.IOException -> GeminiFailureType.NETWORK
    else -> GeminiFailureType.UNKNOWN
}

// GeminiDataSource.kt の catch 節から呼ぶ
import com.google.firebase.crashlytics.FirebaseCrashlytics
 
private fun reportFailure(t: Throwable, modelName: String, attempt: Int) {
    val type = classifyGeminiFailure(t)
    FirebaseCrashlytics.getInstance().apply {
        setCustomKey("gemini_failure_type", type.name)
        setCustomKey("gemini_model", modelName)
        setCustomKey("gemini_attempt", attempt)
        // 安全性ブロックやレート超過は「想定内の失敗」なので
        // クラッシュ扱いにせず log にとどめ、ノイズを減らす
        if (type == GeminiFailureType.SAFETY_BLOCKED || type == GeminiFailureType.RATE_LIMIT) {
            log("gemini_${type.name.lowercase()} model=$modelName attempt=$attempt")
        } else {
            recordException(t)
        }
    }
}

class ChatViewModel @Inject constructor(
    private val repository: GeminiRepository,
    private val savedState: SavedStateHandle
) : ViewModel() {
 
    fun sendMessage(prompt: String) {
        viewModelScope.launch {
            val buffer = StringBuilder()
            repository.streamResponse(prompt)
                .onCompletion { cause ->
                    if (cause == null) {
                        repository.persistTurn(prompt, buffer.toString()) // Room へ確定保存
                        savedState[KEY_PARTIAL] = ""                       // 退避をクリア
                    }
                }
                .collect { chunk ->
                    buffer.append(chunk.text)
                    savedState[KEY_PARTIAL] = buffer.toString()            // 1チャンクごとに退避
                    emitToUi(buffer.toString())
                }
        }
    }
 
    init {
        // 復帰時に退避テキストが残っていれば「未完了の応答」として復元する
        val pending = savedState.get<String>(KEY_PARTIAL).orEmpty()
        if (pending.isNotBlank()) {
            emitToUi(pending, incomplete = true)  // 「中断されました・再生成しますか?」UI
        }
    }
 
    companion object { private const val KEY_PARTIAL = "partial_response" }
}