Cache and Eviction Strategy: Offline First

app/build.gradle.kts

@@ -181,6 +181,21 @@ dependencies {
     testImplementation(libs.coroutines.test)
     debugImplementation(libs.compose.ui.tooling)
     debugImplementation(libs.compose.ui.test.manifest)
+    implementation(libs.androidx.work.testing)
+    implementation(libs.core.ktx)
+    testImplementation(libs.roboelectric)
+    testImplementation(libs.androidx.arch.core)
+    implementation(libs.core.ktx.test)
+
+    //Room
+    implementation(libs.room.ktx)
+    implementation(libs.room.runtime)
+    kapt(libs.room.compiler)
+
+    //WorkManager
+    implementation(libs.androidx.work.ktx)
+    implementation(libs.hilt.ext.work)
+    kapt(libs.hilt.compiler)
 
     // chucker
     debugImplementation(libs.chucker.debug)

app/proguard-rules.pro

@@ -18,4 +18,4 @@
 
 # If you keep the line number information, uncomment this to
 # hide the original source file name.
-#-renamesourcefileattribute SourceFile
+#-renamesourcefileattribute SourceFile

app/src/main/AndroidManifest.xml

@@ -4,7 +4,7 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
-
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
     <application
         android:name=".WeatherApp"
         android:allowBackup="true"
@@ -30,6 +30,11 @@
                 android:name="android.app.lib_name"
                 android:value="" />
         </activity>
+        <provider
+            android:name="androidx.startup.InitializationProvider"
+            android:authorities="${applicationId}.androidx-startup"
+            tools:node="remove">
+        </provider>
     </application>
 
 </manifest>

app/src/main/java/com/github/odaridavid/weatherapp/WeatherApp.kt

@@ -1,7 +1,29 @@
 package com.github.odaridavid.weatherapp
 
 import android.app.Application
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.work.Configuration
+import com.github.odaridavid.weatherapp.worker.WeatherUpdateScheduler
 import dagger.hilt.android.HiltAndroidApp
+import javax.inject.Inject
 
 @HiltAndroidApp
-class WeatherApp : Application()
+class WeatherApp : Application(),  Configuration.Provider{
+    @Inject
+    lateinit var workerFactory: HiltWorkerFactory
+
+    @Inject
+    lateinit var weatherUpdateScheduler: WeatherUpdateScheduler
+
+    override fun onCreate() {
+        super.onCreate()
+        schedulePeriodicWeatherUpdates()
+    }
+
+    override fun getWorkManagerConfiguration(): Configuration =
+        Configuration.Builder().setWorkerFactory(workerFactory).build()
+
+    private fun schedulePeriodicWeatherUpdates() {
+        weatherUpdateScheduler.schedulePeriodicWeatherUpdates()
+    }
+}

app/src/main/java/com/github/odaridavid/weatherapp/data/weather/DefaultWeatherRepository.kt

@@ -8,8 +8,7 @@ import com.github.odaridavid.weatherapp.core.model.DefaultLocation
 import com.github.odaridavid.weatherapp.core.model.ExcludedData
 import com.github.odaridavid.weatherapp.core.model.SupportedLanguage
 import com.github.odaridavid.weatherapp.core.model.Weather
-import com.google.firebase.crashlytics.ktx.crashlytics
-import com.google.firebase.ktx.Firebase
+import com.github.odaridavid.weatherapp.data.weather.local.dao.WeatherDao
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.flow
@@ -19,30 +18,43 @@ import javax.inject.Inject
 
 class DefaultWeatherRepository @Inject constructor(
     private val openWeatherService: OpenWeatherService,
+    private val weatherDao: WeatherDao,
     private val logger: Logger
 ) : WeatherRepository {
     override fun fetchWeatherData(
         defaultLocation: DefaultLocation,
         language: String,
         units: String
     ): Flow<ApiResult<Weather>> = flow {
-
+        val cachedWeather = weatherDao.getWeather()
+        if (cachedWeather != null && cachedWeather.isDataValid()) {
+            val weatherData = cachedWeather.toCoreEntity(unit = units)
+            emit(ApiResult.Success(data = weatherData))
+            return@flow
+        }
         val excludedData = "${ExcludedData.MINUTELY.value},${ExcludedData.ALERTS.value}"
 
-        val response = openWeatherService.getWeatherData(
+        val apiResponse = openWeatherService.getWeatherData(
             longitude = defaultLocation.longitude,
             latitude = defaultLocation.latitude,
             excludedInfo = excludedData,
             units = units,
             language = getLanguageValue(language),
             appid = BuildConfig.OPEN_WEATHER_API_KEY
         )
-
-        if (response.isSuccessful && response.body() != null) {
-            val weatherData = response.body()!!.toCoreModel(unit = units)
-            emit(ApiResult.Success(data = weatherData))
+        val response = apiResponse.body()
+        if (apiResponse.isSuccessful && response != null) {
+            val currentWeather = apiResponse.body()!!.toCurrentWeatherEntity()
+            val hourlyEntity = apiResponse.body()!!.toHourlyEntity()
+            val dailyEntity = apiResponse.body()!!.toDailyEntity()
+            weatherDao.insertCurrentWeather(currentWeather)
+            weatherDao.insertHourlyWeather(hourlyEntity)
+            weatherDao.insertDailyWeather(dailyEntity)
+            val getWeather = weatherDao.getWeather()
+            val data = getWeather!!.toCoreEntity(unit = units)
+            emit(ApiResult.Success(data =data))
         } else {
-            val errorMessage = mapResponseCodeToErrorMessage(response.code())
+            val errorMessage = mapResponseCodeToErrorMessage(apiResponse.code())
             emit(ApiResult.Error(errorMessage))
         }
     }.catch { throwable ->
@@ -53,7 +65,6 @@ class DefaultWeatherRepository @Inject constructor(
         logger.logException(throwable)
         emit(ApiResult.Error(errorMessage))
     }
-
     private fun mapResponseCodeToErrorMessage(code: Int): Int = when (code) {
         HTTP_UNAUTHORIZED -> R.string.error_unauthorized
         in 400..499 -> R.string.error_client

app/src/main/java/com/github/odaridavid/weatherapp/data/weather/Mappers.kt

@@ -8,10 +8,17 @@ import com.github.odaridavid.weatherapp.core.model.Temperature
 import com.github.odaridavid.weatherapp.core.model.Units
 import com.github.odaridavid.weatherapp.core.model.Weather
 import com.github.odaridavid.weatherapp.core.model.WeatherInfo
+import com.github.odaridavid.weatherapp.data.weather.local.entity.DailyWeatherEntity
+import com.github.odaridavid.weatherapp.data.weather.local.entity.HourlyWeatherEntity
+import com.github.odaridavid.weatherapp.data.weather.local.entity.PopulatedWeather
+import com.github.odaridavid.weatherapp.data.weather.local.entity.TemperatureEntity
+import com.github.odaridavid.weatherapp.data.weather.local.entity.WeatherEntity
+import com.github.odaridavid.weatherapp.data.weather.local.entity.WeatherInfoResponseEntity
 import java.text.SimpleDateFormat
 import java.util.Date
 import kotlin.math.roundToInt
 
+
 fun WeatherResponse.toCoreModel(unit: String): Weather = Weather(
     current = current.toCoreModel(unit = unit),
     daily = daily.map { it.toCoreModel(unit = unit) },
@@ -52,6 +59,57 @@ fun TemperatureResponse.toCoreModel(unit: String): Temperature =
         min = formatTemperatureValue(min, unit),
         max = formatTemperatureValue(max, unit)
     )
+fun PopulatedWeather.toCoreEntity(unit: String): Weather =
+    Weather(
+        current = toCurrentWeather(unit = unit),
+        hourly = hourly.map{it.asCoreModel(unit = unit)},
+        daily = daily.map {
+            it.asCoreModel(unit = unit) }
+    )
+
+private fun PopulatedWeather.toCurrentWeather(unit: String): CurrentWeather =
+    CurrentWeather(
+        temperature = formatTemperatureValue(current.temp, unit),
+        feelsLike = formatTemperatureValue(current.feels_like, unit),
+        weather = listOf(
+            WeatherInfo(
+                id = current.id,
+                main = current.main,
+                description = current.description,
+                icon = current.icon
+            )
+        )
+    )
+fun DailyWeatherEntity.asCoreModel(unit: String): DailyWeather =
+    DailyWeather(
+        forecastedTime = getDate(dt,"EEEE dd/M"),
+        temperature = temperature.asCoreModel(unit = unit),
+        weather = weather.map { it.asCoreModel() }
+    )
+
+fun HourlyWeatherEntity.asCoreModel(unit: String): HourlyWeather =
+    HourlyWeather(
+        forecastedTime = getDate(dt,"HH:SS"),
+        temperature = formatTemperatureValue(temperature, unit),
+        weather = weather.map { it.asCoreModel() }
+    )
+
+fun WeatherInfoResponseEntity.asCoreModel(): WeatherInfo =
+    WeatherInfo(
+        id = id,
+        main = main,
+        description = description,
+        icon = "${BuildConfig.OPEN_WEATHER_ICONS_URL}[email protected]"
+    )
+fun TemperatureEntity.asCoreModel(unit: String): Temperature =
+    Temperature(
+        min = formatTemperatureValue(min, unit),
+        max = formatTemperatureValue(max, unit)
+    )
+
+fun WeatherInfoResponseEntity.toWeatherInfo(): WeatherInfo {
+    return WeatherInfo(id, main, description, icon)
+}
 
 private fun formatTemperatureValue(temperature: Float, unit: String): String =
     "${temperature.roundToInt()}${getUnitSymbols(unit = unit)}"
@@ -68,3 +126,59 @@ private fun getDate(utcInMillis: Long, formatPattern: String): String {
     val dateFormat = Date(utcInMillis * 1000)
     return sdf.format(dateFormat)
 }
+
+fun WeatherResponse.toHourlyEntity():List<HourlyWeatherEntity> {
+    val hourlyWeatherEntities = hourly.map { hourlyResponse ->
+        HourlyWeatherEntity(
+            dt = hourlyResponse.forecastedTime,
+            temperature = hourlyResponse.temperature,
+            weather = hourlyResponse.weather.map { it.toWeatherInfoResponse() }
+        )
+    }
+    return hourlyWeatherEntities
+}
+fun WeatherResponse.toDailyEntity():List<DailyWeatherEntity> {
+    val dailyWeatherEntities = daily.map { dailyResponse ->
+        DailyWeatherEntity(
+            dt = dailyResponse.forecastedTime,
+            temperature = dailyResponse.temperature.toTemperatureEntity(),
+            weather = dailyResponse.weather.map { it.toWeatherInfoResponse() }
+        )
+    }
+    return dailyWeatherEntities
+}
+
+fun WeatherResponse.toCurrentWeatherEntity(): WeatherEntity {
+    val currentTime = System.currentTimeMillis()
+    val currentWeatherInfo = current.weather.first()
+
+    return WeatherEntity(
+        dt = currentTime,
+        id = 0,
+        feels_like = current.feelsLike,
+        temp = current.temperature,
+        temp_max = current.temperature,
+        temp_min = current.temperature,
+        description = currentWeatherInfo.description,
+        icon = currentWeatherInfo.icon,
+        main = currentWeatherInfo.main,
+        lastRefreshed = currentTime,
+        isValid = true,
+    )
+}
+
+private fun WeatherInfoResponse.toWeatherInfoResponse(): WeatherInfoResponseEntity {
+    return WeatherInfoResponseEntity(
+        id = id,
+        main = main,
+        description = description,
+        icon = icon
+    )
+}
+
+fun TemperatureResponse.toTemperatureEntity(): TemperatureEntity {
+    return TemperatureEntity(
+        min = min,
+        max = max
+    )
+}

app/src/main/java/com/github/odaridavid/weatherapp/data/weather/RefreshWeatherUseCase.kt

@@ -0,0 +1,45 @@
+package com.github.odaridavid.weatherapp.data.weather
+
+import android.content.Context
+import com.github.odaridavid.weatherapp.R
+import com.github.odaridavid.weatherapp.core.api.WeatherRepository
+import com.github.odaridavid.weatherapp.core.model.DefaultLocation
+import com.github.odaridavid.weatherapp.core.model.Weather
+import com.github.odaridavid.weatherapp.util.NotificationUtil
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import javax.inject.Inject
+
+class RefreshWeatherUseCase @Inject constructor(
+    private val weatherRepository: WeatherRepository,
+    private val notificationUtil: NotificationUtil,
+    private val context: Context
+) {
+    operator fun invoke(
+        defaultLocation: DefaultLocation,
+        language: String,
+        units: String
+    ): Flow<ApiResult<Weather>>  = flow{
+        weatherRepository.fetchWeatherData(
+            defaultLocation = defaultLocation,
+            language = language,
+            units =units
+        ).collect{ result->
+            when (result) {
+                is ApiResult.Success -> {
+                    notificationUtil.makeNotification(context.getString(R.string.weather_updates))
+                }
+                is ApiResult.Error -> {
+                    R.string.error_generic
+                }
+            }
+        }
+
+    }
+}
+
+
+
+
+
+

app/src/main/java/com/github/odaridavid/weatherapp/data/weather/local/WeatherDatabase.kt

@@ -0,0 +1,23 @@
+package com.github.odaridavid.weatherapp.data.weather.local
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import com.github.odaridavid.weatherapp.data.weather.local.converters.Converters
+import com.github.odaridavid.weatherapp.data.weather.local.dao.WeatherDao
+import com.github.odaridavid.weatherapp.data.weather.local.entity.DailyWeatherEntity
+import com.github.odaridavid.weatherapp.data.weather.local.entity.HourlyWeatherEntity
+import com.github.odaridavid.weatherapp.data.weather.local.entity.WeatherEntity
+
+@Database(
+    entities = [
+        WeatherEntity::class,
+        HourlyWeatherEntity::class,
+        DailyWeatherEntity::class],
+    version = 5,
+    exportSchema = false
+)
+@TypeConverters(Converters::class)
+abstract class WeatherDatabase: RoomDatabase(){
+    abstract fun weatherDao():WeatherDao
+}

app/src/main/java/com/github/odaridavid/weatherapp/data/weather/local/converters/Converters.kt

@@ -0,0 +1,19 @@
+package com.github.odaridavid.weatherapp.data.weather.local.converters
+
+import androidx.room.ProvidedTypeConverter
+import androidx.room.TypeConverter
+import com.github.odaridavid.weatherapp.data.weather.local.entity.WeatherInfoResponseEntity
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+@ProvidedTypeConverter
+class Converters {
+
+    @TypeConverter
+    fun fromWeatherInfo(value: List<WeatherInfoResponseEntity>?): String = Json.encodeToString(value)
+
+    @TypeConverter
+    fun toWeatherInfo(value: String?) = value?.let { Json.decodeFromString<List<WeatherInfoResponseEntity>>(it) }
+
+}