ci: add BuildTool and route Android builds through it

.gitea/workflows/android-build.yml

@@ -0,0 +1,84 @@
+name: Android build
+
+permissions:
+  contents: write
+  releases: write
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+  release:
+    types:
+      - published
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Java 17
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: '17'
+
+      - name: Run project build tooling for debug APK
+        if: github.event_name != 'release'
+        shell: bash
+        env:
+          CI_VERSION_CODE: ${{ github.run_number }}
+        run: |
+          set -euxo pipefail
+          chmod +x ./BuildTool.sh
+          ./BuildTool.sh --no-commit --apk-only
+
+      - name: Run project build tooling for release AAB
+        if: github.event_name == 'release'
+        shell: bash
+        env:
+          CI_VERSION_CODE: ${{ github.run_number }}
+          CI_ARTIFACT_TIMESTAMP: ${{ github.run_id }}
+          ANDROID_KEYSTORE_BASE64: ${{ secrets.ANDROID_KEYSTORE_BASE64 }}
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.ANDROID_KEYSTORE_PASSWORD }}
+          ANDROID_KEY_ALIAS: ${{ secrets.ANDROID_KEY_ALIAS }}
+          ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
+        run: |
+          set -euxo pipefail
+          chmod +x ./BuildTool.sh
+          ./BuildTool.sh --no-commit --with-aab
+
+      - name: Upload debug APK
+        if: github.event_name != 'release'
+        uses: actions/upload-artifact@v3
+        with:
+          name: debug-apk
+          path: dist/*.apk
+          if-no-files-found: error
+
+      - name: Attach release AAB to Gitea release
+        if: github.event_name == 'release'
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          GITHUB_TOKEN: ${{ github.token }}
+        shell: bash
+        run: |
+          set -euxo pipefail
+          token="${GITHUB_TOKEN:-${GITEA_TOKEN:-}}"
+          if [ -z "$token" ]; then
+            echo "::error::No release upload token is available from secrets.GITEA_TOKEN or github.token"
+            exit 1
+          fi
+          release_id="$(python3 -c 'import json, os; print(json.load(open(os.environ["GITHUB_EVENT_PATH"], encoding="utf-8"))["release"]["id"])')"
+          aab="$(find dist -name '*.aab' | head -n 1)"
+          curl --fail-with-body \
+            --request POST \
+            --header "Authorization: token ${token}" \
+            --form "attachment=@${aab}" \
+            "${GITHUB_SERVER_URL}/api/v1/repos/${GITHUB_REPOSITORY}/releases/${release_id}/assets?name=$(basename "$aab")"

.gitignore

@@ -3,9 +3,13 @@
 *.iml
 build/
 app/build/
+dist/
+commit-message.txt
+.android-sdk/
 local.properties
 
 # Signing
 keystore/*.jks
 keystore/*.properties
-
+keystore.properties
+.ci-secrets/

BuildTool.sh

@@ -0,0 +1,263 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+APP_NAME="MindMachine"
+MODULE="app"
+API_LEVEL="36"
+BUILD_TOOLS_VERSION="36.0.0"
+DIST_DIR="dist"
+COMMIT_MSG_FILE="commit-message.txt"
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$ROOT_DIR"
+
+export GRADLE_OPTS="${GRADLE_OPTS:-} -Dorg.gradle.daemon=false"
+
+usage() {
+  cat <<EOF
+Usage: ./BuildTool.sh [options]
+
+Options:
+  --setup-only      Check/install build environment and exit
+  --no-commit       Build successfully but do not auto-commit
+  --apk-only        Build debug APK only (default)
+  --with-aab        Also build release AAB
+  --help            Show this help
+
+Behavior:
+  - Disables Gradle daemon
+  - Increments versionCode/versionName for local builds
+  - Honors CI_VERSION_CODE for CI builds
+  - Names CI release AABs with APP_NAME + CI_ARTIFACT_TIMESTAMP when provided
+  - Uses repo secrets from env for release signing when provided
+  - Copies artifacts to dist/
+EOF
+}
+
+SETUP_ONLY=false
+DO_COMMIT=true
+WITH_AAB=false
+
+for arg in "$@"; do
+  case "$arg" in
+    --setup-only) SETUP_ONLY=true ;;
+    --no-commit) DO_COMMIT=false ;;
+    --apk-only) WITH_AAB=false ;;
+    --with-aab) WITH_AAB=true ;;
+    --help|-h) usage; exit 0 ;;
+    *) echo "Unknown option: $arg" >&2; usage; exit 1 ;;
+  esac
+done
+
+CI_VERSION_CODE="${CI_VERSION_CODE:-}"
+CI_ARTIFACT_TIMESTAMP="${CI_ARTIFACT_TIMESTAMP:-}"
+
+need_cmd() {
+  command -v "$1" >/dev/null 2>&1 || {
+    echo "Missing required command: $1" >&2
+    exit 1
+  }
+}
+
+ensure_java() {
+  need_cmd java
+  local major
+  major="$(java -version 2>&1 | awk -F[\".] '/version/ {print $2}')"
+  if [[ "${major:-0}" -lt 17 ]]; then
+    echo "Java 17+ is required. Found Java ${major:-unknown}." >&2
+    exit 1
+  fi
+}
+
+ensure_android_sdk() {
+  if [[ -z "${ANDROID_HOME:-}" ]]; then
+    export ANDROID_HOME="$ROOT_DIR/.android-sdk"
+  fi
+  export ANDROID_SDK_ROOT="$ANDROID_HOME"
+  export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$PATH"
+
+  if [[ ! -x "$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager" ]]; then
+    need_cmd curl
+    need_cmd unzip
+    mkdir -p "$ANDROID_HOME/cmdline-tools"
+    local zip_path="$ANDROID_HOME/cmdline-tools/commandlinetools.zip"
+    curl -L -o "$zip_path" "https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip"
+    rm -rf "$ANDROID_HOME/cmdline-tools/latest" "$ANDROID_HOME/cmdline-tools/cmdline-tools"
+    unzip -q "$zip_path" -d "$ANDROID_HOME/cmdline-tools"
+    mv "$ANDROID_HOME/cmdline-tools/cmdline-tools" "$ANDROID_HOME/cmdline-tools/latest"
+    rm "$zip_path"
+  fi
+
+  yes | sdkmanager --licenses >/dev/null || true
+  sdkmanager \
+    "platform-tools" \
+    "platforms;android-$API_LEVEL" \
+    "build-tools;$BUILD_TOOLS_VERSION" >/dev/null
+}
+
+ensure_gradle_wrapper() {
+  if [[ ! -x "./gradlew" ]]; then
+    if [[ -f "./gradlew" ]]; then
+      chmod +x ./gradlew
+    else
+      echo "Missing Gradle wrapper ./gradlew" >&2
+      exit 1
+    fi
+  fi
+}
+
+gradle_no_daemon() {
+  ./gradlew --no-daemon -Dorg.gradle.daemon=false "$@"
+}
+
+prepare_optional_release_signing() {
+  local required=(ANDROID_KEYSTORE_BASE64 ANDROID_KEYSTORE_PASSWORD ANDROID_KEY_ALIAS ANDROID_KEY_PASSWORD)
+  local missing=()
+  local key
+  for key in "${required[@]}"; do
+    if [[ -z "${!key:-}" ]]; then
+      missing+=("$key")
+    fi
+  done
+
+  if [[ ${#missing[@]} -eq ${#required[@]} ]]; then
+    return
+  fi
+  if [[ ${#missing[@]} -gt 0 ]]; then
+    printf 'Release signing secrets missing: %s\n' "${missing[*]}" >&2
+    exit 1
+  fi
+
+  mkdir -p .ci-secrets
+  printf '%s' "$ANDROID_KEYSTORE_BASE64" | base64 -d > .ci-secrets/release-keystore.jks
+  cat > keystore.properties <<EOF
+storeFile=.ci-secrets/release-keystore.jks
+storePassword=$ANDROID_KEYSTORE_PASSWORD
+keyAlias=$ANDROID_KEY_ALIAS
+keyPassword=$ANDROID_KEY_PASSWORD
+EOF
+}
+
+ensure_gitignore_entries() {
+  touch .gitignore
+  for entry in \
+    "$COMMIT_MSG_FILE" \
+    ".android-sdk/" \
+    ".gradle/" \
+    "$DIST_DIR/" \
+    "local.properties" \
+    "**/build/" \
+    "*.iml" \
+    ".idea/" \
+  ; do
+    grep -qxF "$entry" .gitignore || echo "$entry" >> .gitignore
+  done
+}
+
+increment_versions() {
+  local gradle_file="$MODULE/build.gradle.kts"
+  python3 - "$gradle_file" "$CI_VERSION_CODE" <<'PY'
+import re
+import sys
+from pathlib import Path
+
+path = Path(sys.argv[1])
+text = path.read_text()
+ci_version_code = sys.argv[2].strip()
+
+m_code = re.search(r'\bversionCode\s*=\s*(\d+)', text)
+m_name = re.search(r'\bversionName\s*=\s*"(\d+(?:\.\d+)*)"', text)
+if not m_code or not m_name:
+    raise SystemExit('Could not find versionCode/versionName in app/build.gradle.kts')
+
+old_code = int(m_code.group(1))
+new_code = int(ci_version_code) if ci_version_code else old_code + 1
+parts = m_name.group(1).split('.')
+parts[-1] = str(int(parts[-1]) + 1)
+new_name = '.'.join(parts)
+
+text = re.sub(r'(\bversionCode\s*=\s*)\d+', rf'\g<1>{new_code}', text, count=1)
+if not ci_version_code:
+    text = re.sub(r'(\bversionName\s*=\s*)"\d+(?:\.\d+)*"', rf'\g<1>"{new_name}"', text, count=1)
+path.write_text(text)
+print(new_code)
+PY
+}
+
+build_artifacts() {
+  gradle_no_daemon clean assembleDebug
+  if [[ "$WITH_AAB" == true ]]; then
+    gradle_no_daemon bundleRelease
+  fi
+}
+
+copy_artifacts() {
+  local version_code="$1"
+  mkdir -p "$DIST_DIR"
+
+  local debug_apk
+  debug_apk="$(find "$MODULE/build/outputs/apk/debug" -name "*.apk" | head -n 1 || true)"
+  [[ -f "$debug_apk" ]] || { echo "Debug APK not found." >&2; exit 1; }
+  cp "$debug_apk" "$DIST_DIR/${APP_NAME}-v${version_code}-debug.apk"
+
+  if [[ "$WITH_AAB" == true ]]; then
+    local release_aab
+    release_aab="$(find "$MODULE/build/outputs/bundle/release" -name "*.aab" | head -n 1 || true)"
+    [[ -f "$release_aab" ]] || { echo "Release AAB not found." >&2; exit 1; }
+    local release_name
+    if [[ -n "$CI_ARTIFACT_TIMESTAMP" ]]; then
+      release_name="${APP_NAME}-${CI_ARTIFACT_TIMESTAMP}-release.aab"
+    else
+      release_name="${APP_NAME}-v${version_code}-release.aab"
+    fi
+    cp "$release_aab" "$DIST_DIR/$release_name"
+  fi
+}
+
+commit_successful_build() {
+  git rev-parse --is-inside-work-tree >/dev/null 2>&1 || return
+  local message
+  if [[ -s "$COMMIT_MSG_FILE" ]]; then
+    message="$(cat "$COMMIT_MSG_FILE")"
+  else
+    message="No Details"
+  fi
+  git add -A
+  git reset -q HEAD -- keystore.properties '.ci-secrets' '*.jks' 2>/dev/null || true
+  if ! git diff --cached --quiet; then
+    git commit -m "$message"
+  fi
+  : > "$COMMIT_MSG_FILE"
+}
+
+main() {
+  need_cmd python3
+  ensure_java
+  ensure_android_sdk
+  ensure_gradle_wrapper
+  ensure_gitignore_entries
+
+  printf 'sdk.dir=%s\n' "$ANDROID_HOME" > local.properties
+
+  if [[ "$SETUP_ONLY" == true ]]; then
+    echo "Build environment setup complete."
+    exit 0
+  fi
+
+  if [[ "$WITH_AAB" == true ]]; then
+    prepare_optional_release_signing
+  fi
+
+  local version_code
+  version_code="$(increment_versions)"
+  build_artifacts
+  copy_artifacts "$version_code"
+
+  if [[ "$DO_COMMIT" == true ]]; then
+    commit_successful_build
+  fi
+
+  echo "Build completed successfully for versionCode $version_code."
+}
+
+main "$@"

