Android FusedLocationClient无法获取有效定位问题求助

我在Android项目中需要启动时获取用户的最后/当前位置，但始终无法拿到有效定位，locationGetter.client.lastLocation返回的location一直为null。已经在模拟器中设置过位置，排除无历史定位数据的可能，以下是相关代码和问题细节：

一、MainActivity权限检查代码 #

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding = ActivityMainBinding.inflate(layoutInflater)
    setContentView(binding.root)
    permissionHelper = PermissionHelper(this)
    val drawerLayout: DrawerLayout = binding.drawerLayout
    val navView: NavigationView = binding.navView
    val navHostFragment = supportFragmentManager.findFragmentById(R.id.nav_host_fragment_content_home) as NavHostFragment
    val navController = navHostFragment.navController

    appBarConfiguration = AppBarConfiguration(
        setOf(
            R.id.nav_home,
            R.id.nav_account, R.id.nav_pictures, R.id.nav_settings
        ), drawerLayout
    )
    setupActionBarWithNavController(navController, appBarConfiguration)
    navView.setupWithNavController(navController)

    NavigationUI.setupWithNavController(binding.navView, navController)

    navController.addOnDestinationChangedListener { _, destination, _ ->
        isCurrentLocationFragmentVisible = destination.id == R.id.nav_home
        if (isCurrentLocationFragmentVisible) {
            invalidateOptionsMenu()
        }
    }
    handleLocationAndWeather()
    currentLocationViewModel.weather.observe(this){
        currentLocation = LocationDto(it.location.cityName, it.location.locationIndex)

    }
}

private fun handleLocationAndWeather() {
    // 检查定位权限是否已授予
    if (permissionHelper.isPermissionGranted(Manifest.permission.ACCESS_COARSE_LOCATION)) {
        // 权限已授予，加载天气数据
        viewModel.updatePermissionState(LocationPermissionState.Granted)
        viewModel.loadCurrentLocationWeather()
    } else {
        // 未授予权限，发起申请
        permissionHelper.requestPermission(
            Manifest.permission.ACCESS_COARSE_LOCATION,
            "需要定位权限来获取您当前位置的天气数据。",
            LOCATION_PERMISSION_REQUEST_CODE
        )
    }
}
override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)

    when (requestCode) {
        LOCATION_PERMISSION_REQUEST_CODE ->
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // 权限授予成功，更新状态并加载天气数据
                viewModel.updatePermissionState(LocationPermissionState.Granted)
                viewModel.loadCurrentLocationWeather()
            } else {
                // 权限被拒绝，更新状态并处理
                viewModel.updatePermissionState(LocationPermissionState.Denied)
                viewModel.loadCurrentLocationWeather()
                //TODO 此处显示提示吐司
            }
    }
}

二、PermissionHelper权限处理类代码 #

class PermissionHelper(private val activity: Activity) {

    fun isPermissionGranted(permission: String): Boolean {
        return ContextCompat.checkSelfPermission(activity, permission) == PackageManager.PERMISSION_GRANTED
    }

    fun requestPermission(permission: String, rationale: String, requestCode: Int) {
        if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
            showRationaleDialog(rationale) { _, _ ->
                ActivityCompat.requestPermissions(
                    activity,
                    arrayOf(permission),
                    requestCode
                )
            }
        } else {
            ActivityCompat.requestPermissions(
                activity,
                arrayOf(permission),
                requestCode
            )
        }
    }

    private fun showRationaleDialog(message: String, onPositiveClick: (DialogInterface, Int) -> Unit) {
        AlertDialog.Builder(activity)
            .setTitle("需要定位权限")
            .setMessage(message)
            .setPositiveButton("确定", onPositiveClick)
            .setNegativeButton("取消", null)
            .show()
    }
}

三、ViewModel中定位获取相关代码 #

private val _locationPermissionState = MutableStateFlow<LocationPermissionState>(LocationPermissionState.Granted)
val locationPermissionState: StateFlow<LocationPermissionState> = _locationPermissionState

