prep for F-Droid: isolate firebase and mobile_scanner behind seams

.github/workflows/build.yml

@@ -243,6 +243,89 @@ jobs:
           files: ${{ steps.rename.outputs.apk }}
           generate_release_notes: true
 
+  # Keeps the F-Droid build recipe (docs/fdroid/*.yml) in sync with each
+  # release and, once a fdroiddata fork is configured, pushes the updated
+  # recipe there as a merge request. F-Droid builds from source itself (see
+  # docs/fdroid/wtf.openstrap.openstrap_edge.yml's header for the full
+  # rationale/verification) — this job never ships a binary to F-Droid, it
+  # only keeps the recipe's versionName/versionCode/commit current so the
+  # inclusion (or an update) has something correct to build. After the FIRST
+  # inclusion is merged, F-Droid's own AutoUpdateMode:Version +
+  # UpdateCheckMode:Tags bot picks up ordinary tags on its own — this job's
+  # ongoing job is mainly a safety net for now, and the sole mechanism before
+  # that first inclusion exists.
+  #
+  # Deliberately does NOT fail the release if fdroiddata isn't configured yet
+  # (no FDROID_GITLAB_TOKEN secret) — F-Droid isn't wired up until the first
+  # inclusion MR is manually opened and merged; this job just keeps the draft
+  # recipe current in the meantime and does the rest once it is wired up.
+  fdroid:
+    needs: preflight
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false   # nothing here writes to THIS repo
+
+      # Stamp the release's real versionName/versionCode/commit into the
+      # checked-in draft recipe. Plain sed rather than a YAML library: the
+      # three fields each appear in exactly one recognizable spot in the file
+      # (see docs/fdroid/wtf.openstrap.openstrap_edge.yml), and keeping this
+      # a shell one-liner means no extra Python deps for a 3-line edit.
+      - name: Stamp release version into the fdroid recipe
+        run: |
+          set -euo pipefail
+          ver=$(grep -E '^version:' pubspec.yaml | head -1 | awk '{print $2}')
+          name=${ver%%+*}
+          build=${ver#*+}
+          tag="$GITHUB_REF_NAME"
+          f=docs/fdroid/wtf.openstrap.openstrap_edge.yml
+          sed -i \
+            -e "s/^\([[:space:]-]*versionName:[[:space:]]*\).*/\1$name/" \
+            -e "s/^\([[:space:]]*versionCode:[[:space:]]*\).*/\1$build/" \
+            -e "s/^\([[:space:]]*commit:[[:space:]]*\)[^ ]*/\1$tag/" \
+            -e "s/^CurrentVersion:.*/CurrentVersion: $name/" \
+            -e "s/^CurrentVersionCode:.*/CurrentVersionCode: $build/" \
+            "$f"
+          echo "Stamped $f -> versionName=$name versionCode=$build commit=$tag"
+
+      # Push the stamped recipe to a fdroiddata fork and open/update a merge
+      # request, ONLY once that fork + token are configured. Until then this
+      # step just explains what's missing and exits clean — the release
+      # itself must never fail on account of F-Droid plumbing.
+      - name: Sync recipe to fdroiddata fork
+        env:
+          FDROID_GITLAB_TOKEN: ${{ secrets.FDROID_GITLAB_TOKEN }}
+          FDROID_FORK_REPO: ${{ vars.FDROID_FORK_REPO }}   # e.g. https://gitlab.com/yourname/fdroiddata.git
+        run: |
+          set -euo pipefail
+          if [ -z "${FDROID_GITLAB_TOKEN:-}" ] || [ -z "${FDROID_FORK_REPO:-}" ]; then
+            echo "::notice::FDROID_GITLAB_TOKEN / FDROID_FORK_REPO not set — skipping fdroiddata sync."
+            echo "::notice::One-time setup: fork https://gitlab.com/fdroid/fdroiddata, add a GitLab"
+            echo "::notice::personal access token as the FDROID_GITLAB_TOKEN secret and the fork's"
+            echo "::notice::clone URL as the FDROID_FORK_REPO repo variable. Until the first"
+            echo "::notice::inclusion MR is opened and merged by hand, this step has nothing to do."
+            exit 0
+          fi
+
+          branch="update-openstrap-edge-${GITHUB_REF_NAME}"
+          workdir="$RUNNER_TEMP/fdroiddata"
+          repo_url="${FDROID_FORK_REPO/https:\/\//https:\/\/oauth2:${FDROID_GITLAB_TOKEN}@}"
+
+          git clone --depth 1 "$repo_url" "$workdir"
+          cp docs/fdroid/wtf.openstrap.openstrap_edge.yml \
+            "$workdir/metadata/wtf.openstrap.openstrap_edge.yml"
+
+          cd "$workdir"
+          git checkout -b "$branch"
+          git -c user.name="openstrap-release-bot" -c user.email="noreply@openstrap.wtf" \
+            commit -am "wtf.openstrap.openstrap_edge: update to ${GITHUB_REF_NAME}" \
+            --allow-empty -- metadata/wtf.openstrap.openstrap_edge.yml
+          git push -u origin "$branch" \
+            -o merge_request.create \
+            -o merge_request.title="wtf.openstrap.openstrap_edge: update to ${GITHUB_REF_NAME}" \
+            -o merge_request.target=fdroid/fdroiddata
+
   # Unsigned iOS .ipa for sideloading (AltStore / Sideloadly / TrollStore). It is
   # NOT App Store signed — users re-sign it with their own Apple ID on install.
   # Note: free-account sideloads re-sign with a different team id, so App Group

docs/fdroid/barcode_reader.floss.dart

@@ -0,0 +1,98 @@
+// barcode_reader.dart (F-Droid / FLOSS variant) — flutter_zxing-backed
+// stand-in with the exact API of lib/scan/barcode_reader.dart, zero Google
+// dependencies (mobile_scanner's ML Kit pulls play-services-basement/base/
+// tasks on Android either way — checked its build.gradle directly).
+//
+// Not compiled by default. The F-Droid build recipe (see
+// docs/fdroid/wtf.openstrap.openstrap_edge.yml) copies this over
+// lib/scan/barcode_reader.dart and adds flutter_zxing + camera to
+// pubspec.yaml before building. scan_barcode.dart (the only caller) is
+// unaffected — it only ever sees this API.
+//
+// flutter_zxing (pub.dev, 2.3.0, Apache-2.0, pure Dart FFI over the ZXing
+// C++ library via the `camera` plugin — no Google Play Services / ML Kit)
+// verified to cover every format this app scans: Format.ean13/ean8/upca/
+// upce/dataBar/dataBarExpanded all exist (lib/src/models/format.dart).
+// ReaderWidget's error surface is onControllerCreated(controller, error) —
+// a non-null error there is how the underlying `camera` plugin reports
+// camera failures, including permission denial via a CameraException whose
+// `code` is 'CameraAccessDenied' (or 'CameraAccessDeniedWithoutPrompt' on
+// iOS, kept here for API parity though this file only ever ships on
+// Android).
+
+import 'package:camera/camera.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_zxing/flutter_zxing.dart' as zx;
+
+enum BarcodeFormat { ean13, ean8, upcA, upcE, dataBar, dataBarExpanded }
+
+class BarcodeReaderError {
+  const BarcodeReaderError({required this.permissionDenied});
+  final bool permissionDenied;
+}
+
+typedef BarcodeReaderErrorBuilder = Widget Function(BuildContext, BarcodeReaderError);
+
+class BarcodeReaderWidget extends StatefulWidget {
+  const BarcodeReaderWidget({
+    super.key,
+    required this.formats,
+    required this.onDetect,
+    required this.errorBuilder,
+  });
+
+  final List<BarcodeFormat> formats;
+  final ValueChanged<String> onDetect;
+  final BarcodeReaderErrorBuilder errorBuilder;
+
+  @override
+  State<BarcodeReaderWidget> createState() => _BarcodeReaderWidgetState();
+}
+
+class _BarcodeReaderWidgetState extends State<BarcodeReaderWidget> {
+  bool _done = false;
+  BarcodeReaderError? _error;
+
+  static const Map<BarcodeFormat, int> _formatBits = {
+    BarcodeFormat.ean13: zx.Format.ean13,
+    BarcodeFormat.ean8: zx.Format.ean8,
+    BarcodeFormat.upcA: zx.Format.upca,
+    BarcodeFormat.upcE: zx.Format.upce,
+    BarcodeFormat.dataBar: zx.Format.dataBar,
+    BarcodeFormat.dataBarExpanded: zx.Format.dataBarExpanded,
+  };
+
+  int get _codeFormat =>
+      widget.formats.fold(0, (acc, f) => acc | (_formatBits[f] ?? 0));
+
+  void _onScan(zx.Code code) {
+    if (_done || !code.isValid) return;
+    final text = code.text;
+    if (text == null || text.trim().isEmpty) return;
+    _done = true;
+    widget.onDetect(text.trim());
+  }
+
+  void _onControllerCreated(CameraController? controller, Exception? error) {
+    if (error == null) return;
+    final denied = error is CameraException &&
+        (error.code == 'CameraAccessDenied' ||
+            error.code == 'CameraAccessDeniedWithoutPrompt');
+    if (mounted) setState(() => _error = BarcodeReaderError(permissionDenied: denied));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final err = _error;
+    if (err != null) return widget.errorBuilder(context, err);
+    return zx.ReaderWidget(
+      codeFormat: _codeFormat,
+      onScan: _onScan,
+      onControllerCreated: _onControllerCreated,
+      showFlashlight: false,
+      showToggleCamera: false,
+      showGallery: false,
+      allowPinchZoom: false,
+    );
+  }
+}

docs/fdroid/firebase_bridge.floss.dart

@@ -0,0 +1,38 @@
+// firebase_bridge.dart (F-Droid / FLOSS variant) — no-op stand-in with the
+// exact API of lib/telemetry/firebase_bridge.dart, zero firebase_* imports.
+//
+// Not compiled by default. The F-Droid build recipe (see
+// docs/fdroid/wtf.openstrap.openstrap_edge.yml) copies this over
+// lib/telemetry/firebase_bridge.dart and drops the four firebase_* lines
+// from pubspec.yaml before building, so the FLOSS build contains zero
+// Google Play Services / Firebase code. Every caller (telemetry_service.dart,
+// main.dart) is unaffected — they only ever see this API.
+
+import 'package:flutter/foundation.dart';
+
+class FirebaseTraceHandle {
+  const FirebaseTraceHandle._();
+  Future<void> stop() async {}
+  void putAttribute(String name, String value) {}
+}
+
+class FirebaseBridge {
+  static Future<void> initialize({Duration? timeout}) async {}
+
+  static bool get isInitialized => false;
+
+  static void setCollectionEnabled(bool value) {}
+
+  static void recordFlutterError(FlutterErrorDetails details, {required bool fatal}) {}
+
+  static void recordError(Object error, StackTrace stack, {required bool fatal, String? reason}) {}
+
+  static void log(String message) {}
+
+  static void setCustomKey(String key, Object value) {}
+
+  static Future<FirebaseTraceHandle> startTrace(String name) async =>
+      const FirebaseTraceHandle._();
+
+  static void logEvent(String name, Map<String, Object> parameters) {}
+}

docs/fdroid/wtf.openstrap.openstrap_edge.yml

@@ -0,0 +1,117 @@
+# F-Droid build recipe for OpenStrap edge — VERIFIED locally, full combined
+# build (all three patches below applied together): `flutter build apk
+# --release` succeeds, and the resulting APK's classes.dex has zero
+# com/google/firebase and zero com/google/mlkit references. The only
+# remaining com/google/android/gms/* strings are microG's own FOSS
+# reimplementation classes (Apache-2.0, published under that namespace by
+# design so Google-API-compiled code links against them unmodified).
+#
+# This is NOT read by F-Droid from this repo — it's the file to copy into
+# fdroiddata (https://gitlab.com/fdroid/fdroiddata) as
+# metadata/wtf.openstrap.openstrap_edge.yml when opening the inclusion MR.
+# Keeping it here, versioned next to the app it describes.
+#
+# ── FIRST blocker: Firebase ─────────────────────────────────────────────────
+# pubspec.yaml depends on firebase_core/firebase_crashlytics/
+# firebase_performance/firebase_analytics. Firebase is already fully
+# optional at RUNTIME (see lib/telemetry/telemetry_service.dart and
+# android/app/build.gradle.kts — the app builds and runs with zero Firebase
+# credentials), but F-Droid rejects apps that bundle the Play Services /
+# Firebase Android libraries at all, used or not.
+#
+# Fix landed in this repo: every firebase_* import is confined to ONE file,
+# lib/telemetry/firebase_bridge.dart (see its header comment). A FLOSS-build
+# stand-in with the identical API and zero firebase_* imports lives at
+# docs/fdroid/firebase_bridge.floss.dart. The recipe just swaps that one file
+# and drops the four firebase_* pubspec lines — no other source edits
+# needed, so it survives future changes to telemetry_service.dart without
+# hand-patching call sites.
+#
+# ── SECOND blocker: geolocator's GMS location backend ───────────────────────
+# geolocator_android pulls com.google.android.gms:play-services-location
+# (used for GPS workout routes). Verified in its actual source
+# (GeolocationManager.java:72-88, geolocator_android 4.6.2): it already falls
+# back to plain android.location.LocationManager whenever Google Play
+# Services isn't available, via the SAME com.google.android.gms.location.*
+# package/class names either way. That's exactly what microG's FOSS
+# reimplementation (org.microg.gms:play-services-location, Apache-2.0)
+# ships, so a Gradle dependency substitution swaps it in with ZERO Dart/
+# Kotlin source changes — same technique used by organicmaps' F-Droid flavor
+# (github.com/organicmaps/organicmaps PR #9575). Appended to
+# android/app/build.gradle.kts by the recipe, not a permanent change to this
+# repo's checked-in file — the Play Store / GitHub-release build keeps
+# Google's real fused location provider. Must substitute the whole
+# basement/base/tasks family, not just play-services-location, or anything
+# else in the graph still pulling the real ones causes a duplicate-class
+# build failure (hit this locally before adding mobile_scanner's fix below —
+# see THIRD item).
+#
+# ── THIRD blocker: mobile_scanner's ML Kit ───────────────────────────────────
+# mobile_scanner (food barcode scan) bundles Google ML Kit on Android either
+# way — checked its build.gradle directly: both the bundled
+# com.google.mlkit:barcode-scanning and the useUnbundled
+# play-services-mlkit-barcode-scanning paths pull the REAL
+# com.google.android.gms:play-services-basement/base/tasks, which is also
+# what caused the SECOND item's duplicate-class conflict until this was
+# fixed. No Gradle-only escape hatch exists for ML Kit itself (unlike
+# geolocator, whose own code already had a non-GMS fallback path).
+#
+# Fix landed in this repo: every mobile_scanner import is confined to ONE
+# file, lib/scan/barcode_reader.dart (see its header comment) — same seam
+# pattern as firebase_bridge.dart. A FLOSS-build stand-in backed by
+# flutter_zxing (pub.dev, Apache-2.0, pure Dart FFI over the ZXing C++
+# library, zero Google dependencies) with the identical API lives at
+# docs/fdroid/barcode_reader.floss.dart. Verified to cover every barcode
+# format this app scans (EAN13/EAN8/UPC-A/UPC-E/DataBar/DataBarExpanded —
+# checked flutter_zxing's Format enum directly) and to build clean alongside
+# both fixes above. iOS and the Play Store / GitHub-release Android build
+# keep mobile_scanner unchanged; F-Droid never builds iOS at all.
+
+Categories:
+  - Health
+License: MIT
+SourceCode: https://github.com/OpenStrap/edge
+IssueTracker: https://github.com/OpenStrap/edge/issues
+
+AutoName: OpenStrap
+
+RepoType: git
+Repo: https://github.com/OpenStrap/edge.git
+
+Builds:
+  - versionName: 0.9.29
+    versionCode: 62
+    commit: v0.9.29           # TODO: tag this release before submitting
+    subdir: android
+    sudo:
+      # Firebase → no-op stub (see FIRST blocker above).
+      - cp docs/fdroid/firebase_bridge.floss.dart lib/telemetry/firebase_bridge.dart
+      - sed -i '/^[[:space:]]*firebase_core:/d;/^[[:space:]]*firebase_crashlytics:/d;/^[[:space:]]*firebase_performance:/d;/^[[:space:]]*firebase_analytics:/d' pubspec.yaml
+      - rm -f app/google-services.json
+      # Barcode scanner → flutter_zxing (see THIRD blocker above). Must run
+      # BEFORE the geolocator substitution below, or the real
+      # play-services-basement/base/tasks mobile_scanner still pulls in
+      # duplicates microG's substituted classes.
+      - cp docs/fdroid/barcode_reader.floss.dart lib/scan/barcode_reader.dart
+      - |
+        sed -i "s/^\([[:space:]]*mobile_scanner:.*\)/\1\n  flutter_zxing: ^2.3.0\n  camera: ^0.11.0/" pubspec.yaml
+      - sed -i '/^[[:space:]]*mobile_scanner:/d' pubspec.yaml
+      # geolocator's GMS location backend → microG (see SECOND blocker above).
+      - |
+        cat >> app/build.gradle.kts <<'EOF'
+        configurations.all {
+            resolutionStrategy.dependencySubstitution {
+                val microg = "0.3.14.250932"
+                substitute(module("com.google.android.gms:play-services-location")).using(module("org.microg.gms:play-services-location:$microg"))
+                substitute(module("com.google.android.gms:play-services-base")).using(module("org.microg.gms:play-services-base:$microg"))
+                substitute(module("com.google.android.gms:play-services-basement")).using(module("org.microg.gms:play-services-basement:$microg"))
+                substitute(module("com.google.android.gms:play-services-tasks")).using(module("org.microg.gms:play-services-tasks:$microg"))
+            }
+        }
+        EOF
+    output: app/build/outputs/apk/release/app-release-unsigned.apk
+
+AutoUpdateMode: Version
+UpdateCheckMode: Tags
+CurrentVersion: 0.9.29
+CurrentVersionCode: 62

lib/compute/derivation_engine.dart

@@ -31,13 +31,12 @@ import 'package:flutter/foundation.dart';
 import 'findings.dart';
 import 'nap_edits.dart';
 import 'package:openstrap_analytics/onehz.dart' as ana;
-import 'package:firebase_core/firebase_core.dart';
-import 'package:firebase_performance/firebase_performance.dart';
 
 import '../data/db.dart';
 import '../data/day_label.dart';
 import '../data/series_codec.dart';
 import '../notify/fired_keys.dart';
+import '../telemetry/firebase_bridge.dart';
 import '../notify/notification_center.dart';
 import '../notify/notification_event.dart';
 import '../notify/tap_router.dart' show workoutSuggestionRoute;
@@ -2190,15 +2189,14 @@ class DerivationEngine {
       ..['concurrency'] = _deriveConcurrency
       ..['last_error'] = null;
 
-    Trace? runTrace;
+    FirebaseTraceHandle? runTrace;
     try {
       // Heavy/force passes only. Light passes run many times a day (including
       // all night in the background), and each trace is buffered + eventually
       // uploaded — periodic radio wakeups from a local-first app, for timings
       // the _diag map already captures locally.
-      if (Firebase.apps.isNotEmpty && (heavy || force)) {
-        runTrace = FirebasePerformance.instance.newTrace('derivation_engine_run');
-        await runTrace.start();
+      if (FirebaseBridge.isInitialized && (heavy || force)) {
+        runTrace = await FirebaseBridge.startTrace('derivation_engine_run');
         runTrace.putAttribute('mode', force ? 'force' : (heavy ? 'heavy' : 'light'));
       }
     } catch (_) {}