Android- Wait to change latitude and longitude

Question

Situation: I have a OpenActivity in which I wanna have current position, to do this I ask all permissions required, after, I want to open new activity and provide this data it.

Problem: at the first launching I provide latitude and longitude = 0.00.

Question: How I can resolve this problem? I want call new activity only when my position is correctly set.

this is my code:

public class OpenActivity extends AppCompatActivity {
    public static final int PERMISSIONS_REQUEST_LOCATION = 99;
    public static final int PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE = 98;
    public Boolean networkPermission=false;
    public Boolean locationPermission=false;
    public Boolean storagePermission=false;

    private TrackGPS gps = null;


    double longitude=0.00;
    double latitude=0.00;
    private Location location=null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_open);
        checkLocationPermission();
        checkStoragePermission();
        networkPermission=checkNetworkState();
        getLocation();
        Intent i = new Intent(OpenActivity.this,MainActivity.class);
    i.putExtra("location",location);
    startActivity(i);

    }

    public void getLocation(){


        if(locationPermission){
            gps = new TrackGPS(OpenActivity.this);
            if(gps.canGetLocation() && gps.getLoc()!=null){
                location=gps.getLoc();
                    latitude=location.getLatitude();
                    longitude=location.getLongitude();

            }
            else
            {
                if (!gps.canGetLocation())
                    {
                    gps.showSettingsAlert();
                    }
            }
        }
    }
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode) {
            case PERMISSIONS_REQUEST_LOCATION:
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                   locationPermission=true;

                } else {
                    locationPermission=false;
                }


            break;
            case PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE:
            {
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    storagePermission=true;
                  } else {
                    storagePermission=false;
                }

            }
            break;
        }


    }


    private void checkStoragePermission() {
        if (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.READ_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                    Manifest.permission.READ_EXTERNAL_STORAGE)) {
                new AlertDialog.Builder(this)
                        .setTitle("Storage Permission Needed")
                        .setMessage("This app needs the Storage permission, please accept to use Storage functionality")
                        .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialogInterface, int i) {
                                ActivityCompat.requestPermissions(OpenActivity.this,
                                        new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                                        PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE );
                            }
                        })
                        .create()
                        .show();


            } else {
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                        PERMISSIONS_REQUEST_READ_EXTERNAL_STORAGE );
            }
        }else{
            storagePermission=true;
        }
    }



    private void checkLocationPermission() {
        if (ContextCompat.checkSelfPermission(getApplicationContext(), android.Manifest.permission.ACCESS_FINE_LOCATION)
                != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                    android.Manifest.permission.ACCESS_FINE_LOCATION)) {
                new AlertDialog.Builder(this)
                        .setTitle("Location Permission Needed")
                        .setMessage("This app needs the Location permission, please accept to use location functionality")
                        .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialogInterface, int i) {
                                ActivityCompat.requestPermissions(OpenActivity.this,
                                        new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION},
                                        PERMISSIONS_REQUEST_LOCATION );
                            }
                        })
                        .create()
                        .show();


            } else {
                ActivityCompat.requestPermissions(this,
                        new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION},
                        PERMISSIONS_REQUEST_LOCATION );
            }
        }else{
            locationPermission=true;
        }
    }

    protected boolean checkNetworkState(){
        ConnectivityManager connectivityManager = (ConnectivityManager)getSystemService(OpenActivity.this.CONNECTIVITY_SERVICE);
        if(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState() == NetworkInfo.State.CONNECTED ||
                connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState() == NetworkInfo.State.CONNECTED) {
            return true ;
        }
        else {
            return false;
        }
    }

}

TrackGPS.java

public class TrackGPS extends Service implements LocationListener {

    private final Context mContext;


    boolean checkGPS = false;


    boolean checkNetwork = false;

    boolean canGetLocation = false;

    Location loc;
    double latitude;
    double longitude;

    public Location getLoc() {
        return loc;
    }

    private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 10;


