How to get the current location latitude and longitude in android

In my application, I get the current location's latitude and longitude when application is open, but not when the application is closed.

I am using Service class to get the current location latitude and longitude in my application.

Please tell me how to get the current location latitude and longitude even when application is closed

Before couple of months, I created GPSTracker library to help me to get GPS locations. In case you need to view GPSTracker > getLocation

Demo

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Activity

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;
import android.widget.TextView;

public class MainActivity extends Activity {

	TextView textview;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.geo_locations);

		// check if GPS enabled
		GPSTracker gpsTracker = new GPSTracker(this);

		if (gpsTracker.getIsGPSTrackingEnabled())
		{
			String stringLatitude = String.valueOf(gpsTracker.latitude);
			textview = (TextView)findViewById(R.id.fieldLatitude);
			textview.setText(stringLatitude);

			String stringLongitude = String.valueOf(gpsTracker.longitude);
			textview = (TextView)findViewById(R.id.fieldLongitude);
			textview.setText(stringLongitude);

			String country = gpsTracker.getCountryName(this);
			textview = (TextView)findViewById(R.id.fieldCountry);
			textview.setText(country);

			String city = gpsTracker.getLocality(this);
			textview = (TextView)findViewById(R.id.fieldCity);
			textview.setText(city);

			String postalCode = gpsTracker.getPostalCode(this);
			textview = (TextView)findViewById(R.id.fieldPostalCode);
			textview.setText(postalCode);

			String addressLine = gpsTracker.getAddressLine(this);
			textview = (TextView)findViewById(R.id.fieldAddressLine);
			textview.setText(addressLine);
		}
		else
		{
			// can't get location
            // GPS or Network is not enabled
            // Ask user to enable GPS/network in settings
			gpsTracker.showSettingsAlert();
		}
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.varna_lab_geo_locations, menu);
		return true;
	}
}

GPS Tracker

import java.io.IOException;
import java.util.List;
import java.util.Locale;

import android.app.AlertDialog;
import android.app.Service;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.location.Address;
import android.location.Geocoder;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.IBinder;
import android.provider.Settings;
import android.util.Log;

/**
 * Create this Class from tutorial : 
 * http://www.androidhive.info/2012/07/android-gps-location-manager-tutorial
 * 
 * For Geocoder read this : http://stackoverflow.com/questions/472313/android-reverse-geocoding-getfromlocation
 * 
 */

public class GPSTracker extends Service implements LocationListener {

	// Get Class Name
	private static String TAG = GPSTracker.class.getName();
	
	private final Context mContext;
	
	// flag for GPS Status
	boolean isGPSEnabled = false;
	
	// flag for network status
	boolean isNetworkEnabled = false;
	
	// flag for GPS Tracking is enabled 
	boolean 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 final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters
	
	// The minimum time between updates in milliseconds
	private static final 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(LOCATION_SERVICE);
			
			//getting GPS status
			isGPSEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
			
			//getting network status
			isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
			
