Renamed support->viewpager, removed old deprecated code

Fixes #582

.travis.yml

@@ -3,8 +3,8 @@ language: android
 android:
   components:
     - tools
-    - build-tools-27.0.3
-    - android-27
+    - build-tools-28.0.3
+    - android-28
     - extra-android-m2repository
   licenses:
     - '.+'

README.md

@@ -1,4 +1,4 @@
-[![Travis Build](https://travis-ci.org/bluelinelabs/Conductor.svg)](https://travis-ci.org/bluelinelabs/Conductor) [![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-Conductor-brightgreen.svg?style=flat)](http://android-arsenal.com/details/1/3361) [![Javadocs](http://javadoc.io/badge/com.bluelinelabs/conductor.svg)](http://javadoc.io/doc/com.bluelinelabs/conductor)
+[![Travis Build](https://travis-ci.com/bluelinelabs/Conductor.svg)](https://travis-ci.com/bluelinelabs/Conductor) [![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-Conductor-brightgreen.svg?style=flat)](http://android-arsenal.com/details/1/3361) [![Javadocs](http://javadoc.io/badge/com.bluelinelabs/conductor.svg)](http://javadoc.io/doc/com.bluelinelabs/conductor)
 
 # Conductor
 
@@ -20,28 +20,30 @@ Conductor is architecture-agnostic and does not try to force any design decision
 ## Installation
 
 ```gradle
-implementation 'com.bluelinelabs:conductor:2.1.5'
+implementation 'com.bluelinelabs:conductor:3.0.0-rc3'
 
-// If you want the components that go along with
-// Android's support libraries (currently just a PagerAdapter):
-implementation 'com.bluelinelabs:conductor-support:2.1.5'
+// If you want AndroidX Transition change handlers:
+implementation 'com.bluelinelabs:conductor-androidx-transition:3.0.0-rc3'
+
+// If you want a PagerAdapter for ViewPager:
+implementation 'com.bluelinelabs:conductor-viewpager:3.0.0-rc3'
 
 // If you want RxJava lifecycle support:
-implementation 'com.bluelinelabs:conductor-rxlifecycle:2.1.5'
+implementation 'com.bluelinelabs:conductor-rxlifecycle:3.0.0-rc3'
 
 // If you want RxJava2 lifecycle support:
-implementation 'com.bluelinelabs:conductor-rxlifecycle2:2.1.5'
+implementation 'com.bluelinelabs:conductor-rxlifecycle2:3.0.0-rc3'
 
 // If you want RxJava2 Autodispose support:
-implementation 'com.bluelinelabs:conductor-autodispose:2.1.5'
+implementation 'com.bluelinelabs:conductor-autodispose:3.0.0-rc3'
 
 // If you want Controllers that are Lifecycle-aware (architecture components):
-implementation 'com.bluelinelabs:conductor-archlifecycle:2.1.5'
+implementation 'com.bluelinelabs:conductor-archlifecycle:3.0.0-rc3'
 ```
 
 **SNAPSHOT**
 
-Just use `2.1.6-SNAPSHOT` as your version number in any of the dependencies above and add the url to the snapshot repository:
+Just use `3.0.1-SNAPSHOT` as your version number in any of the dependencies above and add the url to the snapshot repository:
 
 ```gradle
 allprojects {
@@ -58,7 +60,7 @@ allprojects {
 __Controller__ | The Controller is the View wrapper that will give you all of your lifecycle management features. Think of it as a lighter-weight and more predictable Fragment alternative with an easier to manage lifecycle.
 __Router__ | A Router implements navigation and backstack handling for Controllers. Router objects are attached to Activity/containing ViewGroup pairs. Routers do not directly render or push Views to the container ViewGroup, but instead defer this responsibility to the ControllerChangeHandler specified in a given transaction.
 __ControllerChangeHandler__ | ControllerChangeHandlers are responsible for swapping the View for one Controller to the View of another. They can be useful for performing animations and transitions between Controllers. Several default ControllerChangeHandlers are included.
-__ControllerTransaction__ | Transactions are used to define data about adding Controllers. RouterControllerTransactions are used to push a Controller to a Router with specified ControllerChangeHandlers, while ChildControllerTransactions are used to add child Controllers.
+__RouterTransaction__ | Transactions are used to define data about adding Controllers. RouterTransactions are used to push a Controller to a Router with specified ControllerChangeHandlers, while ChildControllerTransactions are used to add child Controllers.
 
 ## Getting Started
 
@@ -132,6 +134,14 @@ The lifecycle of a Controller is significantly simpler to understand than that o
 ### RxJava Lifecycle
 If the AutoDispose dependency has been added, there is a `ControllerScopeProvider` available that can be used along with the standard [AutoDispose library](https://github.com/uber/AutoDispose).
 
+## Community Projects
+The community has provided several helpful modules to make developing apps with Conductor even easier. Here's a collection of helpful libraries:
+
+* [ConductorGlide](https://github.com/MkhytarMkhoian/ConductorGlide) - Adds Glide lifecycle support to Controllers
+* [ConductorDialog](https://github.com/MkhytarMkhoian/ConductorDialog) - Adds a helpful DialogController (a Conductor version of DialogFragment)
+* [Mosby-Conductor](https://github.com/sockeqwe/mosby-conductor) - A plugin to integrate Mosby, an MVP/MVI library
+
+
 ## License
 ```
 Copyright 2016 BlueLine Labs, Inc.

build.gradle

@@ -4,7 +4,7 @@ buildscript {
         google()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.1.3'
+        classpath 'com.android.tools.build:gradle:3.5.2'
     }
 }
 

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

@@ -5,10 +5,19 @@ import com.android.tools.lint.detector.api.Issue;
 import java.util.Arrays;
 import java.util.List;
 
+import static com.android.tools.lint.detector.api.ApiKt.CURRENT_API;
+
 public final class IssueRegistry extends com.android.tools.lint.client.api.IssueRegistry {
-    @Override public List<Issue> getIssues() {
+
+    @Override
+    public List<Issue> getIssues() {
         return Arrays.asList(
                 ControllerIssueDetector.ISSUE,
                 ControllerChangeHandlerIssueDetector.ISSUE);
     }
+
+    @Override
+    public int getApi() {
+        return CURRENT_API;
+    }
 }

conductor-modules/androidx-transition/build.gradle

@@ -0,0 +1,35 @@
+buildscript {
+    repositories {
+        jcenter()
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion rootProject.ext.compileSdkVersion
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode Integer.parseInt(project.VERSION_CODE)
+        versionName project.VERSION_NAME
+    }
+}
+
+dependencies {
+    implementation rootProject.ext.androidxAppCompat
+    implementation rootProject.ext.androidxCollection
+    api rootProject.ext.androidxTransition
+    implementation project(':conductor')
+}
+
+ext.artifactId = 'conductor-androidx-transition'
+
+apply from: rootProject.file('dependencies.gradle')
+apply from: rootProject.file('gradle-mvn-push.gradle')

conductor-modules/androidx-transition/gradle.properties

@@ -0,0 +1,3 @@
+POM_NAME=Conductor AndroidX Transition Extensions
+POM_ARTIFACT_ID=conductor-androidx-transition
+POM_PACKAGING=aar

conductor-modules/androidx-transition/src/main/AndroidManifest.xml

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

conductor-modules/androidx-transition/src/main/java/com/bluelinelabs/conductor/changehandler/androidxtransition/SharedElementTransitionChangeHandler.java

@@ -0,0 +1,653 @@
+package com.bluelinelabs.conductor.changehandler.androidxtransition;
+
+import android.graphics.Rect;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewTreeObserver;
+import android.view.ViewTreeObserver.OnPreDrawListener;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.collection.ArrayMap;
+import androidx.core.app.SharedElementCallback;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.ViewGroupCompat;
+import androidx.transition.Transition;
+import androidx.transition.TransitionSet;
+
+import com.bluelinelabs.conductor.Controller;
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+import com.bluelinelabs.conductor.internal.TransitionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A TransitionChangeHandler that facilitates using different Transitions for the entering view, the exiting view,
+ * and shared elements between the two.
+ */
+// Much of this class is based on FragmentTransition.java and FragmentTransitionCompat21.java from the Android support library
+public abstract class SharedElementTransitionChangeHandler extends TransitionChangeHandler {
+
+    // A map of from -> to names. Generally these will be the same.
+    @NonNull  final ArrayMap<String, String> sharedElementNames = new ArrayMap<>();
+
+    @NonNull  final List<String> waitForTransitionNames = new ArrayList<>();
+    @NonNull  final List<ViewParentPair> removedViews = new ArrayList<>();
+
+    @Nullable Transition exitTransition;
+    @Nullable Transition enterTransition;
+    @Nullable Transition sharedElementTransition;
+    @Nullable private SharedElementCallback exitTransitionCallback;
+    @Nullable private SharedElementCallback enterTransitionCallback;
+
+    @NonNull
+    @Override
+    protected final Transition getTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush) {
+        exitTransition = getExitTransition(container, from, to, isPush);
+        enterTransition = getEnterTransition(container, from, to, isPush);
+        sharedElementTransition = getSharedElementTransition(container, from, to, isPush);
+        exitTransitionCallback = getExitTransitionCallback(container, from, to, isPush);
+        enterTransitionCallback = getEnterTransitionCallback(container, from, to, isPush);
+
+        if (enterTransition == null && sharedElementTransition == null && exitTransition == null) {
+            throw new IllegalStateException("SharedElementTransitionChangeHandler must have at least one transaction.");
+        }
+
+        return mergeTransitions(isPush);
+    }
+
+    @Override
+    public void prepareForTransition(@NonNull final ViewGroup container, @Nullable final View from, @Nullable final View to, @NonNull final Transition transition, final boolean isPush, @NonNull final OnTransitionPreparedListener onTransitionPreparedListener) {
+        OnTransitionPreparedListener listener = new OnTransitionPreparedListener() {
+            @Override
+            public void onPrepared() {
+                configureTransition(container, from, to, transition, isPush);
+                onTransitionPreparedListener.onPrepared();
+            }
+        };
+
+        configureSharedElements(container, from, to, isPush);
+
+        if (to != null && to.getParent() == null && waitForTransitionNames.size() > 0) {
+            waitOnAllTransitionNames(to, listener);
+            container.addView(to);
+        } else {
+            listener.onPrepared();
+        }
+    }
+
+    @Override
+    public final void executePropertyChanges(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, @Nullable Transition transition, boolean isPush) {
+        if (to != null && removedViews.size() > 0) {
+            to.setVisibility(View.VISIBLE);
+
+            for (ViewParentPair removedView : removedViews) {
+                removedView.parent.addView(removedView.view);
+            }
+
+            removedViews.clear();
+        }
+
+        super.executePropertyChanges(container, from, to, transition, isPush);
+    }
+
+    @Override
+    public void onAbortPush(@NonNull ControllerChangeHandler newHandler, @Nullable Controller newTop) {
+        super.onAbortPush(newHandler, newTop);
+
+        removedViews.clear();
+    }
+
+    void configureTransition(@NonNull final ViewGroup container, @Nullable View from, @Nullable View to, @NonNull final Transition transition, boolean isPush) {
+        final View nonExistentView = new View(container.getContext());
+
+        List<View> fromSharedElements = new ArrayList<>();
+        List<View> toSharedElements = new ArrayList<>();
+
+        configureSharedElements(container, nonExistentView, to, from, isPush, fromSharedElements, toSharedElements);
+
+        List<View> exitingViews = exitTransition != null ? configureEnteringExitingViews(exitTransition, from, fromSharedElements, nonExistentView) : null;
+        if (exitingViews == null || exitingViews.isEmpty()) {
+            exitTransition = null;
+        }
+
+        if (enterTransition != null) {
+            enterTransition.addTarget(nonExistentView);
+        }
+
+        final List<View> enteringViews = new ArrayList<>();
+        scheduleRemoveTargets(transition, enterTransition, enteringViews, exitTransition, exitingViews, sharedElementTransition, toSharedElements);
+        scheduleTargetChange(container, to, nonExistentView, toSharedElements, enteringViews, exitingViews);
+
+        setNameOverrides(container, toSharedElements);
+        scheduleNameReset(container, toSharedElements);
+    }
+
+    private void waitOnAllTransitionNames(@NonNull final View to, @NonNull final OnTransitionPreparedListener onTransitionPreparedListener) {
+        OnPreDrawListener onPreDrawListener = new OnPreDrawListener() {
+            boolean addedSubviewListeners;
+
+            @Override
+            public boolean onPreDraw() {
+                List<View> foundViews = new ArrayList<>();
+                boolean allViewsFound = true;
+                for (String transitionName : waitForTransitionNames) {
+                    View namedView = TransitionUtils.findNamedView(to, transitionName);
+                    if (namedView != null) {
+                        foundViews.add(TransitionUtils.findNamedView(to, transitionName));
+                    } else {
+                        allViewsFound = false;
+                        break;
+                    }
+                }
+
+                if (allViewsFound && !addedSubviewListeners) {
+                    addedSubviewListeners = true;
+                    waitOnChildTransitionNames(to, foundViews, this, onTransitionPreparedListener);
+                }
+
+                return false;
+            }
+        };
+
+        to.getViewTreeObserver().addOnPreDrawListener(onPreDrawListener);
+    }
+
+    void waitOnChildTransitionNames(@NonNull final View to, @NonNull List<View> foundViews, @NonNull final OnPreDrawListener parentPreDrawListener, @NonNull final OnTransitionPreparedListener onTransitionPreparedListener) {
+        for (final View view : foundViews) {
+            OneShotPreDrawListener.add(true, view, new Runnable() {
+                @Override
+                public void run() {
+                    waitForTransitionNames.remove(ViewCompat.getTransitionName(view));
+
+                    removedViews.add(new ViewParentPair(view, (ViewGroup)view.getParent()));
+                    ((ViewGroup)view.getParent()).removeView(view);
+
+                    if (waitForTransitionNames.size() == 0) {
+                        to.getViewTreeObserver().removeOnPreDrawListener(parentPreDrawListener);
+                        to.setVisibility(View.INVISIBLE);
+                        onTransitionPreparedListener.onPrepared();
+                    }
+                }
+            });
+        }
+    }
+
+    private void scheduleTargetChange(@NonNull final ViewGroup container, @Nullable final View to, @NonNull final View nonExistentView,
+                                      @NonNull final List<View> toSharedElements, @NonNull final List<View> enteringViews, @Nullable final List<View> exitingViews) {
+        OneShotPreDrawListener.add(true, container, new Runnable() {
+            @Override
+            public void run() {
+                if (enterTransition != null) {
+                    enterTransition.removeTarget(nonExistentView);
+                    List<View> views = configureEnteringExitingViews(enterTransition, to, toSharedElements, nonExistentView);
+                    enteringViews.addAll(views);
+                }
+
+                if (exitingViews != null) {
+                    if (exitTransition != null) {
+                        List<View> tempExiting = new ArrayList<>();
+                        tempExiting.add(nonExistentView);
+                        TransitionUtils.replaceTargets(exitTransition, exitingViews, tempExiting);
+                    }
+                    exitingViews.clear();
+                    exitingViews.add(nonExistentView);
+                }
+            }
+        });
+    }
+
+    private Transition mergeTransitions(boolean isPush) {
+        boolean overlap = enterTransition == null || exitTransition == null || allowTransitionOverlap(isPush);
+
+        if (overlap) {
+            return TransitionUtils.mergeTransitions(TransitionSet.ORDERING_TOGETHER, exitTransition, enterTransition, sharedElementTransition);
+        } else {
+            Transition staggered = TransitionUtils.mergeTransitions(TransitionSet.ORDERING_SEQUENTIAL, exitTransition, enterTransition);
+            return TransitionUtils.mergeTransitions(TransitionSet.ORDERING_TOGETHER, staggered, sharedElementTransition);
+        }
+    }
+
+    @NonNull List<View> configureEnteringExitingViews(@NonNull Transition transition, @Nullable View view, @NonNull List<View> sharedElements, @NonNull View nonExistentView) {
+        List<View> viewList = new ArrayList<>();
+        if (view != null) {
+            captureTransitioningViews(viewList, view);
+        }
+        viewList.removeAll(sharedElements);
+        if (!viewList.isEmpty()) {
+            viewList.add(nonExistentView);
+            TransitionUtils.addTargets(transition, viewList);
+        }
+        return viewList;
+    }
+
+    private void configureSharedElements(@NonNull ViewGroup container, @NonNull final View nonExistentView, @Nullable final View to, @Nullable View from,
+                                         final boolean isPush, @NonNull final List<View> fromSharedElements, @NonNull final List<View> toSharedElements) {
+
+        if (to == null || from == null) {
+            return;
+        }
+
+        ArrayMap<String, View> capturedFromSharedElements = captureFromSharedElements(from);
+
+        if (sharedElementNames.isEmpty()) {
+            sharedElementTransition = null;
+        } else if (capturedFromSharedElements != null) {
+            fromSharedElements.addAll(capturedFromSharedElements.values());
+        }
+
+        if (enterTransition == null && exitTransition == null && sharedElementTransition == null) {
+            return;
+        }
+
+        callSharedElementStartEnd(capturedFromSharedElements, true);
+
+        final Rect toEpicenter;
+        if (sharedElementTransition != null) {
+            toEpicenter = new Rect();
+            TransitionUtils.setTargets(sharedElementTransition, nonExistentView, fromSharedElements);
+            setFromEpicenter(capturedFromSharedElements);
+            if (enterTransition != null) {
+                enterTransition.setEpicenterCallback(new Transition.EpicenterCallback() {
+                    @Override
+                    public Rect onGetEpicenter(Transition transition) {
+                        if (toEpicenter.isEmpty()) {
+                            return null;
+                        }
+                        return toEpicenter;
+                    }
+                });
+            }
+        } else {
+            toEpicenter = null;
+        }
+
+        OneShotPreDrawListener.add(true, container, new Runnable() {
+            @Override
+            public void run() {
+                ArrayMap<String, View> capturedToSharedElements = captureToSharedElements(to, isPush);
+
+                if (capturedToSharedElements != null) {
+                    toSharedElements.addAll(capturedToSharedElements.values());
+                    toSharedElements.add(nonExistentView);
+                }
+
+                callSharedElementStartEnd(capturedToSharedElements, false);
+                if (sharedElementTransition != null) {
+                    sharedElementTransition.getTargets().clear();
+                    sharedElementTransition.getTargets().addAll(toSharedElements);
+                    TransitionUtils.replaceTargets(sharedElementTransition, fromSharedElements, toSharedElements);
+
+                    final View toEpicenterView = getToEpicenterView(capturedToSharedElements);
+                    if (toEpicenterView != null && toEpicenter != null) {
+                        TransitionUtils.getBoundsOnScreen(toEpicenterView, toEpicenter);
+                    }
+                }
+            }
+        });
+    }
+
+    @Nullable View getToEpicenterView(@Nullable ArrayMap<String, View> toSharedElements) {
+        if (enterTransition != null && sharedElementNames.size() > 0 && toSharedElements != null) {
+            return toSharedElements.get(sharedElementNames.valueAt(0));
+        }
+        return null;
+    }
+
+    private void setFromEpicenter(@Nullable ArrayMap<String, View> fromSharedElements) {
+        if (sharedElementNames.size() > 0 && fromSharedElements != null) {
+            final View fromEpicenterView = fromSharedElements.get(sharedElementNames.keyAt(0));
+
+            if (sharedElementTransition != null) {
+                TransitionUtils.setEpicenter(sharedElementTransition, fromEpicenterView);
+            }
+
+            if (exitTransition != null) {
+                TransitionUtils.setEpicenter(exitTransition, fromEpicenterView);
+            }
+        }
+    }
+
+    @Nullable ArrayMap<String, View> captureToSharedElements(@Nullable final View to, boolean isPush) {
+        if (sharedElementNames.isEmpty() || sharedElementTransition == null || to == null) {
+            sharedElementNames.clear();
+            return null;
+        }
+
+        final ArrayMap<String, View> toSharedElements = new ArrayMap<>();
+        TransitionUtils.findNamedViews(toSharedElements, to);
+        for (ViewParentPair removedView : removedViews) {
+            toSharedElements.put(ViewCompat.getTransitionName(removedView.view), removedView.view);
+        }
+
+        final List<String> names = new ArrayList<>(sharedElementNames.values());
+
+        toSharedElements.retainAll(names);
+        if (enterTransitionCallback != null) {
+            enterTransitionCallback.onMapSharedElements(names, toSharedElements);
+            for (int i = names.size() - 1; i >= 0; i--) {
+                String name = names.get(i);
+                View view = toSharedElements.get(name);
+                if (view == null) {
+                    String key = findKeyForValue(sharedElementNames, name);
+                    if (key != null) {
+                        sharedElementNames.remove(key);
+                    }
+                } else if (!name.equals(ViewCompat.getTransitionName(view))) {
+                    String key = findKeyForValue(sharedElementNames, name);
+                    if (key != null) {
+                        sharedElementNames.put(key, ViewCompat.getTransitionName(view));
+                    }
+                }
+            }
+        } else {
+            for (int i = sharedElementNames.size() - 1; i >= 0; i--) {
+                final String targetName = sharedElementNames.valueAt(i);
+                if (!toSharedElements.containsKey(targetName)) {
+                    sharedElementNames.removeAt(i);
+                }
+            }
+        }
+        return toSharedElements;
+    }
+
+    @Nullable String findKeyForValue(@NonNull ArrayMap<String, String> map, @NonNull String value) {
+        final int numElements = map.size();
+        for (int i = 0; i < numElements; i++) {
+            if (value.equals(map.valueAt(i))) {
+                return map.keyAt(i);
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    private ArrayMap<String, View> captureFromSharedElements(@NonNull View from) {
+        if (sharedElementNames.isEmpty() || sharedElementTransition == null) {
+            sharedElementNames.clear();
+            return null;
+        }
+
+        final ArrayMap<String, View> fromSharedElements = new ArrayMap<>();
+        TransitionUtils.findNamedViews(fromSharedElements, from);
+
+        final List<String> names = new ArrayList<>(sharedElementNames.keySet());
+
+        fromSharedElements.retainAll(names);
+        if (exitTransitionCallback != null) {
+            exitTransitionCallback.onMapSharedElements(names, fromSharedElements);
+            for (int i = names.size() - 1; i >= 0; i--) {
+                String name = names.get(i);
+                View view = fromSharedElements.get(name);
+                if (view == null) {
+                    sharedElementNames.remove(name);
+                } else if (!name.equals(ViewCompat.getTransitionName(view))) {
+                    String targetValue = sharedElementNames.remove(name);
+                    sharedElementNames.put(ViewCompat.getTransitionName(view), targetValue);
+                }
+            }
+        } else {
+            sharedElementNames.retainAll(fromSharedElements.keySet());
+        }
+        return fromSharedElements;
+    }
+
+    void callSharedElementStartEnd(@Nullable ArrayMap<String, View> sharedElements, boolean isStart) {
+        if (enterTransitionCallback != null) {
+            final int count = sharedElements == null ? 0 : sharedElements.size();
+            List<View> views = new ArrayList<>(count);
+            List<String> names = new ArrayList<>(count);
+            for (int i = 0; i < count; i++) {
+                names.add(sharedElements.keyAt(i));
+                views.add(sharedElements.valueAt(i));
+            }
+            if (isStart) {
+                enterTransitionCallback.onSharedElementStart(names, views, null);
+            } else {
+                enterTransitionCallback.onSharedElementEnd(names, views, null);
+            }
+        }
+    }
+
+    private void captureTransitioningViews(@NonNull List<View> transitioningViews, @NonNull View view) {
+        if (view.getVisibility() == View.VISIBLE) {
+            if (view instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view;
+                if (ViewGroupCompat.isTransitionGroup(viewGroup)) {
+                    transitioningViews.add(viewGroup);
+                } else {
+                    int count = viewGroup.getChildCount();
+                    for (int i = 0; i < count; i++) {
+                        View child = viewGroup.getChildAt(i);
+                        captureTransitioningViews(transitioningViews, child);
+                    }
+                }
+            } else {
+                transitioningViews.add(view);
+            }
+        }
+    }
+
+    private void scheduleRemoveTargets(@NonNull final Transition overallTransition,
+                                       @Nullable final Transition enterTransition, @Nullable final List<View> enteringViews,
+                                       @Nullable final Transition exitTransition, @Nullable final List<View> exitingViews,
+                                       @Nullable final Transition sharedElementTransition, @Nullable final List<View> toSharedElements) {
+        overallTransition.addListener(new Transition.TransitionListener() {
+            @Override
+            public void onTransitionStart(Transition transition) {
+                if (enterTransition != null && enteringViews != null) {
+                    TransitionUtils.replaceTargets(enterTransition, enteringViews, null);
+                }
+                if (exitTransition != null && exitingViews != null) {
+                    TransitionUtils.replaceTargets(exitTransition, exitingViews, null);
+                }
+                if (sharedElementTransition != null && toSharedElements != null) {
+                    TransitionUtils.replaceTargets(sharedElementTransition, toSharedElements, null);
+                }
+            }
+
+            @Override
+            public void onTransitionEnd(Transition transition) { }
+
+            @Override
+            public void onTransitionCancel(Transition transition) { }
+
+            @Override
+            public void onTransitionPause(Transition transition) { }
+
+            @Override
+            public void onTransitionResume(Transition transition) { }
+        });
+    }
+
+    private void setNameOverrides(@NonNull final View container, @NonNull final List<View> toSharedElements) {
+        OneShotPreDrawListener.add(true, container, new Runnable() {
+            @Override
+            public void run() {
+                final int numSharedElements = toSharedElements.size();
+                for (int i = 0; i < numSharedElements; i++) {
+                    View view = toSharedElements.get(i);
+                    String name = ViewCompat.getTransitionName(view);
+                    if (name != null) {
+                        String inName = findKeyForValue(sharedElementNames, name);
+                        ViewCompat.setTransitionName(view, inName);
+                    }
+                }
+            }
+        });
+    }
+
+    private void scheduleNameReset(@NonNull final ViewGroup container, @NonNull final List<View> toSharedElements) {
+        OneShotPreDrawListener.add(true, container, new Runnable() {
+            @Override
+            public void run() {
+                final int numSharedElements = toSharedElements.size();
+                for (int i = 0; i < numSharedElements; i++) {
+                    final View view = toSharedElements.get(i);
+                    final String name = ViewCompat.getTransitionName(view);
+                    final String inName = sharedElementNames.get(name);
+                    ViewCompat.setTransitionName(view, inName);
+                }
+            }
+        });
+    }
+
+    /**
+     * Will be called when views are ready to have their shared elements configured. Within this method one of the addSharedElement methods
+     * should be called for each shared element that will be used. If one or more of these shared elements will not instantly be available in
+     * the incoming view (for ex, in a RecyclerView), waitOnSharedElementNamed can be called to delay the transition until everything is available.
+     */
+    public abstract void configureSharedElements(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush);
+
+    /**
+     * Should return the transition that will be used on the exiting ("from") view, if one is desired.
+     */
+    @Nullable
+    public abstract Transition getExitTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush);
+
+    /**
+     * Should return the transition that will be used on shared elements between the from and to views.
+     */
+    @Nullable
+    public abstract Transition getSharedElementTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush);
+
+    /**
+     * Should return the transition that will be used on the entering ("to") view, if one is desired.
+     */
+    @Nullable
+    public abstract Transition getEnterTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush);
+
+    /**
+     * Should return a callback that can be used to customize transition behavior of the shared element transition for the "from" view.
+     */
+    @Nullable
+    public SharedElementCallback getExitTransitionCallback(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush) {
+        return null;
+    }
+
+    /**
+     * Should return a callback that can be used to customize transition behavior of the shared element transition for the "to" view.
+     */
+    @Nullable
+    public SharedElementCallback getEnterTransitionCallback(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush) {
+        return null;
+    }
+
+    /**
+     * Should return whether or not the the exit transition and enter transition should overlap. If true,
+     * the enter transition will start as soon as possible. Otherwise, the enter transition will wait until the
+     * completion of the exit transition. Defaults to true.
+     */
+    public boolean allowTransitionOverlap(boolean isPush) {
+        return true;
+    }
+
+    /**
+     * Used to register an element that will take part in the shared element transition.
+     *
+     * @param name The transition name that is used for both the entering and exiting views.
+     */
+    protected final void addSharedElement(@NonNull String name) {
+        sharedElementNames.put(name, name);
+    }
+
+    /**
+     * Used to register an element that will take part in the shared element transition. Maps the name used in the
+     * "from" view to the name used in the "to" view if they are not the same.
+     *
+     * @param fromName The transition name used in the "from" view
+     * @param toName The transition name used in the "to" view
+     */
+    protected final void addSharedElement(@NonNull String fromName, @NonNull String toName) {
+        sharedElementNames.put(fromName, toName);
+    }
+
+    /**
+     * Used to register an element that will take part in the shared element transition. Maps the name used in the
+     * "from" view to the name used in the "to" view if they are not the same.
+     *
+     * @param sharedElement The view from the "from" view that will take part in the shared element transition
+     * @param toName The transition name used in the "to" view
+     */
+    protected final void addSharedElement(@NonNull View sharedElement, @NonNull String toName) {
+        String transitionName = ViewCompat.getTransitionName(sharedElement);
+        if (transitionName == null) {
+            throw new IllegalArgumentException("Unique transitionNames are required for all sharedElements");
+        }
+        sharedElementNames.put(transitionName, toName);
+    }
+
+    /**
+     * The transition will be delayed until the view with the name passed in is available in the "to" hierarchy. This is
+     * particularly useful for views that don't load instantly, like RecyclerViews. Note that using this method can
+     * potentially lock up your app indefinitely if the view never loads!
+     */
+    protected final void waitOnSharedElementNamed(@NonNull String name) {
+        if (!sharedElementNames.values().contains(name)) {
+            throw new IllegalStateException("Can't wait on a shared element that hasn't been registered using addSharedElement");
+        }
+        waitForTransitionNames.add(name);
+    }
+
+    private static class OneShotPreDrawListener implements OnPreDrawListener, View.OnAttachStateChangeListener {
+
+        private final View view;
+        private ViewTreeObserver viewTreeObserver;
+        private final Runnable runnable;
+        private final boolean preDrawReturnValue;
+
+        private OneShotPreDrawListener(boolean preDrawReturnValue, @NonNull View view, @NonNull Runnable runnable) {
+            this.preDrawReturnValue = preDrawReturnValue;
+            this.view = view;
+            viewTreeObserver = view.getViewTreeObserver();
+            this.runnable = runnable;
+        }
+
+        @NonNull
+        public static OneShotPreDrawListener add(boolean preDrawReturnValue, @NonNull View view, @NonNull Runnable runnable) {
+            OneShotPreDrawListener listener = new OneShotPreDrawListener(preDrawReturnValue, view, runnable);
+            view.getViewTreeObserver().addOnPreDrawListener(listener);
+            view.addOnAttachStateChangeListener(listener);
+            return listener;
+        }
+
+        @Override
+        public boolean onPreDraw() {
+            removeListener();
+            runnable.run();
+            return preDrawReturnValue;
+        }
+
+        private void removeListener() {
+            if (viewTreeObserver.isAlive()) {
+                viewTreeObserver.removeOnPreDrawListener(this);
+            } else {
+                view.getViewTreeObserver().removeOnPreDrawListener(this);
+            }
+            view.removeOnAttachStateChangeListener(this);
+        }
+
+        @Override
+        public void onViewAttachedToWindow(View v) {
+            viewTreeObserver = v.getViewTreeObserver();
+        }
+
+        @Override
+        public void onViewDetachedFromWindow(View v) {
+            removeListener();
+        }
+
+    }
+
+    private static class ViewParentPair {
+        @NonNull final View view;
+        @NonNull final ViewGroup parent;
+
+        ViewParentPair(@NonNull View view, ViewGroup parent) {
+            this.view = view;
+            this.parent = parent;
+        }
+    }
+
+}

conductor-modules/androidx-transition/src/main/java/com/bluelinelabs/conductor/changehandler/androidxtransition/TransitionChangeHandler.java

@@ -0,0 +1,150 @@
+package com.bluelinelabs.conductor.changehandler.androidxtransition;
+
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.transition.Transition;
+import androidx.transition.TransitionManager;
+
+import com.bluelinelabs.conductor.Controller;
+import com.bluelinelabs.conductor.ControllerChangeHandler;
+
+/**
+ * A base {@link ControllerChangeHandler} that facilitates using {@link Transition}s to replace Controller Views.
+ */
+public abstract class TransitionChangeHandler extends ControllerChangeHandler {
+
+    public interface OnTransitionPreparedListener {
+        void onPrepared();
+    }
+
+    boolean canceled;
+    private boolean needsImmediateCompletion;
+
+    /**
+     * Should be overridden to return the Transition to use while replacing Views.
+     *
+     * @param container The container these Views are hosted in
+     * @param from      The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to        The next View that should be put in the container or {@code null} if no Controller is being transitioned to
+     * @param isPush    True if this is a push transaction, false if it's a pop
+     */
+    @NonNull
+    protected abstract Transition getTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush);
+
+    @Override
+    public void onAbortPush(@NonNull ControllerChangeHandler newHandler, @Nullable Controller newTop) {
+        super.onAbortPush(newHandler, newTop);
+
+        canceled = true;
+    }
+
+    @Override
+    public void completeImmediately() {
+        super.completeImmediately();
+
+        needsImmediateCompletion = true;
+    }
+
+    @Nullable
+    private ControllerChangeCompletedListener listener;
+
+    @Override
+    public void performChange(@NonNull final ViewGroup container, @Nullable final View from, @Nullable final View to, final boolean isPush, @NonNull final ControllerChangeCompletedListener changeListener) {
+        listener = changeListener;
+        if (canceled) {
+            changeListener.onChangeCompleted();
+            return;
+        }
+        if (needsImmediateCompletion) {
+            executePropertyChanges(container, from, to, null, isPush);
+            changeListener.onChangeCompleted();
+            return;
+        }
+
+        final Runnable onTransitionNotStarted = new Runnable() {
+            @Override
+            public void run() {
+                changeListener.onChangeCompleted();
+            }
+        };
+
+        final Transition transition = getTransition(container, from, to, isPush);
+        transition.addListener(new Transition.TransitionListener() {
+            @Override
+            public void onTransitionStart(Transition transition) {
+                container.removeCallbacks(onTransitionNotStarted);
+            }
+
+            @Override
+            public void onTransitionEnd(Transition transition) {
+                listener.onChangeCompleted();
+                listener = null;
+            }
+
+            @Override
+            public void onTransitionCancel(Transition transition) {
+                listener.onChangeCompleted();
+                listener = null;
+            }
+
+            @Override
+            public void onTransitionPause(Transition transition) { }
+
+            @Override
+            public void onTransitionResume(Transition transition) { }
+        });
+
+        prepareForTransition(container, from, to, transition, isPush, new OnTransitionPreparedListener() {
+            @Override
+            public void onPrepared() {
+                if (!canceled) {
+                    TransitionManager.beginDelayedTransition(container, transition);
+                    executePropertyChanges(container, from, to, transition, isPush);
+                    container.post(onTransitionNotStarted);
+                }
+            }
+        });
+    }
+
+    @Override
+    public boolean removesFromViewOnPush() {
+        return true;
+    }
+
+    /**
+     * Called before a transition occurs. This can be used to reorder views, set their transition names, etc. The transition will begin
+     * when {@code onTransitionPreparedListener} is called.
+     *
+     * @param container  The container these Views are hosted in
+     * @param from       The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to         The next View that should be put in the container or {@code null} if no Controller is being transitioned to
+     * @param transition The transition that is being prepared for
+     * @param isPush     True if this is a push transaction, false if it's a pop
+     */
+    public void prepareForTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, @NonNull Transition transition, boolean isPush, @NonNull OnTransitionPreparedListener onTransitionPreparedListener) {
+        onTransitionPreparedListener.onPrepared();
+    }
+
+    /**
+     * This should set all view properties needed for the transition to work properly. By default it removes the "from" view
+     * and adds the "to" view.
+     *
+     * @param container  The container these Views are hosted in
+     * @param from       The previous View in the container or {@code null} if there was no Controller before this transition
+     * @param to         The next View that should be put in the container or {@code null} if no Controller is being transitioned to
+     * @param transition The transition with which {@code TransitionManager.beginDelayedTransition} has been called. This will be null only if another ControllerChangeHandler immediately overrides this one.
+     * @param isPush     True if this is a push transaction, false if it's a pop
+     */
+    public void executePropertyChanges(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, @Nullable Transition transition, boolean isPush) {
+        if (from != null && (removesFromViewOnPush() || !isPush) && from.getParent() == container) {
+            container.removeView(from);
+        }
+        if (to != null && to.getParent() == null) {
+            container.addView(to);
+        }
+    }
+
+}

conductor-modules/androidx-transition/src/main/java/com/bluelinelabs/conductor/internal/TransitionUtils.java

@@ -1,24 +1,23 @@
 package com.bluelinelabs.conductor.internal;
 
-import android.annotation.TargetApi;
 import android.graphics.Rect;
-import android.os.Build;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.transition.Transition;
-import android.transition.TransitionSet;
 import android.view.View;
 import android.view.ViewGroup;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.view.ViewCompat;
+import androidx.transition.Transition;
+import androidx.transition.TransitionSet;
+
 import java.util.List;
 import java.util.Map;
 
-@TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public class TransitionUtils {
 
     public static void findNamedViews(@NonNull Map<String, View> namedViews, View view) {
         if (view.getVisibility() == View.VISIBLE) {
-            String transitionName = view.getTransitionName();
+            String transitionName = ViewCompat.getTransitionName(view);
             if (transitionName != null) {
                 namedViews.put(transitionName, view);
             }
@@ -36,7 +35,7 @@ public class TransitionUtils {
 
     @Nullable
     public static View findNamedView(@NonNull View view, @NonNull String transitionName) {
-        if (transitionName.equals(view.getTransitionName())) {
+        if (transitionName.equals(ViewCompat.getTransitionName(view))) {
             return view;
         }
 

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

@@ -1,11 +1,11 @@
 package com.bluelinelabs.conductor.archlifecycle;
 
-import android.arch.lifecycle.Lifecycle;
-import android.arch.lifecycle.Lifecycle.Event;
-import android.arch.lifecycle.LifecycleOwner;
-import android.arch.lifecycle.LifecycleRegistry;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.Lifecycle.Event;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.LifecycleRegistry;
 import android.content.Context;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 
 import com.bluelinelabs.conductor.Controller;

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

@@ -1,10 +1,10 @@
 package com.bluelinelabs.conductor.archlifecycle;
 
-import android.arch.lifecycle.Lifecycle;
-import android.arch.lifecycle.LifecycleOwner;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.bluelinelabs.conductor.Controller;
 

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

@@ -1,10 +1,10 @@
 package com.bluelinelabs.conductor.archlifecycle;
 
-import android.arch.lifecycle.Lifecycle;
-import android.arch.lifecycle.LifecycleOwner;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleOwner;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.bluelinelabs.conductor.RestoreViewOnCreateController;
 

conductor-modules/autodispose/build.gradle

@@ -22,6 +22,7 @@ android {
 dependencies {
     api rootProject.ext.rxJava2
     api rootProject.ext.autodispose
+    api rootProject.ext.autodisposeLifecycle
 
     implementation project(':conductor')
 }

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

@@ -1,11 +1,11 @@
 package com.bluelinelabs.conductor.autodispose;
 
 import android.content.Context;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 
 import com.bluelinelabs.conductor.Controller;
-import com.uber.autodispose.OutsideLifecycleException;
+import com.uber.autodispose.OutsideScopeException;
 
 import io.reactivex.subjects.BehaviorSubject;
 
@@ -16,7 +16,7 @@ public class ControllerLifecycleSubjectHelper {
     public static BehaviorSubject<ControllerEvent> create(@NonNull Controller controller) {
         ControllerEvent initialState;
         if (controller.isBeingDestroyed() || controller.isDestroyed()) {
-            throw new OutsideLifecycleException("Cannot bind to Controller lifecycle when outside of it.");
+            throw new OutsideScopeException("Cannot bind to Controller lifecycle when outside of it.");
         } else if (controller.isAttached()) {
             initialState = ControllerEvent.ATTACH;
         } else if (controller.getView() != null) {

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

@@ -1,20 +1,22 @@
 package com.bluelinelabs.conductor.autodispose;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 import com.bluelinelabs.conductor.Controller;
-import com.uber.autodispose.LifecycleScopeProvider;
-import com.uber.autodispose.OutsideLifecycleException;
+import com.uber.autodispose.OutsideScopeException;
+import com.uber.autodispose.lifecycle.LifecycleScopeProvider;
+import com.uber.autodispose.lifecycle.LifecycleScopes;
+import com.uber.autodispose.lifecycle.CorrespondingEventsFunction;
 
+import io.reactivex.CompletableSource;
 import io.reactivex.Observable;
-import io.reactivex.functions.Function;
 import io.reactivex.subjects.BehaviorSubject;
 
 public class ControllerScopeProvider implements LifecycleScopeProvider<ControllerEvent> {
-    private static final CorrespondingEventsFunction CORRESPONDING_EVENTS =
-            new CorrespondingEventsFunction() {
+    private static final CorrespondingEventsFunction<ControllerEvent> CORRESPONDING_EVENTS =
+            new CorrespondingEventsFunction<ControllerEvent>() {
                 @Override
-                public ControllerEvent apply(ControllerEvent lastEvent) throws OutsideLifecycleException {
+                public ControllerEvent apply(ControllerEvent lastEvent) throws OutsideScopeException {
                     switch (lastEvent) {
                         case CREATE:
                             return ControllerEvent.DESTROY;
@@ -27,20 +29,20 @@ public class ControllerScopeProvider implements LifecycleScopeProvider<Controlle
                         case DETACH:
                             return ControllerEvent.DESTROY;
                         default:
-                            throw new OutsideLifecycleException("Cannot bind to Controller lifecycle when outside of it.");
+                            throw new OutsideScopeException("Cannot bind to Controller lifecycle when outside of it.");
                     }
                 }
             };
 
     @NonNull private final BehaviorSubject<ControllerEvent> lifecycleSubject;
-    @NonNull private final Function<ControllerEvent, ControllerEvent> correspondingEventsFunction;
+    @NonNull private final CorrespondingEventsFunction<ControllerEvent> correspondingEventsFunction;
 
     public static ControllerScopeProvider from(@NonNull Controller controller) {
         return new ControllerScopeProvider(controller, CORRESPONDING_EVENTS);
     }
 
     public static ControllerScopeProvider from(@NonNull Controller controller, @NonNull final ControllerEvent untilEvent) {
-        return new ControllerScopeProvider(controller, new CorrespondingEventsFunction() {
+        return new ControllerScopeProvider(controller, new CorrespondingEventsFunction<ControllerEvent>() {
             @Override
             public ControllerEvent apply(ControllerEvent controllerEvent) {
                 return untilEvent;
@@ -48,11 +50,11 @@ public class ControllerScopeProvider implements LifecycleScopeProvider<Controlle
         });
     }
 
-    public static ControllerScopeProvider from(@NonNull Controller controller, @NonNull final CorrespondingEventsFunction correspondingEventsFunction) {
+    public static ControllerScopeProvider from(@NonNull Controller controller, @NonNull final CorrespondingEventsFunction<ControllerEvent> correspondingEventsFunction) {
         return new ControllerScopeProvider(controller, correspondingEventsFunction);
     }
 
-    private ControllerScopeProvider(@NonNull Controller controller, @NonNull CorrespondingEventsFunction correspondingEventsFunction) {
+    private ControllerScopeProvider(@NonNull Controller controller, @NonNull CorrespondingEventsFunction<ControllerEvent> correspondingEventsFunction) {
         lifecycleSubject = ControllerLifecycleSubjectHelper.create(controller);
         this.correspondingEventsFunction = correspondingEventsFunction;
     }
@@ -63,7 +65,7 @@ public class ControllerScopeProvider implements LifecycleScopeProvider<Controlle
     }
 
     @Override
-    public Function<ControllerEvent, ControllerEvent> correspondingEvents() {
+    public CorrespondingEventsFunction<ControllerEvent> correspondingEvents() {
         return correspondingEventsFunction;
     }
 
@@ -71,4 +73,9 @@ public class ControllerScopeProvider implements LifecycleScopeProvider<Controlle
     public ControllerEvent peekLifecycle() {
         return lifecycleSubject.getValue();
     }
+
+    @Override
+    public CompletableSource requestScope() throws Exception {
+        return LifecycleScopes.resolveScopeFromLifecycle(this);
+    }
 }

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

@@ -1,24 +0,0 @@
-package com.bluelinelabs.conductor.autodispose;
-
-import com.uber.autodispose.OutsideLifecycleException;
-
-import io.reactivex.functions.Function;
-
-/**
- * Based on https://github.com/uber/AutoDispose/blob/master/lifecycle/autodispose-lifecycle/src/main/java/com/uber/autodispose/lifecycle/CorrespondingEventsFunction.java
- *
- * A corresponding events function that acts as a normal {@link Function} but ensures ControllerEvent event
- * types are used in the generic and tightens the possible exception thrown to {@link OutsideLifecycleException}.
- */
-public interface CorrespondingEventsFunction extends Function<ControllerEvent, ControllerEvent> {
-
-    /**
-     * Given an event {@code event}, returns the next corresponding event that this lifecycle should
-     * dispose on.
-     *
-     * @param event the source or start event.
-     * @return the target event that should signal disposal.
-     * @throws OutsideLifecycleException if the lifecycle exceeds its scope boundaries.
-     */
-    @Override ControllerEvent apply(ControllerEvent event) throws OutsideLifecycleException;
-}

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.rxlifecycle;
 
 import android.content.Context;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 
 import com.bluelinelabs.conductor.Controller;

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.rxlifecycle;
 
 import android.os.Bundle;
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
 
 import com.bluelinelabs.conductor.Controller;
 import com.trello.rxlifecycle.LifecycleProvider;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.rxlifecycle;
 
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
 
 import com.trello.rxlifecycle.LifecycleTransformer;
 import com.trello.rxlifecycle.OutsideLifecycleException;

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.rxlifecycle;
 
 import android.os.Bundle;
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
 
 import com.bluelinelabs.conductor.RestoreViewOnCreateController;
 import com.trello.rxlifecycle.LifecycleProvider;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.rxlifecycle2;
 
 import android.content.Context;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 
 import com.bluelinelabs.conductor.Controller;

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

@@ -1,9 +1,9 @@
 package com.bluelinelabs.conductor.rxlifecycle2;
 
 import android.os.Bundle;
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import com.bluelinelabs.conductor.Controller;
 import com.trello.rxlifecycle2.LifecycleProvider;
 import com.trello.rxlifecycle2.LifecycleTransformer;

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

@@ -1,6 +1,6 @@
 package com.bluelinelabs.conductor.rxlifecycle2;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import com.trello.rxlifecycle2.LifecycleTransformer;
 import com.trello.rxlifecycle2.OutsideLifecycleException;
 import com.trello.rxlifecycle2.RxLifecycle;

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.rxlifecycle2;
 
 import android.os.Bundle;
-import android.support.annotation.CheckResult;
-import android.support.annotation.NonNull;
+import androidx.annotation.CheckResult;
+import androidx.annotation.NonNull;
 import com.bluelinelabs.conductor.RestoreViewOnCreateController;
 import com.trello.rxlifecycle2.LifecycleProvider;
 import com.trello.rxlifecycle2.LifecycleTransformer;

conductor-modules/support/gradle.properties

@@ -1,3 +0,0 @@
-POM_NAME=Conductor Support Extensions
-POM_ARTIFACT_ID=conductor-support
-POM_PACKAGING=aar

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

@@ -1,154 +0,0 @@
-package com.bluelinelabs.conductor.support;
-
-import android.os.Bundle;
-import android.os.Parcelable;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v4.view.PagerAdapter;
-import android.util.SparseArray;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.bluelinelabs.conductor.Controller;
-import com.bluelinelabs.conductor.Router;
-import com.bluelinelabs.conductor.RouterTransaction;
-
-/**
- * @deprecated Use RouterPagerAdapter instead! This implementation was too limited and had too many
- * gotchas associated with it.
- *
- * An adapter for ViewPagers that will handle adding and removing Controllers
- */
-@Deprecated
-public abstract class ControllerPagerAdapter extends PagerAdapter {
-
-    private static final String KEY_SAVED_PAGES = "ControllerPagerAdapter.savedStates";
-    private static final String KEY_SAVES_STATE = "ControllerPagerAdapter.savesState";
-    private static final String KEY_VISIBLE_PAGE_IDS_KEYS = "ControllerPagerAdapter.visiblePageIds.keys";
-    private static final String KEY_VISIBLE_PAGE_IDS_VALUES = "ControllerPagerAdapter.visiblePageIds.values";
-
-    private final Controller host;
-    private boolean savesState;
-    private SparseArray<Bundle> savedPages = new SparseArray<>();
-    private SparseArray<String> visiblePageIds = new SparseArray<>();
-
-    /**
-     * Creates a new ControllerPagerAdapter using the passed host.
-     */
-    public ControllerPagerAdapter(@NonNull Controller host, boolean saveControllerState) {
-        this.host = host;
-        savesState = saveControllerState;
-    }
-
-    /**
-     * Return the Controller associated with a specified position.
-     */
-    @NonNull
-    public abstract Controller getItem(int position);
-
-    @Override
-    public Object instantiateItem(ViewGroup container, int position) {
-        final String name = makeControllerName(container.getId(), getItemId(position));
-
-        Router router = host.getChildRouter(container, name);
-        if (savesState && !router.hasRootController()) {
-            Bundle routerSavedState = savedPages.get(position);
-
-            if (routerSavedState != null) {
-                router.restoreInstanceState(routerSavedState);
-            }
-        }
-
-        final Controller controller;
-        if (!router.hasRootController()) {
-            controller = getItem(position);
-            router.setRoot(RouterTransaction.with(controller).tag(name));
-        } else {
-            router.rebindIfNeeded();
-            controller = router.getControllerWithTag(name);
-        }
-
-        if (controller != null) {
-            visiblePageIds.put(position, controller.getInstanceId());
-        }
-
-        return router.getControllerWithTag(name);
-    }
-
-    @Override
-    public void destroyItem(ViewGroup container, int position, Object object) {
-        Router router = ((Controller)object).getRouter();
-
-        if (savesState) {
-            Bundle savedState = new Bundle();
-            router.saveInstanceState(savedState);
-            savedPages.put(position, savedState);
-        }
-
-        visiblePageIds.remove(position);
-
-        host.removeChildRouter(router);
-    }
-
-    @Override
-    public boolean isViewFromObject(View view, Object object) {
-        return ((Controller)object).getView() == view;
-    }
-
-    @Override
-    public Parcelable saveState() {
-        Bundle bundle = new Bundle();
-        bundle.putBoolean(KEY_SAVES_STATE, savesState);
-        bundle.putSparseParcelableArray(KEY_SAVED_PAGES, savedPages);
-
-        int[] visiblePageIdsKeys = new int[visiblePageIds.size()];
-        String[] visiblePageIdsValues = new String[visiblePageIds.size()];
-        for (int i = 0; i < visiblePageIds.size(); i++) {
-            visiblePageIdsKeys[i] = visiblePageIds.keyAt(i);
-            visiblePageIdsValues[i] = visiblePageIds.valueAt(i);
-        }
-        bundle.putIntArray(KEY_VISIBLE_PAGE_IDS_KEYS, visiblePageIdsKeys);
-        bundle.putStringArray(KEY_VISIBLE_PAGE_IDS_VALUES, visiblePageIdsValues);
-
-        return bundle;
-    }
-
-    @Override
-    public void restoreState(Parcelable state, ClassLoader loader) {
-        Bundle bundle = (Bundle)state;
-        if (state != null) {
-            savesState = bundle.getBoolean(KEY_SAVES_STATE, false);
-            savedPages = bundle.getSparseParcelableArray(KEY_SAVED_PAGES);
-
-            int[] visiblePageIdsKeys = bundle.getIntArray(KEY_VISIBLE_PAGE_IDS_KEYS);
-            String[] visiblePageIdsValues = bundle.getStringArray(KEY_VISIBLE_PAGE_IDS_VALUES);
-            visiblePageIds = new SparseArray<>(visiblePageIdsKeys.length);
-            for (int i = 0; i < visiblePageIdsKeys.length; i++) {
-                visiblePageIds.put(visiblePageIdsKeys[i], visiblePageIdsValues[i]);
-            }
-        }
-    }
-
-    /**
-     * Returns the already instantiated Controller in the specified position or {@code null} if
-     * this position does not yet have a controller.
-     */
-    @Nullable
-    public Controller getController(int position) {
-        String instanceId = visiblePageIds.get(position);
-        if (instanceId != null) {
-            return host.getRouter().getControllerWithInstanceId(instanceId);
-        } else {
-            return null;
-        }
-    }
-
-    public long getItemId(int position) {
-        return position;
-    }
-
-    private static String makeControllerName(int viewId, long id) {
-        return viewId + ":" + id;
-    }
-
-}

conductor-modules/viewpager/build.gradle

@@ -30,11 +30,11 @@ dependencies {
     testImplementation rootProject.ext.junit
     testImplementation rootProject.ext.roboelectric
 
-    implementation rootProject.ext.supportV4
+    implementation rootProject.ext.androidxAppCompat
     implementation project(':conductor')
 }
 
-ext.artifactId = 'conductor-support'
+ext.artifactId = 'conductor-viewpager'
 
 apply from: rootProject.file('dependencies.gradle')
 apply from: rootProject.file('gradle-mvn-push.gradle')

conductor-modules/viewpager/gradle.properties

@@ -0,0 +1,3 @@
+POM_NAME=Conductor PagerAdapter
+POM_ARTIFACT_ID=conductor-viewpager
+POM_PACKAGING=aar

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

@@ -2,9 +2,6 @@ package com.bluelinelabs.conductor.support;
 
 import android.os.Bundle;
 import android.os.Parcelable;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v4.view.PagerAdapter;
 import android.util.SparseArray;
 import android.view.View;
 import android.view.ViewGroup;
@@ -14,7 +11,13 @@ import com.bluelinelabs.conductor.Router;
 import com.bluelinelabs.conductor.RouterTransaction;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.viewpager.widget.PagerAdapter;
 
 /**
  * An adapter for ViewPagers that uses Routers as pages
@@ -22,11 +25,14 @@ import java.util.List;
 public abstract class RouterPagerAdapter extends PagerAdapter {
 
     private static final String KEY_SAVED_PAGES = "RouterPagerAdapter.savedStates";
+    private static final String KEY_TAGS_KEYS = "RouterPagerAdapter.tags.keys";
+    private static final String KEY_TAGS_VALUES = "RouterPagerAdapter.tags.values";
     private static final String KEY_MAX_PAGES_TO_STATE_SAVE = "RouterPagerAdapter.maxPagesToStateSave";
     private static final String KEY_SAVE_PAGE_HISTORY = "RouterPagerAdapter.savedPageHistory";
 
     private final Controller host;
     private int maxPagesToStateSave = Integer.MAX_VALUE;
+    private Map<Integer, String> tags = new HashMap<>();
     private SparseArray<Bundle> savedPages = new SparseArray<>();
     private SparseArray<Router> visibleRouters = new SparseArray<>();
     private ArrayList<Integer> savedPageHistory = new ArrayList<>();
@@ -65,6 +71,12 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
     public Object instantiateItem(ViewGroup container, int position) {
         final String name = makeRouterName(container.getId(), getItemId(position));
 
+        // Ensure we don't try to restore state for a router with a different ID just because
+        // the position was reused. Fixes https://github.com/bluelinelabs/Conductor/issues/582
+        if (tags.get(position) != null && !tags.get(position).equals(name)) {
+            savedPages.remove(position);
+        }
+
         Router router = host.getChildRouter(container, name);
         if (!router.hasRootController()) {
             Bundle routerSavedState = savedPages.get(position);
@@ -85,6 +97,7 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
             }
         }
 
+        tags.put(position, name);
         visibleRouters.put(position, router);
         return router;
     }
@@ -141,6 +154,8 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
     public Parcelable saveState() {
         Bundle bundle = new Bundle();
         bundle.putSparseParcelableArray(KEY_SAVED_PAGES, savedPages);
+        bundle.putIntegerArrayList(KEY_TAGS_KEYS, new ArrayList<>(tags.keySet()));
+        bundle.putStringArrayList(KEY_TAGS_VALUES, new ArrayList<>(tags.values()));
         bundle.putInt(KEY_MAX_PAGES_TO_STATE_SAVE, maxPagesToStateSave);
         bundle.putIntegerArrayList(KEY_SAVE_PAGE_HISTORY, savedPageHistory);
         return bundle;
@@ -153,6 +168,14 @@ public abstract class RouterPagerAdapter extends PagerAdapter {
             savedPages = bundle.getSparseParcelableArray(KEY_SAVED_PAGES);
             maxPagesToStateSave = bundle.getInt(KEY_MAX_PAGES_TO_STATE_SAVE);
             savedPageHistory = bundle.getIntegerArrayList(KEY_SAVE_PAGE_HISTORY);
+
+            List<Integer> tagsKeys = bundle.getIntegerArrayList(KEY_TAGS_KEYS);
+            List<String> tagsValues = bundle.getStringArrayList(KEY_TAGS_VALUES);
+            if (tagsKeys != null && tagsValues != null && tagsKeys.size() == tagsValues.size()) {
+                for (int i = 0; i < tagsKeys.size(); i++) {
+                    tags.put(tagsKeys.get(i), tagsValues.get(i));
+                }
+            }
         }
     }
 

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

@@ -2,7 +2,7 @@ package com.bluelinelabs.conductor.support;
 
 import android.app.Activity;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.util.SparseArray;
 import android.widget.FrameLayout;
 

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

@@ -1,6 +1,6 @@
 package com.bluelinelabs.conductor.support.util;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

conductor/build.gradle

@@ -35,7 +35,7 @@ dependencies {
     testImplementation rootProject.ext.junit
     testImplementation rootProject.ext.roboelectric
 
-    api rootProject.ext.supportAnnotations
+    api rootProject.ext.androidxAnnotations
 
     lintChecks project(path: ':conductor-lint', configuration: 'lintChecks')
 }

conductor/proguard-rules.txt

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

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

@@ -5,8 +5,8 @@ import android.content.Intent;
 import android.content.IntentSender;
 import android.content.IntentSender.SendIntentException;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.ControllerChangeHandler.ControllerChangeListener;

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import java.util.ArrayDeque;
 import java.util.ArrayList;

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

@@ -3,8 +3,8 @@ package com.bluelinelabs.conductor;
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.os.Build;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.util.AttributeSet;
 import android.view.MotionEvent;
 import android.view.ViewGroup;

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

@@ -2,9 +2,9 @@ package com.bluelinelabs.conductor;
 
 import android.app.Activity;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.annotation.UiThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.UiThread;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.internal.LifecycleHandler;

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

@@ -9,9 +9,6 @@ import android.content.res.Resources;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcelable;
-import android.support.annotation.IdRes;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
 import android.text.TextUtils;
 import android.util.SparseArray;
 import android.view.LayoutInflater;
@@ -35,6 +32,10 @@ import java.util.Comparator;
 import java.util.List;
 import java.util.UUID;
 
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 /**
  * A Controller manages portions of the UI. It is similar to an Activity or Fragment in that it manages its
  * own lifecycle and controls interactions between the UI and whatever logic is required. It is, however,
@@ -846,7 +847,7 @@ public abstract class Controller {
 
     final void activityStopped(@NonNull Activity activity) {
         final boolean attached = this.attached;
-        
+
         if (viewAttachHandler != null) {
             viewAttachHandler.onActivityStopped();
         }
@@ -883,7 +884,7 @@ public abstract class Controller {
 
     void attach(@NonNull View view) {
         attachedToUnownedParent = router == null || view.getParent() != router.container;
-        if (attachedToUnownedParent) {
+        if (attachedToUnownedParent || isBeingDestroyed) {
             return;
         }
 
@@ -1281,6 +1282,8 @@ public abstract class Controller {
             }
             destroyedView = null;
         }
+
+        changeHandler.onEnd();
     }
 
     final void setDetachFrozen(boolean frozen) {

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewParent;
@@ -232,6 +232,8 @@ public abstract class ControllerChangeHandler {
         }
     }
 
+    protected void onEnd(){ }
+
     public boolean removesFromViewOnPush() {
         return true;
     }

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

@@ -5,9 +5,9 @@ import android.content.Intent;
 import android.content.IntentSender;
 import android.content.IntentSender.SendIntentException;
 import android.os.Bundle;
-import android.support.annotation.IdRes;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.ControllerChangeHandler.ControllerChangeListener;

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -4,9 +4,6 @@ import android.app.Activity;
 import android.content.Intent;
 import android.content.IntentSender;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.annotation.UiThread;
 import android.view.Menu;
 import android.view.MenuInflater;
 import android.view.MenuItem;
@@ -26,6 +23,10 @@ import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.UiThread;
+
 /**
  * A Router implements navigation and backstack handling for {@link Controller}s. Router objects are attached
  * to Activity/containing ViewGroup pairs. Routers do not directly render or push Views to the container ViewGroup,
@@ -139,6 +140,9 @@ public abstract class Router {
             RouterTransaction removedTransaction = null;
             RouterTransaction nextTransaction = null;
             Iterator<RouterTransaction> iterator = backstack.iterator();
+            ControllerChangeHandler topPushHandler = topTransaction != null ? topTransaction.pushChangeHandler() : null;
+            final boolean needsNextTransactionAttach = topPushHandler != null ? !topPushHandler.removesFromViewOnPush() : false;
+
             while (iterator.hasNext()) {
                 RouterTransaction transaction = iterator.next();
                 if (transaction.controller == controller) {
@@ -148,7 +152,7 @@ public abstract class Router {
                     iterator.remove();
                     removedTransaction = transaction;
                 } else if (removedTransaction != null) {
-                    if (!transaction.controller.isAttached()) {
+                    if (needsNextTransactionAttach && !transaction.controller.isAttached()) {
                         nextTransaction = transaction;
                     }
                     break;
@@ -490,7 +494,18 @@ public abstract class Router {
         // set the backstack to prevent the possibility that they'll be destroyed before the controller
         // change handler runs.
         for (RouterTransaction removedTransaction : transactionsToBeRemoved) {
-            removedTransaction.controller.destroy();
+
+            // Still need to ensure the controller isn't queued up to be removed later on.
+            boolean willBeRemoved = false;
+            for (ChangeTransaction pendingTransaction : pendingControllerChanges) {
+                if (pendingTransaction.from == removedTransaction.controller) {
+                    willBeRemoved = true;
+                }
+            }
+
+            if (!willBeRemoved) {
+                removedTransaction.controller.destroy();
+            }
         }
     }
 
@@ -536,6 +551,8 @@ public abstract class Router {
 
             if (transaction.controller.getNeedsAttach()) {
                 performControllerChange(transaction, null, true, new SimpleSwapChangeHandler(false));
+            } else {
+                setControllerRouter(transaction.controller);
             }
         }
     }

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.bluelinelabs.conductor.internal.TransactionIndexer;
 

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

@@ -4,8 +4,8 @@ import android.animation.Animator;
 import android.animation.Animator.AnimatorListener;
 import android.animation.AnimatorListenerAdapter;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewTreeObserver;

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

@@ -1,33 +0,0 @@
-package com.bluelinelabs.conductor.changehandler;
-
-import android.annotation.TargetApi;
-import android.os.Build;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.transition.AutoTransition;
-import android.transition.Transition;
-import android.view.View;
-import android.view.ViewGroup;
-
-import com.bluelinelabs.conductor.ControllerChangeHandler;
-
-/**
- * @deprecated It's very rare that a simple AutoTransition is what you want when changing controllers. This class
- * is deprecated simply because it was often a red herring for people trying to make nice transitions.
- *
- * A change handler that will use an AutoTransition.
- */
-@TargetApi(Build.VERSION_CODES.LOLLIPOP)
-public class AutoTransitionChangeHandler extends TransitionChangeHandler {
-
-    @Override @NonNull
-    protected Transition getTransition(@NonNull ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush) {
-        return new AutoTransition();
-    }
-
-    @Override @NonNull
-    public ControllerChangeHandler copy() {
-        return new AutoTransitionChangeHandler();
-    }
-
-}

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

@@ -3,8 +3,8 @@ package com.bluelinelabs.conductor.changehandler;
 import android.animation.Animator;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -3,8 +3,8 @@ package com.bluelinelabs.conductor.changehandler;
 import android.animation.Animator;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -4,8 +4,6 @@ import android.annotation.TargetApi;
 import android.app.SharedElementCallback;
 import android.graphics.Rect;
 import android.os.Build;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
 import android.transition.Transition;
 import android.transition.Transition.TransitionListener;
 import android.transition.TransitionSet;
@@ -17,17 +15,23 @@ import android.view.ViewTreeObserver.OnPreDrawListener;
 
 import com.bluelinelabs.conductor.Controller;
 import com.bluelinelabs.conductor.ControllerChangeHandler;
-import com.bluelinelabs.conductor.internal.TransitionUtils;
+import com.bluelinelabs.conductor.internal.LegacyTransitionUtils;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 /**
  * A TransitionChangeHandler that facilitates using different Transitions for the entering view, the exiting view,
  * and shared elements between the two.
+ *
+ * @deprecated See {@link TransitionChangeHandler}
  */
 // Much of this class is based on FragmentTransition.java and FragmentTransitionCompat21.java from the Android support library
 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+@Deprecated
 public abstract class SharedElementTransitionChangeHandler extends TransitionChangeHandler {
 
     // A map of from -> to names. Generally these will be the same.
@@ -134,9 +138,9 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
                 List<View> foundViews = new ArrayList<>();
                 boolean allViewsFound = true;
                 for (String transitionName : waitForTransitionNames) {
-                    View namedView = TransitionUtils.findNamedView(to, transitionName);
+                    View namedView = LegacyTransitionUtils.findNamedView(to, transitionName);
                     if (namedView != null) {
-                        foundViews.add(TransitionUtils.findNamedView(to, transitionName));
+                        foundViews.add(LegacyTransitionUtils.findNamedView(to, transitionName));
                     } else {
                         allViewsFound = false;
                         break;
@@ -190,7 +194,7 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
                     if (exitTransition != null) {
                         List<View> tempExiting = new ArrayList<>();
                         tempExiting.add(nonExistentView);
-                        TransitionUtils.replaceTargets(exitTransition, exitingViews, tempExiting);
+                        LegacyTransitionUtils.replaceTargets(exitTransition, exitingViews, tempExiting);
                     }
                     exitingViews.clear();
                     exitingViews.add(nonExistentView);
@@ -203,10 +207,10 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
         boolean overlap = enterTransition == null || exitTransition == null || allowTransitionOverlap(isPush);
 
         if (overlap) {
-            return TransitionUtils.mergeTransitions(TransitionSet.ORDERING_TOGETHER, exitTransition, enterTransition, sharedElementTransition);
+            return LegacyTransitionUtils.mergeTransitions(TransitionSet.ORDERING_TOGETHER, exitTransition, enterTransition, sharedElementTransition);
         } else {
-            Transition staggered = TransitionUtils.mergeTransitions(TransitionSet.ORDERING_SEQUENTIAL, exitTransition, enterTransition);
-            return TransitionUtils.mergeTransitions(TransitionSet.ORDERING_TOGETHER, staggered, sharedElementTransition);
+            Transition staggered = LegacyTransitionUtils.mergeTransitions(TransitionSet.ORDERING_SEQUENTIAL, exitTransition, enterTransition);
+            return LegacyTransitionUtils.mergeTransitions(TransitionSet.ORDERING_TOGETHER, staggered, sharedElementTransition);
         }
     }
 
@@ -218,7 +222,7 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
         viewList.removeAll(sharedElements);
         if (!viewList.isEmpty()) {
             viewList.add(nonExistentView);
-            TransitionUtils.addTargets(transition, viewList);
+            LegacyTransitionUtils.addTargets(transition, viewList);
         }
         return viewList;
     }
@@ -247,7 +251,7 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
         final Rect toEpicenter;
         if (sharedElementTransition != null) {
             toEpicenter = new Rect();
-            TransitionUtils.setTargets(sharedElementTransition, nonExistentView, fromSharedElements);
+            LegacyTransitionUtils.setTargets(sharedElementTransition, nonExistentView, fromSharedElements);
             setFromEpicenter(capturedFromSharedElements);
             if (enterTransition != null) {
                 enterTransition.setEpicenterCallback(new Transition.EpicenterCallback() {
@@ -278,11 +282,11 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
                 if (sharedElementTransition != null) {
                     sharedElementTransition.getTargets().clear();
                     sharedElementTransition.getTargets().addAll(toSharedElements);
-                    TransitionUtils.replaceTargets(sharedElementTransition, fromSharedElements, toSharedElements);
+                    LegacyTransitionUtils.replaceTargets(sharedElementTransition, fromSharedElements, toSharedElements);
 
                     final View toEpicenterView = getToEpicenterView(capturedToSharedElements);
                     if (toEpicenterView != null && toEpicenter != null) {
-                        TransitionUtils.getBoundsOnScreen(toEpicenterView, toEpicenter);
+                        LegacyTransitionUtils.getBoundsOnScreen(toEpicenterView, toEpicenter);
                     }
                 }
             }
@@ -301,11 +305,11 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
             final View fromEpicenterView = fromSharedElements.get(sharedElementNames.keyAt(0));
 
             if (sharedElementTransition != null) {
-                TransitionUtils.setEpicenter(sharedElementTransition, fromEpicenterView);
+                LegacyTransitionUtils.setEpicenter(sharedElementTransition, fromEpicenterView);
             }
 
             if (exitTransition != null) {
-                TransitionUtils.setEpicenter(exitTransition, fromEpicenterView);
+                LegacyTransitionUtils.setEpicenter(exitTransition, fromEpicenterView);
             }
         }
     }
@@ -317,7 +321,7 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
         }
 
         final ArrayMap<String, View> toSharedElements = new ArrayMap<>();
-        TransitionUtils.findNamedViews(toSharedElements, to);
+        LegacyTransitionUtils.findNamedViews(toSharedElements, to);
         for (ViewParentPair removedView : removedViews) {
             toSharedElements.put(removedView.view.getTransitionName(), removedView.view);
         }
@@ -371,7 +375,7 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
         }
 
         final ArrayMap<String, View> fromSharedElements = new ArrayMap<>();
-        TransitionUtils.findNamedViews(fromSharedElements, from);
+        LegacyTransitionUtils.findNamedViews(fromSharedElements, from);
 
         final List<String> names = new ArrayList<>(sharedElementNames.keySet());
 
@@ -438,13 +442,13 @@ public abstract class SharedElementTransitionChangeHandler extends TransitionCha
             @Override
             public void onTransitionStart(Transition transition) {
                 if (enterTransition != null && enteringViews != null) {
-                    TransitionUtils.replaceTargets(enterTransition, enteringViews, null);
+                    LegacyTransitionUtils.replaceTargets(enterTransition, enteringViews, null);
                 }
                 if (exitTransition != null && exitingViews != null) {
-                    TransitionUtils.replaceTargets(exitTransition, exitingViews, null);
+                    LegacyTransitionUtils.replaceTargets(exitTransition, exitingViews, null);
                 }
                 if (sharedElementTransition != null && toSharedElements != null) {
-                    TransitionUtils.replaceTargets(sharedElementTransition, toSharedElements, null);
+                    LegacyTransitionUtils.replaceTargets(sharedElementTransition, toSharedElements, null);
                 }
             }
 

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.changehandler;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.View.OnAttachStateChangeListener;
 import android.view.ViewGroup;

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

@@ -2,8 +2,8 @@ package com.bluelinelabs.conductor.changehandler;
 
 import android.annotation.TargetApi;
 import android.os.Build;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.transition.Transition;
 import android.transition.Transition.TransitionListener;
 import android.transition.TransitionManager;
@@ -15,8 +15,15 @@ import com.bluelinelabs.conductor.ControllerChangeHandler;
 
 /**
  * A base {@link ControllerChangeHandler} that facilitates using {@link android.transition.Transition}s to replace Controller Views.
+ *
+ * @deprecated Transitions are backported via
+ * <a href="https://developer.android.com/jetpack/androidx/releases/transition">AndroidX</a>.
+ * They have the same API, but are preferred to the built-in framework transitions as they fix
+ * platform-specific bugs, and even work on versions older than 5.0.
+ * The {@code androidx-transition} module provides an equivalent {@link ControllerChangeHandler}.
  */
 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+@Deprecated
 public abstract class TransitionChangeHandler extends ControllerChangeHandler {
 
     public interface OnTransitionPreparedListener {
@@ -51,8 +58,12 @@ public abstract class TransitionChangeHandler extends ControllerChangeHandler {
         needsImmediateCompletion = true;
     }
 
+    @Nullable
+    private ControllerChangeCompletedListener listener;
+
     @Override
     public void performChange(@NonNull final ViewGroup container, @Nullable final View from, @Nullable final View to, final boolean isPush, @NonNull final ControllerChangeCompletedListener changeListener) {
+        listener = changeListener;
         if (canceled) {
             changeListener.onChangeCompleted();
             return;
@@ -63,19 +74,30 @@ public abstract class TransitionChangeHandler extends ControllerChangeHandler {
             return;
         }
 
+        final Runnable onTransitionNotStarted = new Runnable() {
+            @Override
+            public void run() {
+                changeListener.onChangeCompleted();
+            }
+        };
+
         final Transition transition = getTransition(container, from, to, isPush);
         transition.addListener(new TransitionListener() {
             @Override
-            public void onTransitionStart(Transition transition) { }
+            public void onTransitionStart(Transition transition) {
+                container.removeCallbacks(onTransitionNotStarted);
+            }
 
             @Override
             public void onTransitionEnd(Transition transition) {
-                changeListener.onChangeCompleted();
+                listener.onChangeCompleted();
+                listener = null;
             }
 
             @Override
             public void onTransitionCancel(Transition transition) {
-                changeListener.onChangeCompleted();
+                listener.onChangeCompleted();
+                listener = null;
             }
 
             @Override
@@ -91,6 +113,7 @@ public abstract class TransitionChangeHandler extends ControllerChangeHandler {
                 if (!canceled) {
                     TransitionManager.beginDelayedTransition(container, transition);
                     executePropertyChanges(container, from, to, transition, isPush);
+                    container.post(onTransitionNotStarted);
                 }
             }
         });

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

@@ -2,8 +2,8 @@ package com.bluelinelabs.conductor.changehandler;
 
 import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 
@@ -20,6 +20,7 @@ public class TransitionChangeHandlerCompat extends ControllerChangeHandler {
     private static final String KEY_CHANGE_HANDLER_CLASS = "TransitionChangeHandlerCompat.changeHandler.class";
     private static final String KEY_HANDLER_STATE = "TransitionChangeHandlerCompat.changeHandler.state";
 
+    @Nullable 
     private ControllerChangeHandler changeHandler;
 
     public TransitionChangeHandlerCompat() { }
@@ -41,17 +42,23 @@ public class TransitionChangeHandlerCompat extends ControllerChangeHandler {
 
     @Override
     public void performChange(@NonNull final ViewGroup container, @Nullable View from, @Nullable View to, boolean isPush, @NonNull final ControllerChangeCompletedListener changeListener) {
-        changeHandler.performChange(container, from, to, isPush, changeListener);
+        if (changeHandler != null) {
+            changeHandler.performChange(container, from, to, isPush, changeListener);
+        }
     }
 
     @Override
     public void saveToBundle(@NonNull Bundle bundle) {
         super.saveToBundle(bundle);
 
-        bundle.putString(KEY_CHANGE_HANDLER_CLASS, changeHandler.getClass().getName());
+        if (changeHandler != null) {
+            bundle.putString(KEY_CHANGE_HANDLER_CLASS, changeHandler.getClass().getName());
+        }
 
         Bundle stateBundle = new Bundle();
-        changeHandler.saveToBundle(stateBundle);
+        if (changeHandler != null) {
+            changeHandler.saveToBundle(stateBundle);
+        }
         bundle.putBundle(KEY_HANDLER_STATE, stateBundle);
     }
 
@@ -67,7 +74,10 @@ public class TransitionChangeHandlerCompat extends ControllerChangeHandler {
 
     @Override
     public boolean removesFromViewOnPush() {
-        return changeHandler.removesFromViewOnPush();
+        if (changeHandler != null) {
+            return changeHandler.removesFromViewOnPush();
+        }
+        return true;
     }
 
     @Override @NonNull
@@ -81,17 +91,27 @@ public class TransitionChangeHandlerCompat extends ControllerChangeHandler {
 
     @Override
     public void onAbortPush(@NonNull ControllerChangeHandler newHandler, @Nullable Controller newTop) {
-        changeHandler.onAbortPush(newHandler, newTop);
+        if (changeHandler != null) {
+            changeHandler.onAbortPush(newHandler, newTop);
+        }
     }
 
     @Override
     public void completeImmediately() {
+      if (changeHandler != null) {
         changeHandler.completeImmediately();
+      }
     }
 
     @Override
     public void setForceRemoveViewOnPush(boolean force) {
+      if (changeHandler != null) {
         changeHandler.setForceRemoveViewOnPush(force);
+      }
     }
 
+    @Override 
+    protected void onEnd() {
+        changeHandler = null;
+    }
 }

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

@@ -3,8 +3,8 @@ package com.bluelinelabs.conductor.changehandler;
 import android.animation.Animator;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.internal;
 
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.text.TextUtils;
 
 public class ClassUtils {

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

@@ -0,0 +1,185 @@
+package com.bluelinelabs.conductor.internal;
+
+import android.annotation.TargetApi;
+import android.graphics.Rect;
+import android.os.Build;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import android.transition.Transition;
+import android.transition.TransitionSet;
+import android.view.View;
+import android.view.ViewGroup;
+
+import java.util.List;
+import java.util.Map;
+
+@TargetApi(Build.VERSION_CODES.LOLLIPOP)
+public class LegacyTransitionUtils {
+
+    public static void findNamedViews(@NonNull Map<String, View> namedViews, View view) {
+        if (view.getVisibility() == View.VISIBLE) {
+            String transitionName = view.getTransitionName();
+            if (transitionName != null) {
+                namedViews.put(transitionName, view);
+            }
+
+            if (view instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view;
+                int childCount = viewGroup.getChildCount();
+                for (int i = 0; i < childCount; i++) {
+                    View child = viewGroup.getChildAt(i);
+                    findNamedViews(namedViews, child);
+                }
+            }
+        }
+    }
+
+    @Nullable
+    public static View findNamedView(@NonNull View view, @NonNull String transitionName) {
+        if (transitionName.equals(view.getTransitionName())) {
+            return view;
+        }
+
+        if (view instanceof ViewGroup) {
+            ViewGroup viewGroup = (ViewGroup) view;
+            int childCount = viewGroup.getChildCount();
+            for (int i = 0; i < childCount; i++) {
+                View viewWithTransitionName = findNamedView(viewGroup.getChildAt(i), transitionName);
+                if (viewWithTransitionName != null) {
+                    return viewWithTransitionName;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public static void setEpicenter(@NonNull Transition transition, @Nullable View view) {
+        if (view != null) {
+            final Rect epicenter = new Rect();
+            getBoundsOnScreen(view, epicenter);
+            transition.setEpicenterCallback(new Transition.EpicenterCallback() {
+                @Override
+                public Rect onGetEpicenter(Transition transition) {
+                    return epicenter;
+                }
+            });
+        }
+    }
+
+    public static void getBoundsOnScreen(@NonNull View view, @NonNull Rect epicenter) {
+        int[] loc = new int[2];
+        view.getLocationOnScreen(loc);
+        epicenter.set(loc[0], loc[1], loc[0] + view.getWidth(), loc[1] + view.getHeight());
+    }
+
+    public static void setTargets(@NonNull Transition transition, @NonNull View nonExistentView, @NonNull List<View> sharedViews) {
+        final List<View> views = transition.getTargets();
+        views.clear();
+        final int count = sharedViews.size();
+        for (int i = 0; i < count; i++) {
+            final View view = sharedViews.get(i);
+            bfsAddViewChildren(views, view);
+        }
+        views.add(nonExistentView);
+        sharedViews.add(nonExistentView);
+        addTargets(transition, sharedViews);
+    }
+
+    public static void addTargets(@Nullable Transition transition, @NonNull List<View> views) {
+        if (transition == null) {
+            return;
+        }
+        if (transition instanceof TransitionSet) {
+            TransitionSet set = (TransitionSet) transition;
+            int numTransitions = set.getTransitionCount();
+            for (int i = 0; i < numTransitions; i++) {
+                Transition child = set.getTransitionAt(i);
+                addTargets(child, views);
+            }
+        } else if (!hasSimpleTarget(transition)) {
+            List<View> targets = transition.getTargets();
+            if (isNullOrEmpty(targets)) {
+                int numViews = views.size();
+                for (int i = 0; i < numViews; i++) {
+                    transition.addTarget(views.get(i));
+                }
+            }
+        }
+    }
+
+    public static void replaceTargets(@NonNull Transition transition, @NonNull List<View> oldTargets, @Nullable List<View> newTargets) {
+        if (transition instanceof TransitionSet) {
+            TransitionSet set = (TransitionSet) transition;
+            int numTransitions = set.getTransitionCount();
+            for (int i = 0; i < numTransitions; i++) {
+                Transition child = set.getTransitionAt(i);
+                replaceTargets(child, oldTargets, newTargets);
+            }
+        } else if (!LegacyTransitionUtils.hasSimpleTarget(transition)) {
+            List<View> targets = transition.getTargets();
+            if (targets != null && targets.size() == oldTargets.size() && targets.containsAll(oldTargets)) {
+                final int targetCount = newTargets == null ? 0 : newTargets.size();
+                for (int i = 0; i < targetCount; i++) {
+                    transition.addTarget(newTargets.get(i));
+                }
+                for (int i = oldTargets.size() - 1; i >= 0; i--) {
+                    transition.removeTarget(oldTargets.get(i));
+                }
+            }
+        }
+    }
+
+    private static void bfsAddViewChildren(@NonNull final List<View> views, @NonNull final View startView) {
+        final int startIndex = views.size();
+        if (containedBeforeIndex(views, startView, startIndex)) {
+            return; // This child is already in the list, so all its children are also.
+        }
+        views.add(startView);
+        for (int index = startIndex; index < views.size(); index++) {
+            final View view = views.get(index);
+            if (view instanceof ViewGroup) {
+                ViewGroup viewGroup = (ViewGroup) view;
+                final int childCount = viewGroup.getChildCount();
+                for (int childIndex = 0; childIndex < childCount; childIndex++) {
+                    final View child = viewGroup.getChildAt(childIndex);
+                    if (!containedBeforeIndex(views, child, startIndex)) {
+                        views.add(child);
+                    }
+                }
+            }
+        }
+    }
+
+    private static boolean containedBeforeIndex(@NonNull List<View> views, View view, int maxIndex) {
+        for (int i = 0; i < maxIndex; i++) {
+            if (views.get(i) == view) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static boolean hasSimpleTarget(@NonNull Transition transition) {
+        return !isNullOrEmpty(transition.getTargetIds())
+                || !isNullOrEmpty(transition.getTargetNames())
+                || !isNullOrEmpty(transition.getTargetTypes());
+    }
+
+    private static boolean isNullOrEmpty(@Nullable List list) {
+        return list == null || list.isEmpty();
+    }
+
+    @NonNull
+    public static TransitionSet mergeTransitions(int ordering, Transition... transitions) {
+        TransitionSet transitionSet = new TransitionSet();
+        for (Transition transition : transitions) {
+            if (transition != null) {
+                transitionSet.addTransition(transition);
+            }
+        }
+        transitionSet.setOrdering(ordering);
+        return transitionSet;
+    }
+
+}

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

@@ -11,8 +11,6 @@ import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcel;
 import android.os.Parcelable;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
 import android.util.SparseArray;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -27,6 +25,9 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 public class LifecycleHandler extends Fragment implements ActivityLifecycleCallbacks {
 
     private static final String FRAGMENT_TAG = "LifecycleHandler";

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.internal;
 
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -2,7 +2,7 @@ package com.bluelinelabs.conductor.internal;
 
 import android.os.Parcel;
 import android.os.Parcelable;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.util.SparseArray;
 
 public class StringSparseArrayParceler implements Parcelable {

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.internal;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 
 public class TransactionIndexer {
 

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -2,7 +2,7 @@ package com.bluelinelabs.conductor;
 
 import android.content.Context;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -6,6 +6,7 @@ import android.view.ViewGroup;
 import com.bluelinelabs.conductor.util.ActivityProxy;
 import com.bluelinelabs.conductor.util.MockChangeHandler;
 import com.bluelinelabs.conductor.util.TestController;
+import com.bluelinelabs.conductor.util.ViewUtils;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -257,6 +258,35 @@ public class ReattachCaseTests {
         assertTrue(controller2.isAttached());
     }
 
+    @Test
+    public void testPopMiddleControllerAttaches() {
+        Controller controller1 = new TestController();
+        Controller controller2 = new TestController();
+        Controller controller3 = new TestController();
+
+        router.setRoot(RouterTransaction.with(controller1));
+        router.pushController(RouterTransaction.with(controller2));
+        router.pushController(RouterTransaction.with(controller3));
+        router.popController(controller2);
+
+        assertFalse(controller1.isAttached());
+        assertFalse(controller2.isAttached());
+        assertTrue(controller3.isAttached());
+
+        controller1 = new TestController();
+        controller2 = new TestController();
+        controller3 = new TestController();
+
+        router.setRoot(RouterTransaction.with(controller1));
+        router.pushController(RouterTransaction.with(controller2));
+        router.pushController(RouterTransaction.with(controller3).pushChangeHandler(MockChangeHandler.noRemoveViewOnPushHandler()));
+        router.popController(controller2);
+
+        assertTrue(controller1.isAttached());
+        assertFalse(controller2.isAttached());
+        assertTrue(controller3.isAttached());
+    }
+
     private void sleepWakeDevice() {
         activityProxy.saveInstanceState(new Bundle()).pause();
         activityProxy.resume();

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

@@ -1,6 +1,6 @@
 package com.bluelinelabs.conductor;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.util;
 
 import android.os.Bundle;
-import android.support.annotation.IdRes;
+import androidx.annotation.IdRes;
 
 import org.robolectric.Robolectric;
 import org.robolectric.android.controller.ActivityController;

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.util;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -3,8 +3,8 @@ package com.bluelinelabs.conductor.util;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
-import android.support.annotation.IdRes;
-import android.support.annotation.NonNull;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuInflater;

demo/build.gradle

@@ -4,8 +4,8 @@ android {
     compileSdkVersion rootProject.ext.compileSdkVersion
 
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_7
-        targetCompatibility JavaVersion.VERSION_1_7
+        sourceCompatibility 1.8
+        targetCompatibility 1.8
     }
 
     defaultConfig {
@@ -30,8 +30,8 @@ android {
 }
 
 dependencies {
-    implementation rootProject.ext.supportV4
-    implementation rootProject.ext.supportDesign
+    implementation rootProject.ext.androidxAppCompat
+    implementation rootProject.ext.material
 
     implementation rootProject.ext.archComponentsLiveDataCore // Fix duplicate classes
 
@@ -40,11 +40,12 @@ dependencies {
     implementation rootProject.ext.picasso
 
     implementation project(':conductor')
-    implementation project(':conductor-modules:support')
+    implementation project(':conductor-modules:viewpager')
     implementation project(':conductor-modules:rxlifecycle')
     implementation project(':conductor-modules:rxlifecycle2')
     implementation project(':conductor-modules:autodispose')
     implementation project(':conductor-modules:arch-components-lifecycle')
+    implementation project(':conductor-modules:androidx-transition')
 
     debugImplementation rootProject.ext.leakCanary
     releaseImplementation rootProject.ext.leakCanaryNoOp

demo/src/main/java/com/bluelinelabs/conductor/demo/ActionBarProvider.java

@@ -1,6 +1,6 @@
 package com.bluelinelabs.conductor.demo;
 
-import android.support.v7.app.ActionBar;
+import androidx.appcompat.app.ActionBar;
 
 public interface ActionBarProvider {
     ActionBar getSupportActionBar();

demo/src/main/java/com/bluelinelabs/conductor/demo/MainActivity.java

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.demo;
 
 import android.os.Bundle;
-import android.support.v7.app.AppCompatActivity;
-import android.support.v7.widget.Toolbar;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.appcompat.widget.Toolbar;
 import android.view.ViewGroup;
 
 import com.bluelinelabs.conductor.Conductor;

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

@@ -1,28 +1,25 @@
 package com.bluelinelabs.conductor.demo.changehandler;
 
-import android.annotation.TargetApi;
-import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.transition.ArcMotion;
-import android.transition.ChangeBounds;
-import android.transition.ChangeClipBounds;
-import android.transition.ChangeTransform;
-import android.transition.Fade;
-import android.transition.Transition;
-import android.transition.Transition.TransitionListener;
-import android.transition.TransitionSet;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.transition.ArcMotion;
+import androidx.transition.ChangeBounds;
+import androidx.transition.ChangeClipBounds;
+import androidx.transition.ChangeTransform;
+import androidx.transition.Fade;
+import androidx.transition.Transition;
+import androidx.transition.TransitionSet;
+
 import android.view.View;
 import android.view.ViewGroup;
 
-import com.bluelinelabs.conductor.changehandler.SharedElementTransitionChangeHandler;
+import com.bluelinelabs.conductor.changehandler.androidxtransition.SharedElementTransitionChangeHandler;
 import com.bluelinelabs.conductor.internal.TransitionUtils;
 
 import java.util.ArrayList;
 import java.util.Collections;
 
-@TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public class ArcFadeMoveChangeHandler extends SharedElementTransitionChangeHandler {
 
     private static final String KEY_SHARED_ELEMENT_NAMES = "ArcFadeMoveChangeHandler.sharedElementNames";
@@ -62,7 +59,7 @@ public class ArcFadeMoveChangeHandler extends SharedElementTransitionChangeHandl
         transition.setPathMotion(new ArcMotion());
 
         // The framework doesn't totally fade out the "from" shared element, so we'll hide it manually once it's safe.
-        transition.addListener(new TransitionListener() {
+        transition.addListener(new Transition.TransitionListener() {
             @Override
             public void onTransitionStart(Transition transition) {
                 if (from != null) {

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

@@ -1,16 +0,0 @@
-package com.bluelinelabs.conductor.demo.changehandler;
-
-import com.bluelinelabs.conductor.changehandler.FadeChangeHandler;
-import com.bluelinelabs.conductor.changehandler.TransitionChangeHandlerCompat;
-
-public class ArcFadeMoveChangeHandlerCompat extends TransitionChangeHandlerCompat {
-
-    public ArcFadeMoveChangeHandlerCompat() {
-        super();
-    }
-
-    public ArcFadeMoveChangeHandlerCompat(String... transitionNames) {
-        super(new ArcFadeMoveChangeHandler(transitionNames), new FadeChangeHandler());
-    }
-
-}

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

@@ -4,7 +4,7 @@ import android.animation.Animator;
 import android.annotation.TargetApi;
 import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.ViewAnimationUtils;
 import android.view.ViewGroup;

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

@@ -4,7 +4,7 @@ import android.animation.Animator;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
 import android.os.Build;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.ViewGroup;
 

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

@@ -1,27 +1,25 @@
 package com.bluelinelabs.conductor.demo.changehandler;
 
-import android.annotation.TargetApi;
-import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.transition.ChangeBounds;
-import android.transition.ChangeClipBounds;
-import android.transition.ChangeTransform;
-import android.transition.Explode;
-import android.transition.Slide;
-import android.transition.Transition;
-import android.transition.TransitionSet;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.transition.ChangeBounds;
+import androidx.transition.ChangeClipBounds;
+import androidx.transition.ChangeTransform;
+import androidx.transition.Explode;
+import androidx.transition.Slide;
+import androidx.transition.Transition;
+import androidx.transition.TransitionSet;
+
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
 
-import com.bluelinelabs.conductor.changehandler.SharedElementTransitionChangeHandler;
+import com.bluelinelabs.conductor.changehandler.androidxtransition.SharedElementTransitionChangeHandler;
 
 import java.util.ArrayList;
 import java.util.List;
 
-@TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public class CityGridSharedElementTransitionChangeHandler extends SharedElementTransitionChangeHandler {
 
     private static final String KEY_WAIT_FOR_TRANSITION_NAMES = "CityGridSharedElementTransitionChangeHandler.names";

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

@@ -1,22 +1,20 @@
 package com.bluelinelabs.conductor.demo.changehandler;
 
-import android.annotation.TargetApi;
-import android.os.Build;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v4.content.ContextCompat;
-import android.transition.Fade;
-import android.transition.Transition;
-import android.transition.TransitionSet;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
+import androidx.transition.Fade;
+import androidx.transition.Transition;
+import androidx.transition.TransitionSet;
+
 import android.view.View;
 import android.view.ViewGroup;
 
-import com.bluelinelabs.conductor.changehandler.TransitionChangeHandler;
+import com.bluelinelabs.conductor.changehandler.androidxtransition.TransitionChangeHandler;
 import com.bluelinelabs.conductor.demo.R;
 import com.bluelinelabs.conductor.demo.changehandler.transitions.FabTransform;
 import com.bluelinelabs.conductor.demo.util.AnimUtils;
 
-@TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public class FabToDialogTransitionChangeHandler extends TransitionChangeHandler {
 
     private View fab;

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

@@ -3,7 +3,7 @@ package com.bluelinelabs.conductor.demo.changehandler;
 import android.animation.Animator;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.util.Property;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -3,7 +3,7 @@ package com.bluelinelabs.conductor.demo.changehandler;
 import android.animation.Animator;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.View;
 import android.view.ViewGroup;
 

demo/src/main/java/com/bluelinelabs/conductor/demo/changehandler/transitions/FabTransform.java

@@ -23,19 +23,18 @@ import android.animation.Animator;
 import android.animation.AnimatorListenerAdapter;
 import android.animation.AnimatorSet;
 import android.animation.ObjectAnimator;
-import android.annotation.TargetApi;
 import android.graphics.Bitmap;
 import android.graphics.Outline;
 import android.graphics.Rect;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
-import android.os.Build;
-import android.support.annotation.ColorInt;
-import android.support.annotation.DrawableRes;
-import android.support.v4.content.ContextCompat;
-import android.transition.Transition;
-import android.transition.TransitionValues;
+import androidx.annotation.ColorInt;
+import androidx.annotation.DrawableRes;
+import androidx.core.content.ContextCompat;
+import androidx.transition.Transition;
+import androidx.transition.TransitionValues;
+
 import android.view.View;
 import android.view.ViewAnimationUtils;
 import android.view.ViewGroup;
@@ -55,7 +54,6 @@ import static android.view.View.MeasureSpec.makeMeasureSpec;
  * <p>
  * See: https://www.google.com/design/spec/motion/transforming-material.html#transforming-material-radial-transformation
  */
-@TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public class FabTransform extends Transition {
 
     private static final long DEFAULT_DURATION = 240L;

demo/src/main/java/com/bluelinelabs/conductor/demo/changehandler/transitions/GravityArcMotion.java

@@ -16,13 +16,12 @@
 
 package com.bluelinelabs.conductor.demo.changehandler.transitions;
 
-import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.Path;
-import android.os.Build;
-import android.transition.ArcMotion;
 import android.util.AttributeSet;
 
+import androidx.transition.ArcMotion;
+
 /**
  * A tweak to {@link ArcMotion} which slightly alters the path calculation. In the real world
  * gravity slows upward motion and accelerates downward motion. This class emulates this behavior
@@ -30,7 +29,6 @@ import android.util.AttributeSet;
  * <p>
  * See https://www.google.com/design/spec/motion/movement.html#movement-movement-within-screen-bounds
  */
-@TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public class GravityArcMotion extends ArcMotion {
 
     private static final float DEFAULT_MIN_ANGLE_DEGREES = 0;

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

@@ -1,12 +1,12 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
-import android.arch.lifecycle.Lifecycle.Event;
-import android.arch.lifecycle.LifecycleObserver;
-import android.arch.lifecycle.LifecycleOwner;
-import android.arch.lifecycle.OnLifecycleEvent;
+import androidx.lifecycle.Lifecycle.Event;
+import androidx.lifecycle.LifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.OnLifecycleEvent;
 import android.content.Context;
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -17,8 +17,8 @@ import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler;
 import com.bluelinelabs.conductor.demo.ActionBarProvider;
 import com.bluelinelabs.conductor.demo.DemoApplication;
 import com.bluelinelabs.conductor.demo.R;
-import com.uber.autodispose.LifecycleScopeProvider;
-import com.uber.autodispose.ObservableScoper;
+import com.uber.autodispose.AutoDispose;
+import com.uber.autodispose.lifecycle.LifecycleScopeProvider;
 
 import java.util.concurrent.TimeUnit;
 
@@ -50,7 +50,7 @@ public class AutodisposeController extends Controller {
                         Log.i(TAG, "Disposing from constructor");
                     }
                 })
-                .to(new ObservableScoper<Long>(scopeProvider))
+                .as(AutoDispose.<Long>autoDisposable((scopeProvider)))
                 .subscribe(new Consumer<Long>() {
                     @Override
                     public void accept(Long num) {
@@ -77,7 +77,7 @@ public class AutodisposeController extends Controller {
                         Log.i(TAG, "Disposing from onCreateView()");
                     }
                 })
-                .to(new ObservableScoper<Long>(scopeProvider))
+                .as(AutoDispose.<Long>autoDisposable((scopeProvider)))
                 .subscribe(new Consumer<Long>() {
                     @Override
                     public void accept(Long num) {
@@ -103,7 +103,7 @@ public class AutodisposeController extends Controller {
                         Log.i(TAG, "Disposing from onAttach()");
                     }
                 })
-                .to(new ObservableScoper<Long>(scopeProvider))
+                .as(AutoDispose.<Long>autoDisposable((scopeProvider)))
                 .subscribe(new Consumer<Long>() {
                     @Override
                     public void accept(Long num) {

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -1,11 +1,11 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
 import android.os.Bundle;
-import android.support.annotation.DrawableRes;
-import android.support.annotation.NonNull;
-import android.support.v4.view.ViewCompat;
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
+import androidx.annotation.DrawableRes;
+import androidx.annotation.NonNull;
+import androidx.core.view.ViewCompat;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -28,7 +28,7 @@ public class CityDetailController extends BaseController {
             "• This is a city.",
             "• There's some cool stuff about it.",
             "• But really this is just a demo, not a city guide app.",
-            "• This demo is meant to show some nice transitions, as long as you're on Lollipop or later.",
+            "• This demo is meant to show some nice transitions.",
             "• You should have seen some sweet shared element transitions using the ImageView and the TextView in the \"header\" above.",
             "• This transition utilized some callbacks to ensure all the necessary rows in the RecyclerView were laid about before the transition occurred.",
             "• Just adding some more lines so it scrolls now...\n\n\n\n\n\n\nThe end."

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

@@ -2,12 +2,12 @@ package com.bluelinelabs.conductor.demo.controllers;
 
 import android.graphics.PorterDuff.Mode;
 import android.os.Bundle;
-import android.support.annotation.DrawableRes;
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
-import android.support.v4.view.ViewCompat;
-import android.support.v7.widget.GridLayoutManager;
-import android.support.v7.widget.RecyclerView;
+import androidx.annotation.DrawableRes;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+import androidx.core.view.ViewCompat;
+import androidx.recyclerview.widget.GridLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -15,8 +15,6 @@ import android.widget.ImageView;
 import android.widget.TextView;
 
 import com.bluelinelabs.conductor.RouterTransaction;
-import com.bluelinelabs.conductor.changehandler.FadeChangeHandler;
-import com.bluelinelabs.conductor.changehandler.TransitionChangeHandlerCompat;
 import com.bluelinelabs.conductor.demo.R;
 import com.bluelinelabs.conductor.demo.changehandler.CityGridSharedElementTransitionChangeHandler;
 import com.bluelinelabs.conductor.demo.controllers.base.BaseController;
@@ -101,8 +99,8 @@ public class CityGridController extends BaseController {
         names.add(titleTransitionName);
 
         getRouter().pushController(RouterTransaction.with(new CityDetailController(model.drawableRes, model.title))
-                .pushChangeHandler(new TransitionChangeHandlerCompat(new CityGridSharedElementTransitionChangeHandler(names), new FadeChangeHandler()))
-                .popChangeHandler(new TransitionChangeHandlerCompat(new CityGridSharedElementTransitionChangeHandler(names), new FadeChangeHandler())));
+                .pushChangeHandler(new CityGridSharedElementTransitionChangeHandler(names))
+                .popChangeHandler(new CityGridSharedElementTransitionChangeHandler(names)));
     }
 
     class CityGridAdapter extends RecyclerView.Adapter<CityGridAdapter.ViewHolder> {

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

@@ -2,7 +2,7 @@ package com.bluelinelabs.conductor.demo.controllers;
 
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.text.method.LinkMovementMethod;
 import android.view.LayoutInflater;
 import android.view.View;

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

@@ -2,7 +2,7 @@ package com.bluelinelabs.conductor.demo.controllers;
 
 import android.annotation.TargetApi;
 import android.os.Build.VERSION_CODES;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -1,11 +1,11 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
 import android.graphics.PorterDuff.Mode;
-import android.support.annotation.ColorRes;
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
+import androidx.annotation.ColorRes;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -4,12 +4,12 @@ import android.content.Intent;
 import android.graphics.PorterDuff.Mode;
 import android.net.Uri;
 import android.os.Bundle;
-import android.support.annotation.ColorRes;
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
-import android.support.v4.view.ViewCompat;
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
+import androidx.annotation.ColorRes;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+import androidx.core.view.ViewCompat;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
 import android.text.SpannableString;
 import android.text.SpannableStringBuilder;
 import android.text.Spanned;
@@ -29,9 +29,8 @@ import com.bluelinelabs.conductor.ControllerChangeType;
 import com.bluelinelabs.conductor.RouterTransaction;
 import com.bluelinelabs.conductor.changehandler.FadeChangeHandler;
 import com.bluelinelabs.conductor.changehandler.HorizontalChangeHandler;
-import com.bluelinelabs.conductor.changehandler.TransitionChangeHandlerCompat;
 import com.bluelinelabs.conductor.demo.R;
-import com.bluelinelabs.conductor.demo.changehandler.ArcFadeMoveChangeHandlerCompat;
+import com.bluelinelabs.conductor.demo.changehandler.ArcFadeMoveChangeHandler;
 import com.bluelinelabs.conductor.demo.changehandler.FabToDialogTransitionChangeHandler;
 import com.bluelinelabs.conductor.demo.controllers.NavigationDemoController.DisplayUpMode;
 import com.bluelinelabs.conductor.demo.controllers.base.BaseController;
@@ -153,8 +152,8 @@ public class HomeController extends BaseController {
         description.append("\n\n");
         description.append(link);
 
-        ControllerChangeHandler pushHandler = fromFab ? new TransitionChangeHandlerCompat(new FabToDialogTransitionChangeHandler(), new FadeChangeHandler(false)) : new FadeChangeHandler(false);
-        ControllerChangeHandler popHandler = fromFab ? new TransitionChangeHandlerCompat(new FabToDialogTransitionChangeHandler(), new FadeChangeHandler()) : new FadeChangeHandler();
+        ControllerChangeHandler pushHandler = fromFab ? new FabToDialogTransitionChangeHandler() : new FadeChangeHandler(false);
+        ControllerChangeHandler popHandler = fromFab ? new FabToDialogTransitionChangeHandler() : new FadeChangeHandler();
 
         getRouter()
                 .pushController(RouterTransaction.with(new DialogController("Conductor", description))
@@ -196,8 +195,8 @@ public class HomeController extends BaseController {
                 String dotSharedElementName = getResources().getString(R.string.transition_tag_dot_indexed, position);
 
                 getRouter().pushController(RouterTransaction.with(new CityGridController(model.title, model.color, position))
-                        .pushChangeHandler(new ArcFadeMoveChangeHandlerCompat(titleSharedElementName, dotSharedElementName))
-                        .popChangeHandler(new ArcFadeMoveChangeHandlerCompat(titleSharedElementName, dotSharedElementName)));
+                        .pushChangeHandler(new ArcFadeMoveChangeHandler(titleSharedElementName, dotSharedElementName))
+                        .popChangeHandler(new ArcFadeMoveChangeHandler(titleSharedElementName, dotSharedElementName)));
                 break;
             case DRAG_DISMISS:
                 getRouter().pushController(RouterTransaction.with(new DragDismissController())

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

@@ -1,11 +1,11 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.v4.content.ContextCompat;
-import android.support.v7.widget.LinearLayoutManager;
-import android.support.v7.widget.RecyclerView;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.ContextCompat;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -1,6 +1,6 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
 import android.os.Bundle;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -1,8 +1,8 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
-import android.support.annotation.NonNull;
-import android.support.design.widget.TabLayout;
-import android.support.v4.view.ViewPager;
+import androidx.annotation.NonNull;
+import com.google.android.material.tabs.TabLayout;
+import androidx.viewpager.widget.ViewPager;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
-import android.support.annotation.IdRes;
-import android.support.annotation.NonNull;
+import androidx.annotation.IdRes;
+import androidx.annotation.NonNull;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
-import android.support.annotation.NonNull;
-import android.support.v4.content.ContextCompat;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;

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

@@ -5,7 +5,7 @@ import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
 import android.provider.MediaStore;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.text.TextUtils;
 import android.view.LayoutInflater;
 import android.view.View;

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

@@ -1,7 +1,7 @@
 package com.bluelinelabs.conductor.demo.controllers;
 
 import android.content.Context;
-import android.support.annotation.NonNull;
+import androidx.annotation.NonNull;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;