@_nazmiforreal/flutter-ota 0.1.27 → 0.1.29

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

@@ -30,6 +30,10 @@ class OtaOverlayState {
   final List<LogLine> logs;
   final bool canRetry;
 
+  /// True once the patch is installed and the app is about to cold-restart.
+  /// Drives the final "restarting" phase label + the completed steps list.
+  final bool restarting;
+
   /// Which step index is currently active (0-based). Steps that are done
   /// get a check; the active step gets the braille spinner.
   final int activeStep;
@@ -53,6 +57,7 @@ class OtaOverlayState {
     this.totalBytes = 0,
     this.logs = const [],
     this.canRetry = false,
+    this.restarting = false,
     this.activeStep = 0,
   });
 
@@ -74,6 +79,7 @@ class OtaOverlayState {
     int? totalBytes,
     List<LogLine>? logs,
     bool? canRetry,
+    bool? restarting,
     int? activeStep,
   }) {
     return OtaOverlayState(
@@ -95,6 +101,7 @@ class OtaOverlayState {
       totalBytes: totalBytes ?? this.totalBytes,
       logs: logs ?? this.logs,
       canRetry: canRetry ?? this.canRetry,
+      restarting: restarting ?? this.restarting,
       activeStep: activeStep ?? this.activeStep,
     );
   }
@@ -162,7 +169,7 @@ const Map<String, Color> _logColors = {
 ///  - Title bar (traffic lights + status pill)
 ///  - META (channel / version / bundle / size)
 ///  - STEPS (per-phase status list)
-///  - PROGRESS (monospace bar + speed / eta / phase)
+///  - PROGRESS (single-line determinate bar + percent)
 ///  - LOG (scrolling colored feed)
 ///  - Footer (deploy message, or error hint + retry)
 class OtaProgressOverlay extends StatefulWidget {
@@ -341,14 +348,21 @@ class _OtaProgressOverlayState extends State<OtaProgressOverlay> {
   // ── STEPS ─────────────────────────────────────────────────────────────
   Widget _stepsBlock(OtaOverlayState s) {
     final spinner = _braille[_spinnerIndex];
+    // When restarting, every step is complete. Otherwise the active index is
+    // clamped into range so an out-of-bounds activeStep can never leave the
+    // list looking stuck or skip the visible progression.
+    final int activeIndex = s.restarting
+        ? _stepLabels.length
+        : s.activeStep.clamp(0, _stepLabels.length - 1);
+
     return _panelBox(
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.start,
         children: List.generate(_stepLabels.length, (i) {
-          final done = i < s.activeStep;
-          final active = i == s.activeStep && !s.hasError;
-          final failed = i == s.activeStep && s.hasError;
-          final pending = i > s.activeStep;
+          final done = i < activeIndex;
+          final active = i == activeIndex && !s.hasError && !s.restarting;
+          final failed = i == activeIndex && s.hasError;
+          final pending = i > activeIndex;
 
           final Color color = failed
               ? _C.red
@@ -366,13 +380,22 @@ class _OtaProgressOverlayState extends State<OtaProgressOverlay> {
                       ? spinner
                       : '·';
 
-          final String status = failed
-              ? 'error'
-              : done
-                  ? 'done'
-                  : active
-                      ? _pct(s.fraction)
-                      : 'wait';
+          // Only the downloading step shows a percentage. Verify / install /
+          // Only the download step shows a percentage. Other active phases show
+          // a steady "working…" (no spinning glyph in the status column — the
+          // row's leading glyph already spins), so nothing jitters.
+          final String status;
+          if (failed) {
+            status = 'error';
+          } else if (done) {
+            status = 'done';
+          } else if (active) {
+            final showPct = s.phase == PatchApplyPhase.downloading &&
+                s.fraction != null;
+            status = showPct ? _pct(s.fraction) : 'working…';
+          } else {
+            status = 'wait';
+          }
 
           return Padding(
             padding: const EdgeInsets.symmetric(vertical: 3),
@@ -415,50 +438,53 @@ class _OtaProgressOverlayState extends State<OtaProgressOverlay> {
 
   // ── PROGRESS ──────────────────────────────────────────────────────────
   Widget _progressBlock(OtaOverlayState s) {
-    const total = 34;
-    final frac = (s.fraction ?? 0).clamp(0.0, 1.0);
-    final filled = (frac * total).round();
-    final bar = '${'█' * filled}${'░' * (total - filled)}';
-
-    final speed = (s.bytesPerSec != null && s.bytesPerSec! > 0)
-        ? '${(s.bytesPerSec! / 1048576).toStringAsFixed(1)} MB/s'
-        : '—';
-    String eta = '—';
-    if (s.bytesPerSec != null &&
-        s.bytesPerSec! > 0 &&
-        s.totalBytes > s.bytesReceived) {
-      final secs = ((s.totalBytes - s.bytesReceived) / s.bytesPerSec!).ceil();
-      eta = '${secs}s';
+    // Single honest fraction for the bar:
+    //  - preparing (no phase / no fraction yet) → empty
+    //  - downloading with a known size          → real fraction
+    //  - verifying / installing / finalizing / restarting → full (download is
+    //    already done, so the bar simply stays at 100% — no sliding animation)
+    //  - error → freeze wherever it was
+    final double frac;
+    if (s.hasError) {
+      frac = (s.fraction ?? 0).clamp(0.0, 1.0);
+    } else if (s.restarting) {
+      frac = 1.0;
+    } else if (s.phase == PatchApplyPhase.downloading) {
+      frac = (s.fraction ?? 0).clamp(0.0, 1.0);
+    } else if (s.phase == PatchApplyPhase.verifying ||
+        s.phase == PatchApplyPhase.finalizing) {
+      frac = 1.0;
+    } else {
+      frac = 0.0; // preparing
     }
-    final phase = s.hasError
-        ? 'halted'
-        : (s.phase?.name ?? 'preparing');
+
+    // Percent read-out only while it's a real download percentage.
+    final bool showPct =
+        !s.hasError && s.phase == PatchApplyPhase.downloading && s.fraction != null;
 
     return _panelBox(
-      child: Column(
-        crossAxisAlignment: CrossAxisAlignment.start,
+      child: Row(
         children: [
-          RichText(
-            text: TextSpan(
-              style: const TextStyle(fontFamily: _mono, fontSize: 13),
-              children: [
-                TextSpan(
-                    text: bar,
-                    style: TextStyle(color: s.hasError ? _C.red : _C.blue)),
-                TextSpan(
-                    text: '  ${_pct(s.fraction)}',
-                    style: const TextStyle(
-                        color: _C.text, fontWeight: FontWeight.w700)),
-              ],
+          Expanded(
+            child: _ProgressBar(
+              fraction: frac,
+              color: s.hasError ? _C.red : _C.blue,
             ),
           ),
-          const SizedBox(height: 10),
-          Row(
-            children: [
-              _stat('speed', speed),
-              _stat('eta', eta),
-              _stat('phase', phase),
-            ],
+          const SizedBox(width: 10),
+          SizedBox(
+            width: 44,
+            child: Text(
+              showPct ? _pct(s.fraction) : '',
+              textAlign: TextAlign.right,
+              style: const TextStyle(
+                fontFamily: _mono,
+                fontSize: 13,
+                color: _C.text,
+                fontWeight: FontWeight.w700,
+                fontFeatures: [FontFeature.tabularFigures()],
+              ),
+            ),
           ),
         ],
       ),
@@ -565,22 +591,6 @@ class _OtaProgressOverlayState extends State<OtaProgressOverlay> {
         child: child,
       );
 
-  Widget _stat(String k, String v) => Expanded(
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            Text(k,
-                style: const TextStyle(
-                    color: _C.faint, fontFamily: _mono, fontSize: 10)),
-            const SizedBox(height: 2),
-            Text(v,
-                overflow: TextOverflow.ellipsis,
-                style: const TextStyle(
-                    color: _C.text, fontFamily: _mono, fontSize: 12)),
-          ],
-        ),
-      );
-
   Widget _dot(Color c) => Container(
         width: 11,
         height: 11,
@@ -604,6 +614,75 @@ class _OtaProgressOverlayState extends State<OtaProgressOverlay> {
       );
 }
 
+/// A single-line determinate progress bar that never wraps.
+///
+/// It's a real painted widget with a fixed height inside an [Expanded], so it
+/// always stays on one line regardless of width — unlike the old
+/// character-string bar, which wrapped when it didn't fit. It eases toward its
+/// target (forward-only) instead of snapping, and has no indeterminate sliding
+/// mode — once a download completes the bar simply rests at 100%.
+class _ProgressBar extends StatefulWidget {
+  final double fraction;
+  final Color color;
+
+  const _ProgressBar({required this.fraction, required this.color});
+
+  @override
+  State<_ProgressBar> createState() => _ProgressBarState();
+}
+
+class _ProgressBarState extends State<_ProgressBar> {
+  // Smoothed value so the bar eases toward the target. Forward-only — it never
+  // visually goes backwards.
+  double _shown = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    _shown = widget.fraction.clamp(0.0, 1.0);
+  }
+
+  @override
+  void didUpdateWidget(covariant _ProgressBar old) {
+    super.didUpdateWidget(old);
+    final target = widget.fraction.clamp(0.0, 1.0);
+    if (target >= _shown) _shown = target;
+  }
+
+  static const _height = 8.0;
+  static const _track = Color(0xFF161C24);
+
+  @override
+  Widget build(BuildContext context) {
+    return ClipRRect(
+      borderRadius: BorderRadius.circular(99),
+      child: SizedBox(
+        height: _height,
+        child: ColoredBox(
+          color: _track,
+          child: LayoutBuilder(
+            builder: (context, c) => TweenAnimationBuilder<double>(
+              tween: Tween(end: _shown),
+              duration: const Duration(milliseconds: 300),
+              curve: Curves.easeOut,
+              builder: (context, v, _) => Align(
+                alignment: Alignment.centerLeft,
+                child: Container(
+                  width: c.maxWidth * v.clamp(0.0, 1.0),
+                  decoration: BoxDecoration(
+                    color: widget.color,
+                    borderRadius: BorderRadius.circular(99),
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+}
+
 /// Scrollable terminal log view — auto-scrolls to bottom on new lines.
 ///
 /// A line whose text has a leading token followed by 2+ spaces is rendered
@@ -702,9 +781,9 @@ class OtaOverlayManager {
   bool _disposed = false;
   DateTime? _startTime;
 
-  // Download-speed tracking.
-  int _lastBytes = 0;
-  DateTime? _lastBytesAt;
+  /// Last 10%-bucket we emitted a "download NN%" log line for, to throttle the
+  /// feed. -1 = none yet.
+  int _lastLoggedPctBucket = -1;
 
   OverlayState? Function()? _resolver;
 
@@ -740,8 +819,7 @@ class OtaOverlayManager {
     if (overlay == null) return null;
 
     _startTime = DateTime.now();
-    _lastBytes = 0;
-    _lastBytesAt = null;
+    _lastLoggedPctBucket = -1;
 
     final logs = <LogLine>[
       if (channel != null) LogLine('gray', 'channel  $channel'),
@@ -775,9 +853,13 @@ class OtaOverlayManager {
   void _log(String color, String text) {
     if (_disposed) return;
     final current = _state.value;
-    _state.value = current.copyWith(
-      logs: [...current.logs, LogLine(color, text)],
-    );
+    final next = [...current.logs, LogLine(color, text)];
+    // Cap the feed so a long session can't grow it without bound.
+    const maxLines = 200;
+    final capped = next.length > maxLines
+        ? next.sublist(next.length - maxLines)
+        : next;
+    _state.value = current.copyWith(logs: capped);
   }
 
   /// Map phase to step index.
@@ -802,24 +884,13 @@ class OtaOverlayManager {
         ? '${(pct.clamp(0.0, 1.0) * 100).toStringAsFixed(0)}%'
         : '';
 
-    final newStep = _phaseToStep(progress.phase);
+    // Step index derived from phase, but forced to move only forward so an
+    // out-of-order or duplicate native event can never make the steps jump
+    // backwards or flicker.
+    final phaseStep = _phaseToStep(progress.phase);
+    final newStep = phaseStep < s.activeStep ? s.activeStep : phaseStep;
 
-    // Compute download speed from byte deltas.
-    int? bytesPerSec = s.bytesPerSec;
-    if (progress.phase == PatchApplyPhase.downloading &&
-        progress.bytesReceived > 0) {
-      final now = DateTime.now();
-      if (_lastBytesAt != null && progress.bytesReceived > _lastBytes) {
-        final dt = now.difference(_lastBytesAt!).inMilliseconds / 1000.0;
-        if (dt > 0) {
-          bytesPerSec = ((progress.bytesReceived - _lastBytes) / dt).round();
-        }
-      }
-      _lastBytes = progress.bytesReceived;
-      _lastBytesAt = now;
-    }
-
-    // Log phase transitions with staggered delays.
+    // Log phase transitions once, with staggered detail lines.
     if (s.phase != progress.phase) {
       switch (progress.phase) {
         case PatchApplyPhase.downloading:
@@ -841,12 +912,17 @@ class OtaOverlayManager {
       }
     }
 
-    // Log download progress with size.
+    // Throttle the "download NN%" log so a fast download doesn't spam dozens of
+    // lines (which made the feed scroll frantically). One line per ~10%.
     if (progress.phase == PatchApplyPhase.downloading &&
         pctText.isNotEmpty &&
         progress.totalBytes > 0) {
-      final sizeMB = (progress.totalBytes / 1048576).toStringAsFixed(1);
-      _log('gray', 'download ${sizeMB}MB  $pctText');
+      final bucket = ((progress.fraction ?? 0) * 10).floor();
+      if (bucket != _lastLoggedPctBucket) {
+        _lastLoggedPctBucket = bucket;
+        final sizeMB = (progress.totalBytes / 1048576).toStringAsFixed(1);
+        _log('gray', 'download ${sizeMB}MB  $pctText');
+      }
     }
 
     _state.value = _state.value.copyWith(
@@ -854,7 +930,6 @@ class OtaOverlayManager {
       fraction: progress.fraction,
       bytesReceived: progress.bytesReceived,
       totalBytes: progress.totalBytes > 0 ? progress.totalBytes : null,
-      bytesPerSec: bytesPerSec,
       activeStep: newStep,
     );
   }
@@ -884,11 +959,16 @@ class OtaOverlayManager {
     final remaining = _minDuration - elapsed;
     final delay = remaining.isNegative ? Duration.zero : remaining;
 
+    // On success mark ALL steps complete + flag restarting, so the steps list
+    // finishes cleanly (every ✓, phase = "restarting") instead of freezing on
+    // whatever step the last native progress event happened to leave active.
     _state.value = _state.value.copyWith(
       hasError: hasError,
       errorText: errorText,
       canRetry: hasError,
-      activeStep: hasError ? _state.value.activeStep : 4,
+      restarting: !hasError,
+      fraction: hasError ? null : 1.0,
+      activeStep: hasError ? _state.value.activeStep : _stepLabels.length,
     );
 
     final entry = _entry;

package/dart-src/root/pubspec.yaml

@@ -1,6 +1,6 @@
 name: flutter_ota_kit
 description: Open-source, self-hosted code push (OTA updates) for Flutter Android. Patches Dart AOT libapp.so and assets on cold start with integrity checks and crash rollback.
-version: 0.2.0
+version: 0.2.2
 homepage: https://github.com/HYPER12755/flutter-ota-kit
 repository: https://github.com/HYPER12755/flutter-ota-kit
 issue_tracker: https://github.com/HYPER12755/flutter-ota-kit/issues

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_nazmiforreal/flutter-ota",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "Command-line interface for flutter_ota_kit — an OTA code-push tool for Flutter, hot-updater compatible.",
   "bin": {
     "flutter-ota": "./bin/flutter-ota.js"