Release backend migration

README.md

@@ -1,6 +1,6 @@
 # Eatery Blue - Browse. Search. Eat.
 
-<p align="center"><img src=https://raw.githubusercontent.com/cuappdev/eatery-blue-android/main/eatery-blue-banner.png width=500 /></p>
+<p align="center"><img src="https://github.com/cuappdev/assets/blob/master/app-icons/Eatery-83.5x83.5%402x.png" width=210 /></p>
 
 Eatery was the first app released by AppDev.  With over 6,000 students using it every month, it enables students to browse menus and discover places to eat on Cornell’s campus. It enhances the dining experience at Cornell with features such as providing the crowdedness of eateries, checking meal swipes and dining money balances, and favoriting dishes. Eatery is available on both [iOS](https://github.com/cuappdev/eatery-blue-ios) and Android platforms.
 

app/build.gradle

@@ -23,28 +23,29 @@ android {
         applicationId "com.cornellappdev.android.eatery"
         minSdk 28
         targetSdk 34
-        versionCode 75
-        versionName "1.2.1-cmpmenus-url"
+        versionCode 76
+        versionName "1.3.0"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
             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 {
         debug {
             resValue("bool", "FIREBASE_ANALYTICS_DEACTIVATED", "true")
             buildConfigField("String", "BACKEND_URL", secretsProperties['BACKEND_URL'])
+            buildConfigField("boolean", "ENABLE_NOTIFICATIONS", "true")
         }
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
             buildConfigField("String", "BACKEND_URL", secretsProperties['PROD_ENDPOINT'])
+            buildConfigField("boolean", "ENABLE_NOTIFICATIONS", "false")
         }
     }
 
@@ -103,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'
@@ -142,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,36 +3,155 @@ 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 com.cornellappdev.android.eatery.data.repositories.UserPreferencesRepository
+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.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 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)
 
-        // Want to eventually switch over to this typography
         val typography = androidx.compose.material3.Typography()
         setContent {
             LockScreenOrientation()
 
-            androidx.compose.material3.MaterialTheme {
+            androidx.compose.material3.MaterialTheme(typography = typography) {
                 NavigationSetup(hasOnboarded)
             }
         }
+        val dataRefresher = object : DefaultLifecycleObserver {
+            override fun onResume(owner: LifecycleOwner) {
+                super.onResume(owner)
+                eateryRepository.pingEateries()
+            }
+        }
+        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 {