CC-628: Refresh Customer Center UI after subscription cancellation (#3061)

facumenzella · claude · web-flow · commit 8defaed04dd3 · 2026-02-06T12:42:35.000Z
## Summary
Fixes issue where Customer Center UI doesn't update after subscription
cancellation.

## Changes
- Add lifecycle-aware refresh when activity resumes after being paused
(when user returns from manage subscriptions screen)
- Add `isRefreshing` state to `CustomerCenterState.Success` to show
loading indicator during refresh
- Add `refreshCustomerCenter()` method that keeps content visible while
refreshing (shows subtle loading indicator instead of full loading
screen)
- Match iOS behavior: refresh when returning from manage subscriptions
screen
- Show subtle loading indicator and dim content during refresh (similar
to iOS)

## Testing
- [ ] Test that Customer Center refreshes when returning from Google
Play Store manage subscriptions screen
- [ ] Verify that cancelled subscriptions are shown correctly after
cancellation
- [ ] Verify that loading indicator appears during refresh
- [ ] Verify that content is dimmed during refresh

Closes CC-628

---------

Co-authored-by: Claude Opus 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/ui/revenuecatui/src/main/kotlin/com/revenuecat/purchases/ui/revenuecatui/customercenter/InternalCustomerCenter.kt b/ui/revenuecatui/src/main/kotlin/com/revenuecat/purchases/ui/revenuecatui/customercenter/InternalCustomerCenter.kt
@@ -5,13 +5,16 @@ package com.revenuecat.purchases.ui.revenuecatui.customercenter
 
 import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.ColorScheme
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
@@ -26,6 +29,7 @@ import androidx.compose.material3.TopAppBar
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.TopAppBarScrollBehavior
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -34,10 +38,14 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.compose.LocalLifecycleOwner
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.lifecycle.viewmodel.compose.viewModel
 import com.revenuecat.purchases.PurchasesError
@@ -105,6 +113,32 @@ internal fun InternalCustomerCenter(
         viewModel.trackImpressionIfNeeded()
     }
 
+    // Refresh Customer Center data when activity resumes after being backgrounded.
+    // This matches iOS behavior where we refresh when the manage subscriptions sheet is dismissed.
+    // When the user opens the manage subscriptions screen (Google Play Store), the activity stops.
+    // When they return, the activity starts again, and we refresh to show updated subscription status.
+    // Using ON_STOP/ON_START with isChangingConfigurations check to properly handle configuration changes
+    // (e.g., rotation) without triggering false refreshes.
+    val lifecycleOwner = LocalLifecycleOwner.current
+    val activity = context.getActivity()
+    DisposableEffect(lifecycleOwner) {
+        val observer = LifecycleEventObserver { _, event ->
+            when (event) {
+                Lifecycle.Event.ON_STOP -> {
+                    viewModel.onActivityStopped(activity?.isChangingConfigurations == true)
+                }
+                Lifecycle.Event.ON_START -> {
+                    viewModel.onActivityStarted()
+                }
+                else -> {}
+            }
+        }
+        lifecycleOwner.lifecycle.addObserver(observer)
+        onDispose {
+            lifecycleOwner.lifecycle.removeObserver(observer)
+        }
+    }
+
     BackHandler {
         viewModel.onNavigationButtonPressed(context, onDismiss)
     }
@@ -388,12 +422,32 @@ private fun CustomerCenterLoaded(
         }
     }
 
