Comment obtenir l'emplacement actuel dans GoogleMap using FusedLocationProviderClient

Question

Je veux obtenir des mises à jour de position courantes périodiques (dire toutes les 2 minutes) pour ceci Je suis la documentation officielle, j'ai écrit ce code mais ne donne pas les mises à jour actuelles de localisation toutes les deux minutes spécifié dans l'objet LocationRequest que je passe dans requestLocationUpdates(), voici le code:

public class MapsActivity extends FragmentActivity implements OnMapReadyCallback, 
    GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener{ 

private FusedLocationProviderClient FusedLocationClient; 
private GoogleApiClient mGoogleApiClient; 

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_maps); 
    if (mGoogleApiClient == null) { 
     mGoogleApiClient = new GoogleApiClient.Builder(this) 
       .addConnectionCallbacks(this) 
       .addOnConnectionFailedListener(this) 
       .addApi(LocationServices.API) 
       .build(); 
    } 

SupportMapFragment map = 
    getSupportFragmentManager().findFragmentById(R.id.map)); 

    map.getMapAsync(this); 

    FusedLocationClient LocationServices.getFusedLocationProviderClient(this); 
} 


@Override 
public void onConnected(Bundle bundle) { 
    FusedLocationClient.getLastLocation() 
      .addOnSuccessListener(this, new OnSuccessListener<Location>() { 
       @Override 
       public void onSuccess(Location location) { 

        if (location != null) { 
         Log.i("MainActivity ", "" + location.getLongitude()) 
        } 
       } 
      }); 
FusedLocationClient = LocationServices.getFusedLocationProviderClient(this); 
FusedLocationClient.requestLocationUpdates(requestLocation(), 
new LocationCallback(){ 
     @Override 
     public void onLocationResult(LocationResult locationResult) { 
      for (Location location : locationResult.getLocations()) { 
       Log.i("MainActivity ", "" + location.getLongitude()); 
       //not getting current location updates every 2 minutes 
      } 
     }; 

    },null); 

} 

@Override 
public void onConnectionSuspended(int i) {} 

@Override 
public void onConnectionFailed(ConnectionResult connectionResult) {} 

Answer 1

private LocationRequest locationRequest; 

    public class MapsActivity extends FragmentActivity implements LocationListener{ 

    locationRequest = new LocationRequest(); 
    locationRequest.setInterval(60 * 1000); 
    locationRequest.setFastestInterval(15 * 1000); 
    locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY); 


@Override 
public void onLocationChanged(Location location) { 

    latitude = location.getLatitude(); 
    longitude = location.getLongitude(); 

} 

Mettre en œuvre l'auditeur de changement d'emplacement et vous serez en mesure de passer outre OnLocation changé ...

Answer 2

C'est semblable à mon other answer here, mis à jour pour utiliser la classe FusedLocationProviderClient récemment introduite.

Pour utiliser un FusedLocationProviderClient en conjonction avec une carte Google Map:

1. Attendez que la Google Map est prêt

2. Demander la permission d'emplacement lors de l'exécution si nécessaire

3. Demande mises à jour de localisation une fois l'autorisation accordée

4. Mettre à jour le Google Carte une fois l'emplacement de l'utilisateur est obtenu

d'abord que vous utilisez la version 11 de Google Play Services, les versions antérieures ne sont pas la classe FusedLocationProviderClient:

dependencies { 
    compile 'com.google.android.gms:play-services-maps:11.8.0' 
    compile 'com.google.android.gms:play-services-location:11.8.0' 
    //........ 
} 

Voici le plein classe d'activité:

