如何优化Fused Location API获取用户位置的延迟问题？

嘿，我明白你现在的困扰——在用户从设置页面开启位置服务后，直接调用getLastLocation()经常会遇到延迟或者返回null的情况，所以你用了5秒的固定延迟来绕开这个问题，但这确实不是最可靠的方案。其实我们可以利用Fused Location Provider的实时位置回调机制，让系统在获取到有效位置时主动通知我们，这样既能消除不必要的延迟，又能保证拿到最新的位置数据。

问题根源分析 #

• 当用户刚开启位置服务时，系统需要时间完成定位初始化（比如连接GPS、基站等），这时候getLastLocation()可能还没有可用的缓存位置，所以会返回null或者旧数据。
• 固定延迟的方式完全是预估，无法适配不同设备的定位速度，要么浪费时间，要么还是拿不到位置。

核心优化方案 #

1. 使用LocationCallback监听位置更新：替代单次的getLastLocation()，注册一个回调，当系统成功获取到位置时会自动触发回调方法，不用等待固定时间。
2. 在位置设置开启后直接注册回调：在onActivityResult里直接启动位置监听，而不是延迟调用getLocation()。
3. 及时移除回调避免耗电：在Activity销毁或者不需要定位时，一定要移除回调，防止后台持续耗电。
4. 处理getLastLocation()为null的场景：如果缓存位置不存在，回调会帮我们获取最新的位置。

修改后的完整代码示例 #

public class MainActivity extends AppCompatActivity {
    String addressText = "";
    int LOCATION_REQUEST_CODE = 1;
    int REQUEST_CHECK_SETTINGS = 2;
    TextView latitude, longitude;
    LocationRequest mLocationRequest;
    FusedLocationProviderClient mFusedLocationClient;
    LocationCallback mLocationCallback; // 新增位置回调

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        latitude = findViewById(R.id.latitude);
        longitude = findViewById(R.id.longitude);
        mFusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
        createLocationRequest();
        initLocationCallback(); // 初始化回调
    }

    // 初始化位置回调
    private void initLocationCallback() {
        mLocationCallback = new LocationCallback() {
            @Override
            public void onLocationResult(LocationResult locationResult) {
                if (locationResult == null) {
                    Toast.makeText(MainActivity.this, "无法获取位置", Toast.LENGTH_SHORT).show();
                    return;
                }
                // 获取到最新位置
                Location location = locationResult.getLastLocation();
                if (location != null) {
                    updateLocationUI(location);
                    // 获取到位置后可以移除回调，避免持续更新（如果只需要一次的话）
                    mFusedLocationClient.removeLocationUpdates(mLocationCallback);
                }
            }
        };
    }

    // 更新UI和获取地址
    private void updateLocationUI(Location location) {
        latitude.setText("Latitude : " + location.getLatitude());
        longitude.setText("Longitude : " + location.getLongitude());
        // 注意：AsyncTask已被废弃，建议改用Coroutine或Executor
        new GetAddress().execute(location);
    }

    void getLocation() {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(
                    this,
                    new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                    LOCATION_REQUEST_CODE);
        } else {
            // 先尝试获取缓存位置
            mFusedLocationClient.getLastLocation()
                    .addOnSuccessListener(this, location -> {
                        if (location != null) {
                            updateLocationUI(location);
                        } else {
                            // 缓存位置为空，注册回调等待最新位置
                            startLocationUpdates();
                        }
                    });
        }
    }

    // 启动位置更新监听
    private void startLocationUpdates() {
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        mFusedLocationClient.requestLocationUpdates(mLocationRequest, mLocationCallback, Looper.getMainLooper());
    }

    protected void createLocationRequest() {
        mLocationRequest = new LocationRequest();
        mLocationRequest.setInterval(10000);
        mLocationRequest.setFastestInterval(5000);
        mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);

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

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

        task.addOnSuccessListener(locationSettingsResponse -> getLocation());

        task.addOnFailureListener(e -> {
            if (e instanceof ResolvableApiException) {
                try {
                    ResolvableApiException resolvable = (ResolvableApiException) e;
                    resolvable.startResolutionForResult(MainActivity.this, REQUEST_CHECK_SETTINGS);
                } catch (IntentSender.SendIntentException ignored) {
                }
            }
        });
    }

    class GetAddress extends AsyncTask<Location, Void, Void> {
        @Override
        protected Void doInBackground(Location... locations) {
            Location location = locations[0];
            List<Address> addresses = null;
            Geocoder geocoder = new Geocoder(MainActivity.this, Locale.getDefault());
            try {
                addresses = geocoder.getFromLocation(location.getLatitude(), location.getLongitude(), 1);
            } catch (IOException ioException) {
                runOnUiThread(() -> Toast.makeText(MainActivity.this, "网络不佳，无法获取地址", Toast.LENGTH_SHORT).show());
            }
            if (addresses == null || addresses.size() == 0) {
                runOnUiThread(() -> Toast.makeText(MainActivity.this, "未找到地址", Toast.LENGTH_SHORT).show());
            } else {
                Address address = addresses.get(0);
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i <= address.getMaxAddressLineIndex(); i++) {
                    sb.append(System.getProperty("line.separator")).append(address.getAddressLine(i));
                }
                addressText = sb.toString();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);
            Toast.makeText(MainActivity.this, addressText, Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == LOCATION_REQUEST_CODE && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            getLocation();
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == REQUEST_CHECK_SETTINGS && resultCode == RESULT_OK) {
            // 直接启动位置更新监听，无需延迟
            startLocationUpdates();
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 移除回调，避免后台耗电
        if (mFusedLocationClient != null && mLocationCallback != null) {
            mFusedLocationClient.removeLocationUpdates(mLocationCallback);
        }
    }
}

额外优化建议 #

• 替代AsyncTask：从API 33开始，AsyncTask已经被废弃，建议改用Coroutines或者ExecutorService来处理地址解析的异步任务，避免内存泄漏问题。
• 位置请求参数调整：如果你的应用不需要极高精度，可以把Priority改为PRIORITY_BALANCED_POWER_ACCURACY，平衡定位精度和耗电。
• 错误处理增强：在LocationCallback的onLocationAvailability方法里监听定位可用性，当定位不可用时可以给用户提示。

内容的提问来源于stack exchange，提问作者Abhinav Upadhyay