Background Tasks #

// lib/core/background/file_processor_isolate.dart
import 'dart:async';
import 'dart:io';
import 'dart:isolate';
import 'package:flutter/foundation.dart';

class FileProcessorIsolate {
  /// Processes text lines in a large file asynchronously in a separate Isolate.
  /// Emits progress values (0.0 to 1.0) through a Stream.
  static Stream<double> processFileInBackground({
    required String sourceFilePath,
    required String destinationFilePath,
  }) {
    final StreamController<double> progressController = StreamController<double>();
    final ReceivePort dartReceivePort = ReceivePort();

    // Run the child isolate
    Isolate.spawn<InitParams>(
      _isolateEntryPoint,
      InitParams(
        sendPort: dartReceivePort.sendPort,
        sourceFilePath: sourceFilePath,
        destinationFilePath: destinationFilePath,
      ),
    ).then((Isolate childIsolate) {
      // Listen for messages sent from the child isolate
      dartReceivePort.listen((dynamic message) {
        if (message is double) {
          // Update progress
          progressController.add(message);
        } else if (message is String && message == 'DONE') {
          // Close communication if finished
          dartReceivePort.close();
          childIsolate.kill(priority: Isolate.immediate);
          progressController.close();
        } else if (message is String && message.startsWith('ERROR:')) {
          // Send the error to the stream listener
          dartReceivePort.close();
          childIsolate.kill(priority: Isolate.immediate);
          progressController.addError(Exception(message.replaceFirst('ERROR:', '')));
          progressController.close();
        }
      });
    }).catchError((dynamic err) {
      progressController.addError(err);
      progressController.close();
    });

    return progressController.stream;
  }
}

// Isolate initialization parameter model
class InitParams {
  final SendPort sendPort;
  final String sourceFilePath;
  final String destinationFilePath;

  InitParams({
    required this.sendPort,
    required this.sourceFilePath,
    required this.destinationFilePath,
  });
}

// The child isolate entry point. Must be a top-level or static function.
void _isolateEntryPoint(InitParams params) async {
  try {
    final sourceFile = File(params.sourceFilePath);
    if (!await sourceFile.exists()) {
      params.sendPort.send('ERROR:Source file not found.');
      return;
    }

    final textLines = await sourceFile.readAsLines();
    final totalLines = textLines.length;
    final destinationFile = File(params.destinationFilePath);
    
    // Open the file write sink
    final iosink = destinationFile.openWrite();
    
    for (var i = 0; i < totalLines; i++) {
      // Do the heavy text processing (e.g., normalization and mock encryption)
      final resultString = _processHeavyText(textLines[i]);
      iosink.write('$resultString\n');

      // Send a progress update every 2% of processing to reduce communication overhead
      if (i % (totalLines ~/ 50 + 1) == 0) {
        final double progress = (i + 1) / totalLines;
        params.sendPort.send(progress);
      }
    }

    await iosink.flush();
    await iosink.close();

    // Send the completion signal
    params.sendPort.send('DONE');
  } catch (e) {
    params.sendPort.send('ERROR:${e.toString()}');
  }
}

String _processHeavyText(String input) {
  // Simulated text encryption using complex string manipulation
  return input.trim().split('').reversed.join('|').toUpperCase();
}

<uses-permission android:name="android.permission.INTERNET" />

<key>BGTaskSchedulerPermittedIdentifiers</key>
<array>
    <string>com.unisbadri.flutter.syncTask</string>
</array>

// lib/core/background/workmanager_service.dart
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'package:workmanager/workmanager.dart';

// Unique task ID for system reference
const String syncTaskName = "com.unisbadri.flutter.syncTask";

/// Callback Dispatcher executed by the OS when the background trigger is active.
/// Must be placed as a top-level function outside classes.
@pragma('vm:entry-point')
void callbackDispatcher() {
  Workmanager().executeTask((String taskName, Map<String, dynamic>? inputData) async {
    // IMPORTANT: Inside this scope, we're running in a separate Headless Isolate.
    // There's no widget tree, no active UI provider.
    
    switch (taskName) {
      case syncTaskName:
        return await _executeSyncTask(inputData);
      default:
        return false;
    }
  });
}

