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 {
  /// Memproses baris teks dalam file besar secara asinkron di Isolate terpisah.
  /// Memancarkan nilai progres (0.0 hingga 1.0) melalui Stream.
  static Stream<double> prosesFileLatarBelakang({
    required String pathFileSumber,
    required String pathFileTujuan,
  }) {
    final StreamController<double> controllerProgres = StreamController<double>();
    final ReceivePort portPenerimaDart = ReceivePort();

    // Jalankan isolate anak
    Isolate.spawn<InitParams>(
      _entriPointIsolate,
      InitParams(
        sendPort: portPenerimaDart.sendPort,
        pathFileSumber: pathFileSumber,
        pathFileTujuan: pathFileTujuan,
      ),
    ).then((Isolate isolateAnak) {
      // Dengarkan pesan yang dikirim dari isolate anak
      portPenerimaDart.listen((dynamic pesan) {
        if (pesan is double) {
          // Update progres
          controllerProgres.add(pesan);
        } else if (pesan is String && pesan == 'SELESAI') {
          // Tutup komunikasi jika selesai
          portPenerimaDart.close();
          isolateAnak.kill(priority: Isolate.immediate);
          controllerProgres.close();
        } else if (pesan is String && pesan.startsWith('ERROR:')) {
          // Kirim error ke stream listener
          portPenerimaDart.close();
          isolateAnak.kill(priority: Isolate.immediate);
          controllerProgres.addError(Exception(pesan.replaceFirst('ERROR:', '')));
          controllerProgres.close();
        }
      });
    }).catchError((dynamic err) {
      controllerProgres.addError(err);
      controllerProgres.close();
    });

    return controllerProgres.stream;
  }
}

// Model parameter inisialisasi Isolate
class InitParams {
  final SendPort sendPort;
  final String pathFileSumber;
  final String pathFileTujuan;

  InitParams({
    required this.sendPort,
    required this.pathFileSumber,
    required this.pathFileTujuan,
  });
}

// Titik masuk Isolate anak. Harus berupa fungsi top-level atau static.
void _entriPointIsolate(InitParams params) async {
  try {
    final fileSumber = File(params.pathFileSumber);
    if (!await fileSumber.exists()) {
      params.sendPort.send('ERROR:File sumber tidak ditemukan.');
      return;
    }

    final barisTeks = await fileSumber.readAsLines();
    final totalBaris = barisTeks.length;
    final fileTujuan = File(params.pathFileTujuan);
    
    // Buka sink penulisan file
    final iosink = fileTujuan.openWrite();
    
    for (var i = 0; i < totalBaris; i++) {
      // Lakukan pemrosesan teks berat (misal: normalisasi dan enkripsi tiruan)
      final stringHasil = _prosesTextBerat(barisTeks[i]);
      iosink.write('$stringHasil\n');

      // Kirim pembaruan progres setiap 2% pemrosesan untuk mengurangi overhead komunikasi
      if (i % (totalBaris ~/ 50 + 1) == 0) {
        final double progres = (i + 1) / totalBaris;
        params.sendPort.send(progres);
      }
    }

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

    // Kirim sinyal selesai
    params.sendPort.send('SELESAI');
  } catch (e) {
    params.sendPort.send('ERROR:${e.toString()}');
  }
}

