[Bug]: Location Tracking Lasts 10 minutes

[vdiaza]

Required Reading

• Confirmed

Plugin Version

5.0.0-beta

Flutter Doctor

Doctor summary (to see all details, run flutter doctor -v):
[✓] Flutter (Channel stable, 3.38.3, on macOS 15.5 24F74 darwin-arm64, locale es-CL)
[✓] Android toolchain - develop for Android devices (Android SDK version 36.1.0)
[✓] Xcode - develop for iOS and macOS (Xcode 16.4)
[✓] Chrome - develop for the web
[✓] Connected device (2 available)
[✓] Network resources

• No issues found!

Mobile operating-system(s)

• iOS
• Android

Device Manufacturer(s) and Model(s)

Samsung S25

Device operating-systems(s)

Android 15

What happened?

App stops sending tracking information after 10 minutes.

It should be continue sending info until stopped.

Having debug=true it continue beeping but it does not send the request.

Plugin Code and/or Config

class BackgroundLocationProService {
  BackgroundLocationProService._();

  static final BackgroundLocationProService instance =
      BackgroundLocationProService._();

  bool _configured = false;
  String? _url;
  Map<String, dynamic> _data = {};

  // Check if Background Geolocation Pro is enabled for this app
  bool get isEnabled {
    final enabled = dotenv.env['ENABLE_BG_LOCATION_PRO']?.toLowerCase();
    return enabled == 'true';
  }

  Future<Map<String, dynamic>> configure(Map<String, dynamic> settings) async {
    // Return early if plugin is not enabled (no license for this app)
    if (!isEnabled) {
      AppGlobal.printLog(
          '[BG Geolocation] Plugin disabled for this app (ENABLE_BG_LOCATION_PRO=false)');
      return {'enabled': false, 'disabled_reason': 'no_license'};
    }

    _url = settings['url'] as String?;
    _data = (settings['data'] as Map<String, dynamic>?) ?? {};

    // Build params that the plugin will send with each location
    final Map<String, dynamic> params = Map<String, dynamic>.from(_data);

    // For trip monitoring: need updates even when stationary
    // Server timeout: 2 minutes (120s) without updates = "connection lost"
    final int intervalMs = settings['interval'] ?? 30000; // 30 seconds default

    final config = Config(
      // Some options (like reset) remain on the root config
      reset: settings['reset'] ?? true,

      notification: Notification(
        title: Constants.appName!,
        text: "Modo Activo",
        channelName: "Location Tracking",
        priority: NotificationPriority.high,
        sticky: true, // CRITICAL: Prevent user from dismissing notification
      ),

      // Geolocation-related options
      geolocation: GeoConfig(
        desiredAccuracy: DesiredAccuracy.navigation;,
        // CRITICAL: Set distanceFilter to 0 to enable time-based updates
        // With distanceFilter: 0, locationUpdateInterval takes effect
        distanceFilter: 0,
        // Time-based location updates (works when distanceFilter: 0)
        // This gets you updates even when stationary (default 60s)
        locationUpdateInterval: 30000, // in milliseconds
        fastestLocationUpdateInterval: 3000,
        locationTimeout: 60,
      ),

      // App / lifecycle options
      app: AppConfig(
        // Headless Mode: Continue tracking even when app is terminated
        enableHeadless: true,
        stopOnTerminate: false,
        startOnBoot: true,
        // Heartbeat as backup (min 60s on Android)
        // iOS only with preventSuspend: true
        heartbeatInterval: 60.0,
        preventSuspend: true,
      ),

      // HTTP Configuration - plugin will auto-POST locations
      http: HttpConfig(
        url: _url,
        params: {"data": params},
        headers:
            {
              'Content-Type': 'application/json',
            },
        autoSync: true,
        batchSync: true,
        maxBatchSize: -1,
      ),

      // Logging / debug options
      logger: LoggerConfig(
        debug: true,
        // If you were previously passing a numeric logLevel, you may
        // want to adjust this mapping to LogLevel.* accordingly.
        logLevel: LogLevel.verbose,
      ),
    );

    final state = await BackgroundGeolocation.ready(config);

    if (!_configured) {
      _configured = true;

      // Set up event listeners for debugging/logging

      // onLocation: Fires for EVERY location recorded while moving
      // Plugin auto-POSTs these to the configured URL
      BackgroundGeolocation.onLocation((Location location) {
        AppGlobal.printLog(
            '[BG Geolocation] Location: ${location.coords.latitude}, ${location.coords.longitude}, sample: ${location.sample}');
      });

      // onHeartbeat: Fires periodically (every heartbeatInterval seconds)
      // even when stationary. Plugin auto-POSTs the location.
      BackgroundGeolocation.onHeartbeat((HeartbeatEvent event) {
        AppGlobal.printLog(
            '[BG Geolocation] Heartbeat: location will be posted to server');
      });

      // CRITICAL: Monitor when tracking stops (helps debug service termination)
      BackgroundGeolocation.onEnabledChange((bool enabled) {
        AppGlobal.printLog(
            '[BG Geolocation] ⚠️ Tracking state changed: ${enabled ? "STARTED" : "STOPPED"}');
      });

      // Monitor connectivity issues that could stop location sync
      BackgroundGeolocation.onConnectivityChange((ConnectivityChangeEvent event) {
        AppGlobal.printLog(
            '[BG Geolocation] Connectivity: ${event.connected ? "CONNECTED" : "DISCONNECTED"}');
      });

      // Monitor GPS/location provider changes
      BackgroundGeolocation.onProviderChange((ProviderChangeEvent event) {
        AppGlobal.printLog(
            '[BG Geolocation] Provider - GPS enabled: ${event.enabled}, Status: ${event.status}');
      });
    }

    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }

