Gemini API × Kotlin で Android アプリに AI を組み込む

import com.google.firebase.ai.FirebaseAI
import com.google.firebase.ai.GenerativeModel
import com.google.firebase.ai.type.GenerativeBackend
 
// GenerativeModel の初期化
val model: GenerativeModel = FirebaseAI
    .getInstance()
    .generativeModel(
        modelName = "gemini-3-flash",       // 高速・低コストモデル
        backend = GenerativeBackend.googleAI() // Google AI バックエンド
    )
 
// テキスト生成（Coroutine 内で呼び出す）
suspend fun generateResponse(prompt: String): String {
    val response = model.generateContent(prompt)
    return response.text ?: "応答を取得できませんでした"
}
 
// 使用例
// viewModelScope.launch {
//     val result = generateResponse("Kotlin の拡張関数を3つ教えてください")
//     println(result)
//     // 期待出力:
//     // 1. String.isEmailValid() - メールアドレスのバリデーション
//     // 2. View.visible() - View の表示切り替え
//     // 3. Context.toast(message) - Toast の簡易表示
// }

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import com.google.firebase.ai.type.GenerateContentResponse
 
fun streamResponse(prompt: String): Flow<String> = flow {
    val stream: Flow<GenerateContentResponse> =
        model.generateContentStream(prompt)
 
    stream.collect { chunk ->
        chunk.text?.let { text ->
            emit(text) // 部分テキストを順次発行
        }
    }
}
 
// ViewModel での使用例
class ChatViewModel : ViewModel() {
    private val _response = MutableStateFlow("")
    val response: StateFlow<String> = _response
 
    fun askGemini(prompt: String) {
        viewModelScope.launch {
            _response.value = ""
            streamResponse(prompt).collect { partial ->
                _response.value += partial
            }
        }
    }
}
 
// 期待される動作:
// "Kotlin" → "Kotlin は" → "Kotlin は JetBrains が" → ...
// チャンクごとに UI が更新され、応答完了を待たずに表示される

import android.graphics.Bitmap
import com.google.firebase.ai.type.content
 
suspend fun analyzeImage(bitmap: Bitmap, question: String): String {
    // テキストと画像を含むマルチモーダルプロンプトを構築
    val inputContent = content {
        image(bitmap)   // Bitmap を直接渡せる
        text(question)
    }
 
    val response = model.generateContent(inputContent)
    return response.text ?: "画像を分析できませんでした"
}
 
// 使用例: カメラで撮影した料理の画像を分析
// val result = analyzeImage(
//     bitmap = cameraBitmap,
//     question = "この料理の名前とおおよそのカロリーを教えてください"
// )
// 期待出力:
// "この画像はカルボナーラです。1人前あたり約650〜800kcalと推定されます。
//  主な材料はパスタ、卵黄、パンチェッタ、パルミジャーノチーズです。"

import com.google.firebase.ai.type.FunctionDeclaration
import com.google.firebase.ai.type.Schema
import com.google.firebase.ai.type.Tool
import com.google.firebase.ai.type.FunctionResponse
import com.google.firebase.ai.type.content
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
 
// 1. 関数の宣言（Gemini に「こういう関数がある」と伝える）
val getWeatherFunc = FunctionDeclaration(
    name = "getWeather",
    description = "指定された都市の現在の天気情報を取得する",
    parameters = mapOf(
        "city" to Schema.string("天気を取得する都市名（例: Tokyo, Osaka）")
    )
)
 
// 2. ツール付きモデルの作成
val modelWithTools = FirebaseAI
    .getInstance()
    .generativeModel(
        modelName = "gemini-3-flash",
        backend = GenerativeBackend.googleAI(),
        tools = listOf(Tool(listOf(getWeatherFunc)))
    )
 
// 3. Function Calling のハンドリング
suspend fun chatWithFunctions(userMessage: String): String {
    val chat = modelWithTools.startChat()
    val response = chat.sendMessage(userMessage)
 
    // Gemini が関数呼び出しを要求した場合
    val functionCall = response.functionCalls.firstOrNull()
    if (functionCall != null) {
        // アプリ側で実際の処理を実行
        val city = functionCall.args["city"] as? String ?: "Tokyo"
        val weatherData = fetchWeatherFromApi(city) // 自前の API 呼び出し
 
        // 結果を Gemini に返す
        val functionResponse = content {
            part(FunctionResponse(
                name = "getWeather",
                response = JsonObject(mapOf(
                    "temperature" to JsonPrimitive(weatherData.temp),
                    "condition" to JsonPrimitive(weatherData.condition)
                ))
            ))
        }
        val finalResponse = chat.sendMessage(functionResponse)
        return finalResponse.text ?: ""
    }
 
    return response.text ?: ""
}
 
// 期待出力（「東京の天気を教えて」と入力した場合）:
// "東京の現在の天気は晴れ、気温は22°Cです。
//  お出かけ日和ですが、夕方から雲が増える予報もあるので折りたたみ傘があると安心です。"

