started changes

oppia · Akshatkamboj14 · Mar 2, 2023 · Mar 2, 2023 · Mar 2, 2023 · Mar 10, 2023
commit 8252511e8b965cc024cca8b2db0e1a3582998cbc
diff --git a/.bashrc b/.bashrc
@@ -7,6 +7,8 @@ import android.view.ViewGroup
 import androidx.appcompat.app.AppCompatActivity
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.Observer
+import com.google.common.util.concurrent.FutureCallback
+import com.google.common.util.concurrent.Futures
 import org.oppia.android.R
 import org.oppia.android.app.administratorcontrols.AdministratorControlsActivity
 import org.oppia.android.app.administratorcontrols.ProfileEditDeletionDialogListener
@@ -153,10 +155,10 @@ class ProfileEditFragmentPresenter @Inject constructor(
         fragment,
         Observer {
           if (it is AsyncResult.Success) {
-            snackbarManager.showSnackbar(
-              R.string.profile_edit_delete_success,
-              SnackbarController.SnackbarDuration.LONG
-            )
+//            snackbarManager.showSnackbar(
+//              R.string.profile_edit_delete_success,
+//              SnackbarController.SnackbarDuration.LONG
+//            )
             if (fragment.requireContext().resources.getBoolean(R.bool.isTablet)) {
               val intent =
                 Intent(fragment.requireContext(), AdministratorControlsActivity::class.java)

@@ -4,83 +4,93 @@ import android.view.View
 import androidx.annotation.StringRes
 import androidx.appcompat.app.AppCompatActivity
 import com.google.android.material.snackbar.Snackbar
+import com.google.common.util.concurrent.FutureCallback
+import com.google.common.util.concurrent.Futures
+import com.google.common.util.concurrent.Futures.immediateFuture
+import com.google.common.util.concurrent.ListenableFuture
+import com.google.common.util.concurrent.SettableFuture
+import java.util.concurrent.Executor
+import java.util.concurrent.Future
 import org.oppia.android.domain.oppialogger.OppiaLogger
 import org.oppia.android.domain.snackbar.SnackbarController
 import org.oppia.android.util.data.AsyncResult
 import org.oppia.android.util.data.DataProviders.Companion.toLiveData
 import javax.inject.Inject
+import kotlinx.coroutines.Deferred
+import org.oppia.android.util.data.DataProvider
+import org.oppia.android.util.data.DataProviders
 
 private const val TAG = "SnackbarManager"
 private const val ERROR_MESSAGE = "can't be shown--no activity UI"
+private const val GET_CURRENT_SNACKBAR_STATUS_PROVIDER_ID =
+  "get_current_snackbar_status_provider_id"
+
+class SnackbarManager @Inject constructor(private val activity: AppCompatActivity, private val snackbarController: SnackbarController) {
+  private var currentShowingSnackbarId: Int? = null
+
+  // Must be called by activities wishing to show snackbars.
+  fun enableShowingSnackbars(contentView: View) {
+    snackbarController.getCurrentSnackbarState().toLiveData().observe(activity) { result ->
+
+      when(result){
+        is AsyncResult.Success -> when(val request = result.value) {
+
+          is SnackbarController.CurrentSnackbarState.Showing -> {
+//            if (request.snackbarId != currentShowingSnackbarId){
+//              snackbarController.snackbarRequestQueue.peek()?.let { showSnackbar(contentView, it) }
+//            }
+
+            snackbarController.notifySnackbarShowing(request.snackbarId, )
+
+          }
+
+          is SnackbarController.CurrentSnackbarState.NotShowing -> {
+
+          }
+
+          is SnackbarController.CurrentSnackbarState.WaitingToShow -> {
 
-/** Manager for showing snackbars. */
-class SnackbarManager @Inject constructor(private val snackbarController: SnackbarController) {
-
-  @Inject
-  lateinit var oppiaLogger: OppiaLogger
-
-  /**
-   *  Enqueues the snackbar that is be to shown in the FIFO buffer.
-   *
-   *  @param messageStringId The message string of string resource that is to be displayed
-   *  @param duration The duration for which snackbar is to be shown
-   */
-  fun showSnackbar(@StringRes messageStringId: Int, duration: SnackbarController.SnackbarDuration) {
-    snackbarController.enqueueSnackbar(
-      SnackbarController.SnackbarRequest.ShowSnackbar(
-        messageStringId,
-        duration
-      )
-    )
-  }
 
-  /**
-   * Enables the activity to show the snackbar.
-   *
-   * @param activity An activity that will observe for snackbars and display them
-   */
-  fun enableShowingSnackbars(activity: AppCompatActivity) {
-    snackbarController.getCurrentSnackbar().toLiveData().observe(activity) { result ->
-      when (result) {
-        is AsyncResult.Success -> when (val request = result.value) {
-          is SnackbarController.SnackbarRequest.ShowSnackbar -> showSnackbar(
-            activity.findViewById(
-              android.R.id.content
-            ),
-            request
-          )
-          SnackbarController.SnackbarRequest.ShowNothing -> {
-            if (snackbarController.snackbarRequestQueue.isNotEmpty()) {
-              snackbarController.dismissCurrentSnackbar()
-            }
           }
+
+        }
+        else -> {
+
         }
-        else -> {}
       }
+
+      // Show a new snackbar if the current state is "showing snackbar" with an ID different than currentShowingSnackbarId.
+      // Note that this should automatically handle the case of a new activity being opened before a previous snackbar finished (it should be reshown).
+      // Need to call back into SnackbarController via notifySnackbarShowing() to indicate that it's now showing.
     }
   }
 
   private fun showSnackbar(
-    activityView: View?,
-    showRequest: SnackbarController.SnackbarRequest.ShowSnackbar
-  ) {
-
+    activityView: View,
+    showRequest: SnackbarController.ShowSnackbarRequest
+  ): Pair<Deferred<Unit>, Deferred<Unit>> {
     val duration = when (showRequest.duration) {
       SnackbarController.SnackbarDuration.SHORT -> Snackbar.LENGTH_SHORT
       SnackbarController.SnackbarDuration.LONG -> Snackbar.LENGTH_LONG
     }
 
-    if (activityView == null) {
-      oppiaLogger.e(TAG, ERROR_MESSAGE)
-    } else {
-      Snackbar.make(activityView, showRequest.messageStringId, duration)
-        .addCallback(object : Snackbar.Callback() {
-          override fun onDismissed(transientBottomBar: Snackbar?, event: Int) {
-            super.onDismissed(transientBottomBar, event)
-            snackbarController.dismissCurrentSnackbar()
-          }
-        })
-        .show()
-    }
+    val showFuture = SettableFuture.create<Unit>()
+    val dismissFuture = SettableFuture.create<Unit>()
+    Snackbar.make(activityView, showRequest.messageStringId, duration)
+      .addCallback(object : Snackbar.Callback() {
+        override fun onShown(snackbar: Snackbar) {
+
+//          snackbarController.notifySnackbarShowing()
+          showFuture.set(Unit)
+        }
+
+        override fun onDismissed(transientBottomBar: Snackbar?, event: Int) {
+          dismissFuture.set(Unit)
+
+        }
+      })
+      .show()
+    // See: https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-guava/kotlinx.coroutines.guava/as-deferred.html.
+    return showFuture as Deferred<Unit> to dismissFuture as Deferred<Unit>
   }
-}
+}
@@ -1,13 +1,16 @@
 package org.oppia.android.domain.snackbar
 
 import androidx.annotation.StringRes
+import com.google.common.util.concurrent.SettableFuture
 import org.oppia.android.util.data.AsyncDataSubscriptionManager
 import org.oppia.android.util.data.DataProvider
 import org.oppia.android.util.data.DataProviders
 import java.util.LinkedList
 import java.util.Queue
 import javax.inject.Inject
 import javax.inject.Singleton
+import kotlinx.coroutines.Deferred
+import org.oppia.android.util.data.AsyncResult
 
 private const val GET_CURRENT_SNACKBAR_REQUEST_PROVIDER_ID =
   "get_current_snackbar_request_provider_id"
@@ -19,61 +22,64 @@ class SnackbarController @Inject constructor(
   private val asyncDataSubscriptionManager: AsyncDataSubscriptionManager,
 ) {
 
-  private val _snackbarRequestQueue: Queue<SnackbarRequest.ShowSnackbar> = LinkedList()
+  private var showFuture: Deferred<Unit>? = null
+  val dismissFuture = SettableFuture.create<Unit>()
+  private val _snackbarRequestQueue: Queue<ShowSnackbarRequest> = LinkedList()
 
   /** Queue of the snackbar requests that are to be shown based on FIFO. */
-  val snackbarRequestQueue: Queue<SnackbarRequest.ShowSnackbar>
+  val snackbarRequestQueue: Queue<ShowSnackbarRequest>
     get() = _snackbarRequestQueue
 
-  /**
-   * Gets the snackbar that is enqueued first.
-   *
-   * @return a [DataProvider] of the current request
-   */
-  fun getCurrentSnackbar(): DataProvider<SnackbarRequest> {
+  val currentState = CurrentSnackbarState.NotShowing
+
+
+  fun getCurrentSnackbarState(): DataProvider<CurrentSnackbarState> {
+
     val currentRequest = _snackbarRequestQueue.peek()
-    return dataProviders.createInMemoryDataProvider(GET_CURRENT_SNACKBAR_REQUEST_PROVIDER_ID) {
-      return@createInMemoryDataProvider currentRequest
-        ?: SnackbarRequest.ShowNothing
+
+    if (_snackbarRequestQueue.isEmpty()){
+      return dataProviders.createInMemoryDataProvider(CurrentSnackbarState.NotShowing){
+        return@createInMemoryDataProvider CurrentSnackbarState.NotShowing
+      }
     }
+
+//    if ()
+
   }
 
-  /**
-   * Enqueue the snackbar request that is to be shown and notify subscribers that it has changed.
-   *
-   * @param request that is to be added in the queue
-   */
-  fun enqueueSnackbar(request: SnackbarRequest.ShowSnackbar) {
+  fun enqueueSnackbar(request: ShowSnackbarRequest) {
     _snackbarRequestQueue.add(request)
     notifyPotentialSnackbarChange()
   }
 
-  /** Dismiss the current snackbar and notify subscribers that the [DataProvider] has changed. */
-  fun dismissCurrentSnackbar() {
-    _snackbarRequestQueue.remove()
-    notifyPotentialSnackbarChange()
+  fun notifySnackbarShowing(snackbarId: Int, onShow: Deferred<Unit>, onDismiss: Deferred<Unit>) {
+    // onDismiss is resolved when the snackbar by unique ID snackbarId is no longer showing.
+
+    showFuture = onShow
+
   }
 
   private fun notifyPotentialSnackbarChange() {
     asyncDataSubscriptionManager.notifyChangeAsync(GET_CURRENT_SNACKBAR_REQUEST_PROVIDER_ID)
   }
 
-  /** Sealed class that encapsulates the SnackbarRequest behaviour. */
-  sealed class SnackbarRequest {
+  sealed class CurrentSnackbarState {
+    object NotShowing : CurrentSnackbarState()
 
-    /**
-     * For showing the snackbar.
-     *
-     * @param messageStringId The message string of string resource that is to be displayed
-     * @param duration The duration for which snackbar is to be shown
-     */
-    data class ShowSnackbar(@StringRes val messageStringId: Int, val duration: SnackbarDuration) :
-      SnackbarRequest()
+    data class Showing(val request: ShowSnackbarRequest, val snackbarId: Int) :
+      CurrentSnackbarState()
 
-    /** For not showing snackbar and dismissing the snackbar if present in the queue. */
-    object ShowNothing : SnackbarRequest()
+    data class WaitingToShow(val nextRequest: ShowSnackbarRequest, val snackbarId: Int) :
+      CurrentSnackbarState()
   }
 
+  data class ShowSnackbarRequest(
+    @StringRes val messageStringId: Int,
+    val duration: SnackbarDuration
+  )
+
+  private data class Snackbar(val request: ShowSnackbarRequest, val snackbarId: Int)
+
   /** These are for the length of the snackbar that is to be shown. */
   enum class SnackbarDuration {