AbstractLocationProvider.cs

using System.Collections;
using UnityEngine;
 
#if PLATFORM_ANDROID
using UnityEngine.Android;
#endif
 
namespace ARLocation
{
    public abstract class AbstractLocationProvider : ILocationProvider
    {
        protected double LowPassFilterFactor;
 
        public abstract string Name { get; }
 
        public LocationProviderOptions Options { get; set; }
 
        public LocationReading CurrentLocation { get; protected set; }
 
        public LocationReading LastLocation { get; protected set; }
 
        public LocationReading LastLocationRaw { get; protected set; }
 
        public LocationReading CurrentLocationRaw { get; protected set; }
 
        public HeadingReading CurrentHeading { get; protected set; }
 
        public HeadingReading LastHeading { get; protected set; }
 
        public LocationReading FirstLocation { get; protected set; }
 
        public LocationProviderStatus Status { get; protected set; }
 
        public bool IsEnabled { get; protected set; }
 
        public bool FirstReading { get; protected set; }
 
        public abstract bool IsCompassEnabled { get; }
 
        public float StartTime { get; protected set; }
 
        public bool Paused { get; protected set; }
 
        public int LocationUpdateCount { get; protected set; }
        public bool HasStarted => Status == LocationProviderStatus.Started;
        public bool ApplyCompassTiltCompensationOnAndroid { get; set; } = true;
 
        public double DistanceFromStartPoint
        {
            get { return LocationReading.HorizontalDistance(FirstLocation, CurrentLocation); }
        }
 
        public event LocationUpdatedDelegate LocationUpdated;
 
        public event CompassUpdateDelegate CompassUpdated;
 
        public event LocationEnabledDelegate LocationEnabled;
        public event LocationFailedDelegate LocationFailed;
        public event LocationUpdatedDelegate LocationUpdatedRaw;
        protected abstract LocationReading? ReadLocation();
 
        protected abstract HeadingReading? ReadHeading();
 
        protected abstract void RequestLocationAndCompassUpdates();
 
        protected abstract void UpdateLocationRequestStatus();
 
        protected AbstractLocationProvider()
        {
            IsEnabled = false;
            FirstReading = true;
            Paused = false;
            Status = LocationProviderStatus.Idle;
        }
 
        public virtual IEnumerator Start(uint maxWaitTime = 10000, uint delay = 0)
        {
            // Debug.Log("[AbstractLocationProvider]: Starting...");
 
#if PLATFORM_ANDROID
            if (!Permission.HasUserAuthorizedPermission(Permission.FineLocation))
            {
                Permission.RequestUserPermission(Permission.FineLocation);
            }
 
            yield return new WaitForSeconds(1);
#endif
 
            if (delay > 0)
            {
                yield return new WaitForSeconds(delay);
            }
 
            RequestLocationAndCompassUpdates();
            uint maxWait = maxWaitTime;
            UpdateLocationRequestStatus();
            while (Status == LocationProviderStatus.Initializing && maxWait > 0)
            {
                // Debug.Log("[AbstractLocationProvider]: Wait... " + maxWait);
 
                yield return new WaitForSeconds(1);
                maxWait--;
                UpdateLocationRequestStatus();
            }
 
            if (maxWait < 1)
            {
                // Debug.LogError("[AbstractLocationProvider]: Timed out.");
 
                LocationFailed?.Invoke("Timed out");
 
                yield break;
            }
 
            if (Status == LocationProviderStatus.Failed)
            {
                // Debug.LogError("[AbstractLocationProvider]: Falied to initialize location updates.");
 
                LocationFailed?.Invoke("Falied to initialize location updates.");
 
                yield break;
            }
 
            if (Status != LocationProviderStatus.Started)
            {
                // Debug.LogError("[AbstractLocationProvider]: Unknown error initializing location updates. " + Status);
 
                LocationFailed?.Invoke("Unknown error initializing location updates.");
 
                yield break;
            }
 
            // Debug.Log("[AbstractLocationProvider]: Started!");
 
            FirstReading = true;
            StartTime = Time.time;
        }
 
        public void ForceLocationUpdate()
        {
            LocationUpdated?.Invoke(CurrentLocation, LastLocation);
            LocationUpdatedRaw?.Invoke(CurrentLocationRaw, LastLocationRaw);
        }
 
        protected virtual void InnerOnEnabled()
        {
 
        }
 
 
        protected void EmitLocationUpdated()
        {
            LocationUpdated?.Invoke(CurrentLocation, LastLocation);
        }
 
