Version bump

README.md

@@ -20,27 +20,29 @@ Conductor is architecture-agnostic and does not try to force any design decision
 ## Installation
 
 ```gradle
-implementation 'com.bluelinelabs:conductor:3.1.7'
+def conductorVersion = '3.1.9'
+
+implementation "com.bluelinelabs:conductor:$conductorVersion"
 
 // AndroidX Transition change handlers:
-implementation 'com.bluelinelabs:conductor-androidx-transition:3.1.7'
+implementation "com.bluelinelabs:conductor-androidx-transition:$conductorVersion"
 
 // ViewPager PagerAdapter:
-implementation 'com.bluelinelabs:conductor-viewpager:3.1.7'
+implementation "com.bluelinelabs:conductor-viewpager:$conductorVersion"
 
 // ViewPager2 Adapter:
-implementation 'com.bluelinelabs:conductor-viewpager2:3.1.7'
+implementation "com.bluelinelabs:conductor-viewpager2:$conductorVersion"
 
 // RxJava2 Autodispose support:
-implementation 'com.bluelinelabs:conductor-autodispose:3.1.7'
+implementation "com.bluelinelabs:conductor-autodispose:$conductorVersion"
 
 // Lifecycle-aware Controllers (architecture components):
-implementation 'com.bluelinelabs:conductor-archlifecycle:3.1.7'
+implementation "com.bluelinelabs:conductor-archlifecycle:$conductorVersion"
 ```
 
 **SNAPSHOT**
 
