ViewAnimator — это View, который наследуется от FrameLayout и у которого в конкретный момент времени виден только один из его child. Для переключения видимого child есть набор методов.

public class ViewAnimator extends FrameLayout {

    private int lastWhichIndex = 0;

    public ViewAnimator(Context context) {
        super(context);
    }

    public ViewAnimator(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public void setDisplayedChildIndex(int inChildIndex) {
        if (inChildIndex >= getChildCount()) {
            inChildIndex = 0;
        } else if (inChildIndex < 0) {
            inChildIndex = getChildCount() - 1;
        }
        boolean hasFocus = getFocusedChild() != null;
        int outChildIndex = lastWhichIndex;
        lastWhichIndex = inChildIndex;
        changeVisibility(getChildAt(inChildIndex), getChildAt(outChildIndex));
        if (hasFocus) {
            requestFocus(FOCUS_FORWARD);
        }
    }

    public void setDisplayedChildId(@IdRes int id) {
        if (getDisplayedChildId() == id) {
            return;
        }
        for (int i = 0, count = getChildCount(); i < count; i++) {
            if (getChildAt(i).getId() == id) {
                setDisplayedChildIndex(i);
                return;
            }
        }
        throw new IllegalArgumentException("No view with ID " + id);
    }

    public void setDisplayedChild(View view) {
        setDisplayedChildId(view.getId());
    }

    public int getDisplayedChildIndex() {
        return lastWhichIndex;
    }

    public View getDisplayedChild() {
        return getChildAt(lastWhichIndex);
    }

    public int getDisplayedChildId() {
        return getDisplayedChild().getId();
    }

    protected void changeVisibility(View inChild, View outChild) {
        outChild.setVisibility(INVISIBLE);
        inChild.setVisibility(VISIBLE);
    }

    @Override
    public void addView(View child, int index, ViewGroup.LayoutParams params) {
        super.addView(child, index, params);
        if (getChildCount() == 1) {
            child.setVisibility(View.VISIBLE);
        } else {
            child.setVisibility(View.INVISIBLE);
        }
        if (index >= 0 && lastWhichIndex >= index) {
            setDisplayedChildIndex(lastWhichIndex + 1);
        }
    }

    @Override
    public void removeAllViews() {
        super.removeAllViews();
        lastWhichIndex = 0;
    }

    @Override
    public void removeView(View view) {
        final int index = indexOfChild(view);
        if (index >= 0) {
            removeViewAt(index);
        }
    }

    @Override
    public void removeViewAt(int index) {
        super.removeViewAt(index);
        final int childCount = getChildCount();
        if (childCount == 0) {
            lastWhichIndex = 0;
        } else if (lastWhichIndex >= childCount) {
            setDisplayedChildIndex(childCount - 1);
        } else if (lastWhichIndex == index) {
            setDisplayedChildIndex(lastWhichIndex);
        }
    }

    @Override
    public void removeViewInLayout(View view) {
        removeView(view);
    }

    @Override
    public void removeViews(int start, int count) {
        super.removeViews(start, count);
        if (getChildCount() == 0) {
            lastWhichIndex = 0;
        } else if (lastWhichIndex >= start && lastWhichIndex < start + count) {
            setDisplayedChildIndex(lastWhichIndex);
        }
    }

    @Override
    public void removeViewsInLayout(int start, int count) {
        removeViews(start, count);
    }

    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        if (!(state instanceof SavedState)) {
            super.onRestoreInstanceState(state);
            return;
        }
        SavedState ss = (SavedState) state;
        super.onRestoreInstanceState(ss.getSuperState());
        lastWhichIndex = ss.lastWhichIndex;
        setDisplayedChildIndex(lastWhichIndex);
    }

    @Override
    protected Parcelable onSaveInstanceState() {
        SavedState savedState = new SavedState(super.onSaveInstanceState());
        savedState.lastWhichIndex = lastWhichIndex;
        return savedState;
    }

    public static class SavedState extends View.BaseSavedState {
        int lastWhichIndex;

        SavedState(Parcelable superState) {
            super(superState);
        }

