diff --git a/api/26.0.0-SNAPSHOT.txt b/api/26.0.0-SNAPSHOT.txt
index 084689f..4e217ed 100644
--- a/api/26.0.0-SNAPSHOT.txt
+++ b/api/26.0.0-SNAPSHOT.txt
@@ -1431,6 +1431,7 @@
     method public static boolean isChannelUriForPassthroughInput(android.net.Uri);
     method public static boolean isChannelUriForTunerInput(android.net.Uri);
     method public static boolean isProgramUri(android.net.Uri);
+    method public static boolean isRecordedProgramUri(android.net.Uri);
     method public static void requestChannelBrowsable(android.content.Context, long);
     field public static final java.lang.String ACTION_INITIALIZE_PROGRAMS = "android.media.tv.action.INITIALIZE_PROGRAMS";
     field public static final java.lang.String ACTION_PREVIEW_PROGRAM_ADDED_TO_WATCH_NEXT = "android.media.tv.action.PREVIEW_PROGRAM_ADDED_TO_WATCH_NEXT";
@@ -9604,6 +9605,42 @@
     field public static final float RELATIVE_UNSPECIFIED = 0.0f;
   }
 
+  public class CircularProgressDrawable extends android.graphics.drawable.Drawable {
+    ctor public CircularProgressDrawable(android.content.Context);
+    method public void draw(android.graphics.Canvas);
+    method public boolean getArrowEnabled();
+    method public float getArrowHeight();
+    method public float getArrowScale();
+    method public float getArrowWidth();
+    method public int getBackgroundColor();
+    method public float getCenterRadius();
+    method public int[] getColorSchemeColors();
+    method public float getEndTrim();
+    method public int getOpacity();
+    method public float getProgressRotation();
+    method public float getStartTrim();
+    method public android.graphics.Paint.Cap getStrokeCap();
+    method public float getStrokeWidth();
+    method public boolean isRunning();
+    method public void setAlpha(int);
+    method public void setArrowDimensions(float, float);
+    method public void setArrowEnabled(boolean);
+    method public void setArrowScale(float);
+    method public void setBackgroundColor(int);
+    method public void setCenterRadius(float);
+    method public void setColorFilter(android.graphics.ColorFilter);
+    method public void setColorSchemeColors(int...);
+    method public void setProgressRotation(float);
+    method public void setStartEndTrim(float, float);
+    method public void setStrokeCap(android.graphics.Paint.Cap);
+    method public void setStrokeWidth(float);
+    method public void setStyle(int);
+    method public void start();
+    method public void stop();
+    field public static final int DEFAULT = 1; // 0x1
+    field public static final int LARGE = 0; // 0x0
+  }
+
   public final class CompoundButtonCompat {
     method public static android.graphics.drawable.Drawable getButtonDrawable(android.widget.CompoundButton);
     method public static android.content.res.ColorStateList getButtonTintList(android.widget.CompoundButton);
diff --git a/buildSrc/dependencies.gradle b/buildSrc/dependencies.gradle
index 91315c1..5cf3ae6 100644
--- a/buildSrc/dependencies.gradle
+++ b/buildSrc/dependencies.gradle
@@ -17,9 +17,9 @@
 def libs = [:]
 
 // Testing dependencies
-libs.mockito_core = 'org.mockito:mockito-core:1.9.5'
-libs.dexmaker = 'com.google.dexmaker:dexmaker:1.2'
-libs.dexmaker_mockito = 'com.google.dexmaker:dexmaker-mockito:1.2'
+libs.mockito_core = 'org.mockito:mockito-core:2.7.6'
+libs.dexmaker_mockito = 'com.linkedin.dexmaker:dexmaker-mockito:2.2.0'
+libs.multidex = 'com.android.support:multidex:1.0.1'
 libs.junit = 'junit:junit:4.12'
 libs.test_runner = 'com.android.support.test:runner:0.6-alpha'
 libs.espresso_core = 'com.android.support.test.espresso:espresso-core:2.3-alpha'
diff --git a/compat/build.gradle b/compat/build.gradle
index fc61134..7724a29 100644
--- a/compat/build.gradle
+++ b/compat/build.gradle
@@ -11,7 +11,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
     androidTestCompile project(':support-testutils')
 }
diff --git a/compat/java/android/support/v4/provider/FontsContractCompat.java b/compat/java/android/support/v4/provider/FontsContractCompat.java
index afa565c..8f7719a 100644
--- a/compat/java/android/support/v4/provider/FontsContractCompat.java
+++ b/compat/java/android/support/v4/provider/FontsContractCompat.java
@@ -54,6 +54,7 @@
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -196,7 +197,8 @@
     /** @hide */
     @RestrictTo(LIBRARY_GROUP)
     public static Typeface getFontSync(final Context context, final FontRequest request,
-            final TextView targetView, @FetchStrategy int strategy, int timeout, final int style) {
+            final @Nullable TextView targetView, @FetchStrategy int strategy, int timeout,
+            final int style) {
         final String id = request.getIdentifier() + "-" + style;
         Typeface cached = sTypefaceCache.get(id);
         if (cached != null) {
@@ -229,10 +231,14 @@
                 return null;
             }
         } else {
+            final WeakReference<TextView> textViewWeak = new WeakReference<TextView>(targetView);
             final ReplyCallback<Typeface> reply = new ReplyCallback<Typeface>() {
                 @Override
                 public void onReply(final Typeface typeface) {
-                    targetView.setTypeface(typeface, style);
+                    final TextView textView = textViewWeak.get();
+                    if (textView != null) {
+                        targetView.setTypeface(typeface, style);
+                    }
                 }
             };
 
diff --git a/core-ui/build.gradle b/core-ui/build.gradle
index 86fa71a..2126921 100644
--- a/core-ui/build.gradle
+++ b/core-ui/build.gradle
@@ -12,7 +12,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
     androidTestCompile project(':support-testutils')
 }
