Add Worker service with isolated task management and integrate into app

2025-09-22 19:30:18 +02:00
parent cfd38211a2
commit d374ff6bf9
5 changed files with 370 additions and 58 deletions
--- a/finlog_app/fluttery/lib/src/system/worker/worker_impl.dart
+++ b/finlog_app/fluttery/lib/src/system/worker/worker_impl.dart
@@ -0,0 +1,142 @@
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:flutter/services.dart'
+    show ServicesBinding, RootIsolateToken, BackgroundIsolateBinaryMessenger;
+
+import 'package:fluttery/fluttery.dart';
+import 'package:fluttery/logger.dart';
+import 'package:fluttery/worker.dart';
+
+class WorkerImpl implements Worker {
+  WorkerImpl({
+    this.defaultTimeout,
+    this.maxHistory = 100,
+    RootIsolateToken? rootToken, // optional for tests
+  }) : _rootToken =
+           rootToken ?? ServicesBinding.rootIsolateToken; // <— static getter
+
+  final Duration? defaultTimeout;
+  final int maxHistory;
+
+  // Captured from the root isolate (may be null in some test envs)
+  final RootIsolateToken? _rootToken;
+
+  int _seq = 0;
+  final Map<String, WorkerInfo> _active = {};
+  final List<WorkerInfo> _history = [];
+
+  @override
+  Future<T> spawn<T>(
+    String debugName,
+    FutureOr<T> Function() task, {
+    void Function()? preTask,
+    Duration? timeout,
+  }) {
+    final id = (++_seq).toString().padLeft(6, '0');
+    final started = DateTime.now();
+
+    _active[id] = WorkerInfo(
+      id: id,
+      name: debugName,
+      startedAt: started,
+      status: WorkerStatus.running,
+    );
+
+    Future<T> inner() async {
+      final token = _rootToken; // captured into closure
+
+      return Isolate.run<T>(() async {
+        // Initialize platform channels for this background isolate.
+        if (token != null) {
+          BackgroundIsolateBinaryMessenger.ensureInitialized(token);
+        }
+
+        // Now it's safe to touch plugins (e.g., SharedPreferences).
+        await App.registerDefaultServices();
+
+        preTask?.call();
+
+        return await Future.sync(task);
+      }, debugName: debugName);
+    }
+
+    final effectiveTimeout = timeout ?? defaultTimeout;
+    final fut = effectiveTimeout == null
+        ? inner()
+        : inner().timeout(effectiveTimeout);
+
+    fut
+        .then((_) {
+          _finish(id, status: WorkerStatus.completed);
+        })
+        .catchError((e, st) {
+          _finish(
+            id,
+            status: e is TimeoutException
+                ? WorkerStatus.timedOut
+                : WorkerStatus.failed,
+            error: e,
+            stack: st,
+          );
+          // Best-effort logging
+          try {
+            App.service<Logger>().error(
+              'Worker job "$debugName" ($id) failed: $e',
+              st,
+            );
+          } catch (_) {}
+        });
+
+    return fut;
+  }
+
+  void _finish(
+    String id, {
+    required WorkerStatus status,
+    Object? error,
+    StackTrace? stack,
+  }) {
+    final prev = _active.remove(id);
+    final endedAt = DateTime.now();
+
+    final info = WorkerInfo(
+      id: prev?.id ?? id,
+      name: prev?.name ?? 'unknown',
+      startedAt: prev?.startedAt ?? endedAt,
+      status: status,
+      endedAt: endedAt,
+      error: error,
+      stackTrace: stack,
+    );
+
+    _history.insert(0, info);
+    if (_history.length > maxHistory) {
+      _history.removeRange(maxHistory, _history.length);
+    }
+  }
+
+  @override
+  List<WorkerInfo> getActiveWorkers() =>
+      _active.values.toList()
+        ..sort((a, b) => a.startedAt.compareTo(b.startedAt));
+
+  @override
+  List<WorkerInfo> getAllWorkers() => [...getActiveWorkers(), ..._history];
+
+  @override
+  WorkerInfo? getWorker(String id) {
+    final active = _active[id];
+    if (active != null) return active;
+    for (final w in _history) {
+      if (w.id == id) return w;
+    }
+    return null;
+  }
+
+  @override
+  void purge({Duration maxAge = const Duration(minutes: 30)}) {
+    final cutoff = DateTime.now().subtract(maxAge);
+    _history.removeWhere((w) => (w.endedAt ?? w.startedAt).isBefore(cutoff));
+  }
+}