geofence events not logged to server in real-time about flutter_background_geolocation HOT 8 CLOSED

import 'package:background_fetch/background_fetch.dart';
import 'package:flutter/material.dart';
import 'package:flutter_background_geolocation/flutter_background_geolocation.dart'
    as bg;

import 'package:pointbee/utilities/notifications.dart';
import 'package:pointbee/state/app_state.dart';

/// Receive events from BackgroundGeolocation in Headless state
void backgroundGeolocationHeadlessTask(bg.HeadlessEvent headlessEvent) async {
  print('📬 --> $headlessEvent');

  await setupNotifications();

  switch (headlessEvent.name) {
    case bg.Event.LOCATION:
      bg.Location location = headlessEvent.event;
      print('[BackgroundGeolocation] Headless LOCATION: $location');
      showNotification(
        title: '[BackgroundGeolocation] Headless LOCATION',
        body: 'speed: ${location.coords.speed} time: ${location.timestamp}',
      );
      break;
    case bg.Event.GEOFENCE:
      bg.GeofenceEvent geofenceEvent = headlessEvent.event;
      print('[BackgroundGeolocation] Headless GEOFENCE: $geofenceEvent');
      showNotification(
        title: '[BackgroundGeolocation] Headless GEOFENCE',
        body:
            'speed: ${geofenceEvent.location.coords.speed} time: ${geofenceEvent.location.timestamp}',
      );
      break;
    case bg.Event.GEOFENCESCHANGE:
      bg.GeofencesChangeEvent event = headlessEvent.event;
      print('[BackgroundGeolocation] Headless GEOFENCESCHANGE: $event');
      showNotification(
        title: '[BackgroundGeolocation] Headless GEOFENCESCHANGE',
        body: 'speed: $event',
      );
      break;
  }
}

/// Receive events from BackgroundFetch in Headless state
void backgroundFetchHeadlessTask() async {
  bg.Location location =
      await bg.BackgroundGeolocation.getCurrentPosition(samples: 1);
  await setupNotifications();
  print('[BackgroundFetch] Headless LOCATION: $location');
  showNotification(
    title: '[BackgroundFetch] Headless LOCATION',
    body: 'speed: ${location.coords.speed} time: ${location.timestamp}',
  );
  BackgroundFetch.finish();
}

/// Add a geofence to the plugin
void addGeofence({
  @required String id,
  @required double lat,
  @required double lng,
  @required int radius,
}) async {
  bg.Geofence geofence = bg.Geofence(
    identifier: id,
    latitude: lat,
    longitude: lng,
    radius: double.parse(radius.toString()),
    notifyOnEntry: true,
    notifyOnDwell: true,
    notifyOnExit: true,
  );

  try {
    await bg.BackgroundGeolocation.addGeofence(geofence);
  } catch (e) {
    print('Error adding geofence with id $id');
    return;
  }

  print('Successfully added geofence with id $id');
}

