Fixes part of #5345: Implemented Reset functionality of Platform Parameters with new UI.

app/src/main/java/org/oppia/android/app/databinding/DrawableBindingAdapters.java

@@ -36,16 +36,4 @@ public static void setTopBackgroundDrawable(@NonNull View view, @ColorInt int co
     GradientDrawable background = (GradientDrawable) view.getBackground();
     background.setColor(0xff000000 | colorRgb);
   }
-
-  /** Used to set a large rounded-rect background drawable with a data-bound color. */
-  @BindingAdapter("largeRoundedRectDrawableWithColor")
-  public static void setLargeBorderRadiusBackgroundDrawable(
-      @NonNull View view,
-      @ColorInt int colorRgb
-  ) {
-    view.setBackgroundResource(R.drawable.rounded_rect_large_border_radius);
-    // The input color needs to have alpha channel prepended to it.
-    GradientDrawable background = (GradientDrawable) view.getBackground();
-    background.setColor(0xff000000 | colorRgb);
-  }
 }

app/src/main/java/org/oppia/android/app/devoptions/featureflags/FeatureFlagItemViewModel.kt

@@ -1,6 +1,5 @@
 package org.oppia.android.app.devoptions.featureflags
 
-import androidx.annotation.ColorInt
 import androidx.databinding.ObservableField
 import org.oppia.android.app.model.FeatureFlagId
 import org.oppia.android.app.model.SyncStatus
@@ -24,19 +23,38 @@ class FeatureFlagItemViewModel(
   val featureFlagDisplayName: ObservableField<String> =
     ObservableField(getFeatureFlagDisplayName(featureFlagId))
 
-  /** The text representing the sync status of the feature flag. */
-  val syncStatusDisplayText: ObservableField<String> =
-    ObservableField(getSyncStatusText())
-
   /**
    * Callback to be invoked when the feature flag toggle is changed by the user.
    * Passes the [FeatureFlagId] and the new boolean value.
    */
   var onFeatureFlagToggleCallback: ((FeatureFlagId, Boolean) -> Unit)? = null
 
-  /** The background color associated with the current sync status of the feature flag. */
-  @ColorInt
-  val backgroundColor: Int = retrieveBackgroundColor().toInt()
+  /** Indicates whether the flag is overridden. */
+  val isFlagOverridden: ObservableField<Boolean> =
+    ObservableField(syncStatus == SyncStatus.LOCAL_OVERRIDE)
+
+  /** Tracks whether the reset button is currently enabled (clickable). */
+  val isResetButtonActive: ObservableField<Boolean> = ObservableField(true)
+
+  /** Message for displaying the sync details of the platform parameter. */
+  var syncDetails: ObservableField<String> = ObservableField(processSyncDetails())
+
+  private fun processSyncDetails(): String {
+    return when (syncStatus) {
+      SyncStatus.LOCAL_OVERRIDE ->
+        resourceHandler.getStringInLocale(R.string.platform_parameter_currently_overridden_message)
+      SyncStatus.SYNCED_FROM_SERVER -> {
+        // TODO(#5345): Remove this filler message once the server sync logic is implemented.
+        resourceHandler.getStringInLocale(R.string.platform_parameter_synced_from_server_message)
+      }
+      else ->
+        resourceHandler.getStringInLocale(R.string.platform_parameter_never_synced_message)
+    }
+  }
+
+  /** Indicates whether the reset button should be visible for this flag. */
+  val isResetAvailable: ObservableField<Boolean> =
+    ObservableField(syncStatus == SyncStatus.LOCAL_OVERRIDE)
 
   /** Called when the feature flag switch is toggled in the UI. */
   fun onToggleFeatureFlagSwitch() {
@@ -57,30 +75,4 @@ class FeatureFlagItemViewModel(
       }
     }
   }