diff --git a/core-ui/java/android/support/v4/widget/CircularProgressDrawable.java b/core-ui/java/android/support/v4/widget/CircularProgressDrawable.java
new file mode 100644
index 0000000..34b1874
--- /dev/null
+++ b/core-ui/java/android/support/v4/widget/CircularProgressDrawable.java
@@ -0,0 +1,943 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.support.v4.widget;
+
+import static android.support.annotation.RestrictTo.Scope.LIBRARY_GROUP;
+
+import android.animation.Animator;
+import android.animation.ValueAnimator;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.Paint.Style;
+import android.graphics.Path;
+import android.graphics.PixelFormat;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.graphics.drawable.Animatable;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.IntDef;
+import android.support.annotation.NonNull;
+import android.support.annotation.RestrictTo;
+import android.support.v4.util.Preconditions;
+import android.support.v4.view.animation.FastOutSlowInInterpolator;
+import android.util.DisplayMetrics;
+import android.view.animation.Interpolator;
+import android.view.animation.LinearInterpolator;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Drawable that renders the animated indeterminate progress indicator in the Material design style
+ * without depending on API level 11.
+ *
+ * <p>While this may be used to draw an indeterminate spinner using {@link #start()} and {@link
+ * #stop()} methods, this may also be used to draw a progress arc using {@link
+ * #setStartEndTrim(float, float)} method. CircularProgressDrawable also supports adding an arrow
+ * at the end of the arc by {@link #setArrowEnabled(boolean)} and {@link #setArrowDimensions(float,
+ * float)} methods.
+ *
+ * <p>To use one of the pre-defined sizes instead of using your own, {@link #setStyle(int)} should
+ * be called with one of the {@link #DEFAULT} or {@link #LARGE} styles as its parameter. Doing it
+ * so will update the arrow dimensions, ring size and stroke width to fit the one specified.
+ *
+ * <p>If no center radius is set via {@link #setCenterRadius(float)} or {@link #setStyle(int)}
+ * methods, CircularProgressDrawable will fill the bounds set via {@link #setBounds(Rect)}.
+ */
+public class CircularProgressDrawable extends Drawable implements Animatable {
+    private static final Interpolator LINEAR_INTERPOLATOR = new LinearInterpolator();
+    private static final Interpolator MATERIAL_INTERPOLATOR = new FastOutSlowInInterpolator();
+
+    /** @hide */
+    @RestrictTo(LIBRARY_GROUP)
+    @Retention(RetentionPolicy.SOURCE)
+    @IntDef({LARGE, DEFAULT})
+    public @interface ProgressDrawableSize {
+    }
+
+    /** Maps to ProgressBar.Large style. */
+    public static final int LARGE = 0;
+
+    private static final float CENTER_RADIUS_LARGE = 11f;
+    private static final float STROKE_WIDTH_LARGE = 3f;
+    private static final int ARROW_WIDTH_LARGE = 12;
+    private static final int ARROW_HEIGHT_LARGE = 6;
+
+    /** Maps to ProgressBar default style. */
+    public static final int DEFAULT = 1;
+
+    private static final float CENTER_RADIUS = 7.5f;
+    private static final float STROKE_WIDTH = 2.5f;
+    private static final int ARROW_WIDTH = 10;
+    private static final int ARROW_HEIGHT = 5;
+
+    /**
+     * This is the default set of colors that's used in spinner. {@link
+     * #setColorSchemeColors(int...)} allows modifying colors.
+     */
+    private static final int[] COLORS = new int[]{
+            Color.BLACK
+    };
+
+    /**
+     * The value in the linear interpolator for animating the drawable at which
+     * the color transition should start
+     */
+    private static final float COLOR_CHANGE_OFFSET = 0.75f;
+    private static final float SHRINK_OFFSET = 0.5f;
+
+    /** The duration of a single progress spin in milliseconds. */
+    private static final int ANIMATION_DURATION = 1332;
+
+    /** Full rotation that's done for the animation duration in degrees. */
+    private static final float GROUP_FULL_ROTATION = 1080f / 5f;
+
+    /** The indicator ring, used to manage animation state. */
+    private final Ring mRing;
+
+    /** Canvas rotation in degrees. */
+    private float mRotation;
+
+    /** Maximum length of the progress arc during the animation. */
+    private static final float MAX_PROGRESS_ARC = .8f;
+    /** Minimum length of the progress arc during the animation. */
+    private static final float MIN_PROGRESS_ARC = .01f;
+
+    /** Rotation applied to ring during the animation, to complete it to a full circle. */
+    private static final float RING_ROTATION = 1f - (MAX_PROGRESS_ARC - MIN_PROGRESS_ARC);
+
+    private Resources mResources;
+    private Animator mAnimator;
+    private float mRotationCount;
+    private boolean mFinishing;
+
+    /**
+     * @param context application context
+     */
+    public CircularProgressDrawable(Context context) {
+        mResources = Preconditions.checkNotNull(context).getResources();
+
+        mRing = new Ring();
+        mRing.setColors(COLORS);
+
+        setStrokeWidth(STROKE_WIDTH);
+        setupAnimators();
+    }
+
+    /** Sets all parameters at once in dp. */
+    private void setSizeParameters(float centerRadius, float strokeWidth, float arrowWidth,
+            float arrowHeight) {
+        final Ring ring = mRing;
+        final DisplayMetrics metrics = mResources.getDisplayMetrics();
+        final float screenDensity = metrics.density;
+
+        ring.setStrokeWidth(strokeWidth * screenDensity);
+        ring.setCenterRadius(centerRadius * screenDensity);
+        ring.setColorIndex(0);
+        ring.setArrowDimensions(arrowWidth * screenDensity, arrowHeight * screenDensity);
+    }
+
+    /**
+     * Sets the overall size for the progress spinner. This updates the radius
+     * and stroke width of the ring, and arrow dimensions.
+     *
+     * @param size one of {@link #LARGE} or {@link #DEFAULT}
+     */
+    public void setStyle(@ProgressDrawableSize int size) {
+        if (size == LARGE) {
+            setSizeParameters(CENTER_RADIUS_LARGE, STROKE_WIDTH_LARGE, ARROW_WIDTH_LARGE,
+                    ARROW_HEIGHT_LARGE);
+        } else {
+            setSizeParameters(CENTER_RADIUS, STROKE_WIDTH, ARROW_WIDTH, ARROW_HEIGHT);
+        }
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the stroke width for the progress spinner in pixels.
+     *
+     * @return stroke width in pixels
+     */
+    public float getStrokeWidth() {
+        return mRing.getStrokeWidth();
+    }
+
+    /**
+     * Sets the stroke width for the progress spinner in pixels.
+     *
+     * @param strokeWidth stroke width in pixels
+     */
+    public void setStrokeWidth(float strokeWidth) {
+        mRing.setStrokeWidth(strokeWidth);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the center radius for the progress spinner in pixels.
+     *
+     * @return center radius in pixels
+     */
+    public float getCenterRadius() {
+        return mRing.getCenterRadius();
+    }
+
+    /**
+     * Sets the center radius for the progress spinner in pixels. If set to 0, this drawable will
+     * fill the bounds when drawn.
+     *
+     * @param centerRadius center radius in pixels
+     */
+    public void setCenterRadius(float centerRadius) {
+        mRing.setCenterRadius(centerRadius);
+        invalidateSelf();
+    }
+
+    /**
+     * Sets the stroke cap of the progress spinner. Default stroke cap is {@link Paint.Cap#SQUARE}.
+     *
+     * @param strokeCap stroke cap
+     */
+    public void setStrokeCap(Paint.Cap strokeCap) {
+        mRing.setStrokeCap(strokeCap);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the stroke cap of the progress spinner.
+     *
+     * @return stroke cap
+     */
+    public Paint.Cap getStrokeCap() {
+        return mRing.getStrokeCap();
+    }
+
+    /**
+     * Returns the arrow width in pixels.
+     *
+     * @return arrow width in pixels
+     */
+    public float getArrowWidth() {
+        return mRing.getArrowWidth();
+    }
+
+    /**
+     * Returns the arrow height in pixels.
+     *
+     * @return arrow height in pixels
+     */
+    public float getArrowHeight() {
+        return mRing.getArrowHeight();
+    }
+
+    /**
+     * Sets the dimensions of the arrow at the end of the spinner in pixels.
+     *
+     * @param width width of the baseline of the arrow in pixels
+     * @param height distance from tip of the arrow to its baseline in pixels
+     */
+    public void setArrowDimensions(float width, float height) {
+        mRing.setArrowDimensions(width, height);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns {@code true} if the arrow at the end of the spinner is shown.
+     *
+     * @return {@code true} if the arrow is shown, {@code false} otherwise.
+     */
+    public boolean getArrowEnabled() {
+        return mRing.getShowArrow();
+    }
+
+    /**
+     * Sets if the arrow at the end of the spinner should be shown.
+     *
+     * @param show {@code true} if the arrow should be drawn, {@code false} otherwise
+     */
+    public void setArrowEnabled(boolean show) {
+        mRing.setShowArrow(show);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the scale of the arrow at the end of the spinner.
+     *
+     * @return scale of the arrow
+     */
+    public float getArrowScale() {
+        return mRing.getArrowScale();
+    }
+
+    /**
+     * Sets the scale of the arrow at the end of the spinner.
+     *
+     * @param scale scaling that will be applied to the arrow's both width and height when drawing.
+     */
+    public void setArrowScale(float scale) {
+        mRing.setArrowScale(scale);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the start trim for the progress spinner arc
+     *
+     * @return start trim from [0..1]
+     */
+    public float getStartTrim() {
+        return mRing.getStartTrim();
+    }
+
+    /**
+     * Returns the end trim for the progress spinner arc
+     *
+     * @return end trim from [0..1]
+     */
+    public float getEndTrim() {
+        return mRing.getEndTrim();
+    }
+
+    /**
+     * Sets the start and end trim for the progress spinner arc. 0 corresponds to the geometric
+     * angle of 0 degrees (3 o'clock on a watch) and it increases clockwise, coming to a full circle
+     * at 1.
+     *
+     * @param start starting position of the arc from [0..1]
+     * @param end ending position of the arc from [0..1]
+     */
+    public void setStartEndTrim(float start, float end) {
+        mRing.setStartTrim(start);
+        mRing.setEndTrim(end);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the amount of rotation applied to the progress spinner.
+     *
+     * @return amount of rotation from [0..1]
+     */
+    public float getProgressRotation() {
+        return mRing.getRotation();
+    }
+
+    /**
+     * Sets the amount of rotation to apply to the progress spinner.
+     *
+     * @param rotation rotation from [0..1]
+     */
+    public void setProgressRotation(float rotation) {
+        mRing.setRotation(rotation);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the background color of the circle drawn inside the drawable.
+     *
+     * @return an ARGB color
+     */
+    public int getBackgroundColor() {
+        return mRing.getBackgroundColor();
+    }
+
+    /**
+     * Sets the background color of the circle inside the drawable. Calling {@link
+     * #setAlpha(int)} does not affect the visibility background color, so it should be set
+     * separately if it needs to be hidden or visible.
+     *
+     * @param color an ARGB color
+     */
+    public void setBackgroundColor(int color) {
+        mRing.setBackgroundColor(color);
+        invalidateSelf();
+    }
+
+    /**
+     * Returns the colors used in the progress animation
+     *
+     * @return list of ARGB colors
+     */
+    public int[] getColorSchemeColors() {
+        return mRing.getColors();
+    }
+
+    /**
+     * Sets the colors used in the progress animation from a color list. The first color will also
+     * be the color to be used if animation is not started yet.
+     *
+     * @param colors list of ARGB colors to be used in the spinner
+     */
+    public void setColorSchemeColors(int... colors) {
+        mRing.setColors(colors);
+        mRing.setColorIndex(0);
+        invalidateSelf();
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        final Rect bounds = getBounds();
+        canvas.save();
+        canvas.rotate(mRotation, bounds.exactCenterX(), bounds.exactCenterY());
+        mRing.draw(canvas, bounds);
+        canvas.restore();
+    }
+
+    @Override
+    public void setAlpha(int alpha) {
+        mRing.setAlpha(alpha);
+        invalidateSelf();
+    }
+
+    @Override
+    public int getAlpha() {
+        return mRing.getAlpha();
+    }
+
+    @Override
+    public void setColorFilter(ColorFilter colorFilter) {
+        mRing.setColorFilter(colorFilter);
+        invalidateSelf();
+    }
+
+    private void setRotation(float rotation) {
+        mRotation = rotation;
+    }
+
+    private float getRotation() {
+        return mRotation;
+    }
+
+    @Override
+    public int getOpacity() {
+        return PixelFormat.TRANSLUCENT;
+    }
+
+    @Override
+    public boolean isRunning() {
+        return mAnimator.isRunning();
+    }
+
+    /**
+     * Starts the animation for the spinner.
+     */
+    @Override
+    public void start() {
+        mAnimator.cancel();
+        mRing.storeOriginals();
+        // Already showing some part of the ring
+        if (mRing.getEndTrim() != mRing.getStartTrim()) {
+            mFinishing = true;
+            mAnimator.setDuration(ANIMATION_DURATION / 2);
+            mAnimator.start();
+        } else {
+            mRing.setColorIndex(0);
+            mRing.resetOriginals();
+            mAnimator.setDuration(ANIMATION_DURATION);
+            mAnimator.start();
+        }
+    }
+
+    /**
+     * Stops the animation for the spinner.
+     */
+    @Override
+    public void stop() {
+        mAnimator.cancel();
+        setRotation(0);
+        mRing.setShowArrow(false);
+        mRing.setColorIndex(0);
+        mRing.resetOriginals();
+        invalidateSelf();
+    }
+
+    // Adapted from ArgbEvaluator.java
+    private int evaluateColorChange(float fraction, int startValue, int endValue) {
+        int startA = (startValue >> 24) & 0xff;
+        int startR = (startValue >> 16) & 0xff;
+        int startG = (startValue >> 8) & 0xff;
+        int startB = startValue & 0xff;
+
+        int endA = (endValue >> 24) & 0xff;
+        int endR = (endValue >> 16) & 0xff;
+        int endG = (endValue >> 8) & 0xff;
+        int endB = endValue & 0xff;
+
+        return (startA + (int) (fraction * (endA - startA))) << 24
+                | (startR + (int) (fraction * (endR - startR))) << 16
+                | (startG + (int) (fraction * (endG - startG))) << 8
+                | (startB + (int) (fraction * (endB - startB)));
+    }
+
+    /**
+     * Update the ring color if this is within the last 25% of the animation.
+     * The new ring color will be a translation from the starting ring color to
+     * the next color.
+     */
+    private void updateRingColor(float interpolatedTime, Ring ring) {
+        if (interpolatedTime > COLOR_CHANGE_OFFSET) {
+            ring.setColor(evaluateColorChange((interpolatedTime - COLOR_CHANGE_OFFSET)
+                            / (1f - COLOR_CHANGE_OFFSET), ring.getStartingColor(),
+                    ring.getNextColor()));
+        } else {
+            ring.setColor(ring.getStartingColor());
+        }
+    }
+
+    /**
+     * Update the ring start and end trim if the animation is finishing (i.e. it started with
+     * already visible progress, so needs to shrink back down before starting the spinner).
+     */
+    private void applyFinishTranslation(float interpolatedTime, Ring ring) {
+        // shrink back down and complete a full rotation before
+        // starting other circles
+        // Rotation goes between [0..1].
+        updateRingColor(interpolatedTime, ring);
+        float targetRotation = (float) (Math.floor(ring.getStartingRotation() / MAX_PROGRESS_ARC)
+                + 1f);
+        final float startTrim = ring.getStartingStartTrim()
+                + (ring.getStartingEndTrim() - MIN_PROGRESS_ARC - ring.getStartingStartTrim())
+                * interpolatedTime;
+        ring.setStartTrim(startTrim);
+        ring.setEndTrim(ring.getStartingEndTrim());
+        final float rotation = ring.getStartingRotation()
+                + ((targetRotation - ring.getStartingRotation()) * interpolatedTime);
+        ring.setRotation(rotation);
+    }
+
+    /**
+     * Update the ring start and end trim according to current time of the animation.
+     */
+    private void applyTransformation(float interpolatedTime, Ring ring) {
+        if (mFinishing) {
+            applyFinishTranslation(interpolatedTime, ring);
+        } else {
+            final float startingRotation = ring.getStartingRotation();
+            float startTrim, endTrim;
+
+            if (interpolatedTime < SHRINK_OFFSET) { // Expansion occurs on first half of animation
+                final float scaledTime = interpolatedTime / SHRINK_OFFSET;
+                startTrim = ring.getStartingStartTrim();
+                endTrim = startTrim + ((MAX_PROGRESS_ARC - MIN_PROGRESS_ARC)
+                        * MATERIAL_INTERPOLATOR.getInterpolation(scaledTime) + MIN_PROGRESS_ARC);
+            } else { // Shrinking occurs on second half of animation
+                float scaledTime = (interpolatedTime - SHRINK_OFFSET) / (1f - SHRINK_OFFSET);
+                endTrim = ring.getStartingStartTrim() + (MAX_PROGRESS_ARC - MIN_PROGRESS_ARC);
+                startTrim = endTrim - ((MAX_PROGRESS_ARC - MIN_PROGRESS_ARC)
+                        * (1f - MATERIAL_INTERPOLATOR.getInterpolation(scaledTime))
+                        + MIN_PROGRESS_ARC);
+            }
+
+            final float rotation = startingRotation + (RING_ROTATION * interpolatedTime);
+            float groupRotation = GROUP_FULL_ROTATION * (interpolatedTime + mRotationCount);
+
+            ring.setStartTrim(startTrim);
+            ring.setEndTrim(endTrim);
+            ring.setRotation(rotation);
+            setRotation(groupRotation);
+        }
+    }
+
+    private void setupAnimators() {
+        final Ring ring = mRing;
+        final ValueAnimator animator = ValueAnimator.ofFloat(0f, 1f);
+        animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
+            @Override
+            public void onAnimationUpdate(ValueAnimator animation) {
+                float interpolatedTime = (float) animation.getAnimatedValue();
+                updateRingColor(interpolatedTime, ring);
+                applyTransformation(interpolatedTime, ring);
+                invalidateSelf();
+            }
+        });
+        animator.setRepeatCount(ValueAnimator.INFINITE);
+        animator.setRepeatMode(ValueAnimator.RESTART);
+        animator.setInterpolator(LINEAR_INTERPOLATOR);
+        animator.addListener(new Animator.AnimatorListener() {
+
+            @Override
+            public void onAnimationStart(Animator animator) {
+                mRotationCount = 0;
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animator) {
+                // do nothing
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                // do nothing
+            }
+
+            @Override
+            public void onAnimationRepeat(Animator animator) {
+                applyTransformation(1f, ring); // Set ring to last frame
+                ring.storeOriginals();
+                ring.goToNextColor();
+                if (mFinishing) {
+                    // finished closing the last ring from the swipe gesture; go
+                    // into progress mode
+                    mFinishing = false;
+                    animator.cancel();
+                    animator.setDuration(ANIMATION_DURATION);
+                    animator.start();
+                    ring.setShowArrow(false);
+                } else {
+                    mRotationCount = mRotationCount + 1;
+                }
+            }
+        });
+        mAnimator = animator;
+    }
+
+    /**
+     * A private class to do all the drawing of CircularProgressDrawable, which includes background,
+     * progress spinner and the arrow. This class is to separate drawing from animation.
+     */
+    private class Ring {
+        final RectF mTempBounds = new RectF();
+        final Paint mPaint = new Paint();
+        final Paint mArrowPaint = new Paint();
+        final Paint mCirclePaint = new Paint();
+
+        float mStartTrim = 0f;
+        float mEndTrim = 0f;
+        float mRotation = 0f;
+        float mStrokeWidth = 5f;
+
+        int[] mColors;
+        // mColorIndex represents the offset into the available mColors that the
+        // progress circle should currently display. As the progress circle is
+        // animating, the mColorIndex moves by one to the next available color.
+        int mColorIndex;
+        float mStartingStartTrim;
+        float mStartingEndTrim;
+        float mStartingRotation;
+        boolean mShowArrow;
+        Path mArrow;
+        float mArrowScale = 1;
+        float mRingCenterRadius;
+        int mArrowWidth;
+        int mArrowHeight;
+        int mAlpha = 255;
+        int mCurrentColor;
+
+        Ring() {
+            mPaint.setStrokeCap(Paint.Cap.SQUARE);
+            mPaint.setAntiAlias(true);
+            mPaint.setStyle(Style.STROKE);
+
+            mArrowPaint.setStyle(Paint.Style.FILL);
+            mArrowPaint.setAntiAlias(true);
+
+            mCirclePaint.setColor(Color.TRANSPARENT);
+        }
+
+        /**
+         * Sets the dimensions of the arrowhead.
+         *
+         * @param width width of the hypotenuse of the arrow head
+         * @param height height of the arrow point
+         */
+        void setArrowDimensions(float width, float height) {
+            mArrowWidth = (int) width;
+            mArrowHeight = (int) height;
+        }
+
+        void setStrokeCap(Paint.Cap strokeCap) {
+            mPaint.setStrokeCap(strokeCap);
+        }
+
+        Paint.Cap getStrokeCap() {
+            return mPaint.getStrokeCap();
+        }
+
+        float getArrowWidth() {
+            return mArrowWidth;
+        }
+
+        float getArrowHeight() {
+            return mArrowHeight;
+        }
+
+        /**
+         * Draw the progress spinner
+         */
+        void draw(Canvas c, Rect bounds) {
+            final RectF arcBounds = mTempBounds;
+            float arcRadius = mRingCenterRadius + mStrokeWidth / 2f;
+            if (mRingCenterRadius <= 0) {
+                // If center radius is not set, fill the bounds
+                arcRadius = Math.min(bounds.width(), bounds.height()) / 2f - Math.max(
+                        (mArrowWidth * mArrowScale) / 2f, mStrokeWidth / 2f);
+            }
+            arcBounds.set(bounds.centerX() - arcRadius,
+                    bounds.centerY() - arcRadius,
+                    bounds.centerX() + arcRadius,
+                    bounds.centerY() + arcRadius);
+
+            final float startAngle = (mStartTrim + mRotation) * 360;
+            final float endAngle = (mEndTrim + mRotation) * 360;
+            float sweepAngle = endAngle - startAngle;
+
+            mPaint.setColor(mCurrentColor);
+            mPaint.setAlpha(mAlpha);
+
+            // Draw the background first
+            float inset = mStrokeWidth / 2f; // Calculate inset to draw inside the arc
+            arcBounds.inset(inset, inset); // Apply inset
+            c.drawCircle(arcBounds.centerX(), arcBounds.centerY(), arcBounds.width() / 2f,
+                    mCirclePaint);
+            arcBounds.inset(-inset, -inset); // Revert the inset
+
+            c.drawArc(arcBounds, startAngle, sweepAngle, false, mPaint);
+
+            drawTriangle(c, startAngle, sweepAngle, arcBounds);
+        }
+
+        void drawTriangle(Canvas c, float startAngle, float sweepAngle, RectF bounds) {
+            if (mShowArrow) {
+                if (mArrow == null) {
+                    mArrow = new android.graphics.Path();
+                    mArrow.setFillType(android.graphics.Path.FillType.EVEN_ODD);
+                } else {
+                    mArrow.reset();
+                }
+                float centerRadius = Math.min(bounds.width(), bounds.height()) / 2f;
+                float inset = mArrowWidth * mArrowScale / 2f;
+                // Update the path each time. This works around an issue in SKIA
+                // where concatenating a rotation matrix to a scale matrix
+                // ignored a starting negative rotation. This appears to have
+                // been fixed as of API 21.
+                mArrow.moveTo(0, 0);
+                mArrow.lineTo(mArrowWidth * mArrowScale, 0);
+                mArrow.lineTo((mArrowWidth * mArrowScale / 2), (mArrowHeight
+                        * mArrowScale));
+                mArrow.offset(centerRadius + bounds.centerX() - inset,
+                        bounds.centerY() + mStrokeWidth / 2f);
+                mArrow.close();
+                // draw a triangle
+                mArrowPaint.setColor(mCurrentColor);
+                mArrowPaint.setAlpha(mAlpha);
+                c.save();
+                c.rotate(startAngle + sweepAngle, bounds.centerX(),
+                        bounds.centerY());
+                c.drawPath(mArrow, mArrowPaint);
+                c.restore();
+            }
+        }
+
+        /**
+         * Sets the colors the progress spinner alternates between.
+         *
+         * @param colors array of ARGB colors. Must be non-{@code null}.
+         */
+        void setColors(@NonNull int[] colors) {
+            mColors = colors;
+            // if colors are reset, make sure to reset the color index as well
+            setColorIndex(0);
+        }
+
+        int[] getColors() {
+            return mColors;
+        }
+
+        /**
+         * Sets the absolute color of the progress spinner. This is should only
+         * be used when animating between current and next color when the
+         * spinner is rotating.
+         *
+         * @param color an ARGB color
+         */
+        void setColor(int color) {
+            mCurrentColor = color;
+        }
+
+        /**
+         * Sets the background color of the circle inside the spinner.
+         */
+        void setBackgroundColor(int color) {
+            mCirclePaint.setColor(color);
+        }
+
+        int getBackgroundColor() {
+            return mCirclePaint.getColor();
+        }
+
+        /**
+         * @param index index into the color array of the color to display in
+         *              the progress spinner.
+         */
+        void setColorIndex(int index) {
+            mColorIndex = index;
+            mCurrentColor = mColors[mColorIndex];
+        }
+
+        /**
+         * @return int describing the next color the progress spinner should use when drawing.
+         */
+        int getNextColor() {
+            return mColors[getNextColorIndex()];
+        }
+
+        int getNextColorIndex() {
+            return (mColorIndex + 1) % (mColors.length);
+        }
+
+        /**
+         * Proceed to the next available ring color. This will automatically
+         * wrap back to the beginning of colors.
+         */
+        void goToNextColor() {
+            setColorIndex(getNextColorIndex());
+        }
+
+        void setColorFilter(ColorFilter filter) {
+            mPaint.setColorFilter(filter);
+        }
+
+        /**
+         * @param alpha alpha of the progress spinner and associated arrowhead.
+         */
+        void setAlpha(int alpha) {
+            mAlpha = alpha;
+        }
+
+        /**
+         * @return current alpha of the progress spinner and arrowhead
+         */
+        int getAlpha() {
+            return mAlpha;
+        }
+
+        /**
+         * @param strokeWidth set the stroke width of the progress spinner in pixels.
+         */
+        void setStrokeWidth(float strokeWidth) {
+            mStrokeWidth = strokeWidth;
+            mPaint.setStrokeWidth(strokeWidth);
+        }
+
+        float getStrokeWidth() {
+            return mStrokeWidth;
+        }
+
+        void setStartTrim(float startTrim) {
+            mStartTrim = startTrim;
+        }
+
+        float getStartTrim() {
+            return mStartTrim;
+        }
+
+        float getStartingStartTrim() {
+            return mStartingStartTrim;
+        }
+
+        float getStartingEndTrim() {
+            return mStartingEndTrim;
+        }
+
+        int getStartingColor() {
+            return mColors[mColorIndex];
+        }
+
+        void setEndTrim(float endTrim) {
+            mEndTrim = endTrim;
+        }
+
+        float getEndTrim() {
+            return mEndTrim;
+        }
+
+        void setRotation(float rotation) {
+            mRotation = rotation;
+        }
+
+        float getRotation() {
+            return mRotation;
+        }
+
+        /**
+         * @param centerRadius inner radius in px of the circle the progress spinner arc traces
+         */
+        void setCenterRadius(float centerRadius) {
+            mRingCenterRadius = centerRadius;
+        }
+
+        float getCenterRadius() {
+            return mRingCenterRadius;
+        }
+
+        /**
+         * @param show {@code true} if should show the arrow head on the progress spinner
+         */
+        void setShowArrow(boolean show) {
+            if (mShowArrow != show) {
+                mShowArrow = show;
+            }
+        }
+
+        boolean getShowArrow() {
+            return mShowArrow;
+        }
+
+        /**
+         * @param scale scale of the arrowhead for the spinner
+         */
+        void setArrowScale(float scale) {
+            if (scale != mArrowScale) {
+                mArrowScale = scale;
+            }
+        }
+
+        float getArrowScale() {
+            return mArrowScale;
+        }
+
+        /**
+         * @return The amount the progress spinner is currently rotated, between [0..1].
+         */
+        float getStartingRotation() {
+            return mStartingRotation;
+        }
+
+        /**
+         * If the start / end trim are offset to begin with, store them so that animation starts
+         * from that offset.
+         */
+        void storeOriginals() {
+            mStartingStartTrim = mStartTrim;
+            mStartingEndTrim = mEndTrim;
+            mStartingRotation = mRotation;
+        }
+
+        /**
+         * Reset the progress spinner to default rotation, start and end angles.
+         */
+        void resetOriginals() {
+            mStartingStartTrim = 0;
+            mStartingEndTrim = 0;
+            mStartingRotation = 0;
+            setStartTrim(0);
+            setEndTrim(0);
+            setRotation(0);
+        }
+    }
+}
diff --git a/core-ui/java/android/support/v4/widget/MaterialProgressDrawable.java b/core-ui/java/android/support/v4/widget/MaterialProgressDrawable.java
deleted file mode 100644
index cad36d9..0000000
--- a/core-ui/java/android/support/v4/widget/MaterialProgressDrawable.java
+++ /dev/null
@@ -1,792 +0,0 @@
-/*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.support.v4.widget;
-
-import android.content.Context;
-import android.content.res.Resources;
-import android.graphics.Canvas;
-import android.graphics.Color;
-import android.graphics.ColorFilter;
-import android.graphics.Paint;
-import android.graphics.Paint.Style;
-import android.graphics.Path;
-import android.graphics.PixelFormat;
-import android.graphics.Rect;
-import android.graphics.RectF;
-import android.graphics.drawable.Animatable;
-import android.graphics.drawable.Drawable;
-import android.support.annotation.IntDef;
-import android.support.annotation.NonNull;
-import android.support.v4.view.animation.FastOutSlowInInterpolator;
-import android.util.DisplayMetrics;
-import android.view.View;
-import android.view.animation.Animation;
-import android.view.animation.Interpolator;
-import android.view.animation.LinearInterpolator;
-import android.view.animation.Transformation;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.ArrayList;
-
-/**
- * Fancy progress indicator for Material theme.
- */
-class MaterialProgressDrawable extends Drawable implements Animatable {
-    private static final Interpolator LINEAR_INTERPOLATOR = new LinearInterpolator();
-    static final Interpolator MATERIAL_INTERPOLATOR = new FastOutSlowInInterpolator();
-
-    private static final float FULL_ROTATION = 1080.0f;
-
-    @Retention(RetentionPolicy.SOURCE)
-    @IntDef({LARGE, DEFAULT})
-    public @interface ProgressDrawableSize {}
-
-    // Maps to ProgressBar.Large style
-    static final int LARGE = 0;
-    // Maps to ProgressBar default style
-    static final int DEFAULT = 1;
-
-    // Maps to ProgressBar default style
-    private static final int CIRCLE_DIAMETER = 40;
-    private static final float CENTER_RADIUS = 8.75f; //should add up to 10 when + stroke_width
-    private static final float STROKE_WIDTH = 2.5f;
-
-    // Maps to ProgressBar.Large style
-    private static final int CIRCLE_DIAMETER_LARGE = 56;
-    private static final float CENTER_RADIUS_LARGE = 12.5f;
-    private static final float STROKE_WIDTH_LARGE = 3f;
-
-    private static final int[] COLORS = new int[] {
-        Color.BLACK
-    };
-
-    /**
-     * The value in the linear interpolator for animating the drawable at which
-     * the color transition should start
-     */
-    private static final float COLOR_START_DELAY_OFFSET = 0.75f;
-    private static final float END_TRIM_START_DELAY_OFFSET = 0.5f;
-    private static final float START_TRIM_DURATION_OFFSET = 0.5f;
-
-    /** The duration of a single progress spin in milliseconds. */
-    private static final int ANIMATION_DURATION = 1332;
-
-    /** The number of points in the progress "star". */
-    private static final float NUM_POINTS = 5f;
-    /** The list of animators operating on this drawable. */
-    private final ArrayList<Animation> mAnimators = new ArrayList<Animation>();
-
-    /** The indicator ring, used to manage animation state. */
-    private final Ring mRing;
-
-    /** Canvas rotation in degrees. */
-    private float mRotation;
-
-    /** Layout info for the arrowhead in dp */
-    private static final int ARROW_WIDTH = 10;
-    private static final int ARROW_HEIGHT = 5;
-    private static final float ARROW_OFFSET_ANGLE = 5;
-
-    /** Layout info for the arrowhead for the large spinner in dp */
-    private static final int ARROW_WIDTH_LARGE = 12;
-    private static final int ARROW_HEIGHT_LARGE = 6;
-    private static final float MAX_PROGRESS_ARC = .8f;
-
-    private Resources mResources;
-    private View mParent;
-    private Animation mAnimation;
-    float mRotationCount;
-    private double mWidth;
-    private double mHeight;
-    boolean mFinishing;
-
-    MaterialProgressDrawable(Context context, View parent) {
-        mParent = parent;
-        mResources = context.getResources();
-
-        mRing = new Ring(mCallback);
-        mRing.setColors(COLORS);
-
-        updateSizes(DEFAULT);
-        setupAnimators();
-    }
-
-    private void setSizeParameters(double progressCircleWidth, double progressCircleHeight,
-            double centerRadius, double strokeWidth, float arrowWidth, float arrowHeight) {
-        final Ring ring = mRing;
-        final DisplayMetrics metrics = mResources.getDisplayMetrics();
-        final float screenDensity = metrics.density;
-
-        mWidth = progressCircleWidth * screenDensity;
-        mHeight = progressCircleHeight * screenDensity;
-        ring.setStrokeWidth((float) strokeWidth * screenDensity);
-        ring.setCenterRadius(centerRadius * screenDensity);
-        ring.setColorIndex(0);
-        ring.setArrowDimensions(arrowWidth * screenDensity, arrowHeight * screenDensity);
-        ring.setInsets((int) mWidth, (int) mHeight);
-    }
-
-    /**
-     * Set the overall size for the progress spinner. This updates the radius
-     * and stroke width of the ring.
-     *
-     * @param size One of {@link MaterialProgressDrawable.LARGE} or
-     *            {@link MaterialProgressDrawable.DEFAULT}
-     */
-    public void updateSizes(@ProgressDrawableSize int size) {
-        if (size == LARGE) {
-            setSizeParameters(CIRCLE_DIAMETER_LARGE, CIRCLE_DIAMETER_LARGE, CENTER_RADIUS_LARGE,
-                    STROKE_WIDTH_LARGE, ARROW_WIDTH_LARGE, ARROW_HEIGHT_LARGE);
-        } else {
-            setSizeParameters(CIRCLE_DIAMETER, CIRCLE_DIAMETER, CENTER_RADIUS, STROKE_WIDTH,
-                    ARROW_WIDTH, ARROW_HEIGHT);
-        }
-    }
-
-    /**
-     * @param show Set to true to display the arrowhead on the progress spinner.
-     */
-    public void showArrow(boolean show) {
-        mRing.setShowArrow(show);
-    }
-
-    /**
-     * @param scale Set the scale of the arrowhead for the spinner.
-     */
-    public void setArrowScale(float scale) {
-        mRing.setArrowScale(scale);
-    }
-
-    /**
-     * Set the start and end trim for the progress spinner arc.
-     *
-     * @param startAngle start angle
-     * @param endAngle end angle
-     */
-    public void setStartEndTrim(float startAngle, float endAngle) {
-        mRing.setStartTrim(startAngle);
-        mRing.setEndTrim(endAngle);
-    }
-
-    /**
-     * Set the amount of rotation to apply to the progress spinner.
-     *
-     * @param rotation Rotation is from [0..1]
-     */
-    public void setProgressRotation(float rotation) {
-        mRing.setRotation(rotation);
-    }
-
-    /**
-     * Update the background color of the circle image view.
-     */
-    public void setBackgroundColor(int color) {
-        mRing.setBackgroundColor(color);
-    }
-
-    /**
-     * Set the colors used in the progress animation from color resources.
-     * The first color will also be the color of the bar that grows in response
-     * to a user swipe gesture.
-     *
-     * @param colors
-     */
-    public void setColorSchemeColors(int... colors) {
-        mRing.setColors(colors);
-        mRing.setColorIndex(0);
-    }
-
-    @Override
-    public int getIntrinsicHeight() {
-        return (int) mHeight;
-    }
-
-    @Override
-    public int getIntrinsicWidth() {
-        return (int) mWidth;
-    }
-
-    @Override
-    public void draw(Canvas c) {
-        final Rect bounds = getBounds();
-        final int saveCount = c.save();
-        c.rotate(mRotation, bounds.exactCenterX(), bounds.exactCenterY());
-        mRing.draw(c, bounds);
-        c.restoreToCount(saveCount);
-    }
-
-    @Override
-    public void setAlpha(int alpha) {
-        mRing.setAlpha(alpha);
-    }
-
-    @Override
-    public int getAlpha() {
-        return mRing.getAlpha();
-    }
-
-    @Override
-    public void setColorFilter(ColorFilter colorFilter) {
-        mRing.setColorFilter(colorFilter);
-    }
-
-    @SuppressWarnings("unused")
-    void setRotation(float rotation) {
-        mRotation = rotation;
-        invalidateSelf();
-    }
-
-    @SuppressWarnings("unused")
-    private float getRotation() {
-        return mRotation;
-    }
-
-    @Override
-    public int getOpacity() {
-        return PixelFormat.TRANSLUCENT;
-    }
-
-    @Override
-    public boolean isRunning() {
-        final ArrayList<Animation> animators = mAnimators;
-        final int N = animators.size();
-        for (int i = 0; i < N; i++) {
-            final Animation animator = animators.get(i);
-            if (animator.hasStarted() && !animator.hasEnded()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public void start() {
-        mAnimation.reset();
-        mRing.storeOriginals();
-        // Already showing some part of the ring
-        if (mRing.getEndTrim() != mRing.getStartTrim()) {
-            mFinishing = true;
-            mAnimation.setDuration(ANIMATION_DURATION / 2);
-            mParent.startAnimation(mAnimation);
-        } else {
-            mRing.setColorIndex(0);
-            mRing.resetOriginals();
-            mAnimation.setDuration(ANIMATION_DURATION);
-            mParent.startAnimation(mAnimation);
-        }
-    }
-
-    @Override
-    public void stop() {
-        mParent.clearAnimation();
-        setRotation(0);
-        mRing.setShowArrow(false);
-        mRing.setColorIndex(0);
-        mRing.resetOriginals();
-    }
-
-    float getMinProgressArc(Ring ring) {
-        return (float) Math.toRadians(
-                ring.getStrokeWidth() / (2 * Math.PI * ring.getCenterRadius()));
-    }
-
-    // Adapted from ArgbEvaluator.java
-    private int evaluateColorChange(float fraction, int startValue, int endValue) {
-        int startInt = (Integer) startValue;
-        int startA = (startInt >> 24) & 0xff;
-        int startR = (startInt >> 16) & 0xff;
-        int startG = (startInt >> 8) & 0xff;
-        int startB = startInt & 0xff;
-
-        int endInt = (Integer) endValue;
-        int endA = (endInt >> 24) & 0xff;
-        int endR = (endInt >> 16) & 0xff;
-        int endG = (endInt >> 8) & 0xff;
-        int endB = endInt & 0xff;
-
-        return (int) ((startA + (int) (fraction * (endA - startA))) << 24)
-                | (int) ((startR + (int) (fraction * (endR - startR))) << 16)
-                | (int) ((startG + (int) (fraction * (endG - startG))) << 8)
-                | (int) ((startB + (int) (fraction * (endB - startB))));
-    }
-
-    /**
-     * Update the ring color if this is within the last 25% of the animation.
-     * The new ring color will be a translation from the starting ring color to
-     * the next color.
-     */
-    void updateRingColor(float interpolatedTime, Ring ring) {
-        if (interpolatedTime > COLOR_START_DELAY_OFFSET) {
-            // scale the interpolatedTime so that the full
-            // transformation from 0 - 1 takes place in the
-            // remaining time
-            ring.setColor(evaluateColorChange((interpolatedTime - COLOR_START_DELAY_OFFSET)
-                    / (1.0f - COLOR_START_DELAY_OFFSET), ring.getStartingColor(),
-                    ring.getNextColor()));
-        }
-    }
-
-    void applyFinishTranslation(float interpolatedTime, Ring ring) {
-        // shrink back down and complete a full rotation before
-        // starting other circles
-        // Rotation goes between [0..1].
-        updateRingColor(interpolatedTime, ring);
-        float targetRotation = (float) (Math.floor(ring.getStartingRotation() / MAX_PROGRESS_ARC)
-                + 1f);
-        final float minProgressArc = getMinProgressArc(ring);
-        final float startTrim = ring.getStartingStartTrim()
-                + (ring.getStartingEndTrim() - minProgressArc - ring.getStartingStartTrim())
-                * interpolatedTime;
-        ring.setStartTrim(startTrim);
-        ring.setEndTrim(ring.getStartingEndTrim());
-        final float rotation = ring.getStartingRotation()
-                + ((targetRotation - ring.getStartingRotation()) * interpolatedTime);
-        ring.setRotation(rotation);
-    }
-
-    private void setupAnimators() {
-        final Ring ring = mRing;
-        final Animation animation = new Animation() {
-                @Override
-            public void applyTransformation(float interpolatedTime, Transformation t) {
-                if (mFinishing) {
-                    applyFinishTranslation(interpolatedTime, ring);
-                } else {
-                    // The minProgressArc is calculated from 0 to create an
-                    // angle that matches the stroke width.
-                    final float minProgressArc = getMinProgressArc(ring);
-                    final float startingEndTrim = ring.getStartingEndTrim();
-                    final float startingTrim = ring.getStartingStartTrim();
-                    final float startingRotation = ring.getStartingRotation();
-
-                    updateRingColor(interpolatedTime, ring);
-
-                    // Moving the start trim only occurs in the first 50% of a
-                    // single ring animation
-                    if (interpolatedTime <= START_TRIM_DURATION_OFFSET) {
-                        // scale the interpolatedTime so that the full
-                        // transformation from 0 - 1 takes place in the
-                        // remaining time
-                        final float scaledTime = (interpolatedTime)
-                                / (1.0f - START_TRIM_DURATION_OFFSET);
-                        final float startTrim = startingTrim
-                                + ((MAX_PROGRESS_ARC - minProgressArc) * MATERIAL_INTERPOLATOR
-                                        .getInterpolation(scaledTime));
-                        ring.setStartTrim(startTrim);
-                    }
-
-                    // Moving the end trim starts after 50% of a single ring
-                    // animation completes
-                    if (interpolatedTime > END_TRIM_START_DELAY_OFFSET) {
-                        // scale the interpolatedTime so that the full
-                        // transformation from 0 - 1 takes place in the
-                        // remaining time
-                        final float minArc = MAX_PROGRESS_ARC - minProgressArc;
-                        float scaledTime = (interpolatedTime - START_TRIM_DURATION_OFFSET)
-                                / (1.0f - START_TRIM_DURATION_OFFSET);
-                        final float endTrim = startingEndTrim
-                                + (minArc * MATERIAL_INTERPOLATOR.getInterpolation(scaledTime));
-                        ring.setEndTrim(endTrim);
-                    }
-
-                    final float rotation = startingRotation + (0.25f * interpolatedTime);
-                    ring.setRotation(rotation);
-
-                    float groupRotation = ((FULL_ROTATION / NUM_POINTS) * interpolatedTime)
-                            + (FULL_ROTATION * (mRotationCount / NUM_POINTS));
-                    setRotation(groupRotation);
-                }
-            }
-        };
-        animation.setRepeatCount(Animation.INFINITE);
-        animation.setRepeatMode(Animation.RESTART);
-        animation.setInterpolator(LINEAR_INTERPOLATOR);
-        animation.setAnimationListener(new Animation.AnimationListener() {
-
-                @Override
-            public void onAnimationStart(Animation animation) {
-                mRotationCount = 0;
-            }
-
-                @Override
-            public void onAnimationEnd(Animation animation) {
-                // do nothing
-            }
-
-                @Override
-            public void onAnimationRepeat(Animation animation) {
-                ring.storeOriginals();
-                ring.goToNextColor();
-                ring.setStartTrim(ring.getEndTrim());
-                if (mFinishing) {
-                    // finished closing the last ring from the swipe gesture; go
-                    // into progress mode
-                    mFinishing = false;
-                    animation.setDuration(ANIMATION_DURATION);
-                    ring.setShowArrow(false);
-                } else {
-                    mRotationCount = (mRotationCount + 1) % (NUM_POINTS);
-                }
-            }
-        });
-        mAnimation = animation;
-    }
-
-    private final Callback mCallback = new Callback() {
-        @Override
-        public void invalidateDrawable(Drawable d) {
-            invalidateSelf();
-        }
-
-        @Override
-        public void scheduleDrawable(Drawable d, Runnable what, long when) {
-            scheduleSelf(what, when);
-        }
-
-        @Override
-        public void unscheduleDrawable(Drawable d, Runnable what) {
-            unscheduleSelf(what);
-        }
-    };
-
-    private static class Ring {
-        private final RectF mTempBounds = new RectF();
-        private final Paint mPaint = new Paint();
-        private final Paint mArrowPaint = new Paint();
-
-        private final Callback mCallback;
-
-        private float mStartTrim = 0.0f;
-        private float mEndTrim = 0.0f;
-        private float mRotation = 0.0f;
-        private float mStrokeWidth = 5.0f;
-        private float mStrokeInset = 2.5f;
-
-        private int[] mColors;
-        // mColorIndex represents the offset into the available mColors that the
-        // progress circle should currently display. As the progress circle is
-        // animating, the mColorIndex moves by one to the next available color.
-        private int mColorIndex;
-        private float mStartingStartTrim;
-        private float mStartingEndTrim;
-        private float mStartingRotation;
-        private boolean mShowArrow;
-        private Path mArrow;
-        private float mArrowScale;
-        private double mRingCenterRadius;
-        private int mArrowWidth;
-        private int mArrowHeight;
-        private int mAlpha;
-        private final Paint mCirclePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
-        private int mBackgroundColor;
-        private int mCurrentColor;
-
-        Ring(Callback callback) {
-            mCallback = callback;
-
-            mPaint.setStrokeCap(Paint.Cap.SQUARE);
-            mPaint.setAntiAlias(true);
-            mPaint.setStyle(Style.STROKE);
-
-            mArrowPaint.setStyle(Paint.Style.FILL);
-            mArrowPaint.setAntiAlias(true);
-        }
-
-        public void setBackgroundColor(int color) {
-            mBackgroundColor = color;
-        }
-
-        /**
-         * Set the dimensions of the arrowhead.
-         *
-         * @param width Width of the hypotenuse of the arrow head
-         * @param height Height of the arrow point
-         */
-        public void setArrowDimensions(float width, float height) {
-            mArrowWidth = (int) width;
-            mArrowHeight = (int) height;
-        }
-
-        /**
-         * Draw the progress spinner
-         */
-        public void draw(Canvas c, Rect bounds) {
-            final RectF arcBounds = mTempBounds;
-            arcBounds.set(bounds);
-            arcBounds.inset(mStrokeInset, mStrokeInset);
-
-            final float startAngle = (mStartTrim + mRotation) * 360;
-            final float endAngle = (mEndTrim + mRotation) * 360;
-            float sweepAngle = endAngle - startAngle;
-
-            mPaint.setColor(mCurrentColor);
-            c.drawArc(arcBounds, startAngle, sweepAngle, false, mPaint);
-
-            drawTriangle(c, startAngle, sweepAngle, bounds);
-
-            if (mAlpha < 255) {
-                mCirclePaint.setColor(mBackgroundColor);
-                mCirclePaint.setAlpha(255 - mAlpha);
-                c.drawCircle(bounds.exactCenterX(), bounds.exactCenterY(), bounds.width() / 2,
-                        mCirclePaint);
-            }
-        }
-
-        private void drawTriangle(Canvas c, float startAngle, float sweepAngle, Rect bounds) {
-            if (mShowArrow) {
-                if (mArrow == null) {
-                    mArrow = new android.graphics.Path();
-                    mArrow.setFillType(android.graphics.Path.FillType.EVEN_ODD);
-                } else {
-                    mArrow.reset();
-                }
-
-                // Adjust the position of the triangle so that it is inset as
-                // much as the arc, but also centered on the arc.
-                float inset = (int) mStrokeInset / 2 * mArrowScale;
-                float x = (float) (mRingCenterRadius * Math.cos(0) + bounds.exactCenterX());
-                float y = (float) (mRingCenterRadius * Math.sin(0) + bounds.exactCenterY());
-
-                // Update the path each time. This works around an issue in SKIA
-                // where concatenating a rotation matrix to a scale matrix
-                // ignored a starting negative rotation. This appears to have
-                // been fixed as of API 21.
-                mArrow.moveTo(0, 0);
-                mArrow.lineTo(mArrowWidth * mArrowScale, 0);
-                mArrow.lineTo((mArrowWidth * mArrowScale / 2), (mArrowHeight
-                        * mArrowScale));
-                mArrow.offset(x - inset, y);
-                mArrow.close();
-                // draw a triangle
-                mArrowPaint.setColor(mCurrentColor);
-                c.rotate(startAngle + sweepAngle - ARROW_OFFSET_ANGLE, bounds.exactCenterX(),
-                        bounds.exactCenterY());
-                c.drawPath(mArrow, mArrowPaint);
-            }
-        }
-
-        /**
-         * Set the colors the progress spinner alternates between.
-         *
-         * @param colors Array of integers describing the colors. Must be non-<code>null</code>.
-         */
-        public void setColors(@NonNull int[] colors) {
-            mColors = colors;
-            // if colors are reset, make sure to reset the color index as well
-            setColorIndex(0);
-        }
-
-        /**
-         * Set the absolute color of the progress spinner. This is should only
-         * be used when animating between current and next color when the
-         * spinner is rotating.
-         *
-         * @param color int describing the color.
-         */
-        public void setColor(int color) {
-            mCurrentColor = color;
-        }
-
-        /**
-         * @param index Index into the color array of the color to display in
-         *            the progress spinner.
-         */
-        public void setColorIndex(int index) {
-            mColorIndex = index;
-            mCurrentColor = mColors[mColorIndex];
-        }
-
-        /**
-         * @return int describing the next color the progress spinner should use when drawing.
-         */
-        public int getNextColor() {
-            return mColors[getNextColorIndex()];
-        }
-
-        private int getNextColorIndex() {
-            return (mColorIndex + 1) % (mColors.length);
-        }
-
-        /**
-         * Proceed to the next available ring color. This will automatically
-         * wrap back to the beginning of colors.
-         */
-        public void goToNextColor() {
-            setColorIndex(getNextColorIndex());
-        }
-
-        public void setColorFilter(ColorFilter filter) {
-            mPaint.setColorFilter(filter);
-            invalidateSelf();
-        }
-
-        /**
-         * @param alpha Set the alpha of the progress spinner and associated arrowhead.
-         */
-        public void setAlpha(int alpha) {
-            mAlpha = alpha;
-        }
-
-        /**
-         * @return Current alpha of the progress spinner and arrowhead.
-         */
-        public int getAlpha() {
-            return mAlpha;
-        }
-
-        /**
-         * @param strokeWidth Set the stroke width of the progress spinner in pixels.
-         */
-        public void setStrokeWidth(float strokeWidth) {
-            mStrokeWidth = strokeWidth;
-            mPaint.setStrokeWidth(strokeWidth);
-            invalidateSelf();
-        }
-
-        @SuppressWarnings("unused")
-        public float getStrokeWidth() {
-            return mStrokeWidth;
-        }
-
-        @SuppressWarnings("unused")
-        public void setStartTrim(float startTrim) {
-            mStartTrim = startTrim;
-            invalidateSelf();
-        }
-
-        @SuppressWarnings("unused")
-        public float getStartTrim() {
-            return mStartTrim;
-        }
-
-        public float getStartingStartTrim() {
-            return mStartingStartTrim;
-        }
-
-        public float getStartingEndTrim() {
-            return mStartingEndTrim;
-        }
-
-        public int getStartingColor() {
-            return mColors[mColorIndex];
-        }
-
-        @SuppressWarnings("unused")
-        public void setEndTrim(float endTrim) {
-            mEndTrim = endTrim;
-            invalidateSelf();
-        }
-
-        @SuppressWarnings("unused")
-        public float getEndTrim() {
-            return mEndTrim;
-        }
-
-        @SuppressWarnings("unused")
-        public void setRotation(float rotation) {
-            mRotation = rotation;
-            invalidateSelf();
-        }
-
-        @SuppressWarnings("unused")
-        public float getRotation() {
-            return mRotation;
-        }
-
-        public void setInsets(int width, int height) {
-            final float minEdge = (float) Math.min(width, height);
-            float insets;
-            if (mRingCenterRadius <= 0 || minEdge < 0) {
-                insets = (float) Math.ceil(mStrokeWidth / 2.0f);
-            } else {
-                insets = (float) (minEdge / 2.0f - mRingCenterRadius);
-            }
-            mStrokeInset = insets;
-        }
-
-        @SuppressWarnings("unused")
-        public float getInsets() {
-            return mStrokeInset;
-        }
-
-        /**
-         * @param centerRadius Inner radius in px of the circle the progress
-         *            spinner arc traces.
-         */
-        public void setCenterRadius(double centerRadius) {
-            mRingCenterRadius = centerRadius;
-        }
-
-        public double getCenterRadius() {
-            return mRingCenterRadius;
-        }
-
-        /**
-         * @param show Set to true to show the arrow head on the progress spinner.
-         */
-        public void setShowArrow(boolean show) {
-            if (mShowArrow != show) {
-                mShowArrow = show;
-                invalidateSelf();
-            }
-        }
-
-        /**
-         * @param scale Set the scale of the arrowhead for the spinner.
-         */
-        public void setArrowScale(float scale) {
-            if (scale != mArrowScale) {
-                mArrowScale = scale;
-                invalidateSelf();
-            }
-        }
-
-        /**
-         * @return The amount the progress spinner is currently rotated, between [0..1].
-         */
-        public float getStartingRotation() {
-            return mStartingRotation;
-        }
-
-        /**
-         * If the start / end trim are offset to begin with, store them so that
-         * animation starts from that offset.
-         */
-        public void storeOriginals() {
-            mStartingStartTrim = mStartTrim;
-            mStartingEndTrim = mEndTrim;
-            mStartingRotation = mRotation;
-        }
-
-        /**
-         * Reset the progress spinner to default rotation, start and end angles.
-         */
-        public void resetOriginals() {
-            mStartingStartTrim = 0;
-            mStartingEndTrim = 0;
-            mStartingRotation = 0;
-            setStartTrim(0);
-            setEndTrim(0);
-            setRotation(0);
-        }
-
-        private void invalidateSelf() {
-            mCallback.invalidateDrawable(null);
-        }
-    }
-}
diff --git a/core-ui/java/android/support/v4/widget/SwipeRefreshLayout.java b/core-ui/java/android/support/v4/widget/SwipeRefreshLayout.java
index 6a5a629..d36ae22 100644
--- a/core-ui/java/android/support/v4/widget/SwipeRefreshLayout.java
+++ b/core-ui/java/android/support/v4/widget/SwipeRefreshLayout.java
@@ -66,9 +66,9 @@
 public class SwipeRefreshLayout extends ViewGroup implements NestedScrollingParent,
         NestedScrollingChild {
     // Maps to ProgressBar.Large style
-    public static final int LARGE = MaterialProgressDrawable.LARGE;
+    public static final int LARGE = CircularProgressDrawable.LARGE;
     // Maps to ProgressBar default style
-    public static final int DEFAULT = MaterialProgressDrawable.DEFAULT;
+    public static final int DEFAULT = CircularProgressDrawable.DEFAULT;
 
     @VisibleForTesting
     static final int CIRCLE_DIAMETER = 40;
@@ -146,7 +146,7 @@
 
     int mSpinnerOffsetEnd;
 
-    MaterialProgressDrawable mProgress;
+    CircularProgressDrawable mProgress;
 
     private Animation mScaleAnimation;
 
@@ -294,11 +294,11 @@
      * One of DEFAULT, or LARGE.
      */
     public void setSize(int size) {
-        if (size != MaterialProgressDrawable.LARGE && size != MaterialProgressDrawable.DEFAULT) {
+        if (size != CircularProgressDrawable.LARGE && size != CircularProgressDrawable.DEFAULT) {
             return;
         }
         final DisplayMetrics metrics = getResources().getDisplayMetrics();
-        if (size == MaterialProgressDrawable.LARGE) {
+        if (size == CircularProgressDrawable.LARGE) {
             mCircleDiameter = (int) (CIRCLE_DIAMETER_LARGE * metrics.density);
         } else {
             mCircleDiameter = (int) (CIRCLE_DIAMETER * metrics.density);
@@ -307,7 +307,7 @@
         // update by setting it to null before updating its size and then
         // re-setting it
         mCircleView.setImageDrawable(null);
-        mProgress.updateSizes(size);
+        mProgress.setStyle(size);
         mCircleView.setImageDrawable(mProgress);
     }
 
@@ -376,8 +376,8 @@
 
     private void createProgressView() {
         mCircleView = new CircleImageView(getContext(), CIRCLE_BG_LIGHT);
-        mProgress = new MaterialProgressDrawable(getContext(), this);
-        mProgress.setBackgroundColor(CIRCLE_BG_LIGHT);
+        mProgress = new CircularProgressDrawable(getContext());
+        mProgress.setStyle(CircularProgressDrawable.DEFAULT);
         mCircleView.setImageDrawable(mProgress);
         mCircleView.setVisibility(View.GONE);
         addView(mCircleView);
@@ -520,7 +520,6 @@
      */
     public void setProgressBackgroundColorSchemeColor(@ColorInt int color) {
         mCircleView.setBackgroundColor(color);
-        mProgress.setBackgroundColor(color);
     }
 
     /**
@@ -899,7 +898,7 @@
     }
 
     private void moveSpinner(float overscrollTop) {
-        mProgress.showArrow(true);
+        mProgress.setArrowEnabled(true);
         float originalDragPercent = overscrollTop / mTotalDragDistance;
 
         float dragPercent = Math.min(1f, Math.abs(originalDragPercent));
@@ -976,7 +975,7 @@
                 };
             }
             animateOffsetToStartPosition(mCurrentTargetOffsetTop, listener);
-            mProgress.showArrow(false);
+            mProgress.setArrowEnabled(false);
         }
     }
 
diff --git a/core-ui/tests/AndroidManifest.xml b/core-ui/tests/AndroidManifest.xml
index ad8b493..c1b1a75 100644
--- a/core-ui/tests/AndroidManifest.xml
+++ b/core-ui/tests/AndroidManifest.xml
@@ -28,11 +28,14 @@
         android:theme="@style/TestActivityTheme">
         <activity android:name="android.support.v4.widget.ExploreByTouchHelperTestActivity"/>
 
+        <activity android:name="android.support.v4.widget.CircularProgressDrawableActivity"/>
+
         <activity android:name="android.support.v4.widget.SwipeRefreshLayoutActivity"/>
 
         <activity android:name="android.support.v4.view.ViewPagerWithTitleStripActivity"/>
 
         <activity android:name="android.support.v4.view.ViewPagerWithTabStripActivity"/>
+
     </application>
 
 </manifest>
diff --git a/core-ui/tests/java/android/support/v4/widget/CircularProgressDrawableActivity.java b/core-ui/tests/java/android/support/v4/widget/CircularProgressDrawableActivity.java
new file mode 100644
index 0000000..743cd7d
--- /dev/null
+++ b/core-ui/tests/java/android/support/v4/widget/CircularProgressDrawableActivity.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.support.v4.widget;
+
+import android.support.coreui.test.R;
+import android.support.v4.BaseTestActivity;
+
+public class CircularProgressDrawableActivity extends BaseTestActivity {
+    @Override
+    protected int getContentViewLayoutResId() {
+        return R.layout.circular_progress_drawable_activity;
+    }
+}
diff --git a/core-ui/tests/java/android/support/v4/widget/CircularProgressDrawableTest.java b/core-ui/tests/java/android/support/v4/widget/CircularProgressDrawableTest.java
new file mode 100644
index 0000000..cf31952
--- /dev/null
+++ b/core-ui/tests/java/android/support/v4/widget/CircularProgressDrawableTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.support.v4.widget;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.Matchers.anyFloat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.graphics.RectF;
+import android.support.test.filters.SmallTest;
+import android.support.v4.BaseInstrumentationTestCase;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+
+/**
+ * Tests for CircularProgressDrawable
+ */
+public class CircularProgressDrawableTest extends
+        BaseInstrumentationTestCase<CircularProgressDrawableActivity> {
+
+    public CircularProgressDrawableTest() {
+        super(CircularProgressDrawableActivity.class);
+    }
+
+    private CircularProgressDrawable mDrawableUnderTest;
+
+    @Mock
+    Canvas mMockCanvas;
+
+    @Before
+    public void setUp() {
+        Context context = mActivityTestRule.getActivity().getApplicationContext();
+        mMockCanvas = mock(Canvas.class);
+        mDrawableUnderTest = new CircularProgressDrawable(context);
+    }
+
+    @Test
+    @SmallTest
+    public void sizeIsSquareBasedOnSmallerEdgeWithNoCenterRadius() {
+        int width = 100;
+        int height = 50;
+        mDrawableUnderTest.setBounds(new Rect(0, 0, width, height));
+        mDrawableUnderTest.draw(mMockCanvas);
+
+        ArgumentCaptor<RectF> captor = ArgumentCaptor.forClass(RectF.class);
+        verify(mMockCanvas).drawArc(captor.capture(), anyFloat(), anyFloat(), anyBoolean(),
+                any(Paint.class));
+
+        assertTrue(captor.getValue().width() == captor.getValue().height());
+        assertTrue(captor.getValue().width() <= width);
+        assertTrue(captor.getValue().width() <= height);
+    }
+
+    @Test
+    @SmallTest
+    public void setCenterRadiusFixesSize() {
+        float radius = 10f;
+        float strokeWidth = 4f;
+        mDrawableUnderTest.setCenterRadius(radius);
+        mDrawableUnderTest.setStrokeWidth(strokeWidth);
+        mDrawableUnderTest.setBounds(new Rect(0, 0, 100, 50));
+        mDrawableUnderTest.draw(mMockCanvas);
+
+        ArgumentCaptor<RectF> boundsCaptor = ArgumentCaptor.forClass(RectF.class);
+        verify(mMockCanvas).drawArc(boundsCaptor.capture(), anyFloat(), anyFloat(), anyBoolean(),
+                any(Paint.class));
+
+        assertEquals((radius + strokeWidth / 2f) * 2, boundsCaptor.getValue().width(), 0.5);
+        assertEquals((radius + strokeWidth / 2f) * 2, boundsCaptor.getValue().height(), 0.5);
+    }
+}
diff --git a/core-ui/tests/res/layout/circular_progress_drawable_activity.xml b/core-ui/tests/res/layout/circular_progress_drawable_activity.xml
new file mode 100644
index 0000000..6bb6beb
--- /dev/null
+++ b/core-ui/tests/res/layout/circular_progress_drawable_activity.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2017 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:orientation="vertical">
+
+    <ImageView android:id="@+id/imageView" android:layout_width="match_parent"
+               android:layout_height="match_parent"/>
+</LinearLayout>
\ No newline at end of file
diff --git a/core-utils/build.gradle b/core-utils/build.gradle
index 7ac7cd3..380f1f6 100644
--- a/core-utils/build.gradle
+++ b/core-utils/build.gradle
@@ -12,7 +12,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
 }
 
diff --git a/design/build.gradle b/design/build.gradle
index ea256fa..d76642d 100644
--- a/design/build.gradle
+++ b/design/build.gradle
@@ -17,9 +17,9 @@
         exclude group: 'com.android.support'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
     androidTestCompile project(':support-testutils')
+    androidTestCompile libs.multidex
 
     testCompile libs.junit
     testCompile ("$libs.test_runner") {
@@ -32,6 +32,7 @@
         minSdkVersion 14
         // This disables the builds tools automatic vector -> PNG generation
         generatedDensities = []
+        multiDexEnabled true
     }
 
     sourceSets {
diff --git a/design/tests/AndroidManifest.xml b/design/tests/AndroidManifest.xml
index c4673b3..d5dbf91 100755
--- a/design/tests/AndroidManifest.xml
+++ b/design/tests/AndroidManifest.xml
@@ -19,6 +19,7 @@
     <uses-sdk android:targetSdkVersion="${target-sdk-version}"/>
 
     <application
+        android:name="android.support.multidex.MultiDexApplication"
         android:supportsRtl="true"
         android:theme="@style/Theme.Design">
 
diff --git a/dynamic-animation/build.gradle b/dynamic-animation/build.gradle
index a84e872..49cfbfc 100644
--- a/dynamic-animation/build.gradle
+++ b/dynamic-animation/build.gradle
@@ -11,7 +11,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
 }
 
diff --git a/dynamic-animation/tests/src/android/support/dynamicanimation/tests/SpringTests.java b/dynamic-animation/tests/src/android/support/dynamicanimation/tests/SpringTests.java
index eb4eb5f..1e891eb 100644
--- a/dynamic-animation/tests/src/android/support/dynamicanimation/tests/SpringTests.java
+++ b/dynamic-animation/tests/src/android/support/dynamicanimation/tests/SpringTests.java
@@ -641,8 +641,6 @@
             }
         });
 
-        View mockView = mock(View.class);
-
         final SpringAnimation[] anims = new SpringAnimation[properties.length];
         final DynamicAnimation.OnAnimationUpdateListener[] mockListeners =
                 new DynamicAnimation.OnAnimationUpdateListener[properties.length];
diff --git a/emoji/appcompat/build.gradle b/emoji/appcompat/build.gradle
index 0a28690..42cba1e 100644
--- a/emoji/appcompat/build.gradle
+++ b/emoji/appcompat/build.gradle
@@ -29,7 +29,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
 }
 
diff --git a/emoji/core/build.gradle b/emoji/core/build.gradle
index 1488c0e..c9f29dc 100644
--- a/emoji/core/build.gradle
+++ b/emoji/core/build.gradle
@@ -17,9 +17,8 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(path: ':support-testutils')
+    androidTestCompile project(':support-testutils')
 }
 
 android {
diff --git a/emoji/core/src/android/support/text/emoji/widget/EmojiInputConnection.java b/emoji/core/src/android/support/text/emoji/widget/EmojiInputConnection.java
index e12a0bb..6232c52 100644
--- a/emoji/core/src/android/support/text/emoji/widget/EmojiInputConnection.java
+++ b/emoji/core/src/android/support/text/emoji/widget/EmojiInputConnection.java
@@ -53,7 +53,7 @@
     @Override
     public boolean deleteSurroundingText(final int beforeLength, final int afterLength) {
         final boolean result = EmojiCompat.handleDeleteSurroundingText(this, getEditable(),
-                beforeLength, afterLength, false /* in code ponints */);
+                beforeLength, afterLength, false /*inCodePoints*/);
         return result || super.deleteSurroundingText(beforeLength, afterLength);
     }
 
@@ -61,7 +61,7 @@
     public boolean deleteSurroundingTextInCodePoints(final int beforeLength,
             final int afterLength) {
         final boolean result = EmojiCompat.handleDeleteSurroundingText(this, getEditable(),
-                beforeLength, afterLength, true  /* in code ponints */);
+                beforeLength, afterLength, true /*inCodePoints*/);
         return result || super.deleteSurroundingTextInCodePoints(beforeLength, afterLength);
     }
 
diff --git a/emoji/core/tests/java/android/support/text/emoji/EmojiCompatTest.java b/emoji/core/tests/java/android/support/text/emoji/EmojiCompatTest.java
index eb4ce2e..a656cb0 100644
--- a/emoji/core/tests/java/android/support/text/emoji/EmojiCompatTest.java
+++ b/emoji/core/tests/java/android/support/text/emoji/EmojiCompatTest.java
@@ -680,8 +680,8 @@
         verifyNoMoreInteractions(inputConnection);
 
         // try backwards delete 1 character
-        assertFalse(
-                EmojiCompat.handleDeleteSurroundingText(inputConnection, editable, 1, 0, false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(inputConnection, editable,
+                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
     }
 
     @Test
diff --git a/emoji/core/tests/java/android/support/text/emoji/InitCallbackTest.java b/emoji/core/tests/java/android/support/text/emoji/InitCallbackTest.java
index 10abb01..ec6291d 100644
--- a/emoji/core/tests/java/android/support/text/emoji/InitCallbackTest.java
+++ b/emoji/core/tests/java/android/support/text/emoji/InitCallbackTest.java
@@ -15,6 +15,7 @@
  */
 package android.support.text.emoji;
 
+import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
@@ -68,8 +69,8 @@
 
         InstrumentationRegistry.getInstrumentation().waitForIdleSync();
 
-        verify(initCallback1, times(1)).onFailed(any(Throwable.class));
-        verify(initCallback2, times(1)).onFailed(any(Throwable.class));
+        verify(initCallback1, times(1)).onFailed(nullable(Throwable.class));
+        verify(initCallback2, times(1)).onFailed(nullable(Throwable.class));
     }
 
     @Test
@@ -88,7 +89,7 @@
         emojiCompat.registerInitCallback(initCallback);
         InstrumentationRegistry.getInstrumentation().waitForIdleSync();
 
-        verify(initCallback, times(1)).onFailed(any(Throwable.class));
+        verify(initCallback, times(1)).onFailed(nullable(Throwable.class));
     }
 
     @Test
@@ -107,7 +108,7 @@
         emojiCompat.registerInitCallback(initCallback);
         InstrumentationRegistry.getInstrumentation().waitForIdleSync();
 
-        verify(initCallback, times(1)).onFailed(any(Throwable.class));
+        verify(initCallback, times(1)).onFailed(nullable(Throwable.class));
     }
 
     @Test
@@ -144,9 +145,9 @@
         InstrumentationRegistry.getInstrumentation().waitForIdleSync();
 
         verify(callbackUnregister, times(0)).onFailed(any(Throwable.class));
-        verify(callbackConfigUnregister, times(0)).onFailed(any(Throwable.class));
-        verify(callback, times(1)).onFailed(any(Throwable.class));
-        verify(callbackConfig, times(1)).onFailed(any(Throwable.class));
+        verify(callbackConfigUnregister, times(0)).onFailed(nullable(Throwable.class));
+        verify(callback, times(1)).onFailed(nullable(Throwable.class));
+        verify(callbackConfig, times(1)).onFailed(nullable(Throwable.class));
     }
 
     @Test
diff --git a/emoji/core/tests/java/android/support/text/emoji/SoftDeleteTest.java b/emoji/core/tests/java/android/support/text/emoji/SoftDeleteTest.java
index 5a56bda..1a25aa6 100644
--- a/emoji/core/tests/java/android/support/text/emoji/SoftDeleteTest.java
+++ b/emoji/core/tests/java/android/support/text/emoji/SoftDeleteTest.java
@@ -70,8 +70,8 @@
     @Test
     public void testDelete_doesNotDelete_whenSelectionIsUndefined() {
         // no selection is set on editable
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 1, 0,
-                false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji(EMOJI_WITH_ZWJ));
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -82,8 +82,8 @@
         Selection.setSelection(mEditable, mTestString.emojiStartIndex(),
                 mTestString.emojiEndIndex() + 1);
 
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 1, 0,
-                false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji(EMOJI_WITH_ZWJ));
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -93,7 +93,8 @@
     public void testDelete_withNullEditable() {
         Selection.setSelection(mEditable, mTestString.emojiEndIndex());
 
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, null, 1, 0, false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, null,
+                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji(EMOJI_WITH_ZWJ));
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -103,7 +104,8 @@
     public void testDelete_withNullInputConnection() {
         Selection.setSelection(mEditable, mTestString.emojiEndIndex());
 
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(null, mEditable, 1, 0, false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(null, mEditable,
+                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji(EMOJI_WITH_ZWJ));
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -114,8 +116,8 @@
     public void testDelete_withInvalidLength() {
         Selection.setSelection(mEditable, mTestString.emojiEndIndex());
 
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, -1, 0,
-                false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                -1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji(EMOJI_WITH_ZWJ));
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -126,8 +128,8 @@
     public void testDelete_withInvalidAfterLength() {
         Selection.setSelection(mEditable, mTestString.emojiEndIndex());
 
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 0, -1,
-                false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                0 /*beforeLength*/, -1 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji(EMOJI_WITH_ZWJ));
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -138,8 +140,8 @@
         Selection.setSelection(mEditable, mTestString.emojiEndIndex());
 
         // backwards delete 1 character, it will delete the emoji
-        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 1, 0,
-                false));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals(new TestString().withPrefix().withSuffix().toString(), mEditable.toString());
@@ -150,8 +152,8 @@
         Selection.setSelection(mEditable, mTestString.emojiEndIndex());
 
         // backwards delete 1 character, it will delete the emoji
-        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 1, 0,
-                true));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                1 /*beforeLength*/, 0 /*afterLength*/, true /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals(new TestString().withPrefix().withSuffix().toString(), mEditable.toString());
@@ -162,8 +164,8 @@
         Selection.setSelection(mEditable, mTestString.emojiStartIndex());
 
         // forward delete 1 character, it will dele the emoji.
-        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 0, 1,
-                false));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                0 /*beforeLength*/, 1 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals(new TestString().withPrefix().withSuffix().toString(), mEditable.toString());
@@ -174,8 +176,8 @@
         Selection.setSelection(mEditable, mTestString.emojiStartIndex());
 
         // forward delete 1 codepoint, it will delete the emoji.
-        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 0, 1,
-                false));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                0 /*beforeLength*/, 1 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals(new TestString().withPrefix().withSuffix().toString(), mEditable.toString());
@@ -186,8 +188,8 @@
         // make sure selection at 0 does not do something weird for backward delete
         Selection.setSelection(mEditable, 0);
 
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 1, 0,
-                false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                1 /*beforeLength*/, 0 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji());
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -198,8 +200,8 @@
         // make sure selection at end does not do something weird for forward delete
         Selection.setSelection(mEditable, mTestString.emojiEndIndex());
 
-        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 0, 1,
-                false));
+        assertFalse(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                0 /*beforeLength*/, 1 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, hasEmoji());
         assertEquals(mTestString.toString(), mEditable.toString());
