Version bump

Made ControllerChangeHandler's copy() method public
Fixes #179

.travis.yml

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

README.md

@@ -20,14 +20,17 @@ 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.0.7'
 
 // 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.0.7'
 
-// 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.0.7'
+
+// If you want RxJava2 lifecycle support:
+compile 'com.bluelinelabs:conductor-rxlifecycle2:2.0.7'
 ```
 
 SNAPSHOT:
@@ -36,6 +39,7 @@ SNAPSHOT:
 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'
+compile 'com.bluelinelabs:conductor-rxlifecycle2:2.0.6-SNAPSHOT'
 ```
 
 You also have to add the url to the snapshot repository:

build.gradle

@@ -10,12 +10,8 @@ buildscript {
 allprojects {
     repositories {
         jcenter()
-        mavenLocal()
+        mavenCentral()
     }
 }
 
-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/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-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
 

conductor-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-support/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/build.gradle

@@ -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

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

@@ -18,12 +18,13 @@ 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;
@@ -80,7 +81,7 @@ 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<>();
@@ -229,7 +230,7 @@ public abstract class Controller {
 
     public final void removeChildRouter(@NonNull Router childRouter) {
         if ((childRouter instanceof ControllerHostedRouter) && childRouters.remove(childRouter)) {
-            childRouter.destroy();
+            childRouter.destroy(true);
         }
     }
 
@@ -751,6 +752,7 @@ public abstract class Controller {
             attach(view);
         } else if (attached) {
             needsAttach = false;
+            hasSavedViewState = false;
         }
 
         onActivityResumed(activity);
@@ -846,7 +848,8 @@ public abstract class Controller {
 
             onDestroyView(view);
 
-            view.removeOnAttachStateChangeListener(onAttachStateChangeListener);
+            viewAttachHandler.unregisterAttachListener(view);
+            viewAttachHandler = null;
             viewIsAttached = false;
 
             if (isBeingDestroyed) {
@@ -893,9 +896,9 @@ public abstract class Controller {
 
             restoreViewState(view);
 
-            onAttachStateChangeListener = new OnAttachStateChangeListener() {
+            viewAttachHandler = new ViewAttachHandler(new ViewAttachListener() {
                 @Override
-                public void onViewAttachedToWindow(View v) {
+                public void onAttached(View v) {
                     if (v == view) {
                         viewIsAttached = true;
                         viewWasDetached = false;
@@ -904,7 +907,7 @@ public abstract class Controller {
                 }
 
                 @Override
-                public void onViewDetachedFromWindow(View v) {
+                public void onDetached(View v) {
                     viewIsAttached = false;
                     viewWasDetached = true;
 
@@ -912,9 +915,8 @@ public abstract class Controller {
                         detach(v, false);
                     }
                 }
-            };
-
-            view.addOnAttachStateChangeListener(onAttachStateChangeListener);
+            });
+            viewAttachHandler.listenForAttach(view);
         } else if (retainViewMode == RetainViewMode.RETAIN_DETACH) {
             restoreChildControllerHosts();
         }
@@ -968,7 +970,7 @@ public abstract class Controller {
         }
 
         for (ControllerHostedRouter childRouter : childRouters) {
-            childRouter.destroy();
+            childRouter.destroy(false);
         }
 
         if (!attached) {
@@ -981,7 +983,7 @@ public abstract class Controller {
     private void saveViewState(@NonNull View view) {
         hasSavedViewState = true;
 
-        viewState = new Bundle();
+        viewState = new Bundle(getClass().getClassLoader());
 
         SparseArray<Parcelable> hierarchyState = new SparseArray<>();
         view.saveHierarchyState(hierarchyState);
@@ -1062,6 +1064,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));

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

@@ -28,6 +28,7 @@ public abstract class ControllerChangeHandler {
     private static final Map<String, ControllerChangeHandler> inProgressPushHandlers = new HashMap<>();
 
     private boolean forceRemoveViewOnPush;
+    private boolean hasBeenUsed;
 
     /**
      * Responsible for swapping Views from one Controller to another.
@@ -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();
@@ -134,8 +150,20 @@ public abstract class ControllerChangeHandler {
     }
 
     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) {
+        if (isPush && to != null && to.isDestroyed()) {
+            throw new IllegalStateException("Trying to push a controller that has already been destroyed. (" + to.getClass().getSimpleName() + ")");
+        }
+
         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);

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

@@ -72,9 +72,9 @@ class ControllerHostedRouter extends Router {
     }
 
     @Override
-    void destroy() {
+    void destroy(boolean popViews) {
         setDetachFrozen(false);
-        super.destroy();
+        super.destroy(popViews);
     }
 
     @Override @Nullable

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

@@ -172,7 +172,7 @@ public abstract class Router {
             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.controller, true, handler);
                 }
             }
         }
@@ -185,11 +185,11 @@ public abstract class Router {
         performControllerChange(transaction.pushChangeHandler(handler), topTransaction, true);
     }
 
-    void destroy() {
+    void destroy(boolean popViews) {
         popsLastView = true;
         List<RouterTransaction> poppedControllers = backstack.popAll();
 
-        if (poppedControllers.size() > 0) {
+        if (popViews && poppedControllers.size() > 0) {
             trackDestroyingControllers(poppedControllers);
 
             performControllerChange(null, poppedControllers.get(0).controller, false, poppedControllers.get(0).popChangeHandler());
@@ -344,48 +344,40 @@ public abstract class Router {
     public void setBackstack(@NonNull List<RouterTransaction> newBackstack, @Nullable ControllerChangeHandler changeHandler) {
         List<RouterTransaction> oldVisibleTransactions = getVisibleTransactions(backstack.iterator());
 
-        backstack.setBackstack(newBackstack);
+        removeAllExceptVisibleAndUnowned();
 
+        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) {
-                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);
+                performControllerChange(newVisibleTransactions.get(0).controller, rootController, true, changeHandler);
 
                 for (int i = oldVisibleTransactions.size() - 1; i > 0; i--) {
                     RouterTransaction transaction = oldVisibleTransactions.get(i);
-                    ControllerChangeHandler localHandler = handler.copy();
+                    ControllerChangeHandler localHandler = changeHandler != null ? changeHandler.copy() : new SimpleSwapChangeHandler();
                     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);
+                    performControllerChange(transaction.controller, newVisibleTransactions.get(i - 1).controller, true, transaction.pushChangeHandler());
                 }
             }
+
+            // Ensure all new controllers have a valid router set
+            for (RouterTransaction transaction : newBackstack) {
+                transaction.controller.setRouter(this);
+            }
         }
 
         if (onControllerPushedListener != null) {
@@ -631,7 +623,7 @@ public abstract class Router {
         } else if (from != null) {
             changeHandler = from.popChangeHandler();
         } else {
-            changeHandler = new SimpleSwapChangeHandler();
+            changeHandler = null;
         }
 
         Controller toController = to != null ? to.controller : null;
@@ -730,6 +722,20 @@ 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);
     }

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

@@ -150,6 +150,7 @@ public abstract class AnimatorChangeHandler extends ControllerChangeHandler {
             if (animatorListener != null) {
                 animator.removeListener(animatorListener);
             }
+            animator.end();
             animator = null;
         }
     }

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
  */
@@ -45,4 +47,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.
  */
@@ -54,4 +56,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

@@ -81,4 +81,5 @@ public abstract class TransitionChangeHandler extends ControllerChangeHandler {
     public final boolean removesFromViewOnPush() {
         return true;
     }
+
 }

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

@@ -69,4 +69,13 @@ 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());
+        }
+    }
+
 }

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/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/ViewAttachHandler.java

@@ -0,0 +1,111 @@
+package com.bluelinelabs.conductor.internal;
+
+import android.view.View;
+import android.view.View.OnAttachStateChangeListener;
+import android.view.ViewGroup;
+
+public class ViewAttachHandler {
+
+    public interface ViewAttachListener {
+        void onAttached(View view);
+        void onDetached(View view);
+    }
+
+    private interface ChildAttachListener {
+        void onAttached();
+    }
+
+    private ViewAttachListener attachListener;
+    private OnAttachStateChangeListener rootOnAttachStateChangeListener = new OnAttachStateChangeListener() {
+        boolean rootAttached = false;
+        boolean childrenAttached = false;
+
+        @Override
+        public void onViewAttachedToWindow(final View v) {
+            if (rootAttached) {
+                return;
+            }
+
+            rootAttached = true;
+            listenForDeepestChildAttach(v, new ChildAttachListener() {
+                @Override
+                public void onAttached() {
+                    childrenAttached = true;
+                    attachListener.onAttached(v);
+                }
+            });
+
+        }
+
+        @Override
+        public void onViewDetachedFromWindow(View v) {
+            rootAttached = false;
+            if (childrenAttached) {
+                childrenAttached = false;
+                attachListener.onDetached(v);
+            }
+        }
+    };
+    private OnAttachStateChangeListener childOnAttachStateChangeListener;
+
+    public ViewAttachHandler(ViewAttachListener attachListener) {
+        this.attachListener = attachListener;
+    }
+
+    public void listenForAttach(final View view) {
+        view.addOnAttachStateChangeListener(rootOnAttachStateChangeListener);
+    }
+
+    public void unregisterAttachListener(View view) {
+        view.removeOnAttachStateChangeListener(rootOnAttachStateChangeListener);
+
+        if (childOnAttachStateChangeListener != null && view instanceof ViewGroup) {
+            findDeepestChild((ViewGroup)view).removeOnAttachStateChangeListener(childOnAttachStateChangeListener);
+        }
+    }
+
+    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/ControllerLifecycleTests.java

@@ -6,15 +6,21 @@ 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 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.assertNull;
+
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class ControllerLifecycleTests {
@@ -60,7 +66,7 @@ public class ControllerLifecycleTests {
 
         router.popCurrentController();
 
-        Assert.assertNull(controller.getView());
+        assertNull(controller.getView());
 
         assertCalls(expectedCallState, controller);
     }
@@ -194,212 +200,212 @@ public class ControllerLifecycleTests {
             @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);
@@ -425,8 +431,8 @@ 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);
@@ -445,26 +451,30 @@ public class ControllerLifecycleTests {
 
         router.popCurrentController();
 
+        expectedCallState.detachCalls++;
+        expectedCallState.destroyViewCalls++;
+        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.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,15 +482,15 @@ 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.destroyCalls++;
@@ -488,7 +498,7 @@ public class ControllerLifecycleTests {
             }
 
             @Override
-            void didEndChange() {
+            public void didEndChange() {
                 expectedCallState.changeEndCalls++;
                 assertCalls(expectedCallState, controller);
             }
@@ -496,8 +506,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) {

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

@@ -7,14 +7,21 @@ 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;
+
 @RunWith(RobolectricTestRunner.class)
 @Config(manifest = Config.NONE)
 public class ControllerTests {
@@ -42,26 +49,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 +270,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 +323,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 +333,37 @@ 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());
     }
 
     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.ListUtils;
+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.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 = ListUtils.listOf(
+                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 = ListUtils.listOf(
+                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,23 @@
 package com.bluelinelabs.conductor;
 
-import org.junit.Assert;
+import com.bluelinelabs.conductor.util.ActivityProxy;
+import com.bluelinelabs.conductor.util.ListUtils;
+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.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 +36,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 +56,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 +66,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 +84,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 +99,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 +147,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 +175,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 +187,73 @@ 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 = ListUtils.listOf(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 = ListUtils.listOf(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 = ListUtils.listOf(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
@@ -261,61 +261,55 @@ 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 = ListUtils.listOf(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 = ListUtils.listOf(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());
     }
 
 }

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,149 @@
+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);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+    }
+
+    @Test
+    public void testSimpleViewGroupAttachDetach() {
+        View view = new LinearLayout(activity);
+        viewAttachHandler.listenForAttach(view);
+
+        assertEquals(0, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, true);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+    }
+
+    @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);
+
+        ViewUtils.reportAttached(view, true, false);
+        assertEquals(0, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(child, true, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, true, false);
+        ViewUtils.reportAttached(child, true, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(0, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, false, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, false, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(view, true, false);
+        assertEquals(1, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+
+        ViewUtils.reportAttached(child, true, false);
+        assertEquals(2, viewAttachListener.attaches);
+        assertEquals(1, viewAttachListener.detaches);
+    }
+
+    private static class CountingViewAttachListener implements ViewAttachListener {
+        int attaches;
+        int detaches;
+
+        @Override
+        public void onAttached(View view) {
+            attaches++;
+        }
+
+        @Override
+        public void onDetached(View view) {
+            detaches++;
+        }
+    }
+
+}

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;

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;

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/ListUtils.java

@@ -0,0 +1,16 @@
+package com.bluelinelabs.conductor.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ListUtils {
+
+    public static <T> List<T> listOf(T... elements) {
+        List<T> list = new ArrayList<>();
+        for (T element : elements) {
+            list.add(element);
+        }
+        return list;
+    }
+
+}

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,4 +1,4 @@
-package com.bluelinelabs.conductor;
+package com.bluelinelabs.conductor.util;
 
 import android.content.Intent;
 import android.os.Bundle;
@@ -11,6 +11,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 +23,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();
+    public ChangeHandlerHistory changeHandlerHistory = new ChangeHandlerHistory();
 
     @NonNull
     @Override
@@ -53,6 +54,13 @@ 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

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

@@ -11,11 +11,12 @@ apply plugin: 'com.android.application'
 apply plugin: 'com.neenbedankt.android-apt'
 
 android {
-    compileSdkVersion 23
-    buildToolsVersion "23.0.2"
+    compileSdkVersion 25
+    buildToolsVersion '24.0.3'
 
     lintOptions {
-        abortOnError false
+        abortOnError true
+        ignore 'UnusedResources'
     }
 
     compileOptions {
@@ -26,7 +27,7 @@ android {
     defaultConfig {
         applicationId "com.bluelinelabs.conductor.demo"
         minSdkVersion 16
-        targetSdkVersion 23
+        targetSdkVersion 25
         versionCode 1
         versionName "1.0.0"
     }

demo/src/main/java/com/bluelinelabs/conductor/demo/controllers/ParentController.java

@@ -50,17 +50,19 @@ public class ParentController extends BaseController {
             childController.addLifecycleListener(new LifecycleListener() {
                 @Override
                 public void onChangeEnd(@NonNull Controller controller, @NonNull ControllerChangeHandler changeHandler, @NonNull ControllerChangeType changeType) {
-                    if (changeType == ControllerChangeType.PUSH_ENTER && !hasShownAll) {
-                        if (index < NUMBER_OF_CHILDREN - 1) {
-                            addChild(index + 1);
-                        } else {
-                            hasShownAll = true;
-                        }
-                    } else if (changeType == ControllerChangeType.POP_EXIT) {
-                        if (index > 0) {
-                            removeChild(index - 1);
-                        } else {
-                            getRouter().popController(ParentController.this);
+                    if (!isBeingDestroyed()) {
+                        if (changeType == ControllerChangeType.PUSH_ENTER && !hasShownAll) {
+                            if (index < NUMBER_OF_CHILDREN - 1) {
+                                addChild(index + 1);
+                            } else {
+                                hasShownAll = true;
+                            }
+                        } else if (changeType == ControllerChangeType.POP_EXIT) {
+                            if (index > 0) {
+                                removeChild(index - 1);
+                            } else {
+                                getRouter().popController(ParentController.this);
+                            }
                         }
                     }
                 }

demo/src/main/java/com/bluelinelabs/conductor/demo/widget/ElasticDragDismissFrameLayout.java

@@ -16,6 +16,7 @@
 
 package com.bluelinelabs.conductor.demo.widget;
 
+import android.annotation.TargetApi;
 import android.content.Context;
 import android.support.v4.view.NestedScrollingParent;
 import android.support.v4.view.animation.FastOutSlowInInterpolator;
@@ -32,6 +33,7 @@ import java.util.List;
  * Applies an elasticity factor to reduce movement as you approach the given dismiss distance.
  * Optionally also scales down content during drag.
  */
+@TargetApi(21)
 public class ElasticDragDismissFrameLayout extends FrameLayout implements NestedScrollingParent {
 
     public static abstract class ElasticDragDismissCallback {

demo/src/main/res/layout-land/controller_master_detail_list.xml

@@ -1,9 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
-    android:orientation="horizontal"
+    xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
-    android:layout_height="match_parent">
+    android:layout_height="match_parent"
+    android:orientation="horizontal"
+    tools:ignore="InconsistentLayout">
 
     <android.support.v7.widget.RecyclerView
         android:id="@+id/recycler_view"

demo/src/main/res/layout/controller_drag_dismiss.xml

@@ -17,6 +17,7 @@
             android:textSize="22sp"
             android:padding="16dp"
             android:text="@string/drag_to_dismiss"
+            android:clickable="true"
             />
 
         <android.support.v4.widget.NestedScrollView

demo/src/main/res/layout/controller_overlay.xml

@@ -3,7 +3,8 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
-    android:background="#88000000" >
+    android:background="#88000000"
+    android:clickable="true" >
 
     <FrameLayout
         android:layout_width="match_parent"

demo/src/main/res/layout/controller_pager.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
     android:orientation="vertical">
@@ -13,6 +14,7 @@
         android:elevation="6dp"
         android:minHeight="?attr/actionBarSize"
         android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar"
+        tools:targetApi="lollipop"
         />
 
     <android.support.v4.view.ViewPager

demo/src/main/res/layout/controller_transition_demo.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <FrameLayout
+    xmlns:tools="http://schemas.android.com/tools"
     android:id="@+id/transition_root"
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
@@ -19,6 +20,7 @@
         android:layout_marginTop="96dp"
         android:gravity="center_horizontal"
         android:transitionName="@string/transition_tag_title"
+        tools:targetApi="lollipop"
         />
 
     <android.support.design.widget.FloatingActionButton
@@ -31,6 +33,7 @@
         app:elevation="0dp"
         app:pressedTranslationZ="0dp"
         android:transitionName="@string/transition_tag_dot"
+        tools:targetApi="lollipop"
         />
 
 </FrameLayout>

demo/src/main/res/layout/controller_transition_demo_shared.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <FrameLayout
+    xmlns:tools="http://schemas.android.com/tools"
     android:id="@+id/transition_root"
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
@@ -13,6 +14,7 @@
         android:layout_marginTop="24dp"
         android:gravity="center_horizontal"
         android:transitionName="@string/transition_tag_title"
+        tools:targetApi="lollipop"
         />
 
     <android.support.design.widget.FloatingActionButton
@@ -24,6 +26,7 @@
         app:elevation="0dp"
         app:pressedTranslationZ="0dp"
         android:transitionName="@string/transition_tag_dot"
+        tools:targetApi="lollipop"
         />
 
 </FrameLayout>

dependencies.gradle

@@ -1,36 +1,49 @@
 ext {
     minSdkVersion = 16
-    compileSdkVersion = 23
-    targetSdkVersion = 23
-    buildToolsVersion = '23.0.2'
+    compileSdkVersion = 25
+    targetSdkVersion = 25
+    buildToolsVersion = '24.0.3'
 
-    supportV4 = 'com.android.support:support-v4:23.1.1'
-    supportDesign = 'com.android.support:design:23.1.1'
-    supportAnnotations = 'com.android.support:support-annotations:23.1.1'
-    supportAppCompat = 'com.android.support:appcompat-v7:23.1.1'
+    supportVersion = '23.1.1'
+    butterknifeVersion = '8.0.1'
+    picassoVersion = '2.5.2'
+    leakCanaryVersion = '1.4'
+    rxJavaVersion = '1.2.0'
+    rxJava2Version = '2.0.1'
+    rxLifecycleVersion = '0.8.0'
+    rxLifecycle2Version = '2.0'
+    junitVersion = '4.11'
+    roboelectricVersion = '3.0'
+    lintVersion = '25.2.0'
 
-    butterknife = 'com.jakewharton:butterknife:8.0.1'
-    butterknifeCompiler = 'com.jakewharton:butterknife-compiler:8.0.1'
+    supportV4 = "com.android.support:support-v4:$supportVersion"
+    supportDesign = "com.android.support:design:$supportVersion"
+    supportAnnotations = "com.android.support:support-annotations:$supportVersion"
+    supportAppCompat = "com.android.support:appcompat-v7:$supportVersion"
 
-    picasso = 'com.squareup.picasso:picasso:2.5.2'
+    butterknife = "com.jakewharton:butterknife:$butterknifeVersion"
+    butterknifeCompiler = "com.jakewharton:butterknife-compiler:$butterknifeVersion"
 
-    leakCanary = 'com.squareup.leakcanary:leakcanary-android:1.4'
-    leakCanaryNoOp = 'com.squareup.leakcanary:leakcanary-android-no-op:1.4'
+    picasso = "com.squareup.picasso:picasso:$picassoVersion"
 
-    rxJava = 'io.reactivex:rxjava:1.2.0'
-    rxJava2 = "io.reactivex.rxjava2:rxjava:2.0.1"
+    leakCanary = "com.squareup.leakcanary:leakcanary-android:$leakCanaryVersion"
+    leakCanaryNoOp = "com.squareup.leakcanary:leakcanary-android-no-op:$leakCanaryVersion"
 
-    rxAndroid = 'io.reactivex:rxandroid:1.2.1'
+    rxJava = "io.reactivex:rxjava:$rxJavaVersion"
+    rxJava2 = "io.reactivex.rxjava2:rxjava:$rxJava2Version"
 
-    rxLifecycle = 'com.trello:rxlifecycle:0.8.0'
-    rxLifecycleAndroid = 'com.trello:rxlifecycle-android:0.8.0'
+    rxLifecycle = "com.trello:rxlifecycle:$rxLifecycleVersion"
+    rxLifecycleAndroid = "com.trello:rxlifecycle-android:$rxLifecycleVersion"
 
-    rxLifecycle2 = "com.trello.rxlifecycle2:rxlifecycle:2.0"
-    rxLifecycleAndroid2 = "com.trello.rxlifecycle2:rxlifecycle-android:2.0"
+    rxLifecycle2 = "com.trello.rxlifecycle2:rxlifecycle:$rxLifecycle2Version"
+    rxLifecycleAndroid2 = "com.trello.rxlifecycle2:rxlifecycle-android:$rxLifecycle2Version"
 
-    junit = 'junit:junit:4.11'
-    roboelectric = 'org.robolectric:robolectric:3.0'
+    junit = "junit:junit:$junitVersion"
+    roboelectric = "org.robolectric:robolectric:$roboelectricVersion"
+
+    lintapi = "com.android.tools.lint:lint-api:$lintVersion"
+    lintchecks = "com.android.tools.lint:lint-checks:$lintVersion"
+    lint = "com.android.tools.lint:lint:$lintVersion"
+    lintTests = "com.android.tools.lint:lint-tests:$lintVersion"
 
-    lintapi = 'com.android.tools.lint:lint-api:24.5.0'
-    lintchecks = 'com.android.tools.lint:lint-checks:24.5.0'
 }

gradle.properties

@@ -1,4 +1,4 @@
-VERSION_NAME=2.0.6-SNAPSHOT
+VERSION_NAME=2.0.8-SNAPSHOT
 VERSION_CODE=2
 GROUP=com.bluelinelabs