Modifier les paramètres de localisation

Si votre application a besoin de demander l'accès à la localisation ou de recevoir des mises à jour d'autorisations, l'appareil doit activer les paramètres système adaptés, tels que la recherche GPS ou Wi-Fi. Plutôt que d'activer directement des services tels que le GPS de l'appareil, votre application spécifie le niveau de précision/consommation d'énergie requis et l'intervalle de mise à jour souhaité. L'appareil apporte automatiquement les modifications adaptées aux paramètres système. Ces paramètres sont définis par l'objet de données LocationRequest.

Cette leçon vous indique comment utiliser le client des paramètres pour vérifier quels paramètres sont activés et présenter la boîte de dialogue Paramètres de localisation pour que l'utilisateur puisse mettre à jour ses paramètres d'un simple geste.

Configurer les services de localisation

Pour utiliser les services de localisation fournis par les services Google Play et le "Fused Location Provider", connectez votre application à l'aide du client des paramètres, puis vérifiez les paramètres de localisation actuels et invitez l'utilisateur à activer les paramètres requis, le cas échéant.

Les applications dont les fonctionnalités utilisent les services de localisation doivent demander des autorisations d'accès à la localisation, selon les cas d'utilisation de ces fonctionnalités.

Configurer une requête de localisation

Pour stocker les paramètres des requêtes adressées au "Fused Location Provider", créez une LocationRequest. Les paramètres déterminent le niveau de précision des requêtes de localisation. Pour en savoir plus sur toutes les options de requête de localisation disponibles, consultez la documentation de référence de la classe LocationRequest. Cette leçon définit l'intervalle de mise à jour, l'intervalle de mise à jour le plus rapide et la priorité, comme décrit ci-dessous :

Intervalle de mise à jour

setInterval() : cette méthode permet de définir la vitesse en millisecondes à laquelle votre application préfère recevoir les notifications de position. Notez que les notifications de position peuvent être un peu plus rapides ou plus lentes que cette vitesse pour optimiser l'utilisation de la batterie, voire totalement absentes (si l'appareil n'est pas connecté, par exemple).

Intervalle de mise à jour le plus rapide

setFastestInterval() : cette méthode définit la vitesse la plus rapide, en millisecondes, à laquelle votre application peut gérer les notifications de position. Vous n'avez pas besoin d'appeler cette méthode, à moins que votre application ne bénéficie de la réception de notifications plus rapides que la vitesse spécifiée dans setInterval().

Priorité

setPriority() : cette méthode définit la priorité de la requête, ce qui donne aux services de localisation des services Google Play un indice important sur les sources de localisation à utiliser. Les valeurs suivantes sont prises en charge :

• PRIORITY_BALANCED_POWER_ACCURACY : utilisez ce paramètre pour demander une précision de localisation au niveau des quartiers, ce qui correspond à une précision d'environ 100 mètres. Ce niveau de précision est plutôt approximatif et susceptible de consommer moins d'énergie. Avec ce paramètre, les services de localisation sont susceptibles d'utiliser le Wi-Fi et la position des antennes-relais. Notez toutefois que le choix du fournisseur de localisation dépend de nombreux autres facteurs, tels que les sources disponibles.
• PRIORITY_HIGH_ACCURACY : utilisez ce paramètre pour demander la position la plus exacte possible. Avec ce paramètre, les services de localisation sont plus susceptibles d'utiliser le GPS pour déterminer la position.
• PRIORITY_LOW_POWER : utilisez ce paramètre pour demander la précision au niveau de la ville, soit une précision d'environ 10 kilomètres. Ce niveau de précision est plutôt approximatif et susceptible de consommer moins d'énergie.
• PRIORITY_NO_POWER : utilisez ce paramètre si vous avez besoin d'un impact négligeable sur la consommation d'énergie, mais que vous souhaitez recevoir des notifications de position lorsqu'elles sont disponibles. Avec ce paramètre, votre application ne génère aucune notification de position, mais reçoit les positions générées par d'autres applications.

Créez la requête de localisation et définissez les paramètres comme indiqué dans cet exemple de code :

Kotlin

fun createLocationRequest() {
  val locationRequest = LocationRequest.Builder()
      .setIntervalMillis(10000)
      .setFastestIntervalMillis(5000)
      .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
      .build()
}

Java

protected void createLocationRequest() {
  LocationRequest locationRequest = LocationRequest.Builder()
      .setIntervalMillis(10000)
      .setFastestIntervalMillis(5000)
      .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
      .build();
}