			// Try to get location if you GPS Service is enabled
			if (isGPSEnabled) {
				this.isGPSTrackingEnabled = true;
				
				Log.d(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.GPS_PROVIDER;
				
			} else if (isNetworkEnabled) { // Try to get location if you Network Service is enabled
				this.isGPSTrackingEnabled = true;
				
				Log.d(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.NETWORK_PROVIDER;
				
			} 
			
			// Application can use GPS or Network Provider
			if (!provider_info.isEmpty()) {
				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.e(TAG, "Impossible to connect to LocationManager", e);
		}
	}
	
	/**
	 * Update GPSTracker latitude and longitude
	 */
	public void updateGPSCoordinates() {
		if (location != null) {
			latitude = location.getLatitude();
			longitude = location.getLongitude();
		}
	}
	
	/**
	 * GPSTracker latitude getter and setter
	 * @return latitude
	 */
	public double getLatitude() {
		if (location != null) {
			latitude = location.getLatitude();
		}
		
		return latitude;
	}
	
	/**
	 * GPSTracker longitude getter and setter
	 * @return
	 */
	public double getLongitude() {
		if (location != null) {
			longitude = location.getLongitude();
		}
		
		return longitude;
	}
	
	/**
	 * GPSTracker isGPSTrackingEnabled getter.
	 * Check GPS/wifi is enabled
	 */
	public boolean 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(GPSTracker.this);
		}
	}
	
	/**
	 * Function to show settings alert dialog
	 */
	public void showSettingsAlert() {
		AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);
		
		//Setting Dialog Title
		alertDialog.setTitle(R.string.GPSAlertDialogTitle);
		
		//Setting Dialog Message
		alertDialog.setMessage(R.string.GPSAlertDialogMessage);
		
		//On Pressing Setting button
		alertDialog.setPositiveButton(R.string.action_settings, new DialogInterface.OnClickListener() {
			
			@Override
			public void onClick(DialogInterface dialog, int which) 
			{
				Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
				mContext.startActivity(intent);
			}
		});
		
		//On pressing cancel button
		alertDialog.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
			
			@Override
			public void onClick(DialogInterface dialog, int which) 
			{
				dialog.cancel();
			}
		});
		
		alertDialog.show();
	}
	
	/**
	 * Get list of address by latitude and longitude
	 * @return null or List<Address>
	 */
	public List<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.
				 */
				List<Address> addresses = geocoder.getFromLocation(latitude, longitude, this.geocoderMaxResults);
				
				return addresses;
			} catch (IOException e) {
				//e.printStackTrace();
				Log.e(TAG, "Impossible to connect to Geocoder", e);
			}
		}
		
		return null;
	}
	
	/**
	 * Try to get AddressLine
	 * @return null or addressLine
	 */
	public String getAddressLine(Context context) {
		List<Address> addresses = getGeocoderAddress(context);
		
		if (addresses != null && addresses.size() > 0) {
			Address address = addresses.get(0);
			String addressLine = address.getAddressLine(0);
			
			return addressLine;
		} else {
			return null;
		}
	}
	
	/**
	 * Try to get Locality
	 * @return null or locality
	 */
	public String getLocality(Context context) {
		List<Address> addresses = getGeocoderAddress(context);
		
		if (addresses != null && addresses.size() > 0) {
			Address address = addresses.get(0);
			String locality = address.getLocality();
			
			return locality;
		}
		else {
			return null;
		}
	}
	
	/**
	 * Try to get Postal Code
	 * @return null or postalCode
	 */
	public String getPostalCode(Context context) {
		List<Address> addresses = getGeocoderAddress(context);

		if (addresses != null && addresses.size() > 0) {
			Address address = addresses.get(0);
			String postalCode = address.getPostalCode();

			return postalCode;
		} else {
			return null;
		}
	}
	
	/**
	 * Try to get CountryName
	 * @return null or postalCode
	 */
	public String getCountryName(Context context) {
		List<Address> addresses = getGeocoderAddress(context);
		if (addresses != null && addresses.size() > 0) {
			Address address = addresses.get(0);
			String countryName = address.getCountryName();
			
			return countryName;
		} else {
			return null;
		}
	}

	@Override
	public void onLocationChanged(Location location) {
	}

	@Override
	public void onStatusChanged(String provider, int status, Bundle extras) {
	}

	@Override
	public void onProviderEnabled(String provider) {
	}

	@Override
	public void onProviderDisabled(String provider) {
	}

	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
}

Note

If the method / answer doesn't work. You need to use the official Google Provider: FusedLocationProviderApi.

Article: Getting the Last Known Location

> # IMPORTANT: Please notice this solution is from 2015 might be too old and deprecated.

---

None of the above worked for me so I made a tutorial and wrote it for myself since I lost many hours trying to implement this. Hope this helps someone:

How to use Google Play Services LOCATION API to get current latitude & longitude

1. Add to your AndroidManifest.xml file the ACCESS_COARSE_LOCATION & ACCESS_FINE_LOCATION:

    <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.appname" >
    
        <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
        <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    
        <application...
   

2. Go to app/build.gradlefile and add the following dependency (make sure to use the latest available version):

    dependencies {
        //IMPORTANT: make sure to use the newest version. 11.0.1 is old AF
        compile 'com.google.android.gms:play-services-location:11.0.1
    }
    
   