-Just use `3.1.8-SNAPSHOT` as your version number in any of the dependencies above and add the url to the snapshot repository:
+Just use `3.2.0-SNAPSHOT` as your version number in any of the dependencies above and add the url to the snapshot repository:
 
 ```gradle
 allprojects {

conductor-modules/arch-components-lifecycle/src/main/java/com/bluelinelabs/conductor/archlifecycle/ControllerLifecycleOwner.java

@@ -51,7 +51,10 @@ public class ControllerLifecycleOwner implements LifecycleOwner {
 
             @Override
             public void preDestroy(@NonNull Controller controller) {
-                lifecycleRegistry.handleLifecycleEvent(Event.ON_DESTROY); // --> State.DESTROYED;
+                // Only act on Controllers that have had at least the onContextAvailable call made on them.
+                if (lifecycleRegistry.getCurrentState() != Lifecycle.State.INITIALIZED) {
+                    lifecycleRegistry.handleLifecycleEvent(Event.ON_DESTROY); // --> State.DESTROYED;
+                }
             }
 
         });

conductor/src/main/java/com/bluelinelabs/conductor/Controller.java

@@ -1081,8 +1081,9 @@ public abstract class Controller {
 
     final View inflate(@NonNull ViewGroup parent) {
         if (view != null && view.getParent() != null && view.getParent() != parent) {
+            View viewRef = view;
             detach(view, true, false);
-            removeViewReference(view != null ? view.getContext() : null);
+            removeViewReference(viewRef.getContext());
         }
 
         if (view == null) {

conductor/src/main/java/com/bluelinelabs/conductor/Router.java

@@ -560,10 +560,9 @@ public abstract class Router {
     public void rebindIfNeeded() {
         ThreadUtils.ensureMainThread();
 
-        Iterator<RouterTransaction> backstackIterator = backstack.reverseIterator();
-        while (backstackIterator.hasNext()) {
-            RouterTransaction transaction = backstackIterator.next();
-
+        // Not directly using the iterator in order to prevent ConcurrentModificationExceptions if controllers pop
+        // themselves on re-attach.
+        for (RouterTransaction transaction : getTransactions()) {
             if (transaction.controller().getNeedsAttach()) {
                 performControllerChange(transaction, null, true, new SimpleSwapChangeHandler(false));
             } else {
@@ -782,6 +781,18 @@ public abstract class Router {
         return controllers;
     }
 
+    @NonNull
+    final List<RouterTransaction> getTransactions() {
+        List<RouterTransaction> transactions = new ArrayList<>(backstack.getSize());
+
+        Iterator<RouterTransaction> backstackIterator = backstack.reverseIterator();
+        while (backstackIterator.hasNext()) {
+            transactions.add(backstackIterator.next());
+        }
+
+        return transactions;
+    }
+
     @Nullable
     public final Boolean handleRequestedPermission(@NonNull String permission) {
         for (RouterTransaction transaction : backstack) {

conductor/src/main/java/com/bluelinelabs/conductor/internal/OwnViewTreeLifecycleAndRegistry.kt

@@ -29,7 +29,6 @@ internal class OwnViewTreeLifecycleAndRegistry private constructor(
 
   private var hasSavedState = false
   private var savedRegistryState = Bundle.EMPTY
-  private val parentChangeListeners = mutableMapOf<String, Controller.LifecycleListener>()
 
   init {
     controller.addLifecycleListener(object : Controller.LifecycleListener() {
@@ -97,6 +96,8 @@ internal class OwnViewTreeLifecycleAndRegistry private constructor(
           changeHandler = changeHandler,
           changeType = changeType,
         )
+
+        GlobalChangeStartListener.onChangeStart(changeController, changeHandler, changeType)
       }
 
       override fun preDetach(controller: Controller, view: View) {
@@ -138,11 +139,11 @@ internal class OwnViewTreeLifecycleAndRegistry private constructor(
       }
 
       override fun postContextAvailable(controller: Controller, context: Context) {
-        listenForParentChangeStart(controller)
+        listenForAncestorChangeStart(controller)
       }
 
       override fun preContextUnavailable(controller: Controller, context: Context) {
-        stopListeningForParentChangeStart(controller)
+        stopListeningForAncestorChangeStart(controller)
       }
     })
   }
@@ -151,40 +152,23 @@ internal class OwnViewTreeLifecycleAndRegistry private constructor(
 
   override fun getSavedStateRegistry() = savedStateRegistryController.savedStateRegistry
 
-  private fun listenForParentChangeStart(controller: Controller) {
-    controller.parentController?.let { parent ->
-      val changeListener = object : Controller.LifecycleListener() {
-        override fun onChangeStart(
-          controller: Controller,
-          changeHandler: ControllerChangeHandler,
-          changeType: ControllerChangeType
-        ) {
-          // No-op on the case where we (the child controller) hasn't yet created a View as our parent is being
-          // changed out.
-          if (::lifecycleRegistry.isInitialized) {
-            pauseOnChangeStart(
-              targetController = parent,
-              changeController = controller,
-              changeHandler = changeHandler,
-              changeType = changeType,
-            )
-          }
-        }
+  private fun listenForAncestorChangeStart(controller: Controller) {
+    GlobalChangeStartListener.subscribe(controller, controller.ancestors()) { ancestor, changeHandler, changeType ->
+      // No-op on the case where we (the child controller) hasn't yet created a View as our parent is being
+      // changed out.
+      if (::lifecycleRegistry.isInitialized) {
+        pauseOnChangeStart(
+          targetController = ancestor,
+          changeController = ancestor,
+          changeHandler = changeHandler,
+          changeType = changeType,
+        )
       }
-
-      parent.addLifecycleListener(changeListener)
-      parentChangeListeners[controller.instanceId] = changeListener
-
-      listenForParentChangeStart(parent)
     }
   }
 
-  private fun stopListeningForParentChangeStart(controller: Controller) {
-    controller.parentController?.let { parent ->
-      parentChangeListeners.remove(parent.instanceId)?.let { listener ->
-        parent.removeLifecycleListener(listener)
-      }
-    }
+  private fun stopListeningForAncestorChangeStart(controller: Controller) {
+    GlobalChangeStartListener.unsubscribe(controller)
   }
 
   // AbstractComposeView adds its own OnAttachStateChangeListener by default. Since it
@@ -213,6 +197,16 @@ internal class OwnViewTreeLifecycleAndRegistry private constructor(
     }
   }
 
+  private fun Controller.ancestors(): Collection<String> {
+    return buildList {
+      var ancestor = parentController
+      while (ancestor != null) {
+        add(ancestor.instanceId)
+        ancestor = ancestor.parentController
+      }
+    }
+  }
+
   companion object {
     private const val KEY_SAVED_STATE = "Registry.savedState"
 
@@ -221,3 +215,37 @@ internal class OwnViewTreeLifecycleAndRegistry private constructor(
     }
   }
 }
+
+// In order to prevent child controllers from having strong references to all of their ancestors, some of which may
+// break their connection before the child is made aware, this shared listener is used to call all interested parties
+// when a controller begins transitioning.
+private object GlobalChangeStartListener {
+  private val listeners = mutableMapOf<String, Listener>()
+
+  fun subscribe(
+    controller: Controller,
+    targetControllers: Collection<String>,
+    listener: (Controller, ControllerChangeHandler, ControllerChangeType) -> Unit,
+  ) {
+    listeners[controller.instanceId] = Listener(targetControllers, listener)
+  }
+
+  fun unsubscribe(controller: Controller) {
+    listeners.remove(controller.instanceId)
+  }
+
+  fun onChangeStart(controller: Controller, changeHandler: ControllerChangeHandler, changeType: ControllerChangeType) {
+    listeners.values.forEach { it.call(controller, changeHandler, changeType) }
+  }
+
+  private class Listener(
+    private val targetControllers: Collection<String>,
+    private val listener: (Controller, ControllerChangeHandler, ControllerChangeType) -> Unit,
+  ) {
+    fun call(controller: Controller, changeHandler: ControllerChangeHandler, changeType: ControllerChangeType) {
+      if (targetControllers.contains(controller.instanceId)) {
+        listener(controller, changeHandler, changeType)
+      }
+    }
+  }
+}

gradle.properties

@@ -1,5 +1,5 @@
 VERSION_CODE=3
-VERSION_NAME=3.1.8-SNAPSHOT
+VERSION_NAME=3.2.0-SNAPSHOT
 android.useAndroidX=true
 org.gradle.jvmargs=-Xmx1536m