ARLocationProvider.cs

using System;
using System.Collections;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Serialization;
// ReSharper disable UnusedMember.Global
 
 
namespace ARLocation
{
    using Utils;
 
    [AddComponentMenu("AR+GPS/AR Location Provider")]
    [HelpURL("https://http://docs.unity-ar-gps-location.com/guide/#arlocationprovider")]
    [DisallowMultipleComponent]
    public class ARLocationProvider : Singleton<ARLocationProvider>
    {
        [Serializable]
        public class LocationEnabledUnityEvent : UnityEvent<Location> {}
        [Serializable]
        public class LocationUpdatedUnityEvent : UnityEvent<Location> {}
 
        [Serializable]
        public class CompassUpdatedUnityEvent: UnityEvent<HeadingReading> {}
 
        [FormerlySerializedAs("LocationUpdateSettings")]
        [Tooltip("The options for the Location Provider.")]
        [Header("Update Settings")]
        public LocationProviderOptions LocationProviderSettings = new LocationProviderOptions();
 
        [Tooltip("The data of mock location. If present, overrides the Mock Location above.")]
        [Header("Mock Data")]
        public LocationData MockLocationData;
 
        [Tooltip("The maximum wait time to wait for location initialization.")]
        [Header("Initialization")]
        public uint MaxWaitTime = 200;
 
        [Tooltip("Wait this many seconds before starting location services. Useful when using Unity Remote.")]
        public uint StartUpDelay;
 
        [Header("Debug")]
        [Tooltip("When debug mode is enabled, this component will print relevant messages to the console. Filter by 'ARLocationProvider' in the log output to see the messages.")]
        public bool DebugMode;
 
        [Header("Events")]
 
        [Tooltip("Called after the first location is read.")]
        public LocationEnabledUnityEvent OnEnabled = new LocationEnabledUnityEvent();
 
        [Tooltip("Called after each new location update.")]
        public LocationUpdatedUnityEvent OnLocationUpdated = new LocationUpdatedUnityEvent();
 
        [Tooltip("Called after each new raw device GPS data is obtained.")]
        public LocationUpdatedUnityEvent OnRawLocationUpdated = new LocationUpdatedUnityEvent();
 
        [Tooltip("Called after each new compass update.")]
        public CompassUpdatedUnityEvent OnCompassUpdated = new CompassUpdatedUnityEvent();
 
        public ILocationProvider Provider { get; private set; }
 
        public bool IsEnabled => Provider.IsEnabled;
 
        public bool HasStarted => Provider.HasStarted;
 
        public int LocationUpdateCount => Provider.LocationUpdateCount;
 
        public bool IsPaused => Provider.Paused;
 
        public LocationReading CurrentLocation => Provider.CurrentLocation;
 
        public LocationReading LastLocation => Provider.LastLocation;
 
        public HeadingReading CurrentHeading => Provider.CurrentHeading;
 
 
        public float TimeSinceStart => Time.time - Provider.StartTime;
 
        public double DistanceFromStartPoint => Provider.DistanceFromStartPoint;
 
        private int measurementCount;
        private bool mute;
 
        public event LocationUpdatedDelegate OnLocationUpdatedDelegate;
        public event CompassUpdateDelegate OnCompassUpdateDelegate;
        public event Action OnRestartDelegate;
 
        private Vector3 cameraPositionAtLastUpdate;
        public override void Awake()
        {
            base.Awake();
 
#if UNITY_EDITOR
            Provider = new MockLocationProvider();
 
            if (MockLocationData != null)
            {
                Logger.LogFromMethod("ARLocationProvider", "Awake", $"Using mock location {MockLocationData}", DebugMode);
                ((MockLocationProvider) Provider).mockLocation = MockLocationData.Location;
            }
#elif ARGPS_CUSTOM_PROVIDER
        // If you want to use a custom location provider, add 'ARGPS_CUSTOM_PROVIDER' to the define symbols in the Player
        // settings, create a implementation of ILocationProvider, and instantiate it in the line below.
        Provider = new ARGpsCustomLocationProvider();
#else
        Provider = new UnityLocationProvider();
#endif
            Logger.LogFromMethod("ARLocationProvider", "Awake",": Using provider " + Provider.Name, DebugMode);
        }
 
 
 
        private void InitProviderEventListeners()
        {
            Logger.LogFromMethod("ARLocationProvider", "InitProviderEventListeners","Initializing location provider listeners.", DebugMode);
 
            Provider.LocationUpdated += Provider_LocationUpdated;
            Provider.CompassUpdated += Provider_CompassUpdated;
            Provider.LocationUpdatedRaw += ProviderOnLocationUpdatedRaw;
 
            Provider.OnEnabled(OnProviderEnabledDelegate);
 
            if (Provider.IsEnabled)
            {
                ForceLocationUpdate();
            }
        }
 
