Meilleur moyen d'obtenir la position GPS de l'utilisateur en arrière-plan sous Android
Dans mon application Android, je souhaite obtenir l'emplacement actuel de l'utilisateur toutes les quelques minutes et effectuer la mise à jour sur le serveur de mon centre via le service Web. J'utilise actuellement l'emplacement fusionné. Fournir pour obtenir l'emplacement actuel de l'utilisateur, voir lien
maintenant, je veux savoir quel est le meilleur moyen de localiser l’utilisateur et d’appeler le service Web.
ci-dessous est mon code qui me donne l'emplacement actuel de l'utilisateur: -
locationrequest = LocationRequest.create();
locationrequest.setInterval(10000);
locationclient.requestLocationUpdates(locationrequest,new com.google.Android.gms.location.LocationListener() {
@Override
public void onLocationChanged(Location location) {
Log.i(TAG, "Last Known Location :" + location.getLatitude() + "," + location.getLongitude());
}
});
maintenant d'où je dois appeler ce code. Puis-je l'utiliser dans un service d'arrière-plan ou ailleurs?.
S'il vous plaît fournir votre idée.
TIA.
Aucune des autres réponses n'utilise:
com.google.Android.gms.location.FusedLocationProviderClient
Quel est le fournisseur de localisation avec fusible et le principal point d'entrée pour interagir avec Google avec le fournisseur de localisation avec fusible, et il est très difficile de trouver un bon exemple. Cela a été publié mi 2017 par Google.
Les API de localisation de services Google Play sont préférées à Android API de localisation de la structure (Android.location)
Si vous utilisez actuellement les API de localisation du framework Android, nous vous encourageons vivement à passer aux API de localisation des services Google Play dès que possible.
Pour que vous puissiez utiliser l'API Google Location, ajoutez d'abord ceci à votre build.gradle
compile 'com.google.Android.gms:play-services:11.0.0'
Ensuite, vous pouvez utiliser cette classe Wherebouts.Java:
import Android.location.Location;
import Android.os.Looper;
import Android.util.Log;
import com.google.Android.gms.location.FusedLocationProviderClient;
import com.google.Android.gms.location.LocationCallback;
import com.google.Android.gms.location.LocationRequest;
import com.google.Android.gms.location.LocationResult;
import com.google.Android.gms.location.LocationServices;
import com.google.Android.gms.location.LocationSettingsRequest;
/**
* Uses Google Play API for obtaining device locations
* Created by alejandro.tkachuk
* [email protected]
* www.calculistik.com Mobile Development
*/
public class Wherebouts {
private static final Wherebouts instance = new Wherebouts();
private static final String TAG = Wherebouts.class.getSimpleName();
private FusedLocationProviderClient mFusedLocationClient;
private LocationCallback locationCallback;
private LocationRequest locationRequest;
private LocationSettingsRequest locationSettingsRequest;
private Workable<GPSPoint> workable;
private static final long UPDATE_INTERVAL_IN_MILLISECONDS = 1000;
private static final long FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS = 1000;
private Wherebouts() {
this.locationRequest = new LocationRequest();
this.locationRequest.setInterval(UPDATE_INTERVAL_IN_MILLISECONDS);
this.locationRequest.setFastestInterval(FASTEST_UPDATE_INTERVAL_IN_MILLISECONDS);
this.locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
builder.addLocationRequest(this.locationRequest);
this.locationSettingsRequest = builder.build();
this.locationCallback = new LocationCallback() {
@Override
public void onLocationResult(LocationResult locationResult) {
super.onLocationResult(locationResult); // why? this. is. retarded. Android.
Location currentLocation = locationResult.getLastLocation();
GPSPoint gpsPoint = new GPSPoint(currentLocation.getLatitude(), currentLocation.getLongitude());
Log.i(TAG, "Location Callback results: " + gpsPoint);
if (null != workable)
workable.work(gpsPoint);
}
};
this.mFusedLocationClient = LocationServices.getFusedLocationProviderClient(MainApplication.getAppContext());
this.mFusedLocationClient.requestLocationUpdates(this.locationRequest,
this.locationCallback, Looper.myLooper());
}
public static Wherebouts instance() {
return instance;
}
public void onChange(Workable<GPSPoint> workable) {
this.workable = workable;
}
public LocationSettingsRequest getLocationSettingsRequest() {
return this.locationSettingsRequest;
}
public void stop() {
Log.i(TAG, "stop() Stopping location tracking");
this.mFusedLocationClient.removeLocationUpdates(this.locationCallback);
}
}
À partir de votre activité, vous pouvez l'utiliser comme ceci en transmettant un objet Workable. Un objet Workable n’est rien de plus qu’un objet Callback personnalisé.
Wherebouts.instance().onChange(workable);
En utilisant un rappel tel que Workable, vous écrivez du code lié à l'interface utilisateur dans votre activité et laissez le stress de l'utilisation du GPS à une classe d'assistance, telle que Wherebouts.
new Workable<GPSPoint>() {
@Override
public void work(GPSPoint gpsPoint) {
// draw something in the UI with this new data
}
};
Bien sûr, vous devez demander les autorisations correspondantes au système d'exploitation Android pour que votre application puisse les utiliser. Vous pouvez lire la documentation suivante pour plus d'informations à ce sujet ou effectuer des recherches.
- Référence Android https://developer.Android.com/training/location/index.html
- Wherebouts http://calculistik.com/Wherebouts.Java
- GPSPoint http://calculistik.com/GPSPoint.Java
- Workable http://calculistik.com/Workable.Java
Téléchargez le code source à partir d’ici ( Obtenir l’emplacement actuel à l’aide de Background Service )
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
package="servicetutorial.service">
<uses-permission Android:name="Android.permission.INTERNET"></uses-permission>
<uses-permission Android:name="Android.permission.ACCESS_COARSE_LOCATION"></uses-permission>
<uses-permission Android:name="Android.permission.ACCESS_FINE_LOCATION"></uses-permission>
<application
Android:allowBackup="true"
Android:icon="@mipmap/ic_launcher"
Android:label="@string/app_name"
Android:supportsRtl="true"
Android:theme="@style/AppTheme">
<activity Android:name=".MainActivity"
Android:theme="@Android:style/Theme.Translucent.NoTitleBar">
<intent-filter>
<action Android:name="Android.intent.action.MAIN" />
<category Android:name="Android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service Android:name=".GoogleService"></service>
</application>
</manifest>
activity_main.xml
<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
Android:layout_width="match_parent"
Android:background="#ffffff"
Android:layout_height="match_parent">
<TextView
Android:layout_width="match_parent"
Android:layout_height="50dp"
Android:background="#3F51B5"
Android:text="Location using service"
Android:textColor="#ffffff"
Android:textSize="20dp"
Android:gravity="center"/>
<LinearLayout
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:layout_centerInParent="true"
Android:orientation="vertical">
<LinearLayout
Android:layout_width="match_parent"
Android:orientation="horizontal"
Android:layout_height="50dp">
<TextView
Android:layout_width="150dp"
Android:layout_height="wrap_content"
Android:text="Latitude"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text=""
Android:id="@+id/tv_latitude"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
</LinearLayout>
<LinearLayout
Android:layout_width="match_parent"
Android:orientation="horizontal"
Android:layout_height="50dp">
<TextView
Android:layout_width="150dp"
Android:layout_height="wrap_content"
Android:text="Longitude"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text=""
Android:id="@+id/tv_longitude"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
</LinearLayout>
<LinearLayout
Android:layout_width="match_parent"
Android:orientation="horizontal"
Android:layout_height="50dp">
<TextView
Android:layout_width="150dp"
Android:layout_height="wrap_content"
Android:text="Address"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text=""
Android:id="@+id/tv_address"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
</LinearLayout>
<LinearLayout
Android:layout_width="match_parent"
Android:orientation="horizontal"
Android:layout_height="50dp">
<TextView
Android:layout_width="150dp"
Android:layout_height="wrap_content"
Android:text="Area"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text=""
Android:id="@+id/tv_area"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
</LinearLayout>
<LinearLayout
Android:layout_width="match_parent"
Android:orientation="horizontal"
Android:layout_height="50dp">
<TextView
Android:layout_width="150dp"
Android:layout_height="wrap_content"
Android:text="Locality"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
<TextView
Android:layout_width="wrap_content"
Android:layout_height="wrap_content"
Android:text=""
Android:id="@+id/tv_locality"
Android:layout_gravity="center_vertical"
Android:layout_marginLeft="10dp"
Android:textColor="#000000"
Android:textSize="20dp"/>
</LinearLayout>
</LinearLayout>
<Button
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:id="@+id/btn_start"
Android:text="Get Location"
Android:layout_alignParentBottom="true"/>
</RelativeLayout>
MainActivity.Java
package servicetutorial.service;
import Android.*;
import Android.app.Activity;
import Android.app.ActivityManager;
import Android.content.BroadcastReceiver;
import Android.content.Context;
import Android.content.Intent;
import Android.content.IntentFilter;
import Android.content.SharedPreferences;
import Android.content.pm.PackageManager;
import Android.location.Address;
import Android.location.Geocoder;
import Android.preference.PreferenceManager;
import Android.renderscript.Double2;
import Android.support.v4.app.ActivityCompat;
import Android.support.v4.content.ContextCompat;
import Android.support.v7.app.AppCompatActivity;
import Android.os.Bundle;
import Android.util.Log;
import Android.view.View;
import Android.widget.Button;
import Android.widget.TextView;
import Android.widget.Toast;
import Java.io.IOException;
import Java.util.List;
import Java.util.Locale;
public class MainActivity extends Activity {
Button btn_start;
private static final int REQUEST_PERMISSIONS = 100;
boolean boolean_permission;
TextView tv_latitude, tv_longitude, tv_address,tv_area,tv_locality;
SharedPreferences mPref;
SharedPreferences.Editor medit;
Double latitude,longitude;
Geocoder geocoder;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn_start = (Button) findViewById(R.id.btn_start);
tv_address = (TextView) findViewById(R.id.tv_address);
tv_latitude = (TextView) findViewById(R.id.tv_latitude);
tv_longitude = (TextView) findViewById(R.id.tv_longitude);
tv_area = (TextView)findViewById(R.id.tv_area);
tv_locality = (TextView)findViewById(R.id.tv_locality);
geocoder = new Geocoder(this, Locale.getDefault());
mPref = PreferenceManager.getDefaultSharedPreferences(getApplicationContext());
medit = mPref.edit();
btn_start.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (boolean_permission) {
if (mPref.getString("service", "").matches("")) {
medit.putString("service", "service").commit();
Intent intent = new Intent(getApplicationContext(), GoogleService.class);
startService(intent);
} else {
Toast.makeText(getApplicationContext(), "Service is already running", Toast.LENGTH_SHORT).show();
}
} else {
Toast.makeText(getApplicationContext(), "Please enable the gps", Toast.LENGTH_SHORT).show();
}
}
});
fn_permission();
}
private void fn_permission() {
if ((ContextCompat.checkSelfPermission(getApplicationContext(), Android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED)) {
if ((ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this, Android.Manifest.permission.ACCESS_FINE_LOCATION))) {
} else {
ActivityCompat.requestPermissions(MainActivity.this, new String[]{Android.Manifest.permission.ACCESS_FINE_LOCATION
},
REQUEST_PERMISSIONS);
}
} else {
boolean_permission = true;
}
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode) {
case REQUEST_PERMISSIONS: {
if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
boolean_permission = true;
} else {
Toast.makeText(getApplicationContext(), "Please allow the permission", Toast.LENGTH_LONG).show();
}
}
}
}
private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
latitude = Double.valueOf(intent.getStringExtra("latutide"));
longitude = Double.valueOf(intent.getStringExtra("longitude"));
List<Address> addresses = null;
try {
addresses = geocoder.getFromLocation(latitude, longitude, 1);
String cityName = addresses.get(0).getAddressLine(0);
String stateName = addresses.get(0).getAddressLine(1);
String countryName = addresses.get(0).getAddressLine(2);
tv_area.setText(addresses.get(0).getAdminArea());
tv_locality.setText(stateName);
tv_address.setText(countryName);
} catch (IOException e1) {
e1.printStackTrace();
}
tv_latitude.setText(latitude+"");
tv_longitude.setText(longitude+"");
tv_address.getText();
}
};
@Override
protected void onResume() {
super.onResume();
registerReceiver(broadcastReceiver, new IntentFilter(GoogleService.str_receiver));
}
@Override
protected void onPause() {
super.onPause();
unregisterReceiver(broadcastReceiver);
}
}
GoogleService.Java
package servicetutorial.service;
import Android.app.Service;
import Android.content.Context;
import Android.content.Intent;
import Android.location.Location;
import Android.location.LocationListener;
import Android.location.LocationManager;
import Android.os.Bundle;
import Android.os.Handler;
import Android.os.IBinder;
import Android.support.annotation.Nullable;
import Android.util.Log;
import Java.util.Timer;
import Java.util.TimerTask;
/**
* Created by deepshikha on 24/11/16.
*/
public class GoogleService extends Service implements LocationListener{
boolean isGPSEnable = false;
boolean isNetworkEnable = false;
double latitude,longitude;
LocationManager locationManager;
Location location;
private Handler mHandler = new Handler();
private Timer mTimer = null;
long notify_interval = 1000;
public static String str_receiver = "servicetutorial.service.receiver";
Intent intent;
public GoogleService() {
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public void onCreate() {
super.onCreate();
mTimer = new Timer();
mTimer.schedule(new TimerTaskToGetLocation(),5,notify_interval);
intent = new Intent(str_receiver);
// fn_getlocation();
}
@Override
public void onLocationChanged(Location location) {
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {
}
@Override
public void onProviderEnabled(String provider) {
}
@Override
public void onProviderDisabled(String provider) {
}
private void fn_getlocation(){
locationManager = (LocationManager)getApplicationContext().getSystemService(LOCATION_SERVICE);
isGPSEnable = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
isNetworkEnable = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
if (!isGPSEnable && !isNetworkEnable){
}else {
if (isNetworkEnable){
location = null;
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER,1000,0,this);
if (locationManager!=null){
location = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
if (location!=null){
Log.e("latitude",location.getLatitude()+"");
Log.e("longitude",location.getLongitude()+"");
latitude = location.getLatitude();
longitude = location.getLongitude();
fn_update(location);
}
}
}
if (isGPSEnable){
location = null;
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER,1000,0,this);
if (locationManager!=null){
location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER);
if (location!=null){
Log.e("latitude",location.getLatitude()+"");
Log.e("longitude",location.getLongitude()+"");
latitude = location.getLatitude();
longitude = location.getLongitude();
fn_update(location);
}
}
}
}
}
private class TimerTaskToGetLocation extends TimerTask{
@Override
public void run() {
mHandler.post(new Runnable() {
@Override
public void run() {
fn_getlocation();
}
});
}
}
private void fn_update(Location location){
intent.putExtra("latutide",location.getLatitude()+"");
intent.putExtra("longitude",location.getLongitude()+"");
sendBroadcast(intent);
}
}
Ajouter cette dépendance
compile 'com.google.Android.gms:play-services:9.4.0'
Utilisez: GCM Network Manager
Exécutez ceci pour démarrer une tâche périodique qui sera exécutée même après le redémarrage:
PeriodicTask task = new PeriodicTask.Builder()
.setService(MyLocationService.class)
.setTag("periodic")
.setPeriod(30L)
.setPersisted(true)
.build();
mGcmNetworkManager.schedule(task);
puis dans onRunTask (), récupère l'emplacement actuel et l'utilise (dans cet exemple, l'événement est soumis à la fin pour que l'interface utilisateur sache que l'emplacement a été trouvé):
public void getLastKnownLocation() {
Location lastKnownGPSLocation;
Location lastKnownNetworkLocation;
String gpsLocationProvider = LocationManager.GPS_PROVIDER;
String networkLocationProvider = LocationManager.NETWORK_PROVIDER;
try {
locationManager = (LocationManager) App.get().getSystemService(Context.LOCATION_SERVICE);
lastKnownNetworkLocation = locationManager.getLastKnownLocation(networkLocationProvider);
lastKnownGPSLocation = locationManager.getLastKnownLocation(gpsLocationProvider);
if (lastKnownGPSLocation != null) {
Log.i(TAG, "lastKnownGPSLocation is used.");
this.mCurrentLocation = lastKnownGPSLocation;
} else if (lastKnownNetworkLocation != null) {
Log.i(TAG, "lastKnownNetworkLocation is used.");
this.mCurrentLocation = lastKnownNetworkLocation;
} else {
Log.e(TAG, "lastLocation is not known.");
return;
}
LocationChangedEvent event = new LocationChangedEvent();
event.setLocation(mCurrentLocation);
EventHelper.publishEvent(event);
} catch (SecurityException sex) {
Log.e(TAG, "Location permission is not granted!");
}
return;
}
Le MyLocationService en entier:
public class MyLocationService extends GcmTaskService {
private static final String TAG = MyLocationService.class.getSimpleName();
private LocationManager locationManager;
private Location mCurrentLocation;
public static final String TASK_GET_LOCATION_ONCE="location_oneoff_task";
public static final String TASK_GET_LOCATION_PERIODIC="location_periodic_task";
private static final int RC_PLAY_SERVICES = 123;
@Override
public void onInitializeTasks() {
// When your package is removed or updated, all of its network tasks are cleared by
// the GcmNetworkManager. You can override this method to reschedule them in the case of
// an updated package. This is not called when your application is first installed.
//
// This is called on your application's main thread.
startPeriodicLocationTask(TASK_GET_LOCATION_PERIODIC,
30L, null);
}
@Override
public int onRunTask(TaskParams taskParams) {
Log.d(TAG, "onRunTask: " + taskParams.getTag());
String tag = taskParams.getTag();
Bundle extras = taskParams.getExtras();
// Default result is success.
int result = GcmNetworkManager.RESULT_SUCCESS;
switch (tag) {
case TASK_GET_LOCATION_ONCE:
getLastKnownLocation();
break;
case TASK_GET_LOCATION_PERIODIC:
getLastKnownLocation();
break;
}
return result;
}
public void getLastKnownLocation() {
Location lastKnownGPSLocation;
Location lastKnownNetworkLocation;
String gpsLocationProvider = LocationManager.GPS_PROVIDER;
String networkLocationProvider = LocationManager.NETWORK_PROVIDER;
try {
locationManager = (LocationManager) App.get().getSystemService(Context.LOCATION_SERVICE);
lastKnownNetworkLocation = locationManager.getLastKnownLocation(networkLocationProvider);
lastKnownGPSLocation = locationManager.getLastKnownLocation(gpsLocationProvider);
if (lastKnownGPSLocation != null) {
Log.i(TAG, "lastKnownGPSLocation is used.");
this.mCurrentLocation = lastKnownGPSLocation;
} else if (lastKnownNetworkLocation != null) {
Log.i(TAG, "lastKnownNetworkLocation is used.");
this.mCurrentLocation = lastKnownNetworkLocation;
} else {
Log.e(TAG, "lastLocation is not known.");
return;
}
LocationChangedEvent event = new LocationChangedEvent();
event.setLocation(mCurrentLocation);
EventHelper.publishEvent(event);
} catch (SecurityException sex) {
Log.e(TAG, "Location permission is not granted!");
}
return;
}
public static void startOneOffLocationTask(String tag, Bundle extras) {
Log.d(TAG, "startOneOffLocationTask");
GcmNetworkManager mGcmNetworkManager = GcmNetworkManager.getInstance(App.get());
OneoffTask.Builder taskBuilder = new OneoffTask.Builder()
.setService(MyLocationService.class)
.setTag(tag);
if (extras != null) taskBuilder.setExtras(extras);
OneoffTask task = taskBuilder.build();
mGcmNetworkManager.schedule(task);
}
public static void startPeriodicLocationTask(String tag, Long period, Bundle extras) {
Log.d(TAG, "startPeriodicLocationTask");
GcmNetworkManager mGcmNetworkManager = GcmNetworkManager.getInstance(App.get());
PeriodicTask.Builder taskBuilder = new PeriodicTask.Builder()
.setService(MyLocationService.class)
.setTag(tag)
.setPeriod(period)
.setPersisted(true)
.setRequiredNetwork(Task.NETWORK_STATE_CONNECTED);
if (extras != null) taskBuilder.setExtras(extras);
PeriodicTask task = taskBuilder.build();
mGcmNetworkManager.schedule(task);
}
public static boolean checkPlayServicesAvailable(Activity activity) {
GoogleApiAvailability availability = GoogleApiAvailability.getInstance();
int resultCode = availability.isGooglePlayServicesAvailable(App.get());
if (resultCode != ConnectionResult.SUCCESS) {
if (availability.isUserResolvableError(resultCode)) {
// Show dialog to resolve the error.
availability.getErrorDialog(activity, resultCode, RC_PLAY_SERVICES).show();
}
return false;
} else {
return true;
}
}
Ajoutez également ces 2 au fichier AndroidManifest.xml:
<manifest...
<uses-permission Android:name="Android.permission.RECEIVE_BOOT_COMPLETED" />
<application...
<service
Android:name=".api.location.MyLocationService"
Android:exported="true"
Android:permission="com.google.Android.gms.permission.BIND_NETWORK_TASK_SERVICE">
<intent-filter>
<action Android:name="com.google.Android.gms.gcm.ACTION_TASK_READY" />
</intent-filter>
</service>
Vous devez créer service. Ce service doit implémenter LocationListener. Ensuite, vous devez utiliser AlarmManager pour appeler le service à plusieurs reprises avec un certain délai.
J'espère que celui-ci vous aidera :)
Avec l'aide de l'API LocationServices de GoogleApiClient, nous pouvons obtenir l'emplacement actuel de l'utilisateur/du périphérique dans un intervalle de temps spécifique. Cela peut être ajouté à un service d'arrière-plan qui met à jour l'activité lorsque les rappels onLocationChanged
Le service d'arrière-plan continuera à fonctionner tant que l'application existe dans la mémoire et reste sur le tiroir de notification. Le service gère les fonctionnalités suivantes,
- Connexion à l'API Google LocationServices
- Obtenir la position actuelle
- Partage du résultat à l'activité
Service avec auditeur d'emplacement
public class LocationMonitoringService extends Service implements
GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener,
LocationListener {
...
...
...
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
mLocationClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
mLocationRequest.setInterval(10000); //10 secs
mLocationRequest.setFastestInterval(5000); //5 secs
int priority = LocationRequest.PRIORITY_HIGH_ACCURACY; //by default
//PRIORITY_BALANCED_POWER_ACCURACY, PRIORITY_LOW_POWER, PRIORITY_NO_POWER are the other priority modes
mLocationRequest.setPriority(priority);
mLocationClient.connect();
//Make it stick to the notification panel so it is less prone to get cancelled by the Operating System.
return START_STICKY;
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
/*
* LOCATION CALLBACKS
*/
@Override
public void onConnected(Bundle dataBundle) {
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
// TODO: Consider calling
// ActivityCompat#requestPermissions
// here to request the missing permissions, and then overriding
// public void onRequestPermissionsResult(int requestCode, String[] permissions,
// int[] grantResults)
// to handle the case where the user grants the permission. See the documentation
// for ActivityCompat#requestPermissions for more details.
Log.d(TAG, "== Error On onConnected() Permission not granted");
//Permission not granted by user so cancel the further execution.
return;
}
LocationServices.FusedLocationApi.requestLocationUpdates(mLocationClient, mLocationRequest, this);
Log.d(TAG, "Connected to Google API");
}
/*
* Called by Location Services if the connection to the
* location client drops because of an error.
*/
@Override
public void onConnectionSuspended(int i) {
Log.d(TAG, "Connection suspended");
}
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
Log.d(TAG, "Failed to connect to Google API");
}
//to get the location change
@Override
public void onLocationChanged(Location location) {
Log.d(TAG, "Location changed");
if (location != null) {
//Do something with the location details,
if (location != null) {
//call your API
callAPI(String.valueOf(location.getLatitude()), String.valueOf(location.getLongitude()));
}
}
}
}
Voir le didacticiel complet avec le code source et une explication détaillée >>
J'ai essayé mon code et obtenu le succès essayer ceci
package com.mobeyosoft.latitudelongitude;
import Android.app.Service;
import Android.content.Context;
import Android.content.Intent;
import Android.location.Location;
import Android.location.LocationListener;
import Android.location.LocationManager;
import Android.os.Bundle;
import Android.os.IBinder;
import Android.util.Log;
import Android.widget.Toast;
/**
* Created by 5943 6417 on 14-09-2016.
*/
public class LocationService extends Service
{
public static final String BROADCAST_ACTION = "Hello World";
private static final int TWO_MINUTES = 1000 * 60 * 1;
public LocationManager locationManager;
public MyLocationListener listener;
public Location previousBestLocation = null;
Context context;
Intent intent;
int counter = 0;
@Override
public void onCreate() {
super.onCreate();
intent = new Intent(BROADCAST_ACTION);
context=this;
}
@Override
public void onStart(Intent intent, int startId) {
locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
listener = new MyLocationListener();
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 4000, 0, listener);
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 4000, 0, listener);
}
@Override
public IBinder onBind(Intent intent){
return null;
}
protected boolean isBetterLocation(Location location, Location currentBestLocation) {
if (currentBestLocation == null) {
// A new location is always better than no location
return true;
}
// Check whether the new location fix is newer or older
long timeDelta = location.getTime() - currentBestLocation.getTime();
boolean isSignificantlyNewer = timeDelta > TWO_MINUTES;
boolean isSignificantlyOlder = timeDelta < -TWO_MINUTES;
boolean isNewer = timeDelta > 0;
// If it's been more than two minutes since the current location, use the new location
// because the user has likely moved
if (isSignificantlyNewer) {
return true;
// If the new location is more than two minutes older, it must be worse
} else if (isSignificantlyOlder) {
return false;
}
// Check whether the new location fix is more or less accurate
int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
boolean isLessAccurate = accuracyDelta > 0;
boolean isMoreAccurate = accuracyDelta < 0;
boolean isSignificantlyLessAccurate = accuracyDelta > 200;
// Check if the old and new location are from the same provider
boolean isFromSameProvider = isSameProvider(location.getProvider(),
currentBestLocation.getProvider());
// Determine location quality using a combination of timeliness and accuracy
if (isMoreAccurate) {
return true;
} else if (isNewer && !isLessAccurate) {
return true;
} else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
return true;
}
return false;
}
/** Checks whether two providers are the same */
private boolean isSameProvider(String provider1, String provider2) {
if (provider1 == null) {
return provider2 == null;
}
return provider1.equals(provider2);
}
@Override
public void onDestroy() {
// handler.removeCallbacks(sendUpdatesToUI);
super.onDestroy();
Log.v("STOP_SERVICE", "DONE");
locationManager.removeUpdates(listener);
}
public static Thread performOnBackgroundThread(final Runnable runnable) {
final Thread t = new Thread() {
@Override
public void run() {
try {
runnable.run();
} finally {
}
}
};
t.start();
return t;
}
public class MyLocationListener implements LocationListener{
public void onLocationChanged(final Location loc)
{
Log.i("**********", "Location changed");
if(isBetterLocation(loc, previousBestLocation)) {
loc.getLatitude();
loc.getLongitude();
Toast.makeText(context, "Latitude" + loc.getLatitude() + "\nLongitude"+loc.getLongitude(),Toast.LENGTH_SHORT).show();
intent.putExtra("Latitude", loc.getLatitude());
intent.putExtra("Longitude", loc.getLongitude());
intent.putExtra("Provider", loc.getProvider());
sendBroadcast(intent);
}
}
public void onProviderDisabled(String provider)
{
Toast.makeText( getApplicationContext(), "Gps Disabled", Toast.LENGTH_SHORT ).show();
}
public void onProviderEnabled(String provider)
{
Toast.makeText( getApplicationContext(), "Gps Enabled", Toast.LENGTH_SHORT).show();
}
public void onStatusChanged(String provider, int status, Bundle extras)
{
}
}
}
--Kotlin Version
package com.ps.salestrackingapp.Services
import Android.app.Service
import Android.content.Context
import Android.content.Intent
import Android.location.Location
import Android.location.LocationManager
import Android.os.Bundle
import Android.os.IBinder
import Android.util.Log
class LocationService : Service() {
private var mLocationManager: LocationManager? = null
var mLocationListeners = arrayOf(LocationListener(LocationManager.GPS_PROVIDER), LocationListener(LocationManager.NETWORK_PROVIDER))
class LocationListener(provider: String) : Android.location.LocationListener {
internal var mLastLocation: Location
init {
Log.e(TAG, "LocationListener $provider")
mLastLocation = Location(provider)
}
override fun onLocationChanged(location: Location) {
Log.e(TAG, "onLocationChanged: $location")
mLastLocation.set(location)
Log.v("LastLocation", mLastLocation.latitude.toString() +" " + mLastLocation.longitude.toString())
}
override fun onProviderDisabled(provider: String) {
Log.e(TAG, "onProviderDisabled: $provider")
}
override fun onProviderEnabled(provider: String) {
Log.e(TAG, "onProviderEnabled: $provider")
}
override fun onStatusChanged(provider: String, status: Int, extras: Bundle) {
Log.e(TAG, "onStatusChanged: $provider")
}
}
override fun onBind(arg0: Intent): IBinder? {
return null
}
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
Log.e(TAG, "onStartCommand")
super.onStartCommand(intent, flags, startId)
return Service.START_STICKY
}
override fun onCreate() {
Log.e(TAG, "onCreate")
initializeLocationManager()
try {
mLocationManager!!.requestLocationUpdates(
LocationManager.NETWORK_PROVIDER, LOCATION_INTERVAL.toLong(), LOCATION_DISTANCE,
mLocationListeners[1])
} catch (ex: Java.lang.SecurityException) {
Log.i(TAG, "fail to request location update, ignore", ex)
} catch (ex: IllegalArgumentException) {
Log.d(TAG, "network provider does not exist, " + ex.message)
}
try {
mLocationManager!!.requestLocationUpdates(
LocationManager.GPS_PROVIDER, LOCATION_INTERVAL.toLong(), LOCATION_DISTANCE,
mLocationListeners[0])
} catch (ex: Java.lang.SecurityException) {
Log.i(TAG, "fail to request location update, ignore", ex)
} catch (ex: IllegalArgumentException) {
Log.d(TAG, "gps provider does not exist " + ex.message)
}
}
override fun onDestroy() {
Log.e(TAG, "onDestroy")
super.onDestroy()
if (mLocationManager != null) {
for (i in mLocationListeners.indices) {
try {
mLocationManager!!.removeUpdates(mLocationListeners[i])
} catch (ex: Exception) {
Log.i(TAG, "fail to remove location listners, ignore", ex)
}
}
}
}
private fun initializeLocationManager() {
Log.e(TAG, "initializeLocationManager")
if (mLocationManager == null) {
mLocationManager = applicationContext.getSystemService(Context.LOCATION_SERVICE) as LocationManager
}
}
companion object {
private val TAG = "BOOMBOOMTESTGPS"
private val LOCATION_INTERVAL = 1000
private val LOCATION_DISTANCE = 0f
}
}
import Android.app.Service;
import Android.content.Context;
import Android.content.Intent;
import Android.hardware.GeomagneticField;
import Android.location.Location;
import Android.location.LocationListener;
import Android.location.LocationManager;
import Android.os.Bundle;
import Android.os.IBinder;
import Android.provider.Settings;
import Android.widget.Toast;
public class LocationService extends Service {
private static final int MINUTES = 1000 * 60 * 2;
public LocationManager locationManager;
public MyLocationListener listener;
public Location previousBestLocation = null;
Context mContext;
private boolean isGpsEnabled = false;
private boolean isNetworkEnabled = false;
private GeomagneticField geoField;
private double latitude = 0.0;
private double longitude = 0.0;
@Override
public void onCreate() {
super.onCreate();
mContext = getApplicationContext();
if (locationManager == null) {
locationManager = (LocationManager) mContext.getSystemService(Context.LOCATION_SERVICE);
}
getCurrentLocation();
}
private void getCurrentLocation() {
try {
assert locationManager != null;
isGpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
} catch (Exception ex) {
ex.printStackTrace();
}
if (!isGpsEnabled && !isNetworkEnabled) {
showSettingsAlert();
}
listener = new MyLocationListener();
try {
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 10000, 0, listener);
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 10000, 0, listener);
} catch (SecurityException e) {
e.printStackTrace();
}
}
private void showSettingsAlert() {
Toast.makeText(mContext, "GPS is disabled in your device. Please Enable it ?", Toast.LENGTH_LONG).show();
Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mContext.startActivity(intent);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return START_STICKY;
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
protected boolean isBetterLocation(Location location, Location currentBestLocation) {
if (currentBestLocation == null) {
return true;
}
long timeDelta = location.getTime() - currentBestLocation.getTime();
boolean isSignificantlyNewer = timeDelta > MINUTES;
boolean isSignificantlyOlder = timeDelta < -MINUTES;
boolean isNewer = timeDelta > 0;
if (isSignificantlyNewer) {
return true;
} else if (isSignificantlyOlder) {
return false;
}
int accuracyDelta = (int) (location.getAccuracy() - currentBestLocation.getAccuracy());
boolean isLessAccurate = accuracyDelta > 0;
boolean isMoreAccurate = accuracyDelta < 0;
boolean isSignificantlyLessAccurate = accuracyDelta > 200;
boolean isFromSameProvider = isSameProvider(location.getProvider(), currentBestLocation.getProvider());
if (isMoreAccurate) {
return true;
} else if (isNewer && !isLessAccurate) {
return true;
} else if (isNewer && !isSignificantlyLessAccurate && isFromSameProvider) {
return true;
}
return false;
}
private boolean isSameProvider(String provider1, String provider2) {
if (provider1 == null) {
return provider2 == null;
}
return provider1.equals(provider2);
}
@Override
public void onDestroy() {
super.onDestroy();
locationManager.removeUpdates(listener);
}
private void setupFinalLocationData(Location mLocation) {
if (mLocation != null) {
geoField = new GeomagneticField(
Double.valueOf(mLocation.getLatitude()).floatValue(),
Double.valueOf(mLocation.getLongitude()).floatValue(),
Double.valueOf(mLocation.getAltitude()).floatValue(),
System.currentTimeMillis()
);
latitude = mLocation.getLatitude();
longitude = mLocation.getLongitude();
//Update latitude and longtitude in SharedPreference...
}
}
public class MyLocationListener implements LocationListener {
public void onLocationChanged(final Location loc) {
if (isBetterLocation(loc, previousBestLocation)) {
setupFinalLocationData(loc);
}
}
public void onProviderDisabled(String provider) {
}
public void onProviderEnabled(String provider) {
}
public void onStatusChanged(String provider, int status, Bundle extras) {
}
}
}
Accordez l'autorisation requise ACCESS_FINE_LOCATION, ACCESS_COARSE_LOCATION après le démarrage du service
import Android.annotation.SuppressLint;
import Android.app.Notification;
import Android.app.NotificationChannel;
import Android.app.NotificationManager;
import Android.app.PendingIntent;
import Android.app.Service;
import Android.content.Context;
import Android.content.Intent;
import Android.content.IntentSender;
import Android.location.Location;
import Android.location.LocationListener;
import Android.media.RingtoneManager;
import Android.net.Uri;
import Android.os.Build;
import Android.os.Bundle;
import Android.os.Handler;
import Android.os.IBinder;
import Android.os.Looper;
import Android.support.annotation.NonNull;
import Android.support.annotation.Nullable;
import Android.support.v4.app.NotificationCompat;
import Android.support.v7.app.AppCompatActivity;
import Android.util.Log;
import com.google.Android.gms.common.ConnectionResult;
import com.google.Android.gms.common.GoogleApiAvailability;
import com.google.Android.gms.common.api.ApiException;
import com.google.Android.gms.common.api.GoogleApiClient;
import com.google.Android.gms.common.api.ResolvableApiException;
import com.google.Android.gms.location.FusedLocationProviderClient;
import com.google.Android.gms.location.LocationCallback;
import com.google.Android.gms.location.LocationRequest;
import com.google.Android.gms.location.LocationResult;
import com.google.Android.gms.location.LocationServices;
import com.google.Android.gms.location.LocationSettingsRequest;
import com.google.Android.gms.location.LocationSettingsResponse;
import com.google.Android.gms.location.LocationSettingsStatusCodes;
import com.google.Android.gms.location.SettingsClient;
import com.google.Android.gms.tasks.OnCanceledListener;
import com.google.Android.gms.tasks.OnFailureListener;
import com.google.Android.gms.tasks.OnSuccessListener;
import Java.util.concurrent.TimeUnit;
/**
* Created by Ketan Ramani on 05/11/18.
*/
public class BackgroundBackgroundLocationUpdateService extends Service implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, LocationListener {
/* Declare in manifest
<service Android:name=".BackgroundBackgroundLocationUpdateService"/>
*/
private final String TAG = "BackgroundBackgroundLocationUpdateService";
private final String TAG_LOCATION = "TAG_LOCATION";
private Context context;
private boolean stopService = false;
/* For Google Fused API */
protected GoogleApiClient mGoogleApiClient;
protected LocationSettingsRequest mLocationSettingsRequest;
private String latitude = "0.0", longitude = "0.0";
private FusedLocationProviderClient mFusedLocationClient;
private SettingsClient mSettingsClient;
private LocationCallback mLocationCallback;
private LocationRequest mLocationRequest;
private Location mCurrentLocation;
/* For Google Fused API */
@Override
public void onCreate() {
super.onCreate();
context = this;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
StartForeground();
final Handler handler = new Handler();
final Runnable runnable = new Runnable() {
@Override
public void run() {
try {
if (!stopService) {
//Perform your task here
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (!stopService) {
handler.postDelayed(this, TimeUnit.SECONDS.toMillis(10));
}
}
}
};
handler.postDelayed(runnable, 2000);
buildGoogleApiClient();
return START_STICKY;
}
@Override
public void onDestroy() {
Log.e(TAG, "Service Stopped");
stopService = true;
if (mFusedLocationClient != null) {
mFusedLocationClient.removeLocationUpdates(mLocationCallback);
Log.e(TAG_LOCATION, "Location Update Callback Removed");
}
super.onDestroy();
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return null;
}
private void StartForeground() {
Intent intent = new Intent(context, MainActivity.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0 /* Request code */, intent, PendingIntent.FLAG_ONE_SHOT);
String CHANNEL_ID = "channel_location";
String CHANNEL_NAME = "channel_location";
NotificationCompat.Builder builder = null;
NotificationManager notificationManager = (NotificationManager) getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
NotificationChannel channel = new NotificationChannel(CHANNEL_ID, CHANNEL_NAME, NotificationManager.IMPORTANCE_DEFAULT);
channel.setLockscreenVisibility(Notification.VISIBILITY_PRIVATE);
notificationManager.createNotificationChannel(channel);
builder = new NotificationCompat.Builder(getApplicationContext(), CHANNEL_ID);
builder.setChannelId(CHANNEL_ID);
builder.setBadgeIconType(NotificationCompat.BADGE_ICON_NONE);
} else {
builder = new NotificationCompat.Builder(getApplicationContext(), CHANNEL_ID);
}
builder.setContentTitle("Your title");
builder.setContentText("You are now online");
Uri notificationSound = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_NOTIFICATION);
builder.setSound(notificationSound);
builder.setAutoCancel(true);
builder.setSmallIcon(R.drawable.ic_logo);
builder.setContentIntent(pendingIntent);
Notification notification = builder.build();
startForeground(101, notification);
}
@Override
public void onLocationChanged(Location location) {
Log.e(TAG_LOCATION, "Location Changed Latitude : " + location.getLatitude() + "\tLongitude : " + location.getLongitude());
latitude = String.valueOf(location.getLatitude());
longitude = String.valueOf(location.getLongitude());
if (latitude.equalsIgnoreCase("0.0") && longitude.equalsIgnoreCase("0.0")) {
requestLocationUpdate();
} else {
Log.e(TAG_LOCATION, "Latitude : " + location.getLatitude() + "\tLongitude : " + location.getLongitude());
}
}
@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 onConnected(@Nullable Bundle bundle) {
mLocationRequest = new LocationRequest();
mLocationRequest.setInterval(10 * 1000);
mLocationRequest.setFastestInterval(5 * 1000);
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();
builder.addLocationRequest(mLocationRequest);
builder.setAlwaysShow(true);
mLocationSettingsRequest = builder.build();
mSettingsClient
.checkLocationSettings(mLocationSettingsRequest)
.addOnSuccessListener(new OnSuccessListener<LocationSettingsResponse>() {
@Override
public void onSuccess(LocationSettingsResponse locationSettingsResponse) {
Log.e(TAG_LOCATION, "GPS Success");
requestLocationUpdate();
}
}).addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
int statusCode = ((ApiException) e).getStatusCode();
switch (statusCode) {
case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
try {
int REQUEST_CHECK_SETTINGS = 214;
ResolvableApiException rae = (ResolvableApiException) e;
rae.startResolutionForResult((AppCompatActivity) context, REQUEST_CHECK_SETTINGS);
} catch (IntentSender.SendIntentException sie) {
Log.e(TAG_LOCATION, "Unable to execute request.");
}
break;
case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
Log.e(TAG_LOCATION, "Location settings are inadequate, and cannot be fixed here. Fix in Settings.");
}
}
}).addOnCanceledListener(new OnCanceledListener() {
@Override
public void onCanceled() {
Log.e(TAG_LOCATION, "checkLocationSettings -> onCanceled");
}
});
}
@Override
public void onConnectionSuspended(int i) {
connectGoogleClient();
}
@Override
public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
buildGoogleApiClient();
}
protected synchronized void buildGoogleApiClient() {
mFusedLocationClient = LocationServices.getFusedLocationProviderClient(context);
mSettingsClient = LocationServices.getSettingsClient(context);
mGoogleApiClient = new GoogleApiClient.Builder(context)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
connectGoogleClient();
mLocationCallback = new LocationCallback() {
@Override
public void onLocationResult(LocationResult locationResult) {
super.onLocationResult(locationResult);
Log.e(TAG_LOCATION, "Location Received");
mCurrentLocation = locationResult.getLastLocation();
onLocationChanged(mCurrentLocation);
}
};
}
private void connectGoogleClient() {
GoogleApiAvailability googleAPI = GoogleApiAvailability.getInstance();
int resultCode = googleAPI.isGooglePlayServicesAvailable(context);
if (resultCode == ConnectionResult.SUCCESS) {
mGoogleApiClient.connect();
}
}
@SuppressLint("MissingPermission")
private void requestLocationUpdate() {
mFusedLocationClient.requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.myLooper());
}
}
En activité
Démarrer le service: startService(new Intent(this, BackgroundLocationUpdateService.class));
Service d'arrêt: stopService(new Intent(this, BackgroundLocationUpdateService.class));
En fragment
Démarrer le service: getActivity().startService(new Intent(getActivity().getBaseContext(), BackgroundLocationUpdateService.class));
Service d'arrêt: getActivity().stopService(new Intent(getActivity(), BackgroundLocationUpdateService.class));
Vous pouvez l'archiver avec un gestionnaire de services et d'alarmes, mais soyez prudent, car si vous configurez une priorité élevée, vous allez vider la batterie du téléphone. Par contre, vous avez vraiment besoin de notifier l'emplacement à chaque minute? C'est parce que la seule façon de voir un changement considérable de la position de l'utilisateur, c'est de voyager en voiture ou en train. Je demande seulement, parce que cela dépendra de votre application et de l'exigence du suivi.
Bien créer un service d'extension de classe, ce service contiendra votre classe d'écouteur d'emplacement (fournisseur d'emplacement fusionné). Ce service a pour but d'obtenir l'emplacement périodiquement, quelque chose comme ceci.
public class LocationGetter extends Service {
......
public class MyLocationListener implements GooglePlayServicesClient.ConnectionCallbacks,GooglePlayServicesClient.OnConnectionFailedListener,LocationListener, com.google.Android.gms.location.LocationListener {
//your fused Location provider code
}
......
}
Créez ensuite une classe qui étend le récepteur de diffusion, de telle sorte que le but de ce récepteur de diffusion soit de vérifier si le service est actif, sinon redémarré, même pendant l'activation/désactivation du téléphone ....
enregistrer le récepteur dans votre activité, écouter les émissions, désenregistrer le récepteur en fonction de vos besoins ...