La priorité de PRIORITY_HIGH_ACCURACY, combinée au paramètre d'autorisation ACCESS_FINE_LOCATION que vous avez défini dans le fichier manifeste d'application et à un intervalle de mise à jour rapide de 5 000 millisecondes (5 secondes), permet au "Fused Location Provider" de renvoyer des notifications de position précises à quelques mètres près. Cette approche est adaptée aux applications de cartographie qui affichent la position en temps réel.

Indice de performance : si votre application accède au réseau ou effectue d'autres tâches de longue durée après la réception d'une notification de position, ajustez l'intervalle le plus rapide sur une valeur plus lente. Cet ajustement empêche votre application de recevoir des notifications qu'elle ne peut pas utiliser. Une fois la tâche de longue durée terminée, rétablissez une valeur plus rapide pour l'intervalle le plus rapide.

Obtenir les paramètres de localisation actuels

Une fois connecté aux services Google Play et à l'API des services de localisation, vous pouvez obtenir les paramètres de localisation actuels de l'appareil d'un utilisateur. Pour ce faire, créez un LocationSettingsRequest.Builder et ajoutez une ou plusieurs requêtes de localisation. L'extrait de code suivant illustre comment ajouter la requête de localisation créée à l'étape précédente :

Kotlin

val builder = LocationSettingsRequest.Builder()
        .addLocationRequest(locationRequest)

Java

LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
     .addLocationRequest(locationRequest);

Ensuite, vérifiez si les paramètres de localisation actuels sont respectés :

Kotlin

val builder = LocationSettingsRequest.Builder()

// ...

val client: SettingsClient = LocationServices.getSettingsClient(this)
val task: Task<LocationSettingsResponse> = client.checkLocationSettings(builder.build())

Java

LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder();

// ...

SettingsClient client = LocationServices.getSettingsClient(this);
Task<LocationSettingsResponse> task = client.checkLocationSettings(builder.build());

Une fois la Task terminée, votre application peut vérifier les paramètres de localisation en consultant le code d'état de l'objet LocationSettingsResponse. Pour obtenir plus de détails sur l'état actuel des paramètres de localisation pertinents, votre application peut appeler la méthode getLocationSettingsStates() de l'objet LocationSettingsResponse.

Inviter l'utilisateur à modifier les paramètres de localisation

Pour déterminer si les paramètres de localisation sont adaptés à la requête de localisation, ajoutez un OnFailureListener à l'objet Task qui valide les paramètres de localisation. Ensuite, vérifiez si l'objet Exception transmis à la méthode onFailure() est une instance de la classe ResolvableApiException, qui indique que les paramètres doivent être modifiés. Ensuite, affichez une boîte de dialogue qui demande à l'utilisateur l'autorisation de modifier les paramètres de localisation en appelant startResolutionForResult().

L'extrait de code suivant montre comment déterminer si les paramètres de localisation de l'utilisateur permettent aux services de localisation de créer une LocationRequest, mais également comment lui demander l'autorisation de modifier les paramètres de localisation, le cas échéant :

Kotlin

task.addOnSuccessListener { locationSettingsResponse ->
    // All location settings are satisfied. The client can initialize
    // location requests here.
    // ...
}

task.addOnFailureListener { exception ->
    if (exception is ResolvableApiException){
        // Location settings are not satisfied, but this can be fixed
        // by showing the user a dialog.
        try {
            // Show the dialog by calling startResolutionForResult(),
            // and check the result in onActivityResult().
            exception.startResolutionForResult(this@MainActivity,
                    REQUEST_CHECK_SETTINGS)
        } catch (sendEx: IntentSender.SendIntentException) {
            // Ignore the error.
        }
    }
}

Java

task.addOnSuccessListener(this, new OnSuccessListener<LocationSettingsResponse>() {
    @Override
    public void onSuccess(LocationSettingsResponse locationSettingsResponse) {
        // All location settings are satisfied. The client can initialize
        // location requests here.
        // ...
    }
});

task.addOnFailureListener(this, new OnFailureListener() {
    @Override
    public void onFailure(@NonNull Exception e) {
        if (e instanceof ResolvableApiException) {
            // Location settings are not satisfied, but this can be fixed
            // by showing the user a dialog.
            try {
                // Show the dialog by calling startResolutionForResult(),
                // and check the result in onActivityResult().
                ResolvableApiException resolvable = (ResolvableApiException) e;
                resolvable.startResolutionForResult(MainActivity.this,
                        REQUEST_CHECK_SETTINGS);
            } catch (IntentSender.SendIntentException sendEx) {
                // Ignore the error.
            }
        }
    }
});

La leçon suivante, Recevoir des notifications de position, vous explique comment recevoir des notifications de position périodiques.