@_nazmiforreal/flutter-ota 0.1.26 → 0.1.28

package/dart-src/root/lib/src/pack/pack.dart

@@ -0,0 +1,434 @@
+import 'dart:convert';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:archive/archive.dart';
+import 'package:crypto/crypto.dart';
+
+const List<String> abiPriority = <String>['arm64-v8a', 'armeabi-v7a', 'x86_64'];
+const String flutterAssetsPrefix = 'assets/flutter_assets/';
+const String assetManifestPath = '${flutterAssetsPrefix}AssetManifest.bin';
+
+/// Result of a successful [packPatch] run.
+class PackResult {
+  const PackResult({
+    required this.payloadPath,
+    required this.manifestPath,
+    required this.abis,
+    required this.md5,
+    required this.version,
+    required this.targetVersionCode,
+    required this.assetCount,
+  });
+
+  final String payloadPath;
+  final String manifestPath;
+  final List<String> abis;
+  final String md5;
+  final String version;
+  final int targetVersionCode;
+  final int assetCount;
+}
+
+/// Pack a release APK into a device-compatible OTA patch (`patch.zip`).
+///
+/// Mirrors the standalone `bin/pack.dart` CLI, but as a library usable by the
+/// `flutter_ota_kit build` command. Includes **every** ABI found in the APK so
+/// a single bundle serves all device ABIs (the device SDK picks its ABI).
+Future<PackResult> packPatch({
+  required String apkPath,
+  required String version,
+  required int targetVersionCode,
+  String? abi,
+  List<String> requestedAssets = const [],
+  required String out,
+  void Function(int done, int total, String label)? onProgress,
+}) async {
+  final apkFile = File(apkPath);
+  if (!apkFile.existsSync()) {
+    throw PackException('APK not found: $apkPath');
+  }
+
+  final apkBytes = apkFile.readAsBytesSync();
+  final archive = ZipDecoder().decodeBytes(apkBytes);
+
+  final libs = _collectLibapps(archive);
+  if (libs.isEmpty) {
+    throw PackException(
+      'libapp.so not found in APK for any of $abiPriority '
+      '(or requested --abi $abi).',
+    );
+  }
+
+  if (abi != null && !libs.any((e) => e.$1 == abi)) {
+    throw PackException('requested --abi $abi not present in APK.');
+  }
+
+  final outDir = Directory(out);
+  outDir.createSync(recursive: true);
+  final result = _writePatchPackage(
+    outDir: outDir,
+    archive: archive,
+    libs: libs,
+    version: version,
+    targetVersionCode: targetVersionCode,
+    requestedAssets: requestedAssets,
+    abi: abi,
+    onProgress: onProgress,
+  );
+  return result;
+}
+
+PackResult _writePatchPackage({
+  required Directory outDir,
+  required Archive archive,
+  required List<(String, List<int>)> libs,
+  required String version,
+  required int targetVersionCode,
+  required List<String> requestedAssets,
+  String? abi,
+  void Function(int done, int total, String label)? onProgress,
+}) {
+  // When an ABI is requested, restrict the patch to only that ABI instead of
+  // shipping every architecture found in the APK.
+  final effectiveLibs = abi == null
+      ? libs
+      : libs.where((e) => e.$1 == abi).toList();
+  final patchFiles = <String, _PatchAssetFile>{};
+  final operations = <Map<String, dynamic>>[];
+  var baseManifestSize = 0;
+
+  if (requestedAssets.isNotEmpty) {
+    final manifestEntry = _findFile(archive, assetManifestPath);
+    if (manifestEntry == null) {
+      throw PackException(
+        'AssetManifest.bin not found in APK: $assetManifestPath',
+      );
+    }
+    final manifestBytes = _archiveFileBytes(manifestEntry);
+    baseManifestSize = manifestBytes.length;
+    final decoded = _FlutterStandardMessageCodec().decode(manifestBytes);
+    if (decoded is! Map) {
+      throw PackException('AssetManifest.bin must decode to a map.');
+    }
+    final assetManifest = Map<String, dynamic>.from(decoded);
+
+    for (final key in requestedAssets) {
+      final variantsRaw = assetManifest[key];
+      if (variantsRaw is! List) {
+        throw PackException('asset key not found in AssetManifest.bin: $key');
+      }
+      final variants = variantsRaw
+          .map((variant) => Map<String, dynamic>.from(variant as Map))
+          .toList(growable: false);
+      operations.add({'op': 'upsert', 'key': key, 'variants': variants});
+      for (final variant in variants) {
+        final assetPath = variant['asset'];
+        if (assetPath is! String || assetPath.isEmpty) {
+          throw PackException('invalid variant asset for key $key');
+        }
+        _validateArchiveRelativePath(assetPath, 'asset path');
+        final apkPath = '$flutterAssetsPrefix$assetPath';
+        final entry = _findFile(archive, apkPath);
+        if (entry == null) {
+          throw PackException(
+            'variant file for $key not found in APK: $apkPath',
+          );
+        }
+        final bytes = _archiveFileBytes(entry);
+        patchFiles[assetPath] = _PatchAssetFile(
+          path: assetPath,
+          bytes: bytes,
+          md5Hex: md5.convert(bytes).toString(),
+        );
+      }
+    }
+  }
+
+  final libManifest = <String, dynamic>{
+    for (final (currentAbi, soBytes) in effectiveLibs)
+      currentAbi: {
+        'path': 'lib/$currentAbi/libapp.so',
+        'md5': md5.convert(soBytes).toString(),
+      },
+  };
+
+  final zipManifest = <String, dynamic>{
+    'schemaVersion': 2,
+    'version': version,
+    'targetVersionCode': targetVersionCode,
+    'lib': libManifest,
+    if (requestedAssets.isNotEmpty)
+      'assets': {
+        'mode': 'overlay',
+        'manifestPatch': 'manifest_patch.json',
+        'prefix': 'assets/',
+        'files': patchFiles.values
+            .map(
+              (file) => {
+                'path': file.path,
+                'md5': file.md5Hex,
+                'size': file.bytes.length,
+              },
+            )
+            .toList(),
+      },
+  };
+
+  final package = Archive()
+    ..addFile(_jsonArchiveFile('manifest.json', zipManifest));
+  final progressTotal = effectiveLibs.length + 1;
+  onProgress?.call(0, progressTotal, 'libapp.so');
+  var progressDone = 0;
+  for (final (currentAbi, soBytes) in effectiveLibs) {
+    package.addFile(
+      ArchiveFile('lib/$currentAbi/libapp.so', soBytes.length, soBytes),
+    );
+    progressDone++;
+    onProgress?.call(progressDone, progressTotal, 'lib/$currentAbi/libapp.so');
+  }
+
+  if (requestedAssets.isNotEmpty) {
+    final manifestPatch = <String, dynamic>{
+      'schemaVersion': 1,
+      'manifestFormat': 'bin',
+      'baseManifestSize': baseManifestSize,
+      'operations': operations,
+    };
+    package.addFile(_jsonArchiveFile('manifest_patch.json', manifestPatch));
+    for (final file in patchFiles.values) {
+      package.addFile(
+        ArchiveFile('assets/${file.path}', file.bytes.length, file.bytes),
+      );
+    }
+  }
+
+  // archive 3.x returns List<int>?, 4.x returns List<int>; drop the null-coalesce
+  // because we resolve archive >= 4 in the lockfile (and the constraint below).
+  final List<int> packageBytes = ZipEncoder().encode(package);
+  final outZip = File('${outDir.path}/patch.zip');
+  outZip.writeAsBytesSync(packageBytes);
+  onProgress?.call(progressTotal, progressTotal, 'patch.zip');
+
+  final payloadMd5 = md5.convert(packageBytes).toString();
+  final outerManifest = <String, dynamic>{
+    'schemaVersion': 2,
+    'version': version,
+    'md5': payloadMd5,
+    'targetVersionCode': targetVersionCode,
+    'abis': effectiveLibs.map((e) => e.$1).toList(),
+    'payload': 'patch.zip',
+  };
+  _writeJson(File('${outDir.path}/manifest.json'), outerManifest);
+
+  return PackResult(
+    payloadPath: outZip.path,
+    manifestPath: '${outDir.path}/manifest.json',
+    abis: effectiveLibs.map((e) => e.$1).toList(),
+    md5: payloadMd5,
+    version: version,
+    targetVersionCode: targetVersionCode,
+    assetCount: patchFiles.length,
+  );
+}
+
+ArchiveFile _jsonArchiveFile(String name, Map<String, dynamic> json) {
+  final bytes = utf8.encode(
+    '${const JsonEncoder.withIndent('  ').convert(json)}\n',
+  );
+  return ArchiveFile(name, bytes.length, bytes);
+}
+
+/// Collect every `lib/<abi>/libapp.so` present in the APK.
+List<(String, List<int>)> _collectLibapps(Archive archive) {
+  final found = <(String, List<int>)>[];
+  final seen = <String>{};
+  final regex = RegExp(r'^lib/([^/]+)/libapp\.so$');
+  for (final file in archive.files) {
+    final m = regex.firstMatch(file.name);
+    if (m != null && seen.add(m.group(1)!)) {
+      found.add((m.group(1)!, _archiveFileBytes(file)));
+    }
+  }
+  found.sort((a, b) {
+    final ia = abiPriority.indexOf(a.$1);
+    final ib = abiPriority.indexOf(b.$1);
+    final ra = ia < 0 ? _nonPriorityRank(a.$1) : ia;
+    final rb = ib < 0 ? _nonPriorityRank(b.$1) : ib;
+    return ra.compareTo(rb);
+  });
+  return found;
+}
+
+int _nonPriorityRank(String abi) => abiPriority.length;
+
+ArchiveFile? _findFile(Archive archive, String name) {
+  for (final file in archive.files) {
+    if (!file.isFile) continue;
+    if (file.name == name) return file;
+  }
+  return null;
+}
+
+void _writeJson(File file, Map<String, dynamic> json) {
+  file.writeAsStringSync(
+    '${const JsonEncoder.withIndent('  ').convert(json)}\n',
+  );
+}
+
+void _validateArchiveRelativePath(String path, String label) {
+  if (path.isEmpty ||
+      path.startsWith('/') ||
+      path.startsWith('\\') ||
+      path.contains('\u0000') ||
+      path.split('/').contains('..')) {
+    throw PackException('invalid $label: $path');
+  }
+}
+
+List<int> _archiveFileBytes(ArchiveFile file) {
+  final dynamic dynamicFile = file;
+  try {
+    return List<int>.from(dynamicFile.readBytes() as List<int>);
+  } on NoSuchMethodError {
+    return List<int>.from(dynamicFile.content as List<int>);
+  }
+}
+
+class _PatchAssetFile {
+  const _PatchAssetFile({
+    required this.path,
+    required this.bytes,
+    required this.md5Hex,
+  });
+
+  final String path;
+  final List<int> bytes;
+  final String md5Hex;
+}
+
+/// Error carrying a stable CLI exit code.
+class PackException implements Exception {
+  const PackException(this.message, [this.exitCode = 1]);
+
+  final String message;
+  final int exitCode;
+}
+
+class _FlutterStandardMessageCodec {
+  late ByteData _data;
+  late int _offset;
+
+  Object? decode(List<int> bytes) {
+    final list = Uint8List.fromList(bytes);
+    _data = ByteData.sublistView(list);
+    _offset = 0;
+    final value = _readValue();
+    if (_offset != _data.lengthInBytes) {
+      throw PackException('AssetManifest.bin has trailing bytes.');
+    }
+    return value;
+  }
+
+  Object? _readValue() {
+    final type = _readUint8();
+    switch (type) {
+      case 0:
+        return null;
+      case 1:
+        return true;
+      case 2:
+        return false;
+      case 3:
+        return _readInt32();
+      case 4:
+        return _readInt64();
+      case 6:
+        _alignTo(8);
+        return _readFloat64();
+      case 7:
+        final len = _readSize();
+        final bytes = _readBytes(len);
+        return utf8.decode(bytes);
+      case 12:
+        final len = _readSize();
+        return List<Object?>.generate(len, (_) => _readValue());
+      case 13:
+        final len = _readSize();
+        final map = <Object?, Object?>{};
+        for (var i = 0; i < len; i++) {
+          map[_readValue()] = _readValue();
+        }
+        return map;
+      default:
+        throw PackException(
+          'unsupported StandardMessageCodec type in AssetManifest.bin: $type',
+        );
+    }
+  }
+
+  int _readSize() {
+    final first = _readUint8();
+    if (first < 254) return first;
+    if (first == 254) return _readUint16();
+    return _readUint32();
+  }
+
+  int _readUint8() {
+    _ensure(1);
+    return _data.getUint8(_offset++);
+  }
+
+  int _readUint16() {
+    _ensure(2);
+    final value = _data.getUint16(_offset, Endian.little);
+    _offset += 2;
+    return value;
+  }
+
+  int _readUint32() {
+    _ensure(4);
+    final value = _data.getUint32(_offset, Endian.little);
+    _offset += 4;
+    return value;
+  }
+
+  int _readInt32() {
+    _ensure(4);
+    final value = _data.getInt32(_offset, Endian.little);
+    _offset += 4;
+    return value;
+  }
+
+  int _readInt64() {
+    _ensure(8);
+    final value = _data.getInt64(_offset, Endian.little);
+    _offset += 8;
+    return value;
+  }
+
+  double _readFloat64() {
+    _ensure(8);
+    final value = _data.getFloat64(_offset, Endian.little);
+    _offset += 8;
+    return value;
+  }
+
+  Uint8List _readBytes(int length) {
+    _ensure(length);
+    final start = _offset;
+    _offset += length;
+    return _data.buffer.asUint8List(start, length);
+  }
+
+  void _alignTo(int alignment) {
+    final mod = _offset % alignment;
+    if (mod != 0) _offset += alignment - mod;
+  }
+
+  void _ensure(int length) {
+    if (_offset + length > _data.lengthInBytes) {
+      throw PackException('truncated AssetManifest.bin');
+    }
+  }
+}

