Version bump

Cleaned up the demo and directory structure a bit now that there are so many external modules

.travis.yml

@@ -3,9 +3,11 @@ language: android
 android:
   components:
     - tools
-    - build-tools-23.0.2
-    - android-23
+    - build-tools-25.0.3
+    - android-25
     - extra-android-m2repository
+  licenses:
+    - '.+'
 
 script:
   - ./gradlew test

README.md

@@ -4,8 +4,8 @@
 
 A small, yet full-featured framework that allows building View-based Android applications. Conductor provides a light-weight wrapper around standard Android Views that does just about everything you'd want:
 
-              |  Conductor
-------|------------------------------
+|           |  Conductor  |
+|-----------|-------------|
 :tada: | Easy integration
 :point_up: | Single Activity apps without using Fragments
 :recycle: | Simple but powerful lifecycle management
@@ -20,25 +20,28 @@ Conductor is architecture-agnostic and does not try to force any design decision
 ## Installation
 
 ```gradle
-compile 'com.bluelinelabs:conductor:2.0.5'
+compile 'com.bluelinelabs:conductor:2.1.4'
 
 // If you want the components that go along with
 // Android's support libraries (currently just a PagerAdapter):
-compile 'com.bluelinelabs:conductor-support:2.0.5'
+compile 'com.bluelinelabs:conductor-support:2.1.4'
 
-// If you want RxJava/RxAndroid lifecycle support:
-compile 'com.bluelinelabs:conductor-rxlifecycle:2.0.5'
+// If you want RxJava lifecycle support:
+compile 'com.bluelinelabs:conductor-rxlifecycle:2.1.4'
+
+// If you want RxJava2 lifecycle support:
+compile 'com.bluelinelabs:conductor-rxlifecycle2:2.1.4'
+
+// If you want RxJava2 Autodispose support:
+compile 'com.bluelinelabs:conductor-autodispose:2.1.4'
+
+// If you want Controllers that are Lifecycle-aware (architecture components):
+compile 'com.bluelinelabs:conductor-arch-components-lifecycle:0.1.1'
 ```
 
 SNAPSHOT:
 
