Building AI-Powered Android Apps with Gemini API and Kotlin

import com.google.firebase.ai.FirebaseAI
import com.google.firebase.ai.GenerativeModel
import com.google.firebase.ai.type.GenerativeBackend
 
// Initialize the GenerativeModel
val model: GenerativeModel = FirebaseAI
    .getInstance()
    .generativeModel(
        modelName = "gemini-3-flash",        // Fast, cost-effective model
        backend = GenerativeBackend.googleAI() // Google AI backend
    )
 
// Generate text (call within a coroutine)
suspend fun generateResponse(prompt: String): String {
    val response = model.generateContent(prompt)
    return response.text ?: "Failed to get a response"
}
 
// Usage example:
// viewModelScope.launch {
//     val result = generateResponse("Give me 3 useful Kotlin extension functions")
//     println(result)
//     // Expected output:
//     // 1. String.isEmailValid() - Email validation
//     // 2. View.visible() - Toggle view visibility
//     // 3. Context.toast(message) - Quick Toast display
// }

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) // Emit partial text as it arrives
        }
    }
}
 
// ViewModel usage
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
            }
        }
    }
}
 
// Expected behavior:
// "Kotlin" → "Kotlin is" → "Kotlin is a modern" → ...
// UI updates incrementally without waiting for the full response

import android.graphics.Bitmap
import com.google.firebase.ai.type.content
 
suspend fun analyzeImage(bitmap: Bitmap, question: String): String {
    // Build a multimodal prompt with text and image
    val inputContent = content {
        image(bitmap)   // Pass the Bitmap directly
        text(question)
    }
 
    val response = model.generateContent(inputContent)
    return response.text ?: "Could not analyze the image"
}
 
// Example: Analyzing a photo of food
// val result = analyzeImage(
//     bitmap = cameraBitmap,
//     question = "What dish is this and roughly how many calories does it have?"
// )
// Expected output:
// "This appears to be Carbonara. A typical serving contains approximately
//  650-800 calories. Key ingredients include pasta, egg yolk, pancetta,
//  and Parmigiano-Reggiano cheese."

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. Declare the function (tell Gemini what's available)
val getWeatherFunc = FunctionDeclaration(
    name = "getWeather",
    description = "Get current weather information for a specified city",
    parameters = mapOf(
        "city" to Schema.string("City name to get weather for (e.g., Tokyo, New York)")
    )
)
 
// 2. Create model with tools
val modelWithTools = FirebaseAI
    .getInstance()
    .generativeModel(
        modelName = "gemini-3-flash",
        backend = GenerativeBackend.googleAI(),
        tools = listOf(Tool(listOf(getWeatherFunc)))
    )
 
// 3. Handle Function Calling in the conversation
suspend fun chatWithFunctions(userMessage: String): String {
    val chat = modelWithTools.startChat()
    val response = chat.sendMessage(userMessage)
 
    // Check if Gemini requested a function call
    val functionCall = response.functionCalls.firstOrNull()
    if (functionCall != null) {
        // Execute the actual logic on the app side
        val city = functionCall.args["city"] as? String ?: "Tokyo"
        val weatherData = fetchWeatherFromApi(city) // Your own API call
 
        // Send the result back to 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 ?: ""
}
 
// Expected output (when user asks "What's the weather in Tokyo?"):
// "The current weather in Tokyo is sunny with a temperature of 22°C.
//  It's a great day to be outside, though clouds may move in by evening,
//  so you might want to carry a small umbrella."

// 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) {
        // Add user message
        _messages.value += Message(text = userText, isUser = true)
        _isLoading.value = true
 
        viewModelScope.launch {
            try {
                // Receive streaming response
                var aiResponse = ""
                _messages.value += Message(
                    text = "", isUser = false, isStreaming = true
                )
 
                chat.sendMessageStream(userText).collect { chunk ->
                    chunk.text?.let { partial ->
                        aiResponse += partial
                        // Update the last message
                        _messages.value = _messages.value.dropLast(1) +
                            Message(
                                text = aiResponse,
                                isUser = false,
                                isStreaming = true
                            )
                    }
                }
 
                // Mark streaming as complete
                _messages.value = _messages.value.dropLast(1) +
                    Message(text = aiResponse, isUser = false)
            } catch (e: Exception) {
                _messages.value += Message(
                    text = "An error occurred: ${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) {
            // Retry on 429 (Rate Limit) or 503 (Service Unavailable)
            if (e.message?.contains("429") == true ||
                e.message?.contains("503") == true) {
                delay(currentDelay)
                currentDelay *= 2 // Exponential backoff
            } else {
                throw e // Rethrow other errors immediately
            }
        }
    }
    return block() // Final attempt
}
 
// Usage:
// val result = retryWithBackoff {
//     model.generateContent("Your prompt here")
// }

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" // low latency, low cost
        TaskTier.HEAVY -> "gemini-3-pro"   // accuracy first
    }
    return FirebaseAI.getInstance().generativeModel(
        modelName = name,
        backend = GenerativeBackend.googleAI()
    )
}
 
// Route light chatter to flash, careful image reading to pro:
// val quick = modelFor(TaskTier.LIGHT)
// val vision = modelFor(TaskTier.HEAVY)

suspend fun generateWithFallback(prompt: String): String {
    return try {
        // Primary: cloud Gemini
        model.generateContent(prompt).text ?: onDeviceFallback(prompt)
    } catch (e: Exception) {
        // Fall back on network loss or rate limiting
        onDeviceFallback(prompt)
    }
}
 
// onDeviceFallback returns a minimal response via on-device Gemma, etc.
// (a path that prioritizes "never fail silently" over peak accuracy)

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
 
    // Accumulate metrics (store in Room, aggregate weekly in practice)
    android.util.Log.d(
        "GeminiUsage",
        "feature=$feature input=${usage?.promptTokenCount} " +
        "output=${usage?.candidatesTokenCount} elapsedMs=$elapsed"
    )
    return response.text ?: ""
}