@@ -216,8 +218,8 @@
         Selection.setSelection(mEditable, "abc".length() + EMOJI_FLAG.charCount() / 2);
 
         // delete 4 characters forward, 4 character backwards
-        assertTrue(
-                EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 4, 4, false));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                4 /*beforeLength*/, 4 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals("af", mEditable.toString());
@@ -234,8 +236,8 @@
         Selection.setSelection(mEditable, "abc".length() + EMOJI_FLAG.charCount() / 2);
 
         // delete 3 codepoints forward, 3 codepoints backwards
-        assertTrue(
-                EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 3, 3, true));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                3 /*beforeLength*/, 3 /*afterLength*/, true /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals("af", mEditable.toString());
@@ -251,8 +253,8 @@
         // set the selection in the middle of emoji
         Selection.setSelection(mEditable, "abc".length() + EMOJI_FLAG.charCount() / 2);
 
-        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 100, 100,
-                false));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                100 /*beforeLength*/, 100 /*afterLength*/, false /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals("", mEditable.toString());
@@ -268,8 +270,8 @@
         // set the selection in the middle of emoji
         Selection.setSelection(mEditable, "abc".length() + EMOJI_FLAG.charCount() / 2);
 
-        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable, 100, 100,
-                true));
+        assertTrue(EmojiCompat.handleDeleteSurroundingText(mInputConnection, mEditable,
+                100 /*beforeLength*/, 100 /*afterLength*/, true /*inCodePoints*/));
 
         assertThat(mEditable, not(hasEmoji()));
         assertEquals("", mEditable.toString());