fun updatePermissionState(state : LocationPermissionState){
    _locationPermissionState.value = state
}
@SuppressLint("MissingPermission")
fun loadCurrentLocationWeather() {
    viewModelScope.launch {
        when (locationPermissionState.value) {
            LocationPermissionState.Granted -> {
                Log.d(TAG, "权限已授予")
                locationGetter.client.lastLocation
                    .addOnSuccessListener { location ->
                        // 检查位置是否不为空
                        if (location != null) {
                            Log.d(TAG, "位置不为空")
                            viewModelScope.launch {
                                weatherRepository.getWeather(
                                    location.latitude,
                                    location.longitude
                                )
                                    .map { locationWithWeatherDataDto ->
                                        val weatherData =
                                            convertWeatherDtoToWeatherModel(
                                                locationWithWeatherDataDto.weather
                                            )
                                        val locationData = LocationModel(
                                            locationWithWeatherDataDto.location.cityName,
                                            locationWithWeatherDataDto.location.locationIndex
                                        )
                                        LocationWeatherModel(
                                            location = locationData,
                                            weather = weatherData
                                        )
                                    }
                                    .collect {
                                        _weather.value = it
                                        Log.d(TAG, it.weather.cityName)
                                    }
                            }
                        } else {
                            // 位置为空，显示芝加哥天气
                            Log.d(TAG, "位置为空")
                            viewModelScope.launch {
                                weatherRepository.getWeather("Chicago")
                                    .map { locationWithWeatherDataDto ->
                                        val weatherData =
                                            convertWeatherDtoToWeatherModel(locationWithWeatherDataDto.weather)
                                        val locationData = LocationModel(
                                            locationWithWeatherDataDto.location.cityName,
                                            locationWithWeatherDataDto.location.locationIndex
                                        )
                                        LocationWeatherModel(location = locationData, weather = weatherData)
                                    }
                                    .collect {
                                        _weather.value = it
                                        Log.d(TAG, it.weather.cityName)
                                    }
                            }
                        }
                    }
            }
            else -> {
                // 定位权限被拒绝
                viewModelScope.launch {
                    weatherRepository.getWeather("Seattle")
                        .map { locationWithWeatherDataDto ->
                            val weatherData =
                                convertWeatherDtoToWeatherModel(locationWithWeatherDataDto.weather)
                            val locationData = LocationModel(
                                locationWithWeatherDataDto.location.cityName,
                                locationWithWeatherDataDto.location.locationIndex
                            )
                            LocationWeatherModel(location = locationData, weather = weatherData)
                        }
                }
            }
        }
    }
}

问题核心 #

调用locationGetter.client.lastLocation.addOnSuccessListener时，回调中的location始终为null，无法获取有效定位。

排查与解决建议 #

• 补充定位权限：当前仅申请了ACCESS_COARSE_LOCATION，建议同时申请ACCESS_FINE_LOCATION。部分设备或场景下，仅粗糙定位权限可能无法获取到系统缓存的历史位置数据，需在权限申请、检查逻辑中添加该权限。
• 主动请求位置更新：lastLocation依赖系统缓存的历史位置，即使模拟器设置了位置，若系统未缓存该位置或缓存已失效，就会返回null。此时需要主动请求单次位置更新，替代仅依赖历史数据的逻辑：

  // 替换原lastLocation的调用逻辑
  val locationRequest = LocationRequest.create().apply {
      priority = LocationRequest.PRIORITY_HIGH_ACCURACY
      interval = 0
      fastestInterval = 0
      numUpdates = 1 // 仅请求一次位置
  }
  locationGetter.client.requestLocationUpdates(locationRequest, object : LocationCallback() {
      override fun onLocationResult(locationResult: LocationResult) {
          super.onLocationResult(locationResult)
          val location = locationResult.lastLocation
          // 此处处理获取到的location
          locationGetter.client.removeLocationUpdates(this) // 及时移除回调，避免内存泄漏
      }
  }, Looper.getMainLooper())
  

• 检查LocationClient初始化：确认locationGetter.client是否正确初始化，是否关联了Google Play服务，初始化时是否配置了正确的权限与回调参数。
• 验证模拟器位置生效：打开系统自带的地图应用，确认地图能正确显示设置的位置，再测试自己的应用，排除模拟器位置未生效的可能。
• 添加错误监听：给lastLocation添加失败监听，获取错误信息辅助定位问题：

  locationGetter.client.lastLocation
      .addOnSuccessListener { ... }
      .addOnFailureListener { e ->
          Log.e(TAG, "获取位置失败: ${e.message}")
      }
  

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