geeknative 0.0.0-stage → 0.1.1

package/template/apps/android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application
+        android:name=".App"
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:roundIcon="@mipmap/ic_launcher_round"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.App">
+
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:windowSoftInputMode="adjustResize">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

package/template/apps/android/app/src/main/kotlin/app/App.kt

@@ -0,0 +1,15 @@
+package app
+
+import android.app.Application
+import app.core.AppContainer
+
+class App : Application() {
+    /** The app's dependencies, created once at launch. */
+    lateinit var container: AppContainer
+        private set
+
+    override fun onCreate() {
+        super.onCreate()
+        container = AppContainer.live(this)
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/MainActivity.kt

@@ -0,0 +1,49 @@
+package app
+
+import android.graphics.Color
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.SystemBarStyle
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.core.LocalAppContainer
+import app.core.designsystem.AppTheme
+import app.core.navigation.AppNavigation
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        val container = (application as App).container
+
+        setContent {
+            // Null until the stored choice loads. Skip that first frame rather than flash the wrong theme.
+            val appearance by container.settingsRepository.appearance.collectAsStateWithLifecycle(initialValue = null)
+            val systemIsDark = isSystemInDarkTheme()
+
+            appearance?.let { chosen ->
+                val dark = chosen.isDark(systemIsDark)
+
+                // Keep the system bar icons readable when the app's appearance differs from the system's.
+                DisposableEffect(dark) {
+                    enableEdgeToEdge(
+                        statusBarStyle = SystemBarStyle.auto(Color.TRANSPARENT, Color.TRANSPARENT) { dark },
+                        navigationBarStyle = SystemBarStyle.auto(Color.TRANSPARENT, Color.TRANSPARENT) { dark },
+                    )
+                    onDispose {}
+                }
+
+                CompositionLocalProvider(LocalAppContainer provides container) {
+                    AppTheme(darkTheme = dark) {
+                        AppNavigation()
+                    }
+                }
+            }
+        }
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/core/AppContainer.kt

@@ -0,0 +1,27 @@
+package app.core
+
+import android.content.Context
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.datastore.preferences.preferencesDataStore
+import app.features.settings.DataStoreSettingsRepository
+import app.features.settings.InMemorySettingsRepository
+import app.features.settings.SettingsRepository
+
+private val Context.settingsDataStore by preferencesDataStore(name = "settings")
+
+/**
+ * The app's dependencies, created once at launch. Composables read it from [LocalAppContainer].
+ * Swap an implementation here (for example, a backend-backed repository) without touching screens.
+ */
+class AppContainer(val settingsRepository: SettingsRepository) {
+    companion object {
+        fun live(context: Context) = AppContainer(
+            settingsRepository = DataStoreSettingsRepository(context.applicationContext.settingsDataStore),
+        )
+
+        /** In-memory dependencies, for previews and tests. */
+        fun preview() = AppContainer(settingsRepository = InMemorySettingsRepository())
+    }
+}
+
+val LocalAppContainer = staticCompositionLocalOf<AppContainer> { error("AppContainer not provided") }

package/template/apps/android/app/src/main/kotlin/app/core/designsystem/AppCard.kt

@@ -0,0 +1,30 @@
+package app.core.designsystem
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.generated.AppRadius
+import app.generated.AppSpacing
+
+/** A card for grouped content on a screen (DESIGN.md: Card). */
+@Composable
+fun AppCard(modifier: Modifier = Modifier, content: @Composable ColumnScope.() -> Unit) {
+    Surface(
+        modifier = modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(AppRadius.lg),
+        color = AppTheme.colors.surface,
+        contentColor = AppTheme.colors.onSurface,
+    ) {
+        Column(
+            modifier = Modifier.padding(AppSpacing.lg),
+            verticalArrangement = Arrangement.spacedBy(AppSpacing.sm),
+            content = content,
+        )
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/core/designsystem/AppTheme.kt

@@ -0,0 +1,35 @@
+package app.core.designsystem
+
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.ReadOnlyComposable
+import androidx.compose.runtime.staticCompositionLocalOf
+import app.generated.AppColorTokens
+import app.generated.AppMaterialTypography
+import app.generated.AppShapes
+import app.generated.DarkAppColors
+import app.generated.LightAppColors
+import app.generated.toColorScheme
+
+private val LocalAppColors = staticCompositionLocalOf { LightAppColors }
+
+/** Applies the design tokens: [AppTheme.colors] for token colors, and Material 3 theming for stock components. */
+@Composable
+fun AppTheme(darkTheme: Boolean, content: @Composable () -> Unit) {
+    val colors = if (darkTheme) DarkAppColors else LightAppColors
+    CompositionLocalProvider(LocalAppColors provides colors) {
+        MaterialTheme(
+            colorScheme = colors.toColorScheme(dark = darkTheme),
+            typography = AppMaterialTypography,
+            shapes = AppShapes,
+            content = content,
+        )
+    }
+}
+
+object AppTheme {
+    /** The current color tokens, light or dark. */
+    val colors: AppColorTokens
+        @Composable @ReadOnlyComposable get() = LocalAppColors.current
+}

package/template/apps/android/app/src/main/kotlin/app/core/navigation/AppNavigation.kt

@@ -0,0 +1,40 @@
+package app.core.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.lifecycle.viewmodel.compose.viewModel
+import androidx.lifecycle.viewmodel.navigation3.rememberViewModelStoreNavEntryDecorator
+import androidx.navigation3.runtime.entryProvider
+import androidx.navigation3.runtime.rememberNavBackStack
+import androidx.navigation3.runtime.rememberSaveableStateHolderNavEntryDecorator
+import androidx.navigation3.ui.NavDisplay
+import app.core.LocalAppContainer
+import app.features.home.HomeScreen
+import app.features.settings.SettingsScreen
+import app.features.settings.SettingsViewModel
+
+/** The navigation root: one back stack, starting at Home. */
+@Composable
+fun AppNavigation() {
+    val container = LocalAppContainer.current
+    val backStack = rememberNavBackStack(Route.Home)
+
+    NavDisplay(
+        backStack = backStack,
+        onBack = { backStack.removeLastOrNull() },
+        entryDecorators = listOf(
+            rememberSaveableStateHolderNavEntryDecorator(),
+            rememberViewModelStoreNavEntryDecorator(),
+        ),
+        entryProvider = entryProvider {
+            entry<Route.Home> {
+                HomeScreen(onOpenSettings = { backStack.add(Route.Settings) })
+            }
+            entry<Route.Settings> {
+                SettingsScreen(
+                    viewModel = viewModel { SettingsViewModel(container.settingsRepository) },
+                    onBack = { backStack.removeLastOrNull() },
+                )
+            }
+        },
+    )
+}

package/template/apps/android/app/src/main/kotlin/app/core/navigation/Route.kt

@@ -0,0 +1,13 @@
+package app.core.navigation
+
+import androidx.navigation3.runtime.NavKey
+import kotlinx.serialization.Serializable
+
+/** Screens on the back stack. Names match spec/navigation.md. */
+sealed interface Route : NavKey {
+    @Serializable
+    data object Home : Route
+
+    @Serializable
+    data object Settings : Route
+}

package/template/apps/android/app/src/main/kotlin/app/features/home/HomeScreen.kt

@@ -0,0 +1,67 @@
+package app.features.home
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.R
+import app.core.designsystem.AppCard
+import app.core.designsystem.AppTheme
+import app.generated.AppIcons
+import app.generated.AppIdentity
+import app.generated.AppSpacing
+import app.generated.AppTypography
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun HomeScreen(onOpenSettings: () -> Unit) {
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(AppIdentity.NAME) },
+                actions = {
+                    IconButton(onClick = onOpenSettings, modifier = Modifier.testTag("home.openSettings")) {
+                        Icon(AppIcons.settings, contentDescription = stringResource(R.string.home_open_settings))
+                    }
+                },
+            )
+        },
+    ) { padding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding)
+                .verticalScroll(rememberScrollState())
+                .padding(AppSpacing.lg),
+        ) {
+            AppCard {
+                Text(stringResource(R.string.home_welcome_title), style = AppTypography.title)
+                Text(
+                    stringResource(R.string.home_welcome_body),
+                    style = AppTypography.body,
+                    color = AppTheme.colors.onSurfaceVariant,
+                )
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+private fun HomeScreenPreview() {
+    AppTheme(darkTheme = false) {
+        HomeScreen(onOpenSettings = {})
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/features/settings/Appearance.kt

@@ -0,0 +1,22 @@
+package app.features.settings
+
+import androidx.annotation.StringRes
+import app.R
+
+/** The appearance setting. Stored as these exact [id]s on every platform. */
+enum class Appearance(val id: String, @StringRes val label: Int) {
+    System("system", R.string.settings_appearance_system),
+    Light("light", R.string.settings_appearance_light),
+    Dark("dark", R.string.settings_appearance_dark);
+
+    /** Whether to render dark, given the system setting. */
+    fun isDark(systemIsDark: Boolean): Boolean = this == Dark || (this == System && systemIsDark)
+
+    companion object {
+        /** Storage key, shared with the iOS and web apps. */
+        const val STORAGE_KEY = "settings.appearance"
+
+        /** A missing or unknown stored value counts as [System]. */
+        fun fromId(id: String?): Appearance = entries.firstOrNull { it.id == id } ?: System
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/features/settings/SettingsRepository.kt

@@ -0,0 +1,40 @@
+package app.features.settings
+
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.map
+
+/** Stores the user's preferences. Screens use whichever implementation AppContainer provides. */
+interface SettingsRepository {
+    val appearance: Flow<Appearance>
+
+    suspend fun setAppearance(appearance: Appearance)
+}
+
+/** Keeps settings in Jetpack DataStore. */
+class DataStoreSettingsRepository(private val dataStore: DataStore<Preferences>) : SettingsRepository {
+    override val appearance: Flow<Appearance> = dataStore.data.map { Appearance.fromId(it[appearanceKey]) }
+
+    override suspend fun setAppearance(appearance: Appearance) {
+        dataStore.edit { it[appearanceKey] = appearance.id }
+    }
+
+    private companion object {
+        val appearanceKey = stringPreferencesKey(Appearance.STORAGE_KEY)
+    }
+}
+
+/** Keeps settings in memory, for previews and tests. */
+class InMemorySettingsRepository(initial: Appearance = Appearance.System) : SettingsRepository {
+    private val state = MutableStateFlow(initial)
+
+    override val appearance: Flow<Appearance> = state
+
+    override suspend fun setAppearance(appearance: Appearance) {
+        state.value = appearance
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/features/settings/SettingsScreen.kt

@@ -0,0 +1,113 @@
+package app.features.settings
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.R
+import app.core.designsystem.AppCard
+import app.core.designsystem.AppTheme
+import app.generated.AppIcons
+import app.generated.AppSpacing
+import app.generated.AppTypography
+
+@Composable
+fun SettingsScreen(viewModel: SettingsViewModel, onBack: () -> Unit) {
+    val state by viewModel.uiState.collectAsStateWithLifecycle()
+    SettingsContent(state = state, onSelectAppearance = viewModel::selectAppearance, onBack = onBack)
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun SettingsContent(state: SettingsUiState, onSelectAppearance: (Appearance) -> Unit, onBack: () -> Unit) {
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.settings_title)) },
+                navigationIcon = {
+                    IconButton(onClick = onBack) {
+                        Icon(AppIcons.back, contentDescription = stringResource(R.string.common_back))
+                    }
+                },
+            )
+        },
+    ) { padding ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding)
+                .verticalScroll(rememberScrollState())
+                .padding(AppSpacing.lg),
+            verticalArrangement = Arrangement.spacedBy(AppSpacing.xl),
+        ) {
+            AppCard {
+                SectionTitle(stringResource(R.string.settings_appearance_title))
+                Column(Modifier.selectableGroup().testTag("settings.appearance")) {
+                    state.appearanceOptions.forEach { option ->
+                        Row(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .heightIn(min = 48.dp)
+                                .selectable(
+                                    selected = option == state.appearance,
+                                    onClick = { onSelectAppearance(option) },
+                                    role = Role.RadioButton,
+                                ),
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.spacedBy(AppSpacing.md),
+                        ) {
+                            RadioButton(selected = option == state.appearance, onClick = null)
+                            Text(stringResource(option.label), style = AppTypography.body)
+                        }
+                    }
+                }
+            }
+
+            AppCard {
+                SectionTitle(stringResource(R.string.settings_about_title))
+                Text(
+                    stringResource(R.string.settings_about_version, state.version, state.build),
+                    style = AppTypography.body,
+                    modifier = Modifier.testTag("settings.version"),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun SectionTitle(text: String) {
+    Text(text, style = AppTypography.label, color = AppTheme.colors.onSurfaceVariant)
+}
+
+@Preview
+@Composable
+private fun SettingsScreenPreview() {
+    AppTheme(darkTheme = false) {
+        SettingsContent(state = SettingsUiState(), onSelectAppearance = {}, onBack = {})
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/features/settings/SettingsViewModel.kt

@@ -0,0 +1,28 @@
+package app.features.settings
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import app.generated.AppIdentity
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+
+data class SettingsUiState(
+    val appearance: Appearance = Appearance.System,
+    val appearanceOptions: List<Appearance> = Appearance.entries,
+    val version: String = AppIdentity.VERSION,
+    val build: Int = AppIdentity.BUILD,
+)
+
+/** State and actions for the Settings screen. */
+class SettingsViewModel(private val repository: SettingsRepository) : ViewModel() {
+    val uiState: StateFlow<SettingsUiState> = repository.appearance
+        .map { SettingsUiState(appearance = it) }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), SettingsUiState())
+
+    fun selectAppearance(appearance: Appearance) {
+        viewModelScope.launch { repository.setAppearance(appearance) }
+    }
+}

package/template/apps/android/app/src/main/kotlin/app/generated/AppIdentity.kt

@@ -0,0 +1,10 @@
+// GENERATED by geeknative from contracts/app.json. Do not edit: change the contract, then run `make gen`.
+package app.generated
+
+/** The app's name, identifier and version, shared with the iOS and web apps. */
+object AppIdentity {
+    const val NAME = "GeekNative"
+    const val ID = "com.example.geeknative"
+    const val VERSION = "1.0.0"
+    const val BUILD = 1
+}

package/template/apps/android/app/src/main/kotlin/app/generated/Icons.kt

@@ -0,0 +1,15 @@
+// GENERATED by geeknative from contracts/icons.json. Do not edit: change the contract, then run `make gen`.
+package app.generated
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Home
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.ui.graphics.vector.ImageVector
+
+/** Icons as Material icons. Use with `Icon(AppIcons.settings, contentDescription = ...)`. */
+object AppIcons {
+    val back: ImageVector get() = Icons.AutoMirrored.Filled.ArrowBack
+    val home: ImageVector get() = Icons.Filled.Home
+    val settings: ImageVector get() = Icons.Filled.Settings
+}