package/dart-src/root/lib/src/patch_info.dart

@@ -0,0 +1,12 @@
+// Re-exported from `flutter_ota_kit_core` (the canonical, framework-agnostic
+// home for the data model). The device SDK previously defined these here; they
+// now live in core so the server client can produce `PatchInfo` without pulling
+// in the Flutter plugin.
+export 'package:flutter_ota_kit/src/pkg/core/flutter_ota_kit_core.dart'
+    show
+        PatchApplyError,
+        PatchApplyPhase,
+        PatchApplyProgress,
+        PatchApplyResult,
+        PatchCheckResult,
+        PatchInfo;

package/dart-src/root/lib/src/patcher_channel.dart

@@ -0,0 +1,160 @@
+import 'package:flutter/services.dart';
+import 'package:restart_app/restart_app.dart';
+
+/// MethodChannel constants and thin wrappers for talking to the Android native layer.
+class PatcherChannel {
+  PatcherChannel._();
+
+  static const MethodChannel channel = MethodChannel('flutter_ota_kit');
+
+  /// Persists the Dart-side config to native (SharedPreferences). On the next cold
+  /// start the native side reads this config during `Application.attachBaseContext`
+  /// to verify signatures and load the patch.
+  static Future<void> saveConfig({
+    required String publicKeyBase64,
+    required int maxCrashCount,
+    required bool strictSignature,
+    required List<String> loaderFieldCandidates,
+    required bool loaderFallbackHeuristic,
+    int maxPatchHistory = 4,
+    int maxAssetHistory = 4,
+  }) async {
+    await channel.invokeMethod<void>('saveConfig', {
+      'publicKeyBase64': publicKeyBase64,
+      'maxCrashCount': maxCrashCount,
+      'strictSignature': strictSignature,
+      'loaderFieldCandidates': loaderFieldCandidates,
+      'loaderFallbackHeuristic': loaderFallbackHeuristic,
+      'maxPatchHistory': maxPatchHistory,
+      'maxAssetHistory': maxAssetHistory,
+    });
+  }
+
+  /// Called at the very start of Dart `init`: marks "booting" (it cross-checks the
+  /// native `attachBaseContext` marker as a safety net).
+  static Future<void> markBooting() async {
+    await channel.invokeMethod<void>('markBooting');
+  }
+
+  /// Called after the first Dart frame renders -> resets the circuit-breaker counter.
+  static Future<void> reportBootSuccess() async {
+    await channel.invokeMethod<void>('reportBootSuccess');
+  }
+
+  /// Reports an uncaught Dart exception during the boot phase. The native side treats
+  /// it like an `ApplicationExitInfo` REASON_CRASH: `crash_count += 1`, and once the
+  /// threshold is reached it trips the circuit breaker, deletes the patch, and
+  /// blacklists it.
+  ///
+  /// When called: only inside the "verifyAfter window" (between the first frame
+  /// rendering and `verifyAfter` seconds later), triggered by the
+  /// `PlatformDispatcher.onError` / `FlutterError.onError` hooks installed by
+  /// `FlutterPatcher.init`. Business exceptions after the window closes do not call
+  /// this method.
+  static Future<void> reportDartBootError(String message) async {
+    await channel.invokeMethod<void>('reportDartBootError', {
+      'message': message,
+    });
+  }
+
+  /// Download + verify signature + write atomically (atomic swap). Takes effect on
+  /// the next cold start.
+  ///
+  /// The native side returns `Map{ok, error, message}`, deserialized by the caller
+  /// via `PatchApplyResult.fromNative`.
+  static Future<Object?> applyPatch(Map<String, dynamic> patch) async {
+    return channel.invokeMethod<Object?>('applyPatch', patch);
+  }
+
+  /// Deletes the current patch + resets the circuit-breaker flag.
+  static Future<void> rollback() async {
+    await channel.invokeMethod<void>('rollback');
+  }
+
+  /// Rolls back to the immediately previous patch in local history.
+  /// Returns the RollbackOutcome enum name as string.
+  static Future<String> rollbackToPrevious() async {
+    final result = await channel.invokeMethod<String>('rollbackToPrevious');
+    return result ?? 'FALLBACK_TO_BASE';
+  }
+
+  /// The currently installed patch version (null / empty when none installed).
+  static Future<String?> currentVersion() async {
+    return channel.invokeMethod<String>('currentVersion');
+  }
+
+  /// Diagnostics from the last cold-start patch load.
+  ///
+  /// The native side returns `Map?` (see `BootDiagnosticStore`), deserialized by the
+  /// caller via `PatchBootDiagnostic.fromNative`; `null` means it was never recorded.
+  static Future<Map<dynamic, dynamic>?> lastBootDiagnostic() async {
+    return channel.invokeMethod<Map<dynamic, dynamic>?>('lastBootDiagnostic');
+  }
+
+  /// Absolute path to a plugin-writable cache directory, used for internal staging by
+  /// `applyPatchBytes`. Isolated from the existing `PatchManager.patchDir` (one is
+  /// temporary staging, the other is the final patch).
+  static Future<String?> cacheDir() async {
+    return channel.invokeMethod<String>('cacheDir');
+  }
+
+  /// The host APK's versionCode (uses `longVersionCode` on API 28+). The native side
+  /// returns -1 (INVALID_VERSION_CODE) on failure.
+  static Future<int?> appVersionCode() async {
+    final v = await channel.invokeMethod<int>('appVersionCode');
+    if (v == null || v < 0) return null;
+    return v;
+  }
+
+  /// The device's preferred ABI, so the server can serve ABI-specific patches.
+  static Future<String?> deviceAbi() async {
+    return channel.invokeMethod<String>('deviceAbi');
+  }
+
+  /// The local blacklist of patches known to "crash on install". The native side
+  /// returns `List<Map>`, deserialized by the caller via `BlacklistEntry.fromNative`.
+  static Future<List<dynamic>?> blacklist() async {
+    return channel.invokeMethod<List<dynamic>>('blacklist');
+  }
+
+  /// Clears the blacklist. Use with care: normally only called during debugging.
+  static Future<void> clearBlacklist() async {
+    await channel.invokeMethod<void>('clearBlacklist');
+  }
+
+  /// Reports a failed patch apply to the native blacklist. The patch will be
+  /// skipped on future attempts.
+  static Future<void> reportApplyFailure({
+    required String version,
+    required String md5,
+    String reason = 'APPLY_FAILED',
+  }) async {
+    await channel.invokeMethod<void>('reportApplyFailure', {
+      'version': version,
+      'md5': md5,
+      'reason': reason,
+    });
+  }
+
+  /// Checks whether a patch version (optionally with md5) is blacklisted.
+  static Future<bool> isVersionBlacklisted(String version, {String md5 = ''}) async {
+    final found = await channel.invokeMethod<bool>('isVersionBlacklisted', {
+      'version': version,
+      'md5': md5,
+    });
+    return found ?? false;
+  }
+
+  /// Immediately restarts the whole App process (so a forced update takes effect).
+  ///
+  /// Uses the `restart_app` package with [RestartMode.process], which on Android
+  /// starts a fresh launch activity and then terminates the current process
+  /// (`exit(0)`). This true cold restart is required so the patched `libapp.so`
+  /// and assets are reloaded on the next launch. Without the process kill, only
+  /// the Flutter engine would be recreated with the old, already-mapped library.
+  ///
+  /// On non-Android this is a no-op handled upstream by `FlutterPatcher.restart`.
+  static Future<void> restartApp() async {
+    await Restart.restartApp(mode: RestartMode.process);
+  }
+}

