designmd-forge 1.2.0

package/dist/data/designs/ios-gemini-android.md

@@ -0,0 +1,568 @@
+# Google Gemini (iOS) — Jetpack Compose Implementation Guide
+
+Companion to [DESIGN.md](DESIGN.md) — the framework-neutral spec. This file ports Gemini's visual language to **Android with Jetpack Compose (Material 3)**: a color token object, the brand gradient, a `Typography` set, paste-ready `@Composable`s, `Modifier`s, motion, and haptics.
+
+> Why a Compose guide for an iOS-referenced app? The DESIGN.md tokens are platform-neutral. This file keeps the *visual* identity (Gemini's document-not-feed canvas, the rationed gradient, gradient sparkle + streaming shimmer + focus ring, drawer-only nav) while making everything idiomatic Android — `ModalNavigationDrawer` instead of a UISplitView, `Brush.linearGradient` for the gradient, `sp`/`dp` instead of `pt`.
+
+Assumes Compose BOM `2024.09+`, Kotlin `2.0+`, `minSdk 24`, Material 3.
+
+## 1. Color Tokens
+
+```kotlin
+// ui/theme/GeminiColors.kt
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+
+object GeminiColors {
+    // Light
+    val Canvas  = Color(0xFFFFFFFF)
+    val Surface = Color(0xFFF0F4F9)
+    val Divider = Color(0xFFE3E3E3)
+    val TextPrimary   = Color(0xFF1F1F1F)
+    val TextSecondary = Color(0xFF5F6368)
+    val TextTertiary  = Color(0xFF9AA0A6)
+
+    // Dark
+    val DarkCanvas  = Color(0xFF1E1E1E)
+    val DarkSurface = Color(0xFF282A2C)
+    val DarkDivider = Color(0xFF3C3C3C)
+    val DarkTextPrimary   = Color(0xFFE3E3E3)
+    val DarkTextSecondary = Color(0xFF9AA0A6)
+
+    // Brand
+    val Blue        = Color(0xFF4285F4)
+    val BluePressed = Color(0xFF3367D6)
+    val DarkBlue    = Color(0xFF8AB4F8)
+    val Violet      = Color(0xFF9B72CB)
+    val Coral       = Color(0xFFD96570)
+
+    // Semantic
+    val Success = Color(0xFF1E8E3E)
+    val Warning = Color(0xFFF9AB00)
+    val Error   = Color(0xFFD93025)
+}
+
+// The single brand gesture — sparkle, streaming edge, focus ring, chip accent.
+fun geminiGradient() = Brush.linearGradient(
+    listOf(GeminiColors.Blue, GeminiColors.Violet, GeminiColors.Coral)
+)
+```
+
+Wire it into Material 3 light + dark schemes so ripples, dividers, and default component colors inherit the brand. `primary` is solid Google Blue (the gradient is structural, never a component fill).
+
+```kotlin
+// ui/theme/Theme.kt
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.foundation.isSystemInDarkTheme
+
+private val GeminiLight = lightColorScheme(
+    primary        = GeminiColors.Blue,
+    onPrimary      = Color.White,
+    background     = GeminiColors.Canvas,
+    onBackground   = GeminiColors.TextPrimary,
+    surface        = GeminiColors.Canvas,
+    onSurface      = GeminiColors.TextPrimary,
+    surfaceVariant = GeminiColors.Surface,
+    outline        = GeminiColors.Divider,
+    error          = GeminiColors.Error,
+)
+
+private val GeminiDark = darkColorScheme(
+    primary        = GeminiColors.DarkBlue,
+    onPrimary      = Color(0xFF1E1E1E),
+    background     = GeminiColors.DarkCanvas,
+    onBackground   = GeminiColors.DarkTextPrimary,
+    surface        = GeminiColors.DarkCanvas,
+    onSurface      = GeminiColors.DarkTextPrimary,
+    surfaceVariant = GeminiColors.DarkSurface,
+    outline        = GeminiColors.DarkDivider,
+    error          = GeminiColors.Error,
+)
+
+@Composable
+fun GeminiTheme(
+    dark: Boolean = isSystemInDarkTheme(),
+    content: @Composable () -> Unit,
+) = MaterialTheme(
+    colorScheme = if (dark) GeminiDark else GeminiLight,
+    typography  = GeminiTypography,
+    content     = content,
+)
+```
+
+## 2. Typography
+
+Google Sans is Google's product typeface. The closest free substitute is **Inter** — drop the TTFs in `res/font/` (lowercase, snake_case) and build a `FontFamily`. Use Roboto Mono for code. Fall back to the system grotesque (Roboto) if Inter is unavailable.
+
+```kotlin
+// ui/theme/GeminiType.kt
+import androidx.compose.material3.Typography
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.Font
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
+
+val GoogleSans = FontFamily(
+    Font(R.font.google_sans_regular, FontWeight.Normal), // 400
+    Font(R.font.google_sans_medium,  FontWeight.Medium),  // 500
+    Font(R.font.google_sans_bold,    FontWeight.Bold),    // 700
+)
+val RobotoMono = FontFamily(Font(R.font.roboto_mono_regular, FontWeight.Normal))
+
+// Named ramp — mirrors DESIGN.md §3 exactly (pt → sp 1:1)
+object GeminiText {
+    val Greeting    = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 28.sp, lineHeight = 34.sp, letterSpacing = (-0.2).sp)
+    val Title       = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 22.sp, lineHeight = 28.sp, letterSpacing = (-0.1).sp)
+    val Section     = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 18.sp, lineHeight = 23.sp)
+    val AnswerH2    = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 20.sp, lineHeight = 26.sp)
+    val AnswerH3    = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 17.sp, lineHeight = 23.sp)
+    val AnswerBody  = TextStyle(GoogleSans, fontWeight = FontWeight.Normal, fontSize = 16.sp, lineHeight = 25.sp) // ≈ 1.55
+    val UserTurn    = TextStyle(GoogleSans, fontWeight = FontWeight.Normal, fontSize = 16.sp, lineHeight = 23.sp)
+    val PromptInput = TextStyle(GoogleSans, fontWeight = FontWeight.Normal, fontSize = 16.sp, lineHeight = 22.sp)
+    val Chip        = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 14.sp, lineHeight = 18.sp)
+    val Meta        = TextStyle(GoogleSans, fontWeight = FontWeight.Normal, fontSize = 13.sp, lineHeight = 17.sp)
+    val Code        = TextStyle(RobotoMono, fontWeight = FontWeight.Normal, fontSize = 14.sp, lineHeight = 21.sp)
+    val LabelUpper  = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 11.sp, lineHeight = 13.sp, letterSpacing = 0.6.sp)
+    val Button      = TextStyle(GoogleSans, fontWeight = FontWeight.Medium, fontSize = 15.sp, lineHeight = 19.sp)
+}
+
+// Map onto Material 3 slots so stock components inherit the brand
+val GeminiTypography = Typography(
+    headlineLarge = GeminiText.Greeting,
+    headlineSmall = GeminiText.Title,
+    titleMedium   = GeminiText.Section,
+    bodyMedium    = GeminiText.AnswerBody,
+    labelSmall    = GeminiText.Meta,
+)
+```
+
+## 3. Signature Components
+
+### Gradient Sparkle
+
+```kotlin
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.size
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun GeminiSparkle(size: Dp = 20.dp, modifier: Modifier = Modifier) {
+    Canvas(modifier.size(size)) {
+        val w = this.size.width; val h = this.size.height
+        val cx = w / 2f; val cy = h / 2f
+        // Four-point sparkle: concave-diamond star
+        val path = Path().apply {
+            moveTo(cx, 0f)
+            quadraticBezierTo(cx, cy, w, cy)
+            quadraticBezierTo(cx, cy, cx, h)
+            quadraticBezierTo(cx, cy, 0f, cy)
+            quadraticBezierTo(cx, cy, cx, 0f)
+            close()
+        }
+        drawPath(path, brush = geminiGradient())
+    }
+}
+```
+
+### User Turn Chip
+
+```kotlin
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.draw.clip
+
+@Composable
+fun GeminiUserTurn(text: String, modifier: Modifier = Modifier) {
+    Row(
+        modifier.fillMaxWidth().padding(horizontal = 16.dp),
+        horizontalArrangement = Arrangement.End,
+    ) {
+        Text(
+            text,
+            style = GeminiText.UserTurn,
+            color = MaterialTheme.colorScheme.onBackground,
+            modifier = Modifier
+                .widthIn(max = 320.dp)
+                .clip(RoundedCornerShape(topStart = 20.dp, topEnd = 20.dp,
+                    bottomStart = 20.dp, bottomEnd = 4.dp))
+                .background(MaterialTheme.colorScheme.surfaceVariant)
+                .padding(horizontal = 16.dp, vertical = 12.dp),
+        )
+    }
+}
+```
+
+### Assistant Turn (plain text, no bubble)
+
+```kotlin
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.ContentCopy
+import androidx.compose.material3.Icon
+
+@Composable
+fun GeminiAssistantTurn(
+    text: String,
+    streaming: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    Column(modifier.fillMaxWidth().padding(horizontal = 16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+        Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+            GeminiSparkle(20.dp)
+            Text(text, style = GeminiText.AnswerBody,
+                color = MaterialTheme.colorScheme.onBackground, modifier = Modifier.weight(1f))
+        }
+        if (!streaming) {
+            Row(
+                Modifier.padding(start = 30.dp),
+                horizontalArrangement = Arrangement.spacedBy(20.dp),
+            ) {
+                listOf(
+                    Icons.Outlined.ContentCopy to "Copy",
+                    Icons.Filled.Refresh to "Regenerate",
+                    Icons.Filled.IosShare to "Share",
+                    Icons.Filled.MoreHoriz to "More",
+                ).forEach { (icon, cd) ->
+                    Icon(icon, cd, tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.size(20.dp))
+                }
+            }
+        }
+    }
+}
+```
+
+### Streaming Shimmer + Thinking
+
+```kotlin
+import androidx.compose.animation.core.*
+import androidx.compose.foundation.layout.Box
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Color
+
+@Composable
+fun GeminiStreamingText(text: String, modifier: Modifier = Modifier) {
+    val t = rememberInfiniteTransition(label = "stream")
+    val x by t.animateFloat(
+        -120f, 1000f,
+        infiniteRepeatable(tween(1100, easing = LinearEasing)),
+        label = "sweep",
+    )
+    Text(
+        text,
+        style = GeminiText.AnswerBody,
+        color = MaterialTheme.colorScheme.onBackground,
+        modifier = modifier.drawWithContent {
+            drawContent()
+            drawRect(
+                brush = Brush.horizontalGradient(
+                    0f to Color.Transparent,
+                    0.5f to GeminiColors.Violet.copy(alpha = 0.28f),
+                    1f to Color.Transparent,
+                    startX = x, endX = x + 120f,
+                ),
+                blendMode = BlendMode.Plus,
+            )
+        },
+    )
+}
+
+@Composable
+fun GeminiThinking() {
+    val t = rememberInfiniteTransition(label = "thinking")
+    Row(horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+        repeat(3) { i ->
+            val s by t.animateFloat(
+                0.5f, 1f,
+                infiniteRepeatable(tween(500), RepeatMode.Reverse, StartOffset(i * 150)),
+                label = "dot$i",
+            )
+            Box(
+                Modifier.size(7.dp).scale(s).clip(CircleShape).background(geminiGradient())
+            )
+        }
+    }
+}
+```
+
+### Prompt Bar (gradient focus ring)
+
+```kotlin
+import androidx.compose.foundation.border
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.ArrowUpward
+import androidx.compose.material.icons.filled.Mic
+import androidx.compose.material.icons.filled.Stop
+import androidx.compose.runtime.*
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalHapticFeedback
+
+@Composable
+fun GeminiPromptBar(
+    value: String,
+    onValueChange: (String) -> Unit,
+    onSend: () -> Unit,
+    onStop: () -> Unit,
+    streaming: Boolean = false,
+    modifier: Modifier = Modifier,
+) {
+    val interaction = remember { MutableInteractionSource() }
+    val focused by interaction.collectIsFocusedAsState()
+    val active = value.isNotEmpty()
+    val haptics = LocalHapticFeedback.current
+
+    Row(
+        modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp)
+            .clip(RoundedCornerShape(26.dp))
+            .background(MaterialTheme.colorScheme.surfaceVariant)
+            .then(
+                if (focused) Modifier.border(1.5.dp, geminiGradient(), RoundedCornerShape(26.dp))
+                else Modifier
+            )
+            .padding(horizontal = 14.dp, vertical = 8.dp)
+            .heightIn(min = 52.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        Icon(Icons.Filled.Add, "Add content",
+            tint = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.size(22.dp))
+        BasicTextField(
+            value = value, onValueChange = onValueChange,
+            interactionSource = interaction,
+            textStyle = GeminiText.PromptInput.copy(color = MaterialTheme.colorScheme.onBackground),
+            modifier = Modifier.weight(1f),
+            decorationBox = { inner ->
+                if (value.isEmpty()) Text("Ask Gemini", style = GeminiText.PromptInput,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant)
+                inner()
+            },
+        )
+        Icon(Icons.Filled.Mic, "Voice",
+            tint = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.size(22.dp))
+        Box(
+            Modifier
+                .size(36.dp).clip(CircleShape)
+                .background(if (streaming || active) GeminiColors.Blue else Color.Transparent)
+                .clickable {
+                    if (streaming) onStop()
+                    else if (active) { haptics.performHapticFeedback(HapticFeedbackType.LongPress); onSend() }
+                },
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(
+                if (streaming) Icons.Filled.Stop else Icons.Filled.ArrowUpward,
+                if (streaming) "Stop generating" else "Send",
+                tint = if (streaming || active) Color.White else GeminiColors.TextTertiary,
+                modifier = Modifier.size(if (streaming) 16.dp else 18.dp),
+            )
+        }
+    }
+}
+```
+
+### Suggestion Chip
+
+```kotlin
+@Composable
+fun GeminiSuggestionChip(
+    label: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    featured: Boolean = false,
+) {
+    Row(
+        modifier
+            .clip(RoundedCornerShape(18.dp))
+            .background(MaterialTheme.colorScheme.surfaceVariant)
+            .then(
+                if (featured) Modifier.border(1.dp, geminiGradient(), RoundedCornerShape(18.dp))
+                else Modifier.border(1.dp, MaterialTheme.colorScheme.outline, RoundedCornerShape(18.dp))
+            )
+            .clickable(onClick = onClick)
+            .padding(horizontal = 16.dp, vertical = 10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(6.dp),
+    ) {
+        if (featured) GeminiSparkle(12.dp)
+        Text(label, style = GeminiText.Chip, color = MaterialTheme.colorScheme.onBackground)
+    }
+}
+```
+
+## 4. Navigation (no bottom bar — drawer + top bar)
+
+Gemini has **no bottom navigation**. Use Material 3 `ModalNavigationDrawer` as the sole primary nav, with a `CenterAlignedTopAppBar` whose title is the tappable model selector.
+
+```kotlin
+import androidx.compose.material3.*
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun GeminiScaffold() {
+    val drawerState = rememberDrawerState(DrawerValue.Closed)
+    val scope = rememberCoroutineScope()
+
+    ModalNavigationDrawer(
+        drawerState = drawerState,
+        scrimColor = Color.Black.copy(alpha = 0.40f),
+        drawerContent = {
+            ModalDrawerSheet(
+                drawerContainerColor = MaterialTheme.colorScheme.background,
+                modifier = Modifier.fillMaxWidth(0.82f),
+            ) { GeminiDrawerContent() }
+        },
+    ) {
+        Scaffold(
+            topBar = {
+                CenterAlignedTopAppBar(
+                    title = {
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            Text("Gemini", style = GeminiText.Button)
+                            Icon(Icons.Filled.ExpandMore, "Switch model", Modifier.size(18.dp))
+                        }
+                    },
+                    navigationIcon = {
+                        IconButton(onClick = { scope.launch { drawerState.open() } }) {
+                            Icon(Icons.Filled.Menu, "Open drawer")
+                        }
+                    },
+                    actions = {
+                        Icon(Icons.Filled.AccountCircle, "Account",
+                            Modifier.size(28.dp).padding(end = 8.dp))
+                    },
+                    colors = TopAppBarDefaults.centerAlignedTopAppBarColors(
+                        containerColor = MaterialTheme.colorScheme.background),
+                )
+            },
+            bottomBar = { /* prompt bar — NOT a NavigationBar */ },
+        ) { pad -> ConversationList(Modifier.padding(pad)) }
+    }
+}
+```
+
+```kotlin
+@Composable
+fun GeminiDrawerContent() {
+    Column(Modifier.fillMaxSize().padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        Row(
+            Modifier.clip(CircleShape).background(MaterialTheme.colorScheme.surfaceVariant)
+                .clickable { }.padding(horizontal = 16.dp, vertical = 12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            Icon(Icons.Filled.Add, null, Modifier.size(20.dp))
+            Text("New chat", style = GeminiText.Button)
+        }
+        Text("TODAY", style = GeminiText.LabelUpper,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier.padding(top = 16.dp, start = 8.dp))
+        // recents rows: 48.dp, active row gets a surfaceVariant pill highlight
+    }
+}
+```
+
+## 5. Code Block (inside an answer)
+
+```kotlin
+@Composable
+fun GeminiCodeBlock(language: String, code: String) {
+    Column(
+        Modifier.fillMaxWidth()
+            .clip(RoundedCornerShape(12.dp))
+            .background(MaterialTheme.colorScheme.surfaceVariant)
+            .border(1.dp, MaterialTheme.colorScheme.outline, RoundedCornerShape(12.dp)),
+    ) {
+        Row(
+            Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 8.dp),
+            horizontalArrangement = Arrangement.SpaceBetween,
+        ) {
+            Text(language, style = GeminiText.Meta, color = MaterialTheme.colorScheme.onSurfaceVariant)
+            Text("Copy", style = GeminiText.Button)
+        }
+        Text(code, style = GeminiText.Code,
+            modifier = Modifier.horizontalScroll(rememberScrollState()).padding(16.dp))
+    }
+}
+```
+
+## 6. Motion
+
+| Moment | Compose recipe |
+|--------|----------------|
+| Streaming sweep | `rememberInfiniteTransition` driving a horizontal gradient `drawWithContent` overlay (BlendMode.Plus) |
+| Thinking dots | `rememberInfiniteTransition` 3 gradient dots scaling 0.5 → 1 with `StartOffset(i*150)` |
+| Send ⇄ Stop | swap the icon; `Crossfade` or `AnimatedContent` on the streaming flag |
+| Prompt focus ring | toggle `Modifier.border(geminiGradient())`; `animateDpAsState` on width over 180ms |
+| Drawer | `ModalNavigationDrawer` default slide + scrim fade |
+| Suggestion chip tap | `scale` 1 → 0.98; cross-fade label into the prompt field |
+| Copy confirm | `AnimatedVisibility(enter = slideInVertically + fadeIn)`, gradient-edged Snackbar, 1.5s |
+
+```kotlin
+// Idle sparkle shimmer (empty-state hero) — animate gradient start offset slowly
+@Composable
+fun ShimmerSparkle(size: Dp) {
+    val t = rememberInfiniteTransition(label = "sparkle")
+    val o by t.animateFloat(0f, 1f,
+        infiniteRepeatable(tween(2600, easing = LinearEasing)), label = "shimmer")
+    Canvas(Modifier.size(size)) {
+        val brush = Brush.linearGradient(
+            listOf(GeminiColors.Blue, GeminiColors.Violet, GeminiColors.Coral),
+            start = Offset(this.size.width * (o - 1f), 0f),
+            end   = Offset(this.size.width * (o + 1f), this.size.height),
+        )
+        // draw the sparkle path with `brush` (see GeminiSparkle)
+    }
+}
+```
+
+Haptics: prefer `LocalHapticFeedback`. For richer control use `LocalView.current.performHapticFeedback(HapticFeedbackConstants.CONTEXT_CLICK)` (API 30+) or a `Vibrator` `VibrationEffect.createOneShot(10, ...)` to approximate iOS's `.soft` impact on send.
+
+## 7. Icons
+
+Closest first-party set is `androidx.compose.material:material-icons-extended`. The **sparkle is custom** — draw the gradient path (see `GeminiSparkle`) or load a vector drawable with a gradient `<aapt:attr>` fill.
+
+| Purpose | SF Symbol (iOS) | Material Icon (Compose) |
+|---------|-----------------|--------------------------|
+| Sparkle (brand) | `sparkle` | custom gradient `Canvas` path |
+| Send | `arrow.up` | `Icons.Filled.ArrowUpward` |
+| Stop streaming | `stop.fill` | `Icons.Filled.Stop` |
+| Mic | `mic` | `Icons.Filled.Mic` |
+| Add content | `plus` | `Icons.Filled.Add` |
+| Copy | `doc.on.doc` | `Icons.Outlined.ContentCopy` |
+| Regenerate | `arrow.clockwise` | `Icons.Filled.Refresh` |
+| Share | `square.and.arrow.up` | `Icons.Filled.IosShare` |
+| More | `ellipsis` | `Icons.Filled.MoreHoriz` |
+| Drawer toggle | `line.3.horizontal` | `Icons.Filled.Menu` |
+| Model chevron | `chevron.down` | `Icons.Filled.ExpandMore` |
+| New chat | `square.and.pencil` | `Icons.Filled.Add` / `Icons.Outlined.Edit` |
+| Search (drawer) | `magnifyingglass` | `Icons.Filled.Search` |
+| Conversation row | `bubble.left` | `Icons.Outlined.ChatBubbleOutline` |
+| Account | `person.crop.circle` | `Icons.Filled.AccountCircle` |
+
+## 8. Minimum SDK & Accessibility Notes
+
+- **minSdk 24** (Compose floor is 21; modern motion comfortable at 24). `compileSdk 34+`, Compose BOM `2024.09+`, Kotlin `2.0+`.
+- **Edge-to-edge**: call `enableEdgeToEdge()` in the `Activity`; in light mode use dark system-bar icons (and the inverse in dark) via `WindowCompat`. Use `Scaffold` insets + `Modifier.imePadding()` so the prompt bar floats above the keyboard.
+- **No bottom navigation**: do not add a `NavigationBar`. The `ModalNavigationDrawer` is the sole primary nav; the prompt bar lives in the `bottomBar` slot but is a composer, not nav.
+- **Font scaling**: `sp` honors the user's font scale automatically — keep it on greeting, answers, body. Pin the prompt-bar base height and drawer day labels via `dp` or a fixed `Density` override.
+- **TalkBack**: mark `GeminiSparkle` with `Modifier.semantics { hideFromAccessibility() }` (decorative); the send button announces "Send" / "Stop generating"; announce stream completion with `LocalView.current.announceForAccessibility(...)`.
+- **The gradient is brand, not state**: never rely on it alone to signal focus/streaming — pair the focus ring with a TalkBack focus event and the stream with a live region.
+- **Contrast**: `#5F6368` on `#FFFFFF` and `#9AA0A6` on `#1E1E1E` pass WCAG AA at 13sp+. Use `DarkBlue #8AB4F8` for links/send on the dark canvas.
+- **Dynamic color**: do **not** enable Material You `dynamicLightColorScheme()` — Gemini's brand requires the fixed canvas/surface and the exact `#4285F4 → #9B72CB → #D96570` gradient regardless of wallpaper, identical across light and dark.