    private static final long MIN_TIME_BW_UPDATES = 1000 * 60 * 1;
    protected LocationManager locationManager;

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

    private Location getLocation() {

        try {
            locationManager = (LocationManager) mContext
                    .getSystemService(LOCATION_SERVICE);

            // getting GPS status
            checkGPS = locationManager
                    .isProviderEnabled(LocationManager.GPS_PROVIDER);

            // getting network status
            checkNetwork = locationManager
                    .isProviderEnabled(LocationManager.NETWORK_PROVIDER);

            if (!checkGPS && !checkNetwork) {
                Toast.makeText(mContext, "No access", Toast.LENGTH_SHORT).show();
            } else {
                this.canGetLocation = true;
                if (checkNetwork) {
                    try {
                        locationManager.requestLocationUpdates(
                                LocationManager.NETWORK_PROVIDER,
                                MIN_TIME_BW_UPDATES,
                                MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                        if (locationManager != null) {
                            loc = locationManager
                                    .getLastKnownLocation(LocationManager.NETWORK_PROVIDER);

                        }

                        if (loc != null) {
                            latitude = loc.getLatitude();
                            longitude = loc.getLongitude();
                        }
                    }
                    catch(SecurityException e){

                    }
                    }
                }
                if (checkGPS) {
                    if (loc == null) {
                        try {
                            locationManager.requestLocationUpdates(
                                    LocationManager.GPS_PROVIDER,
                                    MIN_TIME_BW_UPDATES,
                                    MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
                            if (locationManager != null) {
                                loc = locationManager
                                        .getLastKnownLocation(LocationManager.GPS_PROVIDER);
                                if (loc != null) {
                                    latitude = loc.getLatitude();
                                    longitude = loc.getLongitude();
                                }
                            }
                        } catch (SecurityException e) {

                        }
                    }
            }

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

        return loc;
    }

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

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

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

    public void showSettingsAlert() {
        AlertDialog.Builder alertDialog = new AlertDialog.Builder(mContext);


        alertDialog.setTitle("GPS non attivo");

        alertDialog.setMessage("E' necessario abilitare il GPS, vuoi abilitarlo");


        alertDialog.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                mContext.startActivity(intent);
                ((Activity)mContext).finish();

            }
        });


        alertDialog.setNegativeButton("No", new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                dialog.cancel();
            }
        });


        alertDialog.show();
    }


    public void stopUsingGPS() {
        if (locationManager != null) {

            locationManager.removeUpdates(TrackGPS.this);
        }
    }

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

    @Override
    public void onLocationChanged(Location location) {

    }

    @Override
    public void onStatusChanged(String s, int i, Bundle bundle) {

    }

    @Override
    public void onProviderEnabled(String s) {

    }

    @Override
    public void onProviderDisabled(String s) {

    }
}

In gradle: compile 'com.google.android.gms:play-services:9.4.0'

Answer 1

I solved the problem myself, I've implemented an callback method, I don't now if it is efficiently but works, I post new lines code that I added/updated:

TrackGPS.java ,

     public interface Icall{
            void call(Location location);
        }
        private Icall callerActivity;

        public void show(Location posizione){
            callerActivity.call(posizione);
        }
   @Override
    public void onLocationChanged(Location location) {
        this.show(location);
    }

I updated the constructor:

public TrackGPS(Context mContext,Activity activity) {
        this.mContext = mContext;
        callerActivity=(Iprova)activity;
        getLocation();
    }

and in OpenActivity.class I've implemented Icall:

public class OpenActivity extends AppCompatActivity implements TrackGPS.ICall

changed the call for TrackGPS object:

gps = new TrackGPS(OpenActivity.this, (Activity)this);

and override method:

@Override
    public void call(Location location) {
        //code to call
    }

I hope this can serve someone.

Answer 2

Call your intent in the "OnLoctaionChanged" method. Define a condition in "OnLocationChanged" method to check if you got a proper location or not. when this condition is true then pass the intent, otherwise do nothing. "OnLocationChanged" method keeps calling again and again until you stop it. Hope this will help.