        protected void EmitLocationUpdatedRaw()
        {
            LocationUpdatedRaw?.Invoke(CurrentLocationRaw, LastLocationRaw);
        }
 
        protected void EmitCompassUpdated()
        {
            CompassUpdated?.Invoke(CurrentHeading, LastHeading);
        }
 
        protected void UpdateLocation(LocationReading newLocation)
        {
            if (newLocation.timestamp == CurrentLocationRaw.timestamp)
            {
                return;
            }
 
            LastLocationRaw = CurrentLocationRaw;
            CurrentLocationRaw = newLocation;
 
            EmitLocationUpdatedRaw();
 
            if (!ShouldUpdateLocation(newLocation))
            {
                return;
            }
 
            LastLocation = CurrentLocation;
            CurrentLocation = newLocation;
 
            LocationUpdateCount++;
 
            EmitLocationUpdated();
        }
 
        protected void UpdateHeading(HeadingReading newHeading)
        {
            if (!ShouldUpdateHeading(newHeading))
            {
                return;
            }
 
            LastHeading = CurrentHeading;
 
            CurrentHeading = newHeading;
 
            EmitCompassUpdated();
        }
 
        protected bool ShouldUpdateHeading(HeadingReading newHeading)
        {
            if (newHeading.timestamp == CurrentHeading.timestamp)
            {
                return false;
            }
 
            return true;
        }
 
        protected bool ShouldUpdateLocation(LocationReading newLocation)
        {
            if (Paused)
            {
                return false;
            }
 
            if (newLocation.timestamp - CurrentLocation.timestamp < ((long) (Options.TimeBetweenUpdates * 1000)))
            {
                return false;
            }
 
            if (LocationReading.HorizontalDistance(newLocation, CurrentLocation) < Options.MinDistanceBetweenUpdates)
            {
                return false;
            }
 
            if ((newLocation.accuracy > Options.AccuracyRadius) && (Options.AccuracyRadius > 0))
            {
                return false;
            }
 
 
            return true;
        }
 
        public virtual void Update()
        {
            if (!HasStarted)
            {
                return;
            }
 
            var location = ReadLocation();
            var heading = ReadHeading();
 
            if (location == null || heading == null)
            {
                // Debug.Log("[AbstractLocationProvider]: Null reading");
                return;
            }
 
            if (FirstReading)
            {
                FirstLocation = location.Value;
                CurrentLocation = FirstLocation;
                CurrentLocationRaw = FirstLocation;
                CurrentHeading = heading.Value;
 
                IsEnabled = true;
                FirstReading = false;
 
                LocationEnabled?.Invoke();
                InnerOnEnabled();
 
                EmitCompassUpdated();
                EmitLocationUpdated();
                EmitLocationUpdatedRaw();
 
                return;
            }
 
            UpdateLocation(location.Value);
            UpdateHeading(heading.Value);
        }
 
        public void Restart()
        {
            LocationUpdateCount = 0;
            FirstReading = true;
        }
 
        public void ResetStartPoint()
        {
            FirstLocation = CurrentLocation;
        }
 
        public void SetCompassLowPassFactor(double factor)
        {
            LowPassFilterFactor = factor;
        }
 
        public string GetStatusString()
        {
            switch (Status)
            {
                case LocationProviderStatus.Idle:
                    return "Idle";
                case LocationProviderStatus.Failed:
                    return "Failed";
                case LocationProviderStatus.Initializing:
                    return "Initializing";
                case LocationProviderStatus.Started:
                    return "Started";
            }
 
            return "UnknownStatus";
        }
 
        public string GetInfoString()
        {
            return Name +
                "{ \n" +
                CurrentLocation + "\n" +
                CurrentHeading + "\n" +
                "Status = " + GetStatusString() + "\n" +
                "DistanceFromStartPoint = " + DistanceFromStartPoint + "\n" +
                "TimeSinceStart = " + (Time.time - StartTime) + "\n" +
                "}";
        }
 
        public void OnEnabled(LocationEnabledDelegate del)
        {
            LocationEnabled += del;
 
            if (IsEnabled)
            {
                del();
            }
        }
 
        public void OnFail(LocationFailedDelegate del)
        {
            LocationFailed += del;
        }
 
        public void Pause()
        {
            Paused = true;
        }
 
        public void Resume()
        {
            Paused = false;
        }
    }
}