watchposition() issues

[petertoth-dev]

Environment

Platforms

iOS (not tested on Android)

Versions

• Android: -
• iOS: 17.5.1
• react-native-geolocation: 3.1.0
• react-native: 0.72.9
• react: 18.2.0

Description

For some reason if the watcher is active, and requests a location again, everything location-related response will stop working.
When I use Geolocation.getCurrentPosition() multiple times, everything is working. Some users have reported the same behavior, they just use setInterval() with getCurrentPosition() to update the location which is a VERY BAD practice regarding the battery and performance.

When I use watchposition() and do something that would request watchposition again, even if I make sure to clear the previous watch, everything, even the previous ones will stop working until I close and re-open the entire app. No workarounds, no errors, permissions are OK, everything has been checked and confirmed 100x.

So please just check what's going on and how to avoid stopping location tracking when watchposition() has been called.

Reproducible Demo

Sorry but I really don't have time to do that, but just take a look at the previous tickets, numerous are mentioning this huge and frustrating issue.

[petertoth-dev]

UPDATE:
Calling Geolocation.stopObserving() before watchPosition solved the issues. Something is off with the clearWatch method.

This is what's working:

    if (locationPermission === 'granted') {
      if(subscriptionIds?.length){
        for(const subscriptionId of subscriptionIds){
          Geolocation.clearWatch(subscriptionId)
        }
        setSubscriptionIds([]);
      }

      Geolocation.stopObserving();
        let watchPositionSubscriptionId = Geolocation.watchPosition(position => {
          console.log('-------> USER POSITION UPDATED' , position)
          setUserCoords([position.coords.longitude, position.coords.latitude]);
        },
        error => {
          console.log('!! ERROR watchPositionSubscriptionId', error)

        },
        {enableHighAccuracy: true, timeout: 15000, maximumAge: 10000});
        subscriptionIds.push(watchPositionSubscriptionId)
        setSubscriptionIds(subscriptionIds);
    }

But if I remove Geolocation.stopObserving(); the bug persists.

[michalchudziak]

Thanks for reporting the issue. clearWatch issues should be resolved in the 3.4.0 release. Please let me know if an update solved your case.

[ninacoder-info]

Thanks for reporting the issue. clearWatch issues should be resolved in the 3.4.0 release. Please let me know if an update solved your case.

Sorry but still same issue, I have to use Geolocation.stopObserving(); to start the tracking

[onlystard]

Thanks for reporting the issue. clearWatch issues should be resolved in the 3.4.0 release. Please let me know if an update solved your case.

I have the same issue

[petertoth-dev]

@michalchudziak well this didn't work out :))

[csimpi]

@michalchudziak why closed? Same error still.

[Nikolai141]

Hello still need to use Geolocation.stopObserving(); before watchPosition. Issue is still here!

[rodrigo2392]

Same issue, watch position not working at all on IOS

[petertoth-dev]

Dear everyone with the same problem, here's the ultimate production tested solution. Unfortunately this package is bugged and very unmaintained. React Native shouldn't drop this from the core and let community drive this part. This is too difficult to maintain by a developer.

So I am here for the rescue, many workarounds but it's perfect and performant:

const useWatchLocation = () => {
    const setUserLocation = useStore((state) => state.map.setUserLocation);
    useEffect(() => {
        if(RN_GEOLOCATION_WATCHERS && RN_GEOLOCATION_WATCHERS.length > 0) return;

        check(PERMISSIONS.LOCATION_ALWAYS.permission).then((status) => {

            if (status === RESULTS.GRANTED) {
                // Fix for long initial wait on Android
                if (Platform.OS === 'android') {
                    Geolocation.getCurrentPosition(position => {
                        setUserLocation(position);
                    });
                }

                // Start watching location
                const watcherId = Geolocation.watchPosition(
                    (position) => {
                        console.log('Position update:', position);
                        setUserLocation(position);
                    },
                    (error) => {
                        log.error('Watch Position Error:', error);
                    },
                    {
                        // interval (ms) -- (Android only) The rate in milliseconds at which your app prefers to receive location
                        interval: 1000, // TODO: Increase this in production
                        // timeout (ms)
                        timeout: 10,
                        // maximumAge (ms) - Is a positive value indicating the maximum age in milliseconds
                        maximumAge: 10 * 60 * 1000,
                        // enableHighAccuracy (bool) - Is a boolean representing if to use GPS or not. If set to true, a GPS position will be requested. If set to false, a WIFI location will be requested.
                        enableHighAccuracy: true,
                        // distanceFilter (m) - The minimum distance from the previous location to exceed
                        distanceFilter: 1,
                        // useSignificantChanges (bool) - Uses the battery-efficient native significant changes APIs
                        // useSignificantChanges: true, // TODO: Enable this in production
                    }
                );

                RN_GEOLOCATION_WATCHERS.push(watcherId);
            } else {
                console.warn('Location permission not granted');
            }
        });

        return () => {
            for(let k in RN_GEOLOCATION_WATCHERS){
                Geolocation.clearWatch(RN_GEOLOCATION_WATCHERS[k]);
                RN_GEOLOCATION_WATCHERS.splice(+k, 1);
            }
        };
    }, []);
};

export default useWatchLocation;

export const RN_GEOLOCATION_WATCHERS: any[] = [];

Explanation:
This package is bugged for many reasons, and the only way to make sure you won't use watchPosition twice is this ugly but stable way. Works for thousands of users with no issues. Just make sure you adjust the settings, since this is only for heavy testing.

[rodrigo2392]

@petertoth-dev agree with you with this library, so poor maintained.
So basically the issue is triggering the watchPosition function twice?

[petertoth-dev]

@petertoth-dev agree with you with this library, so poor maintained. So basically the issue is triggering the watchPosition function twice?

Yes, I can assure you this is definitely the issue. Even if you'd think you was sure to clear watches and stopObserving(), any single mistake will cause the position tracking die and you cannot enable it back unless you totally close and reboot the app.

If you make sure you never run it twice in one instance, it'll work.