        @Override
        public void writeToParcel(Parcel dest, int flags) {
            super.writeToParcel(dest, flags);
            dest.writeInt(this.lastWhichIndex);
        }

        @Override
        public String toString() {
            return "ViewAnimator.SavedState{" +
                    "lastWhichIndex=" + lastWhichIndex +
                    '}';
        }

        public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
            @Override
            public SavedState createFromParcel(Parcel source) {
                return new SavedState(source);
            }

            @Override
            public SavedState[] newArray(int size) {
                return new SavedState[size];
            }
        };

        protected SavedState(Parcel in) {
            super(in);
            this.lastWhichIndex = in.readInt();
        }
    }
}

public interface CannyTransition {
    Transition getTransition(View inChild, View outChild);
}

public class TransitionViewAnimator extends ViewAnimator {
    private CannyTransition cannyTransition;
    private Transition transition;

    public TransitionViewAnimator(Context context) {
        super(context);
    }

    public TransitionViewAnimator(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    protected void changeVisibility(View inChild, View outChild) {
        prepareTransition(inChild, outChild);
        startTransition();
        super.changeVisibility(inChild, outChild);
    }

    protected void prepareTransition(View inChild, View outChild) {
        if (cannyTransition != null) {
            transition = cannyTransition.getTransition(inChild, outChild);
        }
    }

    public void startTransition() {
        if (transition != null) {
            TransitionManager.beginDelayedTransition(this, transition);
        }
    }

    public void setCannyTransition(CannyTransition cannyTransition) {
        this.cannyTransition = cannyTransition;
    }
}

public interface InAnimator {
    Animator getInAnimator(View inChild, View outChild);
}

public interface OutAnimator {
    Animator getOutAnimator(View inChild, View outChild);
}

public class CannyViewAnimator extends TransitionViewAnimator {

    public static final int SEQUENTIALLY = 1;
    public static final int TOGETHER = 2;
    private int animateType = SEQUENTIALLY;

    @Retention(RetentionPolicy.SOURCE)
    @IntDef({SEQUENTIALLY, TOGETHER})
    @interface AnimateType {
    }

    public static final int FOR_POSITION = 1;
    public static final int IN_ALWAYS_TOP = 2;
    public static final int OUT_ALWAYS_TOP = 3;
    private int locationType = FOR_POSITION;

    @Retention(RetentionPolicy.SOURCE)
    @IntDef({FOR_POSITION, IN_ALWAYS_TOP, OUT_ALWAYS_TOP})
    @interface LocationType {
    }

    private List<? extends InAnimator> inAnimator;
    private List<? extends OutAnimator> outAnimator;
    private final Map<View, Boolean> attachedList = new HashMap<>(getChildCount());

    public CannyViewAnimator(Context context) {
        super(context);
    }