Future<bool> _executeSyncTask(Map<String, dynamic>? inputData) async {
  try {
    debugPrint('[Workmanager] Starting data synchronization in the background...');
    
    // Re-initialize local storage (SharedPreferences is thread-safe)
    final prefs = await SharedPreferences.getInstance();
    
    // Get the last synchronization timestamp
    final lastSync = prefs.getInt('last_sync_timestamp') ?? 0;
    debugPrint('[Workmanager] Last sync: ${DateTime.fromMillisecondsSinceEpoch(lastSync)}');

    // Run the HTTP request (simulated)
    final successStatus = await _sendDataToServer(inputData);
    
    if (successStatus) {
      await prefs.setInt('last_sync_timestamp', DateTime.now().millisecondsSinceEpoch);
      debugPrint('[Workmanager] Synchronization completed successfully.');
      return true; // Return true so the OS knows the task succeeded
    }
    return false; // Return false so the OS reschedules (retries)
  } catch (e) {
    debugPrint('[Workmanager] Failed to run synchronization: $e');
    return false;
  }
}

Future<bool> _sendDataToServer(Map<String, dynamic>? inputData) async {
  // Simulated network data delivery
  await Future.delayed(const Duration(seconds: 4));
  return true;
}

class WorkmanagerService {
  /// Initial Workmanager initialization
  static Future<void> initialize() async {
    await Workmanager().initialize(
      callbackDispatcher,
      isInDebugMode: kDebugMode, // Shows debug notifications on Android
    );
  }

  /// Registers a periodic task to sync data every 15 minutes
  static Future<void> registerPeriodicSyncTask() async {
    await Workmanager().registerPeriodicTask(
      "sync-data-unique-id", // Unique internal Workmanager ID
      syncTaskName,
      frequency: const Duration(minutes: 15), // The Android/iOS minimum frequency limit is 15 minutes
      constraints: Constraints(
        networkType: NetworkType.connected, // Only run if the device is connected to the internet
        requiresBatteryNotLow: true,        // Don't run if the battery is low
        requiresCharging: false,
      ),
      existingWorkPolicy: ExistingWorkPolicy.keep, // Keep already-registered tasks
    );
  }

  /// Cancels all registered background tasks
  static Future<void> disableAllTasks() async {
    await Workmanager().cancelAll();
    debugPrint('[Workmanager] All background tasks have been cancelled.');
  }
}

<!-- Permission to run the foreground service -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<application ...>
    <!-- Register the background service -->
    <service
        android:name="id.flutter.flutter_background_service.BackgroundService"
        android:foregroundServiceType="location"
        android:exported="false" />
</application>

// lib/core/background/tracking_background_service.dart
import 'dart:async';
import 'dart:ui';
import 'package:flutter/material.dart';
import 'package:flutter_background_service/flutter_background_service.dart';
import 'package:flutter_background_service_android/flutter_background_service_android.dart';

class TrackingBackgroundService {
  static const String notificationChannelId = 'my_tracking_channel';
  static const int notificationId = 999;

  /// Initial service configuration initialization
  static Future<void> initialize() async {
    final service = FlutterBackgroundService();

    await service.configure(
      androidConfiguration: AndroidConfiguration(
        onStart: _serviceEntryPoint,
        autoStart: false, // Don't start automatically, wait for UI triggering
        isForegroundMode: true,
        notificationChannelId: notificationChannelId,
        initialNotificationTitle: 'Route Tracking Active',
        initialNotificationContent: 'Waiting for GPS signal...',
        foregroundServiceNotificationId: notificationId,
      ),
      iosConfiguration: IosConfiguration(
        autoStart: false,
        onForeground: _serviceEntryPoint,
        onBackground: _onIosBackgroundFallback,
      ),
    );
  }

  /// Starts the background service
  static Future<void> startService() async {
    final service = FlutterBackgroundService();
    final isRunning = await service.isRunning();
    if (!isRunning) {
      await service.startService();
    }
  }