3. In your activity implement the following:

    import com.google.android.gms.common.ConnectionResult;
    import com.google.android.gms.common.api.GoogleApiClient;
    import com.google.android.gms.common.api.GoogleApiClient.ConnectionCallbacks;
    import com.google.android.gms.common.api.GoogleApiClient.OnConnectionFailedListener;
    import com.google.android.gms.location.LocationListener;
    import com.google.android.gms.location.LocationRequest;
    import com.google.android.gms.location.LocationServices;
    import com.google.android.gms.maps.GoogleMap;
    
    public class HomeActivity extends AppCompatActivity implements
            ConnectionCallbacks,
            OnConnectionFailedListener,
            LocationListener {
    
        //Define a request code to send to Google Play services
        private final static int CONNECTION_FAILURE_RESOLUTION_REQUEST = 9000;
        private GoogleApiClient mGoogleApiClient;
        private LocationRequest mLocationRequest;
        private double currentLatitude;
        private double currentLongitude;
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_home);
    
            mGoogleApiClient = new GoogleApiClient.Builder(this)
                    // The next two lines tell the new client that “this” current class will handle connection stuff
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    //fourth line adds the LocationServices API endpoint from GooglePlayServices
                    .addApi(LocationServices.API)
                    .build();
    
            // Create the LocationRequest object
            mLocationRequest = LocationRequest.create()
                    .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
                    .setInterval(10 * 1000)        // 10 seconds, in milliseconds
                    .setFastestInterval(1 * 1000); // 1 second, in milliseconds
    
        }
    
        @Override
        protected void onResume() {
            super.onResume();
            //Now lets connect to the API
            mGoogleApiClient.connect();
        }
        
        @Override
        protected void onPause() {
            super.onPause();
            Log.v(this.getClass().getSimpleName(), "onPause()");
    
            //Disconnect from API onPause()
            if (mGoogleApiClient.isConnected()) {
                LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
                mGoogleApiClient.disconnect();
            }
    
    
        }
    
        /**
         * If connected get lat and long
         * 
         */
        @Override
        public void onConnected(Bundle bundle) {
            Location location = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
    
            if (location == null) {
                LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
    
            } else {
                //If everything went fine lets get latitude and longitude
                currentLatitude = location.getLatitude();
                currentLongitude = location.getLongitude();
    
                Toast.makeText(this, currentLatitude + " WORKS " + currentLongitude + "", Toast.LENGTH_LONG).show();
            }
        }
    
    
        @Override
        public void onConnectionSuspended(int i) {}
    
        @Override
        public void onConnectionFailed(ConnectionResult connectionResult) {
            /*
             * Google Play services can resolve some errors it detects.
             * If the error has a resolution, try sending an Intent to
             * start a Google Play services activity that can resolve
             * error.
             */
            if (connectionResult.hasResolution()) {
                try {
                    // Start an Activity that tries to resolve the error
                    connectionResult.startResolutionForResult(this, CONNECTION_FAILURE_RESOLUTION_REQUEST);
                    /*
                     * Thrown if Google Play services canceled the original
                     * PendingIntent
                     */
                } catch (IntentSender.SendIntentException e) {
                    // Log the error
                    e.printStackTrace();
                }
            } else {
                /*
                 * If no resolution is available, display a dialog to the
                 * user with the error.
                 */
                Log.e("Error", "Location services connection failed with code " + connectionResult.getErrorCode());
            }
        }
    
        /**
         * If locationChanges change lat and long
         * 
         * 
         * @param location
         */
        @Override
        public void onLocationChanged(Location location) {
            currentLatitude = location.getLatitude();
            currentLongitude = location.getLongitude();
    
            Toast.makeText(this, currentLatitude + " WORKS " + currentLongitude + "", Toast.LENGTH_LONG).show();
        }
    
    }
   

If you need more info just go to:

The Beginner’s Guide to Location in Android

Note: This doesn't seem to work in the emulator but works just fine on a device

Use Location Listener Method

@Override
public void onLocationChanged(Location loc) {
Double lat = loc.getLatitude();
Double lng = loc.getLongitude();
}

You can use following class as service class to run your application in background

import java.util.Timer;
import java.util.TimerTask;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.widget.Toast;

public class MyService extends Service {
	
	private GPSTracker gpsTracker;
	private Handler handler= new Handler();
	private Timer timer = new Timer();
	private Distance pastDistance = new Distance();
	 private Distance currentDistance = new Distance();
	public static double DISTANCE;
	boolean flag = true ;
	private double totalDistance ;
	@Override
	@Deprecated
	public void onStart(Intent intent, int startId) {
		
		super.onStart(intent, startId);
		gpsTracker = new GPSTracker(HomeFragment.HOMECONTEXT);
		TimerTask timerTask = new TimerTask() {
			
			@Override
			public void run() {
				handler.post(new Runnable() {
					
					@Override
					public void run() {
						if(flag){
							pastDistance.setLatitude(gpsTracker.getLocation().getLatitude());
							pastDistance.setLongitude(gpsTracker.getLocation().getLongitude());
							flag = false;
						}else{
							currentDistance.setLatitude(gpsTracker.getLocation().getLatitude());
							currentDistance.setLongitude(gpsTracker.getLocation().getLongitude());
							flag = comapre_LatitudeLongitude();
						}
						Toast.makeText(HomeFragment.HOMECONTEXT, "latitude:"+gpsTracker.getLocation().getLatitude(), 4000).show();
						
					}
				});
				
				
			}
		};
		
		timer.schedule(timerTask,0, 5000);
	    
	}
	