package/dart-src/{plugins/aws/lib → root/lib/src/pkg/aws}/src/aws_database.dart

@@ -1,6 +1,6 @@
 import 'dart:convert' show jsonDecode, jsonEncode, utf8;
 
-import 'package:flutter_ota_kit_plugin_core/flutter_ota_kit_plugin_core.dart'
+import 'package:flutter_ota_kit/src/pkg/plugin_core/flutter_ota_kit_plugin_core.dart'
     show BlobOperations, createBlobDatabasePlugin, updateJsonKeyRegex;
 
 import 'aws_cloudfront_client.dart'

package/dart-src/{plugins/aws/lib → root/lib/src/pkg/aws}/src/aws_s3_client.dart

@@ -3,7 +3,7 @@ import 'dart:io' show File;
 import 'dart:typed_data' show Uint8List;
 
 import 'package:crypto/crypto.dart' show Hmac, sha256;
-import 'package:flutter_ota_kit_plugin_core/flutter_ota_kit_plugin_core.dart'
+import 'package:flutter_ota_kit/src/pkg/plugin_core/flutter_ota_kit_plugin_core.dart'
     show StorageObject;
 import 'package:http/http.dart' show Client, Request, Response;
 

package/dart-src/{plugins/aws/lib → root/lib/src/pkg/aws}/src/aws_storage.dart