-
-  private fun getSyncStatusText(): String {
-    return when (syncStatus) {
-      SyncStatus.SYNC_STATUS_UNSPECIFIED ->
-        resourceHandler.getStringInLocale(R.string.feature_flag_unknown_sync_status)
-      SyncStatus.NOT_SYNCED_FROM_SERVER ->
-        resourceHandler.getStringInLocale(R.string.feature_flag_default_sync_status)
-      SyncStatus.SYNCED_FROM_SERVER ->
-        resourceHandler.getStringInLocale(R.string.feature_flag_server_sync_status)
-      SyncStatus.LOCAL_OVERRIDE ->
-        resourceHandler.getStringInLocale(R.string.feature_flag_overridden_sync_status)
-      else ->
-        resourceHandler.getStringInLocale(R.string.feature_flag_unknown_sync_status)
-    }
-  }
-
-  @ColorInt
-  private fun retrieveBackgroundColor(): Long {
-    return when (syncStatus) {
-      SyncStatus.SYNC_STATUS_UNSPECIFIED -> 0xFF4F4F4F
-      SyncStatus.NOT_SYNCED_FROM_SERVER -> 0xFFBE563C
-      SyncStatus.SYNCED_FROM_SERVER -> 0xFF00645C
-      SyncStatus.LOCAL_OVERRIDE -> 0xFFC2B71B
-      else -> 0xFF00645C
-    }
-  }
 }

app/src/main/java/org/oppia/android/app/devoptions/featureflags/FeatureFlagsFragment.kt