  /// Stops the background service
  static void stopService() {
    final service = FlutterBackgroundService();
    service.invoke('stopService');
  }
}

// Main handler when the Android/iOS background service is active
@pragma('vm:entry-point')
void _serviceEntryPoint(ServiceInstance service) async {
  // Make sure the plugin engine is properly connected to the host platform
  DartPluginRegistrant.ensureInitialized();

  if (service is AndroidServiceInstance) {
    service.on('setAsForeground').listen((event) {
      service.setAsForegroundService();
    });

    service.on('setAsBackground').listen((event) {
      service.setAsBackgroundService();
    });
  }

  // Listen for stop triggers from the UI
  service.on('stopService').listen((event) {
    service.stopSelf();
  });

  // Example periodic tracking (GPS coordinate emulation simulation)
  double latitude = -6.2088;
  double longitude = 106.8456;

  Timer.periodic(const Duration(seconds: 3), (timer) async {
    final isRunning = await service.isRunning();
    if (!isRunning) {
      timer.cancel();
      return;
    }

    // Change coordinate points randomly as if the user is moving
    latitude += 0.0001;
    longitude += 0.0001;

    // 1. Update info on the Android system notification
    if (service is AndroidServiceInstance) {
      if (await service.isForegroundService()) {
        service.setForegroundNotificationInfo(
          title: 'Route Tracking Running',
          content: 'Coordinates: ${latitude.toStringAsFixed(5)}, ${longitude.toStringAsFixed(5)}',
        );
      }
    }

    // 2. Send event messages to the main UI thread (if the app is open)
    service.invoke(
      'updateCoordinates',
      {
        'latitude': latitude,
        'longitude': longitude,
        'timestamp': DateTime.now().toIso8601String(),
      },
    );
  });
}

@pragma('vm:entry-point')
Future<bool> _onIosBackgroundFallback(ServiceInstance service) async {
  return true;
}

// lib/presentation/pages/tracking_page.dart
import 'package:flutter/material.dart';
import 'package:flutter_background_service/flutter_background_service.dart';
import '../../core/background/tracking_background_service.dart';

class TrackingPage extends StatefulWidget {
  const TrackingPage({super.key});

  @override
  State<TrackingPage> createState() => _TrackingPageState();
}

class _TrackingPageState extends State<TrackingPage> {
  String _serviceStatus = 'Service Off';
  String _lastPosition = 'No data yet';
  StreamSubscription? _sub;

  @override
  void initState() {
    super.initState();
    _initializeListener();
  }

  void _initializeListener() {
    // Connect the listener to the 'updateCoordinates' event channel emitted by the service
    _sub = FlutterBackgroundService().on('updateCoordinates').listen((Map<String, dynamic>? event) {
      if (event != null && mounted) {
        final double lat = event['latitude'] as double;
        final double lng = event['longitude'] as double;
        setState(() {
          _serviceStatus = 'Service Running';
          _lastPosition = 'Lat: ${lat.toStringAsFixed(6)}, Lng: ${lng.toStringAsFixed(6)}';
        });
      }
    });
  }

  @override
  void dispose() {
    _sub?.cancel(); // Make sure the subscription is cleaned up
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Background GPS Tracking')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Service Status: $_serviceStatus', style: const TextStyle(fontSize: 18)),
            const SizedBox(height: 8),
            Text('Current Position:\n$_lastPosition', textAlign: TextAlign.center),
            const SizedBox(height: 24),
            ElevatedButton(
              onPressed: () async {
                await TrackingBackgroundService.startService();
                setState(() => _serviceStatus = 'Starting Service...');
              },
              child: const Text('Start Tracking'),
            ),
            const SizedBox(height: 12),
            ElevatedButton(
              onPressed: () {
                TrackingBackgroundService.stopService();
                setState(() {
                  _serviceStatus = 'Service Off';
                  _lastPosition = 'Stopped';
                });
              },
              style: ElevatedButton.styleFrom(backgroundColor: Colors.red.shade100),
              child: const Text('Stop Tracking', style: TextStyle(color: Colors.red)),
            ),
          ],
        ),
      ),
    );
  }
}