diff --git a/emoji/core/tests/java/android/support/text/emoji/util/EmojiMatcher.java b/emoji/core/tests/java/android/support/text/emoji/util/EmojiMatcher.java
index 20f656d..8e871e0 100644
--- a/emoji/core/tests/java/android/support/text/emoji/util/EmojiMatcher.java
+++ b/emoji/core/tests/java/android/support/text/emoji/util/EmojiMatcher.java
@@ -21,10 +21,10 @@
 import android.text.Spanned;
 import android.text.TextUtils;
 
-import org.hamcrest.BaseMatcher;
 import org.hamcrest.Description;
 import org.hamcrest.Matcher;
 import org.hamcrest.TypeSafeMatcher;
+import org.mockito.ArgumentMatcher;
 
 /**
  * Utility class that includes matchers specific to emojis and EmojiSpans.
@@ -62,9 +62,9 @@
     }
 
     public static <T extends CharSequence> T sameCharSequence(final T expected) {
-        return argThat(new BaseMatcher<T>() {
+        return argThat(new ArgumentMatcher<T>() {
             @Override
-            public boolean matches(Object o) {
+            public boolean matches(T o) {
                 if (o instanceof CharSequence && expected.getClass() == o.getClass()) {
                     return TextUtils.equals(expected, (CharSequence) o);
                 }
@@ -72,8 +72,8 @@
             }
 
             @Override
-            public void describeTo(Description description) {
-                description.appendText("doesn't match " + expected);
+            public String toString() {
+                return "doesn't match " + expected;
             }
         });
     }
diff --git a/emoji/core/tests/java/android/support/text/emoji/widget/EmojiInputFilterTest.java b/emoji/core/tests/java/android/support/text/emoji/widget/EmojiInputFilterTest.java
index ca594cf..690a946 100644
--- a/emoji/core/tests/java/android/support/text/emoji/widget/EmojiInputFilterTest.java
+++ b/emoji/core/tests/java/android/support/text/emoji/widget/EmojiInputFilterTest.java
@@ -68,7 +68,7 @@
     @Test
     public void testFilter_withString() {
         final String testString = "abc";
-        when(mEmojiCompat.process(any(Spannable.class), anyInt(), anyInt()))
+        when(mEmojiCompat.process(any(CharSequence.class), anyInt(), anyInt()))
                 .thenReturn(new SpannableString(testString));
         final CharSequence result = mInputFilter.filter(testString, 0, 1, null, 0, 1);
 
diff --git a/fragment/build.gradle b/fragment/build.gradle
index f93d020..79921a2 100644
--- a/fragment/build.gradle
+++ b/fragment/build.gradle
@@ -13,7 +13,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
 }
 
diff --git a/fragment/tests/java/android/support/v4/app/CtsMockitoUtils.java b/fragment/tests/java/android/support/v4/app/CtsMockitoUtils.java
index c82b61d..1ccb87b 100644
--- a/fragment/tests/java/android/support/v4/app/CtsMockitoUtils.java
+++ b/fragment/tests/java/android/support/v4/app/CtsMockitoUtils.java
@@ -18,6 +18,7 @@
 import android.os.SystemClock;
 
 import org.mockito.exceptions.base.MockitoAssertionError;
+import org.mockito.internal.verification.VerificationModeFactory;
 import org.mockito.internal.verification.api.VerificationData;
 import org.mockito.invocation.Invocation;
 import org.mockito.verification.VerificationMode;
@@ -74,6 +75,11 @@
                     + data.getWanted().toString());
         }
 
+        @Override
+        public VerificationMode description(String description) {
+            return VerificationModeFactory.description(this, description);
+        }
+
         private void markAllInvocationsAsVerified(VerificationData data) {
             for (Invocation invocation : data.getAllInvocations()) {
                 invocation.markVerified();
diff --git a/media-compat/build.gradle b/media-compat/build.gradle
index edc51d7..9d28f80 100644
--- a/media-compat/build.gradle
+++ b/media-compat/build.gradle
@@ -11,9 +11,8 @@
     androidTestCompile(libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile(libs.mockito_core)
-    androidTestCompile(libs.dexmaker)
-    androidTestCompile(libs.dexmaker_mockito)
+    androidTestCompile libs.mockito_core
+    androidTestCompile libs.dexmaker_mockito
     androidTestCompile project(':support-testutils')
 }
 
diff --git a/transition/build.gradle b/transition/build.gradle
index 44d18d7..decde29 100644
--- a/transition/build.gradle
+++ b/transition/build.gradle
@@ -13,7 +13,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
 }
 
diff --git a/tv-provider/src/android/support/media/tv/TvContractCompat.java b/tv-provider/src/android/support/media/tv/TvContractCompat.java
index d108ade..5773061 100644
--- a/tv-provider/src/android/support/media/tv/TvContractCompat.java
+++ b/tv-provider/src/android/support/media/tv/TvContractCompat.java
@@ -556,6 +556,13 @@
     }
 
     /**
+     * Returns {@code true}, if {@code uri} is a recorded program URI.
+     */
+    public static boolean isRecordedProgramUri(Uri uri) {
+        return isTvUri(uri) && isTwoSegmentUriStartingWith(uri, PATH_RECORDED_PROGRAM);
+    }
+
+    /**
      * Requests to make a channel browsable.
      *
      * <p>Once called, the system will review the request and make the channel browsable based on
diff --git a/v13/build.gradle b/v13/build.gradle
index 261bb70..9c25738 100644
--- a/v13/build.gradle
+++ b/v13/build.gradle
@@ -12,7 +12,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
 }
 
diff --git a/v13/tests/java/android/support/v13/view/DragStartHelperTest.java b/v13/tests/java/android/support/v13/view/DragStartHelperTest.java
index c92de6a..993a4e5 100644
--- a/v13/tests/java/android/support/v13/view/DragStartHelperTest.java
+++ b/v13/tests/java/android/support/v13/view/DragStartHelperTest.java
@@ -44,7 +44,6 @@
 import android.view.View;
 import android.view.ViewConfiguration;
 
-import org.hamcrest.Description;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -135,7 +134,7 @@
                 action, buttonState, anchor, offsetX, offsetY));
     }
 
-    static class TouchPositionMatcher extends ArgumentMatcher<Point> {
+    static class TouchPositionMatcher implements ArgumentMatcher<Point> {
 
         private final Point mExpectedPosition;
 
@@ -148,13 +147,13 @@
         }
 
         @Override
-        public boolean matches(Object actual) {
+        public boolean matches(Point actual) {
             return mExpectedPosition.equals(actual);
         }
 
         @Override
-        public void describeTo(Description description) {
-            description.appendText("TouchPositionMatcher: " + mExpectedPosition);
+        public String toString() {
+            return "TouchPositionMatcher: " + mExpectedPosition;
         }
     }
 
diff --git a/v17/leanback/build.gradle b/v17/leanback/build.gradle
index d0c1832..8c02cc4 100644
--- a/v17/leanback/build.gradle
+++ b/v17/leanback/build.gradle
@@ -15,13 +15,14 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
+    androidTestCompile libs.multidex
 }
 
 android {
     defaultConfig {
         minSdkVersion 17
+        multiDexEnabled true
     }
 
     sourceSets {
diff --git a/v17/leanback/tests/AndroidManifest.xml b/v17/leanback/tests/AndroidManifest.xml
index b21246e..d719485 100644
--- a/v17/leanback/tests/AndroidManifest.xml
+++ b/v17/leanback/tests/AndroidManifest.xml
@@ -18,6 +18,7 @@
     <uses-sdk android:targetSdkVersion="${target-sdk-version}"/>
 
     <application
+        android:name="android.support.multidex.MultiDexApplication"
         android:supportsRtl="true">
         <activity android:name="android.support.v17.leanback.widget.GridActivity"
                   android:exported="true"/>
diff --git a/v7/appcompat/build.gradle b/v7/appcompat/build.gradle
index 706d6d3..f604aa3 100644
--- a/v7/appcompat/build.gradle
+++ b/v7/appcompat/build.gradle
@@ -14,7 +14,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
     androidTestCompile project(':support-testutils')
 }
diff --git a/v7/appcompat/tests/src/android/support/v7/widget/ListPopupWindowTest.java b/v7/appcompat/tests/src/android/support/v7/widget/ListPopupWindowTest.java
index 3b01e4b..7ef6a85 100644
--- a/v7/appcompat/tests/src/android/support/v7/widget/ListPopupWindowTest.java
+++ b/v7/appcompat/tests/src/android/support/v7/widget/ListPopupWindowTest.java
@@ -29,6 +29,7 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.eq;
@@ -266,7 +267,7 @@
 
         // Verify that our menu item click listener hasn't been called yet
         verify(popupBuilder.mOnItemClickListener, never()).onItemClick(
-                any(AdapterView.class), any(View.class), any(int.class), any(int.class));
+                any(AdapterView.class), any(View.class), any(int.class), anyLong());
 
         final View mainDecorView = mActivityTestRule.getActivity().getWindow().getDecorView();
         onView(withText("Charlie"))
@@ -276,7 +277,7 @@
         // position. Note that we use any() for other parameters, as we don't want to tie ourselves
         // to the specific implementation details of how ListPopupWindow displays its content.
         verify(popupBuilder.mOnItemClickListener, times(1)).onItemClick(
-                any(AdapterView.class), any(View.class), eq(2), any(int.class));
+                any(AdapterView.class), any(View.class), eq(2), anyLong());
 
         // Our item click listener also dismisses the popup
         assertFalse("Popup window not showing after click", mListPopupWindow.isShowing());
@@ -293,7 +294,7 @@
 
         // Verify that our menu item click listener hasn't been called yet
         verify(popupBuilder.mOnItemClickListener, never()).onItemClick(
-                any(AdapterView.class), any(View.class), any(int.class), any(int.class));
+                any(AdapterView.class), any(View.class), any(int.class), anyLong());
 
         mActivityTestRule.runOnUiThread(new Runnable() {
             @Override
@@ -306,7 +307,7 @@
         // position. Note that we use any() for other parameters, as we don't want to tie ourselves
         // to the specific implementation details of how ListPopupWindow displays its content.
         verify(popupBuilder.mOnItemClickListener, times(1)).onItemClick(
-                any(AdapterView.class), any(View.class), eq(1), any(int.class));
+                any(AdapterView.class), any(View.class), eq(1), anyLong());
         // Our item click listener also dismisses the popup
         assertFalse("Popup window not showing after click", mListPopupWindow.isShowing());
     }
diff --git a/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceDataStoreTest.java b/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceDataStoreTest.java
index 5c0923f..8f9929e 100644
--- a/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceDataStoreTest.java
+++ b/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceDataStoreTest.java
@@ -22,6 +22,7 @@
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.AdditionalMatchers.or;
+import static org.mockito.ArgumentMatchers.nullable;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyFloat;
@@ -212,7 +213,7 @@
     private void putStringTestCommon() {
         mPreference.putString(TEST_STR);
 
-        verify(mDataStore, atLeast(0)).getString(eq(KEY), anyString());
+        verify(mDataStore, atLeast(0)).getString(eq(KEY), nullable(String.class));
         verify(mDataStore, atLeastOnce()).putString(eq(KEY), anyString());
         verifyNoMoreInteractions(mDataStore);
 
diff --git a/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceIconSpaceTest.java b/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceIconSpaceTest.java
index a891d36..c03f411 100644
--- a/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceIconSpaceTest.java
+++ b/v7/preference/tests/src/android/support/v7/preference/tests/PreferenceIconSpaceTest.java
@@ -24,7 +24,6 @@
 import android.support.test.InstrumentationRegistry;
 import android.support.test.annotation.UiThreadTest;
 import android.support.test.filters.LargeTest;
-import android.support.test.filters.SmallTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v7.preference.AndroidResources;
 import android.support.v7.preference.Preference;
@@ -40,7 +39,7 @@
 import org.mockito.MockitoAnnotations;
 
 @RunWith(AndroidJUnit4.class)
-@SmallTest
+@LargeTest
 public class PreferenceIconSpaceTest {
 
     private Preference mPreference;
diff --git a/v7/recyclerview/build.gradle b/v7/recyclerview/build.gradle
index 274c91e..2c8bef3 100644
--- a/v7/recyclerview/build.gradle
+++ b/v7/recyclerview/build.gradle
@@ -14,7 +14,6 @@
     }
     androidTestCompile libs.junit
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
     androidTestCompile project(':support-testutils')
 
diff --git a/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewCacheTest.java b/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewCacheTest.java
index 1006e1b..620953a 100644
--- a/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewCacheTest.java
+++ b/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewCacheTest.java
@@ -44,12 +44,11 @@
 import android.view.ViewGroup;
 import android.widget.FrameLayout;
 
-import org.hamcrest.BaseMatcher;
-import org.hamcrest.Description;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentMatcher;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
@@ -687,15 +686,11 @@
 
         verify(mockAdapter, times(2)).onCreateViewHolder(any(ViewGroup.class), anyInt());
         verify(mockAdapter, times(2)).onBindViewHolder(
-                argThat(new BaseMatcher<RecyclerView.ViewHolder>() {
+                argThat(new ArgumentMatcher<RecyclerView.ViewHolder>() {
                     @Override
-                    public boolean matches(Object item) {
-                        RecyclerView.ViewHolder holder = (RecyclerView.ViewHolder) item;
+                    public boolean matches(RecyclerView.ViewHolder holder) {
                         return holder.itemView == holder.mNestedRecyclerView.get();
                     }
-
-                    @Override
-                    public void describeTo(Description description) { }
                 }),
                 anyInt(),
                 any(List.class));
diff --git a/wear/build.gradle b/wear/build.gradle
index 07e579e..6ceff5b 100644
--- a/wear/build.gradle
+++ b/wear/build.gradle
@@ -13,7 +13,6 @@
         exclude module: 'support-annotations'
     }
     androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker
     androidTestCompile libs.dexmaker_mockito
 }