    public CannyViewAnimator(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @SafeVarargs
    public final <T extends InAnimator> void setInAnimator(T... inAnimators) {
        setInAnimator(Arrays.asList(inAnimators));
    }

    public void setInAnimator(List<? extends InAnimator> inAnimators) {
        this.inAnimator = inAnimators;
    }

    @SafeVarargs
    public final <T extends OutAnimator> void setOutAnimator(T... outAnimators) {
        setOutAnimator(Arrays.asList(outAnimators));
    }

    public void setOutAnimator(List<? extends OutAnimator> outAnimators) {
        this.outAnimator = outAnimators;
    }

    @Override
    protected void changeVisibility(View inChild, View outChild) {
        if (attachedList.get(outChild) && attachedList.get(inChild)) {
            AnimatorSet animatorSet = new AnimatorSet();
            Animator inAnimator = mergeInAnimators(inChild, outChild);
            Animator outAnimator = mergeOutAnimators(inChild, outChild);
            prepareTransition(inChild, outChild);

            switch (animateType) {
                case SEQUENTIALLY:
                    animatorSet.playSequentially(outAnimator, inAnimator);
                    break;
                case TOGETHER:
                    animatorSet.playTogether(outAnimator, inAnimator);
                    break;
            }

            switch (locationType) {
                case FOR_POSITION:
                    addOnStartVisibleListener(inAnimator, inChild);
                    addOnEndInvisibleListener(outAnimator, outChild);
                    break;
                case IN_ALWAYS_TOP:
                    addOnStartVisibleListener(inAnimator, inChild);
                    addOnEndInvisibleListener(inAnimator, outChild);
                    addOnStartToTopOnEndToInitPositionListener(inAnimator, inChild);
                    break;
                case OUT_ALWAYS_TOP:
                    addOnStartVisibleListener(outAnimator, inChild);
                    addOnEndInvisibleListener(outAnimator, outChild);
                    addOnStartToTopOnEndToInitPositionListener(outAnimator, outChild);
                    break;
            }
            animatorSet.start();
        } else {
            super.changeVisibility(inChild, outChild);
        }
    }

    private AnimatorSet mergeInAnimators(final View inChild, final View outChild) {
        AnimatorSet animatorSet = new AnimatorSet();
        List<Animator> animators = new ArrayList<>(inAnimator.size());
        for (InAnimator inAnimator : this.inAnimator) {
            if (inAnimator != null) {
                Animator animator = inAnimator.getInAnimator(inChild, outChild);
                if (animator != null) {
                    animators.add(animator);
                }
            }
        }
        animatorSet.playTogether(animators);
        return animatorSet;
    }

    private AnimatorSet mergeOutAnimators(final View inChild, final View outChild) {
        AnimatorSet animatorSet = new AnimatorSet();
        List<Animator> animators = new ArrayList<>(outAnimator.size());
        for (OutAnimator outAnimator : this.outAnimator) {
            if (outAnimator != null) {
                Animator animator = outAnimator.getOutAnimator(inChild, outChild);
                if (animator != null)
                    animators.add(animator);
            }
        }
        animatorSet.playTogether(animators);
        addRestoreInitValuesListener(animatorSet);
        return animatorSet;
    }

    private void addRestoreInitValuesListener(AnimatorSet animatorSet) {
        for (Animator animator : animatorSet.getChildAnimations()) {
            if (animator instanceof ValueAnimator) {
                animator.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        animation.removeListener(this);
                        animation.setDuration(0);
                        ((ValueAnimator) animation).reverse();
                    }
                });
            }
        }
    }

    private void addOnStartVisibleListener(Animator animator, final View view) {
        animator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationStart(Animator animation) {
                startTransition();
                view.setVisibility(VISIBLE);
            }
        });
    }

    private void addOnEndInvisibleListener(Animator animator, final View view) {
        animator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                startTransition();
                view.setVisibility(INVISIBLE);
            }
        });
    }

    private void addOnStartToTopOnEndToInitPositionListener(Animator animator, final View view) {
        final int initLocation = indexOfChild(view);
        animator.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationStart(Animator animation) {
                bringChildToPosition(view, getChildCount() - 1);
            }

            @Override
            public void onAnimationEnd(Animator animation) {
                bringChildToPosition(view, initLocation);
            }
        });
    }

    public int getAnimateType() {
        return animateType;
    }

    public void setAnimateType(@AnimateType int animateType) {
        this.animateType = animateType;
    }

    public int getLocationType() {
        return locationType;
    }

    public void setLocationType(@LocationType int locationType) {
        this.locationType = locationType;
    }

    @Override
    public void addView(View child, int index, ViewGroup.LayoutParams params) {
        attachedList.put(child, false);
        child.addOnAttachStateChangeListener(new OnAttachStateChangeListener() {
            @Override
            public void onViewAttachedToWindow(View v) {
                attachedList.put(v, true);
            }

            @Override
            public void onViewDetachedFromWindow(View v) {
                attachedList.put(v, false);
            }
        });
        super.addView(child, index, params);
    }

    @Override
    public void removeAllViews() {
        attachedList.clear();
        super.removeAllViews();
    }

    @Override
    public void removeView(View view) {
        attachedList.remove(view);
        super.removeView(view);
    }

    @Override
    public void removeViewAt(int index) {
        attachedList.remove(getChildAt(index));
        super.removeViewAt(index);
    }

    @Override
    public void removeViews(int start, int count) {
        for (int i = start; i < start + count; i++) {
            attachedList.remove(getChildAt(i));
        }
        super.removeViews(start, count);
    }
}