-```gradle
-compile 'com.bluelinelabs:conductor:2.0.6-SNAPSHOT'
-compile 'com.bluelinelabs:conductor-support:2.0.6-SNAPSHOT'
-compile 'com.bluelinelabs:conductor-rxlifecycle:2.0.6-SNAPSHOT'
-```
-
-You also have to add the url to the snapshot repository:
+Just use `2.1.5-SNAPSHOT` as your version number in any of the above dependencies and add the url to the snapshot repository:
 
 ```gradle
 allprojects {
@@ -51,7 +54,7 @@ allprojects {
 
 ## Components to Know
 
-              |  Conductor Components
+|             |  Conductor Components |
 ------|------------------------------
 __Controller__ | The Controller is the View wrapper that will give you all of your lifecycle management features. Think of it as a lighter-weight and more predictable Fragment alternative with an easier to manage lifecycle.
 __Router__ | A Router implements navigation and backstack handling for Controllers. Router objects are attached to Activity/containing ViewGroup pairs. Routers do not directly render or push Views to the container ViewGroup, but instead defer this responsibility to the ControllerChangeHandler specified in a given transaction.
@@ -114,7 +117,7 @@ public class HomeController extends Controller {
 
 The lifecycle of a Controller is significantly simpler to understand than that of a Fragment. A lifecycle diagram is shown below:
 
-![Controller Lifecycle](docs/Controller Lifecycle.jpg)
+![Controller Lifecycle](docs/Controller%20Lifecycle.jpg)
 
 ## Advanced Topics
 

build.gradle

@@ -3,19 +3,16 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.2.3'
+        classpath 'com.android.tools.build:gradle:2.3.2'
     }
 }
 
 allprojects {
     repositories {
         jcenter()
-        mavenLocal()
+        mavenCentral()
+        maven { url 'https://maven.google.com' }
     }
 }
 
-task wrapper(type: Wrapper) {
-    gradleVersion = '2.10'
-}
-
 apply from: rootProject.file('dependencies.gradle')

conductor-lint/build.gradle

@@ -1,5 +1,8 @@
 apply plugin: 'java'
 
+targetCompatibility = JavaVersion.VERSION_1_7
+sourceCompatibility = JavaVersion.VERSION_1_7
+
 configurations {
     lintChecks
 }
@@ -8,6 +11,9 @@ dependencies {
     compile rootProject.ext.lintapi
     compile rootProject.ext.lintchecks
 
+    testCompile rootProject.ext.lint
+    testCompile rootProject.ext.lintTests
+
     lintChecks files(jar)
 }
 

conductor-lint/src/main/java/com/bluelinelabs/conductor/lint/ControllerChangeHandlerIssueDetector.java

@@ -1,7 +1,6 @@
 package com.bluelinelabs.conductor.lint;
 
-import com.android.annotations.NonNull;
-import com.android.tools.lint.client.api.JavaParser.ResolvedClass;
+import com.android.tools.lint.client.api.JavaEvaluator;
 import com.android.tools.lint.detector.api.Category;
 import com.android.tools.lint.detector.api.Detector;
 import com.android.tools.lint.detector.api.Implementation;
@@ -9,21 +8,13 @@ import com.android.tools.lint.detector.api.Issue;
 import com.android.tools.lint.detector.api.JavaContext;
 import com.android.tools.lint.detector.api.Scope;
 import com.android.tools.lint.detector.api.Severity;
-import com.android.tools.lint.detector.api.Speed;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiMethod;
 
-import java.lang.reflect.Modifier;
 import java.util.Collections;
 import java.util.List;
 
-import lombok.ast.ClassDeclaration;
-import lombok.ast.ConstructorDeclaration;
-import lombok.ast.Node;
-import lombok.ast.NormalTypeBody;
-import lombok.ast.StrictListAccessor;
-import lombok.ast.TypeMember;
-import lombok.ast.VariableDefinition;
-
-public final class ControllerChangeHandlerIssueDetector extends Detector implements Detector.JavaScanner, Detector.ClassScanner {
+public final class ControllerChangeHandlerIssueDetector extends Detector implements Detector.JavaPsiScanner {
 
     public static final Issue ISSUE =
             Issue.create("ValidControllerChangeHandler", "ControllerChangeHandler not instantiatable",
@@ -34,67 +25,45 @@ public final class ControllerChangeHandlerIssueDetector extends Detector impleme
 
     public ControllerChangeHandlerIssueDetector() { }
 
-    @NonNull
-    @Override
-    public Speed getSpeed() {
-        return Speed.FAST;
-    }
-
     @Override
     public List<String> applicableSuperClasses() {
         return Collections.singletonList("com.bluelinelabs.conductor.ControllerChangeHandler");
     }
 
     @Override
-    public void checkClass(@NonNull JavaContext context, ClassDeclaration node,
-                           @NonNull Node declarationOrAnonymous, @NonNull ResolvedClass cls) {
-
-        if (node == null) {
+    public void checkClass(JavaContext context, PsiClass declaration) {
+        final JavaEvaluator evaluator = context.getEvaluator();
+        if (evaluator.isAbstract(declaration)) {
             return;
         }
 
-        final int flags = node.astModifiers().getEffectiveModifierFlags();
-        if ((flags & Modifier.ABSTRACT) != 0) {
+        if (!evaluator.isPublic(declaration)) {
+            String message = String.format("This ControllerChangeHandler class should be public (%1$s)", declaration.getQualifiedName());
+            context.report(ISSUE, declaration, context.getLocation(declaration), message);
             return;
         }
 
-        if ((flags & Modifier.PUBLIC) == 0) {
-            String message = String.format("This ControllerChangeHandler class should be public (%1$s)", cls.getName());
-            context.report(ISSUE, node, context.getLocation(node.astName()), message);
+        if (declaration.getContainingClass() != null && !evaluator.isStatic(declaration)) {
+            String message = String.format("This ControllerChangeHandler inner class should be static (%1$s)", declaration.getQualifiedName());
+            context.report(ISSUE, declaration, context.getLocation(declaration), message);
             return;
         }
 
-        if (cls.getContainingClass() != null && (flags & Modifier.STATIC) == 0) {
-            String message = String.format("This ControllerChangeHandler inner class should be static (%1$s)", cls.getName());
-            context.report(ISSUE, node, context.getLocation(node.astName()), message);
-            return;
-        }
-
-        boolean hasConstructor = false;
         boolean hasDefaultConstructor = false;
-        NormalTypeBody body = node.astBody();
-        if (body != null) {
-            for (TypeMember member : body.astMembers()) {
-                if (member instanceof ConstructorDeclaration) {
-                    hasConstructor = true;
-                    ConstructorDeclaration constructor = (ConstructorDeclaration)member;
-
-                    if (constructor.astModifiers().isPublic()) {
-                        StrictListAccessor<VariableDefinition, ConstructorDeclaration> params = constructor.astParameters();
-                        if (params.isEmpty()) {
-                            hasDefaultConstructor = true;
-                            break;
-                        }
-                    }
+        PsiMethod[] constructors = declaration.getConstructors();
+        for (PsiMethod constructor : constructors) {
+            if (evaluator.isPublic(constructor)) {
+                if (constructor.getParameterList().getParametersCount() == 0) {
+                    hasDefaultConstructor = true;
+                    break;
                 }
             }
         }
 
-        if (hasConstructor && !hasDefaultConstructor) {
+        if (constructors.length > 0 && !hasDefaultConstructor) {
             String message = String.format(
-                    "This ControllerChangeHandler needs to have a public default constructor (`%1$s`)",
-                    cls.getName());
-            context.report(ISSUE, node, context.getLocation(node.astName()), message);
+                    "This ControllerChangeHandler needs to have a public default constructor (`%1$s`)", declaration.getQualifiedName());
+            context.report(ISSUE, declaration, context.getLocation(declaration), message);
         }
     }
-}
+}

conductor-lint/src/main/java/com/bluelinelabs/conductor/lint/ControllerIssueDetector.java

@@ -1,8 +1,7 @@
 package com.bluelinelabs.conductor.lint;
 
 import com.android.SdkConstants;
-import com.android.annotations.NonNull;
-import com.android.tools.lint.client.api.JavaParser.ResolvedClass;
+import com.android.tools.lint.client.api.JavaEvaluator;
 import com.android.tools.lint.detector.api.Category;
 import com.android.tools.lint.detector.api.Detector;
 import com.android.tools.lint.detector.api.Implementation;
@@ -10,21 +9,14 @@ import com.android.tools.lint.detector.api.Issue;
 import com.android.tools.lint.detector.api.JavaContext;
 import com.android.tools.lint.detector.api.Scope;
 import com.android.tools.lint.detector.api.Severity;
-import com.android.tools.lint.detector.api.Speed;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiMethod;
+import com.intellij.psi.PsiParameter;
 
-import java.lang.reflect.Modifier;
 import java.util.Collections;
 import java.util.List;
 
-import lombok.ast.ClassDeclaration;
-import lombok.ast.ConstructorDeclaration;
-import lombok.ast.Node;
-import lombok.ast.NormalTypeBody;
-import lombok.ast.StrictListAccessor;
-import lombok.ast.TypeMember;
-import lombok.ast.VariableDefinition;
-
-public final class ControllerIssueDetector extends Detector implements Detector.JavaScanner, Detector.ClassScanner {
+public final class ControllerIssueDetector extends Detector implements Detector.JavaPsiScanner {
 
     public static final Issue ISSUE =
             Issue.create("ValidController", "Controller not instantiatable",
@@ -35,74 +27,56 @@ public final class ControllerIssueDetector extends Detector implements Detector.
 
     public ControllerIssueDetector() { }
 
-    @NonNull
-    @Override
-    public Speed getSpeed() {
-        return Speed.FAST;
-    }
-
     @Override
     public List<String> applicableSuperClasses() {
         return Collections.singletonList("com.bluelinelabs.conductor.Controller");
     }
 
     @Override
-    public void checkClass(@NonNull JavaContext context, ClassDeclaration node,
-                           @NonNull Node declarationOrAnonymous, @NonNull ResolvedClass cls) {
-
-        if (node == null) {
+    public void checkClass(JavaContext context, PsiClass declaration) {
+        final JavaEvaluator evaluator = context.getEvaluator();
+        if (evaluator.isAbstract(declaration)) {
             return;
         }
 
-        final int flags = node.astModifiers().getEffectiveModifierFlags();
-        if ((flags & Modifier.ABSTRACT) != 0) {
+        if (!evaluator.isPublic(declaration)) {
+            String message = String.format("This Controller class should be public (%1$s)", declaration.getQualifiedName());
+            context.report(ISSUE, declaration, context.getLocation(declaration), message);
             return;
         }
 
-        if ((flags & Modifier.PUBLIC) == 0) {
-            String message = String.format("This Controller class should be public (%1$s)", cls.getName());
-            context.report(ISSUE, node, context.getLocation(node.astName()), message);
+        if (declaration.getContainingClass() != null && !evaluator.isStatic(declaration)) {
+            String message = String.format("This Controller inner class should be static (%1$s)", declaration.getQualifiedName());
+            context.report(ISSUE, declaration, context.getLocation(declaration), message);
             return;
         }
 
-        if (cls.getContainingClass() != null && (flags & Modifier.STATIC) == 0) {
-            String message = String.format("This Controller inner class should be static (%1$s)", cls.getName());
-            context.report(ISSUE, node, context.getLocation(node.astName()), message);
-            return;
-        }
 
-        boolean hasConstructor = false;
         boolean hasDefaultConstructor = false;
         boolean hasBundleConstructor = false;
-        NormalTypeBody body = node.astBody();
-        if (body != null) {
-            for (TypeMember member : body.astMembers()) {
-                if (member instanceof ConstructorDeclaration) {
-                    hasConstructor = true;
-                    ConstructorDeclaration constructor = (ConstructorDeclaration)member;
+        PsiMethod[] constructors = declaration.getConstructors();
+        for (PsiMethod constructor : constructors) {
+            if (evaluator.isPublic(constructor)) {
+                PsiParameter[] parameters = constructor.getParameterList().getParameters();
 
-                    if (constructor.astModifiers().isPublic()) {
-                        StrictListAccessor<VariableDefinition, ConstructorDeclaration> params = constructor.astParameters();
-                        if (params.isEmpty()) {
-                            hasDefaultConstructor = true;
-                            break;
-                        } else if (params.size() == 1 &&
-                                (params.first().astTypeReference().getTypeName().equals(SdkConstants.CLASS_BUNDLE)) ||
-                                params.first().astTypeReference().getTypeName().equals("Bundle")) {
-                            hasBundleConstructor = true;
-                            break;
-                        }
-                    }
+                if (parameters.length == 0) {
+                    hasDefaultConstructor = true;
+                    break;
+                } else if (parameters.length == 1 &&
+                        parameters[0].getType().equalsToText(SdkConstants.CLASS_BUNDLE) ||
+                        parameters[0].getType().equalsToText("Bundle")) {
+                    hasBundleConstructor = true;
+                    break;
                 }
             }
         }
 
-        if (hasConstructor && !hasDefaultConstructor && !hasBundleConstructor) {
+        if (constructors.length > 0 && !hasDefaultConstructor && !hasBundleConstructor) {
             String message = String.format(
                     "This Controller needs to have either a public default constructor or a" +
                             " public single-argument constructor that takes a Bundle. (`%1$s`)",
-                    cls.getName());
-            context.report(ISSUE, node, context.getLocation(node.astName()), message);
+                    declaration.getQualifiedName());
+            context.report(ISSUE, declaration, context.getLocation(declaration), message);
         }
     }
-}
+}

conductor-lint/src/main/java/com/bluelinelabs/conductor/lint/IssueRegistry.java

@@ -11,4 +11,4 @@ public final class IssueRegistry extends com.android.tools.lint.client.api.Issue
                 ControllerIssueDetector.ISSUE,
                 ControllerChangeHandlerIssueDetector.ISSUE);
     }
-}
+}

conductor-lint/src/test/java/com/bluelinelabs/conductor/lint/ControllerChangeHandlerDetectorTest.java

@@ -0,0 +1,96 @@
+package com.bluelinelabs.conductor.lint;
+
+import com.android.tools.lint.checks.infrastructure.LintDetectorTest;
+import com.android.tools.lint.detector.api.Detector;
+import com.android.tools.lint.detector.api.Issue;
+
+import org.intellij.lang.annotations.Language;
+
+import java.util.Collections;
+import java.util.List;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class ControllerChangeHandlerDetectorTest extends LintDetectorTest {
+
+    private static final String NO_WARNINGS = "No warnings.";
+    private static final String CONSTRUCTOR =
+            "src/test/SampleHandler.java:2: Error: This ControllerChangeHandler needs to have a public default constructor (test.SampleHandler) [ValidControllerChangeHandler]\n"
+            + "public class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+            + "^\n"
+            + "1 errors, 0 warnings\n";
+    private static final String PRIVATE_CLASS_ERROR =
+            "src/test/SampleHandler.java:2: Error: This ControllerChangeHandler class should be public (test.SampleHandler) [ValidControllerChangeHandler]\n"
+                    + "private class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+                    + "^\n"
+                    + "1 errors, 0 warnings\n";
+
+    public void testWithNoConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(NO_WARNINGS);
+    }
+
+    public void testWithEmptyConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+                + "    public SampleHandler() { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(NO_WARNINGS);
+    }
+
+    public void testWithInvalidConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+                + "    public SampleHandler(int number) { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(CONSTRUCTOR);
+    }
+
+    public void testWithEmptyAndInvalidConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+                + "    public SampleHandler() { }\n"
+                + "    public SampleHandler(int number) { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(NO_WARNINGS);
+    }
+
+    public void testWithPrivateConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+                + "    private SampleHandler() { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(CONSTRUCTOR);
+    }
+
+    public void testWithPrivateClass() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "private class SampleHandler extends com.bluelinelabs.conductor.ControllerChangeHandler {\n"
+                + "    public SampleHandler() { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(PRIVATE_CLASS_ERROR);
+    }
+
+    @Override
+    protected Detector getDetector() {
+        return new ControllerChangeHandlerIssueDetector();
+    }
+
+    @Override
+    protected List<Issue> getIssues() {
+        return Collections.singletonList(ControllerChangeHandlerIssueDetector.ISSUE);
+    }
+
+    @Override
+    protected boolean allowCompilationErrors() {
+        return true;
+    }
+}

conductor-lint/src/test/java/com/bluelinelabs/conductor/lint/ControllerDetectorTest.java

@@ -0,0 +1,96 @@
+package com.bluelinelabs.conductor.lint;
+
+import com.android.tools.lint.checks.infrastructure.LintDetectorTest;
+import com.android.tools.lint.detector.api.Detector;
+import com.android.tools.lint.detector.api.Issue;
+
+import org.intellij.lang.annotations.Language;
+
+import java.util.Collections;
+import java.util.List;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class ControllerDetectorTest extends LintDetectorTest {
+
+    private static final String NO_WARNINGS = "No warnings.";
+    private static final String CONSTRUCTOR_ERROR =
+            "src/test/SampleController.java:2: Error: This Controller needs to have either a public default constructor or a public single-argument constructor that takes a Bundle. (test.SampleController) [ValidController]\n"
+            + "public class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+            + "^\n"
+            + "1 errors, 0 warnings\n";
+    private static final String CLASS_ERROR =
+            "src/test/SampleController.java:2: Error: This Controller class should be public (test.SampleController) [ValidController]\n"
+                    + "private class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+                    + "^\n"
+                    + "1 errors, 0 warnings\n";
+
+    public void testWithNoConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(NO_WARNINGS);
+    }
+
+    public void testWithEmptyConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+                + "    public SampleController() { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(NO_WARNINGS);
+    }
+
+    public void testWithInvalidConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+                + "    public SampleController(int number) { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(CONSTRUCTOR_ERROR);
+    }
+
+    public void testWithEmptyAndInvalidConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+                + "    public SampleController() { }\n"
+                + "    public SampleController(int number) { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(NO_WARNINGS);
+    }
+
+    public void testWithPrivateConstructor() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "public class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+                + "    private SampleController() { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(CONSTRUCTOR_ERROR);
+    }
+
+    public void testWithPrivateClass() throws Exception {
+        @Language("JAVA") String source = ""
+                + "package test;\n"
+                + "private class SampleController extends com.bluelinelabs.conductor.Controller {\n"
+                + "    public SampleController() { }\n"
+                + "}";
+        assertThat(lintProject(java(source))).isEqualTo(CLASS_ERROR);
+    }
+
+    @Override
+    protected Detector getDetector() {
+        return new ControllerIssueDetector();
+    }
+
+    @Override
+    protected List<Issue> getIssues() {
+        return Collections.singletonList(ControllerIssueDetector.ISSUE);
+    }
+
+    @Override
+    protected boolean allowCompilationErrors() {
+        return true;
+    }
+}

conductor-modules/arch-components-lifecycle/build.gradle

@@ -7,10 +7,6 @@ android {
     compileSdkVersion rootProject.ext.compileSdkVersion
     buildToolsVersion rootProject.ext.buildToolsVersion
 
-    lintOptions {
-        abortOnError false
-    }
-
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_7
         targetCompatibility JavaVersion.VERSION_1_7
@@ -25,9 +21,9 @@ android {
 }
 
 dependencies {
-    compile rootProject.ext.supportAppCompat
+    compile rootProject.ext.archComopnentsLifecycle
+
     compile project(':conductor')
 }
 
-ext.artifactId = 'conductor-support'
-
+ext.artifactId = 'conductor-arch-components-lifecycle'

conductor-modules/arch-components-lifecycle/gradle.properties

@@ -0,0 +1,4 @@
+POM_NAME=Conductor Architecture Components Lifecycle Extensions
+POM_ARTIFACT_ID=conductor-archlifecycle
+POM_PACKAGING=aar
+VERSION_NAME=0.1.2-SNAPSHOT

conductor-modules/arch-components-lifecycle/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest package="com.bluelinelabs.conductor.archlifecycle">
+    <application />
+</manifest>

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

@@ -0,0 +1,79 @@
+package com.bluelinelabs.conductor.archlifecycle;
+
+import android.arch.lifecycle.Lifecycle.Event;
+import android.arch.lifecycle.Lifecycle.State;
+import android.arch.lifecycle.LifecycleRegistry;
+import android.arch.lifecycle.LifecycleRegistryOwner;
+import android.support.annotation.NonNull;
+import android.view.View;
+
+import com.bluelinelabs.conductor.Controller;
+import com.bluelinelabs.conductor.Controller.LifecycleListener;
+
+public class ControllerLifecycleRegistryOwner extends LifecycleListener implements LifecycleRegistryOwner {
+
+    private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
+
+    public ControllerLifecycleRegistryOwner(Controller controller) {
+        lifecycleRegistry.handleLifecycleEvent(Event.ON_CREATE);
+        lifecycleRegistry.markState(State.CREATED);
+
+        controller.addLifecycleListener(new LifecycleListener() {
+            @Override
+            public void preCreateView(@NonNull Controller controller) {
+                lifecycleRegistry.handleLifecycleEvent(Event.ON_START);
+            }
+
+            @Override
+            public void postCreateView(@NonNull Controller controller, @NonNull View view) {
+                lifecycleRegistry.markState(State.STARTED);
+            }
+
+            @Override
+            public void preAttach(@NonNull Controller controller, @NonNull View view) {
+                lifecycleRegistry.handleLifecycleEvent(Event.ON_RESUME);
+            }
+
+            @Override
+            public void postAttach(@NonNull Controller controller, @NonNull View view) {
+                lifecycleRegistry.markState(State.RESUMED);
+            }
+
+            @Override
+            public void preDetach(@NonNull Controller controller, @NonNull View view) {
+                lifecycleRegistry.handleLifecycleEvent(Event.ON_PAUSE);
+            }
+
+            @Override
+            public void postDetach(@NonNull Controller controller, @NonNull View view) {
+                lifecycleRegistry.markState(State.STARTED);
+            }
+
+            @Override
+            public void preDestroyView(@NonNull Controller controller, @NonNull View view) {
+                lifecycleRegistry.handleLifecycleEvent(Event.ON_STOP);
+            }
+
+            @Override
+            public void postDestroyView(@NonNull Controller controller) {
+                lifecycleRegistry.markState(State.CREATED);
+            }
+
+            @Override
+            public void preDestroy(@NonNull Controller controller) {
+                lifecycleRegistry.handleLifecycleEvent(Event.ON_DESTROY);
+            }
+
+            @Override
+            public void postDestroy(@NonNull Controller controller) {
+                lifecycleRegistry.markState(State.DESTROYED);
+            }
+        });
+    }
+
+    @Override
+    public LifecycleRegistry getLifecycle() {
+        return lifecycleRegistry;
+    }
+
+}

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

@@ -0,0 +1,17 @@
+package com.bluelinelabs.conductor.archlifecycle;
+
+import android.arch.lifecycle.LifecycleRegistry;
+import android.arch.lifecycle.LifecycleRegistryOwner;
+
+import com.bluelinelabs.conductor.Controller;
+
+public abstract class LifecycleController extends Controller implements LifecycleRegistryOwner {
+
+    private final ControllerLifecycleRegistryOwner lifecycleRegistryOwner = new ControllerLifecycleRegistryOwner(this);
+
+    @Override
+    public LifecycleRegistry getLifecycle() {
+        return lifecycleRegistryOwner.getLifecycle();
+    }
+
+}

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

@@ -0,0 +1,17 @@
+package com.bluelinelabs.conductor.archlifecycle;
+
+import android.arch.lifecycle.LifecycleRegistry;
+import android.arch.lifecycle.LifecycleRegistryOwner;
+
+import com.bluelinelabs.conductor.RestoreViewOnCreateController;
+
+public abstract class LifecycleRestoreViewOnCreateController extends RestoreViewOnCreateController implements LifecycleRegistryOwner {
+
+    private final ControllerLifecycleRegistryOwner lifecycleRegistryOwner = new ControllerLifecycleRegistryOwner(this);
+
+    @Override
+    public LifecycleRegistry getLifecycle() {
+        return lifecycleRegistryOwner.getLifecycle();
+    }
+
+}

conductor-modules/autodispose/build.gradle

@@ -0,0 +1,30 @@
+apply from: rootProject.file('dependencies.gradle')
+apply from: rootProject.file('gradle-mvn-push.gradle')
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion rootProject.ext.compileSdkVersion
+    buildToolsVersion rootProject.ext.buildToolsVersion
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode Integer.parseInt(project.VERSION_CODE)
+        versionName project.VERSION_NAME
+    }
+}
+
+dependencies {
+    compile rootProject.ext.rxJava2
+    compile rootProject.ext.autodispose
+
+    compile project(':conductor')
+}
+
+ext.artifactId = 'conductor-autodispose'

conductor-modules/autodispose/gradle.properties

@@ -0,0 +1,3 @@
+POM_NAME=Conductor AutoDispose Extensions
+POM_ARTIFACT_ID=conductor-autodispose
+POM_PACKAGING=aar

conductor-modules/autodispose/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest package="com.bluelinelabs.conductor.autodispose">
+    <application />
+</manifest>

conductor-modules/autodispose/src/main/java/com/bluelinelabs/conductor/autodispose/ControllerEvent.java

@@ -0,0 +1,14 @@
+package com.bluelinelabs.conductor.autodispose;
+
+public enum ControllerEvent {
+
+    CREATE,
+    CONTEXT_AVAILABLE,
+    CREATE_VIEW,
+    ATTACH,
+    DETACH,
+    DESTROY_VIEW,
+    CONTEXT_UNAVAILABLE,
+    DESTROY
+
+}

conductor-modules/autodispose/src/main/java/com/bluelinelabs/conductor/autodispose/ControllerLifecycleSubjectHelper.java

@@ -0,0 +1,71 @@
+package com.bluelinelabs.conductor.autodispose;
+
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.view.View;
+
+import com.bluelinelabs.conductor.Controller;
+import com.uber.autodispose.OutsideLifecycleException;
+
+import io.reactivex.subjects.BehaviorSubject;
+
+public class ControllerLifecycleSubjectHelper {
+    private ControllerLifecycleSubjectHelper() { }
+
+    @NonNull
+    public static BehaviorSubject<ControllerEvent> create(Controller controller) {
+        ControllerEvent initialState;
+        if (controller.isBeingDestroyed() || controller.isDestroyed()) {
+            throw new OutsideLifecycleException("Cannot bind to Controller lifecycle when outside of it.");
+        } else if (controller.isAttached()) {
+            initialState = ControllerEvent.ATTACH;
+        } else if (controller.getView() != null) {
+            initialState = ControllerEvent.CREATE_VIEW;
+        } else if (controller.getActivity() != null) {
+            initialState = ControllerEvent.CONTEXT_AVAILABLE;
+        } else {
+            initialState = ControllerEvent.CREATE;
+        }
+
+        final BehaviorSubject<ControllerEvent> subject = BehaviorSubject.createDefault(initialState);
+
+        controller.addLifecycleListener(new Controller.LifecycleListener() {
+            @Override
+            public void preContextAvailable(@NonNull Controller controller) {
+                subject.onNext(ControllerEvent.CONTEXT_AVAILABLE);
+            }
+
+            @Override
+            public void preCreateView(@NonNull Controller controller) {
+                subject.onNext(ControllerEvent.CREATE_VIEW);
+            }
+
+            @Override
+            public void preAttach(@NonNull Controller controller, @NonNull View view) {
+                subject.onNext(ControllerEvent.ATTACH);
+            }
+
+            @Override
+            public void preDetach(@NonNull Controller controller, @NonNull View view) {
+                subject.onNext(ControllerEvent.DETACH);
+            }
+
+            @Override
+            public void preDestroyView(@NonNull Controller controller, @NonNull View view) {
+                subject.onNext(ControllerEvent.DESTROY_VIEW);
+            }
+
+            @Override
+            public void preContextUnavailable(@NonNull Controller controller, @NonNull Context context) {
+                subject.onNext(ControllerEvent.CONTEXT_UNAVAILABLE);
+            }
+
+            @Override
+            public void preDestroy(@NonNull Controller controller) {
+                subject.onNext(ControllerEvent.DESTROY);
+            }
+        });
+
+        return subject;
+    }
+}

conductor-modules/autodispose/src/main/java/com/bluelinelabs/conductor/autodispose/ControllerScopeProvider.java

@@ -0,0 +1,59 @@
+package com.bluelinelabs.conductor.autodispose;
+
+import android.support.annotation.NonNull;
+
+import com.bluelinelabs.conductor.Controller;
+import com.uber.autodispose.LifecycleScopeProvider;
+import com.uber.autodispose.OutsideLifecycleException;
+
+import io.reactivex.Observable;
+import io.reactivex.functions.Function;
+import io.reactivex.subjects.BehaviorSubject;
+
+public class ControllerScopeProvider implements LifecycleScopeProvider<ControllerEvent> {
+    private static final Function<ControllerEvent, ControllerEvent> CORRESPONDING_EVENTS =
+            new Function<ControllerEvent, ControllerEvent>() {
+                @Override
+                public ControllerEvent apply(ControllerEvent lastEvent) throws Exception {
+                    switch (lastEvent) {
+                        case CREATE:
+                            return ControllerEvent.DESTROY;
+                        case CONTEXT_AVAILABLE:
+                            return ControllerEvent.CONTEXT_UNAVAILABLE;
+                        case CREATE_VIEW:
+                            return ControllerEvent.DESTROY_VIEW;
+                        case ATTACH:
+                            return ControllerEvent.DETACH;
+                        case DETACH:
+                            return ControllerEvent.DESTROY;
+                        default:
+                            throw new OutsideLifecycleException("Cannot bind to Controller lifecycle when outside of it.");
+                    }
+                }
+            };
+
+    @NonNull private final BehaviorSubject<ControllerEvent> lifecycleSubject;
+
+    public static ControllerScopeProvider from(@NonNull Controller controller) {
+        return new ControllerScopeProvider(controller);
+    }
+
+    private ControllerScopeProvider(@NonNull Controller controller) {
+        lifecycleSubject = ControllerLifecycleSubjectHelper.create(controller);
+    }
+
+    @Override
+    public Observable<ControllerEvent> lifecycle() {
+        return lifecycleSubject.hide();
+    }
+
+    @Override
+    public Function<ControllerEvent, ControllerEvent> correspondingEvents() {
+        return CORRESPONDING_EVENTS;
+    }
+
+    @Override
+    public ControllerEvent peekLifecycle() {
+        return lifecycleSubject.getValue();
+    }
+}

conductor-modules/rxlifecycle/build.gradle

@@ -7,10 +7,6 @@ android {
     compileSdkVersion rootProject.ext.compileSdkVersion
     buildToolsVersion rootProject.ext.buildToolsVersion
 
-    lintOptions {
-        abortOnError false
-    }
-
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_7
         targetCompatibility JavaVersion.VERSION_1_7
@@ -26,7 +22,6 @@ android {
 
 dependencies {
     compile rootProject.ext.rxJava
-    compile rootProject.ext.rxAndroid
     compile rootProject.ext.rxLifecycle
     compile rootProject.ext.rxLifecycleAndroid
 
@@ -34,4 +29,3 @@ dependencies {
 }
 
 ext.artifactId = 'conductor-rxlifecycle'
-

conductor-modules/rxlifecycle/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
 <manifest package="com.bluelinelabs.conductor.rxlifecycle">
     <application />
-</manifest>
+</manifest>

conductor-modules/rxlifecycle/src/main/java/com/bluelinelabs/conductor/rxlifecycle/ControllerEvent.java

@@ -3,10 +3,12 @@ package com.bluelinelabs.conductor.rxlifecycle;
 public enum ControllerEvent {
 
     CREATE,
+    CONTEXT_AVAILABLE,
     CREATE_VIEW,
     ATTACH,
     DETACH,
     DESTROY_VIEW,
+    CONTEXT_UNAVAILABLE,
     DESTROY
 
 }

conductor-modules/rxlifecycle/src/main/java/com/bluelinelabs/conductor/rxlifecycle/ControllerLifecycleSubjectHelper.java

@@ -1,10 +1,12 @@
 package com.bluelinelabs.conductor.rxlifecycle;
 
+import android.content.Context;
 import android.support.annotation.NonNull;
 import android.view.View;
 
 import com.bluelinelabs.conductor.Controller;
 import com.bluelinelabs.conductor.Controller.LifecycleListener;
+import com.trello.rxlifecycle.OutsideLifecycleException;
 
 import rx.subjects.BehaviorSubject;
 
@@ -17,9 +19,27 @@ public class ControllerLifecycleSubjectHelper {
     private ControllerLifecycleSubjectHelper() { }
 
     public static BehaviorSubject<ControllerEvent> create(Controller controller) {
-        final BehaviorSubject<ControllerEvent> subject = BehaviorSubject.create(ControllerEvent.CREATE);
+        ControllerEvent initialState;
+        if (controller.isBeingDestroyed() || controller.isDestroyed()) {
+            throw new OutsideLifecycleException("Cannot bind to Controller lifecycle when outside of it.");
+        } else if (controller.isAttached()) {
+            initialState = ControllerEvent.ATTACH;
+        } else if (controller.getView() != null) {
+            initialState = ControllerEvent.CREATE_VIEW;
+        } else if (controller.getActivity() != null) {
+            initialState = ControllerEvent.CONTEXT_AVAILABLE;
+        } else {
+            initialState = ControllerEvent.CREATE;
+        }
+
+        final BehaviorSubject<ControllerEvent> subject = BehaviorSubject.create(initialState);
 
         controller.addLifecycleListener(new LifecycleListener() {
+            @Override
+            public void preContextAvailable(@NonNull Controller controller) {
+                subject.onNext(ControllerEvent.CONTEXT_AVAILABLE);
+            }
+
             @Override
             public void preCreateView(@NonNull Controller controller) {
                 subject.onNext(ControllerEvent.CREATE_VIEW);
@@ -40,6 +60,11 @@ public class ControllerLifecycleSubjectHelper {
                 subject.onNext(ControllerEvent.DESTROY_VIEW);
             }
 
+            @Override
+            public void preContextUnavailable(@NonNull Controller controller, @NonNull Context context) {
+                subject.onNext(ControllerEvent.CONTEXT_UNAVAILABLE);
+            }
+
             @Override
             public void preDestroy(@NonNull Controller controller) {
                 subject.onNext(ControllerEvent.DESTROY);

conductor-modules/rxlifecycle/src/main/java/com/bluelinelabs/conductor/rxlifecycle/RxController.java

@@ -49,4 +49,4 @@ public abstract class RxController extends Controller implements LifecycleProvid
         return RxControllerLifecycle.bindController(lifecycleSubject);
     }
 
-}
+}

conductor-modules/rxlifecycle/src/main/java/com/bluelinelabs/conductor/rxlifecycle/RxControllerLifecycle.java

@@ -17,7 +17,7 @@ public class RxControllerLifecycle {
      * {@link com.trello.rxlifecycle.android.RxLifecycleAndroid#bindFragment(Observable)}.
      *
      * @param lifecycle the lifecycle sequence of a Controller
-     * @return a reusable {@link Observable.Transformer} that unsubscribes the source during the Controller lifecycle
+     * @return a reusable {@link rx.Observable.Transformer} that unsubscribes the source during the Controller lifecycle
      */
     @NonNull
     @CheckResult
@@ -32,6 +32,8 @@ public class RxControllerLifecycle {
                     switch (lastEvent) {
                         case CREATE:
                             return ControllerEvent.DESTROY;
+                        case CONTEXT_AVAILABLE:
+                            return ControllerEvent.CONTEXT_UNAVAILABLE;
                         case ATTACH:
                             return ControllerEvent.DETACH;
                         case CREATE_VIEW:

conductor-modules/rxlifecycle/src/main/java/com/bluelinelabs/conductor/rxlifecycle/RxRestoreViewOnCreateController.java

@@ -49,4 +49,4 @@ public abstract class RxRestoreViewOnCreateController extends RestoreViewOnCreat
         return RxControllerLifecycle.bindController(lifecycleSubject);
     }
 
-}
+}

conductor-modules/rxlifecycle2/build.gradle

@@ -7,10 +7,6 @@ android {
     compileSdkVersion rootProject.ext.compileSdkVersion
     buildToolsVersion rootProject.ext.buildToolsVersion
 
-    lintOptions {
-        abortOnError false
-    }
-
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_7
         targetCompatibility JavaVersion.VERSION_1_7

conductor-modules/rxlifecycle2/src/main/AndroidManifest.xml

@@ -1,4 +1,3 @@
 <manifest package="com.bluelinelabs.conductor.rxlifecycle2">
     <application />
 </manifest>
-

conductor-modules/rxlifecycle2/src/main/java/com/bluelinelabs/conductor/rxlifecycle2/ControllerEvent.java

@@ -3,10 +3,12 @@ package com.bluelinelabs.conductor.rxlifecycle2;
 public enum ControllerEvent {
 
     CREATE,
+    CONTEXT_AVAILABLE,
     CREATE_VIEW,
     ATTACH,
     DETACH,
     DESTROY_VIEW,
+    CONTEXT_UNAVAILABLE,
     DESTROY
 
 }

conductor-modules/rxlifecycle2/src/main/java/com/bluelinelabs/conductor/rxlifecycle2/ControllerLifecycleSubjectHelper.java

@@ -1,18 +1,40 @@
 package com.bluelinelabs.conductor.rxlifecycle2;
 
+import android.content.Context;
 import android.support.annotation.NonNull;
 import android.view.View;
+
 import com.bluelinelabs.conductor.Controller;
+import com.trello.rxlifecycle2.OutsideLifecycleException;
+
 import io.reactivex.subjects.BehaviorSubject;
 
 public class ControllerLifecycleSubjectHelper {
     private ControllerLifecycleSubjectHelper() {
     }
 
-    public static BehaviorSubject<ControllerEvent> create(Controller controller){
-        final BehaviorSubject<ControllerEvent> subject = BehaviorSubject.createDefault(ControllerEvent.CREATE);
+    public static BehaviorSubject<ControllerEvent> create(Controller controller) {
+        ControllerEvent initialState;
+        if (controller.isBeingDestroyed() || controller.isDestroyed()) {
+            throw new OutsideLifecycleException("Cannot bind to Controller lifecycle when outside of it.");
+        } else if (controller.isAttached()) {
+            initialState = ControllerEvent.ATTACH;
+        } else if (controller.getView() != null) {
+            initialState = ControllerEvent.CREATE_VIEW;
+        } else if (controller.getActivity() != null) {
+            initialState = ControllerEvent.CONTEXT_AVAILABLE;
+        } else {
+            initialState = ControllerEvent.CREATE;
+        }
+
+        final BehaviorSubject<ControllerEvent> subject = BehaviorSubject.createDefault(initialState);
 
         controller.addLifecycleListener(new Controller.LifecycleListener() {
+            @Override
+            public void preContextAvailable(@NonNull Controller controller) {
+                subject.onNext(ControllerEvent.CONTEXT_AVAILABLE);
+            }
+
             @Override
             public void preCreateView(@NonNull Controller controller) {
                 subject.onNext(ControllerEvent.CREATE_VIEW);
@@ -33,6 +55,11 @@ public class ControllerLifecycleSubjectHelper {
                 subject.onNext(ControllerEvent.DESTROY_VIEW);
             }
 
+            @Override
+            public void preContextUnavailable(@NonNull Controller controller, @NonNull Context context) {
+                subject.onNext(ControllerEvent.CONTEXT_UNAVAILABLE);
+            }
+
             @Override
             public void preDestroy(@NonNull Controller controller) {
                 subject.onNext(ControllerEvent.DESTROY);

conductor-modules/rxlifecycle2/src/main/java/com/bluelinelabs/conductor/rxlifecycle2/RxControllerLifecycle.java

@@ -27,6 +27,8 @@ public class RxControllerLifecycle {
                 switch (lastEvent) {
                     case CREATE:
                         return ControllerEvent.DESTROY;
+                    case CONTEXT_AVAILABLE:
+                        return ControllerEvent.CONTEXT_UNAVAILABLE;
                     case ATTACH:
                         return ControllerEvent.DETACH;
                     case CREATE_VIEW:

conductor-modules/support/build.gradle

@@ -0,0 +1,48 @@
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'de.mobilej.unmock:UnMockPlugin:0.6.0'
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'de.mobilej.unmock'
+
+android {
+    compileSdkVersion rootProject.ext.compileSdkVersion
+    buildToolsVersion rootProject.ext.buildToolsVersion
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode Integer.parseInt(project.VERSION_CODE)
+        versionName project.VERSION_NAME
+    }
+}
+
+dependencies {
+    testCompile rootProject.ext.junit
+    testCompile rootProject.ext.roboelectric
+
+    compile rootProject.ext.supportAppCompat
+    compile project(':conductor')
+
+    unmock 'org.robolectric:android-all:4.3_r2-robolectric-0'
+}
+
+unMock {
+    keep "android.os.Bundle"
+    keep "android.os.BaseBundle"
+}
+
+ext.artifactId = 'conductor-support'
+
+apply from: rootProject.file('dependencies.gradle')
+apply from: rootProject.file('gradle-mvn-push.gradle')

conductor-modules/support/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
 <manifest package="com.bluelinelabs.conductor.support">
     <application />
-</manifest>
+</manifest>

conductor-modules/support/src/main/java/com/bluelinelabs/conductor/support/ControllerPagerAdapter.java

@@ -2,6 +2,7 @@ package com.bluelinelabs.conductor.support;
 
 import android.os.Bundle;
 import android.os.Parcelable;
+import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v4.view.PagerAdapter;
 import android.util.SparseArray;
@@ -13,8 +14,12 @@ import com.bluelinelabs.conductor.Router;
 import com.bluelinelabs.conductor.RouterTransaction;
 
 /**
+ * @deprecated Use RouterPagerAdapter instead! This implementation was too limited and had too many
+ * gotchas associated with it.
+ *
  * An adapter for ViewPagers that will handle adding and removing Controllers
  */
+@Deprecated
 public abstract class ControllerPagerAdapter extends PagerAdapter {
 
     private static final String KEY_SAVED_PAGES = "ControllerPagerAdapter.savedStates";
@@ -30,7 +35,7 @@ public abstract class ControllerPagerAdapter extends PagerAdapter {
     /**
      * Creates a new ControllerPagerAdapter using the passed host.
      */
-    public ControllerPagerAdapter(Controller host, boolean saveControllerState) {
+    public ControllerPagerAdapter(@NonNull Controller host, boolean saveControllerState) {
         this.host = host;
         savesState = saveControllerState;
     }
@@ -38,6 +43,7 @@ public abstract class ControllerPagerAdapter extends PagerAdapter {
     /**
      * Return the Controller associated with a specified position.
      */
+    @NonNull
     public abstract Controller getItem(int position);
 
     @Override
@@ -53,12 +59,17 @@ public abstract class ControllerPagerAdapter extends PagerAdapter {
             }
         }
 
+        final Controller controller;
         if (!router.hasRootController()) {
-            Controller controller = getItem(position);
+            controller = getItem(position);
             router.setRoot(RouterTransaction.with(controller).tag(name));
-            visiblePageIds.put(position, controller.getInstanceId());
         } else {
             router.rebindIfNeeded();
+            controller = router.getControllerWithTag(name);
+        }
+
+        if (controller != null) {
+            visiblePageIds.put(position, controller.getInstanceId());
         }
 
         return router.getControllerWithTag(name);
@@ -119,7 +130,8 @@ public abstract class ControllerPagerAdapter extends PagerAdapter {
     }
 
     /**
-     * Returns the already instantiated Controller in the specified position, if available.
+     * Returns the already instantiated Controller in the specified position or {@code null} if
+     * this position does not yet have a controller.
      */
     @Nullable
     public Controller getController(int position) {
@@ -139,4 +151,4 @@ public abstract class ControllerPagerAdapter extends PagerAdapter {
         return viewId + ":" + id;
     }
 
-}
+}

conductor-modules/support/src/main/java/com/bluelinelabs/conductor/support/RouterPagerAdapter.java

@@ -2,6 +2,7 @@ package com.bluelinelabs.conductor.support;
 
 import android.os.Bundle;
 import android.os.Parcelable;
+import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v4.view.PagerAdapter;
 import android.util.SparseArray;
@@ -12,6 +13,7 @@ import com.bluelinelabs.conductor.Controller;
 import com.bluelinelabs.conductor.Router;
 import com.bluelinelabs.conductor.RouterTransaction;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -20,15 +22,19 @@ import java.util.List;
 public abstract class RouterPagerAdapter extends PagerAdapter {
 
     private static final String KEY_SAVED_PAGES = "RouterPagerAdapter.savedStates";
+    private static final String KEY_MAX_PAGES_TO_STATE_SAVE = "RouterPagerAdapter.maxPagesToStateSave";
+    private static final String KEY_SAVE_PAGE_HISTORY = "RouterPagerAdapter.savedPageHistory";
 
     private final Controller host;
+    private int maxPagesToStateSave = Integer.MAX_VALUE;
     private SparseArray<Bundle> savedPages = new SparseArray<>();
     private SparseArray<Router> visibleRouters = new SparseArray<>();
+    private ArrayList<Integer> savedPageHistory = new ArrayList<>();
 
     /**
      * Creates a new RouterPagerAdapter using the passed host.
      */
-    public RouterPagerAdapter(Controller host) {
+    public RouterPagerAdapter(@NonNull Controller host) {
         this.host = host;
     }
 
@@ -38,7 +44,21 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
      * @param router   The router used for the page
      * @param position The page position to be instantiated.
      */
-    public abstract void configureRouter(Router router, int position);
+    public abstract void configureRouter(@NonNull Router router, int position);
+
+    /**
+     * Sets the maximum number of pages that will have their states saved. When this number is exceeded,
+     * the page that was state saved least recently will have its state removed from the save data.
+     */
+    public void setMaxPagesToStateSave(int maxPagesToStateSave) {
+        if (maxPagesToStateSave < 0) {
+            throw new IllegalArgumentException("Only positive integers may be passed for maxPagesToStateSave.");
+        }
+
+        this.maxPagesToStateSave = maxPagesToStateSave;
+
+        ensurePagesSaved();
+    }
 
     @Override
     public Object instantiateItem(ViewGroup container, int position) {
@@ -50,6 +70,7 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
 
             if (routerSavedState != null) {
                 router.restoreInstanceState(routerSavedState);
+                savedPages.remove(position);
             }
         }
 
@@ -68,6 +89,11 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
         router.saveInstanceState(savedState);
         savedPages.put(position, savedState);
 
+        savedPageHistory.remove((Integer)position);
+        savedPageHistory.add(position);
+
+        ensurePagesSaved();
+
         host.removeChildRouter(router);
 
         visibleRouters.remove(position);
@@ -89,6 +115,8 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
     public Parcelable saveState() {
         Bundle bundle = new Bundle();
         bundle.putSparseParcelableArray(KEY_SAVED_PAGES, savedPages);
+        bundle.putInt(KEY_MAX_PAGES_TO_STATE_SAVE, maxPagesToStateSave);
+        bundle.putIntegerArrayList(KEY_SAVE_PAGE_HISTORY, savedPageHistory);
         return bundle;
     }
 
@@ -97,11 +125,14 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
         Bundle bundle = (Bundle)state;
         if (state != null) {
             savedPages = bundle.getSparseParcelableArray(KEY_SAVED_PAGES);
+            maxPagesToStateSave = bundle.getInt(KEY_MAX_PAGES_TO_STATE_SAVE);
+            savedPageHistory = bundle.getIntegerArrayList(KEY_SAVE_PAGE_HISTORY);
         }
     }
 
     /**
-     * Returns the already instantiated Router in the specified position, if available.
+     * Returns the already instantiated Router in the specified position or {@code null} if there
+     * is no router associated with this position.
      */
     @Nullable
     public Router getRouter(int position) {
@@ -112,8 +143,19 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
         return position;
     }
 
+    SparseArray<Bundle> getSavedPages() {
+        return savedPages;
+    }
+
+    private void ensurePagesSaved() {
+        while (savedPages.size() > maxPagesToStateSave) {
+            int positionToRemove = savedPageHistory.remove(0);
+            savedPages.remove(positionToRemove);
+        }
+    }
+
     private static String makeRouterName(int viewId, long id) {
         return viewId + ":" + id;
     }
 
-}
+}

conductor-modules/support/src/test/java/com/bluelinelabs/conductor/support/StateSaveTests.java

@@ -0,0 +1,113 @@
+package com.bluelinelabs.conductor.support;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.util.SparseArray;
+import android.widget.FrameLayout;
+
+import com.bluelinelabs.conductor.Conductor;
+import com.bluelinelabs.conductor.Router;
+import com.bluelinelabs.conductor.RouterTransaction;
+import com.bluelinelabs.conductor.support.util.FakePager;
+import com.bluelinelabs.conductor.support.util.TestController;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+import org.robolectric.util.ActivityController;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class StateSaveTests {
+
+    private FakePager pager;
+    private RouterPagerAdapter pagerAdapter;
+
+    public void createActivityController(Bundle savedInstanceState) {
+        ActivityController<Activity> activityController = Robolectric.buildActivity(Activity.class).create().start().resume();
+        Router router = Conductor.attachRouter(activityController.get(), new FrameLayout(activityController.get()), savedInstanceState);
+        TestController controller = new TestController();
+        router.setRoot(RouterTransaction.with(controller));
+
+        pager = new FakePager(new FrameLayout(activityController.get()));
+        pager.setOffscreenPageLimit(1);
+
+        pagerAdapter = new RouterPagerAdapter(controller) {
+            @Override
+            public void configureRouter(@NonNull Router router, int position) {
+                if (!router.hasRootController()) {
+                    router.setRoot(RouterTransaction.with(new TestController()));
+                }
+            }
+
+            @Override
+            public int getCount() {
+                return 20;
+            }
+        };
+
+        pager.setAdapter(pagerAdapter);
+    }
+
+    @Before
+    public void setup() {
+        createActivityController(null);
+    }
+
+    @Test
+    public void testNoMaxSaves() {
+        // Load all pages
+        for (int i = 0; i < pagerAdapter.getCount(); i++) {
+            pager.pageTo(i);
+        }
+
+        pager.pageTo(pagerAdapter.getCount() / 2);
+
+        // Ensure all non-visible pages are saved
+        assertEquals(pagerAdapter.getCount() - 1 - pager.getOffscreenPageLimit() * 2, pagerAdapter.getSavedPages().size());
+    }
+
+    @Test
+    public void testMaxSavedSet() {
+        final int maxPages = 3;
+        pagerAdapter.setMaxPagesToStateSave(maxPages);
+
+        // Load all pages
+        for (int i = 0; i < pagerAdapter.getCount(); i++) {
+            pager.pageTo(i);
+        }
+
+        final int firstSelectedItem = pagerAdapter.getCount() / 2;
+        pager.pageTo(firstSelectedItem);
+
+        SparseArray<Bundle> savedPages = pagerAdapter.getSavedPages();
+
+        // Ensure correct number of pages are saved
+        assertEquals(maxPages, savedPages.size());
+
+        // Ensure correct pages are saved
+        assertEquals(pagerAdapter.getCount() - 3, savedPages.keyAt(0));
+        assertEquals(pagerAdapter.getCount() - 2, savedPages.keyAt(1));
+        assertEquals(pagerAdapter.getCount() - 1, savedPages.keyAt(2));
+
+        final int secondSelectedItem = 1;
+        pager.pageTo(secondSelectedItem);
+
+        savedPages = pagerAdapter.getSavedPages();
+
+        // Ensure correct number of pages are saved
+        assertEquals(maxPages, savedPages.size());
+
+        // Ensure correct pages are saved
+        assertEquals(firstSelectedItem - 1, savedPages.keyAt(0));
+        assertEquals(firstSelectedItem, savedPages.keyAt(1));
+        assertEquals(firstSelectedItem + 1, savedPages.keyAt(2));
+    }
+
+}

conductor-modules/support/src/test/java/com/bluelinelabs/conductor/support/util/FakePager.java

@@ -0,0 +1,61 @@
+package com.bluelinelabs.conductor.support.util;
+
+import android.util.SparseArray;
+import android.view.ViewGroup;
+
+import com.bluelinelabs.conductor.support.RouterPagerAdapter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FakePager {
+
+    private ViewGroup container;
+    private int offscreenPageLimit;
+    private final SparseArray<Object> pages = new SparseArray<>();
+
+    private RouterPagerAdapter adapter;
+
+    public FakePager(ViewGroup container) {
+        this.container = container;
+    }
+
+    public void setAdapter(RouterPagerAdapter adapter) {
+        this.adapter = adapter;
+    }
+
+    public void pageTo(int page) {
+        int firstPage = Math.max(0, page - offscreenPageLimit);
+        int lastPage = Math.min(adapter.getCount() - 1, page + offscreenPageLimit);
+
+        List<Integer> pagesI = new ArrayList<>();
+        for (int i = 0; i < pages.size(); i++) {
+            pagesI.add(pages.keyAt(i));
+        }
+
+        for (int i = pages.size() - 1; i >= 0; i--) {
+            int key = pages.keyAt(i);
+
+            if (key < firstPage || key > lastPage) {
+                adapter.destroyItem(container, key, pages.get(key));
+                pages.remove(key);
+            }
+        }
+
+        for (int key = firstPage; key <= lastPage; key++) {
+            if (pages.get(key) == null) {
+                pages.put(key, adapter.instantiateItem(container, key));
+            }
+        }
+
+        adapter.setPrimaryItem(container, page, pages.get(page));
+    }
+
+    public int getOffscreenPageLimit() {
+        return offscreenPageLimit;
+    }
+
+    public void setOffscreenPageLimit(int offscreenPageLimit) {
+        this.offscreenPageLimit = offscreenPageLimit;
+    }
+}

conductor-modules/support/src/test/java/com/bluelinelabs/conductor/support/util/TestController.java

@@ -0,0 +1,18 @@
+package com.bluelinelabs.conductor.support.util;
+
+import android.support.annotation.NonNull;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+
+import com.bluelinelabs.conductor.Controller;
+
+public class TestController extends Controller {
+
+    @NonNull @Override
+    protected View onCreateView(@NonNull LayoutInflater inflater, @NonNull ViewGroup container) {
+        return new FrameLayout(inflater.getContext());
+    }
+
+}

conductor/build.gradle

@@ -3,7 +3,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'de.mobilej.unmock:UnMockPlugin:0.3.6'
+        classpath 'de.mobilej.unmock:UnMockPlugin:0.6.0'
     }
 }
 
@@ -14,10 +14,6 @@ android {
     compileSdkVersion rootProject.ext.compileSdkVersion
     buildToolsVersion rootProject.ext.buildToolsVersion
 
-    lintOptions {
-        abortOnError false
-    }
-
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_7
         targetCompatibility JavaVersion.VERSION_1_7
@@ -43,11 +39,11 @@ dependencies {
     compile rootProject.ext.supportAnnotations
 
     lintChecks project(path: ':conductor-lint', configuration: 'lintChecks')
+
+    unmock 'org.robolectric:android-all:4.3_r2-robolectric-0'
 }
 
 unMock {
-    downloadFrom 'https://oss.sonatype.org/content/groups/public/org/robolectric/android-all/4.3_r2-robolectric-0/android-all-4.3_r2-robolectric-0.jar'
-
     keep "android.os.Bundle"
     keep "android.os.BaseBundle"
     keep "android.text.TextUtils"

conductor/proguard-rules.txt

@@ -2,4 +2,4 @@
 -keepclassmembers public class * extends com.bluelinelabs.conductor.Controller {
    public <init>();
    public <init>(android.os.Bundle);
-}
+}

conductor/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
 <manifest package="com.bluelinelabs.conductor">
     <application />
-</manifest>
+</manifest>

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

@@ -2,6 +2,8 @@ package com.bluelinelabs.conductor;
 
 import android.app.Activity;
 import android.content.Intent;
+import android.content.IntentSender;
+import android.content.IntentSender.SendIntentException;
 import android.os.Bundle;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
@@ -9,12 +11,14 @@ import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.ControllerChangeHandler.ControllerChangeListener;
 import com.bluelinelabs.conductor.internal.LifecycleHandler;
+import com.bluelinelabs.conductor.internal.TransactionIndexer;
 
 import java.util.List;
 
 public class ActivityHostedRouter extends Router {
 
     private LifecycleHandler lifecycleHandler;
+    private final TransactionIndexer transactionIndexer = new TransactionIndexer();
 
     public final void setHost(@NonNull LifecycleHandler lifecycleHandler, @NonNull ViewGroup container) {
         if (this.lifecycleHandler != lifecycleHandler || this.container != container) {
@@ -28,9 +32,25 @@ public class ActivityHostedRouter extends Router {
 
             this.lifecycleHandler = lifecycleHandler;
             this.container = container;
+
+            watchContainerAttach();
         }
     }
 
+    @Override
+    public void saveInstanceState(@NonNull Bundle outState) {
+        super.saveInstanceState(outState);
+
+        transactionIndexer.saveInstanceState(outState);
+    }
+
+    @Override
+    public void restoreInstanceState(@NonNull Bundle savedInstanceState) {
+        super.restoreInstanceState(savedInstanceState);
+
+        transactionIndexer.restoreInstanceState(savedInstanceState);
+    }
+
     @Override @Nullable
     public Activity getActivity() {
         return lifecycleHandler != null ? lifecycleHandler.getLifecycleActivity() : null;
@@ -69,6 +89,12 @@ public class ActivityHostedRouter extends Router {
         lifecycleHandler.startActivityForResult(instanceId, intent, requestCode, options);
     }
 
+    @Override
+    void startIntentSenderForResult(@NonNull String instanceId, @NonNull IntentSender intent, int requestCode, @Nullable Intent fillInIntent,
+                                    int flagsMask, int flagsValues, int extraFlags, @Nullable Bundle options) throws SendIntentException {
+        lifecycleHandler.startIntentSenderForResult(instanceId, intent, requestCode, fillInIntent, flagsMask, flagsValues, extraFlags, options);
+    }
+
     @Override
     void registerForActivityResult(@NonNull String instanceId, int requestCode) {
         lifecycleHandler.registerForActivityResult(instanceId, requestCode);
@@ -98,4 +124,15 @@ public class ActivityHostedRouter extends Router {
     Router getRootRouter() {
         return this;
     }
+
+    @Override @Nullable
+    TransactionIndexer getTransactionIndexer() {
+        return transactionIndexer;
+    }
+
+    @Override
+    public void onContextAvailable() {
+        super.onContextAvailable();
+    }
+
 }

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

@@ -18,16 +18,16 @@ class Backstack implements Iterable<RouterTransaction> {
     private final Deque<RouterTransaction> backstack = new ArrayDeque<>();
 
     @SuppressWarnings("BooleanMethodIsAlwaysInverted")
-    public boolean isEmpty() {
+    boolean isEmpty() {
         return backstack.isEmpty();
     }
 
-    public int size() {
+    int size() {
         return backstack.size();
     }
 
     @Nullable
-    public RouterTransaction root() {
+    RouterTransaction root() {
         return backstack.size() > 0 ? backstack.getLast() : null;
     }
 
@@ -37,12 +37,12 @@ class Backstack implements Iterable<RouterTransaction> {
     }
 
     @NonNull
-    public Iterator<RouterTransaction> reverseIterator() {
+    Iterator<RouterTransaction> reverseIterator() {
         return backstack.descendingIterator();
     }
 
     @NonNull
-    public List<RouterTransaction> popTo(@NonNull RouterTransaction transaction) {
+    List<RouterTransaction> popTo(@NonNull RouterTransaction transaction) {
         List<RouterTransaction> popped = new ArrayList<>();
         if (backstack.contains(transaction)) {
             while (backstack.peek() != transaction) {
@@ -56,27 +56,27 @@ class Backstack implements Iterable<RouterTransaction> {
     }
 
     @NonNull
-    public RouterTransaction pop() {
+    RouterTransaction pop() {
         RouterTransaction popped = backstack.pop();
         popped.controller.destroy();
         return popped;
     }
 
     @Nullable
-    public RouterTransaction peek() {
+    RouterTransaction peek() {
         return backstack.peek();
     }
 
-    public void remove(@NonNull RouterTransaction transaction) {
+    void remove(@NonNull RouterTransaction transaction) {
         backstack.removeFirstOccurrence(transaction);
     }
 
-    public void push(@NonNull RouterTransaction transaction) {
+    void push(@NonNull RouterTransaction transaction) {
         backstack.push(transaction);
     }
 
     @NonNull
-    public List<RouterTransaction> popAll() {
+    List<RouterTransaction> popAll() {
         List<RouterTransaction> list = new ArrayList<>();
         while (!isEmpty()) {
             list.add(pop());
@@ -84,7 +84,7 @@ class Backstack implements Iterable<RouterTransaction> {
         return list;
     }
 
-    public void setBackstack(@NonNull List<RouterTransaction> backstack) {
+    void setBackstack(@NonNull List<RouterTransaction> backstack) {
         for (RouterTransaction existingTransaction : this.backstack) {
             boolean contains = false;
             for (RouterTransaction newTransaction : backstack) {
@@ -105,7 +105,11 @@ class Backstack implements Iterable<RouterTransaction> {
         }
     }
 
-    public void saveInstanceState(@NonNull Bundle outState) {
+    boolean contains(@NonNull RouterTransaction transaction) {
+        return backstack.contains(transaction);
+    }
+
+    void saveInstanceState(@NonNull Bundle outState) {
         ArrayList<Bundle> entryBundles = new ArrayList<>(backstack.size());
         for (RouterTransaction entry : backstack) {
             entryBundles.add(entry.saveInstanceState());
@@ -114,7 +118,7 @@ class Backstack implements Iterable<RouterTransaction> {
         outState.putParcelableArrayList(KEY_ENTRIES, entryBundles);
     }
 
-    public void restoreInstanceState(@NonNull Bundle savedInstanceState) {
+    void restoreInstanceState(@NonNull Bundle savedInstanceState) {
         ArrayList<Bundle> entryBundles = savedInstanceState.getParcelableArrayList(KEY_ENTRIES);
         if (entryBundles != null) {
             Collections.reverse(entryBundles);

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

@@ -8,14 +8,15 @@ import android.support.annotation.UiThread;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.internal.LifecycleHandler;
+import com.bluelinelabs.conductor.internal.ThreadUtils;
 
 /**
  * Point of initial interaction with Conductor. Used to attach a {@link Router} to your Activity.
  */
 public final class Conductor {
-    
+
     private Conductor() {}
-    
+
     /**
      * Conductor will create a {@link Router} that has been initialized for your Activity and containing ViewGroup.
      * If an existing {@link Router} is already associated with this Activity/ViewGroup pair, either in memory
@@ -30,6 +31,8 @@ public final class Conductor {
      */
     @NonNull @UiThread
     public static Router attachRouter(@NonNull Activity activity, @NonNull ViewGroup container, @Nullable Bundle savedInstanceState) {
+        ThreadUtils.ensureMainThread();
+
         LifecycleHandler lifecycleHandler = LifecycleHandler.install(activity);
 
         Router router = lifecycleHandler.getRouter(container, savedInstanceState);

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

@@ -4,6 +4,7 @@ import android.annotation.TargetApi;
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
+import android.content.IntentSender;
 import android.content.res.Resources;
 import android.os.Build;
 import android.os.Bundle;
@@ -18,18 +19,19 @@ import android.view.Menu;
 import android.view.MenuInflater;
 import android.view.MenuItem;
 import android.view.View;
-import android.view.View.OnAttachStateChangeListener;
 import android.view.ViewGroup;
 
-import com.bluelinelabs.conductor.Router.OnControllerPushedListener;
 import com.bluelinelabs.conductor.internal.ClassUtils;
 import com.bluelinelabs.conductor.internal.RouterRequiringFunc;
+import com.bluelinelabs.conductor.internal.ViewAttachHandler;
+import com.bluelinelabs.conductor.internal.ViewAttachHandler.ViewAttachListener;
 
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.LinkedList;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.List;
 import java.util.UUID;
 
@@ -44,7 +46,6 @@ public abstract class Controller {
     private static final String KEY_CLASS_NAME = "Controller.className";
     private static final String KEY_VIEW_STATE = "Controller.viewState";
     private static final String KEY_CHILD_ROUTERS = "Controller.childRouters";
-    private static final String KEY_CHILD_BACKSTACK = "Controller.childBackstack";
     private static final String KEY_SAVED_STATE = "Controller.savedState";
     private static final String KEY_INSTANCE_ID = "Controller.instanceId";
     private static final String KEY_TARGET_INSTANCE_ID = "Controller.target.instanceId";
@@ -54,7 +55,7 @@ public abstract class Controller {
     private static final String KEY_OVERRIDDEN_PUSH_HANDLER = "Controller.overriddenPushHandler";
     private static final String KEY_OVERRIDDEN_POP_HANDLER = "Controller.overriddenPopHandler";
     private static final String KEY_VIEW_STATE_HIERARCHY = "Controller.viewState.hierarchy";
-    private static final String KEY_VIEW_STATE_BUNDLE = "Controller.viewState.bundle";
+    static final String KEY_VIEW_STATE_BUNDLE = "Controller.viewState.bundle";
     private static final String KEY_RETAIN_VIEW_MODE = "Controller.retainViewMode";
 
     private final Bundle args;
@@ -80,35 +81,40 @@ public abstract class Controller {
     private ControllerChangeHandler overriddenPushHandler;
     private ControllerChangeHandler overriddenPopHandler;
     private RetainViewMode retainViewMode = RetainViewMode.RELEASE_DETACH;
-    private OnAttachStateChangeListener onAttachStateChangeListener;
+    private ViewAttachHandler viewAttachHandler;
     private final List<ControllerHostedRouter> childRouters = new ArrayList<>();
     private final List<LifecycleListener> lifecycleListeners = new ArrayList<>();
     private final ArrayList<String> requestedPermissions = new ArrayList<>();
     private final ArrayList<RouterRequiringFunc> onRouterSetListeners = new ArrayList<>();
-    private final List<Controller> childBackstack = new LinkedList<>();
     private WeakReference<View> destroyedView;
-
-    private final OnControllerPushedListener onControllerPushedListener = new OnControllerPushedListener() {
-        @Override
-        public void onControllerPushed(Controller controller) {
-            onChildControllerPushed(controller);
-        }
-    };
+    private boolean isPerformingExitTransition;
+    private boolean isContextAvailable;
 
     @NonNull
     static Controller newInstance(@NonNull Bundle bundle) {
         final String className = bundle.getString(KEY_CLASS_NAME);
         //noinspection ConstantConditions
-        Constructor[] constructors = ClassUtils.classForName(className, false).getConstructors();
+        Class cls = ClassUtils.classForName(className, false);
+        Constructor[] constructors = cls.getConstructors();
         Constructor bundleConstructor = getBundleConstructor(constructors);
 
+        Bundle args = bundle.getBundle(KEY_ARGS);
+        if (args != null) {
+            args.setClassLoader(cls.getClassLoader());
+        }
+
         Controller controller;
         try {
             if (bundleConstructor != null) {
-                controller = (Controller)bundleConstructor.newInstance(bundle.getBundle(KEY_ARGS));
+                controller = (Controller)bundleConstructor.newInstance(args);
             } else {
                 //noinspection ConstantConditions
                 controller = (Controller)getDefaultConstructor(constructors).newInstance();
+
+                // Restore the args that existed before the last process death
+                if (args != null) {
+                    controller.args.putAll(args);
+                }
             }
         } catch (Exception e) {
             throw new RuntimeException("An exception occurred while creating a new instance of " + className + ". " + e.getMessage(), e);
@@ -131,7 +137,7 @@ public abstract class Controller {
      * @param args Any arguments that need to be retained.
      */
     protected Controller(@Nullable Bundle args) {
-        this.args = args != null ? args : new Bundle();
+        this.args = args != null ? args : new Bundle(getClass().getClassLoader());
         instanceId = UUID.randomUUID().toString();
         ensureRequiredConstructor();
     }
@@ -182,7 +188,7 @@ public abstract class Controller {
      * the same container unless you have a great reason to do so (ex: ViewPagers).
      *
      * @param container The ViewGroup that hosts the child Router
-     * @param tag The router's tag
+     * @param tag The router's tag or {@code null} if none is needed
      */
     @NonNull
     public final Router getChildRouter(@NonNull ViewGroup container, @Nullable String tag) {
@@ -194,10 +200,12 @@ public abstract class Controller {
      * Retrieves the child {@link Router} for the given container/tag combination. Note that multiple
      * routers should not exist in the same container unless a lot of care is taken to maintain order
      * between them. Avoid using the same container unless you have a great reason to do so (ex: ViewPagers).
+     * The only time this method will return {@code null} is when the child router does not exist prior
+     * to calling this method and the createIfNeeded parameter is set to false.
      *
      * @param container The ViewGroup that hosts the child Router
-     * @param tag The router's tag
-     * @param createIfNeeded If true, a router will be created if one does not yet exist. Else false will be returned in this case.
+     * @param tag The router's tag or {@code null} if none is needed
+     * @param createIfNeeded If true, a router will be created if one does not yet exist. Else {@code null} will be returned in this case.
      */
     @Nullable
     public final Router getChildRouter(@NonNull ViewGroup container, @Nullable String tag, boolean createIfNeeded) {
@@ -214,22 +222,30 @@ public abstract class Controller {
         if (childRouter == null) {
             if (createIfNeeded) {
                 childRouter = new ControllerHostedRouter(container.getId(), tag);
-                monitorChildRouter(childRouter);
                 childRouter.setHost(this, container);
                 childRouters.add(childRouter);
+
+                if (isPerformingExitTransition) {
+                    childRouter.setDetachFrozen(true);
+                }
             }
         } else if (!childRouter.hasHost()) {
             childRouter.setHost(this, container);
-            monitorChildRouter(childRouter);
             childRouter.rebindIfNeeded();
         }
 
         return childRouter;
     }
 
+    /**
+     * Removes a child {@link Router} from this Controller. When removed, all Controllers currently managed by
+     * the {@link Router} will be destroyed.
+     *
+     * @param childRouter The router to be removed
+     */
     public final void removeChildRouter(@NonNull Router childRouter) {
         if ((childRouter instanceof ControllerHostedRouter) && childRouters.remove(childRouter)) {
-            childRouter.destroy();
+            childRouter.destroy(true);
         }
     }
 
@@ -255,7 +271,8 @@ public abstract class Controller {
     }
 
     /**
-     * Return this Controller's View, if available.
+     * Return this Controller's View or {@code null} if it has not yet been created or has been
+     * destroyed.
      */
     @Nullable
     public final View getView() {
@@ -263,15 +280,17 @@ public abstract class Controller {
     }
 
     /**
-     * Returns the host Activity of this Controller's {@link Router}
+     * Returns the host Activity of this Controller's {@link Router} or {@code null} if this
+     * Controller has not yet been attached to an Activity or if the Activity has been destroyed.
      */
     @Nullable
     public final Activity getActivity() {
-        return router.getActivity();
+        return router != null ? router.getActivity() : null;
     }
 
     /**
-     * Returns the Resources from the host Activity
+     * Returns the Resources from the host Activity or {@code null} if this Controller has not
+     * yet been attached to an Activity or if the Activity has been destroyed.
      */
     @Nullable
     public final Resources getResources() {
@@ -280,7 +299,8 @@ public abstract class Controller {
     }
 
     /**
-     * Returns the Application Context derived from the host Activity
+     * Returns the Application Context derived from the host Activity or {@code null} if this Controller
+     * has not yet been attached to an Activity or if the Activity has been destroyed.
      */
     @Nullable
     public final Context getApplicationContext() {
@@ -289,7 +309,8 @@ public abstract class Controller {
     }
 
     /**
-     * Returns this Controller's parent Controller if it is a child Controller.
+     * Returns this Controller's parent Controller if it is a child Controller or {@code null} if
+     * it has no parent.
      */
     @Nullable
     public final Controller getParentController() {
@@ -306,10 +327,10 @@ public abstract class Controller {
     }
 
     /**
-     * Returns the Controller with the given instance id, if available.
-     * May return the controller itself or a matching descendant
+     * Returns the Controller with the given instance id or {@code null} if no such Controller
+     * exists. May return the Controller itself or a matching descendant
+     *
      * @param instanceId The instance ID being searched for
-     * @return The matching Controller, if one exists
      */
     @Nullable
     final Controller findController(@NonNull String instanceId) {
@@ -354,7 +375,8 @@ public abstract class Controller {
     }
 
     /**
-     * Returns the target Controller that was set with the {@link #setTargetController(Controller)} method
+     * Returns the target Controller that was set with the {@link #setTargetController(Controller)}
+     * method or {@code null} if this Controller has no target.
      *
      * @return This Controller's target
      */
@@ -390,6 +412,19 @@ public abstract class Controller {
      */
     protected void onChangeEnded(@NonNull ControllerChangeHandler changeHandler, @NonNull ControllerChangeType changeType) { }
 
+    /**
+     * Called when this Controller has a Context available to it. This will happen very early on in the lifecycle
+     * (before a view is created). If the host activity is re-created (ex: for orientation change), this will be
+     * called again when the new context is available.
+     */
+    protected void onContextAvailable(@NonNull Context context) { }
+
+    /**
+     * Called when this Controller's Context is no longer available. This can happen when the Controller is
+     * destroyed or when the host Activity is destroyed.
+     */
+    protected void onContextUnavailable() { }
+
     /**
      * Called when this Controller is attached to its host ViewGroup
      *
@@ -490,6 +525,14 @@ public abstract class Controller {
         });
     }
 
+    /**
+     * Calls startIntentSenderForResult(IntentSender, int, Intent, int, int, int, Bundle) from this Controller's host Activity.
+     */
+    public final void startIntentSenderForResult(@NonNull final IntentSender intent, final int requestCode, @Nullable final Intent fillInIntent, final int flagsMask,
+                                                 final int flagsValues, final int extraFlags, @Nullable final Bundle options) throws IntentSender.SendIntentException {
+        router.startIntentSenderForResult(instanceId, intent, requestCode, fillInIntent, flagsMask, flagsValues, extraFlags, options);
+    }
+
     /**
      * Registers this Controller to handle onActivityResult responses. Calling this method is NOT
      * necessary when calling {@link #startActivityForResult(Intent, int)}
@@ -533,7 +576,7 @@ public abstract class Controller {
      * @param permission A permission this Controller has requested
      */
     public boolean shouldShowRequestPermissionRationale(@NonNull String permission) {
-        return false;
+        return Build.VERSION.SDK_INT >= 23 && getActivity().shouldShowRequestPermissionRationale(permission);
     }
 
     /**
@@ -551,8 +594,22 @@ public abstract class Controller {
      * @return True if this Controller has consumed the back button press, otherwise false
      */
     public boolean handleBack() {
-        for (int i = childBackstack.size() - 1; i >= 0; i--) {
-            Controller childController = childBackstack.get(i);
+        List<RouterTransaction> childTransactions = new ArrayList<>();
+
+        for (ControllerHostedRouter childRouter : childRouters) {
+            childTransactions.addAll(childRouter.getBackstack());
+        }
+
+        Collections.sort(childTransactions, new Comparator<RouterTransaction>() {
+            @Override
+            public int compare(RouterTransaction o1, RouterTransaction o2) {
+                return o2.transactionIndex - o1.transactionIndex;
+            }
+        });
+
+        for (RouterTransaction transaction : childTransactions) {
+            Controller childController = transaction.controller;
+
             if (childController.isAttached() && childController.getRouter().handleBack()) {
                 return true;
             }
@@ -566,7 +623,7 @@ public abstract class Controller {
      *
      * @param lifecycleListener The listener
      */
-    public void addLifecycleListener(@NonNull LifecycleListener lifecycleListener) {
+    public final void addLifecycleListener(@NonNull LifecycleListener lifecycleListener) {
         if (!lifecycleListeners.contains(lifecycleListener)) {
             lifecycleListeners.add(lifecycleListener);
         }
@@ -577,7 +634,7 @@ public abstract class Controller {
      *
      * @param lifecycleListener The listener to be removed
      */
-    public void removeLifecycleListener(@NonNull LifecycleListener lifecycleListener) {
+    public final void removeLifecycleListener(@NonNull LifecycleListener lifecycleListener) {
         lifecycleListeners.remove(lifecycleListener);
     }
 
@@ -694,8 +751,8 @@ public abstract class Controller {
         return false;
     }
 
-    final void setNeedsAttach() {
-        needsAttach = true;
+    final void setNeedsAttach(boolean needsAttach) {
+        this.needsAttach = needsAttach;
     }
 
     final void prepareForHostDetach() {
@@ -734,6 +791,29 @@ public abstract class Controller {
         }
     }
 
+    final void onContextAvailable() {
+        final Context context = router.getActivity();
+
+        if (context != null && !isContextAvailable) {
+            List<LifecycleListener> listeners = new ArrayList<>(lifecycleListeners);
+            for (LifecycleListener lifecycleListener : listeners) {
+                lifecycleListener.preContextAvailable(this);
+            }
+
+            isContextAvailable = true;
+            onContextAvailable(context);
+
+            listeners = new ArrayList<>(lifecycleListeners);
+            for (LifecycleListener lifecycleListener : listeners) {
+                lifecycleListener.postContextAvailable(this, context);
+            }
+        }
+
+        for (Router childRouter : childRouters) {
+            childRouter.onContextAvailable();
+        }
+    }
+
     final void executeWithRouter(@NonNull RouterRequiringFunc listener) {
         if (router != null) {
             listener.execute();
@@ -743,6 +823,10 @@ public abstract class Controller {
     }
 
     final void activityStarted(@NonNull Activity activity) {
+        if (viewAttachHandler != null) {
+            viewAttachHandler.onActivityStarted();
+        }
+
         onActivityStarted(activity);
     }
 
@@ -751,6 +835,7 @@ public abstract class Controller {
             attach(view);
         } else if (attached) {
             needsAttach = false;
+            hasSavedViewState = false;
         }
 
         onActivityResumed(activity);
@@ -761,15 +846,33 @@ public abstract class Controller {
     }
 
     final void activityStopped(@NonNull Activity activity) {
+        if (viewAttachHandler != null) {
+            viewAttachHandler.onActivityStopped();
+        }
         onActivityStopped(activity);
     }
 
-    final void activityDestroyed(boolean isChangingConfigurations) {
-        if (isChangingConfigurations) {
-            detach(view, true);
+    final void activityDestroyed(@NonNull Activity activity) {
+        if (activity.isChangingConfigurations()) {
+            detach(view, true, false);
         } else {
             destroy(true);
         }
+
+        if (isContextAvailable) {
+            List<LifecycleListener> listeners = new ArrayList<>(lifecycleListeners);
+            for (LifecycleListener lifecycleListener : listeners) {
+                lifecycleListener.preContextUnavailable(this, activity);
+            }
+
+            isContextAvailable = false;
+            onContextUnavailable();
+
+            listeners = new ArrayList<>(lifecycleListeners);
+            for (LifecycleListener lifecycleListener : listeners) {
+                lifecycleListener.postContextUnavailable(this);
+            }
+        }
     }
 
     private void attach(@NonNull View view) {
@@ -796,18 +899,18 @@ public abstract class Controller {
 
         listeners = new ArrayList<>(lifecycleListeners);
         for (LifecycleListener lifecycleListener : listeners) {
-            lifecycleListener.postAttach(this, view);
+            lifecycleListener.postAttach(Controller.this, view);
         }
     }
 
-    void detach(@NonNull View view, boolean forceViewRefRemoval) {
+    void detach(@NonNull View view, boolean forceViewRefRemoval, boolean blockViewRefRemoval) {
         if (!attachedToUnownedParent) {
             for (ControllerHostedRouter router : childRouters) {
                 router.prepareForHostDetach();
             }
         }
 
-        final boolean removeViewRef = forceViewRefRemoval || retainViewMode == RetainViewMode.RELEASE_DETACH || isBeingDestroyed;
+        final boolean removeViewRef = !blockViewRefRemoval && (forceViewRefRemoval || retainViewMode == RetainViewMode.RELEASE_DETACH || isBeingDestroyed);
 
         if (attached) {
             List<LifecycleListener> listeners = new ArrayList<>(lifecycleListeners);
@@ -846,7 +949,8 @@ public abstract class Controller {
 
             onDestroyView(view);
 
-            view.removeOnAttachStateChangeListener(onAttachStateChangeListener);
+            viewAttachHandler.unregisterAttachListener(view);
+            viewAttachHandler = null;
             viewIsAttached = false;
 
             if (isBeingDestroyed) {
@@ -871,7 +975,7 @@ public abstract class Controller {
 
     final View inflate(@NonNull ViewGroup parent) {
         if (view != null && view.getParent() != null && view.getParent() != parent) {
-            detach(view, true);
+            detach(view, true, false);
             removeViewReference();
         }
 
@@ -893,28 +997,32 @@ public abstract class Controller {
 
             restoreViewState(view);
 
-            onAttachStateChangeListener = new OnAttachStateChangeListener() {
+            viewAttachHandler = new ViewAttachHandler(new ViewAttachListener() {
                 @Override
-                public void onViewAttachedToWindow(View v) {
-                    if (v == view) {
-                        viewIsAttached = true;
-                        viewWasDetached = false;
-                    }
-                    attach(v);
+                public void onAttached() {
+                    viewIsAttached = true;
+                    viewWasDetached = false;
+                    attach(view);
                 }
 
                 @Override
-                public void onViewDetachedFromWindow(View v) {
+                public void onDetached(boolean fromActivityStop) {
                     viewIsAttached = false;
                     viewWasDetached = true;
 
                     if (!isDetachFrozen) {
-                        detach(v, false);
+                        detach(view, false, fromActivityStop);
                     }
                 }
-            };
 
-            view.addOnAttachStateChangeListener(onAttachStateChangeListener);
+                @Override
+                public void onViewDetachAfterStop() {
+                    if (!isDetachFrozen) {
+                        detach(view, false, false);
+                    }
+                }
+            });
+            viewAttachHandler.listenForAttach(view);
         } else if (retainViewMode == RetainViewMode.RETAIN_DETACH) {
             restoreChildControllerHosts();
         }
@@ -929,7 +1037,6 @@ public abstract class Controller {
 
                 if (containerView != null && containerView instanceof ViewGroup) {
                     childRouter.setHost(this, (ViewGroup)containerView);
-                    monitorChildRouter(childRouter);
                     childRouter.rebindIfNeeded();
                 }
             }
@@ -937,6 +1044,21 @@ public abstract class Controller {
     }
 
     private void performDestroy() {
+        if (isContextAvailable) {
+            List<LifecycleListener> listeners = new ArrayList<>(lifecycleListeners);
+            for (LifecycleListener lifecycleListener : listeners) {
+                lifecycleListener.preContextUnavailable(this, getActivity());
+            }
+
+            isContextAvailable = false;
+            onContextUnavailable();
+
+            listeners = new ArrayList<>(lifecycleListeners);
+            for (LifecycleListener lifecycleListener : listeners) {
+                lifecycleListener.postContextUnavailable(this);
+            }
+        }
+
         if (!destroyed) {
             List<LifecycleListener> listeners = new ArrayList<>(lifecycleListeners);
             for (LifecycleListener lifecycleListener : listeners) {
@@ -968,26 +1090,26 @@ public abstract class Controller {
         }
 
         for (ControllerHostedRouter childRouter : childRouters) {
-            childRouter.destroy();
+            childRouter.destroy(false);
         }
 
         if (!attached) {
             removeViewReference();
         } else if (removeViews) {
-            detach(view, true);
+            detach(view, true, false);
         }
     }
 
     private void saveViewState(@NonNull View view) {
         hasSavedViewState = true;
 
-        viewState = new Bundle();
+        viewState = new Bundle(getClass().getClassLoader());
 
         SparseArray<Parcelable> hierarchyState = new SparseArray<>();
         view.saveHierarchyState(hierarchyState);
         viewState.putSparseParcelableArray(KEY_VIEW_STATE_HIERARCHY, hierarchyState);
 
-        Bundle stateBundle = new Bundle();
+        Bundle stateBundle = new Bundle(getClass().getClassLoader());
         onSaveViewState(view, stateBundle);
         viewState.putBundle(KEY_VIEW_STATE_BUNDLE, stateBundle);
 
@@ -1000,7 +1122,9 @@ public abstract class Controller {
     private void restoreViewState(@NonNull View view) {
         if (viewState != null) {
             view.restoreHierarchyState(viewState.getSparseParcelableArray(KEY_VIEW_STATE_HIERARCHY));
-            onRestoreViewState(view, viewState.getBundle(KEY_VIEW_STATE_BUNDLE));
+            Bundle savedViewState = viewState.getBundle(KEY_VIEW_STATE_BUNDLE);
+            savedViewState.setClassLoader(getClass().getClassLoader());
+            onRestoreViewState(view, savedViewState);
 
             restoreChildControllerHosts();
 
@@ -1041,13 +1165,7 @@ public abstract class Controller {
         }
         outState.putParcelableArrayList(KEY_CHILD_ROUTERS, childBundles);
 
-        ArrayList<String> childBackstack = new ArrayList<>();
-        for (Controller controller : this.childBackstack) {
-            childBackstack.add(controller.instanceId);
-        }
-        outState.putStringArrayList(KEY_CHILD_BACKSTACK, childBackstack);
-
-        Bundle savedState = new Bundle();
+        Bundle savedState = new Bundle(getClass().getClassLoader());
         onSaveInstanceState(savedState);
 
         List<LifecycleListener> listeners = new ArrayList<>(lifecycleListeners);
@@ -1062,6 +1180,10 @@ public abstract class Controller {
 
     private void restoreInstanceState(@NonNull Bundle savedInstanceState) {
         viewState = savedInstanceState.getBundle(KEY_VIEW_STATE);
+        if (viewState != null) {
+            viewState.setClassLoader(getClass().getClassLoader());
+        }
+
         instanceId = savedInstanceState.getString(KEY_INSTANCE_ID);
         targetInstanceId = savedInstanceState.getString(KEY_TARGET_INSTANCE_ID);
         requestedPermissions.addAll(savedInstanceState.getStringArrayList(KEY_REQUESTED_PERMISSIONS));
@@ -1074,19 +1196,13 @@ public abstract class Controller {
         for (Bundle childBundle : childBundles) {
             ControllerHostedRouter childRouter = new ControllerHostedRouter();
             childRouter.restoreInstanceState(childBundle);
-            monitorChildRouter(childRouter);
             childRouters.add(childRouter);
         }
 
-        List<String> childBackstackIds = savedInstanceState.getStringArrayList(KEY_CHILD_BACKSTACK);
-        for (String controllerId : childBackstackIds) {
-            Controller childController = findController(controllerId);
-            if (childController != null) {
-                childBackstack.add(childController);
-            }
-        }
-
         this.savedInstanceState = savedInstanceState.getBundle(KEY_SAVED_STATE);
+        if (this.savedInstanceState != null) {
+            this.savedInstanceState.setClassLoader(getClass().getClassLoader());
+        }
         performOnRestoreInstanceState();
     }
 
@@ -1105,6 +1221,7 @@ public abstract class Controller {
 
     final void changeStarted(@NonNull ControllerChangeHandler changeHandler, @NonNull ControllerChangeType changeType) {
         if (!changeType.isEnter) {
+            isPerformingExitTransition = true;
             for (ControllerHostedRouter router : childRouters) {
                 router.setDetachFrozen(true);
             }
@@ -1120,6 +1237,7 @@ public abstract class Controller {
 
     final void changeEnded(@NonNull ControllerChangeHandler changeHandler, @NonNull ControllerChangeType changeType) {
         if (!changeType.isEnter) {
+            isPerformingExitTransition = false;
             for (ControllerHostedRouter router : childRouters) {
                 router.setDetachFrozen(false);
             }
@@ -1150,7 +1268,7 @@ public abstract class Controller {
             }
 
             if (!frozen && view != null && viewWasDetached) {
-                detach(view, false);
+                detach(view, false, false);
             }
         }
     }
@@ -1171,22 +1289,6 @@ public abstract class Controller {
         return attached && hasOptionsMenu && !optionsMenuHidden && onOptionsItemSelected(item);
     }
 
-    private void monitorChildRouter(@NonNull ControllerHostedRouter childRouter) {
-        childRouter.setOnControllerPushedListener(onControllerPushedListener);
-    }
-
-    private void onChildControllerPushed(@NonNull Controller controller) {
-        if (!childBackstack.contains(controller)) {
-            childBackstack.add(controller);
-            controller.addLifecycleListener(new LifecycleListener() {
-                @Override
-                public void postDestroy(@NonNull Controller controller) {
-                    childBackstack.remove(controller);
-                }
-            });
-        }
-    }
-
     final void setParentController(@Nullable Controller controller) {
         parentController = controller;
     }
@@ -1247,6 +1349,12 @@ public abstract class Controller {
         public void preDestroy(@NonNull Controller controller) { }
         public void postDestroy(@NonNull Controller controller) { }
 
+        public void preContextAvailable(@NonNull Controller controller) { }
+        public void postContextAvailable(@NonNull Controller controller, @NonNull Context context) { }
+
+        public void preContextUnavailable(@NonNull Controller controller, @NonNull Context context) { }
+        public void postContextUnavailable(@NonNull Controller controller) { }
+
         public void onSaveInstanceState(@NonNull Controller controller, @NonNull Bundle outState) { }
         public void onRestoreInstanceState(@NonNull Controller controller, @NonNull Bundle savedInstanceState) { }
 

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

@@ -10,7 +10,6 @@ import android.view.ViewParent;
 import com.bluelinelabs.conductor.changehandler.SimpleSwapChangeHandler;
 import com.bluelinelabs.conductor.internal.ClassUtils;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -25,16 +24,17 @@ public abstract class ControllerChangeHandler {
     private static final String KEY_CLASS_NAME = "ControllerChangeHandler.className";
     private static final String KEY_SAVED_STATE = "ControllerChangeHandler.savedState";
 
-    private static final Map<String, ControllerChangeHandler> inProgressPushHandlers = new HashMap<>();
+    private static final Map<String, ChangeHandlerData> inProgressChangeHandlers = new HashMap<>();
 
     private boolean forceRemoveViewOnPush;
+    private boolean hasBeenUsed;
 
     /**
      * Responsible for swapping Views from one Controller to another.
      *
      * @param container      The container these Views are hosted in.
-     * @param from           The previous View in the container, if any.
-     * @param to             The next View that should be put in the container, if any.
+     * @param from           The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to             The next View that should be put in the container or {@code null} if no Controller is being transitioned to
      * @param isPush         True if this is a push transaction, false if it's a pop.
      * @param changeListener This listener must be called when any transitions or animations are completed.
      */
@@ -62,8 +62,9 @@ public abstract class ControllerChangeHandler {
      * Will be called on change handlers that push a controller if the controller being pushed is
      * popped before it has completed.
      *
-     * @param newHandler the change handler that has caused this push to be aborted
-     * @param newTop     the controller that will now be at the top of the backstack
+     * @param newHandler The change handler that has caused this push to be aborted
+     * @param newTop     The Controller that will now be at the top of the backstack or {@code null}
+     *                   if there will be no new Controller at the top
      */
     public void onAbortPush(@NonNull ControllerChangeHandler newHandler, @Nullable Controller newTop) { }
 
@@ -73,6 +74,26 @@ public abstract class ControllerChangeHandler {
      */
     public void completeImmediately() { }
 
+    /**
+     * Returns a copy of this ControllerChangeHandler. This method is internally used by the library, so
+     * ensure it will return an exact copy of your handler if overriding. If not overriding, the handler
+     * will be saved and restored from the Bundle format.
+     */
+    @NonNull
+    public ControllerChangeHandler copy() {
+        return fromBundle(toBundle());
+    }
+
+    /**
+     * Returns whether or not this is a reusable ControllerChangeHandler. Defaults to false and should
+     * ONLY be overridden if there are absolutely no side effects to using this handler more than once.
+     * In the case that a handler is not reusable, it will be copied using the {@link #copy()} method
+     * prior to use.
+     */
+    public boolean isReusable() {
+        return false;
+    }
+
     @NonNull
     final Bundle toBundle() {
         Bundle bundle = new Bundle();
@@ -85,11 +106,6 @@ public abstract class ControllerChangeHandler {
         return bundle;
     }
 
-    @NonNull
-    final ControllerChangeHandler copy() {
-        return fromBundle(toBundle());
-    }
-
     private void ensureDefaultConstructor() {
         try {
             getClass().getConstructor();
@@ -111,40 +127,55 @@ public abstract class ControllerChangeHandler {
         }
     }
 
-    static boolean completePushImmediately(@NonNull String controllerInstanceId) {
-        ControllerChangeHandler changeHandler = inProgressPushHandlers.get(controllerInstanceId);
-        if (changeHandler != null) {
-            changeHandler.completeImmediately();
-            inProgressPushHandlers.remove(controllerInstanceId);
+    static boolean completeHandlerImmediately(@NonNull String controllerInstanceId) {
+        ChangeHandlerData changeHandlerData = inProgressChangeHandlers.get(controllerInstanceId);
+        if (changeHandlerData != null) {
+            changeHandlerData.changeHandler.completeImmediately();
+            inProgressChangeHandlers.remove(controllerInstanceId);
             return true;
         }
         return false;
     }
 
-    public static void abortPush(@NonNull Controller toAbort, @Nullable Controller newController, @NonNull ControllerChangeHandler newChangeHandler) {
-        ControllerChangeHandler handlerForPush = inProgressPushHandlers.get(toAbort.getInstanceId());
-        if (handlerForPush != null) {
-            handlerForPush.onAbortPush(newChangeHandler, newController);
-            inProgressPushHandlers.remove(toAbort.getInstanceId());
+    static void abortOrComplete(@NonNull Controller toAbort, @Nullable Controller newController, @NonNull ControllerChangeHandler newChangeHandler) {
+        ChangeHandlerData changeHandlerData = inProgressChangeHandlers.get(toAbort.getInstanceId());
+        if (changeHandlerData != null) {
+            if (changeHandlerData.isPush) {
+                changeHandlerData.changeHandler.onAbortPush(newChangeHandler, newController);
+            } else {
+                changeHandlerData.changeHandler.completeImmediately();
+            }
+
+            inProgressChangeHandlers.remove(toAbort.getInstanceId());
         }
     }
 
-    public static void executeChange(@Nullable final Controller to, @Nullable final Controller from, boolean isPush, @NonNull ViewGroup container, @NonNull ControllerChangeHandler inHandler) {
-        executeChange(to, from, isPush, container, inHandler, new ArrayList<ControllerChangeListener>());
+    static void executeChange(@NonNull final ChangeTransaction transaction) {
+        executeChange(transaction.to, transaction.from, transaction.isPush, transaction.container, transaction.changeHandler, transaction.listeners);
     }
 
-    public static void executeChange(@Nullable final Controller to, @Nullable final Controller from, final boolean isPush, @Nullable final ViewGroup container, @Nullable final ControllerChangeHandler inHandler, @NonNull final List<ControllerChangeListener> listeners) {
+    private static void executeChange(@Nullable final Controller to, @Nullable final Controller from, final boolean isPush, @Nullable final ViewGroup container, @Nullable final ControllerChangeHandler inHandler, @NonNull final List<ControllerChangeListener> listeners) {
         if (container != null) {
-            final ControllerChangeHandler handler = inHandler != null ? inHandler : new SimpleSwapChangeHandler();
+            final ControllerChangeHandler handler;
+            if (inHandler == null) {
+                handler = new SimpleSwapChangeHandler();
+            } else if (inHandler.hasBeenUsed && !inHandler.isReusable()) {
+                handler = inHandler.copy();
+            } else {
+                handler = inHandler;
+            }
+            handler.hasBeenUsed = true;
 
-            if (isPush && to != null) {
-                inProgressPushHandlers.put(to.getInstanceId(), handler);
-
-                if (from != null) {
-                    completePushImmediately(from.getInstanceId());
+            if (from != null) {
+                if (isPush) {
+                    completeHandlerImmediately(from.getInstanceId());
+                } else {
+                    abortOrComplete(from, to, handler);
                 }
-            } else if (!isPush && from != null) {
-                abortPush(from, to, handler);
+            }
+
+            if (to != null) {
+                inProgressChangeHandlers.put(to.getInstanceId(), new ChangeHandlerData(handler, isPush));
             }
 
             for (ControllerChangeListener listener : listeners) {
@@ -178,7 +209,7 @@ public abstract class ControllerChangeHandler {
                     }
 
                     if (to != null) {
-                        inProgressPushHandlers.remove(to.getInstanceId());
+                        inProgressChangeHandlers.remove(to.getInstanceId());
                         to.changeEnded(handler, toChangeType);
                     }
 
@@ -192,6 +223,10 @@ public abstract class ControllerChangeHandler {
                             ((ViewGroup)fromParent).removeView(fromView);
                         }
                     }
+
+                    if (handler.removesFromViewOnPush() && from != null) {
+                        from.setNeedsAttach(false);
+                    }
                 }
             });
         }
@@ -205,6 +240,24 @@ public abstract class ControllerChangeHandler {
         forceRemoveViewOnPush = force;
     }
 
+    static class ChangeTransaction {
+        @Nullable final Controller to;
+        @Nullable final Controller from;
+        final boolean isPush;
+        @Nullable final ViewGroup container;
+        @Nullable final ControllerChangeHandler changeHandler;
+        @NonNull final List<ControllerChangeListener> listeners;
+
+        public ChangeTransaction(@Nullable Controller to, @Nullable Controller from, boolean isPush, @Nullable ViewGroup container, @Nullable ControllerChangeHandler changeHandler, @NonNull List<ControllerChangeListener> listeners) {
+            this.to = to;
+            this.from = from;
+            this.isPush = isPush;
+            this.container = container;
+            this.changeHandler = changeHandler;
+            this.listeners = listeners;
+        }
+    }
+
     /**
      * A listener interface useful for allowing external classes to be notified of change events.
      */
@@ -212,8 +265,8 @@ public abstract class ControllerChangeHandler {
         /**
          * Called when a {@link ControllerChangeHandler} has started changing {@link Controller}s
          *
-         * @param to        The new Controller
-         * @param from      The old Controller
+         * @param to        The new Controller or {@code null} if no Controller is being transitioned to
+         * @param from      The old Controller or {@code null} if there was no Controller before this transition
          * @param isPush    True if this is a push operation, or false if it's a pop.
          * @param container The containing ViewGroup
          * @param handler   The change handler being used.
@@ -223,9 +276,9 @@ public abstract class ControllerChangeHandler {
         /**
          * Called when a {@link ControllerChangeHandler} has completed changing {@link Controller}s
          *
-         * @param to        The new Controller
-         * @param from      The old Controller
-         * @param isPush    True if this was a push operation, or false if it's a pop.
+         * @param to        The new Controller or {@code null} if no Controller is being transitioned to
+         * @param from      The old Controller or {@code null} if there was no Controller before this transition
+         * @param isPush    True if this was a push operation, or false if it's a pop
          * @param container The containing ViewGroup
          * @param handler   The change handler that was used.
          */
@@ -243,4 +296,14 @@ public abstract class ControllerChangeHandler {
         void onChangeCompleted();
     }
 
+    private static class ChangeHandlerData {
+        public final ControllerChangeHandler changeHandler;
+        public final boolean isPush;
+
+        public ChangeHandlerData(ControllerChangeHandler changeHandler, boolean isPush) {
+            this.changeHandler = changeHandler;
+            this.isPush = isPush;
+        }
+    }
+
 }

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

@@ -2,6 +2,8 @@ package com.bluelinelabs.conductor;
 
 import android.app.Activity;
 import android.content.Intent;
+import android.content.IntentSender;
+import android.content.IntentSender.SendIntentException;
 import android.os.Bundle;
 import android.support.annotation.IdRes;
 import android.support.annotation.NonNull;
@@ -9,6 +11,7 @@ import android.support.annotation.Nullable;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.ControllerChangeHandler.ControllerChangeListener;
+import com.bluelinelabs.conductor.internal.TransactionIndexer;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -22,6 +25,7 @@ class ControllerHostedRouter extends Router {
 
     @IdRes private int hostId;
     private String tag;
+    private boolean isDetachFrozen;
 
     ControllerHostedRouter() { }
 
@@ -40,6 +44,12 @@ class ControllerHostedRouter extends Router {
 
             hostController = controller;
             this.container = container;
+
+            for (RouterTransaction transaction : backstack) {
+                transaction.controller.setParentController(controller);
+            }
+
+            watchContainerAttach();
         }
     }
 
@@ -51,12 +61,12 @@ class ControllerHostedRouter extends Router {
         final List<Controller> controllersToDestroy = new ArrayList<>(destroyingControllers);
         for (Controller controller : controllersToDestroy) {
             if (controller.getView() != null) {
-                controller.detach(controller.getView(), true);
+                controller.detach(controller.getView(), true, false);
             }
         }
         for (RouterTransaction transaction : backstack) {
             if (transaction.controller.getView() != null) {
-                transaction.controller.detach(transaction.controller.getView(), true);
+                transaction.controller.detach(transaction.controller.getView(), true, false);
             }
         }
 
@@ -66,15 +76,34 @@ class ControllerHostedRouter extends Router {
     }
 
     final void setDetachFrozen(boolean frozen) {
+        isDetachFrozen = frozen;
         for (RouterTransaction transaction : backstack) {
             transaction.controller.setDetachFrozen(frozen);
         }
     }
 
     @Override
-    void destroy() {
+    void destroy(boolean popViews) {
         setDetachFrozen(false);
-        super.destroy();
+        super.destroy(popViews);
+    }
+
+    @Override
+    protected void pushToBackstack(@NonNull RouterTransaction entry) {
+        if (isDetachFrozen) {
+            entry.controller.setDetachFrozen(true);
+        }
+        super.pushToBackstack(entry);
+    }
+
+    @Override
+    public void setBackstack(@NonNull List<RouterTransaction> newBackstack, @Nullable ControllerChangeHandler changeHandler) {
+        if (isDetachFrozen) {
+            for (RouterTransaction transaction : newBackstack) {
+                transaction.controller.setDetachFrozen(true);
+            }
+        }
+        super.setBackstack(newBackstack, changeHandler);
     }
 
     @Override @Nullable
@@ -124,6 +153,13 @@ class ControllerHostedRouter extends Router {
         }
     }
 
+    @Override
+    void startIntentSenderForResult(@NonNull String instanceId, @NonNull IntentSender intent, int requestCode, @Nullable Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags, @Nullable Bundle options) throws SendIntentException {
+        if (hostController != null && hostController.getRouter() != null) {
+            hostController.getRouter().startIntentSenderForResult(instanceId, intent, requestCode, fillInIntent, flagsMask, flagsValues, extraFlags, options);
+        }
+    }
+
     @Override
     void registerForActivityResult(@NonNull String instanceId, int requestCode) {
         if (hostController != null && hostController.getRouter() != null) {
@@ -197,4 +233,9 @@ class ControllerHostedRouter extends Router {
             return this;
         }
     }
+
+    @Override @Nullable
+    TransactionIndexer getTransactionIndexer() {
+        return getRootRouter().getTransactionIndexer();
+    }
 }

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

@@ -32,7 +32,7 @@ abstract public class RestoreViewOnCreateController extends Controller {
 
     @Override @NonNull
     protected final View onCreateView(@NonNull LayoutInflater inflater, @NonNull ViewGroup container) {
-        return onCreateView(inflater, container, viewState);
+        return onCreateView(inflater, container, viewState == null ? null : viewState.getBundle(KEY_VIEW_STATE_BUNDLE));
     }
 
     /**
@@ -45,7 +45,7 @@ abstract public class RestoreViewOnCreateController extends Controller {
      *                       This Controller's view should NOT be added in this method. It is simply passed in
      *                       so that valid LayoutParams can be used during inflation.
      * @param savedViewState A bundle for the view's state, which would have been created in {@link #onSaveViewState(View, Bundle)},
-     *                       or null if no saved state exists.
+     *                       or {@code null} if no saved state exists.
      */
     @NonNull
     protected abstract View onCreateView(@NonNull LayoutInflater inflater, @NonNull ViewGroup container, @Nullable Bundle savedViewState);

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

@@ -2,6 +2,7 @@ package com.bluelinelabs.conductor;
 
 import android.app.Activity;
 import android.content.Intent;
+import android.content.IntentSender;
 import android.os.Bundle;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
@@ -13,9 +14,12 @@ import android.view.View;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.Controller.LifecycleListener;
+import com.bluelinelabs.conductor.ControllerChangeHandler.ChangeTransaction;
 import com.bluelinelabs.conductor.ControllerChangeHandler.ControllerChangeListener;
 import com.bluelinelabs.conductor.changehandler.SimpleSwapChangeHandler;
 import com.bluelinelabs.conductor.internal.NoOpControllerChangeHandler;
+import com.bluelinelabs.conductor.internal.ThreadUtils;
+import com.bluelinelabs.conductor.internal.TransactionIndexer;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -32,17 +36,19 @@ public abstract class Router {
     private static final String KEY_BACKSTACK = "Router.backstack";
     private static final String KEY_POPS_LAST_VIEW = "Router.popsLastView";
 
-    protected final Backstack backstack = new Backstack();
-    private OnControllerPushedListener onControllerPushedListener;
+    final Backstack backstack = new Backstack();
     private final List<ControllerChangeListener> changeListeners = new ArrayList<>();
+    private final List<ChangeTransaction> pendingControllerChanges = new ArrayList<>();
     final List<Controller> destroyingControllers = new ArrayList<>();
 
     private boolean popsLastView = false;
+    boolean containerFullyAttached = false;
 
     ViewGroup container;
 
     /**
-     * Returns this Router's host Activity
+     * Returns this Router's host Activity or {@code null} if it has either not yet been attached to
+     * an Activity or if the Activity has been destroyed.
      */
     @Nullable
     public abstract Activity getActivity();
@@ -52,8 +58,8 @@ public abstract class Router {
      * of the controller that called startActivityForResult is not known.
      *
      * @param requestCode The Activity's onActivityResult requestCode
-     * @param resultCode The Activity's onActivityResult resultCode
-     * @param data The Activity's onActivityResult data
+     * @param resultCode  The Activity's onActivityResult resultCode
+     * @param data        The Activity's onActivityResult data
      */
     public abstract void onActivityResult(int requestCode, int resultCode, @Nullable Intent data);
 
@@ -61,9 +67,9 @@ public abstract class Router {
      * This should be called by the host Activity when its onRequestPermissionsResult method is called. The call will be forwarded
      * to the {@link Controller} with the instanceId passed in.
      *
-     * @param instanceId The instanceId of the Controller to which this result should be forwarded
-     * @param requestCode The Activity's onRequestPermissionsResult requestCode
-     * @param permissions The Activity's onRequestPermissionsResult permissions
+     * @param instanceId   The instanceId of the Controller to which this result should be forwarded
+     * @param requestCode  The Activity's onRequestPermissionsResult requestCode
+     * @param permissions  The Activity's onRequestPermissionsResult permissions
      * @param grantResults The Activity's onRequestPermissionsResult grantResults
      */
     public void onRequestPermissionsResult(@NonNull String instanceId, int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
@@ -81,6 +87,8 @@ public abstract class Router {
      */
     @UiThread
     public boolean handleBack() {
+        ThreadUtils.ensureMainThread();
+
         if (!backstack.isEmpty()) {
             //noinspection ConstantConditions
             if (backstack.peek().controller.handleBack()) {
@@ -98,8 +106,11 @@ public abstract class Router {
      *
      * @return Whether or not this Router still has controllers remaining on it after popping.
      */
+    @SuppressWarnings("WeakerAccess")
     @UiThread
     public boolean popCurrentController() {
+        ThreadUtils.ensureMainThread();
+
         RouterTransaction transaction = backstack.peek();
         if (transaction == null) {
             throw new IllegalStateException("Trying to pop the current controller when there are none on the backstack.");
@@ -115,26 +126,39 @@ public abstract class Router {
      */
     @UiThread
     public boolean popController(@NonNull Controller controller) {
-        RouterTransaction topController = backstack.peek();
-        boolean poppingTopController = topController != null && topController.controller == controller;
+        ThreadUtils.ensureMainThread();
+
+        RouterTransaction topTransaction = backstack.peek();
+        boolean poppingTopController = topTransaction != null && topTransaction.controller == controller;
 
         if (poppingTopController) {
             trackDestroyingController(backstack.pop());
+            performControllerChange(backstack.peek(), topTransaction, false);
         } else {
+            RouterTransaction removedTransaction = null;
+            RouterTransaction nextTransaction = null;
             for (RouterTransaction transaction : backstack) {
                 if (transaction.controller == controller) {
+                    if (controller.isAttached()) {
+                        trackDestroyingController(transaction);
+                    }
                     backstack.remove(transaction);
+                    removedTransaction = transaction;
+                } else if (removedTransaction != null) {
+                    if (!transaction.controller.isAttached()) {
+                        nextTransaction = transaction;
+                    }
                     break;
                 }
             }
-        }
 
-        if (poppingTopController) {
-            performControllerChange(backstack.peek(), topController, false);
+            if (removedTransaction != null) {
+                performControllerChange(nextTransaction, removedTransaction, false);
+            }
         }
 
         if (popsLastView) {
-            return topController != null;
+            return topTransaction != null;
         } else {
             return !backstack.isEmpty();
         }
@@ -148,6 +172,8 @@ public abstract class Router {
      */
     @UiThread
     public void pushController(@NonNull RouterTransaction transaction) {
+        ThreadUtils.ensureMainThread();
+
         RouterTransaction from = backstack.peek();
         pushToBackstack(transaction);
         performControllerChange(transaction, from, true);
@@ -159,8 +185,11 @@ public abstract class Router {
      * @param transaction The transaction detailing what should be pushed, including the {@link Controller},
      *                    and its push and pop {@link ControllerChangeHandler}, and its tag.
      */
+    @SuppressWarnings("WeakerAccess")
     @UiThread
     public void replaceTopController(@NonNull RouterTransaction transaction) {
+        ThreadUtils.ensureMainThread();
+
         RouterTransaction topTransaction = backstack.peek();
         if (!backstack.isEmpty()) {
             trackDestroyingController(backstack.pop());
@@ -168,11 +197,12 @@ public abstract class Router {
 
         final ControllerChangeHandler handler = transaction.pushChangeHandler();
         if (topTransaction != null) {
+            //noinspection ConstantConditions
             final boolean oldHandlerRemovedViews = topTransaction.pushChangeHandler() == null || topTransaction.pushChangeHandler().removesFromViewOnPush();
             final boolean newHandlerRemovesViews = handler == null || handler.removesFromViewOnPush();
             if (!oldHandlerRemovedViews && newHandlerRemovesViews) {
                 for (RouterTransaction visibleTransaction : getVisibleTransactions(backstack.iterator())) {
-                    performControllerChange(null, visibleTransaction.controller, true, handler != null ? handler.copy() : new SimpleSwapChangeHandler());
+                    performControllerChange(null, visibleTransaction, true, handler);
                 }
             }
         }
@@ -185,14 +215,26 @@ public abstract class Router {
         performControllerChange(transaction.pushChangeHandler(handler), topTransaction, true);
     }
 
-    void destroy() {
+    void destroy(boolean popViews) {
         popsLastView = true;
-        List<RouterTransaction> poppedControllers = backstack.popAll();
+        final List<RouterTransaction> poppedControllers = backstack.popAll();
+        trackDestroyingControllers(poppedControllers);
 
-        if (poppedControllers.size() > 0) {
-            trackDestroyingControllers(poppedControllers);
+        if (popViews && poppedControllers.size() > 0) {
+            RouterTransaction topTransaction = poppedControllers.get(0);
+            topTransaction.controller().addLifecycleListener(new LifecycleListener() {
+                @Override
+                public void onChangeEnd(@NonNull Controller controller, @NonNull ControllerChangeHandler changeHandler, @NonNull ControllerChangeType changeType) {
+                    if (changeType == ControllerChangeType.POP_EXIT) {
+                        for (int i = poppedControllers.size() - 1; i > 0; i--) {
+                            RouterTransaction transaction = poppedControllers.get(i);
+                            performControllerChange(null, transaction, true, new SimpleSwapChangeHandler());
+                        }
+                    }
+                }
+            });
 
-            performControllerChange(null, poppedControllers.get(0).controller, false, poppedControllers.get(0).popChangeHandler());
+            performControllerChange(null, topTransaction, false, topTransaction.popChangeHandler());
         }
     }
 
@@ -218,6 +260,8 @@ public abstract class Router {
      */
     @UiThread
     public boolean popToRoot() {
+        ThreadUtils.ensureMainThread();
+
         return popToRoot(null);
     }
 
@@ -227,8 +271,11 @@ public abstract class Router {
      * @param changeHandler The {@link ControllerChangeHandler} to handle this transaction
      * @return Whether or not any {@link Controller}s were popped in order to get to the root transaction
      */
+    @SuppressWarnings("WeakerAccess")
     @UiThread
     public boolean popToRoot(@Nullable ControllerChangeHandler changeHandler) {
+        ThreadUtils.ensureMainThread();
+
         if (backstack.size() > 1) {
             //noinspection ConstantConditions
             popToTransaction(backstack.root(), changeHandler);
@@ -246,18 +293,23 @@ public abstract class Router {
      */
     @UiThread
     public boolean popToTag(@NonNull String tag) {
+        ThreadUtils.ensureMainThread();
+
         return popToTag(tag, null);
     }
 
     /**
      * Pops all {@link Controller}s until the {@link Controller} with the passed tag is at the top
      *
-     * @param tag The tag being popped to
+     * @param tag           The tag being popped to
      * @param changeHandler The {@link ControllerChangeHandler} to handle this transaction
      * @return Whether or not the {@link Controller} with the passed tag is now at the top
      */
+    @SuppressWarnings("WeakerAccess")
     @UiThread
     public boolean popToTag(@NonNull String tag, @Nullable ControllerChangeHandler changeHandler) {
+        ThreadUtils.ensureMainThread();
+
         for (RouterTransaction transaction : backstack) {
             if (tag.equals(transaction.tag())) {
                 popToTransaction(transaction, changeHandler);
@@ -275,16 +327,17 @@ public abstract class Router {
      */
     @UiThread
     public void setRoot(@NonNull RouterTransaction transaction) {
-        List<RouterTransaction> transactions = new ArrayList<>();
-        transactions.add(transaction);
+        ThreadUtils.ensureMainThread();
+
+        List<RouterTransaction> transactions = Collections.singletonList(transaction);
         setBackstack(transactions, transaction.pushChangeHandler());
     }
 
     /**
-     * Returns the hosted Controller with the given instance id, if available.
+     * Returns the hosted Controller with the given instance id or {@code null} if no such
+     * Controller exists in this Router.
      *
      * @param instanceId The instance ID being searched for
-     * @return The matching Controller, if one exists
      */
     @Nullable
     public Controller getControllerWithInstanceId(@NonNull String instanceId) {
@@ -298,10 +351,10 @@ public abstract class Router {
     }
 
     /**
-     * Returns the hosted Controller that was pushed with the given tag, if available.
+     * Returns the hosted Controller that was pushed with the given tag or {@code null} if no
+     * such Controller exists in this Router.
      *
      * @param tag The tag being searched for
-     * @return The matching Controller, if one exists
      */
     @Nullable
     public Controller getControllerWithTag(@NonNull String tag) {
@@ -316,6 +369,7 @@ public abstract class Router {
     /**
      * Returns the number of {@link Controller}s currently in the backstack
      */
+    @SuppressWarnings("WeakerAccess")
     public int getBackstackSize() {
         return backstack.size();
     }
@@ -337,60 +391,68 @@ public abstract class Router {
      * Sets the backstack, transitioning from the current top controller to the top of the new stack (if different)
      * using the passed {@link ControllerChangeHandler}
      *
-     * @param newBackstack The new backstack
+     * @param newBackstack  The new backstack
      * @param changeHandler An optional change handler to be used to handle the root view of transition
      */
+    @SuppressWarnings("WeakerAccess")
     @UiThread
     public void setBackstack(@NonNull List<RouterTransaction> newBackstack, @Nullable ControllerChangeHandler changeHandler) {
+        ThreadUtils.ensureMainThread();
+
         List<RouterTransaction> oldVisibleTransactions = getVisibleTransactions(backstack.iterator());
 
-        backstack.setBackstack(newBackstack);
+        boolean newRootRequiresPush = !(newBackstack.size() > 0 && backstack.contains(newBackstack.get(0)));
 
+        removeAllExceptVisibleAndUnowned();
+        ensureOrderedTransactionIndices(newBackstack);
+
+        backstack.setBackstack(newBackstack);
         for (RouterTransaction transaction : backstack) {
             transaction.onAttachedToRouter();
         }
 
-        removeAllExceptVisibleAndUnowned();
-
         if (newBackstack.size() > 0) {
             List<RouterTransaction> reverseNewBackstack = new ArrayList<>(newBackstack);
             Collections.reverse(reverseNewBackstack);
             List<RouterTransaction> newVisibleTransactions = getVisibleTransactions(reverseNewBackstack.iterator());
 
-            boolean visibleTransactionsChanged = newVisibleTransactions.size() != oldVisibleTransactions.size();
-            if (!visibleTransactionsChanged) {
-                for (int i = 0; i < oldVisibleTransactions.size(); i++) {
-                    if (oldVisibleTransactions.get(i).controller != newVisibleTransactions.get(i).controller) {
-                        visibleTransactionsChanged = true;
-                        break;
+            boolean visibleTransactionsChanged = !backstacksAreEqual(newVisibleTransactions, oldVisibleTransactions);
+            if (visibleTransactionsChanged) {
+                RouterTransaction oldRootTransaction = oldVisibleTransactions.size() > 0 ? oldVisibleTransactions.get(0) : null;
+                RouterTransaction newRootTransaction = newVisibleTransactions.get(0);
+
+                // Replace the old root with the new one
+                if (oldRootTransaction == null || oldRootTransaction.controller != newRootTransaction.controller) {
+                    // Ensure the existing root controller is fully pushed to the view hierarchy
+                    if (oldRootTransaction != null) {
+                        ControllerChangeHandler.completeHandlerImmediately(oldRootTransaction.controller.getInstanceId());
+                    }
+                    performControllerChange(newRootTransaction, oldRootTransaction, newRootRequiresPush, changeHandler);
+                }
+
+                // Remove all visible controllers that were previously on the backstack
+                for (int i = oldVisibleTransactions.size() - 1; i > 0; i--) {
+                    RouterTransaction transaction = oldVisibleTransactions.get(i);
+                    if (!newVisibleTransactions.contains(transaction)) {
+                        ControllerChangeHandler localHandler = changeHandler != null ? changeHandler.copy() : new SimpleSwapChangeHandler();
+                        localHandler.setForceRemoveViewOnPush(true);
+                        ControllerChangeHandler.completeHandlerImmediately(transaction.controller.getInstanceId());
+                        performControllerChange(null, transaction, newRootRequiresPush, localHandler);
+                    }
+                }
+
+                // Add any new controllers to the backstack
+                for (int i = 1; i < newVisibleTransactions.size(); i++) {
+                    RouterTransaction transaction = newVisibleTransactions.get(i);
+                    if (!oldVisibleTransactions.contains(transaction)) {
+                        performControllerChange(transaction, newVisibleTransactions.get(i - 1), true, transaction.pushChangeHandler());
                     }
                 }
             }
 
-            if (visibleTransactionsChanged) {
-                ControllerChangeHandler handler = changeHandler != null ? changeHandler : new SimpleSwapChangeHandler();
-
-                Controller rootController = oldVisibleTransactions.size() > 0 ? oldVisibleTransactions.get(0).controller : null;
-                performControllerChange(newVisibleTransactions.get(0).controller, rootController, true, handler);
-
-                for (int i = oldVisibleTransactions.size() - 1; i > 0; i--) {
-                    RouterTransaction transaction = oldVisibleTransactions.get(i);
-                    ControllerChangeHandler localHandler = handler.copy();
-                    localHandler.setForceRemoveViewOnPush(true);
-                    performControllerChange(null, transaction.controller, true, localHandler);
-                }
-
-                for (int i = 1; i < newVisibleTransactions.size(); i++) {
-                    RouterTransaction transaction = newVisibleTransactions.get(i);
-                    handler = transaction.pushChangeHandler() != null ? transaction.pushChangeHandler().copy() : new SimpleSwapChangeHandler();
-                    performControllerChange(transaction.controller, newVisibleTransactions.get(i - 1).controller, true, handler);
-                }
-            }
-        }
-
-        if (onControllerPushedListener != null) {
+            // Ensure all new controllers have a valid router set
             for (RouterTransaction transaction : newBackstack) {
-                onControllerPushedListener.onControllerPushed(transaction.controller);
+                transaction.controller.setRouter(this);
             }
         }
     }
@@ -407,6 +469,7 @@ public abstract class Router {
      *
      * @param changeListener The listener
      */
+    @SuppressWarnings("WeakerAccess")
     public void addChangeListener(@NonNull ControllerChangeListener changeListener) {
         if (!changeListeners.contains(changeListener)) {
             changeListeners.add(changeListener);
@@ -418,6 +481,7 @@ public abstract class Router {
      *
      * @param changeListener The listener to be removed
      */
+    @SuppressWarnings("WeakerAccess")
     public void removeChangeListener(@NonNull ControllerChangeListener changeListener) {
         changeListeners.remove(changeListener);
     }
@@ -427,12 +491,14 @@ public abstract class Router {
      */
     @UiThread
     public void rebindIfNeeded() {
+        ThreadUtils.ensureMainThread();
+
         Iterator<RouterTransaction> backstackIterator = backstack.reverseIterator();
         while (backstackIterator.hasNext()) {
             RouterTransaction transaction = backstackIterator.next();
 
             if (transaction.controller.getNeedsAttach()) {
-                performControllerChange(transaction.controller, null, true, new SimpleSwapChangeHandler(false));
+                performControllerChange(transaction, null, true, new SimpleSwapChangeHandler(false));
             }
         }
     }
@@ -489,7 +555,7 @@ public abstract class Router {
         changeListeners.clear();
 
         for (RouterTransaction transaction : backstack) {
-            transaction.controller.activityDestroyed(activity.isChangingConfigurations());
+            transaction.controller.activityDestroyed(activity);
 
             for (Router childRouter : transaction.controller.getChildRouters()) {
                 childRouter.onActivityDestroyed(activity);
@@ -498,7 +564,7 @@ public abstract class Router {
 
         for (int index = destroyingControllers.size() - 1; index >= 0; index--) {
             Controller controller = destroyingControllers.get(index);
-            controller.activityDestroyed(activity.isChangingConfigurations());
+            controller.activityDestroyed(activity);
 
             for (Router childRouter : controller.getChildRouters()) {
                 childRouter.onActivityDestroyed(activity);
@@ -508,10 +574,10 @@ public abstract class Router {
         container = null;
     }
 
-    public void prepareForHostDetach() {
+    void prepareForHostDetach() {
         for (RouterTransaction transaction : backstack) {
-            if (ControllerChangeHandler.completePushImmediately(transaction.controller.getInstanceId())) {
-                transaction.controller.setNeedsAttach();
+            if (ControllerChangeHandler.completeHandlerImmediately(transaction.controller.getInstanceId())) {
+                transaction.controller.setNeedsAttach(true);
             }
             transaction.controller.prepareForHostDetach();
         }
@@ -529,6 +595,7 @@ public abstract class Router {
 
     public void restoreInstanceState(@NonNull Bundle savedInstanceState) {
         Bundle backstackBundle = savedInstanceState.getParcelable(KEY_BACKSTACK);
+        //noinspection ConstantConditions
         backstack.restoreInstanceState(backstackBundle);
         popsLastView = savedInstanceState.getBoolean(KEY_POPS_LAST_VIEW);
 
@@ -574,29 +641,51 @@ public abstract class Router {
     }
 
     private void popToTransaction(@NonNull RouterTransaction transaction, @Nullable ControllerChangeHandler changeHandler) {
-        RouterTransaction topTransaction = backstack.peek();
-        List<RouterTransaction> poppedTransactions = backstack.popTo(transaction);
-        trackDestroyingControllers(poppedTransactions);
+        if (backstack.size() > 0) {
+            RouterTransaction topTransaction = backstack.peek();
+
+            List<RouterTransaction> updatedBackstack = new ArrayList<>();
+            Iterator<RouterTransaction> backstackIterator = backstack.reverseIterator();
+            while (backstackIterator.hasNext()) {
+                RouterTransaction existingTransaction = backstackIterator.next();
+                updatedBackstack.add(existingTransaction);
+                if (existingTransaction == transaction) {
+                    break;
+                }
+            }
 
-        if (poppedTransactions.size() > 0) {
             if (changeHandler == null) {
+                //noinspection ConstantConditions
                 changeHandler = topTransaction.popChangeHandler();
             }
 
-            performControllerChange(backstack.peek().controller, topTransaction.controller, false, changeHandler);
+            setBackstack(updatedBackstack, changeHandler);
         }
     }
 
-    final void setOnControllerPushedListener(OnControllerPushedListener listener) {
-        onControllerPushedListener = listener;
+    void watchContainerAttach() {
+        container.post(new Runnable() {
+            @Override
+            public void run() {
+                containerFullyAttached = true;
+            }
+        });
     }
 
     void prepareForContainerRemoval() {
+        containerFullyAttached = false;
+
         if (container != null) {
             container.setOnHierarchyChangeListener(null);
         }
     }
 
+    void onContextAvailable() {
+        for (RouterTransaction transaction : backstack) {
+            transaction.controller.onContextAvailable();
+        }
+    }
+
     @NonNull
     final List<Controller> getControllers() {
         List<Controller> controllers = new ArrayList<>();
@@ -631,33 +720,72 @@ public abstract class Router {
         } else if (from != null) {
             changeHandler = from.popChangeHandler();
         } else {
-            changeHandler = new SimpleSwapChangeHandler();
+            changeHandler = null;
         }
 
+        performControllerChange(to, from, isPush, changeHandler);
+    }
+
+    private void performControllerChange(@Nullable RouterTransaction to, @Nullable RouterTransaction from, boolean isPush, @Nullable ControllerChangeHandler changeHandler) {
         Controller toController = to != null ? to.controller : null;
         Controller fromController = from != null ? from.controller : null;
+        boolean forceDetachDestroy = false;
+
+        if (to != null) {
+            to.ensureValidIndex(getTransactionIndexer());
+            setControllerRouter(toController);
+        } else if (backstack.size() == 0 && !popsLastView) {
+            // We're emptying out the backstack. Views get weird if you transition them out, so just no-op it. The host
+            // Activity or controller should be handling this by finishing or at least hiding this view.
+            changeHandler = new NoOpControllerChangeHandler();
+            forceDetachDestroy = true;
+        }
 
         performControllerChange(toController, fromController, isPush, changeHandler);
+
+        if (forceDetachDestroy && fromController != null && fromController.getView() != null) {
+            fromController.detach(fromController.getView(), true, false);
+        }
     }
 
-    private void performControllerChange(@Nullable final Controller to, @Nullable final Controller from, boolean isPush, @Nullable ControllerChangeHandler changeHandler) {
-        if (to != null) {
-            setControllerRouter(to);
-        } else if (backstack.size() == 0 && !popsLastView) {
-            // We're emptying out the backstack. Views get weird if you transition them out, so just no-op it. The hosting
-            // Activity should be handling this by finishing or at least hiding this view.
-            changeHandler = new NoOpControllerChangeHandler();
+    private void performControllerChange(@Nullable final Controller to, @Nullable final Controller from, final boolean isPush, @Nullable final ControllerChangeHandler changeHandler) {
+        if (isPush && to != null && to.isDestroyed()) {
+            throw new IllegalStateException("Trying to push a controller that has already been destroyed. (" + to.getClass().getSimpleName() + ")");
         }
 
-        ControllerChangeHandler.executeChange(to, from, isPush, container, changeHandler, changeListeners);
+        final ChangeTransaction transaction = new ChangeTransaction(to, from, isPush, container, changeHandler, changeListeners);
+
+        if (pendingControllerChanges.size() > 0) {
+            // If we already have changes queued up (awaiting full container attach), queue this one up as well so they don't happen
+            // out of order.
+            pendingControllerChanges.add(transaction);
+        } else if (from != null && (changeHandler == null || changeHandler.removesFromViewOnPush()) && !containerFullyAttached) {
+            // If the change handler will remove the from view, we have to make sure the container is fully attached first so we avoid NPEs
+            // within ViewGroup (details on issue #287). Post this to the container to ensure the attach is complete before we try to remove
+            // anything.
+            pendingControllerChanges.add(transaction);
+            container.post(new Runnable() {
+                @Override
+                public void run() {
+                    performPendingControllerChanges();
+                }
+            });
+        } else {
+            ControllerChangeHandler.executeChange(transaction);
+        }
     }
 
-    private void pushToBackstack(@NonNull RouterTransaction entry) {
+    void performPendingControllerChanges() {
+        // We're intentionally using dynamic size checking (list.size()) here so we can account for changes
+        // that occur during this loop (ex: if a controller is popped from within onAttach)
+        for (int i = 0; i < pendingControllerChanges.size(); i++) {
+            ControllerChangeHandler.executeChange(pendingControllerChanges.get(i));
+        }
+        pendingControllerChanges.clear();
+    }
+
+    protected void pushToBackstack(@NonNull RouterTransaction entry) {
         backstack.push(entry);
-
-        if (onControllerPushedListener != null) {
-            onControllerPushedListener.onControllerPushed(entry.controller);
-        }
     }
 
     private void trackDestroyingController(@NonNull RouterTransaction transaction) {
@@ -703,6 +831,22 @@ public abstract class Router {
         }
     }
 
+    // Swap around transaction indicies to ensure they don't get thrown out of order by the
+    // developer rearranging the backstack at runtime.
+    private void ensureOrderedTransactionIndices(List<RouterTransaction> backstack) {
+        List<Integer> indices = new ArrayList<>();
+        for (RouterTransaction transaction : backstack) {
+            transaction.ensureValidIndex(getTransactionIndexer());
+            indices.add(transaction.transactionIndex);
+        }
+
+        Collections.sort(indices);
+
+        for (int i = 0; i < backstack.size(); i++) {
+            backstack.get(i).transactionIndex = indices.get(i);
+        }
+    }
+
     private void addRouterViewsToList(@NonNull Router router, @NonNull List<View> list) {
         for (Controller controller : router.getControllers()) {
             if (controller.getView() != null) {
@@ -721,6 +865,7 @@ public abstract class Router {
             RouterTransaction transaction = backstackIterator.next();
             transactions.add(transaction);
 
+            //noinspection ConstantConditions
             if (transaction.pushChangeHandler() == null || transaction.pushChangeHandler().removesFromViewOnPush()) {
                 break;
             }
@@ -730,22 +875,37 @@ public abstract class Router {
         return transactions;
     }
 
+    private boolean backstacksAreEqual(List<RouterTransaction> lhs, List<RouterTransaction> rhs) {
+        if (lhs.size() != rhs.size()) {
+            return false;
+        }
+
+        for (int i = 0; i < rhs.size(); i++) {
+            if (rhs.get(i).controller() != lhs.get(i).controller()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     void setControllerRouter(@NonNull Controller controller) {
         controller.setRouter(this);
+        controller.onContextAvailable();
     }
 
     abstract void invalidateOptionsMenu();
     abstract void startActivity(@NonNull Intent intent);
     abstract void startActivityForResult(@NonNull String instanceId, @NonNull Intent intent, int requestCode);
     abstract void startActivityForResult(@NonNull String instanceId, @NonNull Intent intent, int requestCode, @Nullable Bundle options);
+    abstract void startIntentSenderForResult(@NonNull String instanceId, @NonNull IntentSender intent, int requestCode, @Nullable Intent fillInIntent, int flagsMask,
+                                             int flagsValues, int extraFlags, @Nullable Bundle options) throws IntentSender.SendIntentException;
     abstract void registerForActivityResult(@NonNull String instanceId, int requestCode);
     abstract void unregisterForActivityResults(@NonNull String instanceId);
     abstract void requestPermissions(@NonNull String instanceId, @NonNull String[] permissions, int requestCode);
     abstract boolean hasHost();
     @NonNull abstract List<Router> getSiblingRouters();
     @NonNull abstract Router getRootRouter();
+    @Nullable abstract TransactionIndexer getTransactionIndexer();
 
-    interface OnControllerPushedListener {
-        void onControllerPushed(Controller controller);
-    }
 }

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

@@ -4,15 +4,20 @@ import android.os.Bundle;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 
+import com.bluelinelabs.conductor.internal.TransactionIndexer;
+
 /**
  * Metadata used for adding {@link Controller}s to a {@link Router}.
  */
 public class RouterTransaction {
 
+    private static int INVALID_INDEX = -1;
+
     private static final String KEY_VIEW_CONTROLLER_BUNDLE = "RouterTransaction.controller.bundle";
     private static final String KEY_PUSH_TRANSITION = "RouterTransaction.pushControllerChangeHandler";
     private static final String KEY_POP_TRANSITION = "RouterTransaction.popControllerChangeHandler";
     private static final String KEY_TAG = "RouterTransaction.tag";
+    private static final String KEY_INDEX = "RouterTransaction.transactionIndex";
     private static final String KEY_ATTACHED_TO_ROUTER = "RouterTransaction.attachedToRouter";
 
     @NonNull final Controller controller;
@@ -21,6 +26,7 @@ public class RouterTransaction {
     private ControllerChangeHandler pushControllerChangeHandler;
     private ControllerChangeHandler popControllerChangeHandler;
     private boolean attachedToRouter;
+    int transactionIndex = INVALID_INDEX;
 
     @NonNull
     public static RouterTransaction with(@NonNull Controller controller) {
@@ -36,6 +42,7 @@ public class RouterTransaction {
         pushControllerChangeHandler = ControllerChangeHandler.fromBundle(bundle.getBundle(KEY_PUSH_TRANSITION));
         popControllerChangeHandler = ControllerChangeHandler.fromBundle(bundle.getBundle(KEY_POP_TRANSITION));
         tag = bundle.getString(KEY_TAG);
+        transactionIndex = bundle.getInt(KEY_INDEX);
         attachedToRouter = bundle.getBoolean(KEY_ATTACHED_TO_ROUTER);
     }
 
@@ -101,6 +108,15 @@ public class RouterTransaction {
         }
     }
 
+    void ensureValidIndex(@Nullable TransactionIndexer indexer) {
+        if (indexer == null) {
+            throw new RuntimeException();
+        }
+        if (transactionIndex == INVALID_INDEX && indexer != null) {
+            transactionIndex = indexer.nextIndex();
+        }
+    }
+
     /**
      * Used to serialize this transaction into a Bundle
      */
@@ -118,9 +134,10 @@ public class RouterTransaction {
         }
 
         bundle.putString(KEY_TAG, tag);
+        bundle.putInt(KEY_INDEX, transactionIndex);
         bundle.putBoolean(KEY_ATTACHED_TO_ROUTER, attachedToRouter);
 
         return bundle;
     }
 
-}
+}

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/AnimatorChangeHandler.java

@@ -21,6 +21,7 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
     private static final String KEY_DURATION = "AnimatorChangeHandler.duration";
     private static final String KEY_REMOVES_FROM_ON_PUSH = "AnimatorChangeHandler.removesFromViewOnPush";
 
+    @SuppressWarnings("WeakerAccess")
     public static final long DEFAULT_ANIMATION_DURATION = -1;
 
     private long animationDuration;
@@ -29,15 +30,19 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
     private boolean needsImmediateCompletion;
     private boolean completed;
     private Animator animator;
+    private OnAnimationReadyOrAbortedListener onAnimationReadyOrAbortedListener;
 
+    @SuppressWarnings("WeakerAccess")
     public AnimatorChangeHandler() {
         this(DEFAULT_ANIMATION_DURATION, true);
     }
 
+    @SuppressWarnings("WeakerAccess")
     public AnimatorChangeHandler(boolean removesFromViewOnPush) {
         this(DEFAULT_ANIMATION_DURATION, removesFromViewOnPush);
     }
 
+    @SuppressWarnings("WeakerAccess")
     public AnimatorChangeHandler(long duration) {
         this(duration, true);
     }
@@ -68,6 +73,8 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
         canceled = true;
         if (animator != null) {
             animator.cancel();
+        } else if (onAnimationReadyOrAbortedListener != null) {
+            onAnimationReadyOrAbortedListener.onReadyOrAborted();
         }
     }
 
@@ -78,6 +85,8 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
         needsImmediateCompletion = true;
         if (animator != null) {
             animator.end();
+        } else if (onAnimationReadyOrAbortedListener != null) {
+            onAnimationReadyOrAbortedListener.onReadyOrAborted();
         }
     }
 
@@ -94,8 +103,8 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
      * Should be overridden to return the Animator to use while replacing Views.
      *
      * @param container The container these Views are hosted in.
-     * @param from The previous View in the container, if any.
-     * @param to The next View that should be put in the container, if any.
+     * @param from The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to The next View that should be put in the container or {@code null} if no Controller is being transitioned to
      * @param isPush True if this is a push transaction, false if it's a pop.
      * @param toAddedToContainer True if the "to" view was added to the container as a part of this ChangeHandler. False if it was already in the hierarchy.
      */
@@ -121,17 +130,8 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
 
             if (to.getWidth() <= 0 && to.getHeight() <= 0) {
                 readyToAnimate = false;
-                to.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
-                    @Override
-                    public boolean onPreDraw() {
-                        final ViewTreeObserver observer = to.getViewTreeObserver();
-                        if (observer.isAlive()) {
-                            observer.removeOnPreDrawListener(this);
-                        }
-                        performAnimation(container, from, to, isPush, addingToView, changeListener);
-                        return true;
-                    }
-                });
+                onAnimationReadyOrAbortedListener = new OnAnimationReadyOrAbortedListener(container, from, to, isPush, true, changeListener);
+                to.getViewTreeObserver().addOnPreDrawListener(onAnimationReadyOrAbortedListener);
             }
         }
 
@@ -150,8 +150,11 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
             if (animatorListener != null) {
                 animator.removeListener(animatorListener);
             }
+            animator.cancel();
             animator = null;
         }
+
+        onAnimationReadyOrAbortedListener = null;
     }
 
     private void performAnimation(@NonNull final ViewGroup container, @Nullable final View from, @Nullable final View to, final boolean isPush, final boolean toAddedToContainer, @NonNull final ControllerChangeCompletedListener changeListener) {
@@ -159,6 +162,16 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
             complete(changeListener, null);
             return;
         }
+        if (needsImmediateCompletion) {
+            if (from != null && (!isPush || removesFromViewOnPush)) {
+                container.removeView(from);
+            }
+            complete(changeListener, null);
+            if (isPush && from != null) {
+                resetFromView(from);
+            }
+            return;
+        }
 
         animator = getAnimator(container, from, to, isPush, toAddedToContainer);
 
@@ -195,4 +208,46 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
         animator.start();
     }
 
+    private class OnAnimationReadyOrAbortedListener implements ViewTreeObserver.OnPreDrawListener {
+        @NonNull final ViewGroup container;
+        @Nullable final View from;
+        @Nullable final View to;
+        final boolean isPush;
+        final boolean addingToView;
+        @NonNull final ControllerChangeCompletedListener changeListener;
+        private boolean hasRun;
+
+        OnAnimationReadyOrAbortedListener(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush, boolean addingToView, @NonNull ControllerChangeCompletedListener changeListener) {
+            this.container = container;
+            this.from = from;
+            this.to = to;
+            this.isPush = isPush;
+            this.addingToView = addingToView;
+            this.changeListener = changeListener;
+        }
+
+        @Override
+        public boolean onPreDraw() {
+            onReadyOrAborted();
+
+            return true;
+        }
+
+        void onReadyOrAborted() {
+            if (!hasRun) {
+                hasRun = true;
+
+                if (to != null) {
+                    final ViewTreeObserver observer = to.getViewTreeObserver();
+                    if (observer.isAlive()) {
+                        observer.removeOnPreDrawListener(this);
+                    }
+                }
+
+                performAnimation(container, from, to, isPush, addingToView, changeListener);
+            }
+        }
+
+    }
+
 }

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/AutoTransitionChangeHandler.java

@@ -9,6 +9,8 @@ import android.transition.Transition;
 import android.view.View;
 import android.view.ViewGroup;
 
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+
 /**
  * A change handler that will use an AutoTransition.
  */
@@ -20,4 +22,9 @@ public class AutoTransitionChangeHandler extends TransitionChangeHandler {
         return new AutoTransition();
     }
 
+    @Override @NonNull
+    public ControllerChangeHandler copy() {
+        return new AutoTransitionChangeHandler();
+    }
+
 }

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/FadeChangeHandler.java

@@ -8,6 +8,8 @@ import android.support.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+
 /**
  * An {@link AnimatorChangeHandler} that will cross fade two views
  */
@@ -30,11 +32,12 @@ public class FadeChangeHandler extends AnimatorChangeHandler {
     @Override @NonNull
     protected Animator getAnimator(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush, boolean toAddedToContainer) {
         AnimatorSet animator = new AnimatorSet();
-        if (to != null && toAddedToContainer) {
-            animator.play(ObjectAnimator.ofFloat(to, View.ALPHA, 0, 1));
+        if (to != null) {
+            float start = toAddedToContainer ? 0 : to.getAlpha();
+            animator.play(ObjectAnimator.ofFloat(to, View.ALPHA, start, 1));
         }
 
-        if (from != null) {
+        if (from != null && (!isPush || removesFromViewOnPush())) {
             animator.play(ObjectAnimator.ofFloat(from, View.ALPHA, 0));
         }
 
@@ -45,4 +48,10 @@ public class FadeChangeHandler extends AnimatorChangeHandler {
     protected void resetFromView(@NonNull View from) {
         from.setAlpha(1);
     }
+
+    @Override @NonNull
+    public ControllerChangeHandler copy() {
+        return new FadeChangeHandler(getAnimationDuration(), removesFromViewOnPush());
+    }
+
 }

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/HorizontalChangeHandler.java

@@ -8,6 +8,8 @@ import android.support.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+
 /**
  * An {@link AnimatorChangeHandler} that will slide the views left or right, depending on if it's a push or pop.
  */
@@ -43,7 +45,9 @@ public class HorizontalChangeHandler extends AnimatorChangeHandler {
                 animatorSet.play(ObjectAnimator.ofFloat(from, View.TRANSLATION_X, from.getWidth()));
             }
             if (to != null) {
-                animatorSet.play(ObjectAnimator.ofFloat(to, View.TRANSLATION_X, -to.getWidth(), 0));
+                // Allow this to have a nice transition when coming off an aborted push animation
+                float fromLeft = from != null ? from.getTranslationX() : 0;
+                animatorSet.play(ObjectAnimator.ofFloat(to, View.TRANSLATION_X, fromLeft - to.getWidth(), 0));
             }
         }
 
@@ -54,4 +58,10 @@ public class HorizontalChangeHandler extends AnimatorChangeHandler {
     protected void resetFromView(@NonNull View from) {
         from.setTranslationX(0);
     }
+
+    @Override @NonNull
+    public ControllerChangeHandler copy() {
+        return new HorizontalChangeHandler(getAnimationDuration(), removesFromViewOnPush());
+    }
+
 }

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/SimpleSwapChangeHandler.java

@@ -102,4 +102,14 @@ public class SimpleSwapChangeHandler extends ControllerChangeHandler implements
 
     @Override
     public void onViewDetachedFromWindow(@NonNull View v) { }
+
+    @Override @NonNull
+    public ControllerChangeHandler copy() {
+        return new SimpleSwapChangeHandler(removesFromViewOnPush());
+    }
+
+    @Override
+    public boolean isReusable() {
+        return true;
+    }
 }

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/TransitionChangeHandler.java

@@ -19,15 +19,20 @@ import com.bluelinelabs.conductor.ControllerChangeHandler;
 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public abstract class TransitionChangeHandler extends ControllerChangeHandler {
 
+    public interface OnTransitionPreparedListener {
+        void onPrepared();
+    }
+
     private boolean canceled;
+    private boolean needsImmediateCompletion;
 
     /**
      * Should be overridden to return the Transition to use while replacing Views.
      *
-     * @param container The container these Views are hosted in.
-     * @param from The previous View in the container, if any.
-     * @param to The next View that should be put in the container, if any.
-     * @param isPush True if this is a push transaction, false if it's a pop.
+     * @param container The container these Views are hosted in
+     * @param from      The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to        The next View that should be put in the container or {@code null} if no Controller is being transitioned to
+     * @param isPush    True if this is a push transaction, false if it's a pop
      */
     @NonNull
     protected abstract Transition getTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush);
@@ -40,13 +45,25 @@ public abstract class TransitionChangeHandler extends ControllerChangeHandler {
     }
 
     @Override
-    public void performChange(@NonNull final ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush, @NonNull final ControllerChangeCompletedListener changeListener) {
+    public void completeImmediately() {
+        super.completeImmediately();
+
+        needsImmediateCompletion = true;
+    }
+
+    @Override
+    public void performChange(@NonNull final ViewGroup container, @Nullable final View from, @Nullable final View to, final boolean isPush, @NonNull final ControllerChangeCompletedListener changeListener) {
         if (canceled) {
             changeListener.onChangeCompleted();
             return;
         }
+        if (needsImmediateCompletion) {
+            executePropertyChanges(container, from, to, null, isPush);
+            changeListener.onChangeCompleted();
+            return;
+        }
 
-        Transition transition = getTransition(container, from, to, isPush);
+        final Transition transition = getTransition(container, from, to, isPush);
         transition.addListener(new TransitionListener() {
             @Override
             public void onTransitionStart(Transition transition) { }
@@ -68,8 +85,48 @@ public abstract class TransitionChangeHandler extends ControllerChangeHandler {
             public void onTransitionResume(Transition transition) { }
         });
 
-        TransitionManager.beginDelayedTransition(container, transition);
-        if (from != null) {
+        prepareForTransition(container, from, to, transition, isPush, new OnTransitionPreparedListener() {
+            @Override
+            public void onPrepared() {
+                if (!canceled) {
+                    TransitionManager.beginDelayedTransition(container, transition);
+                    executePropertyChanges(container, from, to, transition, isPush);
+                }
+            }
+        });
+    }
+
+    @Override
+    public boolean removesFromViewOnPush() {
+        return true;
+    }
+
+    /**
+     * Called before a transition occurs. This can be used to reorder views, set their transition names, etc. The transition will begin
+     * when {@code onTransitionPreparedListener} is called.
+     *
+     * @param container  The container these Views are hosted in
+     * @param from       The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to         The next View that should be put in the container or {@code null} if no Controller is being transitioned to
+     * @param transition The transition that is being prepared for
+     * @param isPush     True if this is a push transaction, false if it's a pop
+     */
+    public void prepareForTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, @NonNull Transition transition, boolean isPush, @NonNull OnTransitionPreparedListener onTransitionPreparedListener) {
+        onTransitionPreparedListener.onPrepared();
+    }
+
+    /**
+     * This should set all view properties needed for the transition to work properly. By default it removes the "from" view
+     * and adds the "to" view.
+     *
+     * @param container  The container these Views are hosted in
+     * @param from       The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to         The next View that should be put in the container or {@code null} if no Controller is being transitioned to
+     * @param transition The transition with which {@code TransitionManager.beginDelayedTransition} has been called. This will be null only if another ControllerChangeHandler immediately overrides this one.
+     * @param isPush     True if this is a push transaction, false if it's a pop
+     */
+    public void executePropertyChanges(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, @Nullable Transition transition, boolean isPush) {
+        if (from != null && (removesFromViewOnPush() || !isPush) && from.getParent() == container) {
             container.removeView(from);
         }
         if (to != null && to.getParent() == null) {
@@ -77,8 +134,4 @@ public abstract class TransitionChangeHandler extends ControllerChangeHandler {
         }
     }
 
-    @Override
-    public final boolean removesFromViewOnPush() {
-        return true;
-    }
 }

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/TransitionChangeHandlerCompat.java

@@ -7,6 +7,7 @@ import android.support.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 
+import com.bluelinelabs.conductor.Controller;
 import com.bluelinelabs.conductor.ControllerChangeHandler;
 import com.bluelinelabs.conductor.internal.ClassUtils;
 
@@ -69,4 +70,28 @@ public class TransitionChangeHandlerCompat extends ControllerChangeHandler {
         return changeHandler.removesFromViewOnPush();
     }
 
+    @Override @NonNull
+    public ControllerChangeHandler copy() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            return new TransitionChangeHandlerCompat((TransitionChangeHandler)changeHandler.copy(), null);
+        } else {
+            return new TransitionChangeHandlerCompat(null, changeHandler.copy());
+        }
+    }
+
+    @Override
+    public void onAbortPush(@NonNull ControllerChangeHandler newHandler, @Nullable Controller newTop) {
+        changeHandler.onAbortPush(newHandler, newTop);
+    }
+
+    @Override
+    public void completeImmediately() {
+        changeHandler.completeImmediately();
+    }
+
+    @Override
+    public void setForceRemoveViewOnPush(boolean force) {
+        changeHandler.setForceRemoveViewOnPush(force);
+    }
+
 }

conductor/src/main/java/com/bluelinelabs/conductor/changehandler/VerticalChangeHandler.java

@@ -8,6 +8,8 @@ import android.support.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+
 import java.util.ArrayList;
 import java.util.List;
 
@@ -49,4 +51,9 @@ public class VerticalChangeHandler extends AnimatorChangeHandler {
     @Override
     protected void resetFromView(@NonNull View from) { }
 
+    @Override @NonNull
+    public ControllerChangeHandler copy() {
+        return new VerticalChangeHandler(getAnimationDuration(), removesFromViewOnPush());
+    }
+
 }

conductor/src/main/java/com/bluelinelabs/conductor/internal/LifecycleHandler.java

@@ -6,6 +6,7 @@ import android.app.Application.ActivityLifecycleCallbacks;
 import android.app.Fragment;
 import android.content.Context;
 import android.content.Intent;
+import android.content.IntentSender;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcel;
@@ -40,6 +41,7 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
     private boolean destroyed;
     private boolean attached;
 
+    private static final Map<Activity, LifecycleHandler> activeLifecycleHandlers = new HashMap<>();
     private SparseArray<String> permissionRequestMap = new SparseArray<>();
     private SparseArray<String> activityRequestMap = new SparseArray<>();
     private ArrayList<PendingPermissionRequest> pendingPermissionRequests = new ArrayList<>();
@@ -53,7 +55,10 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
 
     @Nullable
     private static LifecycleHandler findInActivity(@NonNull Activity activity) {
-        LifecycleHandler lifecycleHandler = (LifecycleHandler)activity.getFragmentManager().findFragmentByTag(FRAGMENT_TAG);
+        LifecycleHandler lifecycleHandler = activeLifecycleHandlers.get(activity);
+        if (lifecycleHandler == null) {
+            lifecycleHandler = (LifecycleHandler)activity.getFragmentManager().findFragmentByTag(FRAGMENT_TAG);
+        }
         if (lifecycleHandler != null) {
             lifecycleHandler.registerActivityListener(activity);
         }
@@ -112,6 +117,11 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
         if (!hasRegisteredCallbacks) {
             hasRegisteredCallbacks = true;
             activity.getApplication().registerActivityLifecycleCallbacks(this);
+
+            // Since Fragment transactions are async, we have to keep an <Activity, LifecycleHandler> map in addition
+            // to trying to find the LifecycleHandler fragment in the Activity to handle the case of the developer
+            // trying to immediately get > 1 router in the same Activity. See issue #299.
+            activeLifecycleHandlers.put(activity, this);
         }
     }
 
@@ -146,6 +156,7 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
 
         if (activity != null) {
             activity.getApplication().unregisterActivityLifecycleCallbacks(this);
+            activeLifecycleHandlers.remove(activity);
             destroyRouters();
             activity = null;
         }
@@ -183,6 +194,10 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
                 requestPermissions(request.instanceId, request.permissions, request.requestCode);
             }
         }
+
+        for (ActivityHostedRouter router : routerMap.values()) {
+            router.onContextAvailable();
+        }
     }
 
     private void destroyRouters() {
@@ -283,6 +298,14 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
         startActivityForResult(intent, requestCode, options);
     }
 
+    @TargetApi(Build.VERSION_CODES.N)
+    public void startIntentSenderForResult(@NonNull String instanceId, @NonNull IntentSender intent, int requestCode,
+                                           @Nullable Intent fillInIntent, int flagsMask, int flagsValues, int extraFlags,
+                                           @Nullable Bundle options) throws IntentSender.SendIntentException {
+        registerForActivityResult(instanceId, requestCode);
+        startIntentSenderForResult(intent, requestCode, fillInIntent, flagsMask, flagsValues, extraFlags, options);
+    }
+
     @TargetApi(Build.VERSION_CODES.M)
     public void requestPermissions(@NonNull String instanceId, @NonNull String[] permissions, int requestCode) {
         if (attached) {
@@ -297,6 +320,10 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
     public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
         if (this.activity == null && findInActivity(activity) == LifecycleHandler.this) {
             this.activity = activity;
+
+            for (ActivityHostedRouter router : routerMap.values()) {
+                router.onContextAvailable();
+            }
         }
     }
 
@@ -348,7 +375,9 @@ public class LifecycleHandler extends Fragment implements ActivityLifecycleCallb
     }
 
     @Override
-    public void onActivityDestroyed(Activity activity) { }
+    public void onActivityDestroyed(Activity activity) {
+        activeLifecycleHandlers.remove(activity);
+    }
 
     private static class PendingPermissionRequest implements Parcelable {
         final String instanceId;

conductor/src/main/java/com/bluelinelabs/conductor/internal/NoOpControllerChangeHandler.java

@@ -14,4 +14,14 @@ public class NoOpControllerChangeHandler extends ControllerChangeHandler {
         changeListener.onChangeCompleted();
     }
 
-}
+    @NonNull
+    @Override
+    public ControllerChangeHandler copy() {
+        return new NoOpControllerChangeHandler();
+    }
+
+    @Override
+    public boolean isReusable() {
+        return true;
+    }
+}

conductor/src/main/java/com/bluelinelabs/conductor/internal/ThreadUtils.java

@@ -0,0 +1,20 @@
+package com.bluelinelabs.conductor.internal;
+
+import android.os.Looper;
+import android.util.AndroidRuntimeException;
+
+public class ThreadUtils {
+
+    public static void ensureMainThread() {
+        if (Looper.getMainLooper().getThread() != Thread.currentThread()) {
+            throw new CalledFromWrongThreadException("Methods that affect the view hierarchy can can only be called from the main thread.");
+        }
+    }
+
+    private static final class CalledFromWrongThreadException extends AndroidRuntimeException {
+        CalledFromWrongThreadException(String msg) {
+            super(msg);
+        }
+    }
+
+}

conductor/src/main/java/com/bluelinelabs/conductor/internal/TransactionIndexer.java

@@ -0,0 +1,24 @@
+package com.bluelinelabs.conductor.internal;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+
+public class TransactionIndexer {
+
+    private static final String KEY_INDEX = "TransactionIndexer.currentIndex";
+
+    private int currentIndex;
+
+    public int nextIndex() {
+        return ++currentIndex;
+    }
+
+    public void saveInstanceState(@NonNull Bundle outState) {
+        outState.putInt(KEY_INDEX, currentIndex);
+    }
+
+    public void restoreInstanceState(@NonNull Bundle savedInstanceState) {
+        currentIndex = savedInstanceState.getInt(KEY_INDEX);
+    }
+
+}

conductor/src/main/java/com/bluelinelabs/conductor/internal/ViewAttachHandler.java

@@ -0,0 +1,151 @@
+package com.bluelinelabs.conductor.internal;
+
+import android.view.View;
+import android.view.View.OnAttachStateChangeListener;
+import android.view.ViewGroup;
+
+public class ViewAttachHandler implements OnAttachStateChangeListener {
+
+    private enum ReportedState {
+        VIEW_DETACHED,
+        ACTIVITY_STOPPED,
+        ATTACHED
+    }
+
+    public interface ViewAttachListener {
+        void onAttached();
+        void onDetached(boolean fromActivityStop);
+        void onViewDetachAfterStop();
+    }
+
+    private interface ChildAttachListener {
+        void onAttached();
+    }
+
+    private boolean rootAttached = false;
+    private boolean childrenAttached = false;
+    private boolean activityStopped = false;
+    private ReportedState reportedState = ReportedState.VIEW_DETACHED;
+    private ViewAttachListener attachListener;
+    private OnAttachStateChangeListener childOnAttachStateChangeListener;
+
+    public ViewAttachHandler(ViewAttachListener attachListener) {
+        this.attachListener = attachListener;
+    }
+
+    @Override
+    public void onViewAttachedToWindow(final View v) {
+        if (rootAttached) {
+            return;
+        }
+
+        rootAttached = true;
+        listenForDeepestChildAttach(v, new ChildAttachListener() {
+            @Override
+            public void onAttached() {
+                childrenAttached = true;
+                reportAttached();
+
+            }
+        });
+    }
+
+    @Override
+    public void onViewDetachedFromWindow(View v) {
+        rootAttached = false;
+        if (childrenAttached) {
+            childrenAttached = false;
+            reportDetached(false);
+        }
+    }
+
+    public void listenForAttach(final View view) {
+        view.addOnAttachStateChangeListener(this);
+    }
+
+    public void unregisterAttachListener(View view) {
+        view.removeOnAttachStateChangeListener(this);
+
+        if (childOnAttachStateChangeListener != null && view instanceof ViewGroup) {
+            findDeepestChild((ViewGroup)view).removeOnAttachStateChangeListener(childOnAttachStateChangeListener);
+        }
+    }
+
+    public void onActivityStarted() {
+        activityStopped = false;
+        reportAttached();
+    }
+
+    public void onActivityStopped() {
+        activityStopped = true;
+        reportDetached(true);
+    }
+
+    private void reportAttached() {
+        if (rootAttached && childrenAttached && !activityStopped && reportedState != ReportedState.ATTACHED) {
+            reportedState = ReportedState.ATTACHED;
+            attachListener.onAttached();
+        }
+    }
+
+    private void reportDetached(boolean detachedForActivity) {
+        boolean wasDetachedForActivity = reportedState == ReportedState.ACTIVITY_STOPPED;
+
+        if (detachedForActivity) {
+            reportedState = ReportedState.ACTIVITY_STOPPED;
+        } else {
+            reportedState = ReportedState.VIEW_DETACHED;
+        }
+
+        if (wasDetachedForActivity && !detachedForActivity) {
+            attachListener.onViewDetachAfterStop();
+        } else {
+            attachListener.onDetached(detachedForActivity);
+        }
+    }
+
+    private void listenForDeepestChildAttach(final View view, final ChildAttachListener attachListener) {
+        if (!(view instanceof ViewGroup)) {
+            attachListener.onAttached();
+            return;
+        }
+
+        ViewGroup viewGroup = (ViewGroup)view;
+        if (viewGroup.getChildCount() == 0) {
+            attachListener.onAttached();
+            return;
+        }
+
+        childOnAttachStateChangeListener = new OnAttachStateChangeListener() {
+            boolean attached = false;
+
+            @Override
+            public void onViewAttachedToWindow(View v) {
+                if (!attached) {
+                    attached = true;
+                    attachListener.onAttached();
+                    v.removeOnAttachStateChangeListener(this);
+                    childOnAttachStateChangeListener = null;
+                }
+            }
+
+            @Override
+            public void onViewDetachedFromWindow(View v) { }
+        };
+        findDeepestChild(viewGroup).addOnAttachStateChangeListener(childOnAttachStateChangeListener);
+    }
+
+    private View findDeepestChild(ViewGroup viewGroup) {
+        if (viewGroup.getChildCount() == 0) {
+            return viewGroup;
+        }
+
+        View lastChild = viewGroup.getChildAt(viewGroup.getChildCount() - 1);
+        if (lastChild instanceof ViewGroup) {
+            return findDeepestChild((ViewGroup)lastChild);
+        } else {
+            return lastChild;
+        }
+    }
+
+}

conductor/src/test/java/com/bluelinelabs/conductor/BackstackTests.java

@@ -1,9 +1,12 @@
 package com.bluelinelabs.conductor;
 
-import org.junit.Assert;
+import com.bluelinelabs.conductor.util.TestController;
+
 import org.junit.Before;
 import org.junit.Test;
 
+import static org.junit.Assert.assertEquals;
+
 public class BackstackTests {
 
     private Backstack backstack;
@@ -15,20 +18,20 @@ public class BackstackTests {
 
     @Test
     public void testPush() {
-        Assert.assertEquals(0, backstack.size());
+        assertEquals(0, backstack.size());
         backstack.push(RouterTransaction.with(new TestController()));
-        Assert.assertEquals(1, backstack.size());
+        assertEquals(1, backstack.size());
     }
 
     @Test
     public void testPop() {
         backstack.push(RouterTransaction.with(new TestController()));
         backstack.push(RouterTransaction.with(new TestController()));
-        Assert.assertEquals(2, backstack.size());
+        assertEquals(2, backstack.size());
         backstack.pop();
-        Assert.assertEquals(1, backstack.size());
+        assertEquals(1, backstack.size());
         backstack.pop();
-        Assert.assertEquals(0, backstack.size());
+        assertEquals(0, backstack.size());
     }
 
     @Test
@@ -37,13 +40,13 @@ public class BackstackTests {
         RouterTransaction transaction2 = RouterTransaction.with(new TestController());
 
         backstack.push(transaction1);
-        Assert.assertEquals(transaction1, backstack.peek());
+        assertEquals(transaction1, backstack.peek());
 
         backstack.push(transaction2);
-        Assert.assertEquals(transaction2, backstack.peek());
+        assertEquals(transaction2, backstack.peek());
 
         backstack.pop();
-        Assert.assertEquals(transaction1, backstack.peek());
+        assertEquals(transaction1, backstack.peek());
     }
 
     @Test
@@ -56,11 +59,11 @@ public class BackstackTests {
         backstack.push(transaction2);
         backstack.push(transaction3);
 
-        Assert.assertEquals(3, backstack.size());
+        assertEquals(3, backstack.size());
 
         backstack.popTo(transaction1);
 
-        Assert.assertEquals(1, backstack.size());
-        Assert.assertEquals(transaction1, backstack.peek());
+        assertEquals(1, backstack.size());
+        assertEquals(transaction1, backstack.peek());
     }
 }

conductor/src/test/java/com/bluelinelabs/conductor/ControllerChangeHandlerTests.java

@@ -2,10 +2,12 @@ package com.bluelinelabs.conductor;
 
 import com.bluelinelabs.conductor.changehandler.FadeChangeHandler;
 import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler;
+import com.bluelinelabs.conductor.util.TestController;
 
-import org.junit.Assert;
 import org.junit.Test;
 
+import static org.junit.Assert.assertEquals;
+
 public class ControllerChangeHandlerTests {
 
     @Test
@@ -21,17 +23,17 @@ public class ControllerChangeHandlerTests {
         ControllerChangeHandler restoredHorizontal = restoredTransaction.pushChangeHandler();
         ControllerChangeHandler restoredFade = restoredTransaction.popChangeHandler();
 
-        Assert.assertEquals(horizontalChangeHandler.getClass(), restoredHorizontal.getClass());
-        Assert.assertEquals(fadeChangeHandler.getClass(), restoredFade.getClass());
+        assertEquals(horizontalChangeHandler.getClass(), restoredHorizontal.getClass());
+        assertEquals(fadeChangeHandler.getClass(), restoredFade.getClass());
 
         HorizontalChangeHandler restoredHorizontalCast = (HorizontalChangeHandler)restoredHorizontal;
         FadeChangeHandler restoredFadeCast = (FadeChangeHandler)restoredFade;
 
-        Assert.assertEquals(horizontalChangeHandler.getAnimationDuration(), restoredHorizontalCast.getAnimationDuration());
-        Assert.assertEquals(horizontalChangeHandler.removesFromViewOnPush(), restoredHorizontalCast.removesFromViewOnPush());
+        assertEquals(horizontalChangeHandler.getAnimationDuration(), restoredHorizontalCast.getAnimationDuration());
+        assertEquals(horizontalChangeHandler.removesFromViewOnPush(), restoredHorizontalCast.removesFromViewOnPush());
 
-        Assert.assertEquals(fadeChangeHandler.getAnimationDuration(), restoredFadeCast.getAnimationDuration());
-        Assert.assertEquals(fadeChangeHandler.removesFromViewOnPush(), restoredFadeCast.removesFromViewOnPush());
+        assertEquals(fadeChangeHandler.getAnimationDuration(), restoredFadeCast.getAnimationDuration());
+        assertEquals(fadeChangeHandler.removesFromViewOnPush(), restoredFadeCast.removesFromViewOnPush());
     }
 
 }

conductor/src/test/java/com/bluelinelabs/conductor/ControllerLifecycleActivityReferenceTests.java

@@ -0,0 +1,269 @@
+package com.bluelinelabs.conductor;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.MockChangeHandler;
+import com.bluelinelabs.conductor.util.TestController;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class ControllerLifecycleActivityReferenceTests {
+
+    private Router router;
+
+    private ActivityProxy activityProxy;
+
+    public void createActivityController(Bundle savedInstanceState, boolean includeStartAndResume) {
+        activityProxy = new ActivityProxy().create(savedInstanceState);
+
+        if (includeStartAndResume) {
+            activityProxy.start().resume();
+        }
+
+        router = Conductor.attachRouter(activityProxy.getActivity(), activityProxy.getView(), savedInstanceState);
+        router.setPopsLastView(true);
+        if (!router.hasRootController()) {
+            router.setRoot(RouterTransaction.with(new TestController()));
+        }
+    }
+
+    @Before
+    public void setup() {
+        createActivityController(null, true);
+    }
+
+    @Test
+    public void testSingleControllerActivityOnPush() {
+        Controller controller = new TestController();
+
+        assertNull(controller.getActivity());
+
+        ActivityReferencingLifecycleListener listener = new ActivityReferencingLifecycleListener();
+        controller.addLifecycleListener(listener);
+
+        router.pushController(RouterTransaction.with(controller)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        assertEquals(Collections.singletonList(true), listener.changeEndReferences);
+        assertEquals(Collections.singletonList(true), listener.postCreateViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postAttachReferences);
+        assertEquals(Collections.emptyList(), listener.postDetachReferences);
+        assertEquals(Collections.emptyList(), listener.postDestroyViewReferences);
+        assertEquals(Collections.emptyList(), listener.postDestroyReferences);
+    }
+
+    @Test
+    public void testChildControllerActivityOnPush() {
+        Controller parent = new TestController();
+        router.pushController(RouterTransaction.with(parent)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        TestController child = new TestController();
+
+        assertNull(child.getActivity());
+
+        ActivityReferencingLifecycleListener listener = new ActivityReferencingLifecycleListener();
+        child.addLifecycleListener(listener);
+
+        Router childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.VIEW_ID));
+        childRouter.pushController(RouterTransaction.with(child)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        assertEquals(Collections.singletonList(true), listener.changeEndReferences);
+        assertEquals(Collections.singletonList(true), listener.postCreateViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postAttachReferences);
+        assertEquals(Collections.emptyList(), listener.postDetachReferences);
+        assertEquals(Collections.emptyList(), listener.postDestroyViewReferences);
+        assertEquals(Collections.emptyList(), listener.postDestroyReferences);
+    }
+
+    @Test
+    public void testSingleControllerActivityOnPop() {
+        Controller controller = new TestController();
+
+        ActivityReferencingLifecycleListener listener = new ActivityReferencingLifecycleListener();
+        controller.addLifecycleListener(listener);
+
+        router.pushController(RouterTransaction.with(controller)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        router.popCurrentController();
+
+        assertEquals(Arrays.asList(true, true), listener.changeEndReferences);
+        assertEquals(Collections.singletonList(true), listener.postCreateViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postAttachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDetachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyReferences);
+    }
+
+    @Test
+    public void testChildControllerActivityOnPop() {
+        Controller parent = new TestController();
+
+        router.pushController(RouterTransaction.with(parent)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        TestController child = new TestController();
+
+        ActivityReferencingLifecycleListener listener = new ActivityReferencingLifecycleListener();
+        child.addLifecycleListener(listener);
+
+        Router childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.VIEW_ID));
+        childRouter.setPopsLastView(true);
+        childRouter.pushController(RouterTransaction.with(child)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        childRouter.popCurrentController();
+
+        assertEquals(Arrays.asList(true, true), listener.changeEndReferences);
+        assertEquals(Collections.singletonList(true), listener.postCreateViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postAttachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDetachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyReferences);
+    }
+
+    @Test
+    public void testChildControllerActivityOnParentPop() {
+        Controller parent = new TestController();
+
+        router.pushController(RouterTransaction.with(parent)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        TestController child = new TestController();
+
+        ActivityReferencingLifecycleListener listener = new ActivityReferencingLifecycleListener();
+        child.addLifecycleListener(listener);
+
+        Router childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.VIEW_ID));
+        childRouter.setPopsLastView(true);
+        childRouter.pushController(RouterTransaction.with(child)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        router.popCurrentController();
+
+        assertEquals(Collections.singletonList(true), listener.changeEndReferences);
+        assertEquals(Collections.singletonList(true), listener.postCreateViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postAttachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDetachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyReferences);
+    }
+
+    @Test
+    public void testSingleControllerActivityOnDestroy() {
+        Controller controller = new TestController();
+
+        ActivityReferencingLifecycleListener listener = new ActivityReferencingLifecycleListener();
+        controller.addLifecycleListener(listener);
+
+        router.pushController(RouterTransaction.with(controller)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        activityProxy.pause().stop(false).destroy();
+
+        assertEquals(Collections.singletonList(true), listener.changeEndReferences);
+        assertEquals(Collections.singletonList(true), listener.postCreateViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postAttachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDetachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyReferences);
+    }
+
+    @Test
+    public void testChildControllerActivityOnDestroy() {
+        Controller parent = new TestController();
+
+        router.pushController(RouterTransaction.with(parent)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        TestController child = new TestController();
+
+        ActivityReferencingLifecycleListener listener = new ActivityReferencingLifecycleListener();
+        child.addLifecycleListener(listener);
+
+        Router childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.VIEW_ID));
+        childRouter.setPopsLastView(true);
+        childRouter.pushController(RouterTransaction.with(child)
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
+
+        activityProxy.pause().stop(false).destroy();
+
+        assertEquals(Collections.singletonList(true), listener.changeEndReferences);
+        assertEquals(Collections.singletonList(true), listener.postCreateViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postAttachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDetachReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyViewReferences);
+        assertEquals(Collections.singletonList(true), listener.postDestroyReferences);
+    }
+
+    static class ActivityReferencingLifecycleListener extends Controller.LifecycleListener {
+        final List<Boolean> changeEndReferences = new ArrayList<>();
+        final List<Boolean> postCreateViewReferences = new ArrayList<>();
+        final List<Boolean> postAttachReferences = new ArrayList<>();
+        final List<Boolean> postDetachReferences = new ArrayList<>();
+        final List<Boolean> postDestroyViewReferences = new ArrayList<>();
+        final List<Boolean> postDestroyReferences = new ArrayList<>();
+
+        @Override
+        public void onChangeEnd(@NonNull Controller controller, @NonNull ControllerChangeHandler changeHandler, @NonNull ControllerChangeType changeType) {
+            changeEndReferences.add(controller.getActivity() != null);
+        }
+
+        @Override
+        public void postCreateView(@NonNull Controller controller, @NonNull View view) {
+            postCreateViewReferences.add(controller.getActivity() != null);
+        }
+
+        @Override
+        public void postAttach(@NonNull Controller controller, @NonNull View view) {
+            postAttachReferences.add(controller.getActivity() != null);
+        }
+
+        @Override
+        public void postDetach(@NonNull Controller controller, @NonNull View view) {
+            postDetachReferences.add(controller.getActivity() != null);
+        }
+
+        @Override
+        public void postDestroyView(@NonNull Controller controller) {
+            postDestroyViewReferences.add(controller.getActivity() != null);
+        }
+
+        @Override
+        public void postDestroy(@NonNull Controller controller) {
+            postDestroyReferences.add(controller.getActivity() != null);
+        }
+    }
+
+}

conductor/src/test/java/com/bluelinelabs/conductor/ControllerLifecycleCallbacksTests.java

@@ -1,23 +1,32 @@
 package com.bluelinelabs.conductor;
 
+import android.content.Context;
 import android.os.Bundle;
 import android.support.annotation.NonNull;
 import android.view.View;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.Controller.LifecycleListener;
-import com.bluelinelabs.conductor.MockChangeHandler.ChangeHandlerListener;
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.CallState;
+import com.bluelinelabs.conductor.util.MockChangeHandler;
+import com.bluelinelabs.conductor.util.MockChangeHandler.ChangeHandlerListener;
+import com.bluelinelabs.conductor.util.TestController;
+import com.bluelinelabs.conductor.util.ViewUtils;
 
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
-public class ControllerLifecycleTests {
+public class ControllerLifecycleCallbacksTests {
 
     private Router router;
 
@@ -41,7 +50,7 @@ public class ControllerLifecycleTests {
     public void setup() {
         createActivityController(null, true);
 
-        currentCallState = new CallState();
+        currentCallState = new CallState(false);
     }
 
     @Test
@@ -49,7 +58,7 @@ public class ControllerLifecycleTests {
         TestController controller = new TestController();
         attachLifecycleListener(controller);
 
-        CallState expectedCallState = new CallState();
+        CallState expectedCallState = new CallState(false);
 
         assertCalls(expectedCallState, controller);
         router.pushController(RouterTransaction.with(controller)
@@ -60,17 +69,17 @@ public class ControllerLifecycleTests {
 
         router.popCurrentController();
 
-        Assert.assertNull(controller.getView());
+        assertNull(controller.getView());
 
         assertCalls(expectedCallState, controller);
     }
 
     @Test
-    public void testLifecycleWithActivityDestroy() {
+    public void testLifecycleWithActivityStop() {
         TestController controller = new TestController();
         attachLifecycleListener(controller);
 
-        CallState expectedCallState = new CallState();
+        CallState expectedCallState = new CallState(false);
 
         assertCalls(expectedCallState, controller);
         router.pushController(RouterTransaction.with(controller)
@@ -83,7 +92,38 @@ public class ControllerLifecycleTests {
 
         assertCalls(expectedCallState, controller);
 
-        activityProxy.stop();
+        activityProxy.stop(false);
+
+        expectedCallState.detachCalls++;
+        assertCalls(expectedCallState, controller);
+
+        assertNotNull(controller.getView());
+        ViewUtils.reportAttached(controller.getView(), false);
+
+        expectedCallState.saveViewStateCalls++;
+        expectedCallState.destroyViewCalls++;
+        assertCalls(expectedCallState, controller);
+    }
+
+    @Test
+    public void testLifecycleWithActivityDestroy() {
+        TestController controller = new TestController();
+        attachLifecycleListener(controller);
+
+        CallState expectedCallState = new CallState(false);
+
+        assertCalls(expectedCallState, controller);
+        router.pushController(RouterTransaction.with(controller)
+                .pushChangeHandler(getPushHandler(expectedCallState, controller)));
+
+        assertCalls(expectedCallState, controller);
+
+        activityProxy.getActivity().isDestroying = true;
+        activityProxy.pause();
+
+        assertCalls(expectedCallState, controller);
+
+        activityProxy.stop(true);
 
         expectedCallState.saveViewStateCalls++;
         expectedCallState.detachCalls++;
@@ -92,6 +132,7 @@ public class ControllerLifecycleTests {
 
         activityProxy.destroy();
 
+        expectedCallState.contextUnavailableCalls++;
         expectedCallState.destroyCalls++;
         assertCalls(expectedCallState, controller);
     }
@@ -101,7 +142,7 @@ public class ControllerLifecycleTests {
         TestController controller = new TestController();
         attachLifecycleListener(controller);
 
-        CallState expectedCallState = new CallState();
+        CallState expectedCallState = new CallState(false);
 
         assertCalls(expectedCallState, controller);
         router.pushController(RouterTransaction.with(controller)
@@ -122,17 +163,19 @@ public class ControllerLifecycleTests {
         activityProxy.pause();
         assertCalls(expectedCallState, controller);
 
-        activityProxy.stop();
+        activityProxy.stop(true);
         expectedCallState.detachCalls++;
         expectedCallState.destroyViewCalls++;
         assertCalls(expectedCallState, controller);
 
         activityProxy.destroy();
+        expectedCallState.contextUnavailableCalls++;
         assertCalls(expectedCallState, controller);
 
         createActivityController(bundle, false);
         controller = (TestController)router.getControllerWithTag("root");
 
+        expectedCallState.contextAvailableCalls++;
         expectedCallState.restoreInstanceStateCalls++;
         expectedCallState.restoreViewStateCalls++;
         expectedCallState.changeStartCalls++;
@@ -145,6 +188,7 @@ public class ControllerLifecycleTests {
         currentCallState.changeEndCalls = controller.currentCallState.changeEndCalls;
         currentCallState.createViewCalls = controller.currentCallState.createViewCalls;
         currentCallState.attachCalls = controller.currentCallState.attachCalls;
+        currentCallState.contextAvailableCalls = controller.currentCallState.contextAvailableCalls;
 
         assertCalls(expectedCallState, controller);
 
@@ -165,7 +209,7 @@ public class ControllerLifecycleTests {
         TestController controller = new TestController();
         attachLifecycleListener(controller);
 
-        CallState expectedCallState = new CallState();
+        CallState expectedCallState = new CallState(false);
 
         assertCalls(expectedCallState, controller);
         router.pushController(RouterTransaction.with(controller)
@@ -183,228 +227,230 @@ public class ControllerLifecycleTests {
         assertCalls(expectedCallState, controller);
 
         activityProxy.resume();
+
+        assertCalls(expectedCallState, controller);
     }
 
     @Test
     public void testLifecycleCallOrder() {
         final TestController testController = new TestController();
-        final CallState callState = new CallState();
+        final CallState callState = new CallState(false);
 
         testController.addLifecycleListener(new LifecycleListener() {
             @Override
             public void preCreateView(@NonNull Controller controller) {
                 callState.createViewCalls++;
-                Assert.assertEquals(1, callState.createViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.createViewCalls);
+                assertEquals(1, callState.createViewCalls);
+                assertEquals(0, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(0, callState.attachCalls);
-                Assert.assertEquals(0, testController.currentCallState.attachCalls);
+                assertEquals(0, callState.attachCalls);
+                assertEquals(0, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(0, callState.detachCalls);
-                Assert.assertEquals(0, testController.currentCallState.detachCalls);
+                assertEquals(0, callState.detachCalls);
+                assertEquals(0, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(0, callState.destroyViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyViewCalls);
+                assertEquals(0, callState.destroyViewCalls);
+                assertEquals(0, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void postCreateView(@NonNull Controller controller, @NonNull View view) {
                 callState.createViewCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(0, callState.attachCalls);
-                Assert.assertEquals(0, testController.currentCallState.attachCalls);
+                assertEquals(0, callState.attachCalls);
+                assertEquals(0, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(0, callState.detachCalls);
-                Assert.assertEquals(0, testController.currentCallState.detachCalls);
+                assertEquals(0, callState.detachCalls);
+                assertEquals(0, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(0, callState.destroyViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyViewCalls);
+                assertEquals(0, callState.destroyViewCalls);
+                assertEquals(0, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void preAttach(@NonNull Controller controller, @NonNull View view) {
                 callState.attachCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(1, callState.attachCalls);
-                Assert.assertEquals(0, testController.currentCallState.attachCalls);
+                assertEquals(1, callState.attachCalls);
+                assertEquals(0, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(0, callState.detachCalls);
-                Assert.assertEquals(0, testController.currentCallState.detachCalls);
+                assertEquals(0, callState.detachCalls);
+                assertEquals(0, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(0, callState.destroyViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyViewCalls);
+                assertEquals(0, callState.destroyViewCalls);
+                assertEquals(0, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void postAttach(@NonNull Controller controller, @NonNull View view) {
                 callState.attachCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(2, callState.attachCalls);
-                Assert.assertEquals(1, testController.currentCallState.attachCalls);
+                assertEquals(2, callState.attachCalls);
+                assertEquals(1, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(0, callState.detachCalls);
-                Assert.assertEquals(0, testController.currentCallState.detachCalls);
+                assertEquals(0, callState.detachCalls);
+                assertEquals(0, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(0, callState.destroyViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyViewCalls);
+                assertEquals(0, callState.destroyViewCalls);
+                assertEquals(0, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void preDetach(@NonNull Controller controller, @NonNull View view) {
                 callState.detachCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(2, callState.attachCalls);
-                Assert.assertEquals(1, testController.currentCallState.attachCalls);
+                assertEquals(2, callState.attachCalls);
+                assertEquals(1, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(1, callState.detachCalls);
-                Assert.assertEquals(0, testController.currentCallState.detachCalls);
+                assertEquals(1, callState.detachCalls);
+                assertEquals(0, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(0, callState.destroyViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyViewCalls);
+                assertEquals(0, callState.destroyViewCalls);
+                assertEquals(0, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void postDetach(@NonNull Controller controller, @NonNull View view) {
                 callState.detachCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(2, callState.attachCalls);
-                Assert.assertEquals(1, testController.currentCallState.attachCalls);
+                assertEquals(2, callState.attachCalls);
+                assertEquals(1, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(2, callState.detachCalls);
-                Assert.assertEquals(1, testController.currentCallState.detachCalls);
+                assertEquals(2, callState.detachCalls);
+                assertEquals(1, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(0, callState.destroyViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyViewCalls);
+                assertEquals(0, callState.destroyViewCalls);
+                assertEquals(0, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void preDestroyView(@NonNull Controller controller, @NonNull View view) {
                 callState.destroyViewCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(2, callState.attachCalls);
-                Assert.assertEquals(1, testController.currentCallState.attachCalls);
+                assertEquals(2, callState.attachCalls);
+                assertEquals(1, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(2, callState.detachCalls);
-                Assert.assertEquals(1, testController.currentCallState.detachCalls);
+                assertEquals(2, callState.detachCalls);
+                assertEquals(1, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(1, callState.destroyViewCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyViewCalls);
+                assertEquals(1, callState.destroyViewCalls);
+                assertEquals(0, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void postDestroyView(@NonNull Controller controller) {
                 callState.destroyViewCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(2, callState.attachCalls);
-                Assert.assertEquals(1, testController.currentCallState.attachCalls);
+                assertEquals(2, callState.attachCalls);
+                assertEquals(1, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(2, callState.detachCalls);
-                Assert.assertEquals(1, testController.currentCallState.detachCalls);
+                assertEquals(2, callState.detachCalls);
+                assertEquals(1, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(2, callState.destroyViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.destroyViewCalls);
+                assertEquals(2, callState.destroyViewCalls);
+                assertEquals(1, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(0, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(0, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void preDestroy(@NonNull Controller controller) {
                 callState.destroyCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(2, callState.attachCalls);
-                Assert.assertEquals(1, testController.currentCallState.attachCalls);
+                assertEquals(2, callState.attachCalls);
+                assertEquals(1, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(2, callState.detachCalls);
-                Assert.assertEquals(1, testController.currentCallState.detachCalls);
+                assertEquals(2, callState.detachCalls);
+                assertEquals(1, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(2, callState.destroyViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.destroyViewCalls);
+                assertEquals(2, callState.destroyViewCalls);
+                assertEquals(1, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(1, callState.destroyCalls);
-                Assert.assertEquals(0, testController.currentCallState.destroyCalls);
+                assertEquals(1, callState.destroyCalls);
+                assertEquals(0, testController.currentCallState.destroyCalls);
             }
 
             @Override
             public void postDestroy(@NonNull Controller controller) {
                 callState.destroyCalls++;
-                Assert.assertEquals(2, callState.createViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.createViewCalls);
+                assertEquals(2, callState.createViewCalls);
+                assertEquals(1, testController.currentCallState.createViewCalls);
 
-                Assert.assertEquals(2, callState.attachCalls);
-                Assert.assertEquals(1, testController.currentCallState.attachCalls);
+                assertEquals(2, callState.attachCalls);
+                assertEquals(1, testController.currentCallState.attachCalls);
 
-                Assert.assertEquals(2, callState.detachCalls);
-                Assert.assertEquals(1, testController.currentCallState.detachCalls);
+                assertEquals(2, callState.detachCalls);
+                assertEquals(1, testController.currentCallState.detachCalls);
 
-                Assert.assertEquals(2, callState.destroyViewCalls);
-                Assert.assertEquals(1, testController.currentCallState.destroyViewCalls);
+                assertEquals(2, callState.destroyViewCalls);
+                assertEquals(1, testController.currentCallState.destroyViewCalls);
 
-                Assert.assertEquals(2, callState.destroyCalls);
-                Assert.assertEquals(1, testController.currentCallState.destroyCalls);
+                assertEquals(2, callState.destroyCalls);
+                assertEquals(1, testController.currentCallState.destroyCalls);
             }
         });
 
         router.pushController(RouterTransaction.with(testController)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         router.popController(testController);
 
-        Assert.assertEquals(2, callState.createViewCalls);
-        Assert.assertEquals(2, callState.attachCalls);
-        Assert.assertEquals(2, callState.detachCalls);
-        Assert.assertEquals(2, callState.destroyViewCalls);
-        Assert.assertEquals(2, callState.destroyCalls);
+        assertEquals(2, callState.createViewCalls);
+        assertEquals(2, callState.attachCalls);
+        assertEquals(2, callState.detachCalls);
+        assertEquals(2, callState.destroyViewCalls);
+        assertEquals(2, callState.destroyCalls);
     }
 
     @Test
     public void testChildLifecycle() {
         Controller parent = new TestController();
         router.pushController(RouterTransaction.with(parent)
-                .pushChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler()));
 
         TestController child = new TestController();
         attachLifecycleListener(child);
 
-        CallState expectedCallState = new CallState();
+        CallState expectedCallState = new CallState(false);
 
         assertCalls(expectedCallState, child);
 
@@ -425,13 +471,13 @@ public class ControllerLifecycleTests {
     public void testChildLifecycle2() {
         Controller parent = new TestController();
         router.pushController(RouterTransaction.with(parent)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         TestController child = new TestController();
         attachLifecycleListener(child);
 
-        CallState expectedCallState = new CallState();
+        CallState expectedCallState = new CallState(false);
 
         assertCalls(expectedCallState, child);
 
@@ -445,26 +491,32 @@ public class ControllerLifecycleTests {
 
         router.popCurrentController();
 
+        expectedCallState.detachCalls++;
+        expectedCallState.destroyViewCalls++;
+        expectedCallState.contextUnavailableCalls++;
+        expectedCallState.destroyCalls++;
+
         assertCalls(expectedCallState, child);
     }
 
     private MockChangeHandler getPushHandler(final CallState expectedCallState, final TestController controller) {
-        return new MockChangeHandler(new ChangeHandlerListener() {
+        return MockChangeHandler.listeningChangeHandler(new ChangeHandlerListener() {
             @Override
-            void willStartChange() {
+            public void willStartChange() {
+                expectedCallState.contextAvailableCalls++;
                 expectedCallState.changeStartCalls++;
                 expectedCallState.createViewCalls++;
                 assertCalls(expectedCallState, controller);
             }
 
             @Override
-            void didAttachOrDetach() {
+            public void didAttachOrDetach() {
                 expectedCallState.attachCalls++;
                 assertCalls(expectedCallState, controller);
             }
 
             @Override
-            void didEndChange() {
+            public void didEndChange() {
                 expectedCallState.changeEndCalls++;
                 assertCalls(expectedCallState, controller);
             }
@@ -472,23 +524,24 @@ public class ControllerLifecycleTests {
     }
 
     private MockChangeHandler getPopHandler(final CallState expectedCallState, final TestController controller) {
-        return new MockChangeHandler(new ChangeHandlerListener() {
+        return MockChangeHandler.listeningChangeHandler(new ChangeHandlerListener() {
             @Override
-            void willStartChange() {
+            public void willStartChange() {
                 expectedCallState.changeStartCalls++;
                 assertCalls(expectedCallState, controller);
             }
 
             @Override
-            void didAttachOrDetach() {
+            public void didAttachOrDetach() {
                 expectedCallState.destroyViewCalls++;
                 expectedCallState.detachCalls++;
+                expectedCallState.contextUnavailableCalls++;
                 expectedCallState.destroyCalls++;
                 assertCalls(expectedCallState, controller);
             }
 
             @Override
-            void didEndChange() {
+            public void didEndChange() {
                 expectedCallState.changeEndCalls++;
                 assertCalls(expectedCallState, controller);
             }
@@ -496,8 +549,8 @@ public class ControllerLifecycleTests {
     }
 
     private void assertCalls(CallState callState, TestController controller) {
-        Assert.assertEquals("Expected call counts and controller call counts do not match.", callState, controller.currentCallState);
-        Assert.assertEquals("Expected call counts and lifecycle call counts do not match.", callState, currentCallState);
+        assertEquals("Expected call counts and controller call counts do not match.", callState, controller.currentCallState);
+        assertEquals("Expected call counts and lifecycle call counts do not match.", callState, currentCallState);
     }
 
     private void attachLifecycleListener(Controller controller) {
@@ -512,6 +565,16 @@ public class ControllerLifecycleTests {
                 currentCallState.changeEndCalls++;
             }
 
+            @Override
+            public void postContextAvailable(@NonNull Controller controller, @NonNull Context context) {
+                currentCallState.contextAvailableCalls++;
+            }
+
+            @Override
+            public void postContextUnavailable(@NonNull Controller controller) {
+                currentCallState.contextUnavailableCalls++;
+            }
+
             @Override
             public void postCreateView(@NonNull Controller controller, @NonNull View view) {
                 currentCallState.createViewCalls++;

conductor/src/test/java/com/bluelinelabs/conductor/ControllerTests.java

@@ -7,14 +7,22 @@ import android.view.View;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.Controller.RetainViewMode;
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.CallState;
+import com.bluelinelabs.conductor.util.TestController;
+import com.bluelinelabs.conductor.util.ViewUtils;
 
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class ControllerTests {
@@ -42,26 +50,26 @@ public class ControllerTests {
 
         // Test View getting released w/ RELEASE_DETACH
         controller.setRetainViewMode(RetainViewMode.RELEASE_DETACH);
-        Assert.assertNull(controller.getView());
+        assertNull(controller.getView());
         View view = controller.inflate(router.container);
-        Assert.assertNotNull(controller.getView());
+        assertNotNull(controller.getView());
         ViewUtils.reportAttached(view, true);
-        Assert.assertNotNull(controller.getView());
+        assertNotNull(controller.getView());
         ViewUtils.reportAttached(view, false);
-        Assert.assertNull(controller.getView());
+        assertNull(controller.getView());
 
         // Test View getting retained w/ RETAIN_DETACH
         controller.setRetainViewMode(RetainViewMode.RETAIN_DETACH);
         view = controller.inflate(router.container);
-        Assert.assertNotNull(controller.getView());
+        assertNotNull(controller.getView());
         ViewUtils.reportAttached(view, true);
-        Assert.assertNotNull(controller.getView());
+        assertNotNull(controller.getView());
         ViewUtils.reportAttached(view, false);
-        Assert.assertNotNull(controller.getView());
+        assertNotNull(controller.getView());
 
         // Ensure re-setting RELEASE_DETACH releases
         controller.setRetainViewMode(RetainViewMode.RELEASE_DETACH);
-        Assert.assertNull(controller.getView());
+        assertNull(controller.getView());
     }
 
     @Test
@@ -263,48 +271,48 @@ public class ControllerTests {
 
         router.pushController(RouterTransaction.with(parent));
 
-        Assert.assertEquals(0, parent.getChildRouters().size());
-        Assert.assertNull(child1.getParentController());
-        Assert.assertNull(child2.getParentController());
+        assertEquals(0, parent.getChildRouters().size());
+        assertNull(child1.getParentController());
+        assertNull(child2.getParentController());
 
         Router childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.VIEW_ID));
         childRouter.setPopsLastView(true);
         childRouter.setRoot(RouterTransaction.with(child1));
 
-        Assert.assertEquals(1, parent.getChildRouters().size());
-        Assert.assertEquals(childRouter, parent.getChildRouters().get(0));
-        Assert.assertEquals(1, childRouter.getBackstackSize());
-        Assert.assertEquals(child1, childRouter.getControllers().get(0));
-        Assert.assertEquals(parent, child1.getParentController());
-        Assert.assertNull(child2.getParentController());
+        assertEquals(1, parent.getChildRouters().size());
+        assertEquals(childRouter, parent.getChildRouters().get(0));
+        assertEquals(1, childRouter.getBackstackSize());
+        assertEquals(child1, childRouter.getControllers().get(0));
+        assertEquals(parent, child1.getParentController());
+        assertNull(child2.getParentController());
 
         childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.VIEW_ID));
         childRouter.pushController(RouterTransaction.with(child2));
 
-        Assert.assertEquals(1, parent.getChildRouters().size());
-        Assert.assertEquals(childRouter, parent.getChildRouters().get(0));
-        Assert.assertEquals(2, childRouter.getBackstackSize());
-        Assert.assertEquals(child1, childRouter.getControllers().get(0));
-        Assert.assertEquals(child2, childRouter.getControllers().get(1));
-        Assert.assertEquals(parent, child1.getParentController());
-        Assert.assertEquals(parent, child2.getParentController());
+        assertEquals(1, parent.getChildRouters().size());
+        assertEquals(childRouter, parent.getChildRouters().get(0));
+        assertEquals(2, childRouter.getBackstackSize());
+        assertEquals(child1, childRouter.getControllers().get(0));
+        assertEquals(child2, childRouter.getControllers().get(1));
+        assertEquals(parent, child1.getParentController());
+        assertEquals(parent, child2.getParentController());
 
         childRouter.popController(child2);
 
-        Assert.assertEquals(1, parent.getChildRouters().size());
-        Assert.assertEquals(childRouter, parent.getChildRouters().get(0));
-        Assert.assertEquals(1, childRouter.getBackstackSize());
-        Assert.assertEquals(child1, childRouter.getControllers().get(0));
-        Assert.assertEquals(parent, child1.getParentController());
-        Assert.assertNull(child2.getParentController());
+        assertEquals(1, parent.getChildRouters().size());
+        assertEquals(childRouter, parent.getChildRouters().get(0));
+        assertEquals(1, childRouter.getBackstackSize());
+        assertEquals(child1, childRouter.getControllers().get(0));
+        assertEquals(parent, child1.getParentController());
+        assertNull(child2.getParentController());
 
         childRouter.popController(child1);
 
-        Assert.assertEquals(1, parent.getChildRouters().size());
-        Assert.assertEquals(childRouter, parent.getChildRouters().get(0));
-        Assert.assertEquals(0, childRouter.getBackstackSize());
-        Assert.assertNull(child1.getParentController());
-        Assert.assertNull(child2.getParentController());
+        assertEquals(1, parent.getChildRouters().size());
+        assertEquals(childRouter, parent.getChildRouters().get(0));
+        assertEquals(0, childRouter.getBackstackSize());
+        assertNull(child1.getParentController());
+        assertNull(child2.getParentController());
     }
 
     @Test
@@ -316,9 +324,9 @@ public class ControllerTests {
 
         router.pushController(RouterTransaction.with(parent));
 
-        Assert.assertEquals(0, parent.getChildRouters().size());
-        Assert.assertNull(child1.getParentController());
-        Assert.assertNull(child2.getParentController());
+        assertEquals(0, parent.getChildRouters().size());
+        assertNull(child1.getParentController());
+        assertNull(child2.getParentController());
 
         Router childRouter1 = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.CHILD_VIEW_ID_1));
         Router childRouter2 = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.CHILD_VIEW_ID_2));
@@ -326,37 +334,79 @@ public class ControllerTests {
         childRouter1.setRoot(RouterTransaction.with(child1));
         childRouter2.setRoot(RouterTransaction.with(child2));
 
-        Assert.assertEquals(2, parent.getChildRouters().size());
-        Assert.assertEquals(childRouter1, parent.getChildRouters().get(0));
-        Assert.assertEquals(childRouter2, parent.getChildRouters().get(1));
-        Assert.assertEquals(1, childRouter1.getBackstackSize());
-        Assert.assertEquals(1, childRouter2.getBackstackSize());
-        Assert.assertEquals(child1, childRouter1.getControllers().get(0));
-        Assert.assertEquals(child2, childRouter2.getControllers().get(0));
-        Assert.assertEquals(parent, child1.getParentController());
-        Assert.assertEquals(parent, child2.getParentController());
+        assertEquals(2, parent.getChildRouters().size());
+        assertEquals(childRouter1, parent.getChildRouters().get(0));
+        assertEquals(childRouter2, parent.getChildRouters().get(1));
+        assertEquals(1, childRouter1.getBackstackSize());
+        assertEquals(1, childRouter2.getBackstackSize());
+        assertEquals(child1, childRouter1.getControllers().get(0));
+        assertEquals(child2, childRouter2.getControllers().get(0));
+        assertEquals(parent, child1.getParentController());
+        assertEquals(parent, child2.getParentController());
 
         parent.removeChildRouter(childRouter2);
 
-        Assert.assertEquals(1, parent.getChildRouters().size());
-        Assert.assertEquals(childRouter1, parent.getChildRouters().get(0));
-        Assert.assertEquals(1, childRouter1.getBackstackSize());
-        Assert.assertEquals(0, childRouter2.getBackstackSize());
-        Assert.assertEquals(child1, childRouter1.getControllers().get(0));
-        Assert.assertEquals(parent, child1.getParentController());
-        Assert.assertNull(child2.getParentController());
+        assertEquals(1, parent.getChildRouters().size());
+        assertEquals(childRouter1, parent.getChildRouters().get(0));
+        assertEquals(1, childRouter1.getBackstackSize());
+        assertEquals(0, childRouter2.getBackstackSize());
+        assertEquals(child1, childRouter1.getControllers().get(0));
+        assertEquals(parent, child1.getParentController());
+        assertNull(child2.getParentController());
 
         parent.removeChildRouter(childRouter1);
 
-        Assert.assertEquals(0, parent.getChildRouters().size());
-        Assert.assertEquals(0, childRouter1.getBackstackSize());
-        Assert.assertEquals(0, childRouter2.getBackstackSize());
-        Assert.assertNull(child1.getParentController());
-        Assert.assertNull(child2.getParentController());
+        assertEquals(0, parent.getChildRouters().size());
+        assertEquals(0, childRouter1.getBackstackSize());
+        assertEquals(0, childRouter2.getBackstackSize());
+        assertNull(child1.getParentController());
+        assertNull(child2.getParentController());
+    }
+
+    @Test
+    public void testRestoredChildRouterBackstack() {
+        TestController parent = new TestController();
+        router.pushController(RouterTransaction.with(parent));
+        ViewUtils.reportAttached(parent.getView(), true);
+
+        RouterTransaction childTransaction1 = RouterTransaction.with(new TestController());
+        RouterTransaction childTransaction2 = RouterTransaction.with(new TestController());
+
+        Router childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.CHILD_VIEW_ID_1));
+        childRouter.setPopsLastView(true);
+        childRouter.setRoot(childTransaction1);
+        childRouter.pushController(childTransaction2);
+
+        Bundle savedState = new Bundle();
+        childRouter.saveInstanceState(savedState);
+        parent.removeChildRouter(childRouter);
+
+        childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.CHILD_VIEW_ID_1));
+        assertEquals(0, childRouter.getBackstackSize());
+
+        childRouter.restoreInstanceState(savedState);
+        childRouter.rebindIfNeeded();
+
+        assertEquals(2, childRouter.getBackstackSize());
+
+        RouterTransaction restoredChildTransaction1 = childRouter.getBackstack().get(0);
+        RouterTransaction restoredChildTransaction2 = childRouter.getBackstack().get(1);
+
+        assertEquals(childTransaction1.transactionIndex, restoredChildTransaction1.transactionIndex);
+        assertEquals(childTransaction1.controller.getInstanceId(), restoredChildTransaction1.controller.getInstanceId());
+        assertEquals(childTransaction2.transactionIndex, restoredChildTransaction2.transactionIndex);
+        assertEquals(childTransaction2.controller.getInstanceId(), restoredChildTransaction2.controller.getInstanceId());
+
+        assertTrue(parent.handleBack());
+        assertEquals(1, childRouter.getBackstackSize());
+        assertEquals(restoredChildTransaction1, childRouter.getBackstack().get(0));
+
+        assertTrue(parent.handleBack());
+        assertEquals(0, childRouter.getBackstackSize());
     }
 
     private void assertCalls(CallState callState, TestController controller) {
-        Assert.assertEquals("Expected call counts and controller call counts do not match.", callState, controller.currentCallState);
+        assertEquals("Expected call counts and controller call counts do not match.", callState, controller.currentCallState);
     }
 
 }

conductor/src/test/java/com/bluelinelabs/conductor/ControllerTransactionTests.java

@@ -4,11 +4,12 @@ import android.os.Bundle;
 
 import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler;
 import com.bluelinelabs.conductor.changehandler.VerticalChangeHandler;
-
-import junit.framework.Assert;
+import com.bluelinelabs.conductor.util.TestController;
 
 import org.junit.Test;
 
+import static org.junit.Assert.assertEquals;
+
 public class ControllerTransactionTests {
 
     @Test
@@ -22,10 +23,10 @@ public class ControllerTransactionTests {
 
         RouterTransaction restoredTransaction = new RouterTransaction(bundle);
 
-        Assert.assertEquals(transaction.controller.getClass(), restoredTransaction.controller.getClass());
-        Assert.assertEquals(transaction.pushChangeHandler().getClass(), restoredTransaction.pushChangeHandler().getClass());
-        Assert.assertEquals(transaction.popChangeHandler().getClass(), restoredTransaction.popChangeHandler().getClass());
-        Assert.assertEquals(transaction.tag(), restoredTransaction.tag());
+        assertEquals(transaction.controller.getClass(), restoredTransaction.controller.getClass());
+        assertEquals(transaction.pushChangeHandler().getClass(), restoredTransaction.pushChangeHandler().getClass());
+        assertEquals(transaction.popChangeHandler().getClass(), restoredTransaction.popChangeHandler().getClass());
+        assertEquals(transaction.tag(), restoredTransaction.tag());
     }
 
 }

conductor/src/test/java/com/bluelinelabs/conductor/MockChangeHandler.java

@@ -1,85 +0,0 @@
-package com.bluelinelabs.conductor;
-
-
-import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.view.View;
-import android.view.ViewGroup;
-
-public class MockChangeHandler extends ControllerChangeHandler {
-
-    private static final String KEY_REMOVES_FROM_VIEW_ON_PUSH = "MockChangeHandler.removesFromViewOnPush";
-
-    static class ChangeHandlerListener {
-        void willStartChange() { }
-        void didAttachOrDetach() { }
-        void didEndChange() { }
-    }
-
-    final ChangeHandlerListener listener;
-    boolean removesFromViewOnPush;
-
-    public MockChangeHandler() {
-        this(true, null);
-    }
-
-    public MockChangeHandler(boolean removesViewOnPush) {
-        this(removesViewOnPush, null);
-    }
-
-    public MockChangeHandler(@NonNull ChangeHandlerListener listener) {
-        this(true, listener);
-    }
-
-    public MockChangeHandler(boolean removesFromViewOnPush, ChangeHandlerListener listener) {
-        this.removesFromViewOnPush = removesFromViewOnPush;
-
-        if (listener == null) {
-            this.listener = new ChangeHandlerListener() { };
-        } else {
-            this.listener = listener;
-        }
-    }
-
-    @Override
-    public void performChange(@NonNull ViewGroup container, View from, View to, boolean isPush, @NonNull ControllerChangeCompletedListener changeListener) {
-        listener.willStartChange();
-
-        if (isPush) {
-            container.addView(to);
-            listener.didAttachOrDetach();
-
-            if (removesFromViewOnPush && from != null) {
-                container.removeView(from);
-            }
-        } else {
-            container.removeView(from);
-            listener.didAttachOrDetach();
-
-            if (to != null) {
-                container.addView(to);
-            }
-
-        }
-
-        changeListener.onChangeCompleted();
-        listener.didEndChange();
-    }
-
-    @Override
-    public boolean removesFromViewOnPush() {
-        return removesFromViewOnPush;
-    }
-
-    @Override
-    public void saveToBundle(@NonNull Bundle bundle) {
-        super.saveToBundle(bundle);
-        bundle.putBoolean(KEY_REMOVES_FROM_VIEW_ON_PUSH, removesFromViewOnPush);
-    }
-
-    @Override
-    public void restoreFromBundle(@NonNull Bundle bundle) {
-        super.restoreFromBundle(bundle);
-        removesFromViewOnPush = bundle.getBoolean(KEY_REMOVES_FROM_VIEW_ON_PUSH);
-    }
-}

conductor/src/test/java/com/bluelinelabs/conductor/ReattachCaseTests.java

@@ -3,13 +3,19 @@ package com.bluelinelabs.conductor;
 import android.os.Bundle;
 import android.view.ViewGroup;
 
-import org.junit.Assert;
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.MockChangeHandler;
+import com.bluelinelabs.conductor.util.TestController;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class ReattachCaseTests {
@@ -36,71 +42,71 @@ public class ReattachCaseTests {
         final TestController controllerB = new TestController();
 
         router.pushController(RouterTransaction.with(controllerA)
-            .pushChangeHandler(new MockChangeHandler())
-            .popChangeHandler(new MockChangeHandler()));
+            .pushChangeHandler(MockChangeHandler.defaultHandler())
+            .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertFalse(controllerB.isAttached());
 
         sleepWakeDevice();
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertFalse(controllerB.isAttached());
 
         router.pushController(RouterTransaction.with(controllerB)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
 
         activityProxy.rotate();
         router.rebindIfNeeded();
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
     }
 
     @Test
     public void testChildNeedsAttachOnPauseAndOrientation() {
-        final TestController controllerA = new TestController();
-        final TestController childController = new TestController();
-        final TestController controllerB = new TestController();
+        final Controller controllerA = new TestController();
+        final Controller childController = new TestController();
+        final Controller controllerB = new TestController();
 
         router.pushController(RouterTransaction.with(controllerA)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         Router childRouter = controllerA.getChildRouter((ViewGroup)controllerA.getView().findViewById(TestController.VIEW_ID));
         childRouter.pushController(RouterTransaction.with(childController)
-            .pushChangeHandler(new MockChangeHandler())
-            .popChangeHandler(new MockChangeHandler()));
+            .pushChangeHandler(MockChangeHandler.defaultHandler())
+            .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertTrue(childController.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertTrue(childController.isAttached());
+        assertFalse(controllerB.isAttached());
 
         sleepWakeDevice();
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertTrue(childController.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertTrue(childController.isAttached());
+        assertFalse(controllerB.isAttached());
 
         router.pushController(RouterTransaction.with(controllerB)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertFalse(childController.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertFalse(childController.isAttached());
+        assertTrue(controllerB.isAttached());
 
         activityProxy.rotate();
         router.rebindIfNeeded();
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertFalse(childController.isAttached());
-        Assert.assertTrue(childController.getNeedsAttach());
-        Assert.assertTrue(controllerB.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertFalse(childController.isAttached());
+        assertTrue(childController.getNeedsAttach());
+        assertTrue(controllerB.isAttached());
     }
 
     @Test
@@ -110,45 +116,45 @@ public class ReattachCaseTests {
         final TestController childController = new TestController();
 
         router.pushController(RouterTransaction.with(controllerA)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
-        Assert.assertFalse(childController.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertFalse(controllerB.isAttached());
+        assertFalse(childController.isAttached());
 
         router.pushController(RouterTransaction.with(controllerB)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         Router childRouter = controllerB.getChildRouter((ViewGroup)controllerB.getView().findViewById(TestController.VIEW_ID));
         childRouter.setPopsLastView(true);
         childRouter.pushController(RouterTransaction.with(childController)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertTrue(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertTrue(childController.isAttached());
 
         activityProxy.rotate();
         router.rebindIfNeeded();
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertTrue(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertTrue(childController.isAttached());
 
         router.handleBack();
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertFalse(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertFalse(childController.isAttached());
 
         router.handleBack();
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
-        Assert.assertFalse(childController.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertFalse(controllerB.isAttached());
+        assertFalse(childController.isAttached());
     }
 
     // Attempt to test https://github.com/bluelinelabs/Conductor/issues/86#issuecomment-231381271
@@ -159,71 +165,71 @@ public class ReattachCaseTests {
         TestController childController = new TestController();
 
         router.pushController(RouterTransaction.with(controllerA)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
-        Assert.assertFalse(childController.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertFalse(controllerB.isAttached());
+        assertFalse(childController.isAttached());
 
         router.pushController(RouterTransaction.with(controllerB)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         Router childRouter = controllerB.getChildRouter((ViewGroup)controllerB.getView().findViewById(TestController.VIEW_ID));
         childRouter.setPopsLastView(true);
         childRouter.pushController(RouterTransaction.with(childController)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertTrue(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertTrue(childController.isAttached());
 
         router.handleBack();
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertFalse(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertFalse(childController.isAttached());
 
         childController = new TestController();
         childRouter.pushController(RouterTransaction.with(childController)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertTrue(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertTrue(childController.isAttached());
 
         activityProxy.rotate();
         router.rebindIfNeeded();
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertTrue(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertTrue(childController.isAttached());
 
         router.handleBack();
 
         childController = new TestController();
         childRouter.pushController(RouterTransaction.with(childController)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertTrue(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertTrue(childController.isAttached());
 
         router.handleBack();
 
-        Assert.assertFalse(controllerA.isAttached());
-        Assert.assertTrue(controllerB.isAttached());
-        Assert.assertFalse(childController.isAttached());
+        assertFalse(controllerA.isAttached());
+        assertTrue(controllerB.isAttached());
+        assertFalse(childController.isAttached());
 
         router.handleBack();
 
-        Assert.assertTrue(controllerA.isAttached());
-        Assert.assertFalse(controllerB.isAttached());
-        Assert.assertFalse(childController.isAttached());
+        assertTrue(controllerA.isAttached());
+        assertFalse(controllerB.isAttached());
+        assertFalse(childController.isAttached());
     }
 
     private void sleepWakeDevice() {

conductor/src/test/java/com/bluelinelabs/conductor/RouterChangeHandlerTests.java

@@ -0,0 +1,239 @@
+package com.bluelinelabs.conductor;
+
+import android.view.View;
+
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.MockChangeHandler;
+import com.bluelinelabs.conductor.util.TestController;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class RouterChangeHandlerTests {
+
+    private Router router;
+
+    @Before
+    public void setup() {
+        ActivityProxy activityProxy = new ActivityProxy().create(null).start().resume();
+        router = Conductor.attachRouter(activityProxy.getActivity(), activityProxy.getView(), null);
+    }
+
+    @Test
+    public void testSetRootHandler() {
+        MockChangeHandler handler = MockChangeHandler.taggedHandler("root", true);
+        TestController rootController = new TestController();
+        router.setRoot(RouterTransaction.with(rootController).pushChangeHandler(handler));
+
+        assertTrue(rootController.changeHandlerHistory.isValidHistory);
+        assertNull(rootController.changeHandlerHistory.latestFromView());
+        assertNotNull(rootController.changeHandlerHistory.latestToView());
+        assertEquals(rootController.getView(), rootController.changeHandlerHistory.latestToView());
+        assertTrue(rootController.changeHandlerHistory.latestIsPush());
+        assertEquals(handler.tag, rootController.changeHandlerHistory.latestChangeHandler().tag);
+    }
+
+    @Test
+    public void testPushPopHandlers() {
+        TestController rootController = new TestController();
+        router.setRoot(RouterTransaction.with(rootController).pushChangeHandler(MockChangeHandler.defaultHandler()));
+        View rootView = rootController.getView();
+
+        MockChangeHandler pushHandler = MockChangeHandler.taggedHandler("push", true);
+        MockChangeHandler popHandler = MockChangeHandler.taggedHandler("pop", true);
+        TestController pushController = new TestController();
+        router.pushController(RouterTransaction.with(pushController).pushChangeHandler(pushHandler).popChangeHandler(popHandler));
+
+        assertTrue(rootController.changeHandlerHistory.isValidHistory);
+        assertTrue(pushController.changeHandlerHistory.isValidHistory);
+
+        assertNotNull(pushController.changeHandlerHistory.latestFromView());
+        assertNotNull(pushController.changeHandlerHistory.latestToView());
+        assertEquals(rootView, pushController.changeHandlerHistory.latestFromView());
+        assertEquals(pushController.getView(), pushController.changeHandlerHistory.latestToView());
+        assertTrue(pushController.changeHandlerHistory.latestIsPush());
+        assertEquals(pushHandler.tag, pushController.changeHandlerHistory.latestChangeHandler().tag);
+
+        View pushView = pushController.getView();
+        router.popController(pushController);
+
+        assertNotNull(pushController.changeHandlerHistory.latestFromView());
+        assertNotNull(pushController.changeHandlerHistory.latestToView());
+        assertEquals(pushView, pushController.changeHandlerHistory.fromViewAt(1));
+        assertEquals(rootController.getView(), pushController.changeHandlerHistory.latestToView());
+        assertFalse(pushController.changeHandlerHistory.latestIsPush());
+        assertEquals(popHandler.tag, pushController.changeHandlerHistory.latestChangeHandler().tag);
+    }
+
+    @Test
+    public void testResetRootHandlers() {
+        TestController initialController1 = new TestController();
+        MockChangeHandler initialPushHandler1 = MockChangeHandler.taggedHandler("initialPush1", true);
+        MockChangeHandler initialPopHandler1 = MockChangeHandler.taggedHandler("initialPop1", true);
+        router.setRoot(RouterTransaction.with(initialController1).pushChangeHandler(initialPushHandler1).popChangeHandler(initialPopHandler1));
+        TestController initialController2 = new TestController();
+        MockChangeHandler initialPushHandler2 = MockChangeHandler.taggedHandler("initialPush2", false);
+        MockChangeHandler initialPopHandler2 = MockChangeHandler.taggedHandler("initialPop2", false);
+        router.pushController(RouterTransaction.with(initialController2).pushChangeHandler(initialPushHandler2).popChangeHandler(initialPopHandler2));
+
+        View initialView1 = initialController1.getView();
+        View initialView2 = initialController2.getView();
+
+        TestController newRootController = new TestController();
+        MockChangeHandler newRootHandler = MockChangeHandler.taggedHandler("newRootHandler", true);
+
+        router.setRoot(RouterTransaction.with(newRootController).pushChangeHandler(newRootHandler));
+
+        assertTrue(initialController1.changeHandlerHistory.isValidHistory);
+        assertTrue(initialController2.changeHandlerHistory.isValidHistory);
+        assertTrue(newRootController.changeHandlerHistory.isValidHistory);
+
+        assertEquals(3, initialController1.changeHandlerHistory.size());
+        assertEquals(2, initialController2.changeHandlerHistory.size());
+        assertEquals(1, newRootController.changeHandlerHistory.size());
+
+        assertNotNull(initialController1.changeHandlerHistory.latestToView());
+        assertEquals(newRootController.getView(), initialController1.changeHandlerHistory.latestToView());
+        assertEquals(initialView1, initialController1.changeHandlerHistory.latestFromView());
+        assertEquals(newRootHandler.tag, initialController1.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(initialController1.changeHandlerHistory.latestIsPush());
+
+        assertNull(initialController2.changeHandlerHistory.latestToView());
+        assertEquals(initialView2, initialController2.changeHandlerHistory.latestFromView());
+        assertEquals(newRootHandler.tag, initialController2.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(initialController2.changeHandlerHistory.latestIsPush());
+
+        assertNotNull(newRootController.changeHandlerHistory.latestToView());
+        assertEquals(newRootController.getView(), newRootController.changeHandlerHistory.latestToView());
+        assertEquals(initialView1, newRootController.changeHandlerHistory.latestFromView());
+        assertEquals(newRootHandler.tag, newRootController.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(newRootController.changeHandlerHistory.latestIsPush());
+    }
+
+    @Test
+    public void testSetBackstackHandlers() {
+        TestController initialController1 = new TestController();
+        MockChangeHandler initialPushHandler1 = MockChangeHandler.taggedHandler("initialPush1", true);
+        MockChangeHandler initialPopHandler1 = MockChangeHandler.taggedHandler("initialPop1", true);
+        router.setRoot(RouterTransaction.with(initialController1).pushChangeHandler(initialPushHandler1).popChangeHandler(initialPopHandler1));
+        TestController initialController2 = new TestController();
+        MockChangeHandler initialPushHandler2 = MockChangeHandler.taggedHandler("initialPush2", false);
+        MockChangeHandler initialPopHandler2 = MockChangeHandler.taggedHandler("initialPop2", false);
+        router.pushController(RouterTransaction.with(initialController2).pushChangeHandler(initialPushHandler2).popChangeHandler(initialPopHandler2));
+
+        View initialView1 = initialController1.getView();
+        View initialView2 = initialController2.getView();
+
+        TestController newController1 = new TestController();
+        TestController newController2 = new TestController();
+        MockChangeHandler setBackstackHandler = MockChangeHandler.taggedHandler("setBackstackHandler", true);
+
+        List<RouterTransaction> newBackstack = Arrays.asList(
+                RouterTransaction.with(newController1),
+                RouterTransaction.with(newController2)
+        );
+
+        router.setBackstack(newBackstack, setBackstackHandler);
+
+        assertTrue(initialController1.changeHandlerHistory.isValidHistory);
+        assertTrue(initialController2.changeHandlerHistory.isValidHistory);
+        assertTrue(newController1.changeHandlerHistory.isValidHistory);
+
+        assertEquals(3, initialController1.changeHandlerHistory.size());
+        assertEquals(2, initialController2.changeHandlerHistory.size());
+        assertEquals(0, newController1.changeHandlerHistory.size());
+        assertEquals(1, newController2.changeHandlerHistory.size());
+
+        assertNotNull(initialController1.changeHandlerHistory.latestToView());
+        assertEquals(newController2.getView(), initialController1.changeHandlerHistory.latestToView());
+        assertEquals(initialView1, initialController1.changeHandlerHistory.latestFromView());
+        assertEquals(setBackstackHandler.tag, initialController1.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(initialController1.changeHandlerHistory.latestIsPush());
+
+        assertNull(initialController2.changeHandlerHistory.latestToView());
+        assertEquals(initialView2, initialController2.changeHandlerHistory.latestFromView());
+        assertEquals(setBackstackHandler.tag, initialController2.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(initialController2.changeHandlerHistory.latestIsPush());
+
+        assertNotNull(newController2.changeHandlerHistory.latestToView());
+        assertEquals(newController2.getView(), newController2.changeHandlerHistory.latestToView());
+        assertEquals(initialView1, newController2.changeHandlerHistory.latestFromView());
+        assertEquals(setBackstackHandler.tag, newController2.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(newController2.changeHandlerHistory.latestIsPush());
+    }
+
+    @Test
+    public void testSetBackstackWithTwoVisibleHandlers() {
+        TestController initialController1 = new TestController();
+        MockChangeHandler initialPushHandler1 = MockChangeHandler.taggedHandler("initialPush1", true);
+        MockChangeHandler initialPopHandler1 = MockChangeHandler.taggedHandler("initialPop1", true);
+        router.setRoot(RouterTransaction.with(initialController1).pushChangeHandler(initialPushHandler1).popChangeHandler(initialPopHandler1));
+        TestController initialController2 = new TestController();
+        MockChangeHandler initialPushHandler2 = MockChangeHandler.taggedHandler("initialPush2", false);
+        MockChangeHandler initialPopHandler2 = MockChangeHandler.taggedHandler("initialPop2", false);
+        router.pushController(RouterTransaction.with(initialController2).pushChangeHandler(initialPushHandler2).popChangeHandler(initialPopHandler2));
+
+        View initialView1 = initialController1.getView();
+        View initialView2 = initialController2.getView();
+
+        TestController newController1 = new TestController();
+        TestController newController2 = new TestController();
+        MockChangeHandler setBackstackHandler = MockChangeHandler.taggedHandler("setBackstackHandler", true);
+
+        List<RouterTransaction> newBackstack = Arrays.asList(
+                RouterTransaction.with(newController1),
+                RouterTransaction.with(newController2).pushChangeHandler(MockChangeHandler.noRemoveViewOnPushHandler())
+        );
+
+        router.setBackstack(newBackstack, setBackstackHandler);
+
+        assertTrue(initialController1.changeHandlerHistory.isValidHistory);
+        assertTrue(initialController2.changeHandlerHistory.isValidHistory);
+        assertTrue(newController1.changeHandlerHistory.isValidHistory);
+
+        assertEquals(3, initialController1.changeHandlerHistory.size());
+        assertEquals(2, initialController2.changeHandlerHistory.size());
+        assertEquals(2, newController1.changeHandlerHistory.size());
+        assertEquals(1, newController2.changeHandlerHistory.size());
+
+        assertNotNull(initialController1.changeHandlerHistory.latestToView());
+        assertEquals(newController1.getView(), initialController1.changeHandlerHistory.latestToView());
+        assertEquals(initialView1, initialController1.changeHandlerHistory.latestFromView());
+        assertEquals(setBackstackHandler.tag, initialController1.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(initialController1.changeHandlerHistory.latestIsPush());
+
+        assertNull(initialController2.changeHandlerHistory.latestToView());
+        assertEquals(initialView2, initialController2.changeHandlerHistory.latestFromView());
+        assertEquals(setBackstackHandler.tag, initialController2.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(initialController2.changeHandlerHistory.latestIsPush());
+
+        assertNotNull(newController1.changeHandlerHistory.latestToView());
+        assertEquals(newController1.getView(), newController1.changeHandlerHistory.toViewAt(0));
+        assertEquals(newController2.getView(), newController1.changeHandlerHistory.latestToView());
+        assertEquals(initialView1, newController1.changeHandlerHistory.fromViewAt(0));
+        assertEquals(newController1.getView(), newController1.changeHandlerHistory.latestFromView());
+        assertEquals(setBackstackHandler.tag, newController1.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(newController1.changeHandlerHistory.latestIsPush());
+
+        assertNotNull(newController2.changeHandlerHistory.latestToView());
+        assertEquals(newController2.getView(), newController2.changeHandlerHistory.latestToView());
+        assertEquals(newController1.getView(), newController2.changeHandlerHistory.latestFromView());
+        assertEquals(setBackstackHandler.tag, newController2.changeHandlerHistory.latestChangeHandler().tag);
+        assertTrue(newController2.changeHandlerHistory.latestIsPush());
+    }
+
+}

conductor/src/test/java/com/bluelinelabs/conductor/RouterTests.java

@@ -1,15 +1,27 @@
 package com.bluelinelabs.conductor;
 
-import org.junit.Assert;
+import android.view.ViewGroup;
+
+import com.bluelinelabs.conductor.changehandler.FadeChangeHandler;
+import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler;
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.MockChangeHandler;
+import com.bluelinelabs.conductor.util.TestController;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class RouterTests {
@@ -28,13 +40,13 @@ public class RouterTests {
 
         Controller rootController = new TestController();
 
-        Assert.assertFalse(router.hasRootController());
+        assertFalse(router.hasRootController());
 
         router.setRoot(RouterTransaction.with(rootController).tag(rootTag));
 
-        Assert.assertTrue(router.hasRootController());
+        assertTrue(router.hasRootController());
 
-        Assert.assertEquals(rootController, router.getControllerWithTag(rootTag));
+        assertEquals(rootController, router.getControllerWithTag(rootTag));
     }
 
     @Test
@@ -48,8 +60,8 @@ public class RouterTests {
         router.setRoot(RouterTransaction.with(oldRootController).tag(oldRootTag));
         router.setRoot(RouterTransaction.with(newRootController).tag(newRootTag));
 
-        Assert.assertNull(router.getControllerWithTag(oldRootTag));
-        Assert.assertEquals(newRootController, router.getControllerWithTag(newRootTag));
+        assertNull(router.getControllerWithTag(oldRootTag));
+        assertEquals(newRootController, router.getControllerWithTag(newRootTag));
     }
 
     @Test
@@ -58,8 +70,8 @@ public class RouterTests {
 
         router.pushController(RouterTransaction.with(controller));
 
-        Assert.assertEquals(controller, router.getControllerWithInstanceId(controller.getInstanceId()));
-        Assert.assertNull(router.getControllerWithInstanceId("fake id"));
+        assertEquals(controller, router.getControllerWithInstanceId(controller.getInstanceId()));
+        assertNull(router.getControllerWithInstanceId("fake id"));
     }
 
     @Test
@@ -76,8 +88,8 @@ public class RouterTests {
         router.pushController(RouterTransaction.with(controller2)
                 .tag(controller2Tag));
 
-        Assert.assertEquals(controller1, router.getControllerWithTag(controller1Tag));
-        Assert.assertEquals(controller2, router.getControllerWithTag(controller2Tag));
+        assertEquals(controller1, router.getControllerWithTag(controller1Tag));
+        assertEquals(controller2, router.getControllerWithTag(controller2Tag));
     }
 
     @Test
@@ -91,26 +103,26 @@ public class RouterTests {
         router.pushController(RouterTransaction.with(controller1)
                 .tag(controller1Tag));
 
-        Assert.assertEquals(1, router.getBackstackSize());
+        assertEquals(1, router.getBackstackSize());
 
         router.pushController(RouterTransaction.with(controller2)
                 .tag(controller2Tag));
 
-        Assert.assertEquals(2, router.getBackstackSize());
+        assertEquals(2, router.getBackstackSize());
 
         router.popCurrentController();
 
-        Assert.assertEquals(1, router.getBackstackSize());
+        assertEquals(1, router.getBackstackSize());
 
-        Assert.assertEquals(controller1, router.getControllerWithTag(controller1Tag));
-        Assert.assertNull(router.getControllerWithTag(controller2Tag));
+        assertEquals(controller1, router.getControllerWithTag(controller1Tag));
+        assertNull(router.getControllerWithTag(controller2Tag));
 
         router.popCurrentController();
 
-        Assert.assertEquals(0, router.getBackstackSize());
+        assertEquals(0, router.getBackstackSize());
 
-        Assert.assertNull(router.getControllerWithTag(controller1Tag));
-        Assert.assertNull(router.getControllerWithTag(controller2Tag));
+        assertNull(router.getControllerWithTag(controller1Tag));
+        assertNull(router.getControllerWithTag(controller2Tag));
     }
 
     @Test
@@ -139,11 +151,11 @@ public class RouterTests {
 
         router.popToTag(controller2Tag);
 
-        Assert.assertEquals(2, router.getBackstackSize());
-        Assert.assertEquals(controller1, router.getControllerWithTag(controller1Tag));
-        Assert.assertEquals(controller2, router.getControllerWithTag(controller2Tag));
-        Assert.assertNull(router.getControllerWithTag(controller3Tag));
-        Assert.assertNull(router.getControllerWithTag(controller4Tag));
+        assertEquals(2, router.getBackstackSize());
+        assertEquals(controller1, router.getControllerWithTag(controller1Tag));
+        assertEquals(controller2, router.getControllerWithTag(controller2Tag));
+        assertNull(router.getControllerWithTag(controller3Tag));
+        assertNull(router.getControllerWithTag(controller4Tag));
     }
 
     @Test
@@ -167,10 +179,10 @@ public class RouterTests {
 
         router.popController(controller2);
 
-        Assert.assertEquals(2, router.getBackstackSize());
-        Assert.assertEquals(controller1, router.getControllerWithTag(controller1Tag));
-        Assert.assertNull(router.getControllerWithTag(controller2Tag));
-        Assert.assertEquals(controller3, router.getControllerWithTag(controller3Tag));
+        assertEquals(2, router.getBackstackSize());
+        assertEquals(controller1, router.getControllerWithTag(controller1Tag));
+        assertNull(router.getControllerWithTag(controller2Tag));
+        assertEquals(controller3, router.getControllerWithTag(controller3Tag));
     }
 
     @Test
@@ -179,81 +191,115 @@ public class RouterTests {
         RouterTransaction middleTransaction = RouterTransaction.with(new TestController());
         RouterTransaction topTransaction = RouterTransaction.with(new TestController());
 
-        List<RouterTransaction> backstack = new ArrayList<>();
-        backstack.add(rootTransaction);
-        backstack.add(middleTransaction);
-        backstack.add(topTransaction);
-
+        List<RouterTransaction> backstack = Arrays.asList(rootTransaction, middleTransaction, topTransaction);
         router.setBackstack(backstack, null);
 
-        Assert.assertEquals(3, router.getBackstackSize());
+        assertEquals(3, router.getBackstackSize());
 
         List<RouterTransaction> fetchedBackstack = router.getBackstack();
-        Assert.assertEquals(rootTransaction, fetchedBackstack.get(0));
-        Assert.assertEquals(middleTransaction, fetchedBackstack.get(1));
-        Assert.assertEquals(topTransaction, fetchedBackstack.get(2));
+        assertEquals(rootTransaction, fetchedBackstack.get(0));
+        assertEquals(middleTransaction, fetchedBackstack.get(1));
+        assertEquals(topTransaction, fetchedBackstack.get(2));
     }
 
     @Test
     public void testNewSetBackstack() {
         router.setRoot(RouterTransaction.with(new TestController()));
 
-        Assert.assertEquals(1, router.getBackstackSize());
+        assertEquals(1, router.getBackstackSize());
 
         RouterTransaction rootTransaction = RouterTransaction.with(new TestController());
         RouterTransaction middleTransaction = RouterTransaction.with(new TestController());
         RouterTransaction topTransaction = RouterTransaction.with(new TestController());
 
-        List<RouterTransaction> backstack = new ArrayList<>();
-        backstack.add(rootTransaction);
-        backstack.add(middleTransaction);
-        backstack.add(topTransaction);
-
+        List<RouterTransaction> backstack = Arrays.asList(rootTransaction, middleTransaction, topTransaction);
         router.setBackstack(backstack, null);
 
-        Assert.assertEquals(3, router.getBackstackSize());
+        assertEquals(3, router.getBackstackSize());
 
         List<RouterTransaction> fetchedBackstack = router.getBackstack();
-        Assert.assertEquals(rootTransaction, fetchedBackstack.get(0));
-        Assert.assertEquals(middleTransaction, fetchedBackstack.get(1));
-        Assert.assertEquals(topTransaction, fetchedBackstack.get(2));
+        assertEquals(rootTransaction, fetchedBackstack.get(0));
+        assertEquals(middleTransaction, fetchedBackstack.get(1));
+        assertEquals(topTransaction, fetchedBackstack.get(2));
+
+        assertEquals(router, rootTransaction.controller.getRouter());
+        assertEquals(router, middleTransaction.controller.getRouter());
+        assertEquals(router, topTransaction.controller.getRouter());
     }
 
     @Test
     public void testNewSetBackstackWithNoRemoveViewOnPush() {
         RouterTransaction oldRootTransaction = RouterTransaction.with(new TestController());
-        RouterTransaction oldTopTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(new MockChangeHandler(false));
+        RouterTransaction oldTopTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(MockChangeHandler.noRemoveViewOnPushHandler());
 
         router.setRoot(oldRootTransaction);
         router.pushController(oldTopTransaction);
-        Assert.assertEquals(2, router.getBackstackSize());
+        assertEquals(2, router.getBackstackSize());
 
-        Assert.assertTrue(oldRootTransaction.controller.isAttached());
-        Assert.assertTrue(oldTopTransaction.controller.isAttached());
+        assertTrue(oldRootTransaction.controller.isAttached());
+        assertTrue(oldTopTransaction.controller.isAttached());
 
         RouterTransaction rootTransaction = RouterTransaction.with(new TestController());
-        RouterTransaction middleTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(new MockChangeHandler(false));
-        RouterTransaction topTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(new MockChangeHandler(false));
-
-        List<RouterTransaction> backstack = new ArrayList<>();
-        backstack.add(rootTransaction);
-        backstack.add(middleTransaction);
-        backstack.add(topTransaction);
+        RouterTransaction middleTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(MockChangeHandler.noRemoveViewOnPushHandler());
+        RouterTransaction topTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(MockChangeHandler.noRemoveViewOnPushHandler());
 
+        List<RouterTransaction> backstack = Arrays.asList(rootTransaction, middleTransaction, topTransaction);
         router.setBackstack(backstack, null);
 
-        Assert.assertEquals(3, router.getBackstackSize());
+        assertEquals(3, router.getBackstackSize());
 
         List<RouterTransaction> fetchedBackstack = router.getBackstack();
-        Assert.assertEquals(rootTransaction, fetchedBackstack.get(0));
-        Assert.assertEquals(middleTransaction, fetchedBackstack.get(1));
-        Assert.assertEquals(topTransaction, fetchedBackstack.get(2));
+        assertEquals(rootTransaction, fetchedBackstack.get(0));
+        assertEquals(middleTransaction, fetchedBackstack.get(1));
+        assertEquals(topTransaction, fetchedBackstack.get(2));
 
-        Assert.assertFalse(oldRootTransaction.controller.isAttached());
-        Assert.assertFalse(oldTopTransaction.controller.isAttached());
-        Assert.assertTrue(rootTransaction.controller.isAttached());
-        Assert.assertTrue(middleTransaction.controller.isAttached());
-        Assert.assertTrue(topTransaction.controller.isAttached());
+        assertFalse(oldRootTransaction.controller.isAttached());
+        assertFalse(oldTopTransaction.controller.isAttached());
+        assertTrue(rootTransaction.controller.isAttached());
+        assertTrue(middleTransaction.controller.isAttached());
+        assertTrue(topTransaction.controller.isAttached());
+    }
+
+    @Test
+    public void testPopToRoot() {
+        RouterTransaction rootTransaction = RouterTransaction.with(new TestController());
+        RouterTransaction transaction1 = RouterTransaction.with(new TestController());
+        RouterTransaction transaction2 = RouterTransaction.with(new TestController());
+
+        List<RouterTransaction> backstack = Arrays.asList(rootTransaction, transaction1, transaction2);
+        router.setBackstack(backstack, null);
+
+        assertEquals(3, router.getBackstackSize());
+
+        router.popToRoot();
+
+        assertEquals(1, router.getBackstackSize());
+        assertEquals(rootTransaction, router.getBackstack().get(0));
+
+        assertTrue(rootTransaction.controller.isAttached());
+        assertFalse(transaction1.controller.isAttached());
+        assertFalse(transaction2.controller.isAttached());
+    }
+
+    @Test
+    public void testPopToRootWithNoRemoveViewOnPush() {
+        RouterTransaction rootTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(new HorizontalChangeHandler(false));
+        RouterTransaction transaction1 = RouterTransaction.with(new TestController()).pushChangeHandler(new HorizontalChangeHandler(false));
+        RouterTransaction transaction2 = RouterTransaction.with(new TestController()).pushChangeHandler(new HorizontalChangeHandler(false));
+
+        List<RouterTransaction> backstack = Arrays.asList(rootTransaction, transaction1, transaction2);
+        router.setBackstack(backstack, null);
+
+        assertEquals(3, router.getBackstackSize());
+
+        router.popToRoot();
+
+        assertEquals(1, router.getBackstackSize());
+        assertEquals(rootTransaction, router.getBackstack().get(0));
+
+        assertTrue(rootTransaction.controller.isAttached());
+        assertFalse(transaction1.controller.isAttached());
+        assertFalse(transaction2.controller.isAttached());
     }
 
     @Test
@@ -261,61 +307,128 @@ public class RouterTests {
         RouterTransaction rootTransaction = RouterTransaction.with(new TestController());
         RouterTransaction topTransaction = RouterTransaction.with(new TestController());
 
-        List<RouterTransaction> backstack = new ArrayList<>();
-        backstack.add(rootTransaction);
-        backstack.add(topTransaction);
-
+        List<RouterTransaction> backstack = Arrays.asList(rootTransaction, topTransaction);
         router.setBackstack(backstack, null);
 
-        Assert.assertEquals(2, router.getBackstackSize());
+        assertEquals(2, router.getBackstackSize());
 
         List<RouterTransaction> fetchedBackstack = router.getBackstack();
-        Assert.assertEquals(rootTransaction, fetchedBackstack.get(0));
-        Assert.assertEquals(topTransaction, fetchedBackstack.get(1));
+        assertEquals(rootTransaction, fetchedBackstack.get(0));
+        assertEquals(topTransaction, fetchedBackstack.get(1));
 
         RouterTransaction newTopTransaction = RouterTransaction.with(new TestController());
         router.replaceTopController(newTopTransaction);
 
-        Assert.assertEquals(2, router.getBackstackSize());
+        assertEquals(2, router.getBackstackSize());
 
         fetchedBackstack = router.getBackstack();
-        Assert.assertEquals(rootTransaction, fetchedBackstack.get(0));
-        Assert.assertEquals(newTopTransaction, fetchedBackstack.get(1));
+        assertEquals(rootTransaction, fetchedBackstack.get(0));
+        assertEquals(newTopTransaction, fetchedBackstack.get(1));
     }
 
     @Test
     public void testReplaceTopControllerWithNoRemoveViewOnPush() {
         RouterTransaction rootTransaction = RouterTransaction.with(new TestController());
-        RouterTransaction topTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(new MockChangeHandler(false));
-
-        List<RouterTransaction> backstack = new ArrayList<>();
-        backstack.add(rootTransaction);
-        backstack.add(topTransaction);
+        RouterTransaction topTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(MockChangeHandler.noRemoveViewOnPushHandler());
 
+        List<RouterTransaction> backstack = Arrays.asList(rootTransaction, topTransaction);
         router.setBackstack(backstack, null);
 
-        Assert.assertEquals(2, router.getBackstackSize());
+        assertEquals(2, router.getBackstackSize());
 
-        Assert.assertTrue(rootTransaction.controller.isAttached());
-        Assert.assertTrue(topTransaction.controller.isAttached());
+        assertTrue(rootTransaction.controller.isAttached());
+        assertTrue(topTransaction.controller.isAttached());
 
         List<RouterTransaction> fetchedBackstack = router.getBackstack();
-        Assert.assertEquals(rootTransaction, fetchedBackstack.get(0));
-        Assert.assertEquals(topTransaction, fetchedBackstack.get(1));
+        assertEquals(rootTransaction, fetchedBackstack.get(0));
+        assertEquals(topTransaction, fetchedBackstack.get(1));
 
-        RouterTransaction newTopTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(new MockChangeHandler(false));
+        RouterTransaction newTopTransaction = RouterTransaction.with(new TestController()).pushChangeHandler(MockChangeHandler.noRemoveViewOnPushHandler());
         router.replaceTopController(newTopTransaction);
         newTopTransaction.pushChangeHandler().completeImmediately();
 
-        Assert.assertEquals(2, router.getBackstackSize());
+        assertEquals(2, router.getBackstackSize());
 
         fetchedBackstack = router.getBackstack();
-        Assert.assertEquals(rootTransaction, fetchedBackstack.get(0));
-        Assert.assertEquals(newTopTransaction, fetchedBackstack.get(1));
+        assertEquals(rootTransaction, fetchedBackstack.get(0));
+        assertEquals(newTopTransaction, fetchedBackstack.get(1));
 
-        Assert.assertTrue(rootTransaction.controller.isAttached());
-        Assert.assertFalse(topTransaction.controller.isAttached());
-        Assert.assertTrue(newTopTransaction.controller.isAttached());
+        assertTrue(rootTransaction.controller.isAttached());
+        assertFalse(topTransaction.controller.isAttached());
+        assertTrue(newTopTransaction.controller.isAttached());
+    }
+
+    @Test
+    public void testRearrangeTransactionBackstack() {
+        RouterTransaction transaction1 = RouterTransaction.with(new TestController());
+        RouterTransaction transaction2 = RouterTransaction.with(new TestController());
+
+        List<RouterTransaction> backstack = Arrays.asList(transaction1, transaction2);
+        router.setBackstack(backstack, null);
+
+        assertEquals(1, transaction1.transactionIndex);
+        assertEquals(2, transaction2.transactionIndex);
+
+        backstack = Arrays.asList(transaction2, transaction1);
+        router.setBackstack(backstack, null);
+
+        assertEquals(1, transaction2.transactionIndex);
+        assertEquals(2, transaction1.transactionIndex);
+
+        router.handleBack();
+
+        assertEquals(1, router.getBackstackSize());
+        assertEquals(transaction2, router.getBackstack().get(0));
+
+        router.handleBack();
+        assertEquals(0, router.getBackstackSize());
+    }
+
+    @Test
+    public void testChildRouterRearrangeTransactionBackstack() {
+        Controller parent = new TestController();
+        router.setRoot(RouterTransaction.with(parent));
+
+        Router childRouter = parent.getChildRouter((ViewGroup)parent.getView().findViewById(TestController.CHILD_VIEW_ID_1));
+
+        RouterTransaction transaction1 = RouterTransaction.with(new TestController());
+        RouterTransaction transaction2 = RouterTransaction.with(new TestController());
+
+        List<RouterTransaction> backstack = Arrays.asList(transaction1, transaction2);
+        childRouter.setBackstack(backstack, null);
+
+        assertEquals(2, transaction1.transactionIndex);
+        assertEquals(3, transaction2.transactionIndex);
+
+        backstack = Arrays.asList(transaction2, transaction1);
+        childRouter.setBackstack(backstack, null);
+
+        assertEquals(2, transaction2.transactionIndex);
+        assertEquals(3, transaction1.transactionIndex);
+
+        childRouter.handleBack();
+
+        assertEquals(1, childRouter.getBackstackSize());
+        assertEquals(transaction2, childRouter.getBackstack().get(0));
+
+        childRouter.handleBack();
+        assertEquals(0, childRouter.getBackstackSize());
+    }
+
+    @Test
+    public void testRemovesAllViewsOnDestroy() {
+        Controller controller1 = new TestController();
+        Controller controller2 = new TestController();
+
+        router.setRoot(RouterTransaction.with(controller1));
+        router.pushController(RouterTransaction.with(controller2)
+                .pushChangeHandler(new FadeChangeHandler(false)));
+
+        assertEquals(2, router.container.getChildCount());
+
+        router.destroy(true);
+
+        assertEquals(0, router.container.getChildCount());
     }
 
 }

conductor/src/test/java/com/bluelinelabs/conductor/TargetControllerTests.java

@@ -3,13 +3,19 @@ package com.bluelinelabs.conductor;
 import android.os.Bundle;
 import android.view.ViewGroup;
 
-import org.junit.Assert;
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.MockChangeHandler;
+import com.bluelinelabs.conductor.util.TestController;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class TargetControllerTests {
@@ -34,21 +40,21 @@ public class TargetControllerTests {
         final TestController controllerA = new TestController();
         final TestController controllerB = new TestController();
 
-        Assert.assertNull(controllerA.getTargetController());
-        Assert.assertNull(controllerB.getTargetController());
+        assertNull(controllerA.getTargetController());
+        assertNull(controllerB.getTargetController());
 
         router.pushController(RouterTransaction.with(controllerA)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         controllerB.setTargetController(controllerA);
 
         router.pushController(RouterTransaction.with(controllerB)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertNull(controllerA.getTargetController());
-        Assert.assertEquals(controllerA, controllerB.getTargetController());
+        assertNull(controllerA.getTargetController());
+        assertEquals(controllerA, controllerB.getTargetController());
     }
 
     @Test
@@ -56,22 +62,22 @@ public class TargetControllerTests {
         final TestController controllerA = new TestController();
         final TestController controllerB = new TestController();
 
-        Assert.assertNull(controllerA.getTargetController());
-        Assert.assertNull(controllerB.getTargetController());
+        assertNull(controllerA.getTargetController());
+        assertNull(controllerB.getTargetController());
 
         router.pushController(RouterTransaction.with(controllerA)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         controllerB.setTargetController(controllerA);
 
         Router childRouter = controllerA.getChildRouter((ViewGroup)controllerA.getView().findViewById(TestController.VIEW_ID));
         childRouter.pushController(RouterTransaction.with(controllerB)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertNull(controllerA.getTargetController());
-        Assert.assertEquals(controllerA, controllerB.getTargetController());
+        assertNull(controllerA.getTargetController());
+        assertEquals(controllerA, controllerB.getTargetController());
     }
 
     @Test
@@ -79,22 +85,22 @@ public class TargetControllerTests {
         final TestController controllerA = new TestController();
         final TestController controllerB = new TestController();
 
-        Assert.assertNull(controllerA.getTargetController());
-        Assert.assertNull(controllerB.getTargetController());
+        assertNull(controllerA.getTargetController());
+        assertNull(controllerB.getTargetController());
 
         router.pushController(RouterTransaction.with(controllerA)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
         controllerA.setTargetController(controllerB);
 
         Router childRouter = controllerA.getChildRouter((ViewGroup)controllerA.getView().findViewById(TestController.VIEW_ID));
         childRouter.pushController(RouterTransaction.with(controllerB)
-                .pushChangeHandler(new MockChangeHandler())
-                .popChangeHandler(new MockChangeHandler()));
+                .pushChangeHandler(MockChangeHandler.defaultHandler())
+                .popChangeHandler(MockChangeHandler.defaultHandler()));
 
-        Assert.assertNull(controllerB.getTargetController());
-        Assert.assertEquals(controllerB, controllerA.getTargetController());
+        assertNull(controllerB.getTargetController());
+        assertEquals(controllerB, controllerA.getTargetController());
     }
 
 }

conductor/src/test/java/com/bluelinelabs/conductor/ViewAttachHandlerTests.java

@@ -0,0 +1,236 @@
+package com.bluelinelabs.conductor;
+
+import android.app.Activity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+
+import com.bluelinelabs.conductor.internal.ViewAttachHandler;
+import com.bluelinelabs.conductor.internal.ViewAttachHandler.ViewAttachListener;
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.ViewUtils;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class ViewAttachHandlerTests {
+
+    private Activity activity;
+    private ViewAttachHandler viewAttachHandler;
+    private CountingViewAttachListener viewAttachListener;
+
+    @Before
+    public void setup() {
+        activity = new ActivityProxy().create(null).getActivity();
+        viewAttachListener = new CountingViewAttachListener();
+        viewAttachHandler = new ViewAttachHandler(viewAttachListener);
+    }
+
+    @Test
+    public void testSimpleViewAttachDetach() {
+        View view = new View(activity);
+        viewAttachHandler.listenForAttach(view);
+
+        assertEquals(0, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        viewAttachHandler.onActivityStopped();
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+
+        viewAttachHandler.onActivityStarted();
+        assertEquals(3, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+    }
+
+    @Test
+    public void testSimpleViewGroupAttachDetach() {
+        View view = new View(activity);
+        viewAttachHandler.listenForAttach(view);
+
+        assertEquals(0, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        viewAttachHandler.onActivityStopped();
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+
+        viewAttachHandler.onActivityStarted();
+        assertEquals(3, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+    }
+
+    @Test
+    public void testNestedViewGroupAttachDetach() {
+        ViewGroup view = new LinearLayout(activity);
+        View child = new LinearLayout(activity);
+        view.addView(child);
+        viewAttachHandler.listenForAttach(view);
+
+        assertEquals(0, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true, false);
+        assertEquals(0, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(child, true, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true, false);
+        ViewUtils.reportAttached(child, true, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(child, true, false);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        viewAttachHandler.onActivityStopped();
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(0, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, false, false);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+
+        ViewUtils.reportAttached(view, true, false);
+        ViewUtils.reportAttached(child, true, false);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+
+        viewAttachHandler.onActivityStarted();
+        assertEquals(3, viewAttachListener.attaches);
+        assertEquals(2, viewAttachListener.detaches);
+        assertEquals(1, viewAttachListener.detachAfterStops);
+    }
+
+    private static class CountingViewAttachListener implements ViewAttachListener {
+        int attaches;
+        int detaches;
+        int detachAfterStops;
+
+        @Override
+        public void onAttached() {
+            attaches++;
+        }
+
+        @Override
+        public void onDetached(boolean fromActivityStop) {
+            detaches++;
+        }
+
+        @Override
+        public void onViewDetachAfterStop() {
+            detachAfterStops++;
+        }
+    }
+
+}

conductor/src/test/java/com/bluelinelabs/conductor/ViewLeakTests.java

@@ -0,0 +1,132 @@
+package com.bluelinelabs.conductor;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.TestController;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = Config.NONE)
+public class ViewLeakTests {
+
+    private ActivityProxy activityProxy;
+    private Router router;
+
+    public void createActivityController(Bundle savedInstanceState) {
+        activityProxy = new ActivityProxy().create(savedInstanceState).start().resume();
+        router = Conductor.attachRouter(activityProxy.getActivity(), activityProxy.getView(), savedInstanceState);
+        if (!router.hasRootController()) {
+            router.setRoot(RouterTransaction.with(new TestController()));
+        }
+    }
+
+    @Before
+    public void setup() {
+        createActivityController(null);
+    }
+
+    @Test
+    public void testPop() {
+        Controller controller = new TestController();
+        router.pushController(RouterTransaction.with(controller));
+
+        assertNotNull(controller.getView());
+
+        router.popCurrentController();
+
+        assertNull(controller.getView());
+    }
+
+    @Test
+    public void testPopWhenPushNeverAdded() {
+        Controller controller = new TestController();
+        router.pushController(RouterTransaction.with(controller).pushChangeHandler(new NeverAddChangeHandler()));
+
+        assertNotNull(controller.getView());
+
+        router.popCurrentController();
+
+        assertNull(controller.getView());
+    }
+
+    @Test
+    public void testPopWhenPushNeverCompleted() {
+        Controller controller = new TestController();
+        router.pushController(RouterTransaction.with(controller).pushChangeHandler(new NeverCompleteChangeHandler()));
+
+        assertNotNull(controller.getView());
+
+        router.popCurrentController();
+
+        assertNull(controller.getView());
+    }
+
+    @Test
+    public void testActivityStop() {
+        Controller controller = new TestController();
+        router.pushController(RouterTransaction.with(controller));
+
+        assertNotNull(controller.getView());
+
+        activityProxy.stop(true);
+
+        assertNull(controller.getView());
+    }
+
+    @Test
+    public void testActivityStopWhenPushNeverCompleted() {
+        Controller controller = new TestController();
+        router.pushController(RouterTransaction.with(controller).pushChangeHandler(new NeverCompleteChangeHandler()));
+
+        assertNotNull(controller.getView());
+
+        activityProxy.stop(true);
+
+        assertNull(controller.getView());
+    }
+
+    @Test
+    public void testActivityDestroyWhenPushNeverAdded() {
+        Controller controller = new TestController();
+        router.pushController(RouterTransaction.with(controller).pushChangeHandler(new NeverAddChangeHandler()));
+
+        assertNotNull(controller.getView());
+
+        activityProxy.stop(true).destroy();
+
+        assertNull(controller.getView());
+    }
+
+    public static class NeverAddChangeHandler extends ControllerChangeHandler {
+        @Override
+        public void performChange(@NonNull final ViewGroup container, @Nullable View from, @Nullable final View to, boolean isPush, @NonNull ControllerChangeCompletedListener changeListener) {
+            if (from != null) {
+                container.removeView(from);
+            }
+        }
+    }
+
+    public static class NeverCompleteChangeHandler extends ControllerChangeHandler {
+        @Override
+        public void performChange(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush, @NonNull ControllerChangeCompletedListener changeListener) {
+            if (from != null) {
+                container.removeView(from);
+            }
+            container.addView(to);
+        }
+    }
+
+}

conductor/src/test/java/com/bluelinelabs/conductor/util/ActivityProxy.java

@@ -1,4 +1,4 @@
-package com.bluelinelabs.conductor;
+package com.bluelinelabs.conductor.util;
 
 import android.os.Bundle;
 import android.support.annotation.IdRes;
@@ -45,14 +45,19 @@ public class ActivityProxy {
         return this;
     }
 
-    public ActivityProxy stop() {
+    public ActivityProxy stop(boolean detachView) {
         activityController.stop();
-        view.setAttached(false);
+
+        if (detachView) {
+            view.setAttached(false);
+        }
+
         return this;
     }
 
     public ActivityProxy destroy() {
         activityController.destroy();
+        view.setAttached(false);
         return this;
     }
 

conductor/src/test/java/com/bluelinelabs/conductor/util/AttachFakingFrameLayout.java

@@ -1,4 +1,4 @@
-package com.bluelinelabs.conductor;
+package com.bluelinelabs.conductor.util;
 
 import android.content.Context;
 import android.os.IBinder;

conductor/src/test/java/com/bluelinelabs/conductor/util/CallState.java

@@ -1,4 +1,4 @@
-package com.bluelinelabs.conductor;
+package com.bluelinelabs.conductor.util;
 
 import android.os.Parcel;
 import android.os.Parcelable;
@@ -19,10 +19,8 @@ public class CallState implements Parcelable {
     public int onActivityResultCalls;
     public int onRequestPermissionsResultCalls;
     public int createOptionsMenuCalls;
-
-    public CallState() {
-        this(false);
-    }
+    public int contextAvailableCalls;
+    public int contextUnavailableCalls;
 
     public CallState(boolean setupForAddedController) {
         if (setupForAddedController) {
@@ -30,6 +28,7 @@ public class CallState implements Parcelable {
             changeEndCalls++;
             createViewCalls++;
             attachCalls++;
+            contextAvailableCalls++;
         }
     }
 
@@ -42,8 +41,14 @@ public class CallState implements Parcelable {
             return false;
         }
 
-        CallState callState = (CallState)o;
+        CallState callState = (CallState) o;
 
+        if (contextAvailableCalls != callState.contextAvailableCalls) {
+            return false;
+        }
+        if (contextUnavailableCalls != callState.contextUnavailableCalls) {
+            return false;
+        }
         if (changeStartCalls != callState.changeStartCalls) {
             return false;
         }
@@ -102,6 +107,8 @@ public class CallState implements Parcelable {
         result = 31 * result + onActivityResultCalls;
         result = 31 * result + onRequestPermissionsResultCalls;
         result = 31 * result + createOptionsMenuCalls;
+        result = 31 * result + contextAvailableCalls;
+        result = 31 * result + contextUnavailableCalls;
         return result;
     }
 
@@ -122,6 +129,8 @@ public class CallState implements Parcelable {
                 "\n    onActivityResultCalls=" + onActivityResultCalls +
                 "\n    onRequestPermissionsResultCalls=" + onRequestPermissionsResultCalls +
                 "\n    createOptionsMenuCalls=" + createOptionsMenuCalls +
+                "\n    contextAvailableCalls=" + contextAvailableCalls +
+                "\n    contextUnavailableCalls=" + contextUnavailableCalls +
                 "}\n";
     }
 
@@ -144,11 +153,13 @@ public class CallState implements Parcelable {
         out.writeInt(onActivityResultCalls);
         out.writeInt(onRequestPermissionsResultCalls);
         out.writeInt(createOptionsMenuCalls);
+        out.writeInt(contextAvailableCalls);
+        out.writeInt(contextUnavailableCalls);
     }
 
-    public static final Parcelable.Creator<CallState> CREATOR  = new Parcelable.Creator<CallState>() {
+    public static final Parcelable.Creator<CallState> CREATOR = new Parcelable.Creator<CallState>() {
         public CallState createFromParcel(Parcel in) {
-            CallState state = new CallState();
+            CallState state = new CallState(false);
 
             state.changeStartCalls = in.readInt();
             state.changeEndCalls = in.readInt();
@@ -164,6 +175,8 @@ public class CallState implements Parcelable {
             state.onActivityResultCalls = in.readInt();
             state.onRequestPermissionsResultCalls = in.readInt();
             state.createOptionsMenuCalls = in.readInt();
+            state.contextAvailableCalls = in.readInt();
+            state.contextUnavailableCalls = in.readInt();
 
             return state;
         }
@@ -172,4 +185,4 @@ public class CallState implements Parcelable {
             return new CallState[size];
         }
     };
-}
+}

conductor/src/test/java/com/bluelinelabs/conductor/util/ChangeHandlerHistory.java

@@ -0,0 +1,67 @@
+package com.bluelinelabs.conductor.util;
+
+import android.view.View;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ChangeHandlerHistory {
+
+    private List<Entry> entries = new ArrayList<>();
+    public boolean isValidHistory = true;
+
+    public void addEntry(View from, View to, boolean isPush, MockChangeHandler handler) {
+        entries.add(new Entry(from, to, isPush, handler));
+    }
+
+    public int size() {
+        return entries.size();
+    }
+
+    public View fromViewAt(int index) {
+        return entries.get(index).from;
+    }
+
+    public View toViewAt(int index) {
+        return entries.get(index).to;
+    }
+
+    public boolean isPushAt(int index) {
+        return entries.get(index).isPush;
+    }
+
+    public MockChangeHandler changeHandlerAt(int index) {
+        return entries.get(index).changeHandler;
+    }
+
+    public View latestFromView() {
+        return fromViewAt(size() - 1);
+    }
+
+    public View latestToView() {
+        return toViewAt(size() - 1);
+    }
+
+    public boolean latestIsPush() {
+        return isPushAt(size() - 1);
+    }
+
+    public MockChangeHandler latestChangeHandler() {
+        return changeHandlerAt(size() - 1);
+    }
+
+    private static class Entry {
+        final View from;
+        final View to;
+        final boolean isPush;
+        final MockChangeHandler changeHandler;
+
+        Entry(View from, View to, boolean isPush, MockChangeHandler changeHandler) {
+            this.from = from;
+            this.to = to;
+            this.isPush = isPush;
+            this.changeHandler = changeHandler;
+        }
+    }
+
+}

conductor/src/test/java/com/bluelinelabs/conductor/util/MockChangeHandler.java

@@ -0,0 +1,118 @@
+package com.bluelinelabs.conductor.util;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+
+public class MockChangeHandler extends ControllerChangeHandler {
+
+    private static final String KEY_REMOVES_FROM_VIEW_ON_PUSH = "MockChangeHandler.removesFromViewOnPush";
+    private static final String KEY_TAG = "MockChangeHandler.tag";
+
+    public static class ChangeHandlerListener {
+        public void willStartChange() { }
+        public void didAttachOrDetach() { }
+        public void didEndChange() { }
+    }
+
+    private final ChangeHandlerListener listener;
+    private boolean removesFromViewOnPush;
+
+    public View from;
+    public View to;
+    public String tag;
+
+    public static MockChangeHandler defaultHandler() {
+        return new MockChangeHandler(true, null, null);
+    }
+
+    public static MockChangeHandler noRemoveViewOnPushHandler() {
+        return new MockChangeHandler(false, null, null);
+    }
+
+    public static MockChangeHandler listeningChangeHandler(@NonNull ChangeHandlerListener listener) {
+        return new MockChangeHandler(true, null, listener);
+    }
+
+    public static MockChangeHandler taggedHandler(String tag, boolean removeViewOnPush) {
+        return new MockChangeHandler(removeViewOnPush, tag, null);
+    }
+
+    public MockChangeHandler() {
+        listener = null;
+    }
+
+    private MockChangeHandler(boolean removesFromViewOnPush, String tag, ChangeHandlerListener listener) {
+        this.removesFromViewOnPush = removesFromViewOnPush;
+
+        if (listener == null) {
+            this.listener = new ChangeHandlerListener() { };
+        } else {
+            this.listener = listener;
+        }
+    }
+
+    @Override
+    public void performChange(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush, @NonNull ControllerChangeCompletedListener changeListener) {
+        this.from = from;
+        this.to = to;
+
+        listener.willStartChange();
+
+        if (isPush) {
+            if (to != null) {
+                container.addView(to);
+                listener.didAttachOrDetach();
+            }
+
+            if (removesFromViewOnPush && from != null) {
+                container.removeView(from);
+            }
+        } else {
+            container.removeView(from);
+            listener.didAttachOrDetach();
+
+            if (to != null) {
+                container.addView(to);
+            }
+
+        }
+
+        changeListener.onChangeCompleted();
+        listener.didEndChange();
+    }
+
+    @Override
+    public boolean removesFromViewOnPush() {
+        return removesFromViewOnPush;
+    }
+
+    @Override
+    public void saveToBundle(@NonNull Bundle bundle) {
+        super.saveToBundle(bundle);
+        bundle.putBoolean(KEY_REMOVES_FROM_VIEW_ON_PUSH, removesFromViewOnPush);
+        bundle.putString(KEY_TAG, tag);
+    }
+
+    @Override
+    public void restoreFromBundle(@NonNull Bundle bundle) {
+        super.restoreFromBundle(bundle);
+        removesFromViewOnPush = bundle.getBoolean(KEY_REMOVES_FROM_VIEW_ON_PUSH);
+        tag = bundle.getString(KEY_TAG);
+    }
+
+    @NonNull
+    @Override
+    public ControllerChangeHandler copy() {
+        return new MockChangeHandler(removesFromViewOnPush, tag, listener);
+    }
+
+    @Override
+    public boolean isReusable() {
+        return true;
+    }
+}

conductor/src/test/java/com/bluelinelabs/conductor/util/TestActivity.java

@@ -1,4 +1,4 @@
-package com.bluelinelabs.conductor;
+package com.bluelinelabs.conductor.util;
 
 import android.app.Activity;
 

conductor/src/test/java/com/bluelinelabs/conductor/util/TestController.java

@@ -1,5 +1,6 @@
-package com.bluelinelabs.conductor;
+package com.bluelinelabs.conductor.util;
 
+import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
 import android.support.annotation.IdRes;
@@ -11,6 +12,10 @@ import android.view.View;
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 
+import com.bluelinelabs.conductor.Controller;
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+import com.bluelinelabs.conductor.ControllerChangeType;
+
 public class TestController extends Controller {
 
     @IdRes public static final int VIEW_ID = 2342;
@@ -19,11 +24,8 @@ public class TestController extends Controller {
 
     private static final String KEY_CALL_STATE = "TestController.currentCallState";
 
-    public CallState currentCallState;
-
-    public TestController() {
-        currentCallState = new CallState();
-    }
+    public CallState currentCallState = new CallState(false);
+    public ChangeHandlerHistory changeHandlerHistory = new ChangeHandlerHistory();
 
     @NonNull
     @Override
@@ -32,11 +34,11 @@ public class TestController extends Controller {
         FrameLayout view = new AttachFakingFrameLayout(inflater.getContext());
         view.setId(VIEW_ID);
 
-        FrameLayout childContainer1 = new FrameLayout(inflater.getContext());
+        FrameLayout childContainer1 = new AttachFakingFrameLayout(inflater.getContext());
         childContainer1.setId(CHILD_VIEW_ID_1);
         view.addView(childContainer1);
 
-        FrameLayout childContainer2 = new FrameLayout(inflater.getContext());
+        FrameLayout childContainer2 = new AttachFakingFrameLayout(inflater.getContext());
         childContainer2.setId(CHILD_VIEW_ID_2);
         view.addView(childContainer2);
 
@@ -53,6 +55,25 @@ public class TestController extends Controller {
     protected void onChangeEnded(@NonNull ControllerChangeHandler changeHandler, @NonNull ControllerChangeType changeType) {
         super.onChangeEnded(changeHandler, changeType);
         currentCallState.changeEndCalls++;
+
+        if (changeHandler instanceof MockChangeHandler) {
+            MockChangeHandler mockHandler = (MockChangeHandler)changeHandler;
+            changeHandlerHistory.addEntry(mockHandler.from, mockHandler.to, changeType.isPush, mockHandler);
+        } else {
+            changeHandlerHistory.isValidHistory = false;
+        }
+    }
+
+    @Override
+    protected void onContextAvailable(@NonNull Context context) {
+        super.onContextAvailable(context);
+        currentCallState.contextAvailableCalls++;
+    }
+
+    @Override
+    protected void onContextUnavailable() {
+        super.onContextUnavailable();
+        currentCallState.contextUnavailableCalls++;
     }
 
     @Override

conductor/src/test/java/com/bluelinelabs/conductor/util/ViewUtils.java

@@ -1,7 +1,8 @@
-package com.bluelinelabs.conductor;
+package com.bluelinelabs.conductor.util;
 
 import android.view.View;
 import android.view.View.OnAttachStateChangeListener;
+import android.view.ViewGroup;
 
 import org.robolectric.util.ReflectionHelpers;
 
@@ -10,6 +11,10 @@ import java.util.List;
 public class ViewUtils {
 
     public static void reportAttached(View view, boolean attached) {
+        reportAttached(view, attached, true);
+    }
+
+    public static void reportAttached(View view, boolean attached, boolean propogateToChildren) {
         if (view instanceof AttachFakingFrameLayout) {
             ((AttachFakingFrameLayout)view).setAttached(attached, false);
         }
@@ -38,6 +43,14 @@ public class ViewUtils {
             }
         }
 
+        if (propogateToChildren && view instanceof ViewGroup) {
+            ViewGroup viewGroup = (ViewGroup)view;
+            int childCount = viewGroup.getChildCount();
+            for (int i = 0; i < childCount; i++) {
+                reportAttached(viewGroup.getChildAt(i), attached, true);
+            }
+        }
+
     }
 
     private static List<OnAttachStateChangeListener> getAttachStateListeners(View view) {

demo/build.gradle

@@ -1,22 +1,8 @@
-buildscript {
-    repositories {
-        jcenter()
-    }
-    dependencies {
-        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
-    }
-}
-
 apply plugin: 'com.android.application'
-apply plugin: 'com.neenbedankt.android-apt'
 
 android {
-    compileSdkVersion 23
-    buildToolsVersion "23.0.2"
-
-    lintOptions {
-        abortOnError false
-    }
+    compileSdkVersion rootProject.ext.compileSdkVersion
+    buildToolsVersion rootProject.ext.buildToolsVersion
 
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_7
@@ -25,10 +11,11 @@ android {
 
     defaultConfig {
         applicationId "com.bluelinelabs.conductor.demo"
-        minSdkVersion 16
-        targetSdkVersion 23
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
         versionCode 1
         versionName "1.0.0"
+        vectorDrawables.useSupportLibrary true
     }
 
     buildTypes {
@@ -47,13 +34,15 @@ dependencies {
     compile rootProject.ext.supportV4
     compile rootProject.ext.supportDesign
 
-    apt rootProject.ext.butterknifeCompiler
+    annotationProcessor rootProject.ext.butterknifeCompiler
     compile rootProject.ext.butterknife
     compile rootProject.ext.picasso
 
-    compile project(':conductor-support')
-    compile project(':conductor-rxlifecycle')
-    compile project(':conductor-rxlifecycle2')
+    compile project(':conductor-modules:support')
+    compile project(':conductor-modules:rxlifecycle')
+    compile project(':conductor-modules:rxlifecycle2')
+    compile project(':conductor-modules:autodispose')
+    compile project(':conductor-modules:arch-components-lifecycle')
 
     debugCompile rootProject.ext.leakCanary
     releaseCompile rootProject.ext.leakCanaryNoOp

demo/src/main/java/com/bluelinelabs/conductor/demo/changehandler/CircularRevealChangeHandlerCompat.java

@@ -22,8 +22,9 @@ public class CircularRevealChangeHandlerCompat extends CircularRevealChangeHandl
             return super.getAnimator(container, from, to, isPush, toAddedToContainer);
         } else {
             AnimatorSet animator = new AnimatorSet();
-            if (to != null && toAddedToContainer) {
-                animator.play(ObjectAnimator.ofFloat(to, View.ALPHA, 0, 1));
+            if (to != null) {
+                float start = toAddedToContainer ? 0 : to.getAlpha();
+                animator.play(ObjectAnimator.ofFloat(to, View.ALPHA, start, 1));
             }
 
             if (from != null) {