Locations are not getting frequently

Your Environment

Plugin version:
Platform: iOS or Android
OS version:
Device manufacturer / model:
Flutter info (flutter doctor):

Plugin config:


class LiveTrackingHelper {
// static Timer? _timer;
static void startTracking() async {
await _startTracking();
// startRiderLocationLog();
}

static void endTracking(String routeFrom) async {
await bg.BackgroundGeolocation.removeGeofences();
await bg.BackgroundGeolocation.stop();
await bg.BackgroundGeolocation.destroyLocations();
await bg.BackgroundGeolocation.stopSchedule();
await analyticsService.logEvent(
  screen: ScreensKey.liveTracking,
  type: AnalyticsKey.endLiveTrackingSuccess,
  data: {AppKeys.routeFrom: routeFrom},
);
logger.d('LiveTracking [endTracking] routeFrom - $routeFrom \n');
// stopRiderLocationLog();
}

// static void startRiderLocationLog() {
//   stopRiderLocationLog();
//   _timer = Timer.periodic(const Duration(seconds: 10), (timer) {
//     updateRiderLocation();
//   });
// }

// static void stopRiderLocationLog() {
//   _timer?.cancel();
//   _timer = null;
// }

// The function to be called periodically
// static void updateRiderLocation() async {
//   if (_timer != null && _timer!.isActive) {
//     final response = await riderStatusRepo.updateRiderLocation();
//   }
// }

static bool canDisableLiveTracking() {
return false;
}

static Future<void> _startTracking() async {
await bg.BackgroundGeolocation.removeGeofences();
bg.BackgroundGeolocation.onLocation(_onLocation, _onLocationError);
bg.BackgroundGeolocation.onMotionChange(_onMotionChange);
bg.BackgroundGeolocation.onActivityChange(_onActivityChange);
bg.BackgroundGeolocation.onProviderChange(_onProviderChange);
bg.BackgroundGeolocation.onConnectivityChange(_onConnectivityChange);
bg.BackgroundGeolocation.onHttp(_onHttp);
bg.BackgroundGeolocation.onAuthorization(_onAuthorization);
bg.BackgroundGeolocation.onHeartbeat(_onHeartbeat);
bg.BackgroundGeolocation.onGeofence(_onGeofenceAdd);

String token = auth.user.tokenId;
String refreshToken = auth.user.refreshToken;
String email = auth.user.profile.email;
String? attributeValue = businessSettingsService.settings.appSectionConfig
    .firstWhereOrNull((e) => e.attribute == AppKeys.distanceFilter)
    ?.attributeValue;
double? distanceFilter =
    attributeValue != null ? double.parse(attributeValue) : null;
String? locationUpdateIntervalValue = businessSettingsService
    .settings.appSectionConfig
    .firstWhereOrNull((e) => e.attribute == AppKeys.locationUpdateInterval)
    ?.attributeValue;
int? locationUpdateInterval = locationUpdateIntervalValue != null
    ? int.parse(locationUpdateIntervalValue)
    : null;

logger.d(
  'LiveTracking config setting distanceFilter $distanceFilter locationUpdateInterval $locationUpdateInterval\n',
);

// 2.  Configure the plugin
bg.BackgroundGeolocation.ready(
  bg.Config(
    debug: true,
    locationUpdateInterval: locationUpdateInterval,
    logLevel: bg.Config.LOG_LEVEL_VERBOSE,
    desiredAccuracy: bg.Config.DESIRED_ACCURACY_HIGH,
    distanceFilter: distanceFilter,
    stopTimeout: 15,
    heartbeatInterval: 120,
    backgroundPermissionRationale: bg.PermissionRationale(
      title: "Allow {applicationName} to access this device's location.",
      message:
          "This app collects location data to enable geofence your destination point",
      positiveAction: 'Change to "{backgroundPermissionOptionLabel}"',
      negativeAction: 'Cancel',
    ),
    url:
        "${appConfig.serverConfig.baseUrl}${AppEndpoints.updateRiderLocation}",
    authorization: bg.Authorization(
      strategy: bg.Authorization.STRATEGY_JWT,
      accessToken: token,
      refreshToken: refreshToken,
      refreshUrl: "${appConfig.serverConfig.baseUrl}/api/refresh_token",
      refreshPayload: {'refresh_token': '{refreshToken}'},
    ),
    params: {
      AppKeys.riderId: email,
      AppKeys.application: AppKeys.eR,
    },
    showsBackgroundLocationIndicator: true,
    autoSync: true,
    stopOnTerminate: false,
    startOnBoot: true,
    enableHeadless: true,
  ),
).then((bg.State state) async {
  logger.d("LiveTracking [ready] ${state.toMap()} \n");
  await analyticsService.logEvent(
    screen: ScreensKey.liveTracking,
    type: AnalyticsKey.configLiveTrackingSuccess,
    data: {'state': state.toMap()},
  );
}).catchError((error) {
  logger.d('LiveTracking [ready] ERROR: $error \n');
  analyticsService.logError(
    ScreensKey.liveTracking,
    AnalyticsKey.configLiveTrackingError,
    {
      AppKeys.error: error.toString(),
    },
  );
});

_configureBackgroundFetch();
bg.BackgroundGeolocation.start().then((bg.State state) async {
  logger.d('LiveTracking [start] success $state \n');
  await analyticsService.logEvent(
    screen: ScreensKey.liveTracking,
    type: AnalyticsKey.startLiveTrackingSuccess,
    data: {'state': state.toMap()},
  );
  await initGeofencing();
});
}

static Future<void> initGeofencing() async {
try {
  bool bulkOORGeofencing = businessSettingsService.settings.features
      .contains(AppKeys.bulkOORGeofencing);
  bool nearByCheckpoint = businessSettingsService.settings.features
      .contains(AppKeys.nearByCheckpoint);
  if (!bulkOORGeofencing && !nearByCheckpoint) {
    return;
  }
  String? geoFenceRadiusattributeValue = businessSettingsService
      .settings.appSectionConfig
      .firstWhereOrNull((e) => e.attribute == AppKeys.geofenceRadius)
      ?.attributeValue;
  double geofenceRadius = geoFenceRadiusattributeValue != null
      ? double.parse(geoFenceRadiusattributeValue)
      : 2000;
  String? nearByCheckpointRadiusValue =
      businessSettingsService.settings.appSectionConfig
          .firstWhereOrNull(
            (e) => e.attribute == AppKeys.nearByCheckpointRadius,
          )
          ?.attributeValue;
  double nearByCheckpointRadius = nearByCheckpointRadiusValue != null
      ? double.parse(nearByCheckpointRadiusValue)
      : 2000;
  List<bg.Geofence> newGeofences = [];
  List<WarehouseDetails> warehouseDetails =
      await warehouseDetailsRepo.getWarehouseDetailsList(getLocal: true);
  if (warehouseDetails.isNotEmpty) {
    newGeofences = warehouseDetails
        .where(
          (element) =>
              (element.latitude != 0.0 && element.longitude != 0.0),
        )
        .toList()
        .map((e) {
      return bg.Geofence(
        identifier: e.name,
        radius: geofenceRadius,
        latitude: e.latitude,
        longitude: e.longitude,
        notifyOnEntry: true,
        notifyOnExit: true,
      );
    }).toList();
  }
  List<TaskDetailsModel> consigmentList =
      await taskListRepo.getTaskDetailsList(getLocal: true);
  if (consigmentList.isNotEmpty) {
    List<bg.Geofence> customerGeofences = consigmentList
        .where(
          (element) =>
              (element.latitude.isNotEmpty &&
                  double.parse(element.latitude) != 0.0) &&
              element.status != TaskStatus.delivered,
        )
        .toList()
        .map((e) {
      return bg.Geofence(
        identifier: e.consigneeName,
        radius: nearByCheckpointRadius,
        latitude: double.parse(e.latitude),
        longitude: double.parse(e.longitude),
        notifyOnEntry: true,
        notifyOnExit: true,
        extras: {
          'type': 'customer',
          'tracking_ids': [e.trackingId],
        },
      );
    }).toList();
    newGeofences.addAll(customerGeofences);
  }
  if (newGeofences.isNotEmpty) {
    logger.d(
      "LiveTracking [newGeofences]: ${newGeofences.map((i) => i.toMap()).toList()} \n",
    );
    await bg.BackgroundGeolocation.addGeofences(newGeofences);
    bg.BackgroundGeolocation.startGeofences();
    analyticsService.logEvent(
      screen: ScreensKey.liveTracking,
      type: AnalyticsKey.dataGeofencing,
      data: {
        AppKeys.data: newGeofences.map((e) => e.toMap()).toList(),
      },
    );
  }
} catch (e) {
  logger.e('initGeofencing', e);
  analyticsService.logError(
    ScreensKey.liveTracking,
    AnalyticsKey.initGeofencing,
    {
      AppKeys.error: e.toString(),
    },
  );
}
}

static void _configureBackgroundFetch() async {
await BackgroundFetch.configure(
    BackgroundFetchConfig(
      minimumFetchInterval: 15,
      startOnBoot: true,
      stopOnTerminate: false,
      enableHeadless: true,
      requiresStorageNotLow: false,
      requiresBatteryNotLow: false,
      requiresCharging: false,
      requiresDeviceIdle: false,
      requiredNetworkType: NetworkType.NONE,
    ), (String taskId) async {
  if (taskId == 'flutter_background_fetch') {
    try {
      if (auth.user.profile.phoneNo.isNotEmpty) {
        // Fetch current position
        bg.Location location =
            await bg.BackgroundGeolocation.getCurrentPosition(samples: 1);
        LiveTrackingDetails locationData = LiveTrackingDetails(
          location: location,
          riderId: auth.user.profile.email,
          application: AppKeys.eR,
        );
        await riderStatusRepo.updateRiderLocation(
          liveTrackingDetails: locationData,
        );
        await analyticsService.logEvent(
          screen: ScreensKey.liveTracking,
          type: AnalyticsKey.backgroundFetchLocation,
          data: {'state': location.toMap()},
        );
      }
    } catch (error) {
      analyticsService.logError(
        ScreensKey.liveTracking,
        AnalyticsKey.postLiveTrackingError,
        {
          AppKeys.error: error.toString(),
        },
      );
    }
  }
  BackgroundFetch.finish(taskId);
});
}

static void _onLocation(bg.Location location) {
logger.d('LiveTracking [location] - $location \n');
}

static void _onLocationError(bg.LocationError error) {
logger.d('LiveTracking [location] ERROR - $error \n');
analyticsService.logError(
  ScreensKey.liveTracking,
  AnalyticsKey.onLocationError,
  {
    AppKeys.error: error.toString(),
  },
);
}

static void _onMotionChange(bg.Location location) {
if (location.isMoving) {
  logger.d(
    'LiveTracking [onMotionChange] Device has just started MOVING $location \n',
  );
} else {
  logger.d(
    'LiveTracking [onMotionChange] Device has just STOPPED:  $location \n',
  );
}
}

static void _onActivityChange(bg.ActivityChangeEvent event) {
logger.d('LiveTracking [activityChange] - $event \n');
}

static void _onProviderChange(bg.ProviderChangeEvent event) async {
logger.d('LiveTracking [providerChange] - $event \n');
if (event.enabled &&
    (event.status == bg.ProviderChangeEvent.AUTHORIZATION_STATUS_ALWAYS)) {
  await secureStorageService.write(AppKeys.isLiveTrackingEnabled, '1');
  await secureStorageService.write(
    AppKeys.liveTrackingDate,
    AppDateTime.dateTime(DateTime.now()),
  );
  analyticsService.logEvent(
    screen: ScreensKey.liveTracking,
    type: AnalyticsKey.liveTrackingEnabled,
    data: {
      AppKeys.isLiveTrackingEnabled: '1',
      AppKeys.liveTrackingDate: AppDateTime.dateTime(DateTime.now()),
    },
  );
}
}

static void _onHttp(bg.HttpEvent event) async {
logger.d('LiveTracking [HttpEvent] - $event \n');
int status = event.status;
bool success = event.success;
String responseText = event.responseText;
if (status == 200) {
  await secureStorageService.write(AppKeys.isLiveTrackingEnabled, '1');
  await secureStorageService.write(
    AppKeys.liveTrackingDate,
    AppDateTime.dateTime(DateTime.now()),
  );
}
}

static void _onAuthorization(bg.AuthorizationEvent event) async {
logger.d('LiveTracking [authorization] - $event \n');
if (event.success) {
  logger.d("LiveTracking - Authorization response: ${event.response} \n");
} else {
  logger.d("LiveTracking - Authorization error: ${event.error} \n");
}
}

static void _onConnectivityChange(bg.ConnectivityChangeEvent event) {
logger.d('LiveTracking [connectivityChange] - $event \n');
}

static void _onHeartbeat(bg.HeartbeatEvent event) {
logger.d('LiveTracking [heartBeat] - $event \n');
}

static void _onGeofenceAdd(bg.GeofenceEvent event) async {
logger.d('LiveTracking [GeofenceEvent] - $event \n');
try {
  bool bulkOORGeofencing = businessSettingsService.settings.features
      .contains(AppKeys.bulkOORGeofencing);
  if (event.action == AppKeys.exitU && bulkOORGeofencing) {
    List<TaskDetailsModel> taskDetailsList =
        await taskListRepo.getTaskDetailsList(getLocal: true);
    List<String> trackingIdList = TaskListHelper.getDFConsignmentIDs(
      taskDetailsList: taskDetailsList,
    );
    if (trackingIdList.isNotEmpty) {
      LocationModel location = await locationService.fetch();
      bool result = await checkPointRepo.submitTask(
        checkPointData: CheckPointModel(
          trackingId: trackingIdList,
          checkPoint: TaskCheckpoint.outOnRoad.getCheckPointCode,
          latitude: location.latitude,
          longitude: location.longitude,
          reason: "",
          resourceId: auth.user.profile.email,
          finalItems: [],
          paymentReceived: [],
        ),
        isBackground: true,
      );
      if (result) {
        trackingIdList.forEach((id) async {
          await taskListLocalDS.updateTask(
            id: id,
            consignmentStatus:
                TaskCheckpoint.outOnRoad.getUpdatedStatusForCheckPoint,
          );
        });
        overlayService.showSuccessToast(
          LocaleKeys.bulkOORUpdatedSuccessfully.trl(),
        );
      }
    }
  }
  if (event.action == AppKeys.enterU &&
      event.extras != null &&
      (event.extras!.isNotEmpty && event.extras!['type'] == 'customer')) {
    if (event.extras!['tracking_ids'] is List) {
      List<String> trackingIdList =
          List<String>.from(event.extras!['tracking_ids']);
      List<TaskDetailsModel> taskDetailsList =
          await taskListRepo.getTaskDetailsList(getLocal: true);
      List<TaskDetailsModel> taskDetails = taskDetailsList
          .where((e) => e.trackingId == trackingIdList[0])
          .toList();
      bool allowCheckPoint = CheckPointCrudOperation
                  .instance.reachedLocationCheckPointPlayed.isNotEmpty &&
              trackingIdList.isNotEmpty &&
              taskDetails.isNotEmpty &&
              CheckPointCrudOperation.instance
                      .reachedLocationCheckPointPlayed[trackingIdList[0]] !=
                  null
          ? CheckPointCrudOperation
              .instance.reachedLocationCheckPointPlayed[trackingIdList[0]]!
          : false;
      EasyThrottle.throttle(
          'reach_at_location_throttle', const Duration(seconds: 5),
          () async {
        if (trackingIdList.isNotEmpty &&
            taskDetails.isNotEmpty &&
            taskDetails[0].status == TaskStatus.outOnRoad &&
            !allowCheckPoint) {
          CheckPointCrudOperation.instance
              .reachedLocationCheckPointPlayed[trackingIdList[0]] = true;
          bool result = await checkPointRepo.submitTask(
            checkPointData: CheckPointModel(
              trackingId: trackingIdList,
              checkPoint:
                  TaskCheckpoint.pickerReachedAtLocation.getCheckPointCode,
              latitude: event.location.coords.latitude.toString(),
              longitude: event.location.coords.longitude.toString(),
              reason: "",
              resourceId: auth.user.profile.email,
              finalItems: [],
              paymentReceived: [],
            ),
            isBackground: true,
          );
          if (result) {
            trackingIdList.forEach((id) async {
              await taskListLocalDS.updateTask(
                id: id,
                consignmentStatus: TaskCheckpoint
                    .pickerReachedAtLocation.getUpdatedStatusForCheckPoint,
              );
            });
            CheckPointCrudOperation.instance
                .reachedLocationCheckPointPlayed[trackingIdList[0]] = false;
            overlayService.showSuccessToast(
              LocaleKeys.checkpointUpdatedSuccessfully.trl(),
            );
          }
        }
      });
    }
  }
} catch (err) {
  logger.d("LiveTracking - _onGeofenceAdd error: $err \n");
  analyticsService.logError(
    ScreensKey.liveTracking,
    AnalyticsKey.onGeofenceError,
    {
      AppKeys.error: err.toString(),
    },
  );
}
}
}


## Expected Behavior
The location should get updated to server

## Actual Behavior
Very few locations are getting updated on the server. I tried using distance Filter with 10 value also tried locationUpdateInterval with 5 secs. Still I am not getting locations on regular basis. 

## Steps to Reproduce
<!--- reproduce this issue; include code to reproduce, if relevant -->
1.
2.
3.
4.

## Context
I have a delivery app, where I want to track delivery person's location on regular basis. Whenever a person marks his availability I start the live tracking from the startTracking helper method. I want regular locations whenever a person moves from one location to another location. I have 2 different Delivery apps with different codes, I am using the same transistor license in both app. In old delivery app this location package working fine, but in new delivery app it is giving mentioned issue.

Note:
1. I am using 2 different Delivery apps with different codes but with the same package name.
2. We have purchased transistor license, which we are using in both the apps.

## Debug logs
<!-- include iOS / Android logs
- ios XCode logs,
- use #getLog #emailLog methods (@see docs)
- Android: $ adb logcat -s TSLocationManager
-->
<details>
    <summary>Logs</summary>

``` <!-- syntax-highligting:  DO NOT REMOVE -->
PASTE_YOUR_LOGS_HERE

transistorsoft / flutter_background_geolocation

Locations are not getting frequently #1346

Your Environment