MergeOptions, buttons got cleared when animation enabled [Android]

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/StackController.java

@@ -68,7 +68,7 @@ public StackController(Activity activity, List<ViewController<?>> children, Chil
     @Override
     public void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);
-        presenter.onConfigurationChanged(resolveCurrentOptions());
+        presenter.onConfigurationChanged(resolveCurrentOptions(), getCurrentChild());
         fabPresenter.onConfigurationChanged(resolveCurrentOptions());
     }
 

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/topbar/TopBarController.kt

@@ -2,13 +2,16 @@ package com.reactnativenavigation.viewcontrollers.stack.topbar
 
 import android.animation.Animator
 import android.content.Context
+import android.graphics.Color
 import android.view.MenuItem
 import android.view.View
+import androidx.transition.AutoTransition
+import androidx.transition.TransitionManager
 import androidx.viewpager.widget.ViewPager
 import com.reactnativenavigation.options.Alignment
 import com.reactnativenavigation.options.AnimationOptions
+import com.reactnativenavigation.options.ButtonOptions
 import com.reactnativenavigation.options.Options
-import com.reactnativenavigation.utils.CollectionUtils.forEachIndexed
 import com.reactnativenavigation.utils.ViewUtils
 import com.reactnativenavigation.utils.resetViewProperties
 import com.reactnativenavigation.viewcontrollers.stack.topbar.button.ButtonController
@@ -17,12 +20,13 @@ import com.reactnativenavigation.views.stack.StackLayout
 import com.reactnativenavigation.views.stack.topbar.TopBar
 import com.reactnativenavigation.views.stack.topbar.titlebar.ButtonBar
 
