UpdateWorker: Try to refresh authdata before checking for updates

Introduce a new standalone worker to refresh authdata and make it open for inheritance
as periodic workers are not allowed to be chained.

Signed-off-by: Aayush Gupta <aayushgupta219@gmail.com>

app/src/main/java/com/aurora/store/data/work/AuthWorker.kt

@@ -0,0 +1,81 @@
+package com.aurora.store.data.work
+
+import android.content.Context
+import android.util.Log
+import androidx.hilt.work.HiltWorker
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import com.aurora.gplayapi.data.models.AuthData
+import com.aurora.gplayapi.helpers.AuthHelper
+import com.aurora.store.data.model.AccountType
+import com.aurora.store.data.providers.AccountProvider
+import com.aurora.store.data.providers.AuthProvider
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+
+/**
+ * Worker to refresh [AuthData] in background
+ * @see UpdateWorker
+ */
+@HiltWorker
+open class AuthWorker @AssistedInject constructor(
+    private val authProvider: AuthProvider,
+    @Assisted private val appContext: Context,
+    @Assisted workerParams: WorkerParameters
+) : CoroutineWorker(appContext, workerParams) {
+
+    private val TAG = AuthWorker::class.java.simpleName
+
+    override suspend fun doWork(): Result {
+        if (!AccountProvider.isLoggedIn(appContext)) {
+            Log.i(TAG, "User has logged out!")
+            return Result.failure()
+        }
+
+        if (authProvider.isSavedAuthDataValid()) {
+            Log.i(TAG, "Saved AuthData is valid")
+            return Result.success()
+        }
+
+        // Generate and validate new auth
+        try {
+            val accountType = AccountProvider.getAccountType(appContext)
+            val authData = when (accountType) {
+                AccountType.GOOGLE -> {
+                    authProvider.buildGoogleAuthData(
+                        AccountProvider.getLoginEmail(appContext)!!,
+                        AccountProvider.getLoginToken(appContext)!!.first,
+                        AccountProvider.getLoginToken(appContext)!!.second
+                    ).getOrThrow()
+                }
+
+                AccountType.ANONYMOUS -> authProvider.buildAnonymousAuthData().getOrThrow()
+            }
+
+            require(verifyAndSaveAuth(authData, accountType) != null)
+            Log.i(TAG, "Refreshed AuthData successfully")
+            return Result.success()
+        } catch (exception: Exception) {
+            Log.e(TAG, "Failed to refresh authData!", exception)
+            return Result.failure()
+        }
+    }
+
+    private fun verifyAndSaveAuth(authData: AuthData, accountType: AccountType): AuthData? {
+        return if (authData.authToken.isNotEmpty() && authData.deviceConfigToken.isNotEmpty()) {
+            authProvider.saveAuthData(authData)
+            AccountProvider.login(
+                appContext,
+                authData.email,
+                authData.aasToken.ifBlank { authData.authToken },
+                if (authData.aasToken.isBlank()) AuthHelper.Token.AUTH else AuthHelper.Token.AAS,
+                accountType
+            )
+            authData
+        } else {
+            authProvider.removeAuthData(appContext)
+            AccountProvider.logout(appContext)
+            null
+        }
+    }
+}

app/src/main/java/com/aurora/store/data/work/UpdateWorker.kt

@@ -6,7 +6,6 @@ import android.util.Log
 import androidx.core.content.getSystemService
 import androidx.core.content.pm.PackageInfoCompat
 import androidx.hilt.work.HiltWorker
-import androidx.work.CoroutineWorker
 import androidx.work.ForegroundInfo
 import androidx.work.WorkerParameters
 import com.aurora.Constants
@@ -38,11 +37,12 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
 /**
- * A worker to check for updates for installed apps based on
+ * A worker to check for updates for installed apps based on saved authentication data,
  * filters and the auto-updates mode selected by the user. The repeat interval
  * is configurable by the user, defaulting to 3 hours with a flex time of 30 minutes.
- * 
+ *
  * Avoid using this worker directly and prefer using [UpdateHelper] instead.
+ * @see AuthWorker
  */
 @HiltWorker
 class UpdateWorker @AssistedInject constructor(
@@ -54,7 +54,7 @@ class UpdateWorker @AssistedInject constructor(
     private val authProvider: AuthProvider,
     @Assisted private val appContext: Context,
     @Assisted workerParams: WorkerParameters
-) : CoroutineWorker(appContext, workerParams) {
+) : AuthWorker(authProvider, appContext, workerParams) {
 
     private val TAG = UpdateWorker::class.java.simpleName
 
@@ -72,6 +72,8 @@ class UpdateWorker @AssistedInject constructor(
             buildType != BuildType.DEBUG
 
     override suspend fun doWork(): Result {
+        super.doWork()
+
         Log.i(TAG, "Checking for app updates")
         val updateMode = UpdateMode.entries[inputData.getInt(
             UpdateHelper.UPDATE_MODE,