	private double distance(double lat1, double lon1, double lat2, double lon2) {
	      double theta = lon1 - lon2;
	      double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2)) + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.cos(deg2rad(theta));
	      dist = Math.acos(dist);
	      dist = rad2deg(dist);
	      dist = dist * 60 * 1.1515;
	       return (dist);
	    }

	   private double deg2rad(double deg) {
	      return (deg * Math.PI / 180.0);
	    }
	   private double rad2deg(double rad) {
	      return (rad * 180.0 / Math.PI);
   }


	@Override
	public IBinder onBind(Intent intent) {
		
		return null;
	}
	


	@Override
	public void onDestroy() {
		
		super.onDestroy();
		System.out.println("--------------------------------onDestroy -stop service ");
		timer.cancel();
		DISTANCE = totalDistance ;
	}
    public boolean comapre_LatitudeLongitude(){
    	
    	if(pastDistance.getLatitude() == currentDistance.getLatitude() && pastDistance.getLongitude() == currentDistance.getLongitude()){
    		return false;
    	}else{
    		
    		final double distance = distance(pastDistance.getLatitude(),pastDistance.getLongitude(),currentDistance.getLatitude(),currentDistance.getLongitude());
    		System.out.println("Distance in mile :"+distance);
    		handler.post(new Runnable() {
				
				@Override
				public void run() {
					float kilometer=1.609344f;
					
					totalDistance = totalDistance +  distance * kilometer;
					DISTANCE = totalDistance;
					//Toast.makeText(HomeFragment.HOMECONTEXT, "distance in km:"+DISTANCE, 4000).show();
					
				}
			});
			
    		return true;
    	}
    
    }
    
}

Add One another class to get location

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;

public class GPSTracker implements LocationListener {
private final Context mContext;
boolean isGPSEnabled = false;
boolean isNetworkEnabled = false;
boolean canGetLocation = false;
Location location = null; 
double latitude; 
double longitude; 

private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10; // 10 meters
private static final long MIN_TIME_BW_UPDATES = 1000 * 60 * 1; // 1 minute

protected LocationManager locationManager;
private Location m_Location;
 public GPSTracker(Context context) {
    this.mContext = context;
    m_Location = getLocation();
    System.out.println("location Latitude:"+m_Location.getLatitude());
    System.out.println("location Longitude:"+m_Location.getLongitude());
    System.out.println("getLocation():"+getLocation());
    }

public Location getLocation() {
    try {
        locationManager = (LocationManager) mContext
                .getSystemService(Context.LOCATION_SERVICE);

        isGPSEnabled = locationManager
                .isProviderEnabled(LocationManager.GPS_PROVIDER);

        isNetworkEnabled = locationManager
                .isProviderEnabled(LocationManager.NETWORK_PROVIDER);

        if (!isGPSEnabled && !isNetworkEnabled) {
            // no network provider is enabled
        } 
        else {
            this.canGetLocation = true;
            if (isNetworkEnabled) {
                locationManager.requestLocationUpdates(
                        LocationManager.NETWORK_PROVIDER,
                        MIN_TIME_BW_UPDATES,
                        MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                Log.d("Network", "Network Enabled");
                if (locationManager != null) {
                    location = locationManager
                            .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
                    if (location != null) {
                        latitude = location.getLatitude();
                        longitude = location.getLongitude();
                    }
                }
            }
            if (isGPSEnabled) {
                if (location == null) {
                    locationManager.requestLocationUpdates(
                            LocationManager.GPS_PROVIDER,
                            MIN_TIME_BW_UPDATES,
                            MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                    Log.d("GPS", "GPS Enabled");
                    if (locationManager != null) {
                        location = locationManager
                                .getLastKnownLocation(LocationManager.GPS_PROVIDER);
                        if (location != null) {
                            latitude = location.getLatitude();
                            longitude = location.getLongitude();
                        }
                    }
                }
            }
        }

    } catch (Exception e) {
        e.printStackTrace();
    }

    return location;
}

public void stopUsingGPS() {
    if (locationManager != null) {
        locationManager.removeUpdates(GPSTracker.this);
    }
}

public double getLatitude() {
    if (location != null) {
        latitude = location.getLatitude();
    }

    return latitude;
}

public double getLongitude() {
    if (location != null) {
        longitude = location.getLongitude();
    }

    return longitude;
}

public boolean canGetLocation() {
    return this.canGetLocation;
}

@Override
public void onLocationChanged(Location arg0) {
	// TODO Auto-generated method stub
	
}

@Override
public void onProviderDisabled(String arg0) {
	// TODO Auto-generated method stub
	
}

@Override
public void onProviderEnabled(String arg0) {
	// TODO Auto-generated method stub
	
}

@Override
public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
	// TODO Auto-generated method stub
	
}


}

// --------------Distance.java