  Future<Map<String, dynamic>> start() async {
    await BackgroundGeolocation.start();
    final state = await BackgroundGeolocation.state;
    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }

  Future<Map<String, dynamic>> stop() async {
    await BackgroundGeolocation.stop();
    final state = await BackgroundGeolocation.state;
    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }
}

Relevant log output

[christocracy]

Provide logs of "this 10 minutes of tracking".

[vdiaza]

I tried using emailLogs but the app crashes when I do that.

[christocracy]

Show me the crash stacktrace

[vdiaza]

Attempt to invoke virtual method 'java.lang.String[] java.lang.String.split(java.lang.String)' on a null object reference

[christocracy]

Please post the entire stacktrace so I can find out where I need to fix this.

[vdiaza]

java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String[] java.lang.String.split(java.lang.String)' on a null object reference
at com.transistorsoft.locationmanager.logger.b.a(r8-map-id-fed9c793a1b3acbad67608d85536913f32d28bd6b5c81e75c327bd553cfdfa9b:119)
at com.transistorsoft.locationmanager.logger.b.b(r8-map-id-fed9c793a1b3acbad67608d85536913f32d28bd6b5c81e75c327bd553cfdfa9b:291)
at com.transistorsoft.locationmanager.logger.TSLog$c.run(r8-map-id-fed9c793a1b3acbad67608d85536913f32d28bd6b5c81e75c327bd553cfdfa9b:35)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1156)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:651)
at java.lang.Thread.run(Thread.java:1119)

[christocracy]

where are you calling .emailLog relative to where you call .ready(config)?

[vdiaza]

here is whole file.

import 'dart:async';
import 'dart:convert';
import 'package:flutter_background_geolocation/flutter_background_geolocation.dart';
import 'package:flutter_dotenv/flutter_dotenv.dart';
import 'package:sentry_flutter/sentry_flutter.dart';

import 'package:urvan_driver/Utils/AppGlobal.dart';
import 'package:urvan_driver/Utils/Constants.dart';

class BackgroundLocationProService {
  BackgroundLocationProService._();

  static final BackgroundLocationProService instance =
      BackgroundLocationProService._();

