Backend Migration

app/build.gradle

@@ -31,9 +31,8 @@ android {
             useSupportLibrary true
         }
 
-        buildConfigField("String", "GET_BACKEND_URL", secretsProperties['GET_BACKEND_URL'])
         buildConfigField("String", "SESSIONID_WEBVIEW_URL", secretsProperties['SESSIONID_WEBVIEW_URL'])
-        buildConfigField("String", "CORNELL_INSTITUTION_ID", secretsProperties['CORNELL_INSTITUTION_ID'])
+        buildConfigField("boolean", "USE_LOCAL_FAVORITES", "true")
     }
 
     buildTypes {
@@ -105,6 +104,7 @@ dependencies {
     // Networking
     implementation("com.squareup.moshi:moshi:1.14.0")
     implementation("com.squareup.moshi:moshi-kotlin:1.14.0")
+    implementation 'com.squareup.moshi:moshi-adapters:1.14.0'
     implementation 'com.squareup.okhttp3:okhttp'
     implementation 'com.squareup.okhttp3:logging-interceptor:5.0.0-alpha.10'
     implementation 'com.squareup.retrofit2:retrofit:2.9.0'
@@ -144,6 +144,10 @@ dependencies {
     implementation 'com.valentinilk.shimmer:compose-shimmer:1.0.3'
 
     implementation "io.coil-kt:coil-compose:2.2.2"
+
+    // In-app Updates
+    implementation("com.google.android.play:app-update:2.1.0")
+    implementation("com.google.android.play:app-update-ktx:2.1.0")
 }
 
 protobuf {

app/src/main/java/com/cornellappdev/android/eatery/MainActivity.kt

@@ -3,31 +3,52 @@ package com.cornellappdev.android.eatery
 import android.os.Bundle
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
+import androidx.activity.result.ActivityResultLauncher
+import androidx.activity.result.IntentSenderRequest
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.core.view.WindowCompat
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import com.cornellappdev.android.eatery.data.repositories.AuthTokenRepository
 import com.cornellappdev.android.eatery.data.repositories.EateryRepository
-import com.cornellappdev.android.eatery.data.repositories.UserPreferencesRepository
+import com.cornellappdev.android.eatery.data.repositories.UserRepository
 import com.cornellappdev.android.eatery.ui.navigation.NavigationSetup
 import com.cornellappdev.android.eatery.util.LockScreenOrientation
+import com.google.android.play.core.appupdate.AppUpdateManagerFactory
+import com.google.android.play.core.appupdate.AppUpdateOptions
+import com.google.android.play.core.install.InstallStateUpdatedListener
+import com.google.android.play.core.install.model.AppUpdateType
+import com.google.android.play.core.install.model.InstallStatus
+import com.google.android.play.core.install.model.UpdateAvailability
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import javax.inject.Inject
 
 @AndroidEntryPoint
 class MainActivity : ComponentActivity() {
     @Inject
-    lateinit var userPreferences: UserPreferencesRepository
+    lateinit var eateryRepository: EateryRepository
 
     @Inject
-    lateinit var eateryRepository: EateryRepository
+    lateinit var userRepository: UserRepository
+
+    @Inject
+    lateinit var authTokenRepository: AuthTokenRepository
+
+    private lateinit var activityResultLauncher: ActivityResultLauncher<IntentSenderRequest>
+    private val appUpdateManager by lazy { AppUpdateManagerFactory.create(applicationContext) }
+    private var flexibleUpdateListener: InstallStateUpdatedListener? = null
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
-        val hasOnboarded = runBlocking {
-            return@runBlocking userPreferences.getHasOnboarded()
-        }
+        activityResultLauncher = registerForActivityResult(
+            ActivityResultContracts.StartIntentSenderForResult()
+        ) {}
+
+        val hasOnboarded = runBlocking { userRepository.hasOnboarded() }
 
         WindowCompat.setDecorFitsSystemWindows(window, false)
 
@@ -46,5 +67,91 @@ class MainActivity : ComponentActivity() {
             }
         }
         lifecycle.addObserver(dataRefresher)
+        checkForUpdateAvailability()
+        lifecycleScope.launch {
+            configureTokens()
+            userRepository.updateFavorites()
+            authTokenRepository.markTokensAsConfigured()
+        }
+    }
+
+    override fun onStop() {
+        super.onStop()
+        unregisterFlexibleUpdateListener()
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        // in case onStop cleanup did not run
+        unregisterFlexibleUpdateListener()
+    }
+
+    override fun onResume() {
+        super.onResume()
+
+        // Check if there's an update that's already downloaded and waiting to be installed
+        appUpdateManager
+            .appUpdateInfo
+            .addOnSuccessListener { appUpdateInfo ->
+                if (appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) {
+                    // If an in-app update is already running, resume the update.
+                    appUpdateManager.startUpdateFlowForResult(
+                        appUpdateInfo,
+                        activityResultLauncher,
+                        AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build()
+                    )
+                }
+
+                if (appUpdateInfo.installStatus() == InstallStatus.DOWNLOADED) {
+                    // If the update is downloaded but not installed, notify the user to complete the update.
+                    appUpdateManager.completeUpdate()
+                }
+            }
+    }
+
+    private fun checkForUpdateAvailability() {
+        appUpdateManager.appUpdateInfo.addOnSuccessListener { appUpdateInfo ->
+            if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE) {
+                val isImmediateUpdateAllowed =
+                    appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.IMMEDIATE)
+                val isFlexibleUpdateAllowed =
+                    appUpdateInfo.isUpdateTypeAllowed(AppUpdateType.FLEXIBLE)
+
+                // For high priority updates, use immediate update
+                if (appUpdateInfo.updatePriority() >= 4 && isImmediateUpdateAllowed) {
+                    appUpdateManager.startUpdateFlowForResult(
+                        appUpdateInfo,
+                        activityResultLauncher,
+                        AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build()
+                    )
+                }
+                // For normal priority updates, use flexible update
+                else if (isFlexibleUpdateAllowed) {
+                    // Create a listener to track flexible update progress
+                    flexibleUpdateListener = InstallStateUpdatedListener { state ->
+                        if (state.installStatus() == InstallStatus.DOWNLOADED) {
+                            unregisterFlexibleUpdateListener()
+                            appUpdateManager.completeUpdate()
+                        }
+                    }
+                    flexibleUpdateListener?.let { appUpdateManager.registerListener(it) }
+
+                    appUpdateManager.startUpdateFlowForResult(
+                        appUpdateInfo,
+                        activityResultLauncher,
+                        AppUpdateOptions.newBuilder(AppUpdateType.FLEXIBLE).build()
+                    )
+                }
+            }
+        }
+    }
+
+    private fun unregisterFlexibleUpdateListener() {
+        flexibleUpdateListener?.let(appUpdateManager::unregisterListener)
+        flexibleUpdateListener = null
+    }
+
+    private suspend fun configureTokens() {
+        authTokenRepository.getTokens()
     }
 }