String _prosesTextBerat(String input) {
  // Simulasi enkripsi teks menggunakan manipulasi string kompleks
  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';

// ID unik tugas untuk referensi sistem
const String namaTugasSync = "com.unisbadri.flutter.syncTask";

/// Callback Dispatcher yang dieksekusi oleh OS saat trigger background aktif.
/// Harus diletakkan sebagai fungsi top-level di luar kelas.
@pragma('vm:entry-point')
void callbackDispatcher() {
  Workmanager().executeTask((String namaTugas, Map<String, dynamic>? inputData) async {
    // PENTING: Di dalam scope ini, kita berjalan di Headless Isolate terpisah.
    // Tidak ada widget tree, tidak ada active provider UI.
    
    switch (namaTugas) {
      case namaTugasSync:
        return await _eksekusiTugasSinkronisasi(inputData);
      default:
        return false;
    }
  });
}

Future<bool> _eksekusiTugasSinkronisasi(Map<String, dynamic>? inputData) async {
  try {
    debugPrint('[Workmanager] Mulai sinkronisasi data di latar belakang...');
    
    // Inisialisasi ulang penyimpanan lokal (SharedPreferences bersifat thread-safe)
    final prefs = await SharedPreferences.getInstance();
    
    // Mengambil timestamp sinkronisasi terakhir
    final lastSync = prefs.getInt('last_sync_timestamp') ?? 0;
    debugPrint('[Workmanager] Terakhir sinkronisasi: ${DateTime.fromMillisecondsSinceEpoch(lastSync)}');

    // Jalankan request HTTP (simulasi)
    final statusBerhasil = await _kirimDataKeServer(inputData);
    
    if (statusBerhasil) {
      await prefs.setInt('last_sync_timestamp', DateTime.now().millisecondsSinceEpoch);
      debugPrint('[Workmanager] Sinkronisasi selesai dengan sukses.');
      return true; // Mengembalikan true agar OS tahu task berhasil
    }
    return false; // Mengembalikan false agar OS melakukan penjadwalan ulang (retry)
  } catch (e) {
    debugPrint('[Workmanager] Gagal menjalankan sinkronisasi: $e');
    return false;
  }
}

Future<bool> _kirimDataKeServer(Map<String, dynamic>? inputData) async {
  // Simulasi pengiriman data jaringan
  await Future.delayed(const Duration(seconds: 4));
  return true;
}

class WorkmanagerService {
  /// Inisialisasi awal Workmanager
  static Future<void> inisialisasi() async {
    await Workmanager().initialize(
      callbackDispatcher,
      isInDebugMode: kDebugMode, // Memunculkan notifikasi debug di Android
    );
  }

  /// Mendaftarkan tugas berkala untuk menyinkronkan data setiap 15 menit
  static Future<void> daftarkanTugasSyncBerkala() async {
    await Workmanager().registerPeriodicTask(
      "sync-data-id-unik", // ID unik internal Workmanager
      namaTugasSync,
      frequency: const Duration(minutes: 15), // Batas minimum frekuensi Android/iOS adalah 15 menit
      constraints: Constraints(
        networkType: NetworkType.connected, // Hanya jalan jika perangkat terkoneksi internet
        requiresBatteryNotLow: true,        // Jangan jalankan jika baterai lemah
        requiresCharging: false,
      ),
      existingWorkPolicy: ExistingWorkPolicy.keep, // Jaga tugas yang sudah terdaftar
    );
  }

  /// Membatalkan seluruh tugas latar belakang terdaftar
  static Future<void> matikanSemuaTugas() async {
    await Workmanager().cancelAll();
    debugPrint('[Workmanager] Semua tugas latar belakang telah dibatalkan.');
  }
}

<!-- Izin untuk menjalankan 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 ...>
    <!-- Daftarkan service background -->
    <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 channelIdNotifikasi = 'my_tracking_channel';
  static const int idNotifikasi = 999;

  /// Inisialisasi awal konfigurasi service
  static Future<void> inisialisasi() async {
    final service = FlutterBackgroundService();

    await service.configure(
      androidConfiguration: AndroidConfiguration(
        onStart: _entriPointService,
        autoStart: false, // Jangan jalankan otomatis, tunggu pemicuan UI
        isForegroundMode: true,
        notificationChannelId: channelIdNotifikasi,
        initialNotificationTitle: 'Pelacakan Rute Aktif',
        initialNotificationContent: 'Menunggu sinyal GPS...',
        foregroundServiceNotificationId: idNotifikasi,
      ),
      iosConfiguration: IosConfiguration(
        autoStart: false,
        onForeground: _entriPointService,
        onBackground: _onIosBackgroundFallback,
      ),
    );
  }

  /// Memulai layanan latar belakang
  static Future<void> mulaiLayanan() async {
    final service = FlutterBackgroundService();
    final statusBerjalan = await service.isRunning();
    if (!statusBerjalan) {
      await service.startService();
    }
  }

  /// Menghentikan layanan latar belakang
  static void hentikanLayanan() {
    final service = FlutterBackgroundService();
    service.invoke('stopService');
  }
}

// Handler utama saat service background Android/iOS aktif
@pragma('vm:entry-point')
void _entriPointService(ServiceInstance service) async {
  // Pastikan plugin engine terhubung dengan baik ke platform host
  DartPluginRegistrant.ensureInitialized();

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

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

  // Dengarkan pemicu penghentian dari UI
  service.on('stopService').listen((event) {
    service.stopSelf();
  });

  // Contoh pelacakan berkala (Simulasi emulasi GPS koordinat)
  double latitude = -6.2088;
  double longitude = 106.8456;

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

    // Ubah titik koordinat secara acak seolah pengguna sedang bergerak
    latitude += 0.0001;
    longitude += 0.0001;

    // 1. Update info pada notifikasi sistem Android
    if (service is AndroidServiceInstance) {
      if (await service.isForegroundService()) {
        service.setForegroundNotificationInfo(
          title: 'Pelacakan Rute Berjalan',
          content: 'Koordinat: ${latitude.toStringAsFixed(5)}, ${longitude.toStringAsFixed(5)}',
        );
      }
    }

    // 2. Kirim pesan event ke UI thread utama (jika aplikasi sedang terbuka)
    service.invoke(
      'updateKoordinat',
      {
        '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 _statusStatus = 'Layanan Mati';
  String _posisiTerakhir = 'Belum ada data';
  StreamSubscription? _sub;

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

  void _inisialisasiListener() {
    // Hubungkan listener ke channel event 'updateKoordinat' yang dipancarkan service
    _sub = FlutterBackgroundService().on('updateKoordinat').listen((Map<String, dynamic>? event) {
      if (event != null && mounted) {
        final double lat = event['latitude'] as double;
        final double lng = event['longitude'] as double;
        setState(() {
          _statusStatus = 'Layanan Berjalan';
          _posisiTerakhir = 'Lat: ${lat.toStringAsFixed(6)}, Lng: ${lng.toStringAsFixed(6)}';
        });
      }
    });
  }

  @override
  void dispose() {
    _sub?.cancel(); // Pastikan subscription dibersihkan
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Pelacakan GPS Latar Belakang')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Status Layanan: $_statusStatus', style: const TextStyle(fontSize: 18)),
            const SizedBox(height: 8),
            Text('Posisi Saat Ini:\n$_posisiTerakhir', textAlign: TextAlign.center),
            const SizedBox(height: 24),
            ElevatedButton(
              onPressed: () async {
                await TrackingBackgroundService.mulaiLayanan();
                setState(() => _statusStatus = 'Memulai Layanan...');
              },
              child: const Text('Mulai Pelacakan'),
            ),
            const SizedBox(height: 12),
            ElevatedButton(
              onPressed: () {
                TrackingBackgroundService.hentikanLayanan();
                setState(() {
                  _statusStatus = 'Layanan Mati';
                  _posisiTerakhir = 'Dihentikan';
                });
              },
              style: ElevatedButton.styleFrom(backgroundColor: Colors.red.shade100),
              child: const Text('Hentikan Pelacakan', style: TextStyle(color: Colors.red)),
            ),
          ],
        ),
      ),
    );
  }
}