  bool _configured = false;
  String? _url;
  Map<String, dynamic> _data = {};
  String? _playerId;

  DesiredAccuracy _resolveDesiredAccuracy(dynamic value) {
    // If it's already the correct type, just return it.
    if (value is DesiredAccuracy) return value;

    // Legacy numeric values from v4 (int) or custom codes from JS bridge.
    if (value is int) {
      // Map typical accuracy thresholds to enum values.
      if (value <= 10) return DesiredAccuracy.navigation;
      if (value <= 100) return DesiredAccuracy.high;
      if (value <= 1000) return DesiredAccuracy.medium;
      return DesiredAccuracy.low;
    }

    // Allow string-based values like 'high', 'medium', etc.
    if (value is String) {
      switch (value.toLowerCase()) {
        case 'navigation':
          return DesiredAccuracy.navigation;
        case 'high':
          return DesiredAccuracy.high;
        case 'medium':
          return DesiredAccuracy.medium;
        case 'low':
          return DesiredAccuracy.low;
      }
    }

    // Default used when no value or unrecognized type is provided.
    return DesiredAccuracy.navigation;
  }

  // Check if Background Geolocation Pro is enabled for this app
  bool get isEnabled {
    final enabled = dotenv.env['ENABLE_BG_LOCATION_PRO']?.toLowerCase();
    return enabled == 'true';
  }