+const val DEFAULT_BORDER_COLOR = Color.BLACK
 
 open class TopBarController(private val animator: TopBarAnimator = TopBarAnimator()) {
     lateinit var view: TopBar
     private lateinit var leftButtonBar: ButtonBar
     private lateinit var rightButtonBar: ButtonBar
-
+    private val buttonsTransition = AutoTransition()
 
     val height: Int
         get() = view.height
@@ -54,26 +58,26 @@ open class TopBarController(private val animator: TopBarAnimator = TopBarAnimato
     fun getPushAnimation(appearingOptions: Options, additionalDy: Float = 0f): Animator? {
         if (appearingOptions.topBar.animate.isFalse) return null
         return animator.getPushAnimation(
-                appearingOptions.animations.push.topBar,
-                appearingOptions.topBar.visible,
-                additionalDy
+            appearingOptions.animations.push.topBar,
+            appearingOptions.topBar.visible,
+            additionalDy
         )
     }
 
     fun getPopAnimation(appearingOptions: Options, disappearingOptions: Options): Animator? {
         if (appearingOptions.topBar.animate.isFalse) return null
         return animator.getPopAnimation(
-                disappearingOptions.animations.pop.topBar,
-                appearingOptions.topBar.visible
+            disappearingOptions.animations.pop.topBar,
+            appearingOptions.topBar.visible
         )
     }
 
     fun getSetStackRootAnimation(appearingOptions: Options, additionalDy: Float = 0f): Animator? {
         if (appearingOptions.topBar.animate.isFalse) return null
         return animator.getSetStackRootAnimation(
-                appearingOptions.animations.setStackRoot.topBar,
-                appearingOptions.topBar.visible,
-                additionalDy
+            appearingOptions.animations.setStackRoot.topBar,
+            appearingOptions.topBar.visible,
+            additionalDy
         )
     }
 
@@ -105,25 +109,182 @@ open class TopBarController(private val animator: TopBarAnimator = TopBarAnimato
         view.alignTitleComponent(alignment)
     }
 
-    fun applyRightButtons(toAdd: List<ButtonController>) {
+    fun clearRightButtons() {
         view.clearRightButtons()
-        toAdd.reversed().forEachIndexed { i, b -> b.addToMenu(rightButtonBar, i * 10) }
     }
 
-    fun mergeRightButtons(toAdd: List<ButtonController>, toRemove: List<ButtonController>) {
-        toRemove.forEach { view.removeRightButton(it) }
-        toAdd.reversed().forEachIndexed { i, b -> b.addToMenu(rightButtonBar, i * 10) }
+    fun clearLeftButtons() {
+        view.clearLeftButtons()
     }
 
-    open fun applyLeftButtons(toAdd: List<ButtonController>) {
+    fun clearBackButton() {
         view.clearBackButton()
-        view.clearLeftButtons()
-        forEachIndexed(toAdd) { b: ButtonController, i: Int -> b.addToMenu(leftButtonBar, i * 10) }
     }
 
-    open fun mergeLeftButtons(toAdd: List<ButtonController>, toRemove: List<ButtonController>) {
-        view.clearBackButton()
-        toRemove.forEach { view.removeLeftButton(it) }
-        forEachIndexed(toAdd) { b: ButtonController, i: Int -> b.addToMenu(leftButtonBar, i * 10) }
+    fun setBackButton(backButton: ButtonController?) {
+        backButton?.let { view.setBackButton(it) }
+    }
+
+    fun animateRightButtons(shouldAnimate: Boolean) {
+        view.animateRightButtons(shouldAnimate)
+    }
+
+    fun animateLeftButtons(shouldAnimate: Boolean) {
+        view.animateLeftButtons(shouldAnimate)
+    }
+
+    fun mergeRightButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        rightButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        mergeButtonOptions(btnControllers, rightButtons.reversed(), controllerCreator, rightButtonBar)
+    }
+
+    fun mergeLeftButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        leftButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        clearBackButton()
+        mergeButtonOptions(btnControllers, leftButtons, controllerCreator, leftButtonBar)
+    }
+
+    fun applyRightButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        rightButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        applyButtonsOptions(
+            btnControllers,
+            rightButtons.reversed(),
+            controllerCreator,
+            rightButtonBar
+        )
+    }
+
+    fun applyLeftButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        leftButtons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController
+    ) {
+        applyButtonsOptions(btnControllers, leftButtons, controllerCreator, leftButtonBar)
+    }
+
+    private fun applyButtonsOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        buttons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController,
+        buttonBar: ButtonBar
+    ) {
+        if (buttonBar.shouldAnimate)
+            TransitionManager.beginDelayedTransition(buttonBar, buttonsTransition)
+
+        buttonBar.clearButtons()
+        buttons.forEachIndexed { index, it ->
+            val order = index * 10
+            val newController = if (btnControllers.containsKey(it.id)) {
+                btnControllers.remove(it.id)
+            } else {
+                controllerCreator(it)
+            }!!
+
+            newController.addToMenu(buttonBar, order)
+            btnControllers[it.id] = newController
+        }
+    }
+
+
+    private fun mergeButtonOptions(
+        btnControllers: MutableMap<String, ButtonController>,
+        buttons: List<ButtonOptions>,
+        controllerCreator: (ButtonOptions) -> ButtonController,
+        buttonBar: ButtonBar
+    ) {
+        fun hasChangedOrder(): Boolean {
+            val values = btnControllers.values
+            return buttons.filterIndexed { index, buttonOptions ->
+                val buttonController = btnControllers[buttonOptions.id]
+                values.indexOf(buttonController) == index
+            }.size != buttons.size
+        }
+
+        fun sameIdDifferentCompId(
+            toUpdate: MutableMap<String, Int>,
+            ctrl: Map.Entry<String, ButtonController>,
+            buttons: List<ButtonOptions>
+        ) = if (toUpdate.containsKey(ctrl.key)
+            && ctrl.value.button.hasComponent()
+            && buttons[toUpdate[ctrl.key]!!].component.componentId != ctrl.value.button.component.componentId
+        ) {
+            toUpdate.remove(ctrl.key)
+            true
+        } else false
+
+        val requestedButtons = buttons.mapIndexed { index, buttonOptions -> buttonOptions.id to index }.toMap()
+        var toUpdate = requestedButtons.filter {
+            btnControllers[it.key]?.areButtonOptionsChanged(buttons[it.value]) ?: false
+        }.toMutableMap()
+        var toAdd = requestedButtons.filter { !btnControllers.containsKey(it.key) }
+        var toRemove = btnControllers.filter { ctrl -> !requestedButtons.containsKey(ctrl.key) }
+        val toDestroy = btnControllers.filter { ctrl -> sameIdDifferentCompId(toUpdate, ctrl, buttons) }
+            .toMutableMap().apply { this.putAll(toRemove) }
+
+        fun  needsRebuild(): Boolean {
+           return if (toUpdate.size == buttons.size) {
+                hasChangedOrder()
+            } else toAdd.isNotEmpty() || toRemove.isNotEmpty()
+        }
+
+        if (needsRebuild()) {
+            toUpdate = mutableMapOf()
+            toAdd = requestedButtons
+            toRemove = btnControllers.toMap()
+            if (buttonBar.shouldAnimate)
+                TransitionManager.beginDelayedTransition(buttonBar, buttonsTransition)
+        }
+
+        toUpdate.forEach {
+            val button = buttons[it.value]
+            btnControllers[button.id]?.mergeButtonOptions(button, buttonBar)
+        }
+        toRemove.forEach {
+            buttonBar.removeButton(it.value.buttonIntId)
+            btnControllers.remove(it.key)
+        }
+        toDestroy.values.forEach {
+            it.destroy()
+        }
+        toAdd.forEach {
+            val button = buttons[it.value]
+            val order = it.value * 10
+            val newController = btnControllers[button.id] ?: controllerCreator(button)
+            newController.addToMenu(buttonBar, order)
+            btnControllers[button.id] = newController
+        }
+    }
+
+
+    fun onConfigurationChanged(
+        options: Options,
+        leftBtnControllers: MutableMap<String, ButtonController>?,
+        rightBtnControllers: MutableMap<String, ButtonController>?
+    ) {
+        leftBtnControllers?.values?.forEach {
+            it.onConfigurationChanged(leftButtonBar)
+        }
+        rightBtnControllers?.values?.forEach {
+            it.onConfigurationChanged(rightButtonBar)
+        }
+
+        view.setOverflowButtonColor(options.topBar.rightButtonColor.get(Color.BLACK)!!)
+        view.applyTopTabsColors(
+            options.topTabs.selectedTabColor,
+            options.topTabs.unselectedTabColor
+        )
+        view.setBorderColor(options.topBar.borderColor.get(DEFAULT_BORDER_COLOR)!!)
+        view.setBackgroundColor(options.topBar.background.color.get(Color.WHITE)!!)
+        view.setTitleTextColor(options.topBar.title.color.get(TopBar.DEFAULT_TITLE_COLOR)!!)
+        view.setSubtitleColor(options.topBar.subtitle.color.get(TopBar.DEFAULT_TITLE_COLOR)!!)
     }
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/topbar/button/ButtonController.kt

@@ -71,6 +71,10 @@ open class ButtonController(activity: Activity,
         return if (other.id != id) false else button.equals(other.button)
     }
 
+    fun areButtonOptionsChanged(otherOptions:ButtonOptions):Boolean{
+        return otherOptions.id == id  && !button.equals(otherOptions)
+    }
+
     fun applyNavigationIcon(toolbar: Toolbar) {
         presenter.applyNavigationIcon(toolbar) {
             onPressListener.onPress(it)
@@ -83,13 +87,30 @@ open class ButtonController(activity: Activity,
 
     fun addToMenu(buttonBar: ButtonBar, order: Int) {
         if (button.component.hasValue() && buttonBar.containsButton(menuItem, order)) return
-        buttonBar.menu.removeItem(button.intId)
-        menuItem = buttonBar.addButton(Menu.NONE,
+            buttonBar.menu.removeItem(button.intId)
+            menuItem = buttonBar.addButton(Menu.NONE,
                 button.intId,
                 order,
                 presenter.styledText)?.also { menuItem ->
-            menuItem.setOnMenuItemClickListener(this@ButtonController)
-            presenter.applyOptions(buttonBar, menuItem, this@ButtonController::getView)
+                menuItem.setOnMenuItemClickListener(this@ButtonController)
+                presenter.applyOptions(buttonBar, menuItem, this@ButtonController::getView)
+            }
+    }
+
+    fun mergeButtonOptions(optionsToMerge: ButtonOptions,buttonBar: ButtonBar) {
+        button.mergeWith(optionsToMerge)
+        presenter.button = this.button
+        buttonBar.getButtonById(button.intId)?.let {
+                menuItem->
+            presenter.applyOptions(buttonBar,menuItem,this::getView)
         }
     }
+
+    fun onConfigurationChanged(buttonBar: ButtonBar) {
+        buttonBar.getButtonById(button.intId)?.let {
+                menuItem->
+            presenter.applyOptions(buttonBar,menuItem,this::getView)
+        }
+    }
+
 }

lib/android/app/src/main/java/com/reactnativenavigation/viewcontrollers/stack/topbar/button/ButtonPresenter.kt

@@ -25,7 +25,8 @@ import com.reactnativenavigation.utils.ViewUtils
 import com.reactnativenavigation.views.stack.topbar.titlebar.IconBackgroundDrawable
 import kotlin.math.max
 
-open class ButtonPresenter(private val context: Context, private val button: ButtonOptions, private val iconResolver: IconResolver) {
+open class ButtonPresenter(private val context: Context,var button: ButtonOptions, private val iconResolver:
+IconResolver) {
     companion object {
         const val DISABLED_COLOR = Color.LTGRAY
     }
@@ -47,6 +48,8 @@ open class ButtonPresenter(private val context: Context, private val button: But
         applyComponent(menuItem, viewCreator)
         applyAccessibilityLabel(menuItem)
         applyIcon(menuItem)
+        applyText(menuItem)
+
 
         applyOptionsDirectlyOnView(toolbar, menuItem) {
             applyTestId(it)
@@ -55,6 +58,11 @@ open class ButtonPresenter(private val context: Context, private val button: But
         }
     }
 
+    private fun applyText(menuItem: MenuItem) {
+        if (button.text.hasValue())
+            menuItem.title = button.text.get()
+    }
+
     fun applyColor(toolbar: Toolbar, menuItem: MenuItem, color: ThemeColour) {
         button.color = color
         applyIcon(menuItem)