Gemini API Integration in Android Using Kotlin

plugins {
    // ...existing Android/Kotlin plugins
    id("com.google.gms.google-services") version "<latest>" apply false
}

plugins {
    // ...
    id("com.google.gms.google-services")
}

dependencies {
    implementation(platform("com.google.firebase:firebase-bom:<latest>"))
    implementation("com.google.firebase:firebase-ai")

    // App Check: Play Integrity for release builds, debug provider for local development
    implementation("com.google.firebase:firebase-appcheck-playintegrity")
    debugImplementation("com.google.firebase:firebase-appcheck-debug")
}

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        Firebase.initialize(this)
        Firebase.appCheck.installAppCheckProviderFactory(
            if (BuildConfig.DEBUG) DebugAppCheckProviderFactory.getInstance()
            else PlayIntegrityAppCheckProviderFactory.getInstance()
        )
    }
}

import com.google.firebase.Firebase
import com.google.firebase.ai.ai
import com.google.firebase.ai.type.GenerativeBackend
import com.google.firebase.ai.type.content
import com.google.firebase.ai.type.generationConfig
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.mapNotNull

class GeminiTextRepository(modelName: String = "gemini-3.8-flash") {

    private val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
        modelName = modelName,
        // Keep answers focused and bounded: lower temperature, capped output length.
        generationConfig = generationConfig {
            temperature = 0.4f
            maxOutputTokens = 800
        },
        // System instructions shape every response; users can't see or change them.
        systemInstruction = content {
            text(
                "You are a concise assistant inside a study app for Android developers. " +
                "Answer in plain English, use short paragraphs, and say when you are unsure."
            )
        },
    )

    /** Single response: simplest, but the user waits for the whole answer. */
    suspend fun explain(topic: String): String =
        model.generateContent("Explain $topic in under 150 words.").text.orEmpty()

    /** Streaming response: text appears progressively, which feels much faster. */
    fun explainStream(topic: String): Flow<String> =
        model.generateContentStream("Explain $topic in under 150 words.")
            .mapNotNull { chunk -> chunk.text }
}

sealed interface ExplainUiState {
    data object Idle : ExplainUiState
    data object Waiting : ExplainUiState                          // request sent, no text yet
    data class Streaming(val text: String) : ExplainUiState
    data class Done(val text: String) : ExplainUiState
    data class Error(val message: String, val partial: String = "") : ExplainUiState
}

class ExplainViewModel(private val repository: GeminiTextRepository) : ViewModel() {

    private val _uiState = MutableStateFlow<ExplainUiState>(ExplainUiState.Idle)
    val uiState: StateFlow<ExplainUiState> = _uiState.asStateFlow()

    private var job: Job? = null

    fun explain(topic: String) {
        if (topic.isBlank()) return
        job?.cancel()                                            // one request at a time
        job = viewModelScope.launch {
            _uiState.value = ExplainUiState.Waiting
            val buffer = StringBuilder()
            try {
                repository.explainStream(topic.take(500)).collect { chunk ->   // cap user input length
                    buffer.append(chunk)
                    _uiState.value = ExplainUiState.Streaming(buffer.toString())
                }
                _uiState.value = ExplainUiState.Done(buffer.toString())
            } catch (e: CancellationException) {
                _uiState.value = ExplainUiState.Done(buffer.toString())   // user pressed Stop
                throw e
            } catch (e: Exception) {
                _uiState.value = ExplainUiState.Error(e.toUserMessage(), buffer.toString())
            }
        }
    }

    fun stop() { job?.cancel() }
}

@Composable
fun ExplainScreen(viewModel: ExplainViewModel) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()
    var topic by rememberSaveable { mutableStateOf("") }
    val busy = state is ExplainUiState.Waiting || state is ExplainUiState.Streaming

    Column(Modifier.fillMaxSize().padding(16.dp)) {
        OutlinedTextField(
            value = topic,
            onValueChange = { topic = it },
            label = { Text("What should I explain?") },
            enabled = !busy,
            modifier = Modifier.fillMaxWidth(),
        )
        Row(Modifier.padding(vertical = 8.dp), horizontalArrangement = Arrangement.spacedBy(8.dp)) {
            Button(onClick = { viewModel.explain(topic) }, enabled = !busy && topic.isNotBlank()) { Text("Explain") }
            if (busy) OutlinedButton(onClick = viewModel::stop) { Text("Stop") }
        }

        when (val s = state) {
            ExplainUiState.Idle -> Text("Ask about any Android topic.", style = MaterialTheme.typography.bodyMedium)
            ExplainUiState.Waiting -> LinearProgressIndicator(Modifier.fillMaxWidth())
            is ExplainUiState.Streaming -> AiText(s.text)
            is ExplainUiState.Done -> AiText(s.text)
            is ExplainUiState.Error -> {
                if (s.partial.isNotEmpty()) AiText(s.partial)
                Text(s.message, color = MaterialTheme.colorScheme.error)
                TextButton(onClick = { viewModel.explain(topic) }) { Text("Try again") }
            }
        }
    }
}

@Composable
private fun AiText(text: String) {
    Column(Modifier.verticalScroll(rememberScrollState())) {
        Text("AI-generated · may contain mistakes", style = MaterialTheme.typography.labelSmall)
        Text(text, style = MaterialTheme.typography.bodyLarge, modifier = Modifier.padding(top = 4.dp))
    }
}

suspend fun describeForAltText(photo: Bitmap): String {
    val scaled = photo.scaleToMaxSide(1024)          // your helper: keep aspect ratio, max 1024 px
    val prompt = content {
        image(scaled)
        text("Write one sentence of alt text for this image for a screen-reader user. No preamble.")
    }
    return model.generateContent(prompt).text.orEmpty()
}

fun Bitmap.scaleToMaxSide(max: Int): Bitmap {
    val ratio = max.toFloat() / maxOf(width, height)
    if (ratio >= 1f) return this
    return Bitmap.createScaledBitmap(this, (width * ratio).toInt(), (height * ratio).toInt(), true)
}

fun Throwable.toUserMessage(): String = when (this) {
    is java.io.IOException -> "You appear to be offline. Check your connection and try again."
    is com.google.firebase.ai.type.QuotaExceededException -> "The assistant is busy right now. Please try again in a minute."
    is com.google.firebase.ai.type.PromptBlockedException -> "That request can't be answered. Try rephrasing it."
    is com.google.firebase.ai.type.FirebaseAIException -> "The assistant couldn't respond. Please try again."
    else -> "Something went wrong. Please try again."
}