tripz-llc/apps/rider/lib/services/geofencing_service.dart

import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:native_geofence/native_geofence.dart';
import 'package:http/http.dart' as http;
import 'package:get_storage/get_storage.dart';
import 'package:siro_rider/constant/links.dart';

// Top-level function for background execution
@pragma('vm:entry-point')
Future<void> geofenceBackgroundCallback(GeofenceCallbackParams params) async {
  if (params.event == GeofenceEvent.enter) {
    // Note: GetStorage might need to be initialized in the background isolate
    await GetStorage.init();
    final storage = GetStorage();
    final passengerId = storage.read('passenger_id') ?? '';
    if (passengerId.toString().isEmpty) return;

    for (var geofence in params.geofences) {
      debugPrint('Entered Geofence: ${geofence.id}');
      
      try {
        final url = Uri.parse('${AppLink.server}/api/location/sync_location.php');
        await http.post(url, body: {
          'passenger_id': passengerId.toString(),
          'lat': geofence.location.latitude.toString(),
          'lng': geofence.location.longitude.toString(),
          'source': 'geofence',
        });
      } catch (e) {
        debugPrint('Geofence API Error: $e');
      }
    }
  }
}

class SiroGeofencingService {
  static final _storage = GetStorage();
  
  static Future<void> initAndStart() async {
    try {
      await NativeGeofenceManager.instance.initialize();
    } catch (e) {
      debugPrint('Error initializing NativeGeofenceManager: $e');
    }
  }
  
  static Future<void> syncZonesWithServer(double lat, double lng) async {
    try {
      final passengerId = _storage.read('passenger_id') ?? '';
      if (passengerId.toString().isEmpty) return;

      final url = Uri.parse('${AppLink.server}/api/location/sync_location.php');
      final response = await http.post(url, body: {
        'passenger_id': passengerId.toString(),
        'lat': lat.toString(),
        'lng': lng.toString(),
        'source': 'app_usage', 
      });

      if (response.statusCode == 200) {
        final data = json.decode(response.body);
        if (data['status'] == 'success' && data['update_geofences'] != null) {
          await _updateLocalGeofences(data['update_geofences']);
        }
      }
    } catch (e) {
      debugPrint('Error syncing geofence zones: $e');
    }
  }

  static Future<void> _updateLocalGeofences(List<dynamic> regions) async {
    try {
      for (var region in regions) {
        final geofence = Geofence(
          id: region['id'].toString(),
          location: Location(
              latitude: double.parse(region['latitude'].toString()),
              longitude: double.parse(region['longitude'].toString())),
          radiusMeters: double.parse(region['radius_meters'].toString()),
          triggers: {GeofenceEvent.enter},
          iosSettings: const IosGeofenceSettings(
            initialTrigger: true,
          ),
          androidSettings: const AndroidGeofenceSettings(
            initialTriggers: {GeofenceEvent.enter},
          ),
        );
        
        await NativeGeofenceManager.instance.createGeofence(
          geofence,
          geofenceBackgroundCallback,
        );
      }
    } catch (e) {
      debugPrint('Error updating local geofences: $e');
    }
  }
}