@@ -38,6 +38,7 @@ class FeatureFlagsFragment : InjectableFragment() {
     savedInstanceState: Bundle?
   ): View {
     var featureFlagStates: MutableMap<FeatureFlagId, Boolean> = mutableMapOf()
+    var resetFlags: MutableMap<FeatureFlagId, Boolean> = mutableMapOf()
     if (savedInstanceState != null) {
       val args = savedInstanceState.getProto(
         FEATURE_FLAGS_FRAGMENT_SAVED_STATE_KEY,
@@ -46,9 +47,15 @@ class FeatureFlagsFragment : InjectableFragment() {
       featureFlagStates = args?.featureFlagStatesList
         ?.associate { it.id to it.overriddenValue }
         ?.toMutableMap() ?: mutableMapOf()
+      resetFlags = args?.resetFeatureFlagsList
+        ?.associate { it.id to it.overriddenValue }
+        ?.toMutableMap() ?: mutableMapOf()
     }
 
-    return featureFlagsFragmentPresenter.handleCreateView(inflater, container, featureFlagStates)
+    return featureFlagsFragmentPresenter.handleCreateView(
+      inflater, container, featureFlagStates,
+      resetFlags
+    )
   }
 
   override fun onSaveInstanceState(outState: Bundle) {
@@ -61,9 +68,16 @@ class FeatureFlagsFragment : InjectableFragment() {
           .setOverriddenValue(it.value)
           .build()
       }
+    val resetFlags = featureFlagsFragmentPresenter.resetFlags.map {
+      OverriddenFeatureFlag.newBuilder()
+        .setId(it.key)
+        .setOverriddenValue(it.value)
+        .build()
+    }
 
     val proto = FeatureFlagsFragmentStateBundle.newBuilder()
       .addAllFeatureFlagStates(featureFlagStates)
+      .addAllResetFeatureFlags(resetFlags)
       .build()
 
     outState.putProto(FEATURE_FLAGS_FRAGMENT_SAVED_STATE_KEY, proto)

app/src/main/java/org/oppia/android/app/devoptions/featureflags/FeatureFlagsFragmentPresenter.kt

@@ -13,6 +13,8 @@ import org.oppia.android.app.fragment.FragmentScope
 import org.oppia.android.app.model.FeatureFlagId
 import org.oppia.android.app.model.OverriddenFeatureFlag
 import org.oppia.android.app.recyclerview.BindableAdapter
+import org.oppia.android.app.translation.AppLanguageResourceHandler
+import org.oppia.android.app.view.models.R
 import org.oppia.android.domain.oppialogger.OppiaLogger
 import org.oppia.android.domain.platformparameter.PlatformParameterControllerDebugImpl
 import org.oppia.android.util.data.AsyncResult
@@ -24,23 +26,28 @@ import javax.inject.Inject
 class FeatureFlagsFragmentPresenter @Inject constructor(
   private val activity: AppCompatActivity,
   private val fragment: Fragment,
-  private val featureFlagsViewModel: FeatureFlagsViewModel,
+  private val featureFlagsViewModelFactory: FeatureFlagsViewModel.Factory,
   private val oppiaLogger: OppiaLogger,
+  private val resourceHandler: AppLanguageResourceHandler,
   private val platformParameterControllerDebugImpl: PlatformParameterControllerDebugImpl,
   private val singleTypeBuilderFactory: BindableAdapter.SingleTypeBuilder.Factory
 ) {
   private lateinit var binding: FeatureFlagsFragmentBinding
   private lateinit var linearLayoutManager: LinearLayoutManager
   private lateinit var bindingAdapter: BindableAdapter<FeatureFlagItemViewModel>
 
+  /** List of feature flags that have been reset.. */
+  var resetFlags: MutableMap<FeatureFlagId, Boolean> = mutableMapOf()
+
   /** List of feature flag switch states to be used in the fragment. */
   var featureFlagStates: MutableMap<FeatureFlagId, Boolean> = mutableMapOf()
 
   /** Called when [FeatureFlagsFragment] is created. Handles UI for the fragment. */
   fun handleCreateView(
     inflater: LayoutInflater,
     container: ViewGroup?,
-    featureFlagStates: Map<FeatureFlagId, Boolean>
+    featureFlagStates: Map<FeatureFlagId, Boolean>,
+    resetFlags: Map<FeatureFlagId, Boolean>
   ): View {
     binding = FeatureFlagsFragmentBinding.inflate(
       inflater,
@@ -56,19 +63,19 @@ class FeatureFlagsFragmentPresenter @Inject constructor(
       object : OnBackPressedCallback(true) {
         override fun handleOnBackPressed() {
           onBackNavigation()
-          // The dispatcher can hold a reference to the host
-          // so we need to null it out to prevent memory leaks.
-          this.remove()
         }
       }
     )
 
     if (featureFlagStates.isNotEmpty()) {
       this.featureFlagStates = featureFlagStates.toMutableMap()
     }
+    if (resetFlags.isNotEmpty()) {
+      this.resetFlags = resetFlags.toMutableMap()
+    }
     binding.apply {
       this.lifecycleOwner = fragment
-      this.viewModel = featureFlagsViewModel
+      this.viewModel = featureFlagsViewModelFactory.create(resetFlags.keys.toList())
     }
     linearLayoutManager = LinearLayoutManager(activity.applicationContext)
 
@@ -91,11 +98,17 @@ class FeatureFlagsFragmentPresenter @Inject constructor(
   }
 
   private fun onBackNavigation() {
-    val overriddenFeatureFlags = featureFlagStates.map { (id, value) ->
-      OverriddenFeatureFlag.newBuilder()
-        .setId(id)
-        .setOverriddenValue(value)
-        .build()
+    val overriddenFeatureFlags: MutableList<OverriddenFeatureFlag> = mutableListOf()
+
+    featureFlagStates.map { (id, value) ->
+      if (resetFlags[id] != value) {
+        overriddenFeatureFlags.add(
+          OverriddenFeatureFlag.newBuilder()
+            .setId(id)
+            .setOverriddenValue(value)
+            .build()
+        )
+      }
     }
 
     platformParameterControllerDebugImpl
@@ -104,15 +117,15 @@ class FeatureFlagsFragmentPresenter @Inject constructor(
           is AsyncResult.Success -> (activity as FeatureFlagsActivity).finish()
           is AsyncResult.Failure -> {
             oppiaLogger.e(
-              "PlatformParametersFragmentPresenter",
+              "FeatureFlagsFragmentPresenter",
               "Failed to override feature flags: ",
               it.error
             )
           }
+
           is AsyncResult.Pending -> {} // Wait for a result.
         }
       }
-    (activity as FeatureFlagsActivity).finish()
   }
 
   private fun bindFeatureFlagItem(
@@ -121,15 +134,52 @@ class FeatureFlagsFragmentPresenter @Inject constructor(
   ) {
     binding.viewModel = model
 
+    binding.resetButton.setOnClickListener {
+      handleResetFeatureFlag(model)
+    }
+    if (resetFlags.containsKey(model.featureFlagId)) {
+      model.isFlagOverridden.set(true)
+      model.isResetButtonActive.set(false)
+    }
+
     if (featureFlagStates.containsKey(model.featureFlagId)) {
       model.isChecked.set(featureFlagStates[model.featureFlagId])
     }
     model.onFeatureFlagToggleCallback = { id, value ->
-      if (model.currentValue == value) {
+      if (model.currentValue == value && !resetFlags.containsKey(id)) {
         featureFlagStates.remove(id)
       } else {
         featureFlagStates[id] = value
       }
     }
   }
+
+  private fun handleResetFeatureFlag(
+    model: FeatureFlagItemViewModel
+  ) {
+    platformParameterControllerDebugImpl
+      .resetFeatureFlag(model.featureFlagId)
+      .toLiveData()
+      .observe(fragment) { restoredFlagValue ->
+        when (restoredFlagValue) {
+          is AsyncResult.Success -> {
+            resetFlags[model.featureFlagId] = restoredFlagValue.value
+            featureFlagStates[model.featureFlagId] = restoredFlagValue.value
+            model.isChecked.set(restoredFlagValue.value)
+            model.isResetButtonActive.set(false)
+            // TODO(#5345): Remove this filler message once the server sync logic is implemented.
+            model.syncDetails.set(
+              resourceHandler.getStringInLocale(R.string.platform_parameter_never_synced_message)
+            )
+          }
+          is AsyncResult.Failure -> {
+            oppiaLogger.e(
+              "FeatureFlagsFragmentPresenter",
+              "Failed to reset feature flag: ${model.featureFlagId}", restoredFlagValue.error
+            )
+          }
+          is AsyncResult.Pending -> {} // No action required
+        }
+      }
+  }
 }

app/src/main/java/org/oppia/android/app/devoptions/featureflags/FeatureFlagsViewModel.kt

@@ -2,8 +2,11 @@ package org.oppia.android.app.devoptions.featureflags
 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.Transformations
+import org.oppia.android.app.devoptions.platformparameters.PlatformParametersViewModel
 import org.oppia.android.app.fragment.FragmentScope
 import org.oppia.android.app.model.EphemeralFeatureFlag
+import org.oppia.android.app.model.FeatureFlagId
+import org.oppia.android.app.model.SyncStatus
 import org.oppia.android.app.translation.AppLanguageResourceHandler
 import org.oppia.android.app.viewmodel.ObservableViewModel
 import org.oppia.android.domain.platformparameter.PlatformParameterControllerDebugImpl
@@ -17,10 +20,11 @@ import javax.inject.Inject
  * [FeatureFlagItemViewModel] which in turn display the available feature flags.
  */
 @FragmentScope
-class FeatureFlagsViewModel @Inject constructor(
+class FeatureFlagsViewModel private constructor(
   private val platformParameterControllerDebugImpl: PlatformParameterControllerDebugImpl,
   private val machineLocale: OppiaLocale.MachineLocale,
-  private val resourceHandler: AppLanguageResourceHandler
+  private val resourceHandler: AppLanguageResourceHandler,
+  private val resetFlagsList: List<FeatureFlagId>
 ) : ObservableViewModel() {
   private val ephemeralFlagsLiveData: LiveData<List<EphemeralFeatureFlag>> by lazy {
     Transformations.map(
@@ -41,7 +45,13 @@ class FeatureFlagsViewModel @Inject constructor(
     result: AsyncResult<List<EphemeralFeatureFlag>>
   ): List<EphemeralFeatureFlag> {
     return when (result) {
-      is AsyncResult.Success -> result.value
+      is AsyncResult.Success -> {
+        result.value.sortedWith(
+          compareByDescending<EphemeralFeatureFlag> {
+            it.syncStatus == SyncStatus.LOCAL_OVERRIDE || resetFlagsList.contains(it.id)
+          }.thenBy { it.id.name }
+        )
+      }
       else -> emptyList()
     }
   }
@@ -58,4 +68,21 @@ class FeatureFlagsViewModel @Inject constructor(
         )
       }
     }
+
+  /** Factory for creating instances of [FeatureFlagsViewModel]. */
+  class Factory @Inject constructor(
+    private val platformParameterControllerDebugImpl: PlatformParameterControllerDebugImpl,
+    private val machineLocale: OppiaLocale.MachineLocale,
+    private val resourceHandler: AppLanguageResourceHandler
+  ) {
+    /** Creates a new [PlatformParametersViewModel]. */
+    fun create(resetFlagsList: List<FeatureFlagId>): FeatureFlagsViewModel {
+      return FeatureFlagsViewModel(
+        platformParameterControllerDebugImpl,
+        machineLocale,
+        resourceHandler,
+        resetFlagsList
+      )
+    }
+  }
 }