 public class Distance  {
    private	double latitude ;
    private	double longitude;
    	public double getLatitude() {
    		return latitude;
    	}
    	public void setLatitude(double latitude) {
    		this.latitude = latitude;
    	}
    	public double getLongitude() {
    		return longitude;
    	}
    	public void setLongitude(double longitude) {
    		this.longitude = longitude;
    	}
    	
       

}

**The activity should implements LocationListener

In onCreate(), write the following code **

  Boolean network = haveNetworkConnection();
	Log.e("network", "---------->" + network);
	if (!network) {
		Toast.makeText(getApplicationContext(), "Network is not available",
				3000).show();

	}

	SupportMapFragment supportMapFragment = (SupportMapFragment) getSupportFragmentManager()
			.findFragmentById(R.id.googleMap);
	googleMap = supportMapFragment.getMap();
	googleMap.setMyLocationEnabled(true);
	
	
	LocationManager locationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
	locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 30000, 0, this);
	
	
	
	
		if (!locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
			&& !locationManager
					.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {

		

		 TextView title = new TextView(context);
		 title.setText("Location Services Not Active");
		    title.setBackgroundColor(Color.BLACK);
		    title.setPadding(10, 15, 15, 10);
		    title.setGravity(Gravity.CENTER);
		    title.setTextColor(Color.WHITE);
		    title.setTextSize(22);
		
		
		    AlertDialog.Builder builder = new AlertDialog.Builder(this);


		
		
		builder.setCustomTitle(title);


		// builder.setTitle("Location Services Not Active");
		builder.setMessage("Please enable Location Services and GPS");

		builder.setPositiveButton("Turn on",
				new DialogInterface.OnClickListener() {
					public void onClick(DialogInterface dialogInterface,
							int i) {
						// Show location settings when the user acknowledges
						// the alert dialog
						Intent intent = new Intent(
								Settings.ACTION_LOCATION_SOURCE_SETTINGS);

						startActivity(intent);
						finish();
					}
				});

		builder.setNegativeButton("Cancel",
				new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						// TODO Auto-generated method stub
						dialog.cancel();
					}
				});

		builder.show();

	}

	Criteria criteria = new Criteria();
	String bestProvider = locationManager.getBestProvider(criteria, true);
	Location location = locationManager.getLastKnownLocation(bestProvider);

	if (location == null) {
		Toast.makeText(getApplicationContext(), "GPS signal not found",
				3000).show();
	}
	if (location != null) {
		Log.e("locatin", "location--" + location);

		Log.e("latitude at beginning",
				"@@@@@@@@@@@@@@@" + location.getLatitude());
		onLocationChanged(location);
	}

Write a method haveNetworkConnection

private boolean haveNetworkConnection() {
	boolean haveConnectedWifi = false;
	boolean haveConnectedMobile = false;

	ConnectivityManager cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
	NetworkInfo[] netInfo = cm.getAllNetworkInfo();
	for (NetworkInfo ni : netInfo) {
		if (ni.getTypeName().equalsIgnoreCase("WIFI"))
			if (ni.isConnected())
				haveConnectedWifi = true;
		if (ni.getTypeName().equalsIgnoreCase("MOBILE"))
			if (ni.isConnected())
				haveConnectedMobile = true;
	}
	return haveConnectedWifi || haveConnectedMobile;
}



@Override
public void onLocationChanged(Location location) {

	
	LatLng latLng = new LatLng(latitude, longitude);
	googleMap.addMarker(new MarkerOptions()
			.position(latLng)
			.title("Current LOC")
			.icon(BitmapDescriptorFactory
					.defaultMarker(BitmapDescriptorFactory.HUE_RED)));

	googleMap.moveCamera(CameraUpdateFactory.newLatLng(latLng));
	googleMap.animateCamera(CameraUpdateFactory.zoomTo(17));


}