        private void ProviderOnLocationUpdatedRaw(LocationReading currentLocation, LocationReading lastLocation)
        {
            OnRawLocationUpdated?.Invoke(currentLocation.ToLocation());
        }
 
        private void OnProviderEnabledDelegate()
        {
            Logger.LogFromMethod("ARLocationProvider", "OnProviderEnabledDelegate","Provider enabled; emitting 'OnEnabled' event.", DebugMode);
            OnEnabled?.Invoke(CurrentLocation.ToLocation());
        }
 
        IEnumerator Start()
        {
            InitProviderEventListeners();
 
            Provider.Options = LocationProviderSettings;
 
            Logger.LogFromMethod("ARLocationProvider", "Start","Starting the location provider", DebugMode);
            yield return StartCoroutine(Provider.Start(MaxWaitTime, StartUpDelay));
        }
 
        public void Mute()
        {
            Logger.LogFromMethod("ARLocationProvider", "Mute","Muting ARLocationProvider.", DebugMode);
            mute = true;
        }
 
        public void Unmute(bool emit = true)
        {
            Logger.LogFromMethod("ARLocationProvider", "Mute","Un-muting ARLocationProvider.", DebugMode);
            mute = false;
            if (Provider.IsEnabled && emit) ForceLocationUpdate();
        }
 
        private void Provider_CompassUpdated(HeadingReading heading, HeadingReading lastReading)
        {
            if (mute) return;
 
            OnCompassUpdateDelegate?.Invoke(heading, lastReading);
            OnCompassUpdated?.Invoke(heading);
        }
 
        private void Provider_LocationUpdated(LocationReading currentLocation, LocationReading lastLocation)
        {
            if (mute) return;
 
            measurementCount++;
 
            if ((LocationProviderSettings.MaxNumberOfUpdates > 0) && (measurementCount >= LocationProviderSettings.MaxNumberOfUpdates))
            {
                Provider.Pause();
            }
 
            Logger.LogFromMethod("ARLocationProvider", "Provider_LocationUpdated",$"New location {currentLocation}.", DebugMode);
 
            cameraPositionAtLastUpdate = ARLocationManager.Instance.MainCamera.transform.position;
            OnLocationUpdatedDelegate?.Invoke(currentLocation, lastLocation);
            OnLocationUpdated?.Invoke(currentLocation.ToLocation());
        }
 
        public void ForceLocationUpdate()
        {
            Logger.LogFromMethod("ARLocationProvider", "ForceLocationUpdate","Emitting a forced location update", DebugMode);
            Provider.ForceLocationUpdate();
        }
 
        void Update()
        {
            if (Provider == null || !Provider.HasStarted)
            {
                return;
            }
 
            Provider.Update();
        }
 
        public void Pause()
        {
            Logger.LogFromMethod("ARLocationProvider", "Pause","Pausing the location provider.", DebugMode);
            Provider?.Pause();
        }
 
        public void Resume()
        {
            Logger.LogFromMethod("ARLocationProvider", "Resume","Resuming the location provider.", DebugMode);
            Provider?.Resume();
        }
 
        public void Restart()
        {
            Logger.LogFromMethod("ARLocationProvider", "Restart","Restarting the location provider.", DebugMode);
            Provider?.Restart();
            OnRestartDelegate?.Invoke();
        }
 
        public void OnLocationUpdatedEvent(LocationUpdatedDelegate locationUpdatedDelegate, bool useRawIfEnabled = false)
        {
            if (IsEnabled)
            {
                locationUpdatedDelegate(CurrentLocation, useRawIfEnabled ? Provider.LastLocationRaw : LastLocation);
            }
 
            OnLocationUpdatedDelegate += locationUpdatedDelegate;
        }
 
        public void OnProviderRestartEvent(Action del)
        {
            OnRestartDelegate += del;
        }
 
        public void OnCompassUpdatedEvent(CompassUpdateDelegate compassUpdateDelegate)
        {
            OnCompassUpdateDelegate += compassUpdateDelegate;
        }
 
        public void OnEnabledEvent(LocationEnabledDelegate del)
        {
            Provider.OnEnabled(del);
        }
 
        public void OnFailedEvent(LocationFailedDelegate del)
        {
            Provider.OnFail(del);
        }
 
        public Location GetLocationForWorldPosition(Vector3 position)
        {
            var cameraDelta = ARLocationManager.Instance.MainCamera.transform.position - cameraPositionAtLastUpdate;
            return Location.GetLocationForWorldPosition(gameObject.transform, cameraPositionAtLastUpdate, CurrentLocation.ToLocation(), position - cameraDelta);
        }
    }
}