我想做什么
当我的应用程序启动时，我正在使用一个片段，该片段使用AutoCompleteTextView和Places SDK在用户做出选择时获取Place对象。发生这种情况时，我会通过调用repository.storeWeatherLocation(context,placeId)通过我的Repository类将所选的Place（作为WeatherLocation实体）存储在Room数据库中，然后根据需要再次获取天气详细信息。
发生了什么
suspend fun storeWeatherLocationAsync正在调用fetchCurrentWeather()和fetchWeeklyWeather()，因为尽管数据库检查员显示已经存在较早的天气数据，但根据我的记录，previousLocation变量为空。
崩溃详细信息
我的应用程序崩溃，表明我的LocationProvider的getCustomLocationLat()返回null（发生在fetchCurrentWeather()中）。问题是用户选择的位置已成功存储在我的Room数据库中（已使用Database Inspector检查），因此此函数如何返回null？
UPDATE：
[在使用调试器和logcat进行了更多测试之后，我发现WeatherLocation数据在应用运行时正在保存在Room中。一旦崩溃，我重新打开它，该数据再次为空。我在这里想念什么？我是否以某种方式删除了先前的数据？我实际上不是在房间中正确缓存它吗？
数据库类：
@Database(
entities = [CurrentWeatherEntry::class,WeekDayWeatherEntry::class,WeatherLocation::class],
version = 16
)
abstract class ForecastDatabase : RoomDatabase() {
abstract fun currentWeatherDao() : CurrentWeatherDao
abstract fun weekDayWeatherDao() : WeekDayWeatherDao
abstract fun weatherLocationDao() : WeatherLocationDao
// Used to make sure that the ForecastDatabase class will be a singleton
companion object {
// Volatile == all of the threads will have immediate access to this property
@Volatile private var instance:ForecastDatabase? = null
private val LOCK = Any() // dummy object for thread monitoring
operator fun invoke(context:Context) = instance ?: synchronized(LOCK) {
// If the instance var hasn't been initialized, call buildDatabase()
// and assign it the returned object from the function call (it)
instance ?: buildDatabase(context).also { instance = it }
}
/**
* Creates an instance of the ForecastDatabase class
* using Room.databaseBuilder().
*/
private fun buildDatabase(context: Context) =
Room.databaseBuilder(context.applicationContext,
ForecastDatabase::class.java, "forecast.db")
//.addMigrations(MIGRATION_2_3) // specify an explicit Migration Technique
.fallbackToDestructiveMigration()
.build()
}
}
这里是存储库类：
class ForecastRepositoryImpl(
private val currentWeatherDao: CurrentWeatherDao,
private val weekDayWeatherDao: WeekDayWeatherDao,
private val weatherLocationDao: WeatherLocationDao,
private val locationProvider: LocationProvider,
private val weatherNetworkDataSource: WeatherNetworkDataSource
) : ForecastRepository {
init {
weatherNetworkDataSource.apply {
// Persist downloaded data
downloadedCurrentWeatherData.observeForever { newCurrentWeather: CurrentWeatherResponse? ->
persistFetchedCurrentWeather(newCurrentWeather!!)
}
downloadedWeeklyWeatherData.observeForever { newWeeklyWeather: WeeklyWeatherResponse? ->
persistFetchedWeeklyWeather(newWeeklyWeather!!)
}
}
}
override suspend fun getCurrentWeather(): LiveData<CurrentWeatherEntry> {
return withContext(Dispatchers.IO) {
initWeatherData()
return@withContext currentWeatherDao.getCurrentWeather()
}
}
override suspend fun getWeekDayWeatherList(time: Long): LiveData<out List<WeekDayWeatherEntry>> {
return withContext(Dispatchers.IO) {
initWeatherData()
return@withContext weekDayWeatherDao.getFutureWeather(time)
}
}
override suspend fun getWeatherLocation(): LiveData<WeatherLocation> {
return withContext(Dispatchers.IO) {
return@withContext weatherLocationDao.getWeatherLocation()
}
}
private suspend fun initWeatherData() {
// retrieve the last weather location from room
val lastWeatherLocation = weatherLocationDao.getWeatherLocation().value
if (lastWeatherLocation == null ||
locationProvider.hasLocationChanged(lastWeatherLocation)
) {
fetchCurrentWeather()
fetchWeeklyWeather()
return
}
val lastFetchedTime = currentWeatherDao.getCurrentWeather().value?.zonedDateTime
if (isFetchCurrentNeeded(lastFetchedTime!!))
fetchCurrentWeather()
if (isFetchWeeklyNeeded())
fetchWeeklyWeather()
}
/**
* Checks if the current weather data should be re-fetched.
* @param lastFetchedTime The time at which the current weather data were last fetched
* @return True or false respectively
*/
private fun isFetchCurrentNeeded(lastFetchedTime: ZonedDateTime): Boolean {
val thirtyMinutesAgo = ZonedDateTime.now().minusMinutes(30)
return lastFetchedTime.isBefore(thirtyMinutesAgo)
}
/**
* Fetches the Current Weather data from the WeatherNetworkDataSource.
*/
private suspend fun fetchCurrentWeather() {
weatherNetworkDataSource.fetchCurrentWeather(
locationProvider.getPreferredLocationLat(),
locationProvider.getPreferredLocationLong()
)
}
private fun isFetchWeeklyNeeded(): Boolean {
val todayEpochTime = LocalDate.now().toEpochDay()
val futureWeekDayCount = weekDayWeatherDao.countFutureWeekDays(todayEpochTime)
return futureWeekDayCount < WEEKLY_FORECAST_DAYS_COUNT
}
private suspend fun fetchWeeklyWeather() {
weatherNetworkDataSource.fetchWeeklyWeather(
locationProvider.getPreferredLocationLat(),
locationProvider.getPreferredLocationLong()
)
}
override fun storeWeatherLocation(context:Context,placeId: String) {
GlobalScope.launch(Dispatchers.IO) {
storeWeatherLocationAsync(context,placeId)
}
}
override suspend fun storeWeatherLocationAsync(context: Context,placeId: String) {
var isFetchNeeded: Boolean // a flag variable
// Specify the fields to return.
val placeFields: List<Place.Field> =
listOf(Place.Field.ID, Place.Field.NAME,Place.Field.LAT_LNG)
// Construct a request object, passing the place ID and fields array.
val request = FetchPlaceRequest.newInstance(placeId, placeFields)
// Create the client
val placesClient = Places.createClient(context)
placesClient.fetchPlace(request).addOnSuccessListener { response ->
// Get the retrieved place object
val place = response.place
// Create a new WeatherLocation object using the place details
val newWeatherLocation = WeatherLocation(place.latLng!!.latitude,
place.latLng!!.longitude,place.name!!,place.id!!)
val previousLocation = weatherLocationDao.getWeatherLocation().value
if(previousLocation == null || ((newWeatherLocation.latitude != previousLocation.latitude) &&
(newWeatherLocation.longitude != previousLocation.longitude))) {
isFetchNeeded = true
// Store the weatherLocation in the database
persistWeatherLocation(newWeatherLocation)
// fetch the data
GlobalScope.launch(Dispatchers.IO) {
// fetch the weather data and wait for it to finish
withContext(Dispatchers.Default) {
if (isFetchNeeded) {
// fetch the weather data using the new location
fetchCurrentWeather()
fetchWeeklyWeather()
}
}
}
}
Log.d("REPOSITORY","storeWeatherLocationAsync : inside task called")
}.addOnFailureListener { exception ->
if (exception is ApiException) {
// Handle error with given status code.
Log.e("Repository", "Place not found: ${exception.statusCode}")
}
}
}
/**
* Caches the downloaded current weather data to the local
* database.
* @param fetchedCurrentWeather The most recently fetched current weather data
*/
private fun persistFetchedCurrentWeather(fetchedCurrentWeather: CurrentWeatherResponse) {
fetchedCurrentWeather.currentWeatherEntry.setTimezone(fetchedCurrentWeather.timezone)
// Using a GlobalScope since a Repository class doesn't have a lifecycle
GlobalScope.launch(Dispatchers.IO) {
currentWeatherDao.upsert(fetchedCurrentWeather.currentWeatherEntry)
}
}
/**
* Caches the selected location data to the local
* database.
* @param fetchedLocation The most recently fetched location data
*/
private fun persistWeatherLocation(fetchedLocation: WeatherLocation) {
GlobalScope.launch(Dispatchers.IO) {
weatherLocationDao.upsert(fetchedLocation)
}
}
/**
* Caches the downloaded weekly weather data to the local
* database.
* @param fetchedWeeklyWeather The most recently fetched weekly weather data
*/
private fun persistFetchedWeeklyWeather(fetchedWeeklyWeather: WeeklyWeatherResponse) {
fun deleteOldData() {
val time = LocalDate.now().toEpochDay()
weekDayWeatherDao.deleteOldEntries(time)
}
GlobalScope.launch(Dispatchers.IO) {
deleteOldData()
val weekDayEntriesList = fetchedWeeklyWeather.weeklyWeatherContainer.weekDayEntries
weekDayWeatherDao.insert(weekDayEntriesList)
}
}
}
这是LocationProvider的隐含内容：
class LocationProviderImpl(
private val fusedLocationProviderClient: FusedLocationProviderClient,
context: Context,
private val locationDao: WeatherLocationDao
) : PreferenceProvider(context), LocationProvider {
private val appContext = context.applicationContext
override suspend fun hasLocationChanged(lastWeatherLocation: WeatherLocation): Boolean {
return try {
hasDeviceLocationChanged(lastWeatherLocation)
} catch (e:LocationPermissionNotGrantedException) {
false
}
}
/**
* Makes the required checks to determine whether the device's location has
* changed or not.
* @param lastWeatherLocation The last known user selected location
* @return true if the device location has changed or false otherwise
*/
private suspend fun hasDeviceLocationChanged(lastWeatherLocation: WeatherLocation): Boolean {
if(!isUsingDeviceLocation()) return false // we don't have location permissions or setting's disabled
val currentDeviceLocation = getLastDeviceLocationAsync().await()
?: return false
// Check if the old and new locations are far away enough that an update is needed
val comparisonThreshold = 0.03
return abs(currentDeviceLocation.latitude - lastWeatherLocation.latitude) > comparisonThreshold
&& abs(currentDeviceLocation.longitude - lastWeatherLocation.longitude) > comparisonThreshold
}
/**
* Checks if the app has the location permission, and if that's the case
* it will fetch the device's last saved location.
* @return The device's last saved location as a Deferred<Location?>
*/
@SuppressLint("MissingPermission")
private fun getLastDeviceLocationAsync(): Deferred<Location?> {
return if(hasLocationPermission())
fusedLocationProviderClient.lastLocation.asDeferredAsync()
else
throw LocationPermissionNotGrantedException()
}
/**
* Checks if the user has granted the location
* permission.
*/
private fun hasLocationPermission(): Boolean {
return ContextCompat.checkSelfPermission(appContext,
Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
}
/**
* Returns the sharedPrefs value for the USE_DEVICE_LOCATION
* preference with a default value of "true".
*/
private fun isUsingDeviceLocation(): Boolean {
return preferences.getBoolean(USE_DEVICE_LOCATION_KEY,false)
}
private fun getCustomLocationLat() : Double {
val lat:Double? = locationDao.getWeatherLocation().value?.latitude
if(lat == null) Log.d("LOCATION_PROVIDER","lat is null = $lat")
return lat!!
}
private fun getCustomLocationLong():Double {
return locationDao.getWeatherLocation().value!!.longitude
}
override suspend fun getPreferredLocationLat(): Double {
if(isUsingDeviceLocation()) {
try {
val deviceLocation = getLastDeviceLocationAsync().await()
?: return getCustomLocationLat()
return deviceLocation.latitude
} catch (e:LocationPermissionNotGrantedException) {
return getCustomLocationLat()
}
} else {
return getCustomLocationLat()
}
}
override suspend fun getPreferredLocationLong(): Double {
if(isUsingDeviceLocation()) {
try {
val deviceLocation = getLastDeviceLocationAsync().await()
?: return getCustomLocationLong()
return deviceLocation.longitude
} catch (e:LocationPermissionNotGrantedException) {
return getCustomLocationLong()
}
} else {
return getCustomLocationLong()
}
}
}
前言
如果没有完整的代码，也没有充分理解此代码的含义，很难具体说明您的问题。如果我的以下一般建议（基于我的猜测和预测）对您没有用，我建议您要么添加一个到您的存储库的链接，要么简化您的用例，以便有人可以为您提供帮助。但同样，您在最小限度可复制的示例中包含的代码越多，获得具体答案的机会就越多。
我对麻烦根源的猜测
我的猜测（考虑到您描述的事实），您遇到麻烦的主要嫌疑人是代码部分的重叠部分，这些部分是异步的（例如，this case与LiveData有关。但是在调用中断函数时也是如此）不同的协程等等）。那么我所说的问题的条件是什么？接下来是它们-您将数据保存在本地数据库中，然后读取数据，这两个操作都是异步的，并且在第一个事件和第二个事件之间需要一点时间。我真的不了解您所描述的情况是否存在。如果不是，我没猜对吧：-）
我的建议
尝试检查描述的行为是否确实导致了您的问题。有很多方法可以做到这一点。其中一个-更改大小写，第二项操作（从本地db读取）将跟随第一个操作（写入）。为此，您可以将第二个操作放入协程中，并在一些延迟之前添加（我认为，delay（1000）就足够了）。据我了解，您的函数-getCustomLocationLat（），getCustomLocationLong（）-是完成此技巧的第一个候选对象（可能还有其他函数，但是您会更容易了解它们）。如果在此测试用例之后，您的问题得以解决-您可以考虑做出什么适当的更改以保证第二个事件始终在第一个事件之后（它可能取决于对某些问题的回答-1）是否可以将两个一个协程中发生的事件？ 2）您可以用LiveData的观察值或Deferred替换LiveData的拆包值吗？）
您不希望房间LiveData从null返回除getValue()之外的任何内容，直到添加了Observer并在其回调中收到其第一个值。 LiveData主要是一个可观察的数据持有者，Room创建的那些数据持有者在设计上既是惰性的又是异步的，因此在附加Observer之前，它们将不会开始进行后台数据库工作以使值可用。
在LocationProviderImpl中的情况下]]
private fun getCustomLocationLat() : Double { val lat:Double? = locationDao.getWeatherLocation().value?.latitude if(lat == null) Log.d("LOCATION_PROVIDER","lat is null = $lat") return lat!! } private fun getCustomLocationLong():Double { return locationDao.getWeatherLocation().value!!.longitude }您应该使用具有更直接返回类型的
Dao方法来检索值，例如。在您的Dao中，而不是这样：
@Query("<your query here>") fun getWeatherLocation(): LiveData<LocationEntity>创建并使用其中之一：
@Query("<your query here>") suspend fun getWeatherLocation(): LocationEntity? @Query("<your query here>") fun getWeatherLocationSync(): LocationEntity?直到检索到结果后才返回。