  Future<Map<String, dynamic>> configure(Map<String, dynamic> settings) async {
    // Return early if plugin is not enabled (no license for this app)
    if (!isEnabled) {
      AppGlobal.printLog(
          '[BG Geolocation] Plugin disabled for this app (ENABLE_BG_LOCATION_PRO=false)');
      return {'enabled': false, 'disabled_reason': 'no_license'};
    }

    AppGlobal.printLog(
        '[BG Geolocation] ${_configured ? "Reconfiguring" : "Configuring"} plugin...');

    _url = settings['url'] as String?;
    _data = (settings['data'] as Map<String, dynamic>?) ?? {};
    _playerId = settings['playerId'] as String?;

    AppGlobal.printLog('[BG Geolocation] 📍 Config - URL: $_url');
    AppGlobal.printLog('[BG Geolocation] 📍 Config - Player ID: $_playerId');
    AppGlobal.printLog('[BG Geolocation] 📍 Config - Additional data: $_data');

    // Build params that the plugin will send with each location
    final Map<String, dynamic> params = Map<String, dynamic>.from(_data);
    if (_playerId != null) {
      params['playerId'] = _playerId;
    }

    // For trip monitoring: need updates even when stationary
    // Server timeout: 2 minutes (120s) without updates = "connection lost"
    final int intervalMs = settings['interval'] ?? 30000; // 30 seconds default

    AppGlobal.printLog(
        '[BG Geolocation] ⏱️  Config - Update interval: ${intervalMs}ms (${(intervalMs / 1000).round()}s)');
    AppGlobal.printLog(
        '[BG Geolocation] ⏱️  Config - Heartbeat interval: ${settings['heartbeatInterval'] ?? 60.0}s');
    AppGlobal.printLog(
        '[BG Geolocation] 📏 Config - Distance filter: ${settings['distanceFilter'] ?? 0}m');
    AppGlobal.printLog(
        '[BG Geolocation] 🎯 Config - Desired accuracy: ${settings['desiredAccuracy'] ?? "navigation"}');
    AppGlobal.printLog(
        '[BG Geolocation] 🚫 Config - Auto-stop disabled (stopTimeout: 0, stopOnStationary: false)');

    final config = Config(
      // Some options (like reset) remain on the root config
      reset: settings['reset'] ?? true,

      // Geolocation-related options
      geolocation: GeoConfig(
        desiredAccuracy: _resolveDesiredAccuracy(settings['desiredAccuracy']),
        // CRITICAL: Set distanceFilter to 0 to enable time-based updates
        // With distanceFilter: 0, locationUpdateInterval takes effect
        distanceFilter: settings['distanceFilter'] ?? 0,
        // Time-based location updates (works when distanceFilter: 0)
        // This gets you updates even when stationary (default 60s)
        locationUpdateInterval: intervalMs, // in milliseconds
        fastestLocationUpdateInterval: intervalMs,
        locationTimeout: settings['locationTimeout'] ?? 60,
        // CRITICAL: Set to 0 to disable auto-stop when stationary
        // Location tracking continues until manually stopped
        stopTimeout: 0,
      ),

      // App / lifecycle options
      app: AppConfig(
        // Headless Mode: Continue tracking even when app is terminated
        enableHeadless: true,
        stopOnTerminate: false,
        startOnBoot: true,
        // Heartbeat as backup (min 60s on Android)
        // iOS only with preventSuspend: true
        heartbeatInterval: settings['heartbeatInterval'] ?? 60.0,
        preventSuspend: true,

        notification: Notification(
          title: Constants.appName!,
          text: "Modo Activo",
          channelName: "Location Tracking",
          priority: NotificationPriority.high,
          sticky: true, // CRITICAL: Prevent user from dismissing notification
        ),
      ),

      // HTTP Configuration - plugin will auto-POST locations
      http: HttpConfig(
        url: _url,
        params: {"data": params},
        headers: settings['headers'] ??
            {
              'Content-Type': 'application/json',
            },
        autoSync: settings['autoSync'] ?? true,
        batchSync: settings['batchSync'] ?? true,
        maxBatchSize: settings['maxBatchSize'] ?? -1,
      ),

      // Logging / debug options
      logger: LoggerConfig(
        debug: settings['debug'] ?? false,
        // If you were previously passing a numeric logLevel, you may
        // want to adjust this mapping to LogLevel.* accordingly.
        logLevel: settings['logLevel'] ?? LogLevel.verbose,
      ),

      // Activity detection options
      activity: ActivityConfig(
        // CRITICAL: Keep tracking even when device is stationary
        // Only manual stop() calls will halt location tracking
        stopOnStationary: false,
      ),
    );

    final state = await BackgroundGeolocation.ready(config);

    AppGlobal.printLog(
        '[BG Geolocation] ✅ Plugin ready - State: enabled=${state.enabled}, tracking=${state.trackingMode}');
    AppGlobal.printLog(
        '[BG Geolocation] 📊 Current state - scheduledSync=${state.schedulerEnabled}, preventSuspend=${state.preventSuspend}');

    if (!_configured) {
      _configured = true;

      // Set up event listeners for debugging/logging

      // onLocation: Fires for EVERY location recorded while moving
      // Plugin auto-POSTs these to the configured URL
      BackgroundGeolocation.onLocation((Location location) {
        final coords = location.coords;

        AppGlobal.printLog('[BG Geolocation] 📍 Location captured:');
        AppGlobal.printLog(
            '  ├─ Lat/Lng: ${coords.latitude.toStringAsFixed(6)}, ${coords.longitude.toStringAsFixed(6)}');
        AppGlobal.printLog(
            '  ├─ Accuracy: ${coords.accuracy.toStringAsFixed(1)}m | Speed: ${coords.speed.toStringAsFixed(1)}m/s');
        AppGlobal.printLog(
            '  ├─ Altitude: ${coords.altitude.toStringAsFixed(1)}m | Heading: ${coords.heading.toStringAsFixed(0)}°');
        AppGlobal.printLog(
            '  ├─ Sample: ${location.sample} | Moving: ${location.isMoving} | Activity: ${location.activity.type}');
        AppGlobal.printLog('  └─ Timestamp: ${location.timestamp}');
      }, (LocationError error) async {
        AppGlobal.printLog(
            '[BG Geolocation] ❌ Location error: ${error.code} - ${error.message}');
        await Sentry.captureException(error, stackTrace: StackTrace.current,
            withScope: (scope) {
          scope.setTag('source', 'BackgroundGeolocation.onLocation');
          scope.setExtra('code', error.code);
        });
      });

      // onHeartbeat: Fires periodically (every heartbeatInterval seconds)
      // even when stationary. Plugin will attempt to get and post location.
      BackgroundGeolocation.onHeartbeat((HeartbeatEvent event) async {
        AppGlobal.printLog(
            '[BG Geolocation] ⏰ Heartbeat triggered - attempting to get current location');

        // Manually get current position on heartbeat to ensure it's captured
        try {
          final location = await BackgroundGeolocation.getCurrentPosition(
            samples: 1,
            timeout: 30,
          );
          AppGlobal.printLog(
              '[BG Geolocation] ✓ Heartbeat location acquired: ${location.coords.latitude}, ${location.coords.longitude}');
        } catch (e, stackTrace) {
          AppGlobal.printLog(
              '[BG Geolocation] ✗ Heartbeat location failed: $e');
          await Sentry.captureException(e, stackTrace: stackTrace);
        }
      });

      // CRITICAL: Monitor when tracking stops (helps debug service termination)
      BackgroundGeolocation.onEnabledChange((bool enabled) {
        AppGlobal.printLog(
            '[BG Geolocation] ⚠️ Tracking state changed: ${enabled ? "STARTED" : "STOPPED"}');
      });

      // Monitor connectivity issues that could stop location sync
      BackgroundGeolocation.onConnectivityChange(
          (ConnectivityChangeEvent event) {
        AppGlobal.printLog(
            '[BG Geolocation] Connectivity: ${event.connected ? "CONNECTED" : "DISCONNECTED"}');
      });

      // Monitor GPS/location provider changes
      BackgroundGeolocation.onProviderChange((ProviderChangeEvent event) {
        AppGlobal.printLog(
            '[BG Geolocation] Provider - GPS enabled: ${event.enabled}, Status: ${event.status}');
      });

      // Monitor HTTP requests to track if locations are being sent to server
      BackgroundGeolocation.onHttp((HttpEvent event) {
        if (event.success) {
          AppGlobal.printLog(
              '[BG Geolocation] ✓ HTTP POST successful: ${event.status}');
        } else {
          AppGlobal.printLog(
              '[BG Geolocation] ✗ HTTP POST failed: ${event.status} - ${event.responseText}');
        }
      });

      AppGlobal.printLog(
          '[BG Geolocation] ℹ️  Event listeners configured. Use emailLogs() to send debug logs.');
    }

    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }

  Future<Map<String, dynamic>> start() async {
    if (!isEnabled) {
      AppGlobal.printLog('[BG Geolocation] ❌ Cannot start - plugin disabled');
      return {'enabled': false, 'disabled_reason': 'no_license'};
    }

    AppGlobal.printLog('[BG Geolocation] 🚀 Starting location tracking...');
    await BackgroundGeolocation.start();

    final state = await BackgroundGeolocation.state;
    AppGlobal.printLog(
        '[BG Geolocation] ✅ Tracking started - enabled: ${state.enabled}');
    AppGlobal.printLog(
        '[BG Geolocation] 📊 Tracking mode: ${state.trackingMode}, odometer: ${state.odometer}m');

    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }

  Future<Map<String, dynamic>> stop() async {
    if (!isEnabled) {
      AppGlobal.printLog('[BG Geolocation] ❌ Cannot stop - plugin disabled');
      return {'enabled': false, 'disabled_reason': 'no_license'};
    }

    AppGlobal.printLog('[BG Geolocation] 🛑 Stopping location tracking...');
    await BackgroundGeolocation.stop();

    final state = await BackgroundGeolocation.state;
    AppGlobal.printLog(
        '[BG Geolocation] ⏹️  Tracking stopped - enabled: ${state.enabled}');

    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }

  Future<Map<String, dynamic>> clearLocations() async {
    if (!isEnabled) {
      AppGlobal.printLog('[BG Geolocation] ❌ Cannot clear - plugin disabled');
      return {'enabled': false, 'disabled_reason': 'no_license'};
    }

    AppGlobal.printLog('[BG Geolocation] 🗑️  Clearing all saved locations...');
    try {
      await BackgroundGeolocation.destroyLocations();
      AppGlobal.printLog('[BG Geolocation] ✅ Cleared all saved locations');
    } catch (e, stackTrace) {
      AppGlobal.printLog('[BG Geolocation] ❌ Error clearing locations: $e');
      await Sentry.captureException(e, stackTrace: stackTrace);
    }

    final state = await BackgroundGeolocation.state;
    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }

  Future<Map<String, dynamic>> getState() async {
    if (!isEnabled) {
      return {'enabled': false, 'disabled_reason': 'no_license'};
    }

    final state = await BackgroundGeolocation.state;
    final map = state.toMap();
    return map != null ? Map<String, dynamic>.from(map) : <String, dynamic>{};
  }

  Future<bool> getEnabled() async {
    final state = await BackgroundGeolocation.state;
    return state.enabled;
  }

  Future<Map<String, dynamic>> getCurrentPosition(
      Map<String, dynamic> options) async {
    if (!isEnabled) {
      AppGlobal.printLog(
          '[BG Geolocation] ❌ Cannot get position - plugin disabled');
      return {'error': 'Plugin disabled', 'disabled_reason': 'no_license'};
    }

    AppGlobal.printLog(
        '[BG Geolocation] 📡 Getting current position (timeout: ${options['timeout'] ?? 'default'})...');

    try {
      final location = await BackgroundGeolocation.getCurrentPosition(
        persist: options['persist'] ?? false,
        samples: options['samples'],
        timeout: options['timeout'],
        maximumAge: options['maximumAge'],
      );

      AppGlobal.printLog(
          '[BG Geolocation] ✅ Got current position: ${location.coords.latitude}, ${location.coords.longitude}');
      AppGlobal.printLog(
          '[BG Geolocation] 📊 Accuracy: ${location.coords.accuracy}m | Timestamp: ${location.timestamp}');

      return Map<String, dynamic>.from(location.toMap());
    } catch (e, stackTrace) {
      AppGlobal.printLog(
          '[BG Geolocation] ❌ Failed to get current position: $e');
      await Sentry.captureException(e, stackTrace: stackTrace);
      rethrow;
    }
  }

  /// Send debug logs via email
  /// This will open the device's email app with logs attached
  Future<Map<String, dynamic>> emailLogs(String emailAddress) async {
    if (!isEnabled) {
      AppGlobal.printLog(
          '[BG Geolocation] ❌ Cannot send logs - plugin disabled');
      return {'success': false, 'error': 'Plugin disabled'};
    }

    AppGlobal.printLog(
        '[BG Geolocation] 📧 Preparing to send logs to: $emailAddress');

    try {
      final success = await Logger.emailLog(
          emailAddress, SQLQuery(order: SQLQuery.ORDER_DESC));

      if (success) {
        AppGlobal.printLog(
            '[BG Geolocation] ✅ Email log dialog opened successfully');
        return {'success': true, 'message': 'Email client opened'};
      } else {
        AppGlobal.printLog('[BG Geolocation] ❌ Failed to open email client');
        return {'success': false, 'error': 'Failed to open email client'};
      }
    } catch (e, stackTrace) {
      AppGlobal.printLog('[BG Geolocation] ❌ Error sending logs: $e');
      await Sentry.captureException(e, stackTrace: stackTrace);
      return {'success': false, 'error': e.toString()};
    }
  }

