programacion - obtener direccion android studio

No obteniendo latitud y longitud desde el servicio en segundo plano

Question

Soy nuevo en Android. Quiero ejecutar un servicio en segundo plano y obtener latitud y longitud o dirección geográfica después de 10 minutos y enviarlo al servidor.

Por favor, ayúdame.

Aquí está mi código:

En actividad

public void serviceCall(){
Log.e("INSIDE ALARM", "INSIDE ALARM");
Intent intent = new Intent(getApplicationContext(), MyService.class);
final PendingIntent pIntent = PendingIntent.getBroadcast(this, MyService.REQUEST_CODE,
intent, PendingIntent.FLAG_UPDATE_CURRENT);
long firstMillis = System.currentTimeMillis();
AlarmManager alarm = (AlarmManager) this.getSystemService(Context.ALARM_SERVICE);
alarm.setInexactRepeating(AlarmManager.RTC_WAKEUP, firstMillis,
6000, pIntent);
}

en Reciver

public static final int REQUEST_CODE = 9411;
@Override
public void onReceive(Context context, Intent intent) {
Intent inti = new Intent(context, LocationService.class);
intent1.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK |Intent.FLAG_ACTIVITY_CLEAR_TOP |Intent.FLAG_ACTIVITY_NEW_TASK);
context.startService(inti);
}

en IntentService

protected void onHandleIntent(Intent intent) {
Log.e("imsidehandler Service", ":=");
mRequestingLocationUpdates = false;
buildGoogleApiClient();
createLocationRequest();
buildLocationSettingsRequest();
checkLocationSettings();
sendDataServer();
}
public void onConnected(Bundle bundle) {
if (mCurrentLocation == null) {
mCurrentLocation = LocationServices.FusedLocationApi.getLastLocation(mGoogleApiClient);
mLastUpdateTime = DateFormat.getTimeInstance().format(new Date());
updateLocationUI();
}
}
public void onConnectionSuspended(int i) {
}
public void onLocationChanged(Location location) {
mCurrentLocation = location;
mLastUpdateTime = DateFormat.getTimeInstance().format(new Date());
}
public void onConnectionFailed(ConnectionResult connectionResult) {
}
private synchronized void buildGoogleApiClient() {
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}
private void createLocationRequest() {
mLocationRequest = new LocationRequest();
mLocationRequest.setInterval(UPDATE_INTERVAL_IN_MILLISECONDS);
mLocationRequest.setFastestInterval(FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS);
mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
}
private void buildLocationSettingsRequest() {
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
builder.addLocationRequest(mLocationRequest);
mLocationSettingsRequest = builder.build();
}
private void checkLocationSettings() {
PendingResult<LocationSettingsResult> result =
LocationServices.SettingsApi.checkLocationSettings(
mGoogleApiClient,
mLocationSettingsRequest
);
result.setResultCallback(this);
}
protected boolean startLocationUpdates() {
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) {
return true;
}
return false;
}
protected void stopLocationUpdates() {
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, (com.google.android.gms.location.LocationListener) this).setResultCallback(new ResultCallback<Status>() {
@Override
public void onResult(Status status) {
mRequestingLocationUpdates = false;
}
});
}
private void updateLocationUI() {
if (mCurrentLocation != null) {
updateCityAndPincode(mCurrentLocation.getLatitude(), mCurrentLocation.getLongitude());
}
}
private void updateCityAndPincode(double latitude, double longitude) {
try {
Log.e("latitude","==>"+longitude);
Log.e("longitude","==>"+longitude);
this.latitude = latitude;
this.longitude = longitude;
getGeoAddress(latitude, longitude);
} catch (Exception e) {
}
}
private void getGeoAddress(Double latitude, Double longitude) {
Geocoder geocoder = new Geocoder(this, Locale.getDefault());
String result = null;
List<Address> addressList = null;
try {
addressList = geocoder.getFromLocation(
latitude, longitude, 1);
if (addressList != null && addressList.size() > 0) {
Address address = addressList.get(0);
Log.e("address","==>"+address);
for (int i = 0; i < address.getMaxAddressLineIndex(); i++) {
result += address.getAddressLine(i);
result += " ";
}
if (result.contains("null")) {
result1 = result.replace("null", "");
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void onResult(LocationSettingsResult locationSettingsResult) {
final Status status = locationSettingsResult.getStatus();
switch (status.getStatusCode()) {
case LocationSettingsStatusCodes.SUCCESS:
startLocationUpdates();
break;
case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
try {
status.startResolutionForResult((Activity) getApplicationContext(), REQUEST_CHECK_SETTINGS);
} catch (IntentSender.SendIntentException e) {
}
break;
case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
break;
}
}

por favor, ayúdame

Answer 1

El método getLastLocation() simplemente obtiene la última ubicación conocida que el dispositivo sabe. A veces, el dispositivo "no sabe" su ubicación y se devuelve un null .

El dispositivo no determina su ubicación por sí solo, sino solo cuando alguna aplicación solicita la ubicación. Por lo tanto, su aplicación ahora depende de otras aplicaciones que soliciten actualizaciones de ubicación.

Además, la "última ubicación conocida" aquí significa exactamente eso: puede que no esté actualizada. Las ubicaciones vienen con un sello de tiempo que se puede usar para evaluar si la ubicación aún es relevante.

No veo una llamada a requestLocationUpdates() en ningún lugar de tu código. Eso solicitaría actualizaciones de ubicación actualizadas en un intervalo que puede especificar.

Su método onConnected() podría tener:

public void onConnected(Bundle bundle) {
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
}

(La llamada getLastLocation() se puede eliminar).

Y su IntentService podría implementar LocationListener y hacer las mismas cosas que onConnected() ahora, pero solo después de que haya llegado una actualización de ubicación:

@Override
public void onLocationChanged(Location location) {
// Cancel the updates after the first one:
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
mCurrentLocation = location;
mLastUpdateTime = DateFormat.getTimeInstance().format(new Date());
updateLocationUI();
}

Esta sería la forma de solicitar y procesar actualizaciones de ubicación con los cambios de código más pequeños.

Por supuesto, también hay otras formas de solicitar las actualizaciones cada 10 minutos y procesarlas a través de un PendingIntent . Existe esta versión de requestLocationUpdates () que toma un PendingIntent :

public abstract PendingResult<Status> requestLocationUpdates (GoogleApiClient client, LocationRequest request, PendingIntent callbackIntent)

Eso reemplazaría tu mecanismo de temporizador actual.