class PropertyCanny {
    Animator propertyAnimator;

    public PropertyCanny(PropertyValuesHolder... holders) {
        this.propertyAnimator = ObjectAnimator.ofPropertyValuesHolder(holders);
    }

    public PropertyCanny(Property<?, Float> property, float start, float end) {
        this.propertyAnimator = ObjectAnimator.ofFloat(null, property, start, end);
    }

    public PropertyCanny(String propertyName, float start, float end) {
        this.propertyAnimator = ObjectAnimator.ofFloat(null, propertyName, start, end);
    }

    public Animator getPropertyAnimator(View child) {
        propertyAnimator.setTarget(child);
        return propertyAnimator.clone();
    }
}

public class PropertyIn extends PropertyCanny implements InAnimator {

    public PropertyIn(PropertyValuesHolder... holders) {
        super(holders);
    }

    public PropertyIn(Property<?, Float> property, float start, float end) {
        super(property, start, end);
    }

    public PropertyIn(String propertyName, float start, float end) {
        super(propertyName, start, end);
    }

    public PropertyIn setDuration(long millis) {
        propertyAnimator.setDuration(millis);
        return this;
    }

    @Override
    public Animator getInAnimator(View inChild, View outChild) {
        return getPropertyAnimator(inChild);
    }
}

public class PropertyOut extends PropertyCanny implements OutAnimator {

    public PropertyOut(PropertyValuesHolder... holders) {
        super(holders);
    }

    public PropertyOut(Property<?, Float> property, float start, float end) {
        super(property, start, end);
    }

    public PropertyOut(String propertyName, float start, float end) {
        super(propertyName, start, end);
    }

    public PropertyOut setDuration(long millis) {
        propertyAnimator.setDuration(millis);
        return this;
    }

    @Override
    public Animator getOutAnimator(View inChild, View outChild) {
        return getPropertyAnimator(outChild);
    }

}

class RevealCanny {
    private final int gravity;

    public RevealCanny(int gravity) {
        this.gravity = gravity;
    }

    @SuppressLint("RtlHardcoded")
    protected int getCenterX(View view) {
        final int horizontalGravity = gravity & Gravity.HORIZONTAL_GRAVITY_MASK;
        if (horizontalGravity == Gravity.LEFT) {
            return 0;
        } else if (horizontalGravity == Gravity.RIGHT) {
            return view.getWidth();
        } else { // (Gravity.CENTER_HORIZONTAL)
            return view.getWidth() / 2;
        }
    }

    protected int getCenterY(View view) {
        final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
        if (verticalGravity == Gravity.TOP) {
            return 0;
        } else if (verticalGravity == Gravity.BOTTOM) {
            return view.getHeight();
        } else { // (Gravity.CENTER_VERTICAL)
            return view.getHeight() / 2;
        }
    }

    public int getGravity() {
        return gravity;
    }
}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class RevealIn extends RevealCanny implements InAnimator {

    public RevealIn(int gravity) {
        super(gravity);
    }

    @Override
    public Animator getInAnimator(View inChild, View outChild) {
        float inRadius = (float) Math.hypot(inChild.getWidth(), inChild.getHeight());
        return ViewAnimationUtils.createCircularReveal(inChild, getCenterX(inChild),
                getCenterY(inChild), 0, inRadius);
    }

}

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class RevealOut extends RevealCanny implements OutAnimator {

    public RevealOut(int gravity) {
        super(gravity);
    }

    @Override
    public Animator getOutAnimator(View inChild, View outChild) {
        float outRadius = (float) Math.hypot(outChild.getWidth(), outChild.getHeight());
        return ViewAnimationUtils.createCircularReveal(outChild, getCenterX(outChild),
                getCenterY(outChild), outRadius, 0);
    }

}