GPSTracker

using Android.App;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Android.Content;
using Android.OS;
using Android.Locations;
using Android.Runtime;
using Android.Util;
using Java.Util;
using Java.IO;

namespace DSP.Droid
{
    [Service]
    public class GPSTracker : Service , ILocationListener
    {

        private static string TAG = "GPSTracker";

        private  Context mContext;

        // flag for GPS Status
    bool isGPSEnabled = false;

        // flag for network status
        bool isNetworkEnabled = false;

        // flag for GPS Tracking is enabled
        bool isGPSTrackingEnabled = false;

        Location location;
        double latitude;
        double longitude;

        // How many Geocoder should return our GPSTracker
        int geocoderMaxResults = 1;

        // The minimum distance to change updates in meters
        private static  long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters

        // The minimum time between updates in milliseconds
        private static  long MIN_TIME_BW_UPDATES = 1000 * 60 * 1; // 1 minute

        // Declaring a Location Manager
        protected LocationManager locationManager;

        // Store LocationManager.GPS_PROVIDER or LocationManager.NETWORK_PROVIDER information
        private string provider_info;

        public GPSTracker(Context context)
        {
            this.mContext = context;
            getLocation();
        }

        /**
         * Try to get my current location by GPS or Network Provider
         */
        public void getLocation()
        {

            try
            {
                locationManager = (LocationManager)mContext.GetSystemService(LocationService);

                //getting GPS status
                isGPSEnabled = locationManager.IsProviderEnabled(LocationManager.GpsProvider);

                //getting network status
                isNetworkEnabled = locationManager.IsProviderEnabled(LocationManager.NetworkProvider);

                // Try to get location if you GPS Service is enabled
                if (isGPSEnabled)
                {
                    this.isGPSTrackingEnabled = true;

                    Log.Debug(TAG, "Application use GPS Service");

                    /*
                     * This provider determines location using
                     * satellites. Depending on conditions, this provider may take a while to return
                     * a location fix.
                     */

                    provider_info = LocationManager.GpsProvider;

                }
                else if (isNetworkEnabled)
                { // Try to get location if you Network Service is enabled
                    this.isGPSTrackingEnabled = true;

                    Log.Debug(TAG, "Application use Network State to get GPS coordinates");

                    /*
                     * This provider determines location based on
                     * availability of cell tower and WiFi access points. Results are retrieved
                     * by means of a network lookup.
                     */
                    provider_info = LocationManager.NetworkProvider;

                }

                // Application can use GPS or Network Provider
                if (!string.IsNullOrEmpty(provider_info))
                {
                    locationManager.RequestLocationUpdates(
                        provider_info,
                        MIN_TIME_BW_UPDATES,
                        MIN_DISTANCE_CHANGE_FOR_UPDATES,
                        this
                    );

                    if (locationManager != null)
                    {
                        location = locationManager.GetLastKnownLocation(provider_info);
                        updateGPSCoordinates();
                    }
                }
            }
            catch (Exception e)
            {
                //e.printStackTrace();
                Log.Error(TAG, "Impossible to connect to LocationManager", e);
            }
        }

        /**
         * Update GPSTracker latitude and longitude
         */
        public void updateGPSCoordinates()
        {
            if (location != null)
            {
                latitude = location.Latitude;
                longitude = location.Longitude;
            }
        }

        /**
         * GPSTracker latitude getter and setter
         * @return latitude
         */
        public double getLatitude()
        {
            if (location != null)
            {
                latitude = location.Latitude;
            }

            return latitude;
        }

        /**
         * GPSTracker longitude getter and setter
         * @return
         */
        public double getLongitude()
        {
            if (location != null)
            {
                longitude = location.Longitude;
            }

            return longitude;
        }

        /**
         * GPSTracker isGPSTrackingEnabled getter.
         * Check GPS/wifi is enabled
         */
        public bool getIsGPSTrackingEnabled()
        {

            return this.isGPSTrackingEnabled;
        }

        /**
         * Stop using GPS listener
         * Calling this method will stop using GPS in your app
         */
        public void stopUsingGPS()
        {
            if (locationManager != null)
            {
                locationManager.RemoveUpdates(this);
            }
        }

        /**
         * Function to show settings alert dialog
         */
        public void showSettingsAlert()
        {
            AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);

            //Setting Dialog Title
            alertDialog.SetTitle(Resource.String.GPSAlertDialogTitle);

            //Setting Dialog Message
            alertDialog.SetMessage(Resource.String.GPSAlertDialogMessage);

            //On Pressing Setting button
            alertDialog.SetPositiveButton(Resource.String.setting , (senderAlert, args) => {

                Intent intent = new Intent(Android.Provider.Settings.ActionLocationSourceSettings);
                StartActivity(intent);
            });

        //On pressing cancel button
        alertDialog.SetNegativeButton(Resource.String.cancel, (senderAlert, args) => {
            ((Dialog)senderAlert).Cancel();

   });

        alertDialog.Show();
    }

    /**
     * Get list of address by latitude and longitude
     * @return null or List<Address>
     */
    public IList<Address> getGeocoderAddress(Context context)
{
    if (location != null)
    {

        Geocoder geocoder = new Geocoder(context, Locale.English);

        try
        {
            /**
             * Geocoder.getFromLocation - Returns an array of Addresses
             * that are known to describe the area immediately surrounding the given latitude and longitude.
             */
            IList<Address> addresses = geocoder.GetFromLocation(latitude, longitude, geocoderMaxResults);

            return addresses;
        }
        catch (IOException e)
        {
            //e.printStackTrace();
            Log.Error(TAG, "Impossible to connect to Geocoder", e);
        }
    }

    return null;
}

/**
 * Try to get AddressLine
 * @return null or addressLine
 */
public string getAddressLine(Context context)
{
    IList<Address> addresses = getGeocoderAddress(context);

    if (addresses != null && addresses.Count > 0)
    {
        Address address = addresses[0];
        string addressLine = address.GetAddressLine(0);

        return addressLine;
    }
    else
    {
        return null;
    }
}

/**
 * Try to get Locality
 * @return null or locality
 */
public string getLocality(Context context)
{
    IList<Address> addresses = getGeocoderAddress(context);

    if (addresses != null && addresses.Count > 0)
    {
        Address address = addresses[0];
        string locality = address.Locality;

        return locality;
    }
    else
    {
        return null;
    }
}

/**
 * Try to get Postal Code
 * @return null or postalCode
 */
public string getPostalCode(Context context)
{
    IList<Address> addresses = getGeocoderAddress(context);

    if (addresses != null && addresses.Count > 0)
    {
        Address address = addresses[0];
        string postalCode = address.PostalCode;

        return postalCode;
    }
    else
    {
        return null;
    }
}

/**
 * Try to get CountryName
 * @return null or postalCode
 */
public string getCountryName(Context context)
{
    IList<Address> addresses = getGeocoderAddress(context);
    if (addresses != null && addresses.Count > 0)
    {
        Address address = addresses[0];
        string countryName = address.CountryName;

        return countryName;
    }
    else
    {
        return null;
    }
}


        public void OnLocationChanged(Location location)
        {

        }

        public void OnProviderDisabled(string provider)
        {

        }

        public void OnProviderEnabled(string provider)
        {

        }

        public void OnStatusChanged(string provider, [GeneratedEnum] Availability status, Bundle extras)
        {

        }

        public override IBinder OnBind(Intent intent)
        {
            return null;
        }
    }
}