LocationManager.NETWORK_PROVIDER need network, but it is real, not precise. if you want to use LocationManager.GPS_PROVIDER, the situation must be outdoor instead of indoor, because GPS location need satellite, if you are in any building, the satellite cannot find you! pleasle go outdoor and check with GPS_PROVIDER again!

*best approach is getting location from both of GPS and NETWORK and check any of then that was not null and more accurate useing it.

Samsung phones have this problem. There is hack to this. You need to kick the locationmanager on the butt to get the latest location from the maps cache.

God.locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0,
            new LocationListener() {
                @Override
                public void onStatusChanged(String provider, int status, Bundle extras) {
                }

                @Override
                public void onProviderEnabled(String provider) {
                }

                @Override
                public void onProviderDisabled(String provider) {
                }

                @Override
                public void onLocationChanged(final Location location) {
                }
            });
    currentLocation = God.locationManager
            .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

Call getLastKnownLocation after kicking the requestLocationUpdates with 0's.

The primary reason why you aren't getting updated location information quickly is that you're relying on the NETWORK_PROVIDER in the RestaurantHelper.getLastKnownLocation() method, but registering a LocationListener for the GPS_PROVIDER in onCreate().

So, this code in RestaurantHelper.getLastKnownLocation():

Location location = lm.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

...should be changed to:

Location location = lm.getLastKnownLocation(LocationManager.GPS_PROVIDER);

In theory, this should then give you the latest GPS location, which should have been refreshed when you register the listener. Conversely, you could also change to listening to the NETWORK_PROVIDER in onCreate() and leave RestaurantHelper.getLastKnownLocation() as is. It depends on your accuracy requirement - if you want high accuracy locations to return the nearest location to the nearest building level (e.g., 5-30m), you should use the GPS_PROVIDER. But, if you can live with coarser accuracy, the NETWORK_PROVIDER typically returns a new location much faster than GPS, especially if you're indoors, and sometimes this can be fairly accurate if derived from WiFi.

Another approach would be to listen to both GPS_PROVIDER and NETWORK_PROVIDER by registering both via two requestLocationUpdates() lines in onCreate(), and then checking to see most recent timestamp on the Location from lm.getLastKnownLocation(LocationManager.GPS_PROVIDER); and lm.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);, and using the one that was updated more recently.

I would also recommend the following changes to make your code reliable on a large number of Android devices:

1. Specify the requestLocationUpdates() minDistance parameter as 0 when listening for GPS or NETWORK location updates - the minDistance parameter has a history of being unreliable and unpredictable in the way its interpreted by OEMs, until Android 4.1.
2. Switch to the new Fused Location Provider - this should be much more reliable when calling the getLastKnownLocation() method than the Android framework location APIs, and more consistent across different devices. Note that this relies on Google Play Services SDK, which is only available on Android 2.2 and higher.

Import LocationListener interface from android.location package because currently you are importing from com.google.android.gms.location package but requestLocationUpdates method takes android.location.LocationListener as last parameter.

Change :

import com.google.android.gms.location.LocationListener;

to

import android.location.LocationListener;

According to the documentation RuntimeException is called when calling thread has no Looper. Try to call Looper.prepare() before you call LocationManager

You can use this schema. Create new Runnable which will be called every time, when you want it

private final Handler _handler = new Handler();
private static int DATA_INTERVAL =  60 * 1000;

private final Runnable getData = new Runnable()
{
    @Override
    public void run()
    {
        getDataFrame();
    }
};
private void getDataFrame() 
{
    requestGPS();
    Timer time = new Timer();
    time.schedule(new TimerTask() {
            @Override
            public void run() {
                _locationManager.removeUpdates(_connector);
                this.cancel();
            }
        }, 5000, 5000);
    _handler.postDelayed(getData, DATA_INTERVAL);
}
private void requestGPS() 
{
    _locationManager.requestLocationUpdates(
    LocationManager.GPS_PROVIDER,
                0,
                0,
                _connector);
}

Workaround for this issue is to use only one LocationManager and one LocationListener. If your app has needs for different kind of simultaneous location requests (with different parameters), then you need to implement a "location request handler" which decides which parameters should be used for the location request i.e. which parameters have the tightest requirements for location.

Here is a simple example code that explains the idea of "location request handler":

Copyclass LR {

    long lock_min_time; // defined in set_lock_lr before using
    float lock_min_dist;
    boolean lock_active = false;

    long idle_min_time = 3600000; // 1 per hour
    float idle_min_dist = 200;
    boolean idle_active = true;

    long fast_min_time = 0;
    float fast_min_dist = 0;
    boolean fast_active = false;

    //constructor
    public LR()
    {}

    public void set_lock_lr(long min_time, float min_dist, boolean active)
    {
        lock_active = active;
        lock_min_dist = min_dist;
        lock_min_time = min_time;
        System.out.println("LR lock set: "+min_time+", "+min_dist+", "+active);
        update_location_request();
    }

    public void set_idle_lr(boolean active)
    {
        idle_active = active;
        System.out.println("LR idle set: "+active);
        update_location_request();
    }

    public void set_fast_lr(boolean active)
    {
        fast_active = active;
        System.out.println("LR fast set: "+active);
        update_location_request();
    }

    private void update_location_request()
    {
        // Remove current location request
        mlocManager_basic.removeUpdates(mlocListener_basic);

        if(fast_active)
        {
            mlocManager_basic.requestLocationUpdates(LocationManager.GPS_PROVIDER, fast_min_time, fast_min_dist, mlocListener_basic);
            System.out.println("LR: fast_active");
        }
        else if(lock_active)
        {
            mlocManager_basic.requestLocationUpdates(LocationManager.GPS_PROVIDER, lock_min_time, lock_min_dist, mlocListener_basic);
            System.out.println("LR: lock_active");
        }
        else if(idle_active) // only idle updates
        {
            mlocManager_basic.requestLocationUpdates(LocationManager.GPS_PROVIDER, idle_min_time, idle_min_dist, mlocListener_basic);
            System.out.println("LR: idle_active");
        }
    }
}

user this Handler to get Location

private Handler customHandler = new Handler();
private Runnable updateTimerThread = new Runnable() {

@Override
public void run()
    {
        try
            {

                Location myLocation = mGoogleMap.getMyLocation();
                secndLocationListener.onLocationChanged(myLocation);
            }
        catch (Exception e)
            {
                Log.getStackTraceString(e);
            }

    }
    };

call this

   customHandler.postDelayed(updateTimerThread , 10 *  60 * 1000);

You are implementing LocationListener in your activity MainActivity. The call for concurrent location updates will therefor be like this:

mLocationClient.requestLocationUpdates(mLocationRequest, this);

Be sure that the LocationListener you're implementing is from the google api, that is import this:

import com.google.android.gms.location.LocationListener;

and not this:

import android.location.LocationListener;

and it should work just fine.

It's also important that the LocationClient really is connected before you do this. I suggest you don't call it in the onCreate or onStart methods, but in onResume. It is all explained quite well in the tutorial for Google Location Api: https://developer.android.com/training/location/index.html