OnStatusChanged d'Android10 LocationListener est abandonné

  OnStatusChanged de LocationListener est obsolète dans Android10, ce rappel n'est jamais appelé sur Android Q et supérieur, le fournisseur peut être considéré comme toujours dans l'état LocationProvider#AVAILABLE.

EmplacementÉcouteur | Développeurs Android

Il existe les solutions suivantes :

① Utilisez LocationListenerCompat (l'appareil doit être équipé de GMS)

② Utilisez le SDK Amap, le SDK Baidu ou un tiers

Cependant, dans certains projets, ces conditions ne sont pas remplies, ce qui conduit à l'abandon de l'API. Dans les endroits où le signal GPS n'est pas bon, il n'y a aucun moyen de rappeler pour faire savoir à l'application que le signal GPS n'est pas bon et effectuer un traitement logique de la réponse.Cet article se concentre sur la résolution de ce problème.

1. Créez une interface pour demander un emplacement

public interface LocationChangeListener {
    void onLocationChanged(double latitude, double longitude);
    default void onProviderEnabled(String provider) {}
    default void onProviderDisabled(String provider) {}
    default void onStatusChanged(String provider, int status, Bundle extras) {}
}

2. Créer GpsLocationManager

public class GpsLocationManager {

    private static final String TAG = GpsLocationManager.class.getSimpleName();

    private final LocationManager mLocationManager;
    private LocationChangeListener mLocationChangeListener;
    private LocationChangedListener mLocationChangedListener;
    public static SpUtils mGPSSpUtils = null;

    public void setLocationChangeListener(LocationChangeListener listener) {
        this.mLocationChangeListener = listener;
    }

    public GpsLocationManager() {
        mLocationManager = (LocationManager) App.get().getSystemService(Context.LOCATION_SERVICE);
        mLocationChangedListener = new LocationChangedListener();
        mGPSSpUtils = new SpUtils(App.get(), Const.GPS_STATE_SP);
    }

    /**
     * request location.
     *
     * @param context          context
     */
    public void requestLocationUpdates(Context context) {
        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // 如果没有位置权限，请求用户授权
            ActivityCompat.requestPermissions((Activity) context, new String[]{Manifest.permission.ACCESS_FINE_LOCATION}, 1);
        } else {
            // 如果有位置权限，开始监听位置变化
            mLocationManager.requestSingleUpdate(LocationManager.GPS_PROVIDER,mLocationChangedListener, Looper.getMainLooper());
            mGPSSpUtils.setBoolean(Const.GPS_STATE_SP, false);
            mGPSSpUtils.apply();
        }
    }

    /**
     * release LocationManager.
     *
     */
    public void release() {
        if (mLocationManager != null && mLocationChangedListener != null) {
            try {
                mLocationManager.removeUpdates(mLocationChangedListener);
            } catch (SecurityException e) {
                Logger.e(TAG, "Error releasing location updates: " + e.getMessage());
            }
        }
    }

    public class LocationChangedListener implements LocationListener {

        public LocationChangedListener() {
        }

        @Override
        public void onLocationChanged(Location location) {
            mGPSSpUtils.setBoolean(Const.GPS_STATE_SP, true);
            mGPSSpUtils.apply();
            if (mLocationChangeListener != null) {
                mLocationChangeListener.onLocationChanged(location.getLatitude(), location.getLongitude());
            }
        }

        @Override
        public void onStatusChanged(String provider, int status, Bundle extras) {
            if (mLocationChangeListener != null) {
                mLocationChangeListener.onStatusChanged(provider, status, extras);
            }
        }

        @Override
        public void onProviderEnabled(String provider) {
            mGPSSpUtils.setBoolean(Const.GPS_STATE_SP, true);
            mGPSSpUtils.apply();
            if (mLocationChangeListener != null) {
                mLocationChangeListener.onProviderEnabled(provider);
            }
        }

        @Override
        public void onProviderDisabled(String provider) {
            mGPSSpUtils.setBoolean(Const.GPS_STATE_SP, false);
            mGPSSpUtils.apply();
            if (mLocationChangeListener != null) {
                mLocationChangeListener.onProviderDisabled(provider);
            }
        }
    }
}

SharedPreferences est utilisé pour stocker l’état de l’émission des demandes de localisation et de la demande d’informations de localisation.

3. Appelez la méthode dans le gestionnaire pour demander des données là où le projet l'exige.

    private static void requestLocationAndDataUpdates() {
        mGpsLocationManager.setLocationChangeListener(new LocationChangeListener() {
            @Override
            public void onLocationChanged(double latitude, double longitude) {
                Logger.d(TAG, "onLocationChanged: latitude:" + latitude + " longitude:"+ longitude);
                // 请求到位置信息，进行相应的操作
            }
        });

        // 请求位置更新
        mGpsLocationManager.requestLocationUpdates(mContext);
    }

Au bon moment, retardez l’acquisition de la valeur de SharedPreferences pour déterminer si des informations de localisation sont demandées.

new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
                @Override
                public void run() {
                    boolean GpsMsgState = mGPSSpUtils.getBoolean(Const.GPS_STATE_SP,false);
                    Logger.d(TAG, "checkNetworkAndRequestLocation: GpsMsgState:"+GpsMsgState);
                    if (!GpsMsgState) {
                        mWeatherInfo.setGPSState(Const.GPS_INVALID);
                        // 没有请求到位置信息，进行相应的操作
                    }
                }
            }, Const.RQUEST_STATE_DELAYED_TIME);

Ici, je définis Const.RQUEST_STATE_DELAYED_TIME comme 6 secondes. Généralement, le temps nécessaire pour demander des informations de localisation est de quelques secondes à des dizaines de secondes, et peut être ajusté en fonction de projets spécifiques.

   Bien sûr, il serait préférable que le projet soit équipé d'un SDK tiers. Ceci est un dernier recours et présente des inconvénients : si le GPS est en dehors du délai personnalisé, les informations de localisation ne peuvent pas être obtenues (vous pouvez également écrire un programme pour surveiller les changements de longitude et de latitude), si vous rencontrez ce problème, vous pouvez vous y référer.