DEVELOPMENT.md

@@ -2,6 +2,23 @@
 
 ## Build prerequisites
 
+Use the root build tooling so local builds and Gitea Actions run through the same script:
+
+```bash
+./BuildTool.sh --setup-only
+./BuildTool.sh --no-commit --apk-only
+./BuildTool.sh --no-commit --with-aab
+```
+
+Behavior summary:
+- `--setup-only` prepares the local Android SDK/tooling and exits.
+- `--apk-only` builds the debug APK.
+- `--with-aab` also builds the release AAB.
+- `--no-commit` skips the post-build git commit step.
+- Local builds increment `versionCode` and `versionName`.
+- CI can provide `CI_VERSION_CODE` to force the build version code and `CI_ARTIFACT_TIMESTAMP` to control the release AAB filename.
+- Artifacts are copied into `dist/`.
+
 - JDK 17
 - Android Studio (recommended)
 - Android SDK installed

app/build.gradle.kts

@@ -1,3 +1,5 @@
+import java.util.Properties
+
 plugins {
     id("com.android.application")
     id("org.jetbrains.kotlin.android")
@@ -5,43 +7,57 @@ plugins {
     id("org.jetbrains.kotlin.plugin.compose")
 }
 
-import java.util.Properties
+val keystorePropertiesFile = rootProject.file("keystore.properties")
+val keystoreProperties = Properties()
+if (keystorePropertiesFile.exists()) {
+    keystorePropertiesFile.inputStream().use { keystoreProperties.load(it) }
+}
+val hasReleaseSigning = listOf(
+    "storeFile",
+    "storePassword",
+    "keyAlias",
+    "keyPassword",
+).all { !keystoreProperties.getProperty(it).isNullOrBlank() }
 
 android {
     namespace = "solutions.tretter.mindmachine"
-    compileSdk = 35
+    compileSdk = 36
 
     defaultConfig {
         applicationId = "solutions.tretter.mindmachine"
         minSdk = 26
-        targetSdk = 35
-        versionCode = 14
-        versionName = "1.0.9"
+        targetSdk = 36
+        versionCode = 18
+        versionName = "1.0.13"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
-    buildTypes {
     signingConfigs {
+        if (hasReleaseSigning) {
             create("release") {
-                val propsFile = rootProject.file("keystore/upload-keystore.properties")
-                if (propsFile.exists()) {
-                    val props = Properties().apply { propsFile.inputStream().use { this.load(it) } }
-                    storeFile = rootProject.file(props.getProperty("storeFile"))
-                    storePassword = props.getProperty("storePassword")
-                    keyAlias = props.getProperty("keyAlias")
-                    keyPassword = props.getProperty("keyPassword")
+                storeFile = rootProject.file(keystoreProperties.getProperty("storeFile"))
+                storePassword = keystoreProperties.getProperty("storePassword")
+                keyAlias = keystoreProperties.getProperty("keyAlias")
+                keyPassword = keystoreProperties.getProperty("keyPassword")
             }
         }
     }
 
+    buildTypes {
+        debug {
+            buildConfigField("boolean", "DEBUG_AD_FREE", "true")
+        }
         release {
+            if (hasReleaseSigning) {
                 signingConfig = signingConfigs.getByName("release")
+            }
             isMinifyEnabled = false
             proguardFiles(
                 getDefaultProguardFile("proguard-android-optimize.txt"),
                 "proguard-rules.pro"
             )
+            buildConfigField("boolean", "DEBUG_AD_FREE", "false")
         }
     }
     compileOptions {
@@ -53,6 +69,7 @@ android {
     }
     buildFeatures {
         compose = true
+        buildConfig = true
     }
     composeOptions {
         kotlinCompilerExtensionVersion = "2.1.0"
@@ -83,7 +100,6 @@ dependencies {
     implementation("androidx.compose.material:material-icons-extended")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1")
 
-    // Monetization
     implementation("com.google.android.gms:play-services-ads:23.1.0")
     implementation("com.android.billingclient:billing-ktx:8.0.0")
 

app/src/main/java/com/mindmachine/mvp/MainActivity.kt

@@ -13,6 +13,7 @@ import android.util.Log
 import android.view.View
 import android.view.WindowManager
 import androidx.activity.ComponentActivity
+import solutions.tretter.mindmachine.BuildConfig
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.setContent
 import androidx.activity.viewModels
@@ -48,6 +49,7 @@ import androidx.compose.foundation.Image
 import androidx.compose.foundation.Image
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Close
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.PlayArrow
 import androidx.compose.material.icons.filled.Settings
@@ -172,7 +174,9 @@ class MainActivity : ComponentActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        if (!BuildConfig.DEBUG_AD_FREE) {
             MobileAds.initialize(this) {}
+        }
         setContent {
             MaterialTheme(colorScheme = MindMachineColors) {
                 App(vm, billingManager)
@@ -227,7 +231,7 @@ fun App(vm: MainViewModel = viewModel(), billingManager: solutions.tretter.mindm
         composable("home") {
             var confirmDeleteProgramId by remember { mutableStateOf<String?>(null) }
             var confirmDeleteProgramName by remember { mutableStateOf("") }
-            val interstitial = rememberInterstitialController(enabled = !ui.settings.noAds)
+            val interstitial = rememberInterstitialController(enabled = !ui.settings.noAds && !BuildConfig.DEBUG_AD_FREE)
 
             Column(
                 Modifier
@@ -342,11 +346,13 @@ fun App(vm: MainViewModel = viewModel(), billingManager: solutions.tretter.mindm
                     }
                 }
 
+                if (!BuildConfig.DEBUG_AD_FREE) {
                     AdBanner(
                         enabled = !ui.settings.noAds,
                         modifier = Modifier.fillMaxWidth()
                     )
                 }
+            }
 
             if (confirmDeleteProgramId != null) {
                 AlertDialog(
@@ -375,7 +381,7 @@ fun App(vm: MainViewModel = viewModel(), billingManager: solutions.tretter.mindm
             }
         }
         composable("setup") {
-            val interstitial = rememberInterstitialController(enabled = !ui.settings.noAds)
+            val interstitial = rememberInterstitialController(enabled = !ui.settings.noAds && !BuildConfig.DEBUG_AD_FREE)
             SetupScreen(
                 vm = vm,
                 onStart = {
@@ -597,6 +603,8 @@ fun ActiveSessionScreen(vm: MainViewModel, onFinish: () -> Unit, onBackToEntry:
     }
     var brightnessOverlayVisible by remember { mutableStateOf(false) }
     var brightnessOverlayToken by remember { mutableIntStateOf(0) }
+    var stopButtonVisible by remember { mutableStateOf(false) }
+    var stopButtonToken by remember { mutableIntStateOf(0) }
     val timingLogTag = "MindMachineTiming"
 
     LaunchedEffect(brightnessOverlayToken) {
@@ -642,12 +650,24 @@ fun ActiveSessionScreen(vm: MainViewModel, onFinish: () -> Unit, onBackToEntry:
                 detectTapGestures {
                     brightnessOverlayVisible = true
                     brightnessOverlayToken++
+                    if (ui.settings.showImmersiveStopButton && immersiveFullscreen) {
+                        stopButtonVisible = true
+                        stopButtonToken++
+                    }
                     if (!immersiveFullscreen) {
                         showOverlay = !showOverlay
                     }
                 }
             }
     ) {
+        // Auto-hide stop button after 3 seconds of visibility
+        LaunchedEffect(stopButtonToken) {
+            if (stopButtonVisible) {
+                delay(3000)
+                stopButtonVisible = false
+            }
+        }
+
         if (isVisualMode) {
             AndroidView(
                 modifier = Modifier.fillMaxSize(),
@@ -715,6 +735,26 @@ fun ActiveSessionScreen(vm: MainViewModel, onFinish: () -> Unit, onBackToEntry:
             }
         }
 
+        // Stop button in immersive mode (top-right)
+        if (stopButtonVisible && ui.settings.showImmersiveStopButton) {
+            IconButton(
+                onClick = {
+                    vm.stop()
+                    onFinish()
+                },
+                modifier = Modifier
+                    .align(Alignment.TopEnd)
+                    .padding(top = 16.dp, end = 16.dp)
+            ) {
+                Icon(
+                    imageVector = Icons.Filled.Close,
+                    contentDescription = "Stop",
+                    tint = Color.White,
+                    modifier = Modifier.size(28.dp)
+                )
+            }
+        }
+
         if (showOverlay) {
             Column(
                 Modifier
@@ -1233,6 +1273,18 @@ fun SettingsScreen(vm: MainViewModel, onRemoveAds: () -> Unit) {
             Text("Show immersive bottom progress bar", color = MaterialTheme.colorScheme.onBackground)
         }
 
+        Row(verticalAlignment = Alignment.CenterVertically) {
+            Checkbox(checked = ui.settings.showImmersiveStopButton, onCheckedChange = vm::updateShowImmersiveStopButton)
+            Column {
+                Text("Show stop button in immersive mode", color = MaterialTheme.colorScheme.onBackground)
+                Text(
+                    "If off, swipe from edge to display back button",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onBackground.copy(alpha = 0.7f)
+                )
+            }
+        }
+
         Row(verticalAlignment = Alignment.CenterVertically) {
             Checkbox(checked = ui.settings.preferLowestRefreshRate, onCheckedChange = vm::updatePreferLowestRefreshRate)
             Text("Prefer lowest display refresh rate during sessions", color = MaterialTheme.colorScheme.onBackground)

app/src/main/java/com/mindmachine/mvp/billing/BillingManager.kt

@@ -187,18 +187,18 @@ class BillingManager(
                 .setProductList(products)
                 .build()
 
-            billingClient.queryProductDetailsAsync(params) { result, queryResult ->
-                log("queryProductDetailsAsync($productType) result: ${result.responseCode} ${result.debugMessage}")
+            billingClient.queryProductDetailsAsync(params) { billingResult, queryResult ->
+                log("queryProductDetailsAsync($productType) result: ${billingResult.responseCode} ${billingResult.debugMessage}")
 
                 val detailsList = queryResult.productDetailsList
-                log("Fetched $productType products: ${detailsList.map { it.productId }}")
+                log("Fetched $productType products: ${detailsList?.map { it.productId } ?: emptyList()}")
 
                 if (queryResult.unfetchedProductList.isNotEmpty()) {
                     logError("Unfetched $productType products: ${queryResult.unfetchedProductList}")
                 }
 
-                if (result.responseCode == BillingClient.BillingResponseCode.OK) {
-                    _productDetails.value = _productDetails.value + detailsList.associateBy { it.productId }
+                if (billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
+                    _productDetails.value = _productDetails.value + (detailsList?.associateBy { it.productId } ?: emptyMap())
                     log("Product details cache now has: ${_productDetails.value.keys}")
                 }
             }

app/src/main/java/com/mindmachine/mvp/data/SettingsRepository.kt

@@ -20,6 +20,7 @@ class SettingsRepository(private val context: Context) {
         val countdownSeconds = intPreferencesKey("countdown_seconds")
         val forceAudioWithoutHeadphones = booleanPreferencesKey("force_audio_without_headphones")
         val showImmersiveProgressBar = booleanPreferencesKey("show_immersive_progress_bar")
+        val showImmersiveStopButton = booleanPreferencesKey("show_immersive_stop_button")
         val preferLowestRefreshRate = booleanPreferencesKey("prefer_lowest_refresh_rate")
         val monochromeFlashMode = booleanPreferencesKey("monochrome_flash_mode")
         val immersiveBrightnessPercent = intPreferencesKey("immersive_brightness_percent")
@@ -36,6 +37,7 @@ class SettingsRepository(private val context: Context) {
                 ?: 5,
             forceAudioWithoutHeadphones = p[Keys.forceAudioWithoutHeadphones] ?: false,
             showImmersiveProgressBar = p[Keys.showImmersiveProgressBar] ?: true,
+            showImmersiveStopButton = p[Keys.showImmersiveStopButton] ?: true,
             preferLowestRefreshRate = p[Keys.preferLowestRefreshRate] ?: true,
             monochromeFlashMode = p[Keys.monochromeFlashMode] ?: false,
             immersiveBrightnessPercent = (p[Keys.immersiveBrightnessPercent] ?: 50).coerceIn(5, 100),
@@ -58,6 +60,9 @@ class SettingsRepository(private val context: Context) {
             if (prefs[Keys.preferLowestRefreshRate] == null) {
                 prefs[Keys.preferLowestRefreshRate] = true
             }
+            if (prefs[Keys.showImmersiveStopButton] == null) {
+                prefs[Keys.showImmersiveStopButton] = true
+            }
         }
     }
 
@@ -80,6 +85,10 @@ class SettingsRepository(private val context: Context) {
         it[Keys.showImmersiveProgressBar] = value
     }
 
+    suspend fun updateShowImmersiveStopButton(value: Boolean) = context.dataStore.edit {
+        it[Keys.showImmersiveStopButton] = value
+    }
+
     suspend fun updatePreferLowestRefreshRate(value: Boolean) = context.dataStore.edit {
         it[Keys.preferLowestRefreshRate] = value
     }

app/src/main/java/com/mindmachine/mvp/domain/Models.kt

@@ -42,6 +42,7 @@ data class AppSettings(
     val countdownSeconds: Int = 5,
     val forceAudioWithoutHeadphones: Boolean = false,
     val showImmersiveProgressBar: Boolean = true,
+    val showImmersiveStopButton: Boolean = true,
     val preferLowestRefreshRate: Boolean = true,
     val monochromeFlashMode: Boolean = false,
     // Default used only before DataStore emits (and as a fallback).

app/src/main/java/com/mindmachine/mvp/session/MainViewModel.kt

@@ -304,6 +304,7 @@ class MainViewModel(
         settingsRepository.updateForceAudioWithoutHeadphones(value)
     }
     fun updateShowImmersiveProgressBar(value: Boolean) = viewModelScope.launch { settingsRepository.updateShowImmersiveProgressBar(value) }
+    fun updateShowImmersiveStopButton(value: Boolean) = viewModelScope.launch { settingsRepository.updateShowImmersiveStopButton(value) }
     fun updatePreferLowestRefreshRate(value: Boolean) = viewModelScope.launch { settingsRepository.updatePreferLowestRefreshRate(value) }
     fun updateMonochromeFlashMode(value: Boolean) = viewModelScope.launch { settingsRepository.updateMonochromeFlashMode(value) }
     fun updateImmersiveBrightnessPercent(value: Int) = viewModelScope.launch {

app/src/main/java/com/mindmachine/mvp/session/TimelineEditorScreen.kt

@@ -425,7 +425,7 @@ internal fun TimelineGraph(
                                             height = h,
                                             curveId = curveId,
                                         )
-                                        val updated = targetCurve.movePointVerticalWithPropagation(pointIndex, constrainedY, h)
+                                        val updated = targetCurve.movePointVertical(pointIndex, constrainedY, h)
                                         if (curveId == leftId) curveLeft = updated else curveRight = updated
                                         currentOnUpdateCurve(curveId, updated)
                                         onCurveEditedHaptic()

build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id("com.android.application") version "8.5.2" apply false
+    id("com.android.application") version "8.10.0" apply false
     id("org.jetbrains.kotlin.android") version "2.1.0" apply false
     id("org.jetbrains.kotlin.plugin.serialization") version "2.1.0" apply false
     id("org.jetbrains.kotlin.plugin.compose") version "2.1.0" apply false

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME