fluxota_sdk 0.1.0-dev.4

Signed Dart over-the-air updates for Android Flutter apps, with startup health checks and automatic recovery.

Fluxota SDK

Signed Dart over-the-air updates for Android Flutter applications. The SDK checks signed metadata and artifact integrity, prepares compatible updates, activates them at the next process startup, and tracks startup health for recovery.

Development preview: 0.1.0-dev.4. The qualified profile is Flutter 3.35.7 / Dart 3.9.2, Android arm64-v8a, Android API24 or later, and the standard single-activity Flutter host. Historical device acceptance covered the implementation under its former Tessaviko identity on a Samsung SM-A165F with Android16/API36. The renamed Fluxota reference and other device/OS combinations require their own acceptance.

Installation

dependencies:
  fluxota_sdk: 0.1.0-dev.4

Run flutter pub get and commit your application's pubspec.lock. Android builds require compileSdk36. The plugin is Android-only.

Configure an application

The SDK works with a Fluxota API deployment, the Fluxota CLI, and an exact reference build. The CLI and server are distributed separately for the developer pilot. Access to this package alone does not provision an update service.

Use the CLI to bind your project and configure its Android host:

fluxota init --organization "$ORGANIZATION_ID" --application "$APPLICATION_ID" \
  --api-url https://api.example.com
fluxota sdk configure --public-key-spki /private/path/patch.public.spki.der

init uses an access token in FLUXOTA_ACCESS_TOKEN. sdk configure prepares the public assets and converts a supported standard MainActivity to FluxotaActivity. Only the public SPKI belongs in the app. Keep the private patch-signing key outside the project and separate from the Android/store key. See integration and reference builds.

Startup health and updates

import 'dart:async';
import 'package:flutter/widgets.dart';
import 'package:fluxota_sdk/fluxota_sdk.dart';

void main() {
  final binding = WidgetsFlutterBinding.ensureInitialized();
  final updater = FluxotaUpdater();
  runApp(const MyApp());
  unawaited(binding.waitUntilFirstFrameRasterized.then((_) async {
    try {
      // Also run the application's own health checks before confirming.
      await updater.markHealthy();
      await updater.checkForUpdate();
    } on FluxotaUpdateException {
      // Keep the app usable and retry at a later suitable opportunity.
    }
  }));
}

The snippet assumes your MyApp widget. A prepared update becomes available at the next cold start. checkForUpdate does not replace code in the running VM. The baseline confirms no patch. Confirm health after the first frame and the application's required startup checks; unconfirmed candidates retain recovery protection. A server retirement takes effect after the app receives that state.

The package also exposes FluxotaManifestVerifier, FluxotaUpdateStatus, UpdateCheckOutcome and typed failure categories. See the complete Flutter usage example.

Compatibility and distribution

Reference builds and patches must use the same pinned Flutter toolchain and compatible native inputs. Changes to the engine, native code, permissions, locked dependencies, assets or signing root require a new APK/store reference. The developer pilot currently uses the test update channel.

Historical local APK and App Bundle split delivery have been tested. A fresh Fluxota reference requires a new device acceptance run. An OTA acceptance run on an actual Google Play test track remains required before claiming that particular distribution is qualified. iOS and custom/prewarmed Flutter hosts are outside this preview's qualified profile.

License

BSD-3-Clause; see LICENSE. Original generated-binding notices are in THIRD_PARTY_NOTICES.