// ChatViewModel.kt
class ChatViewModel : ViewModel() {
    private val model = FirebaseAI
        .getInstance()
        .generativeModel(
            modelName = "gemini-3-flash",
            backend = GenerativeBackend.googleAI()
        )
 
    private val chat = model.startChat()
 
    data class Message(
        val text: String,
        val isUser: Boolean,
        val isStreaming: Boolean = false
    )
 
    private val _messages = MutableStateFlow<List<Message>>(emptyList())
    val messages: StateFlow<List<Message>> = _messages
 
    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading
 
    fun sendMessage(userText: String) {
        // ユーザーメッセージを追加
        _messages.value += Message(text = userText, isUser = true)
        _isLoading.value = true
 
        viewModelScope.launch {
            try {
                // ストリーミング応答の受信
                var aiResponse = ""
                _messages.value += Message(
                    text = "", isUser = false, isStreaming = true
                )
 
                chat.sendMessageStream(userText).collect { chunk ->
                    chunk.text?.let { partial ->
                        aiResponse += partial
                        // 最後のメッセージを更新
                        _messages.value = _messages.value.dropLast(1) +
                            Message(
                                text = aiResponse,
                                isUser = false,
                                isStreaming = true
                            )
                    }
                }
 
                // ストリーミング完了
                _messages.value = _messages.value.dropLast(1) +
                    Message(text = aiResponse, isUser = false)
            } catch (e: Exception) {
                _messages.value += Message(
                    text = "エラーが発生しました: ${e.localizedMessage}",
                    isUser = false
                )
            } finally {
                _isLoading.value = false
            }
        }
    }
}

import kotlinx.coroutines.delay
 
suspend fun <T> retryWithBackoff(
    maxRetries: Int = 3,
    initialDelay: Long = 1000L,
    block: suspend () -> T
): T {
    var currentDelay = initialDelay
    repeat(maxRetries - 1) { attempt ->
        try {
            return block()
        } catch (e: Exception) {
            // 429 (Rate Limit) や 503 (Service Unavailable) のリトライ
            if (e.message?.contains("429") == true ||
                e.message?.contains("503") == true) {
                delay(currentDelay)
                currentDelay *= 2 // 指数バックオフ
            } else {
                throw e // その他のエラーは即座に再スロー
            }
        }
    }
    return block() // 最後の試行
}
 
// 使用例
// val result = retryWithBackoff {
//     model.generateContent("プロンプト")
// }

import com.google.firebase.ai.type.HarmCategory
import com.google.firebase.ai.type.HarmBlockThreshold
import com.google.firebase.ai.type.SafetySetting
 
val safeModel = FirebaseAI
    .getInstance()
    .generativeModel(
        modelName = "gemini-3-flash",
        backend = GenerativeBackend.googleAI(),
        safetySettings = listOf(
            SafetySetting(HarmCategory.HARASSMENT, HarmBlockThreshold.MEDIUM_AND_ABOVE),
            SafetySetting(HarmCategory.HATE_SPEECH, HarmBlockThreshold.MEDIUM_AND_ABOVE),
            SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, HarmBlockThreshold.MEDIUM_AND_ABOVE),
            SafetySetting(HarmCategory.DANGEROUS_CONTENT, HarmBlockThreshold.MEDIUM_AND_ABOVE)
        )
    )

enum class TaskTier { LIGHT, HEAVY }
 
fun modelFor(tier: TaskTier): GenerativeModel {
    val name = when (tier) {
        TaskTier.LIGHT -> "gemini-3-flash" // 低レイテンシ・低コスト
        TaskTier.HEAVY -> "gemini-3-pro"   // 精度優先
    }
    return FirebaseAI.getInstance().generativeModel(
        modelName = name,
        backend = GenerativeBackend.googleAI()
    )
}
 
// 使用例: 軽い相槌は flash、画像の精読は pro に振り分ける
// val quick = modelFor(TaskTier.LIGHT)
// val vision = modelFor(TaskTier.HEAVY)

suspend fun generateWithFallback(prompt: String): String {
    return try {
        // 第一経路: クラウドの Gemini
        model.generateContent(prompt).text ?: onDeviceFallback(prompt)
    } catch (e: Exception) {
        // ネットワーク不通・レート制限時はオンデバイスへ退避
        onDeviceFallback(prompt)
    }
}
 
// onDeviceFallback は端末内の Gemma 等で最低限の応答を返す
// （精度よりも「無言で失敗しない」ことを優先する経路）

suspend fun generateAndLog(feature: String, prompt: String): String {
    val started = System.currentTimeMillis()
    val response = model.generateContent(prompt)
    val usage = response.usageMetadata
    val elapsed = System.currentTimeMillis() - started
 
    // 計測値を蓄積（実際は Room などに保存して週次集計する）
    android.util.Log.d(
        "GeminiUsage",
        "feature=$feature input=${usage?.promptTokenCount} " +
        "output=${usage?.candidatesTokenCount} elapsedMs=$elapsed"
    )
    return response.text ?: ""
}