@Override
public void onProviderDisabled(String provider) {
	// TODO Auto-generated method stub
}

@Override
public void onProviderEnabled(String provider) {
	// TODO Auto-generated method stub
}

@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
	// TODO Auto-generated method stub
}

Here is Android Location library you can find your current location without using Google account or subscription.

Find this link and download repository

https://github.com/mrmans0n/smart-location-lib

Take care and Enjoy...

try this, hope it will help you to get the current location, every time the location changes.

public class MyClass implements LocationListener {
    double currentLatitude, currentLongitude;

    public void onLocationChanged(Location location) {
        currentLatitude = location.getLatitude();
        currentLongitude = location.getLongitude();
    }
}

for this porous , you can use flowing code :

public class GetLocationActivity extends BaseActivity {
//for getting update of location
FusedLocationProviderClient fusedLocationClient;
//new callback result requesting in activity
ActivityResultLauncher<String[]> locationPermissionRequest =
        registerForActivityResult(new ActivityResultContracts
                        .RequestMultiplePermissions(), result -> {
                    Boolean fineLocationGranted = result.get(
                            Manifest.permission.ACCESS_FINE_LOCATION);
                    Boolean coarseLocationGranted = result.get(
                            Manifest.permission.ACCESS_COARSE_LOCATION);
                    if (fineLocationGranted != null && fineLocationGranted) {
                        // Precise location access granted.
                        if (coarseLocationGranted != null && coarseLocationGranted) {
                            // Only approximate location access granted.
                            //chek is Gps is On or Off and ask from user to enable is
                            checkGPS();
                        }
                    } else {
                        // No location access granted.
                        //show toast for errors
                    }
                }
        );

private void checkGPS() {
//create call for checking gps sensor
    LocationRequest locationRequest = LocationRequest.create();

    LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder().addLocationRequest(locationRequest);

    SettingsClient settingsClient = LocationServices.getSettingsClient(this);
    Task<LocationSettingsResponse> task = settingsClient.checkLocationSettings(builder.build());

    task.addOnSuccessListener(this, locationSettingsResponse -> {
        Log.d("GPS_main", "OnSuccess");
        // GPS is ON
    });

    task.addOnFailureListener(this, new OnFailureListener() {
        @Override
        public void onFailure(@NonNull final Exception e) {
            Log.d("GPS_main", "GPS off");
          
            // GPS off
            if (e instanceof ResolvableApiException) {
                ResolvableApiException resolvable = (ResolvableApiException) e;
                try {
                    resolvable.startResolutionForResult(GetLocationActivity.this, 1);
                } catch (IntentSender.SendIntentException e1) {
                    e1.printStackTrace();
                }
            }
        }
    });
}




@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
   
    fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);

    //location button
    findViewById(R.id.lastLocationFab).setOnClickListener(view -> getPermission());
   
}

private void getPermission() {
    if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
            && ActivityCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
        //call request
        locationPermissionRequest.launch(new String[]{
                Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_COARSE_LOCATION});

    } else {
        fusedLocationClient.requestLocationUpdates(LocationRequest.create()
                        .setInterval(36000).setFastestInterval(36000)
                        .setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY)
                        .setMaxWaitTime(1000),
                getLocationCallback(), Looper.myLooper());
        getCurrentLocation();
    }
}

private LocationCallback getLocationCallback() {
    return new LocationCallback() {
        @Override
        public void onLocationResult(LocationResult locationResult) {
            List<Location> locationList = locationResult.getLocations();
            if (locationList.size() > 0) {
                //The last location in the list is the newest
                Location location = locationList.get(locationList.size() - 1);

            
                //Place current location marker
              
            }
        }

        
    };
}


public void getCurrentLocation() {
    fusedLocationClient.getCurrentLocation(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY, new CancellationToken() {
        @Override
        public boolean isCancellationRequested() {
            return false;
        }

        @NonNull
        @Override
        public CancellationToken onCanceledRequested(@NonNull OnTokenCanceledListener onTokenCanceledListener) {
            return null;
        }
    }).addOnSuccessListener(this, location -> {
        // Got last known location. In some rare situations this can be null.
        if (location != null) {
            LatLng myLoc = new LatLng(location.getLatitude(), location.getLongitude());
           
        }
    });

  }