  /// Upload debug logs to Sentry as an attachment
  Future<Map<String, dynamic>> sendLogsToSentry() async {
    if (!isEnabled) {
      AppGlobal.printLog(
          '[BG Geolocation] ❌ Cannot send logs - plugin disabled');
      return {'success': false, 'error': 'Plugin disabled'};
    }

    AppGlobal.printLog('[BG Geolocation] 📤 Uploading logs to Sentry...');

    try {
      // Get logs from plugin
      // Provide a query to avoid potential null pointer issues in native code
      final logContent =
          await Logger.getLog(SQLQuery(order: SQLQuery.ORDER_DESC));

      if (logContent.isEmpty) {
        AppGlobal.printLog('[BG Geolocation] ⚠️ No logs to send');
        return {'success': false, 'message': 'No logs to send'};
      }

      // Create attachment
      final attachment = SentryAttachment.fromIntList(
        utf8.encode(logContent),
        'bg_geolocation.log',
        contentType: 'text/plain',
      );

      // Capture message with attachment
      final sentryId = await Sentry.captureMessage(
        'Background Geolocation Logs Manual Upload',
        level: SentryLevel.info,
        withScope: (scope) {
          scope.addAttachment(attachment);
        },
      );

      AppGlobal.printLog(
          '[BG Geolocation] ✅ Logs uploaded to Sentry. Event ID: $sentryId');
      return {'success': true, 'eventId': sentryId.toString()};
    } catch (e, stackTrace) {
      AppGlobal.printLog(
          '[BG Geolocation] ❌ Error uploading logs to Sentry: $e');
      await Sentry.captureException(e, stackTrace: stackTrace);
      return {'success': false, 'error': e.toString()};
    }
  }
}

[christocracy]

Your code contains no reference to actually executing your method .emailLogs()

[vdiaza]

  /// Send debug logs via email
  /// This will open the device's email app with logs attached
  Future<Map<String, dynamic>> emailLogs(String emailAddress) async {
    if (!isEnabled) {
      AppGlobal.printLog(
          '[BG Geolocation] ❌ Cannot send logs - plugin disabled');
      return {'success': false, 'error': 'Plugin disabled'};
    }

    AppGlobal.printLog(
        '[BG Geolocation] 📧 Preparing to send logs to: $emailAddress');

    try {
      final success = await Logger.emailLog(
          emailAddress, SQLQuery(order: SQLQuery.ORDER_DESC));

      if (success) {
        AppGlobal.printLog(
            '[BG Geolocation] ✅ Email log dialog opened successfully');
        return {'success': true, 'message': 'Email client opened'};
      } else {
        AppGlobal.printLog('[BG Geolocation] ❌ Failed to open email client');
        return {'success': false, 'error': 'Failed to open email client'};
      }
    } catch (e, stackTrace) {
      AppGlobal.printLog('[BG Geolocation] ❌ Error sending logs: $e');
      await Sentry.captureException(e, stackTrace: stackTrace);
      return {'success': false, 'error': e.toString()};
    }
  }

[christocracy]

Yes, I say your method emailLogs. There is nothing in the code you posted that actually INVOKES your method:

BackgroundLocationProService.emailLogs(emailAddress) // <-- an actual invocation of this method does not exist in your posted code

[vdiaza]

Im using a webview so functions are invoked using javascript.

    // Email logs
    controller.addJavaScriptHandler(
      handlerName: 'backgroundLocationPro.emailLogs',
      callback: (args) async {
        AppGlobal.printLog('backgroundLocationPro.emailLogs Event');
        final String emailAddress =
            args.isNotEmpty ? args[0] : 'logs@geturvan.com';
        return await BackgroundLocationProService.instance
            .emailLogs(emailAddress);
      },
    );

    // Send logs to Sentry
    controller.addJavaScriptHandler(
      handlerName: 'backgroundLocationPro.sendLogsToSentry',
      callback: (args) async {
        AppGlobal.printLog('backgroundLocationPro.sendLogsToSentry Event');
        return await BackgroundLocationProService.instance.sendLogsToSentry();
      },
    );

[vdiaza]

When using sendLogsToSentry, it sends a file with following error:
Attempt to invoke virtual method 'java.lang.String[] java.lang.String.split(java.lang.String)' on a null object reference

[christocracy]

Do not call .emailLog until .ready(config) has resolved.

Execute it in a button click-handler.