@@ -1,4 +1,4 @@
-import 'package:flutter_ota_kit_plugin_core/flutter_ota_kit_plugin_core.dart'
+import 'package:flutter_ota_kit/src/pkg/plugin_core/flutter_ota_kit_plugin_core.dart'
     show createUniversalStoragePlugin;
 
 import 'aws_config.dart' show AwsS3StorageConfig;

package/dart-src/{plugins/aws/lib → root/lib/src/pkg/aws}/src/aws_storage_profile.dart

@@ -1,6 +1,6 @@
 import 'package:path/path.dart' show basename;
 
-import 'package:flutter_ota_kit_plugin_core/flutter_ota_kit_plugin_core.dart'
+import 'package:flutter_ota_kit/src/pkg/plugin_core/flutter_ota_kit_plugin_core.dart'
     show
         NodeStorageProfile,
         RuntimeStorageProfile,

package/dart-src/{plugins/aws/lib → root/lib/src/pkg/aws}/src/with_cloudfront_signed_url.dart

@@ -1,4 +1,4 @@
-import 'package:flutter_ota_kit_plugin_core/flutter_ota_kit_plugin_core.dart'
+import 'package:flutter_ota_kit/src/pkg/plugin_core/flutter_ota_kit_plugin_core.dart'
     show RuntimeStorageProfile, StoragePlugin, StoragePluginProfiles;
 
 import 'aws_cloudfront_signer.dart' show cloudfrontSignedUrl;

package/dart-src/root/lib/src/pkg/client/flutter_ota_kit_client.dart

@@ -0,0 +1 @@
+export 'src/server_update_source.dart';