Android-等待改变纬度和经度

Question

情况：我有一个公开性，我想拥有当前职位，要这样做，我要求所有需要的权限，之后，我想打开新的活动并提供此数据。

问题：在第一次启动时，我提供了纬度和经度= 0.00。

问题：我如何解决此问题？我只想在正确设置职位时才调用新活动。

这是我的代码：

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) {
    }
}

在Gradle中：compile 'com.google.android.gms:play-services:9.4.0'

Answer 1

我自己解决了问题，我已经实现了一种回调方法，如果它有效但有效，我现在不现在，我发布了我添加/更新的新行代码：p> 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);
    }

我更新了构造函数：

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

和在openActivity中。

public class OpenActivity extends AppCompatActivity implements TrackGPS.ICall

更改了trackgps对象的调用：

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

和覆盖方法：

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

我希望这可以为某人服务。

Answer 2

在" OnloctaionChanged"方法中调用您的意图。在" Onlocation Changed"方法中定义条件，以检查您是否有适当的位置。当此条件为真时，然后通过意图，否则什么也不做。" Onlocation Changed"方法会一次又一次地呼叫，直到您停止它为止。希望这会有所帮助。