/// Initialize plugin to start tracking
Future<bool> startTracking({String env}) async {
  // Apply tracker url with username & device params for recognition by tracking server
  Map<String, dynamic> deviceParams = await bg.Config.deviceParams;

  await bg.BackgroundGeolocation.ready(bg.Config(
    desiredAccuracy: bg.Config.DESIRED_ACCURACY_HIGH,
    persistMode: bg.Config.PERSIST_MODE_GEOFENCE,
    logLevel: bg.Config.LOG_LEVEL_VERBOSE,
    stopOnTerminate: false,
    enableHeadless: true,
    startOnBoot: true,
    reset: true,
    autoSync: true,
    httpRootProperty: '.',
    locationTemplate:
        '{ "query": "mutation { insert_location(objects: { lat: <%= latitude %> lng: <%= longitude %> speed: <%= speed %> heading: <%= heading %> accuracy: <%= accuracy %> altitude: <%= altitude %> altitude_accuracy: <%= altitude_accuracy %> timestamp: \\\"<%= timestamp %>\\\" uuid: \\\"<%= uuid %>\\\" event: \\\"<%= event %>\\\" odometer: <%= odometer %> activity_type: \\\"<%= activity.type %>\\\" activity_confidence: <%= activity.confidence %> battery_level: <%= battery.level %> battery_is_charging: <%= battery.is_charging %> device_model: \\\"${deviceParams['device']['model']}\\\" device_platform: \\\"${deviceParams['device']['platform']}\\\" device_manufacturer: \\\"${deviceParams['device']['manufacturer']}\\\" device_version: \\\"${deviceParams['device']['version']}\\\" } ) { affected_rows } }" }',
    geofenceTemplate:
        '{ "query": "mutation { insert_location(objects: { lat: <%= latitude %> lng: <%= longitude %> speed: <%= speed %> heading: <%= heading %> accuracy: <%= accuracy %> altitude: <%= altitude %> altitude_accuracy: <%= altitude_accuracy %> timestamp: \\\"<%= timestamp %>\\\" uuid: \\\"<%= uuid %>\\\" event: \\\"<%= event %>\\\" odometer: <%= odometer %> activity_type: \\\"<%= activity.type %>\\\" activity_confidence: <%= activity.confidence %> battery_level: <%= battery.level %> battery_is_charging: <%= battery.is_charging %> device_model: \\\"${deviceParams['device']['model']}\\\" device_platform: \\\"${deviceParams['device']['platform']}\\\" device_manufacturer: \\\"${deviceParams['device']['manufacturer']}\\\" device_version: \\\"${deviceParams['device']['version']}\\\" geofence_identifier: \\\"<%= geofence.identifier %>\\\" geofence_action: \\\"<%= geofence.action %>\\\" } ) { affected_rows } }" }',
    url: '${appBase.hasuraUrl}',
    locationAuthorizationRequest: 'Always',
    locationAuthorizationAlert: {
      'titleWhenNotEnabled': 'Location services not enabled',
      'titleWhenOff': 'Location services are OFF',
      'instructions':
          'Location services required to start earning points. Please enable \'Always\' in location settings.',
      'cancelButton': 'Cancel',
      'settingsButton': 'Settings'
    },
    // Do not record location event if more than 300 meters/second since last
    // recorded event - Android only, iOS does not allow mock locations on device
    speedJumpFilter: 300,
    foregroundService: true,
    notificationPriority: bg.Config.NOTIFICATION_PRIORITY_MIN,
    notificationTitle: 'Zone Tracker',
    notificationText: 'Zone search underway',
    notificationChannelName: 'Zone Tracker',
  ));

  try {
    await bg.BackgroundGeolocation.startGeofences();
  } catch (e) {
    print(e);
  }

  // Register BackgroundGeolocation headless-task
  bg.BackgroundGeolocation.registerHeadlessTask(
      backgroundGeolocationHeadlessTask);

  // Register BackgroundFetch headless-task
  BackgroundFetch.registerHeadlessTask(backgroundFetchHeadlessTask);

  // Fired whenever a location is recorded
  bg.BackgroundGeolocation.onLocation((bg.Location location) {
    print('[BackgroundGeolocation] onLocation $location');
    showNotification(
      title: '[BackgroundGeolocation] onLocation',
      body: 'speed: ${location.coords.speed} time: ${location.timestamp}',
    );
  }, (bg.LocationError error) {
    print('[onLocation] ERROR: $error');
  });

  bg.BackgroundGeolocation.onHttp((bg.HttpEvent event) {
    print('[BackgroundGeolocation] onHttp $event');
  });

  bg.BackgroundGeolocation.onGeofence((bg.GeofenceEvent event) {
    print('[BackgroundGeolocation] onGeofence $event');
    showNotification(
      title: '[BackgroundGeolocation] onGeofence',
      body:
          'speed: ${event.location.coords.speed} time: ${event.location.timestamp}',
    );
  });

  try {
    // force location permission dialog
    await bg.BackgroundGeolocation.getCurrentPosition(
      persist: false,
      samples: 1,
    );
  } catch (e) {
    print(e);
    // Permission was denied
    if (e.code == 1) return false;
  }

  return true;
}

await bg.BackgroundGeolocation.start();