public class MapsActivity extends AppCompatActivity 
     implements OnMapReadyCallback { 

    GoogleMap mGoogleMap; 
    SupportMapFragment mapFrag; 
    LocationRequest mLocationRequest; 
    Location mLastLocation; 
    Marker mCurrLocationMarker; 
    FusedLocationProviderClient mFusedLocationClient; 

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

     getSupportActionBar().setTitle("Map Location Activity"); 

     mFusedLocationClient = LocationServices.getFusedLocationProviderClient(this); 

     mapFrag = (SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map); 
     mapFrag.getMapAsync(this); 
    } 

    @Override 
    public void onPause() { 
     super.onPause(); 

     //stop location updates when Activity is no longer active 
     if (mFusedLocationClient != null) { 
      mFusedLocationClient.removeLocationUpdates(mLocationCallback); 
     } 
    } 

    @Override 
    public void onMapReady(GoogleMap googleMap) 
    { 
     mGoogleMap=googleMap; 
     mGoogleMap.setMapType(GoogleMap.MAP_TYPE_HYBRID); 

     mLocationRequest = new LocationRequest(); 
     mLocationRequest.setInterval(120000); // two minute interval 
     mLocationRequest.setFastestInterval(120000); 
     mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY); 

     if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
      if (ContextCompat.checkSelfPermission(this, 
        Manifest.permission.ACCESS_FINE_LOCATION) 
        == PackageManager.PERMISSION_GRANTED) { 
       //Location Permission already granted 
       mFusedLocationClient.requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.myLooper()); 
       mGoogleMap.setMyLocationEnabled(true); 
      } else { 
       //Request Location Permission 
       checkLocationPermission(); 
      } 
     } 
     else { 
      mFusedLocationClient.requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.myLooper()); 
      mGoogleMap.setMyLocationEnabled(true); 
     } 
    } 

    LocationCallback mLocationCallback = new LocationCallback(){ 
     @Override 
     public void onLocationResult(LocationResult locationResult) { 
      for (Location location : locationResult.getLocations()) { 
       Log.i("MapsActivity", "Location: " + location.getLatitude() + " " + location.getLongitude()); 
       mLastLocation = location; 
       if (mCurrLocationMarker != null) { 
        mCurrLocationMarker.remove(); 
       } 

       //Place current location marker 
       LatLng latLng = new LatLng(location.getLatitude(), location.getLongitude()); 
       MarkerOptions markerOptions = new MarkerOptions(); 
       markerOptions.position(latLng); 
       markerOptions.title("Current Position"); 
       markerOptions.icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_MAGENTA)); 
       mCurrLocationMarker = mGoogleMap.addMarker(markerOptions); 

       //move map camera 
       mGoogleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(latLng, 11)); 
      } 
     }; 

    }; 

    public static final int MY_PERMISSIONS_REQUEST_LOCATION = 99; 
    private void checkLocationPermission() { 
     if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) 
       != PackageManager.PERMISSION_GRANTED) { 

      // Should we show an explanation? 
      if (ActivityCompat.shouldShowRequestPermissionRationale(this, 
        Manifest.permission.ACCESS_FINE_LOCATION)) { 

       // Show an explanation to the user *asynchronously* -- don't block 
       // this thread waiting for the user's response! After the user 
       // sees the explanation, try again to request the permission. 
       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) { 
           //Prompt the user once explanation has been shown 
           ActivityCompat.requestPermissions(MapsActivity.this, 
             new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 
             MY_PERMISSIONS_REQUEST_LOCATION); 
          } 
         }) 
         .create() 
         .show(); 


      } else { 
       // No explanation needed, we can request the permission. 
       ActivityCompat.requestPermissions(this, 
         new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 
         MY_PERMISSIONS_REQUEST_LOCATION); 
      } 
     } 
    } 

    @Override 
    public void onRequestPermissionsResult(int requestCode, 
              String permissions[], int[] grantResults) { 
     switch (requestCode) { 
      case MY_PERMISSIONS_REQUEST_LOCATION: { 
       // If request is cancelled, the result arrays are empty. 
       if (grantResults.length > 0 
         && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

        // permission was granted, yay! Do the 
        // location-related task you need to do. 
        if (ContextCompat.checkSelfPermission(this, 
          Manifest.permission.ACCESS_FINE_LOCATION) 
          == PackageManager.PERMISSION_GRANTED) { 

         mFusedLocationClient.requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.myLooper()); 
         mGoogleMap.setMyLocationEnabled(true); 
        } 

       } else { 

        // permission denied, boo! Disable the 
        // functionality that depends on this permission. 
        Toast.makeText(this, "permission denied", Toast.LENGTH_LONG).show(); 
       } 
       return; 
      } 

      // other 'case' lines to check for other 
      // permissions this app might request 
     } 

    } 

} 

l'utilisateur sera invité à accepter l'autorisation Emplacement:

L'emplacement sera mis à jour sur le lancement de l'application, et toutes les deux minutes:

Answer 3

mLocationCallback = new LocationCallback() { 
     @Override 
     public void onLocationResult(LocationResult locationResult) { 
      super.onLocationResult(locationResult); 
      currentLocation = locationResult.getLastLocation(); 

     } 
    }; 

ce travail pour moi.

Answer 4

Pour faire simple, essayez avec cette bibliothèque https://github.com/mrmans0n/smart-location-lib. Cela utilisera le fournisseur d'emplacement fusionné.

Vous venez de mettre ce code

SmartLocation.with(context).location(new LocationBasedOnActivityProvider(callback)) 
    .start(new OnLocationUpdatedListener() { ... });