+    // Animate opacity when refreshing (similar to iOS)
+    val contentAlpha by animateFloatAsState(
+        targetValue = if (state.isRefreshing) 0.5f else 1f,
+        animationSpec = tween(durationMillis = 300),
+        label = "refreshAlpha",
+    )
+
     Box(modifier = Modifier.fillMaxSize()) {
-        CustomerCenterNavHost(
-            currentDestination = state.currentDestination,
-            customerCenterState = state,
-            onAction = onAction,
-        )
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .graphicsLayer { alpha = contentAlpha },
+        ) {
+            CustomerCenterNavHost(
+                currentDestination = state.currentDestination,
+                customerCenterState = state,
+                onAction = onAction,
+            )
+        }
+
+        // Show loading indicator when refreshing (similar to iOS)
+        if (state.isRefreshing) {
+            CircularProgressIndicator(
+                modifier = Modifier.align(Alignment.Center),
+            )
+        }
 
         SnackbarHost(
             hostState = snackbarHostState,
diff --git a/ui/revenuecatui/src/main/kotlin/com/revenuecat/purchases/ui/revenuecatui/customercenter/data/CustomerCenterState.kt b/ui/revenuecatui/src/main/kotlin/com/revenuecat/purchases/ui/revenuecatui/customercenter/data/CustomerCenterState.kt
@@ -39,6 +39,7 @@ internal sealed class CustomerCenterState(
         @get:JvmSynthetic override val navigationButtonType: NavigationButtonType = NavigationButtonType.CLOSE,
         @get:JvmSynthetic val virtualCurrencies: VirtualCurrencies? = null,
         @get:JvmSynthetic val showSupportTicketSuccessSnackbar: Boolean = false,
+        @get:JvmSynthetic val isRefreshing: Boolean = false,
     ) : CustomerCenterState(navigationButtonType) {
         val currentDestination: CustomerCenterDestination
             get() = navigationState.currentDestination
diff --git a/ui/revenuecatui/src/main/kotlin/com/revenuecat/purchases/ui/revenuecatui/customercenter/viewmodel/CustomerCenterViewModel.kt b/ui/revenuecatui/src/main/kotlin/com/revenuecat/purchases/ui/revenuecatui/customercenter/viewmodel/CustomerCenterViewModel.kt
@@ -104,6 +104,14 @@ internal interface CustomerCenterViewModel {
 
     @InternalRevenueCatAPI
     suspend fun loadCustomerCenter()
+
+    /**
+     * Refreshes the Customer Center data while keeping the current Success state visible.
+     * Shows a subtle loading indicator instead of the full loading screen.
+     * Used when returning from external screens (e.g., manage subscriptions).
+     */
+    suspend fun refreshCustomerCenter()
+
     fun openURL(
         context: Context,
         url: String,
@@ -128,6 +136,17 @@ internal interface CustomerCenterViewModel {
     fun showCreateSupportTicket()
 
     fun dismissSupportTicketSuccessSnackbar()
+
+    /**
+     * Called when the activity is stopped. Used to track if the user backgrounded the app.
+     * @param isChangingConfigurations true if the stop is due to a configuration change (e.g., rotation)
+     */
+    fun onActivityStopped(isChangingConfigurations: Boolean)
+
+    /**
+     * Called when the activity is started. Triggers a refresh if the user is returning from background.
+     */
+    fun onActivityStarted()
 }
 
 @Stable
@@ -175,6 +194,7 @@ internal class CustomerCenterViewModelImpl(
     }
 
     private var impressionCreationData: CustomerCenterImpressionEvent.CreationData? = null
+    private var wasBackgrounded = false
     private val _lastLocaleList = MutableStateFlow(getCurrentLocaleList())
     private val _colorScheme = MutableStateFlow(colorScheme)
     private val _state = MutableStateFlow<CustomerCenterState>(CustomerCenterState.NotLoaded)
@@ -904,8 +924,20 @@ internal class CustomerCenterViewModelImpl(
 
     @InternalRevenueCatAPI
     override suspend fun loadCustomerCenter() {
+        loadCustomerCenter(isRefresh = false)
+    }
+
+    override suspend fun refreshCustomerCenter() {
+        loadCustomerCenter(isRefresh = true)
+    }
+
+    private suspend fun loadCustomerCenter(isRefresh: Boolean) {
         _state.update { state ->
-            if (state !is CustomerCenterState.Loading) {
+            if (isRefresh && state is CustomerCenterState.Success) {
+                // For refresh, keep Success state but set isRefreshing flag
+                state.copy(isRefreshing = true)
+            } else if (state !is CustomerCenterState.Loading) {
+                // For initial load, show full loading screen
                 CustomerCenterState.Loading
             } else {
                 state
@@ -937,15 +969,40 @@ internal class CustomerCenterViewModelImpl(
                 detailScreenPaths = emptyList(), // Will be computed when a purchase is selected
                 noActiveScreenOffering = noActiveScreenOffering,
                 virtualCurrencies = virtualCurrencies,
+                isRefreshing = false,
             )
             val mainScreenPaths = computeMainScreenPaths(successState)
 
             _state.update {
                 successState.copy(mainScreenPaths = mainScreenPaths)
             }
         } catch (e: PurchasesException) {
-            _state.update {
-                CustomerCenterState.Error(e.error)
+            _state.update { currentState ->
+                if (isRefresh && currentState is CustomerCenterState.Success) {
+                    // On error during refresh, keep the existing state but clear isRefreshing
+                    Logger.e("Error refreshing Customer Center data, keeping existing state", e)
+                    currentState.copy(isRefreshing = false)
+                } else {
+                    CustomerCenterState.Error(e.error)
+                }
+            }
+        }
+    }
+
+    override fun onActivityStopped(isChangingConfigurations: Boolean) {
+        if (!isChangingConfigurations) {
+            wasBackgrounded = true
+        }
+    }
+
+    override fun onActivityStarted() {
+        if (wasBackgrounded) {
+            wasBackgrounded = false
+            val currentState = _state.value
+            if (currentState is CustomerCenterState.Success && !currentState.isRefreshing) {
+                viewModelScope.launch {
+                    refreshCustomerCenter()
+                }
             }
         }
     }