app/src/main/java/com/cornellappdev/android/eatery/data/AuthInterceptor.kt

@@ -0,0 +1,73 @@
+package com.cornellappdev.android.eatery.data
+
+import com.cornellappdev.android.eatery.data.repositories.AuthTokenRepository
+import kotlinx.coroutines.runBlocking
+import okhttp3.Interceptor
+import okhttp3.Request
+import okhttp3.Response
+import javax.inject.Inject
+import javax.inject.Provider
+
+/**
+ * OkHttp interceptor that automatically adds Bearer token to authenticated requests.
+ * Also handles token refresh on 401 responses.
+ *
+ * Uses Provider<AuthTokenRepository> to avoid circular dependency
+ */
+class AuthInterceptor @Inject constructor(
+    private val authTokenRepositoryProvider: Provider<AuthTokenRepository>
+) : Interceptor {
+
+    companion object {
+        private val PUBLIC_ENDPOINTS = setOf(
+            "/eateries/",
+            "/auth/verify-token",
+            "/auth/refresh-token"
+        )
+    }
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val request = chain.request()
+
+        if (!isPublicEndpoint(request)) {
+            val requestWithToken = addTokenToRequest(request)
+            var response = chain.proceed(requestWithToken)
+
+            if (response.code == 401) {
+                response.close()
+                try {
+                    runBlocking {
+                        authTokenRepositoryProvider.get().refreshTokens()
+                    }
+                    val retryRequest = addTokenToRequest(request)
+                    response = chain.proceed(retryRequest)
+                } catch (_: Exception) {
+                    return chain.proceed(request)
+                }
+            }
+
+            return response
+        }
+
+        return chain.proceed(request)
+    }
+
+    private fun addTokenToRequest(request: Request): Request {
+        return try {
+            val token = runBlocking {
+                authTokenRepositoryProvider.get().getAccessToken()
+            }
+            request.newBuilder()
+                .header("Authorization", token)
+                .build()
+        } catch (_: Exception) {
+            request
+        }
+    }
+
+    private fun isPublicEndpoint(request: Request): Boolean {
+        val path = request.url.encodedPath
+        return PUBLIC_ENDPOINTS.any { path.startsWith(it) }
+    }
+}
+

app/src/main/java/com/cornellappdev/android/eatery/data/MoshiAdapters.kt

@@ -1,3 +1,5 @@
+@file:Suppress("unused")
+
 package com.cornellappdev.android.eatery.data
 
 import com.cornellappdev.android.eatery.data.models.AccountType
@@ -62,37 +64,15 @@ class ReportAdapter {
     }
 }
 
-class TransactionDateAdapter {
-    @FromJson
-    fun fromJson(date: String): Date {
-        try {
-            val simpleDate =
-                SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZZZZ", Locale.US).parse(date)
-            if (simpleDate != null) {
-                return simpleDate
-            }
-        } catch (e: ParseException) {
-            e.printStackTrace()
-        }
-        return Date(0)
-    }
-}
-
 class DateTimeAdapter {
     @ToJson
     fun toJson(dateTime: LocalDateTime): String {
         return dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss'Z'"))
     }
 
     @FromJson
-    fun fromJson(dateTime: Long): LocalDateTime {
-        try {
-            val instant = Instant.ofEpochSecond(dateTime)
-            return LocalDateTime.ofInstant(instant, ZoneId.systemDefault())
-        } catch (e: ParseException) {
-            e.printStackTrace()
-        }
-        return LocalDateTime.MIN
+    fun fromJson(dateTime: String): LocalDateTime {
+        return LocalDateTime.ofInstant(Instant.parse(dateTime), ZoneId.systemDefault())
     }
 }
 
@@ -116,18 +96,14 @@ class AccountTypeAdapter {
                 "brb"
             }
 
-            AccountType.CITYBUCKS -> {
+            AccountType.CITY_BUCKS -> {
                 "city bucks"
             }
 
             AccountType.LAUNDRY -> {
                 "laundry"
             }
 
-            AccountType.MEALSWIPES -> {
-                "meal plan"
-            }
-
             else -> {
                 "other"
             }
@@ -155,7 +131,7 @@ class AccountTypeAdapter {
         return if (accountName.contains("brb", ignoreCase = true)) {
             AccountType.BRBS
         } else if (accountName.contains("city bucks", ignoreCase = true)) {
-            AccountType.CITYBUCKS
+            AccountType.CITY_BUCKS
         } else if (accountName.contains("laundry", ignoreCase = true)) {
             AccountType.LAUNDRY
         } else {