diff --git a/annotations/build.gradle b/annotations/build.gradle
index 6071820..195a0e7 100644
--- a/annotations/build.gradle
+++ b/annotations/build.gradle
@@ -1,5 +1,4 @@
 apply plugin: 'java'
-archivesBaseName = 'support-annotations'
 
 sourceSets {
     main.java.srcDir 'src'
diff --git a/buildSrc/init.gradle b/buildSrc/init.gradle
index a483337..c3dc6a4 100644
--- a/buildSrc/init.gradle
+++ b/buildSrc/init.gradle
@@ -92,7 +92,7 @@
 
 def setupRepoOutAndBuildNumber() {
     ext.supportRepoOut = ''
-    ext.buildNumber = Integer.toString(ext.extraVersion)
+    ext.buildNumber = "0"
 
     /*
      * With the build server you are given two env variables.
@@ -163,7 +163,6 @@
             return
         }
 
-        // Current SDK is set in studioCompat.gradle.
         project.ext.currentSdk = gradle.ext.currentSdk
         apply plugin: 'maven'
 
@@ -199,7 +198,7 @@
                             exclude "**/R\$*.class"
                             exclude "**/BuildConfig.class"
                             destinationDir file(project.distDir)
-                            archiveName "${project.archivesBaseName}-${v.baseName}-allclasses.jar"
+                            archiveName "${project.name}-${v.baseName}-allclasses.jar"
                         }
 
                         def collectJacocoAntPackages = project.tasks.create(
@@ -261,7 +260,6 @@
                     // Make the mainupload depend on this one.
                     mainUpload.dependsOn uploadTask
                 }
-
             }
         }
 
@@ -313,15 +311,6 @@
             }
         }
 
-        project.afterEvaluate {
-            // The archivesBaseName isn't available initially, so set it now
-            def createZipTask = project.tasks.findByName("createSeparateZip")
-            if (createZipTask != null) {
-                createZipTask.appendix = archivesBaseName
-                createZipTask.from versionDir()
-            }
-        }
-
         project.afterEvaluate { p ->
             // remove dependency on the test so that we still get coverage even if some tests fail
             p.tasks.findAll { it instanceof JacocoReportTask }.each { task ->
diff --git a/buildSrc/release.gradle b/buildSrc/release.gradle
index 5126d47..5033454 100644
--- a/buildSrc/release.gradle
+++ b/buildSrc/release.gradle
@@ -13,34 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import com.google.common.base.Charsets
-import com.google.common.io.Files
-import com.google.common.hash.HashCode
-import com.google.common.hash.HashFunction
-import com.google.common.hash.Hashing
-import java.nio.charset.Charset
 
-// Main task called by the build server.
-task(createArchive)
-
-// upload anchor for subprojects to upload their artifacts
-// to the local repo.
+// upload anchor for subprojects to upload their artifacts to the local repo.
 task(mainUpload)
 
-rootProject.ext.repoWithHistoryOut = new File(buildDir, 'support_repo_with_history')
-
-// repository creation task
-task createRepository(type: Zip, dependsOn: mainUpload) {
-    from rootProject.ext.supportRepoOut
-    from "${repos.prebuiltsRoot}/maven_repo/android"
-    // if there are duplicates, pick the first one.
-    duplicatesStrategy "EXCLUDE"
-    destinationDir project.ext.distDir
-    into 'm2repository'
-    baseName = String.format("sdk-repo-linux-m2repository-%s", project.ext.buildNumber)
-}
-
-task createTopOfTreeRepository(type : Zip) {
+task createArchive(type : Zip) {
     description "Creates a maven repository that includes just the libraries compiled in this" +
             " project, without any history from prebuilts."
     from rootProject.ext.supportRepoOut
@@ -50,11 +27,8 @@
     dependsOn mainUpload
 }
 
-createArchive.dependsOn createRepository
-createRepository.dependsOn createTopOfTreeRepository
-
-// anchor for prepare repo. This is post unzip + sourceProp.
-task nukeRepoOut() {
+// anchor for prepare repo. This is post unzip.
+task prepareRepo() {
     description "This task clears the repo folder to ensure that we run a fresh build every" +
             " time we create arhives. Otherwise, snapshots will accumulate in the builds folder."
     doFirst {
@@ -62,64 +36,3 @@
         rootProject.ext.supportRepoOut.mkdirs()
     }
 }
-
-task(prepareRepo)
-
-task(createXml).doLast({
-    def repoArchive = createRepository.archivePath
-    def repoArchiveName = createRepository.archiveName
-    def size = repoArchive.length()
-    def sha1 = getSha1(repoArchive)
-
-    def xml =
-            "<sdk:sdk-addon xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:sdk=\"http://schemas.android.com/sdk/android/addon/6\">\n\
-  <sdk:extra>\n\
-    <sdk:revision>\n\
-      <sdk:major>${project.ext.extraVersion}</sdk:major>\n\
-    </sdk:revision>\n\
-    <sdk:vendor-display>Android</sdk:vendor-display>\n\
-    <sdk:vendor-id>android</sdk:vendor-id>\n\
-    <sdk:name-display>Local Maven repository for Support Libraries</sdk:name-display>\n\
-    <sdk:path>m2repository</sdk:path>\n\
-    <sdk:archives>\n\
-      <sdk:archive>\n\
-       <sdk:size>${size}</sdk:size>\n\
-       <sdk:checksum type=\"sha1\">${sha1}</sdk:checksum>\n\
-       <sdk:url>${repoArchiveName}</sdk:url>\n\
-      </sdk:archive>\n\
-    </sdk:archives>\n\
-  </sdk:extra>\n\
-</sdk:sdk-addon>"
-
-    Files.write(xml, new File(project.ext.distDir, 'repo-extras.xml'), Charsets.UTF_8)
-})
-createArchive.dependsOn createXml
-createXml.dependsOn createRepository
-
-task(createSourceProp).doLast({
-    def sourceProp =
-            "Extra.VendorDisplay=Android\n\
-Extra.Path=m2repository\n\
-Archive.Arch=ANY\n\
-Extra.NameDisplay=Android Support Repository\n\
-Archive.Os=ANY\n\
-Pkg.Desc=Local Maven repository for Support Libraries\n\
-Pkg.Revision=${project.ext.extraVersion}.0.0\n\
-Extra.VendorId=android"
-
-    Files.write(sourceProp, new File(project.ext.supportRepoOut, 'source.properties'), Charsets.UTF_8)
-})
-createSourceProp.dependsOn nukeRepoOut
-prepareRepo.dependsOn createSourceProp
-
-/**
- * Generates SHA1 hash for the specified file's absolute path.
- *
- * @param inputFile file to hash
- * @return SHA1 hash
- */
-String getSha1(File inputFile) {
-    HashFunction hashFunction = Hashing.sha1()
-    HashCode hashCode = hashFunction.hashString(inputFile.getAbsolutePath(), Charset.forName("UTF-8"))
-    return hashCode.toString()
-}
diff --git a/buildSrc/versions.gradle b/buildSrc/versions.gradle
index 5814016..d017e79 100644
--- a/buildSrc/versions.gradle
+++ b/buildSrc/versions.gradle
@@ -13,15 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Prevent the Android Gradle plug-in from automatically downloading SDK dependencies.
-ext['android.builder.sdkDownload'] = false
 
 // Version code of the support library components.
 ext.supportVersion = "26.0.0-SNAPSHOT"
 
-// This number gets incremented for each public release.
-ext.extraVersion = 46
-
 // Enforce the use of prebuilt dependencies in all sub-projects. This is
 // required for the doclava dependency.
 ext.usePrebuilts = "true"
diff --git a/compat/build.gradle b/compat/build.gradle
index 7724a29..7e9468b 100644
--- a/compat/build.gradle
+++ b/compat/build.gradle
@@ -1,18 +1,17 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-compat'
 
 dependencies {
-    compile project(':support-annotations')
+    api project(':support-annotations')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(':support-testutils')
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation project(':support-testutils')
 }
 
 android {
diff --git a/compat/java/android/support/v4/view/accessibility/AccessibilityNodeInfoCompat.java b/compat/java/android/support/v4/view/accessibility/AccessibilityNodeInfoCompat.java
index bed729a..df1e18d 100644
--- a/compat/java/android/support/v4/view/accessibility/AccessibilityNodeInfoCompat.java
+++ b/compat/java/android/support/v4/view/accessibility/AccessibilityNodeInfoCompat.java
@@ -23,7 +23,6 @@
 import android.os.Bundle;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
-import android.support.annotation.RequiresApi;
 import android.support.annotation.RestrictTo;
 import android.support.v4.accessibilityservice.AccessibilityServiceInfoCompat;
 import android.support.v4.view.ViewCompat;
@@ -347,7 +346,8 @@
          * @see View#requestRectangleOnScreen(Rect)
          */
         public static final AccessibilityActionCompat ACTION_SHOW_ON_SCREEN =
-                new AccessibilityActionCompat(IMPL.getActionShowOnScreen());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 23
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_SHOW_ON_SCREEN : null);
 
         /**
          * Action that scrolls the node to make the specified collection
@@ -362,37 +362,44 @@
          * @see AccessibilityNodeInfoCompat#getCollectionInfo()
          */
         public static final AccessibilityActionCompat ACTION_SCROLL_TO_POSITION =
-                new AccessibilityActionCompat(IMPL.getActionScrollToPosition());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 23
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_TO_POSITION
+                        : null);
 
         /**
          * Action to scroll the node content up.
          */
         public static final AccessibilityActionCompat ACTION_SCROLL_UP =
-                new AccessibilityActionCompat(IMPL.getActionScrollUp());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 23
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_UP : null);
 
         /**
          * Action to scroll the node content left.
          */
         public static final AccessibilityActionCompat ACTION_SCROLL_LEFT =
-                new AccessibilityActionCompat(IMPL.getActionScrollLeft());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 23
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_LEFT : null);
 
         /**
          * Action to scroll the node content down.
          */
         public static final AccessibilityActionCompat ACTION_SCROLL_DOWN =
-                new AccessibilityActionCompat(IMPL.getActionScrollDown());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 23
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_DOWN : null);
 
         /**
          * Action to scroll the node content right.
          */
         public static final AccessibilityActionCompat ACTION_SCROLL_RIGHT =
-                new AccessibilityActionCompat(IMPL.getActionScrollRight());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 23
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_RIGHT : null);
 
         /**
          * Action that context clicks the node.
          */
         public static final AccessibilityActionCompat ACTION_CONTEXT_CLICK =
-                new AccessibilityActionCompat(IMPL.getActionContextClick());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 23
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_CONTEXT_CLICK : null);
 
         /**
          * Action that sets progress between {@link  RangeInfoCompat#getMin() RangeInfo.getMin()} and
@@ -405,7 +412,8 @@
          * @see RangeInfoCompat
          */
         public static final AccessibilityActionCompat ACTION_SET_PROGRESS =
-                new AccessibilityActionCompat(IMPL.getActionSetProgress());
+                new AccessibilityActionCompat(Build.VERSION.SDK_INT >= 24
+                        ? AccessibilityNodeInfo.AccessibilityAction.ACTION_SET_PROGRESS : null);
 
         final Object mAction;
 
@@ -416,7 +424,8 @@
          * @param label The action label.
          */
         public AccessibilityActionCompat(int actionId, CharSequence label) {
-            this(IMPL.newAccessibilityAction(actionId, label));
+            this(Build.VERSION.SDK_INT >= 21
+                    ? new AccessibilityNodeInfo.AccessibilityAction(actionId, label) : null);
         }
 
         AccessibilityActionCompat(Object action) {
@@ -429,7 +438,11 @@
          * @return The action id.
          */
         public int getId() {
-            return IMPL.getAccessibilityActionId(mAction);
+            if (Build.VERSION.SDK_INT >= 21) {
+                return ((AccessibilityNodeInfo.AccessibilityAction) mAction).getId();
+            } else {
+                return 0;
+            }
         }
 
         /**
@@ -439,7 +452,11 @@
          * @return The label.
          */
         public CharSequence getLabel() {
-            return IMPL.getAccessibilityActionLabel(mAction);
+            if (Build.VERSION.SDK_INT >= 21) {
+                return ((AccessibilityNodeInfo.AccessibilityAction) mAction).getLabel();
+            } else {
+                return null;
+            }
         }
     }
 
@@ -483,8 +500,15 @@
          */
         public static CollectionInfoCompat obtain(int rowCount, int columnCount,
                 boolean hierarchical, int selectionMode) {
-            return new CollectionInfoCompat(IMPL.obtainCollectionInfo(rowCount, columnCount,
-                    hierarchical, selectionMode));
+            if (Build.VERSION.SDK_INT >= 21) {
+                return new CollectionInfoCompat(AccessibilityNodeInfo.CollectionInfo.obtain(
+                        rowCount, columnCount, hierarchical, selectionMode));
+            } else if (Build.VERSION.SDK_INT >= 19) {
+                return new CollectionInfoCompat(AccessibilityNodeInfo.CollectionInfo.obtain(
+                        rowCount, columnCount, hierarchical));
+            } else {
+                return new CollectionInfoCompat(null);
+            }
         }
 
         /**
@@ -498,8 +522,12 @@
          */
         public static CollectionInfoCompat obtain(int rowCount, int columnCount,
                 boolean hierarchical) {
-            return new CollectionInfoCompat(IMPL.obtainCollectionInfo(rowCount, columnCount,
-                    hierarchical));
+            if (Build.VERSION.SDK_INT >= 19) {
+                return new CollectionInfoCompat(AccessibilityNodeInfo.CollectionInfo.obtain(
+                        rowCount, columnCount, hierarchical));
+            } else {
+                return new CollectionInfoCompat(null);
+            }
         }
 
         CollectionInfoCompat(Object info) {
@@ -512,7 +540,11 @@
          * @return The column count.
          */
         public int getColumnCount() {
-            return IMPL.getCollectionInfoColumnCount(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionInfo) mInfo).getColumnCount();
+            } else {
+                return 0;
+            }
         }
 
         /**
@@ -521,7 +553,11 @@
          * @return The row count.
          */
         public int getRowCount() {
-            return IMPL.getCollectionInfoRowCount(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionInfo) mInfo).getRowCount();
+            } else {
+                return 0;
+            }
         }
 
         /**
@@ -530,7 +566,11 @@
          * @return Whether the collection is hierarchical.
          */
         public boolean isHierarchical() {
-            return IMPL.isCollectionInfoHierarchical(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionInfo) mInfo).isHierarchical();
+            } else {
+                return false;
+            }
         }
 
         /**
@@ -544,7 +584,11 @@
          *         </ul>
          */
         public int getSelectionMode() {
-            return IMPL.getCollectionInfoSelectionMode(mInfo);
+            if (Build.VERSION.SDK_INT >= 21) {
+                return ((AccessibilityNodeInfo.CollectionInfo) mInfo).getSelectionMode();
+            } else {
+                return 0;
+            }
         }
     }
 
@@ -575,8 +619,15 @@
          */
         public static CollectionItemInfoCompat obtain(int rowIndex, int rowSpan,
                 int columnIndex, int columnSpan, boolean heading, boolean selected) {
-            return new CollectionItemInfoCompat(IMPL.obtainCollectionItemInfo(rowIndex, rowSpan,
-                    columnIndex, columnSpan, heading, selected));
+            if (Build.VERSION.SDK_INT >= 21) {
+                return new CollectionItemInfoCompat(AccessibilityNodeInfo.CollectionItemInfo.obtain(
+                        rowIndex, rowSpan, columnIndex, columnSpan, heading, selected));
+            } else if (Build.VERSION.SDK_INT >= 19) {
+                return new CollectionItemInfoCompat(AccessibilityNodeInfo.CollectionItemInfo.obtain(
+                        rowIndex, rowSpan, columnIndex, columnSpan, heading));
+            } else {
+                return new CollectionItemInfoCompat(null);
+            }
         }
 
         /**
@@ -591,8 +642,12 @@
          */
         public static CollectionItemInfoCompat obtain(int rowIndex, int rowSpan,
                 int columnIndex, int columnSpan, boolean heading) {
-            return new CollectionItemInfoCompat(IMPL.obtainCollectionItemInfo(rowIndex, rowSpan,
-                    columnIndex, columnSpan, heading));
+            if (Build.VERSION.SDK_INT >= 19) {
+                return new CollectionItemInfoCompat(AccessibilityNodeInfo.CollectionItemInfo.obtain(
+                        rowIndex, rowSpan, columnIndex, columnSpan, heading));
+            } else {
+                return new CollectionItemInfoCompat(null);
+            }
         }
 
         CollectionItemInfoCompat(Object info) {
@@ -605,7 +660,11 @@
          * @return The column index.
          */
         public int getColumnIndex() {
-            return IMPL.getCollectionItemColumnIndex(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionItemInfo) mInfo).getColumnIndex();
+            } else {
+                return 0;
+            }
         }
 
         /**
@@ -614,7 +673,11 @@
          * @return The column span.
          */
         public int getColumnSpan() {
-            return IMPL.getCollectionItemColumnSpan(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionItemInfo) mInfo).getColumnSpan();
+            } else {
+                return 0;
+            }
         }
 
         /**
@@ -623,7 +686,11 @@
          * @return The row index.
          */
         public int getRowIndex() {
-            return IMPL.getCollectionItemRowIndex(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionItemInfo) mInfo).getRowIndex();
+            } else {
+                return 0;
+            }
         }
 
         /**
@@ -632,7 +699,11 @@
          * @return The row span.
          */
         public int getRowSpan() {
-            return IMPL.getCollectionItemRowSpan(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionItemInfo) mInfo).getRowSpan();
+            } else {
+                return 0;
+            }
         }
 
         /**
@@ -642,7 +713,11 @@
          * @return If the item is a heading.
          */
         public boolean isHeading() {
-            return IMPL.isCollectionItemHeading(mInfo);
+            if (Build.VERSION.SDK_INT >= 19) {
+                return ((AccessibilityNodeInfo.CollectionItemInfo) mInfo).isHeading();
+            } else {
+                return false;
+            }
         }
 
         /**
@@ -651,7 +726,11 @@
          * @return If the item is selected.
          */
         public boolean isSelected() {
-            return IMPL.isCollectionItemSelected(mInfo);
+            if (Build.VERSION.SDK_INT >= 21) {
+                return ((AccessibilityNodeInfo.CollectionItemInfo) mInfo).isSelected();
+            } else {
+                return false;
+            }
         }
     }
 
@@ -676,7 +755,12 @@
          * @return The instance
          */
         public static RangeInfoCompat obtain(int type, float min, float max, float current) {
-            return new RangeInfoCompat(IMPL.obtainRangeInfo(type, min, max, current));
+            if (Build.VERSION.SDK_INT >= 19) {
+                return new RangeInfoCompat(
+                        AccessibilityNodeInfo.RangeInfo.obtain(type, min, max, current));
+            } else {
+                return new RangeInfoCompat(null);
+            }
         }
 
         final Object mInfo;
@@ -726,938 +810,8 @@
         }
     }
 
-    static class AccessibilityNodeInfoBaseImpl {
-        public Object newAccessibilityAction(int actionId, CharSequence label) {
-            return null;
-        }
-
-        public AccessibilityNodeInfo obtain(View root, int virtualDescendantId) {
-            return null;
-        }
-
-        public void addAction(AccessibilityNodeInfo info, Object action) {
-        }
-
-        public boolean removeAction(AccessibilityNodeInfo info, Object action) {
-            return false;
-        }
-
-        public int getAccessibilityActionId(Object action) {
-            return 0;
-        }
-
-        public CharSequence getAccessibilityActionLabel(Object action) {
-            return null;
-        }
-
-        public void addChild(AccessibilityNodeInfo info, View child, int virtualDescendantId) {
-        }
-
-        public boolean removeChild(AccessibilityNodeInfo info, View child) {
-            return false;
-        }
-
-        public boolean removeChild(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-            return false;
-        }
-
-        public boolean isVisibleToUser(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public boolean isAccessibilityFocused(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public boolean performAction(AccessibilityNodeInfo info, int action, Bundle arguments) {
-            return false;
-        }
-
-        public void setMovementGranularities(AccessibilityNodeInfo info, int granularities) {
-        }
-
-        public int getMovementGranularities(AccessibilityNodeInfo info) {
-            return 0;
-        }
-
-        public void setVisibleToUser(AccessibilityNodeInfo info, boolean visibleToUser) {
-        }
-
-        public void setAccessibilityFocused(AccessibilityNodeInfo info, boolean focused) {
-        }
-
-        public void setSource(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-        }
-
-        public Object findFocus(AccessibilityNodeInfo info, int focus) {
-            return null;
-        }
-
-        public Object focusSearch(AccessibilityNodeInfo info, int direction) {
-            return null;
-        }
-
-        public void setParent(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-        }
-
-        public String getViewIdResourceName(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setViewIdResourceName(AccessibilityNodeInfo info, String viewId) {
-        }
-
-        public int getLiveRegion(AccessibilityNodeInfo info) {
-            return ViewCompat.ACCESSIBILITY_LIVE_REGION_NONE;
-        }
-
-        public void setLiveRegion(AccessibilityNodeInfo info, int mode) {
-            // No-op
-        }
-
-        public Object getCollectionInfo(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setCollectionInfo(AccessibilityNodeInfo info, Object collectionInfo) {
-        }
-
-        public Object getCollectionItemInfo(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setCollectionItemInfo(AccessibilityNodeInfo info, Object collectionItemInfo) {
-        }
-
-        public Object getRangeInfo(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setRangeInfo(AccessibilityNodeInfo info, Object rangeInfo) {
-        }
-
-        public List<Object> getActionList(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public Object obtainCollectionInfo(int rowCount, int columnCount, boolean hierarchical,
-                int selectionMode) {
-            return null;
-        }
-
-        public Object obtainCollectionInfo(int rowCount, int columnCount, boolean hierarchical) {
-            return null;
-        }
-
-        public int getCollectionInfoColumnCount(Object info) {
-            return 0;
-        }
-
-        public int getCollectionInfoRowCount(Object info) {
-            return 0;
-        }
-
-        public boolean isCollectionInfoHierarchical(Object info) {
-            return false;
-        }
-
-        public Object obtainCollectionItemInfo(int rowIndex, int rowSpan, int columnIndex,
-                int columnSpan, boolean heading, boolean selected) {
-            return null;
-        }
-
-        public Object obtainCollectionItemInfo(int rowIndex, int rowSpan, int columnIndex,
-                int columnSpan, boolean heading) {
-            return null;
-        }
-
-        public int getCollectionItemColumnIndex(Object info) {
-            return 0;
-        }
-
-        public int getCollectionItemColumnSpan(Object info) {
-            return 0;
-        }
-
-        public int getCollectionItemRowIndex(Object info) {
-            return 0;
-        }
-
-        public int getCollectionItemRowSpan(Object info) {
-            return 0;
-        }
-
-        public boolean isCollectionItemHeading(Object info) {
-            return false;
-        }
-
-        public boolean isCollectionItemSelected(Object info) {
-            return false;
-        }
-
-        public Object obtainRangeInfo(int type, float min, float max, float current) {
-            return null;
-        }
-
-        public Object getTraversalBefore(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setTraversalBefore(AccessibilityNodeInfo info, View view) {
-        }
-
-        public void setTraversalBefore(AccessibilityNodeInfo info, View root,
-                int virtualDescendantId) {
-        }
-
-        public Object getTraversalAfter(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setTraversalAfter(AccessibilityNodeInfo info, View view) {
-        }
-
-        public void setTraversalAfter(AccessibilityNodeInfo info, View root,
-                int virtualDescendantId) {
-        }
-
-        public void setContentInvalid(AccessibilityNodeInfo info, boolean contentInvalid) {
-        }
-
-        public boolean isContentInvalid(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public void setError(AccessibilityNodeInfo info, CharSequence error) {
-        }
-
-        public CharSequence getError(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setLabelFor(AccessibilityNodeInfo info, View labeled) {
-        }
-
-        public void setLabelFor(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-        }
-
-        public Object getLabelFor(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setLabeledBy(AccessibilityNodeInfo info, View labeled) {
-        }
-
-        public void setLabeledBy(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-        }
-
-        public Object getLabeledBy(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public boolean canOpenPopup(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public void setCanOpenPopup(AccessibilityNodeInfo info, boolean opensPopup) {
-        }
-
-        public List<AccessibilityNodeInfo> findAccessibilityNodeInfosByViewId(
-                AccessibilityNodeInfo info, String viewId) {
-            return Collections.emptyList();
-        }
-
-        public Bundle getExtras(AccessibilityNodeInfo info) {
-            return new Bundle();
-        }
-
-        public int getInputType(AccessibilityNodeInfo info) {
-            return InputType.TYPE_NULL;
-        }
-
-        public void setInputType(AccessibilityNodeInfo info, int inputType) {
-        }
-
-        public void setMaxTextLength(AccessibilityNodeInfo info, int max) {
-        }
-
-        public int getMaxTextLength(AccessibilityNodeInfo info) {
-            return -1;
-        }
-
-        public void setTextSelection(AccessibilityNodeInfo info, int start, int end) {
-        }
-
-        public int getTextSelectionStart(AccessibilityNodeInfo info) {
-            return -1;
-        }
-
-        public int getTextSelectionEnd(AccessibilityNodeInfo info) {
-            return -1;
-        }
-
-        public Object getWindow(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public boolean isDismissable(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public void setDismissable(AccessibilityNodeInfo info, boolean dismissable) {
-        }
-
-        public boolean isEditable(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public void setEditable(AccessibilityNodeInfo info, boolean editable) {
-        }
-
-        public boolean isMultiLine(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public void setMultiLine(AccessibilityNodeInfo info, boolean multiLine) {
-        }
-
-        public boolean refresh(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public CharSequence getRoleDescription(AccessibilityNodeInfo info) {
-            return null;
-        }
-
-        public void setRoleDescription(AccessibilityNodeInfo info, CharSequence roleDescription) {
-        }
-
-        public Object getActionScrollToPosition() {
-            return null;
-        }
-
-        public Object getActionSetProgress() {
-            return null;
-        }
-
-        public boolean isContextClickable(AccessibilityNodeInfo info) {
-            return false;
-        }
-
-        public void setContextClickable(AccessibilityNodeInfo info, boolean contextClickable) {
-            // Do nothing.
-        }
-
-        public Object getActionShowOnScreen() {
-            return null;
-        }
-
-        public Object getActionScrollUp() {
-            return null;
-        }
-
-        public Object getActionScrollDown() {
-            return null;
-        }
-
-        public Object getActionScrollLeft() {
-            return null;
-        }
-
-        public Object getActionScrollRight() {
-            return null;
-        }
-
-        public Object getActionContextClick() {
-            return null;
-        }
-
-        public int getCollectionInfoSelectionMode(Object info) {
-            return 0;
-        }
-
-        public int getDrawingOrder(AccessibilityNodeInfo info) {
-            return 0;
-        }
-
-        public void setDrawingOrder(AccessibilityNodeInfo info, int drawingOrderInParent) {
-        }
-
-        public boolean isImportantForAccessibility(AccessibilityNodeInfo info) {
-            return true;
-        }
-
-        public void setImportantForAccessibility(AccessibilityNodeInfo info,
-                boolean importantForAccessibility) {
-        }
-    }
-
-    @RequiresApi(16)
-    static class AccessibilityNodeInfoApi16Impl extends AccessibilityNodeInfoBaseImpl {
-        @Override
-        public AccessibilityNodeInfo obtain(View root, int virtualDescendantId) {
-            return AccessibilityNodeInfo.obtain(root, virtualDescendantId);
-        }
-
-        @Override
-        public Object findFocus(AccessibilityNodeInfo info, int focus) {
-            return info.findFocus(focus);
-        }
-
-        @Override
-        public Object focusSearch(AccessibilityNodeInfo info, int direction) {
-            return info.focusSearch(direction);
-        }
-
-        @Override
-        public void addChild(AccessibilityNodeInfo info, View child, int virtualDescendantId) {
-            info.addChild(child, virtualDescendantId);
-        }
-
-        @Override
-        public void setSource(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-            info.setSource(root, virtualDescendantId);
-        }
-
-        @Override
-        public boolean isVisibleToUser(AccessibilityNodeInfo info) {
-            return info.isVisibleToUser();
-        }
-
-        @Override
-        public void setVisibleToUser(AccessibilityNodeInfo info, boolean visibleToUser) {
-            info.setVisibleToUser(visibleToUser);
-        }
-
-        @Override
-        public boolean isAccessibilityFocused(AccessibilityNodeInfo info) {
-            return info.isAccessibilityFocused();
-        }
-
-        @Override
-        public void setAccessibilityFocused(AccessibilityNodeInfo info, boolean focused) {
-            info.setAccessibilityFocused(focused);
-        }
-
-        @Override
-        public boolean performAction(AccessibilityNodeInfo info, int action, Bundle arguments) {
-            return info.performAction(action, arguments);
-        }
-
-        @Override
-        public void setMovementGranularities(AccessibilityNodeInfo info, int granularities) {
-            info.setMovementGranularities(granularities);
-        }
-
-        @Override
-        public int getMovementGranularities(AccessibilityNodeInfo info) {
-            return info.getMovementGranularities();
-        }
-
-        @Override
-        public void setParent(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-            info.setParent(root, virtualDescendantId);
-        }
-    }
-
-    @RequiresApi(17)
-    static class AccessibilityNodeInfoApi17Impl extends AccessibilityNodeInfoApi16Impl {
-
-        @Override
-        public void setLabelFor(AccessibilityNodeInfo info, View labeled) {
-            info.setLabelFor(labeled);
-        }
-
-        @Override
-        public void setLabelFor(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-            info.setLabelFor(root, virtualDescendantId);
-        }
-
-        @Override
-        public Object getLabelFor(AccessibilityNodeInfo info) {
-            return info.getLabelFor();
-        }
-
-        @Override
-        public void setLabeledBy(AccessibilityNodeInfo info, View labeled) {
-            info.setLabeledBy(labeled);
-        }
-
-        @Override
-        public void setLabeledBy(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-            info.setLabeledBy(root, virtualDescendantId);
-        }
-
-        @Override
-        public Object getLabeledBy(AccessibilityNodeInfo info) {
-            return info.getLabeledBy();
-        }
-    }
-
-    @RequiresApi(18)
-    static class AccessibilityNodeInfoApi18Impl extends AccessibilityNodeInfoApi17Impl {
-
-        @Override
-        public String getViewIdResourceName(AccessibilityNodeInfo info) {
-            return info.getViewIdResourceName();
-        }
-
-        @Override
-        public void setViewIdResourceName(AccessibilityNodeInfo info, String viewId) {
-            info.setViewIdResourceName(viewId);
-        }
-
-        @Override
-        public List<AccessibilityNodeInfo> findAccessibilityNodeInfosByViewId(
-                AccessibilityNodeInfo info, String viewId) {
-            return info.findAccessibilityNodeInfosByViewId(viewId);
-        }
-
-        @Override
-        public void setTextSelection(AccessibilityNodeInfo info, int start, int end) {
-            info.setTextSelection(start, end);
-        }
-
-        @Override
-        public int getTextSelectionStart(AccessibilityNodeInfo info) {
-            return info.getTextSelectionStart();
-        }
-
-        @Override
-        public int getTextSelectionEnd(AccessibilityNodeInfo info) {
-            return info.getTextSelectionEnd();
-        }
-
-        @Override
-        public boolean isEditable(AccessibilityNodeInfo info) {
-            return info.isEditable();
-        }
-
-        @Override
-        public void setEditable(AccessibilityNodeInfo info, boolean editable) {
-            info.setEditable(editable);
-        }
-
-        @Override
-        public boolean refresh(AccessibilityNodeInfo info) {
-            return info.refresh();
-        }
-    }
-
-    @RequiresApi(19)
-    static class AccessibilityNodeInfoApi19Impl extends AccessibilityNodeInfoApi18Impl {
-        private static final String ROLE_DESCRIPTION_KEY =
-                "AccessibilityNodeInfo.roleDescription";
-
-        @Override
-        public int getLiveRegion(AccessibilityNodeInfo info) {
-            return info.getLiveRegion();
-        }
-
-        @Override
-        public void setLiveRegion(AccessibilityNodeInfo info, int mode) {
-            info.setLiveRegion(mode);
-        }
-
-        @Override
-        public Object getCollectionInfo(AccessibilityNodeInfo info) {
-            return info.getCollectionInfo();
-        }
-
-        @Override
-        public void setCollectionInfo(AccessibilityNodeInfo info, Object collectionInfo) {
-            info.setCollectionInfo((AccessibilityNodeInfo.CollectionInfo) collectionInfo);
-        }
-
-        @Override
-        public Object obtainCollectionInfo(int rowCount, int columnCount, boolean hierarchical,
-                int selectionMode) {
-            return AccessibilityNodeInfo.CollectionInfo.obtain(rowCount, columnCount, hierarchical);
-        }
-
-        @Override
-        public Object obtainCollectionInfo(int rowCount, int columnCount, boolean hierarchical) {
-            return AccessibilityNodeInfo.CollectionInfo.obtain(rowCount, columnCount, hierarchical);
-        }
-
-        @Override
-        public Object obtainCollectionItemInfo(int rowIndex, int rowSpan, int columnIndex,
-                int columnSpan, boolean heading, boolean selected) {
-            return AccessibilityNodeInfo.CollectionItemInfo.obtain(rowIndex, rowSpan, columnIndex,
-                    columnSpan, heading);
-        }
-
-        @Override
-        public Object obtainCollectionItemInfo(int rowIndex, int rowSpan, int columnIndex,
-                int columnSpan, boolean heading) {
-            return AccessibilityNodeInfo.CollectionItemInfo.obtain(rowIndex, rowSpan, columnIndex,
-                    columnSpan, heading);
-        }
-
-        @Override
-        public int getCollectionInfoColumnCount(Object info) {
-            return ((AccessibilityNodeInfo.CollectionInfo) info).getColumnCount();
-        }
-
-        @Override
-        public int getCollectionInfoRowCount(Object info) {
-            return ((AccessibilityNodeInfo.CollectionInfo) info).getRowCount();
-        }
-
-        @Override
-        public boolean isCollectionInfoHierarchical(Object info) {
-            return ((AccessibilityNodeInfo.CollectionInfo) info).isHierarchical();
-        }
-
-        @Override
-        public Object getCollectionItemInfo(AccessibilityNodeInfo info) {
-            return info.getCollectionItemInfo();
-        }
-
-        @Override
-        public Object getRangeInfo(AccessibilityNodeInfo info) {
-            return info.getRangeInfo();
-        }
-
-        @Override
-        public void setRangeInfo(AccessibilityNodeInfo info, Object rangeInfo) {
-            info.setRangeInfo((AccessibilityNodeInfo.RangeInfo) rangeInfo);
-        }
-
-        @Override
-        public int getCollectionItemColumnIndex(Object info) {
-            return ((AccessibilityNodeInfo.CollectionItemInfo) info).getColumnIndex();
-        }
-
-        @Override
-        public int getCollectionItemColumnSpan(Object info) {
-            return ((AccessibilityNodeInfo.CollectionItemInfo) info).getColumnSpan();
-        }
-
-        @Override
-        public int getCollectionItemRowIndex(Object info) {
-            return ((AccessibilityNodeInfo.CollectionItemInfo) info).getRowIndex();
-        }
-
-        @Override
-        public int getCollectionItemRowSpan(Object info) {
-            return ((AccessibilityNodeInfo.CollectionItemInfo) info).getRowSpan();
-        }
-
-        @Override
-        public boolean isCollectionItemHeading(Object info) {
-            return ((AccessibilityNodeInfo.CollectionItemInfo) info).isHeading();
-        }
-
-        @Override
-        public void setCollectionItemInfo(AccessibilityNodeInfo info, Object collectionItemInfo) {
-            info.setCollectionItemInfo(
-                    (AccessibilityNodeInfo.CollectionItemInfo) collectionItemInfo);
-        }
-
-        @Override
-        public Object obtainRangeInfo(int type, float min, float max, float current) {
-            return AccessibilityNodeInfo.RangeInfo.obtain(type, min, max, current);
-        }
-
-        @Override
-        public void setContentInvalid(AccessibilityNodeInfo info, boolean contentInvalid) {
-            info.setContentInvalid(contentInvalid);
-        }
-
-        @Override
-        public boolean isContentInvalid(AccessibilityNodeInfo info) {
-            return info.isContentInvalid();
-        }
-
-        @Override
-        public boolean canOpenPopup(AccessibilityNodeInfo info) {
-            return info.canOpenPopup();
-        }
-
-        @Override
-        public void setCanOpenPopup(AccessibilityNodeInfo info, boolean opensPopup) {
-            info.setCanOpenPopup(opensPopup);
-        }
-
-        @Override
-        public Bundle getExtras(AccessibilityNodeInfo info) {
-            return info.getExtras();
-        }
-
-        @Override
-        public int getInputType(AccessibilityNodeInfo info) {
-            return info.getInputType();
-        }
-
-        @Override
-        public void setInputType(AccessibilityNodeInfo info, int inputType) {
-            info.setInputType(inputType);
-        }
-
-        @Override
-        public boolean isDismissable(AccessibilityNodeInfo info) {
-            return info.isDismissable();
-        }
-
-        @Override
-        public void setDismissable(AccessibilityNodeInfo info, boolean dismissable) {
-            info.setDismissable(dismissable);
-        }
-
-        @Override
-        public boolean isMultiLine(AccessibilityNodeInfo info) {
-            return info.isMultiLine();
-        }
-
-        @Override
-        public void setMultiLine(AccessibilityNodeInfo info, boolean multiLine) {
-            info.setMultiLine(multiLine);
-        }
-
-        @Override
-        public CharSequence getRoleDescription(AccessibilityNodeInfo info) {
-            Bundle extras = getExtras(info);
-            return extras.getCharSequence(ROLE_DESCRIPTION_KEY);
-        }
-
-        @Override
-        public void setRoleDescription(AccessibilityNodeInfo info, CharSequence roleDescription) {
-            Bundle extras = getExtras(info);
-            extras.putCharSequence(ROLE_DESCRIPTION_KEY, roleDescription);
-        }
-    }
-
-    @RequiresApi(21)
-    static class AccessibilityNodeInfoApi21Impl extends AccessibilityNodeInfoApi19Impl {
-        @Override
-        public Object newAccessibilityAction(int actionId, CharSequence label) {
-            return new AccessibilityNodeInfo.AccessibilityAction(actionId, label);
-        }
-
-        @SuppressWarnings("unchecked")
-        @Override
-        public List<Object> getActionList(AccessibilityNodeInfo info) {
-            Object result = info.getActionList();
-            return (List<Object>) result;
-        }
-
-        @Override
-        public Object obtainCollectionInfo(int rowCount, int columnCount, boolean hierarchical,
-                int selectionMode) {
-            return AccessibilityNodeInfo.CollectionInfo.obtain(rowCount, columnCount, hierarchical,
-                    selectionMode);
-        }
-
-        @Override
-        public void addAction(AccessibilityNodeInfo info, Object action) {
-            info.addAction((AccessibilityNodeInfo.AccessibilityAction) action);
-        }
-
-        @Override
-        public boolean removeAction(AccessibilityNodeInfo info, Object action) {
-            return info.removeAction((AccessibilityNodeInfo.AccessibilityAction) action);
-        }
-
-        @Override
-        public int getAccessibilityActionId(Object action) {
-            return ((AccessibilityNodeInfo.AccessibilityAction) action).getId();
-        }
-
-        @Override
-        public CharSequence getAccessibilityActionLabel(Object action) {
-            return ((AccessibilityNodeInfo.AccessibilityAction) action).getLabel();
-        }
-
-        @Override
-        public Object obtainCollectionItemInfo(int rowIndex, int rowSpan, int columnIndex,
-                int columnSpan, boolean heading, boolean selected) {
-            return AccessibilityNodeInfo.CollectionItemInfo.obtain(rowIndex, rowSpan, columnIndex,
-                    columnSpan, heading, selected);
-        }
-
-        @Override
-        public boolean isCollectionItemSelected(Object info) {
-            return ((AccessibilityNodeInfo.CollectionItemInfo) info).isSelected();
-        }
-
-        @Override
-        public CharSequence getError(AccessibilityNodeInfo info) {
-            return info.getError();
-        }
-
-        @Override
-        public void setError(AccessibilityNodeInfo info, CharSequence error) {
-            info.setError(error);
-        }
-
-        @Override
-        public void setMaxTextLength(AccessibilityNodeInfo info, int max) {
-            info.setMaxTextLength(max);
-        }
-
-        @Override
-        public int getMaxTextLength(AccessibilityNodeInfo info) {
-            return info.getMaxTextLength();
-        }
-
-        @Override
-        public Object getWindow(AccessibilityNodeInfo info) {
-            return info.getWindow();
-        }
-
-        @Override
-        public boolean removeChild(AccessibilityNodeInfo info, View child) {
-            return info.removeChild(child);
-        }
-
-        @Override
-        public boolean removeChild(AccessibilityNodeInfo info, View root, int virtualDescendantId) {
-            return info.removeChild(root, virtualDescendantId);
-        }
-
-        @Override
-        public int getCollectionInfoSelectionMode(Object info) {
-            return ((AccessibilityNodeInfo.CollectionInfo) info).getSelectionMode();
-        }
-    }
-
-    @RequiresApi(22)
-    static class AccessibilityNodeInfoApi22Impl extends AccessibilityNodeInfoApi21Impl {
-        @Override
-        public Object getTraversalBefore(AccessibilityNodeInfo info) {
-            return info.getTraversalBefore();
-        }
-
-        @Override
-        public void setTraversalBefore(AccessibilityNodeInfo info, View view) {
-            info.setTraversalBefore(view);
-        }
-
-        @Override
-        public void setTraversalBefore(AccessibilityNodeInfo info, View root,
-                int virtualDescendantId) {
-            info.setTraversalBefore(root, virtualDescendantId);
-        }
-
-        @Override
-        public Object getTraversalAfter(AccessibilityNodeInfo info) {
-            return info.getTraversalAfter();
-        }
-
-        @Override
-        public void setTraversalAfter(AccessibilityNodeInfo info, View view) {
-            info.setTraversalAfter(view);
-        }
-
-        @Override
-        public void setTraversalAfter(AccessibilityNodeInfo info, View root,
-                int virtualDescendantId) {
-            info.setTraversalAfter(root, virtualDescendantId);
-        }
-    }
-
-    @RequiresApi(23)
-    static class AccessibilityNodeInfoApi23Impl extends AccessibilityNodeInfoApi22Impl {
-        @Override
-        public Object getActionScrollToPosition() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_TO_POSITION;
-        }
-
-        @Override
-        public Object getActionShowOnScreen() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_SHOW_ON_SCREEN;
-        }
-
-        @Override
-        public Object getActionScrollUp() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_UP;
-        }
-
-        @Override
-        public Object getActionScrollDown() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_DOWN;
-        }
-
-        @Override
-        public Object getActionScrollLeft() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_LEFT;
-        }
-
-        @Override
-        public Object getActionScrollRight() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_SCROLL_RIGHT;
-        }
-
-        @Override
-        public Object getActionContextClick() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_CONTEXT_CLICK;
-        }
-
-        @Override
-        public boolean isContextClickable(AccessibilityNodeInfo info) {
-            return info.isContextClickable();
-        }
-
-        @Override
-        public void setContextClickable(AccessibilityNodeInfo info, boolean contextClickable) {
-            info.setContextClickable(contextClickable);
-        }
-    }
-
-    @RequiresApi(24)
-    static class AccessibilityNodeInfoApi24Impl extends AccessibilityNodeInfoApi23Impl {
-        @Override
-        public Object getActionSetProgress() {
-            return AccessibilityNodeInfo.AccessibilityAction.ACTION_SET_PROGRESS;
-        }
-
-        @Override
-        public int getDrawingOrder(AccessibilityNodeInfo info) {
-            return info.getDrawingOrder();
-        }
-
-        @Override
-        public void setDrawingOrder(AccessibilityNodeInfo info, int drawingOrderInParent) {
-            info.setDrawingOrder(drawingOrderInParent);
-        }
-
-        @Override
-        public boolean isImportantForAccessibility(AccessibilityNodeInfo info) {
-            return info.isImportantForAccessibility();
-        }
-
-        @Override
-        public void setImportantForAccessibility(AccessibilityNodeInfo info,
-                boolean importantForAccessibility) {
-            info.setImportantForAccessibility(importantForAccessibility);
-        }
-
-    }
-
-    static {
-        if (Build.VERSION.SDK_INT >= 24) {
-            IMPL = new AccessibilityNodeInfoApi24Impl();
-        } else if (Build.VERSION.SDK_INT >= 23) {
-            IMPL = new AccessibilityNodeInfoApi23Impl();
-        } else if (Build.VERSION.SDK_INT >= 22) {
-            IMPL = new AccessibilityNodeInfoApi22Impl();
-        } else if (Build.VERSION.SDK_INT >= 21) {
-            IMPL = new AccessibilityNodeInfoApi21Impl();
-        } else if (Build.VERSION.SDK_INT >= 19) { // KitKat
-            IMPL = new AccessibilityNodeInfoApi19Impl();
-        } else if (Build.VERSION.SDK_INT >= 18) { // JellyBean MR2
-            IMPL = new AccessibilityNodeInfoApi18Impl();
-        } else if (Build.VERSION.SDK_INT >= 17) { // JellyBean MR1
-            IMPL = new AccessibilityNodeInfoApi17Impl();
-        } else if (Build.VERSION.SDK_INT >= 16) { // JellyBean
-            IMPL = new AccessibilityNodeInfoApi16Impl();
-        } else {
-            IMPL = new AccessibilityNodeInfoBaseImpl();
-        }
-    }
-
-    static final AccessibilityNodeInfoBaseImpl IMPL;
+    private static final String ROLE_DESCRIPTION_KEY =
+            "AccessibilityNodeInfo.roleDescription";
 
     private final AccessibilityNodeInfo mInfo;
 
@@ -2121,8 +1275,12 @@
      * @see #setSource(View, int)
      */
     public static AccessibilityNodeInfoCompat obtain(View root, int virtualDescendantId) {
-        return AccessibilityNodeInfoCompat.wrapNonNullInstance(
-                IMPL.obtain(root, virtualDescendantId));
+        if (Build.VERSION.SDK_INT >= 16) {
+            return AccessibilityNodeInfoCompat.wrapNonNullInstance(
+                    AccessibilityNodeInfo.obtain(root, virtualDescendantId));
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -2174,7 +1332,9 @@
      * @param virtualDescendantId The id of the virtual descendant.
      */
     public void setSource(View root, int virtualDescendantId) {
-        IMPL.setSource(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 16) {
+            mInfo.setSource(root, virtualDescendantId);
+        }
     }
 
     /**
@@ -2189,7 +1349,11 @@
      * @see #FOCUS_ACCESSIBILITY
      */
     public AccessibilityNodeInfoCompat findFocus(int focus) {
-        return AccessibilityNodeInfoCompat.wrapNonNullInstance(IMPL.findFocus(mInfo, focus));
+        if (Build.VERSION.SDK_INT >= 16) {
+            return AccessibilityNodeInfoCompat.wrapNonNullInstance(mInfo.findFocus(focus));
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -2207,7 +1371,11 @@
      * @return The node info for the view that can take accessibility focus.
      */
     public AccessibilityNodeInfoCompat focusSearch(int direction) {
-        return AccessibilityNodeInfoCompat.wrapNonNullInstance(IMPL.focusSearch(mInfo, direction));
+        if (Build.VERSION.SDK_INT >= 16) {
+            return AccessibilityNodeInfoCompat.wrapNonNullInstance(mInfo.focusSearch(direction));
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -2275,7 +1443,9 @@
      * @param virtualDescendantId The id of the virtual child.
      */
     public void addChild(View root, int virtualDescendantId) {
-        IMPL.addChild(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 16) {
+            mInfo.addChild(root, virtualDescendantId);
+        }
     }
 
     /**
@@ -2293,7 +1463,11 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public boolean removeChild(View child) {
-        return IMPL.removeChild(mInfo, child);
+        if (Build.VERSION.SDK_INT >= 21) {
+            return mInfo.removeChild(child);
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -2307,7 +1481,11 @@
      * @see #addChild(View, int)
      */
     public boolean removeChild(View root, int virtualDescendantId) {
-        return IMPL.removeChild(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 21) {
+            return mInfo.removeChild(root, virtualDescendantId);
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -2350,7 +1528,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void addAction(AccessibilityActionCompat action) {
-        IMPL.addAction(mInfo, action.mAction);
+        if (Build.VERSION.SDK_INT >= 21) {
+            mInfo.addAction((AccessibilityNodeInfo.AccessibilityAction) action.mAction);
+        }
     }
 
     /**
@@ -2368,7 +1548,11 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public boolean removeAction(AccessibilityActionCompat action) {
-        return IMPL.removeAction(mInfo, action.mAction);
+        if (Build.VERSION.SDK_INT >= 21) {
+            return mInfo.removeAction((AccessibilityNodeInfo.AccessibilityAction) action.mAction);
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -2401,7 +1585,11 @@
      * @throws IllegalStateException If called outside of an AccessibilityService.
      */
     public boolean performAction(int action, Bundle arguments) {
-        return IMPL.performAction(mInfo, action, arguments);
+        if (Build.VERSION.SDK_INT >= 16) {
+            return mInfo.performAction(action, arguments);
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -2417,7 +1605,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setMovementGranularities(int granularities) {
-        IMPL.setMovementGranularities(mInfo, granularities);
+        if (Build.VERSION.SDK_INT >= 16) {
+            mInfo.setMovementGranularities(granularities);
+        }
     }
 
     /**
@@ -2426,7 +1616,11 @@
      * @return The bit mask with granularities.
      */
     public int getMovementGranularities() {
-        return IMPL.getMovementGranularities(mInfo);
+        if (Build.VERSION.SDK_INT >= 16) {
+            return mInfo.getMovementGranularities();
+        } else {
+            return 0;
+        }
     }
 
     /**
@@ -2503,7 +1697,9 @@
      */
     public void setParent(View root, int virtualDescendantId) {
         mParentVirtualDescendantId = virtualDescendantId;
-        IMPL.setParent(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 16) {
+            mInfo.setParent(root, virtualDescendantId);
+        }
     }
 
     /**
@@ -2656,7 +1852,11 @@
      * @return Whether the node is visible to the user.
      */
     public boolean isVisibleToUser() {
-        return IMPL.isVisibleToUser(mInfo);
+        if (Build.VERSION.SDK_INT >= 16) {
+            return mInfo.isVisibleToUser();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -2672,7 +1872,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setVisibleToUser(boolean visibleToUser) {
-        IMPL.setVisibleToUser(mInfo, visibleToUser);
+        if (Build.VERSION.SDK_INT >= 16) {
+            mInfo.setVisibleToUser(visibleToUser);
+        }
     }
 
     /**
@@ -2681,7 +1883,11 @@
      * @return True if the node is accessibility focused.
      */
     public boolean isAccessibilityFocused() {
-        return IMPL.isAccessibilityFocused(mInfo);
+        if (Build.VERSION.SDK_INT >= 16) {
+            return mInfo.isAccessibilityFocused();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -2697,7 +1903,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setAccessibilityFocused(boolean focused) {
-        IMPL.setAccessibilityFocused(mInfo, focused);
+        if (Build.VERSION.SDK_INT >= 16) {
+            mInfo.setAccessibilityFocused(focused);
+        }
     }
 
     /**
@@ -2853,7 +2061,11 @@
      * @see View#isImportantForAccessibility()
      */
     public boolean isImportantForAccessibility() {
-        return IMPL.isImportantForAccessibility(mInfo);
+        if (Build.VERSION.SDK_INT >= 24) {
+            return mInfo.isImportantForAccessibility();
+        } else {
+            return true;
+        }
     }
 
     /**
@@ -2868,7 +2080,9 @@
      *                  {@code false} otherwise
      */
     public void setImportantForAccessibility(boolean important) {
-        IMPL.setImportantForAccessibility(mInfo, important);
+        if (Build.VERSION.SDK_INT >= 24) {
+            mInfo.setImportantForAccessibility(important);
+        }
     }
 
     /**
@@ -2990,7 +2204,9 @@
      * @param viewId The id resource name.
      */
     public void setViewIdResourceName(String viewId) {
-        IMPL.setViewIdResourceName(mInfo, viewId);
+        if (Build.VERSION.SDK_INT >= 18) {
+            mInfo.setViewIdResourceName(viewId);
+        }
     }
 
     /**
@@ -3006,7 +2222,11 @@
      * @return The id resource name.
      */
     public String getViewIdResourceName() {
-        return IMPL.getViewIdResourceName(mInfo);
+        if (Build.VERSION.SDK_INT >= 18) {
+            return mInfo.getViewIdResourceName();
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3028,7 +2248,11 @@
      * @see ViewCompat#getAccessibilityLiveRegion(View)
      */
     public int getLiveRegion() {
-        return IMPL.getLiveRegion(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.getLiveRegion();
+        } else {
+            return ViewCompat.ACCESSIBILITY_LIVE_REGION_NONE;
+        }
     }
 
     /**
@@ -3044,7 +2268,9 @@
      * @see ViewCompat#setAccessibilityLiveRegion(View, int)
      */
     public void setLiveRegion(int mode) {
-        IMPL.setLiveRegion(mInfo, mode);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setLiveRegion(mode);
+        }
     }
 
     /**
@@ -3059,7 +2285,11 @@
      * @return The drawing position of the view corresponding to this node relative to its siblings.
      */
     public int getDrawingOrder() {
-        return IMPL.getDrawingOrder(mInfo);
+        if (Build.VERSION.SDK_INT >= 24) {
+            return mInfo.getDrawingOrder();
+        } else {
+            return 0;
+        }
     }
 
     /**
@@ -3074,7 +2304,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setDrawingOrder(int drawingOrderInParent) {
-        IMPL.setDrawingOrder(mInfo, drawingOrderInParent);
+        if (Build.VERSION.SDK_INT >= 24) {
+            mInfo.setDrawingOrder(drawingOrderInParent);
+        }
     }
 
     /**
@@ -3084,17 +2316,28 @@
      * @return The collection info.
      */
     public CollectionInfoCompat getCollectionInfo() {
-        Object info = IMPL.getCollectionInfo(mInfo);
-        if (info == null) return null;
-        return new CollectionInfoCompat(info);
+        if (Build.VERSION.SDK_INT >= 19) {
+            AccessibilityNodeInfo.CollectionInfo info = mInfo.getCollectionInfo();
+            if (info != null) {
+                return new CollectionInfoCompat(info);
+            }
+        }
+        return null;
     }
 
     public void setCollectionInfo(Object collectionInfo) {
-        IMPL.setCollectionInfo(mInfo, ((CollectionInfoCompat) collectionInfo).mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setCollectionInfo((AccessibilityNodeInfo.CollectionInfo)
+                    ((CollectionInfoCompat) collectionInfo).mInfo);
+        }
+
     }
 
     public void setCollectionItemInfo(Object collectionItemInfo) {
-        IMPL.setCollectionItemInfo(mInfo, ((CollectionItemInfoCompat) collectionItemInfo).mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setCollectionItemInfo((AccessibilityNodeInfo.CollectionItemInfo)
+                    ((CollectionItemInfoCompat) collectionItemInfo).mInfo);
+        }
     }
 
     /**
@@ -3104,9 +2347,13 @@
      * @return The collection item info.
      */
     public CollectionItemInfoCompat getCollectionItemInfo() {
-        Object info = IMPL.getCollectionItemInfo(mInfo);
-        if (info == null) return null;
-        return new CollectionItemInfoCompat(info);
+        if (Build.VERSION.SDK_INT >= 19) {
+            AccessibilityNodeInfo.CollectionItemInfo info = mInfo.getCollectionItemInfo();
+            if (info != null) {
+                return new CollectionItemInfoCompat(info);
+            }
+        }
+        return null;
     }
 
     /**
@@ -3115,9 +2362,13 @@
      * @return The range.
      */
     public RangeInfoCompat getRangeInfo() {
-        Object info = IMPL.getRangeInfo(mInfo);
-        if (info == null) return null;
-        return new RangeInfoCompat(info);
+        if (Build.VERSION.SDK_INT >= 19) {
+            AccessibilityNodeInfo.RangeInfo info = mInfo.getRangeInfo();
+            if (info != null) {
+                return new RangeInfoCompat(info);
+            }
+        }
+        return null;
     }
 
     /**
@@ -3131,7 +2382,9 @@
      * @param rangeInfo The range info.
      */
     public void setRangeInfo(RangeInfoCompat rangeInfo) {
-        IMPL.setRangeInfo(mInfo, rangeInfo.mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setRangeInfo((AccessibilityNodeInfo.RangeInfo) rangeInfo.mInfo);
+        }
     }
 
     /**
@@ -3139,8 +2392,12 @@
      *
      * @return A list of AccessibilityActions.
      */
+    @SuppressWarnings("unchecked")
     public List<AccessibilityActionCompat> getActionList() {
-        List<Object> actions = IMPL.getActionList(mInfo);
+        List<Object> actions = null;
+        if (Build.VERSION.SDK_INT >= 21) {
+            actions = (List<Object>) (List<?>) mInfo.getActionList();
+        }
         if (actions != null) {
             List<AccessibilityActionCompat> result = new ArrayList<AccessibilityActionCompat>();
             final int actionCount = actions.size();
@@ -3166,7 +2423,9 @@
      * @param contentInvalid If the node content is invalid.
      */
     public void setContentInvalid(boolean contentInvalid) {
-        IMPL.setContentInvalid(mInfo, contentInvalid);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setContentInvalid(contentInvalid);
+        }
     }
 
     /**
@@ -3176,7 +2435,11 @@
      * @return If the node content is invalid.
      */
     public boolean isContentInvalid() {
-        return IMPL.isContentInvalid(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.isContentInvalid();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -3185,7 +2448,11 @@
      * @return True if the node is context clickable.
      */
     public boolean isContextClickable() {
-        return IMPL.isContextClickable(mInfo);
+        if (Build.VERSION.SDK_INT >= 23) {
+            return mInfo.isContextClickable();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -3200,7 +2467,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setContextClickable(boolean contextClickable) {
-        IMPL.setContextClickable(mInfo, contextClickable);
+        if (Build.VERSION.SDK_INT >= 23) {
+            mInfo.setContextClickable(contextClickable);
+        }
     }
 
     /**
@@ -3216,7 +2485,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setError(CharSequence error) {
-        IMPL.setError(mInfo, error);
+        if (Build.VERSION.SDK_INT >= 21) {
+            mInfo.setError(error);
+        }
     }
 
     /**
@@ -3225,7 +2496,11 @@
      * @return The error text.
      */
     public CharSequence getError() {
-        return IMPL.getError(mInfo);
+        if (Build.VERSION.SDK_INT >= 21) {
+            return mInfo.getError();
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3235,7 +2510,9 @@
      * @param labeled The view for which this info serves as a label.
      */
     public void setLabelFor(View labeled) {
-        IMPL.setLabelFor(mInfo, labeled);
+        if (Build.VERSION.SDK_INT >= 17) {
+            mInfo.setLabelFor(labeled);
+        }
     }
 
     /**
@@ -3253,7 +2530,9 @@
      * @param virtualDescendantId The id of the virtual descendant.
      */
     public void setLabelFor(View root, int virtualDescendantId) {
-        IMPL.setLabelFor(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 17) {
+            mInfo.setLabelFor(root, virtualDescendantId);
+        }
     }
 
     /**
@@ -3268,7 +2547,11 @@
      * @return The labeled info.
      */
     public AccessibilityNodeInfoCompat getLabelFor() {
-        return AccessibilityNodeInfoCompat.wrapNonNullInstance(IMPL.getLabelFor(mInfo));
+        if (Build.VERSION.SDK_INT >= 17) {
+            return AccessibilityNodeInfoCompat.wrapNonNullInstance(mInfo.getLabelFor());
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3278,7 +2561,9 @@
      * @param label The view that labels this node's source.
      */
     public void setLabeledBy(View label) {
-        IMPL.setLabeledBy(mInfo, label);
+        if (Build.VERSION.SDK_INT >= 17) {
+            mInfo.setLabeledBy(label);
+        }
     }
 
     /**
@@ -3301,7 +2586,9 @@
      * @param virtualDescendantId The id of the virtual descendant.
      */
     public void setLabeledBy(View root, int virtualDescendantId) {
-        IMPL.setLabeledBy(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 17) {
+            mInfo.setLabeledBy(root, virtualDescendantId);
+        }
     }
 
     /**
@@ -3316,7 +2603,11 @@
      * @return The label.
      */
     public AccessibilityNodeInfoCompat getLabeledBy() {
-        return AccessibilityNodeInfoCompat.wrapNonNullInstance(IMPL.getLabeledBy(mInfo));
+        if (Build.VERSION.SDK_INT >= 17) {
+            return AccessibilityNodeInfoCompat.wrapNonNullInstance(mInfo.getLabeledBy());
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3325,7 +2616,11 @@
      * @return If the the node opens a popup.
      */
     public boolean canOpenPopup() {
-        return IMPL.canOpenPopup(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.canOpenPopup();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -3339,7 +2634,9 @@
      * @param opensPopup If the the node opens a popup.
      */
     public void setCanOpenPopup(boolean opensPopup) {
-        IMPL.setCanOpenPopup(mInfo, opensPopup);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setCanOpenPopup(opensPopup);
+        }
     }
 
     /**
@@ -3365,9 +2662,9 @@
      * @return A list of node info.
      */
     public List<AccessibilityNodeInfoCompat> findAccessibilityNodeInfosByViewId(String viewId) {
-        List<AccessibilityNodeInfo> nodes = IMPL.findAccessibilityNodeInfosByViewId(mInfo, viewId);
-        if (nodes != null) {
-            List<AccessibilityNodeInfoCompat> result = new ArrayList<AccessibilityNodeInfoCompat>();
+        if (Build.VERSION.SDK_INT >= 18) {
+            List<AccessibilityNodeInfo> nodes = mInfo.findAccessibilityNodeInfosByViewId(viewId);
+            List<AccessibilityNodeInfoCompat> result = new ArrayList<>();
             for (AccessibilityNodeInfo node : nodes) {
                 result.add(AccessibilityNodeInfoCompat.wrap(node));
             }
@@ -3391,7 +2688,11 @@
      * @return The bundle.
      */
     public Bundle getExtras() {
-        return IMPL.getExtras(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.getExtras();
+        } else {
+            return new Bundle();
+        }
     }
 
     /**
@@ -3400,7 +2701,11 @@
      * @return The input type.
      */
     public int getInputType() {
-        return IMPL.getInputType(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.getInputType();
+        } else {
+            return InputType.TYPE_NULL;
+        }
     }
 
     /**
@@ -3417,7 +2722,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setInputType(int inputType) {
-        IMPL.setInputType(mInfo, inputType);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setInputType(inputType);
+        }
     }
 
     /**
@@ -3436,7 +2743,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setMaxTextLength(int max) {
-        IMPL.setMaxTextLength(mInfo, max);
+        if (Build.VERSION.SDK_INT >= 21) {
+            mInfo.setMaxTextLength(max);
+        }
     }
 
     /**
@@ -3446,7 +2755,11 @@
      * @see #setMaxTextLength(int)
      */
     public int getMaxTextLength() {
-        return IMPL.getMaxTextLength(mInfo);
+        if (Build.VERSION.SDK_INT >= 21) {
+            return mInfo.getMaxTextLength();
+        } else {
+            return -1;
+        }
     }
 
     /**
@@ -3463,7 +2776,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setTextSelection(int start, int end) {
-        IMPL.setTextSelection(mInfo, start, end);
+        if (Build.VERSION.SDK_INT >= 18) {
+            mInfo.setTextSelection(start, end);
+        }
     }
 
     /**
@@ -3472,7 +2787,11 @@
      * @return The text selection start if there is selection or -1.
      */
     public int getTextSelectionStart() {
-        return IMPL.getTextSelectionStart(mInfo);
+        if (Build.VERSION.SDK_INT >= 18) {
+            return mInfo.getTextSelectionStart();
+        } else {
+            return -1;
+        }
     }
 
     /**
@@ -3481,7 +2800,11 @@
      * @return The text selection end if there is selection or -1.
      */
     public int getTextSelectionEnd() {
-        return IMPL.getTextSelectionEnd(mInfo);
+        if (Build.VERSION.SDK_INT >= 18) {
+            return mInfo.getTextSelectionEnd();
+        } else {
+            return -1;
+        }
     }
 
     /**
@@ -3494,7 +2817,11 @@
      * @see #setTraversalBefore(android.view.View, int)
      */
     public AccessibilityNodeInfoCompat getTraversalBefore() {
-        return AccessibilityNodeInfoCompat.wrapNonNullInstance(IMPL.getTraversalBefore(mInfo));
+        if (Build.VERSION.SDK_INT >= 22) {
+            return AccessibilityNodeInfoCompat.wrapNonNullInstance(mInfo.getTraversalBefore());
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3512,7 +2839,9 @@
      * @see #getTraversalBefore()
      */
     public void setTraversalBefore(View view) {
-        IMPL.setTraversalBefore(mInfo, view);
+        if (Build.VERSION.SDK_INT >= 22) {
+            mInfo.setTraversalBefore(view);
+        }
     }
 
     /**
@@ -3537,7 +2866,9 @@
      * @param virtualDescendantId The id of the virtual descendant.
      */
     public void setTraversalBefore(View root, int virtualDescendantId) {
-        IMPL.setTraversalBefore(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 22) {
+            mInfo.setTraversalBefore(root, virtualDescendantId);
+        }
     }
 
     /**
@@ -3551,7 +2882,11 @@
      * @see #setTraversalAfter(android.view.View, int)
      */
     public AccessibilityNodeInfoCompat getTraversalAfter() {
-        return AccessibilityNodeInfoCompat.wrapNonNullInstance(IMPL.getTraversalAfter(mInfo));
+        if (Build.VERSION.SDK_INT >= 22) {
+            return AccessibilityNodeInfoCompat.wrapNonNullInstance(mInfo.getTraversalAfter());
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3569,7 +2904,9 @@
      * @see #getTraversalAfter()
      */
     public void setTraversalAfter(View view) {
-        IMPL.setTraversalAfter(mInfo, view);
+        if (Build.VERSION.SDK_INT >= 22) {
+            mInfo.setTraversalAfter(view);
+        }
     }
 
     /**
@@ -3593,7 +2930,9 @@
      * @param virtualDescendantId The id of the virtual descendant.
      */
     public void setTraversalAfter(View root, int virtualDescendantId) {
-        IMPL.setTraversalAfter(mInfo, root, virtualDescendantId);
+        if (Build.VERSION.SDK_INT >= 22) {
+            mInfo.setTraversalAfter(root, virtualDescendantId);
+        }
     }
 
     /**
@@ -3604,7 +2943,11 @@
      * @see android.accessibilityservice.AccessibilityService#getWindows()
      */
     public AccessibilityWindowInfoCompat getWindow() {
-        return AccessibilityWindowInfoCompat.wrapNonNullInstance(IMPL.getWindow(mInfo));
+        if (Build.VERSION.SDK_INT >= 21) {
+            return AccessibilityWindowInfoCompat.wrapNonNullInstance(mInfo.getWindow());
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3613,7 +2956,11 @@
      * @return If the node can be dismissed.
      */
     public boolean isDismissable() {
-        return IMPL.isDismissable(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.isDismissable();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -3627,7 +2974,9 @@
      * @param dismissable If the node can be dismissed.
      */
     public void setDismissable(boolean dismissable) {
-        IMPL.setDismissable(mInfo, dismissable);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setDismissable(dismissable);
+        }
     }
 
     /**
@@ -3636,7 +2985,11 @@
      * @return True if the node is editable, false otherwise.
      */
     public boolean isEditable() {
-        return IMPL.isEditable(mInfo);
+        if (Build.VERSION.SDK_INT >= 18) {
+            return mInfo.isEditable();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -3652,7 +3005,9 @@
      * @throws IllegalStateException If called from an AccessibilityService.
      */
     public void setEditable(boolean editable) {
-        IMPL.setEditable(mInfo, editable);
+        if (Build.VERSION.SDK_INT >= 18) {
+            mInfo.setEditable(editable);
+        }
     }
 
     /**
@@ -3661,7 +3016,11 @@
      * @return True if the node is multi line.
      */
     public boolean isMultiLine() {
-        return IMPL.isMultiLine(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.isMultiLine();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -3675,7 +3034,9 @@
      * @param multiLine True if the node is multi line.
      */
     public void setMultiLine(boolean multiLine) {
-        IMPL.setMultiLine(mInfo, multiLine);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.setMultiLine(multiLine);
+        }
     }
 
     /**
@@ -3688,7 +3049,11 @@
      * @return Whether the refresh succeeded.
      */
     public boolean refresh() {
-        return IMPL.refresh(mInfo);
+        if (Build.VERSION.SDK_INT >= 18) {
+            return mInfo.refresh();
+        } else {
+            return false;
+        }
     }
 
     /**
@@ -3696,7 +3061,11 @@
      * @return The role description.
      */
     public @Nullable CharSequence getRoleDescription() {
-        return IMPL.getRoleDescription(mInfo);
+        if (Build.VERSION.SDK_INT >= 19) {
+            return mInfo.getExtras().getCharSequence(ROLE_DESCRIPTION_KEY);
+        } else {
+            return null;
+        }
     }
 
     /**
@@ -3724,7 +3093,9 @@
      * @param roleDescription The role description.
      */
     public void setRoleDescription(@Nullable CharSequence roleDescription) {
-        IMPL.setRoleDescription(mInfo, roleDescription);
+        if (Build.VERSION.SDK_INT >= 19) {
+            mInfo.getExtras().putCharSequence(ROLE_DESCRIPTION_KEY, roleDescription);
+        }
     }
 
     @Override
diff --git a/compat/tests/java/android/support/v4/content/pm/ShortcutManagerCompatTest.java b/compat/tests/java/android/support/v4/content/pm/ShortcutManagerCompatTest.java
index 77e7ae8..2d6cd67 100644
--- a/compat/tests/java/android/support/v4/content/pm/ShortcutManagerCompatTest.java
+++ b/compat/tests/java/android/support/v4/content/pm/ShortcutManagerCompatTest.java
@@ -47,7 +47,6 @@
 import android.graphics.Bitmap;
 import android.os.Build;
 import android.support.test.filters.LargeTest;
-import android.support.test.filters.MediumTest;
 import android.support.test.filters.SmallTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v4.BaseInstrumentationTestCase;
@@ -185,7 +184,7 @@
         verifyLegacyIntent(receiver.blockingGetIntent());
     }
 
-    @MediumTest
+    @LargeTest
     @Test
     public void testRequestPinShortcut_v4_withCallback()  throws Throwable {
         if (Build.VERSION.SDK_INT >= 26) {
diff --git a/compat/tests/java/android/support/v4/provider/SelfDestructiveThreadTest.java b/compat/tests/java/android/support/v4/provider/SelfDestructiveThreadTest.java
index 84fd77f..a0f9fad 100644
--- a/compat/tests/java/android/support/v4/provider/SelfDestructiveThreadTest.java
+++ b/compat/tests/java/android/support/v4/provider/SelfDestructiveThreadTest.java
@@ -27,6 +27,7 @@
 import android.os.Process;
 import android.support.annotation.GuardedBy;
 import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.runner.AndroidJUnit4;
 
@@ -142,6 +143,7 @@
         assertEquals(generation.intValue(), nextGeneration.intValue());
     }
 
+    @LargeTest
     @Test
     public void testReuseSameThread_Multiple() throws InterruptedException {
         final int destructAfterLastActivityInMs = 300;
diff --git a/core-ui/build.gradle b/core-ui/build.gradle
index 2cd1806..0cbea4a 100644
--- a/core-ui/build.gradle
+++ b/core-ui/build.gradle
@@ -1,19 +1,18 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-core-ui'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-compat')
+    api project(':support-annotations')
+    api project(':support-compat')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(':support-testutils')
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation project(':support-testutils')
 }
 
 android {
diff --git a/core-ui/tests/java/android/support/v4/view/BaseViewPagerTest.java b/core-ui/tests/java/android/support/v4/view/BaseViewPagerTest.java
index 855d01d..10b68fa 100644
--- a/core-ui/tests/java/android/support/v4/view/BaseViewPagerTest.java
+++ b/core-ui/tests/java/android/support/v4/view/BaseViewPagerTest.java
@@ -404,7 +404,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testArrowPageChanges() {
         verifyPageChangeViewActions(arrowScroll(View.FOCUS_RIGHT), arrowScroll(View.FOCUS_LEFT));
     }
@@ -646,7 +646,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testPagerStripImmediate() {
         verifyPagerStrip(false);
     }
@@ -723,7 +723,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testPageScrollStateChangedSmooth() {
         // Note that all the actions tested in this method use smooth scrolling and as such we test
         // that we get the matching calls to onPageScrollStateChanged
@@ -746,7 +746,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testPageScrollStateChangedSwipe() {
         // Note that all the actions tested in this method use swiping and as such we test
         // that we get the matching calls to onPageScrollStateChanged
@@ -1045,7 +1045,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testPageScrollPositionChangesSmooth() {
         // Scroll one page to the right
         verifyScrollCallbacksToHigherPage(scrollRight(true), 1);
@@ -1063,7 +1063,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testPageScrollPositionChangesSwipe() {
         // Swipe one page to the left
         verifyScrollCallbacksToHigherPage(wrap(swipeLeft()), 1);
diff --git a/core-utils/build.gradle b/core-utils/build.gradle
index 380f1f6..c6e98f0 100644
--- a/core-utils/build.gradle
+++ b/core-utils/build.gradle
@@ -1,18 +1,17 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-core-utils'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-compat')
+    api project(':support-annotations')
+    api project(':support-compat')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
diff --git a/customtabs/build.gradle b/customtabs/build.gradle
index 6bc7dd5..17e8cb9 100644
--- a/customtabs/build.gradle
+++ b/customtabs/build.gradle
@@ -1,19 +1,16 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'customtabs'
 
 dependencies {
-    compile project(':support-compat')
-    compile project(':support-annotations')
+    api project(':support-compat')
+    api project(':support-annotations')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-
-    androidTestCompile project(':support-testutils')
+    androidTestImplementation project(':support-testutils')
 }
 
 android {
diff --git a/design/build.gradle b/design/build.gradle
index d76642d..b5a13ee 100644
--- a/design/build.gradle
+++ b/design/build.gradle
@@ -1,28 +1,27 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'design'
 
 dependencies {
-    compile project(':support-v4')
-    compile project(':support-appcompat-v7')
-    compile project(':support-recyclerview-v7')
-    compile project(':support-transition')
+    api project(':support-v4')
+    api project(':support-appcompat-v7')
+    api project(':support-recyclerview-v7')
+    api project(':support-transition')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_contrib) {
+    androidTestImplementation (libs.espresso_contrib) {
         exclude group: 'com.android.support'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(':support-testutils')
-    androidTestCompile libs.multidex
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation project(':support-testutils')
+    androidTestImplementation libs.multidex
 
-    testCompile libs.junit
-    testCompile ("$libs.test_runner") {
+    testImplementation libs.junit
+    testImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
 }
diff --git a/design/tests/src/android/support/design/widget/AppBarWithToolbarTest.java b/design/tests/src/android/support/design/widget/AppBarWithToolbarTest.java
index 7045faf..fd5cd26 100644
--- a/design/tests/src/android/support/design/widget/AppBarWithToolbarTest.java
+++ b/design/tests/src/android/support/design/widget/AppBarWithToolbarTest.java
@@ -24,6 +24,7 @@
 import android.graphics.Rect;
 import android.support.design.test.R;
 import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.v4.view.ViewCompat;
 import android.view.View;
@@ -37,6 +38,7 @@
     /**
      * Tests a Toolbar with fitSystemWindows = undefined, with a fitSystemWindows = true parent
      */
+    @LargeTest
     @Test
     public void testScrollToolbarWithFitSystemWindowsParent() throws Throwable {
         configureContent(R.layout.design_appbar_toolbar_scroll_fitsystemwindows_parent,
diff --git a/design/tests/src/android/support/design/widget/BottomSheetBehaviorTest.java b/design/tests/src/android/support/design/widget/BottomSheetBehaviorTest.java
index 6d040d4..fbb44eb 100644
--- a/design/tests/src/android/support/design/widget/BottomSheetBehaviorTest.java
+++ b/design/tests/src/android/support/design/widget/BottomSheetBehaviorTest.java
@@ -45,6 +45,7 @@
 import android.support.test.espresso.assertion.ViewAssertions;
 import android.support.test.espresso.core.deps.guava.base.Preconditions;
 import android.support.test.espresso.matcher.ViewMatchers;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.filters.SmallTest;
 import android.support.v4.view.ViewCompat;
@@ -303,7 +304,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testSwipeDownToCollapse() throws Throwable {
         checkSetState(BottomSheetBehavior.STATE_EXPANDED, ViewMatchers.isDisplayed());
         Espresso.onView(ViewMatchers.withId(R.id.bottom_sheet))
@@ -362,7 +363,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testSkipCollapsed() throws Throwable {
         getBehavior().setSkipCollapsed(true);
         checkSetState(BottomSheetBehavior.STATE_EXPANDED, ViewMatchers.isDisplayed());
@@ -500,7 +501,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testNestedScroll() throws Throwable {
         final ViewGroup bottomSheet = getBottomSheet();
         final BottomSheetBehavior behavior = getBehavior();
diff --git a/design/tests/src/android/support/design/widget/BottomSheetDialogTest.java b/design/tests/src/android/support/design/widget/BottomSheetDialogTest.java
index c434f9f..8ca9b1d 100644
--- a/design/tests/src/android/support/design/widget/BottomSheetDialogTest.java
+++ b/design/tests/src/android/support/design/widget/BottomSheetDialogTest.java
@@ -39,6 +39,7 @@
 import android.support.test.espresso.action.ViewActions;
 import android.support.test.espresso.assertion.ViewAssertions;
 import android.support.test.espresso.matcher.ViewMatchers;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.v7.widget.AppCompatTextView;
 import android.view.View;
@@ -233,7 +234,7 @@
 
     @SuppressWarnings("WrongConstant")
     @Test
-    @MediumTest
+    @LargeTest
     public void testHideThenShow() throws Throwable {
         // Hide the bottom sheet and wait for the dialog to be canceled.
         final DialogInterface.OnCancelListener onCancelListener = mock(
diff --git a/design/tests/src/android/support/design/widget/CustomSnackbarTest.java b/design/tests/src/android/support/design/widget/CustomSnackbarTest.java
index 4fc2525..cc6ed1a 100644
--- a/design/tests/src/android/support/design/widget/CustomSnackbarTest.java
+++ b/design/tests/src/android/support/design/widget/CustomSnackbarTest.java
@@ -228,7 +228,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDismissViaTimeout() throws Throwable {
         verifyDismissCallback(
                 onView(isAssignableFrom(Snackbar.SnackbarLayout.class)),
diff --git a/design/tests/src/android/support/design/widget/NavigationViewTest.java b/design/tests/src/android/support/design/widget/NavigationViewTest.java
index e7e922a..a1ea451 100755
--- a/design/tests/src/android/support/design/widget/NavigationViewTest.java
+++ b/design/tests/src/android/support/design/widget/NavigationViewTest.java
@@ -69,7 +69,7 @@
 import android.support.annotation.IdRes;
 import android.support.design.test.R;
 import android.support.design.testutils.TestDrawable;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.SdkSuppress;
 import android.support.v4.content.res.ResourcesCompat;
 import android.support.v4.view.GravityCompat;
@@ -90,7 +90,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
-@MediumTest
+@LargeTest
 public class NavigationViewTest
         extends BaseInstrumentationTestCase<NavigationViewActivity> {
     private static final int[] MENU_CONTENT_ITEM_IDS = { R.id.destination_home,
diff --git a/design/tests/src/android/support/design/widget/SnackbarTest.java b/design/tests/src/android/support/design/widget/SnackbarTest.java
index 5f5682c..0d0a891 100644
--- a/design/tests/src/android/support/design/widget/SnackbarTest.java
+++ b/design/tests/src/android/support/design/widget/SnackbarTest.java
@@ -50,6 +50,7 @@
 import android.support.test.espresso.action.GeneralSwipeAction;
 import android.support.test.espresso.action.Press;
 import android.support.test.espresso.action.Swipe;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.v4.view.ViewCompat;
 import android.text.TextUtils;
@@ -102,6 +103,7 @@
         SnackbarUtils.dismissTransientBottomBarAndWaitUntilFullyDismissed(snackbar);
     }
 
+    @LargeTest
     @Test
     public void testBasicContent() throws Throwable {
         // Verify different combinations of snackbar content (message and action) and duration
@@ -235,6 +237,7 @@
                 Snackbar.Callback.DISMISS_EVENT_MANUAL);
     }
 
+    @LargeTest
     @Test
     public void testDismissViaTimeout() throws Throwable {
         verifyDismissCallback(
@@ -245,6 +248,7 @@
                 Snackbar.Callback.DISMISS_EVENT_TIMEOUT);
     }
 
+    @LargeTest
     @Test
     public void testSwipeUpDismissesViaTimeout() throws Throwable {
         verifyDismissCallback(
diff --git a/design/tests/src/android/support/design/widget/TabLayoutWithViewPagerTest.java b/design/tests/src/android/support/design/widget/TabLayoutWithViewPagerTest.java
index 09bf43c..b169dad 100755
--- a/design/tests/src/android/support/design/widget/TabLayoutWithViewPagerTest.java
+++ b/design/tests/src/android/support/design/widget/TabLayoutWithViewPagerTest.java
@@ -44,7 +44,6 @@
 import android.support.test.espresso.UiController;
 import android.support.test.espresso.ViewAction;
 import android.support.test.filters.LargeTest;
-import android.support.test.filters.MediumTest;
 import android.support.test.filters.SmallTest;
 import android.support.v4.view.PagerAdapter;
 import android.support.v4.view.ViewPager;
@@ -469,7 +468,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testFixedTabMode() {
         // Create a new adapter (with no content)
         final TextPagerAdapter newAdapter = new TextPagerAdapter();
diff --git a/dynamic-animation/build.gradle b/dynamic-animation/build.gradle
index 49cfbfc..2667bef 100644
--- a/dynamic-animation/build.gradle
+++ b/dynamic-animation/build.gradle
@@ -1,17 +1,16 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-dynamic-animation'
 
 dependencies {
-    compile project(':support-core-utils')
+    api project(':support-core-utils')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
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 1e891eb..588434d 100644
--- a/dynamic-animation/tests/src/android/support/dynamicanimation/tests/SpringTests.java
+++ b/dynamic-animation/tests/src/android/support/dynamicanimation/tests/SpringTests.java
@@ -40,6 +40,7 @@
 import android.support.animation.SpringForce;
 import android.support.dynamicanimation.test.R;
 import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
@@ -305,6 +306,7 @@
      * Verify that stiffer spring animations finish sooner than less stiff spring animations. Run
      * the same verification on different damping ratios.
      */
+    @LargeTest
     @Test
     public void testStiffness() {
         float[] dampingRatios = {0.3f, 0.5f, 1f, 5f};
diff --git a/emoji/appcompat/build.gradle b/emoji/appcompat/build.gradle
index 42cba1e..5e9f83a 100644
--- a/emoji/appcompat/build.gradle
+++ b/emoji/appcompat/build.gradle
@@ -15,21 +15,20 @@
  */
 
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-emoji-appcompat'
 
 dependencies {
-    compile fileTree(include: ['*.jar'], dir: 'libs')
-    compile project(':support-emoji')
-    compile project(':support-appcompat-v7')
+    api fileTree(include: ['*.jar'], dir: 'libs')
+    api project(':support-emoji')
+    api project(':support-appcompat-v7')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
diff --git a/emoji/bundled/build.gradle b/emoji/bundled/build.gradle
index 05fb17f..1309a72 100644
--- a/emoji/bundled/build.gradle
+++ b/emoji/bundled/build.gradle
@@ -1,5 +1,4 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-emoji-bundled'
 
 ext {
     fontDir = project(':noto-emoji-compat').projectDir
@@ -19,7 +18,7 @@
 }
 
 dependencies {
-    compile project(path: ':support-emoji')
+    api project(':support-emoji')
 }
 
 supportLibrary {
diff --git a/emoji/core/build.gradle b/emoji/core/build.gradle
index c9f29dc..87daa69 100644
--- a/emoji/core/build.gradle
+++ b/emoji/core/build.gradle
@@ -1,5 +1,4 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-emoji'
 
 ext {
     fontDir = project(':noto-emoji-compat').projectDir
@@ -7,18 +6,18 @@
 
 evaluationDependsOn(':noto-emoji-compat')
 dependencies {
-    compile project(':support-compat')
-    compile files(project(':noto-emoji-compat').configurations.parser.artifacts.getFiles())
+    api project(':support-compat')
+    api files(project(':noto-emoji-compat').configurations.parser.artifacts.getFiles())
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(':support-testutils')
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation project(':support-testutils')
 }
 
 android {
diff --git a/exifinterface/build.gradle b/exifinterface/build.gradle
index 583ed93..26b6069 100644
--- a/exifinterface/build.gradle
+++ b/exifinterface/build.gradle
@@ -1,10 +1,9 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'exifinterface'
 
 dependencies {
-    compile project(':support-annotations')
+    api project(':support-annotations')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
 }
diff --git a/fragment/build.gradle b/fragment/build.gradle
index 79921a2..86917e9 100644
--- a/fragment/build.gradle
+++ b/fragment/build.gradle
@@ -1,19 +1,18 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-fragment'
 
 dependencies {
-    compile project(':support-compat')
-    compile project(':support-core-ui')
-    compile project(':support-core-utils')
+    api project(':support-compat')
+    api project(':support-core-ui')
+    api project(':support-core-utils')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
diff --git a/fragment/tests/java/android/support/v4/app/PostponedTransitionTest.java b/fragment/tests/java/android/support/v4/app/PostponedTransitionTest.java
index bdb73c2..d0baf36 100644
--- a/fragment/tests/java/android/support/v4/app/PostponedTransitionTest.java
+++ b/fragment/tests/java/android/support/v4/app/PostponedTransitionTest.java
@@ -28,7 +28,7 @@
 import android.os.Parcelable;
 import android.support.fragment.test.R;
 import android.support.test.InstrumentationRegistry;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.SdkSuppress;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
@@ -43,7 +43,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
 public class PostponedTransitionTest {
diff --git a/gradle.properties b/gradle.properties
index 9b77c57..71f1c7a 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,3 +4,4 @@
 # org.gradle.configureondemand=true
 org.gradle.parallel=true
 android.useDexArchive=false
+android.builder.sdkDownload=false
diff --git a/graphics/drawable/animated/build.gradle b/graphics/drawable/animated/build.gradle
index 00a3688..f218e0b 100644
--- a/graphics/drawable/animated/build.gradle
+++ b/graphics/drawable/animated/build.gradle
@@ -1,15 +1,15 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'animated-vector-drawable'
 
 dependencies {
-    compile project(':support-vector-drawable')
-    androidTestCompile (libs.test_runner) {
+    api project(':support-vector-drawable')
+    api project(':support-core-ui')
+
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    compile project(path: ':support-core-ui')
 }
 
 android {
diff --git a/graphics/drawable/static/build.gradle b/graphics/drawable/static/build.gradle
index 996a855..e820bb1 100644
--- a/graphics/drawable/static/build.gradle
+++ b/graphics/drawable/static/build.gradle
@@ -1,10 +1,10 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-vector-drawable'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-compat')
-    androidTestCompile (libs.test_runner) {
+    api project(':support-annotations')
+    api project(':support-compat')
+
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
 }
diff --git a/media-compat/build.gradle b/media-compat/build.gradle
index 9d28f80..2f1fbe7 100644
--- a/media-compat/build.gradle
+++ b/media-compat/build.gradle
@@ -1,19 +1,18 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-media-compat'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-compat')
+    api project(':support-annotations')
+    api project(':support-compat')
 
-    androidTestCompile(libs.test_runner) {
+    androidTestImplementation(libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile(libs.espresso_core) {
+    androidTestImplementation(libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(':support-testutils')
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation project(':support-testutils')
 }
 
 android {
diff --git a/percent/build.gradle b/percent/build.gradle
index 90c2962..4738118 100644
--- a/percent/build.gradle
+++ b/percent/build.gradle
@@ -1,12 +1,12 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'percent'
 
 dependencies {
-    compile project(':support-compat')
-    androidTestCompile (libs.test_runner) {
+    api project(':support-compat')
+
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
 }
diff --git a/recommendation/build.gradle b/recommendation/build.gradle
index 9becae9..8b660f2 100644
--- a/recommendation/build.gradle
+++ b/recommendation/build.gradle
@@ -1,8 +1,7 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'recommendation'
 
 dependencies {
-    compile project(':support-v4')
+    api project(':support-v4')
 }
 
 android {
diff --git a/samples/Support13Demos/build.gradle b/samples/Support13Demos/build.gradle
index c63312f..4c015ae 100644
--- a/samples/Support13Demos/build.gradle
+++ b/samples/Support13Demos/build.gradle
@@ -1,7 +1,7 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-v13')
+    implementation project(':support-v13')
 }
 
 android {
diff --git a/samples/Support4Demos/build.gradle b/samples/Support4Demos/build.gradle
index 836b212..e265698 100644
--- a/samples/Support4Demos/build.gradle
+++ b/samples/Support4Demos/build.gradle
@@ -1,7 +1,7 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-v4')
+    implementation project(':support-v4')
 }
 
 android {
diff --git a/samples/Support7Demos/build.gradle b/samples/Support7Demos/build.gradle
index 618cfab..49b38ec 100644
--- a/samples/Support7Demos/build.gradle
+++ b/samples/Support7Demos/build.gradle
@@ -1,12 +1,12 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-appcompat-v7')
-    compile project(':support-cardview-v7')
-    compile project(':support-gridlayout-v7')
-    compile project(':support-mediarouter-v7')
-    compile project(':support-palette-v7')
-    compile project(':support-recyclerview-v7')
+    implementation project(':support-appcompat-v7')
+    implementation project(':support-cardview-v7')
+    implementation project(':support-gridlayout-v7')
+    implementation project(':support-mediarouter-v7')
+    implementation project(':support-palette-v7')
+    implementation project(':support-recyclerview-v7')
 }
 
 android {
diff --git a/samples/SupportAnimationDemos/build.gradle b/samples/SupportAnimationDemos/build.gradle
index c619f6b..d1ea614 100644
--- a/samples/SupportAnimationDemos/build.gradle
+++ b/samples/SupportAnimationDemos/build.gradle
@@ -1,7 +1,7 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-dynamic-animation')
+    implementation project(':support-dynamic-animation')
 }
 
 android {
diff --git a/samples/SupportAppNavigation/build.gradle b/samples/SupportAppNavigation/build.gradle
index bb48f2f..c7d03b8 100644
--- a/samples/SupportAppNavigation/build.gradle
+++ b/samples/SupportAppNavigation/build.gradle
@@ -17,7 +17,7 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-v4')
+    implementation project(':support-v4')
 }
 
 android {
diff --git a/samples/SupportDesignDemos/build.gradle b/samples/SupportDesignDemos/build.gradle
index 7987f52..48dfc9c 100644
--- a/samples/SupportDesignDemos/build.gradle
+++ b/samples/SupportDesignDemos/build.gradle
@@ -1,7 +1,7 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-design')
+    implementation project(':support-design')
 }
 
 android {
diff --git a/samples/SupportEmojiDemos/build.gradle b/samples/SupportEmojiDemos/build.gradle
index 230e478..c5be42e 100644
--- a/samples/SupportEmojiDemos/build.gradle
+++ b/samples/SupportEmojiDemos/build.gradle
@@ -21,9 +21,9 @@
 }
 
 dependencies {
-    compile project(':support-emoji')
-    compile project(':support-emoji-bundled')
-    compile project(':support-emoji-appcompat')
+    implementation project(':support-emoji')
+    implementation project(':support-emoji-bundled')
+    implementation project(':support-emoji-appcompat')
 }
 
 android {
diff --git a/samples/SupportLeanbackDemos/build.gradle b/samples/SupportLeanbackDemos/build.gradle
index ea6ed9e..4ec403e 100644
--- a/samples/SupportLeanbackDemos/build.gradle
+++ b/samples/SupportLeanbackDemos/build.gradle
@@ -1,8 +1,8 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-leanback-v17')
-    compile project(':support-preference-leanback-v17')
+    implementation project(':support-leanback-v17')
+    implementation project(':support-preference-leanback-v17')
 }
 
 android {
diff --git a/samples/SupportLeanbackJank/build.gradle b/samples/SupportLeanbackJank/build.gradle
index 44346f7..4900a65 100644
--- a/samples/SupportLeanbackJank/build.gradle
+++ b/samples/SupportLeanbackJank/build.gradle
@@ -1,9 +1,9 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile 'com.github.bumptech.glide:glide:3.6.1'
-    compile project(':support-leanback-v17')
-    compile project(':support-preference-leanback-v17')
+    implementation 'com.github.bumptech.glide:glide:3.6.1'
+    implementation project(':support-leanback-v17')
+    implementation project(':support-preference-leanback-v17')
 }
 
 android {
diff --git a/samples/SupportPercentDemos/build.gradle b/samples/SupportPercentDemos/build.gradle
index 7990a21..863da83 100644
--- a/samples/SupportPercentDemos/build.gradle
+++ b/samples/SupportPercentDemos/build.gradle
@@ -1,7 +1,7 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-percent')
+    implementation project(':support-percent')
 }
 
 android {
diff --git a/samples/SupportPreferenceDemos/build.gradle b/samples/SupportPreferenceDemos/build.gradle
index 5bee5e9..d09e3db 100644
--- a/samples/SupportPreferenceDemos/build.gradle
+++ b/samples/SupportPreferenceDemos/build.gradle
@@ -1,12 +1,12 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-appcompat-v7')
-    compile project(':support-recyclerview-v7')
-    compile project(':support-preference-v7')
-    compile project(':support-preference-v14')
-    compile project(':support-leanback-v17')
-    compile project(':support-preference-leanback-v17')
+    implementation project(':support-appcompat-v7')
+    implementation project(':support-recyclerview-v7')
+    implementation project(':support-preference-v7')
+    implementation project(':support-preference-v14')
+    implementation project(':support-leanback-v17')
+    implementation project(':support-preference-leanback-v17')
 }
 
 android {
diff --git a/samples/SupportTransitionDemos/build.gradle b/samples/SupportTransitionDemos/build.gradle
index 7eda8b3..2a4fffc 100644
--- a/samples/SupportTransitionDemos/build.gradle
+++ b/samples/SupportTransitionDemos/build.gradle
@@ -1,8 +1,8 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-transition')
-    compile project(':support-appcompat-v7')
+    implementation project(':support-transition')
+    implementation project(':support-appcompat-v7')
 }
 
 android {
diff --git a/samples/SupportVectorDrawableDemos/build.gradle b/samples/SupportVectorDrawableDemos/build.gradle
index 8520eb1..79383ca 100644
--- a/samples/SupportVectorDrawableDemos/build.gradle
+++ b/samples/SupportVectorDrawableDemos/build.gradle
@@ -17,9 +17,9 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-vector-drawable')
-    compile project(':support-animated-vector-drawable')
-    compile project(':support-appcompat-v7')
+    implementation project(':support-vector-drawable')
+    implementation project(':support-animated-vector-drawable')
+    implementation project(':support-appcompat-v7')
 }
 
 android {
diff --git a/samples/SupportWearDemos/build.gradle b/samples/SupportWearDemos/build.gradle
index a4d0c61..4a22995 100644
--- a/samples/SupportWearDemos/build.gradle
+++ b/samples/SupportWearDemos/build.gradle
@@ -17,7 +17,7 @@
 apply plugin: 'com.android.application'
 
 dependencies {
-    compile project(':support-wear')
+    implementation project(':support-wear')
 }
 
 android {
diff --git a/transition/build.gradle b/transition/build.gradle
index decde29..92c5ec6 100644
--- a/transition/build.gradle
+++ b/transition/build.gradle
@@ -1,19 +1,17 @@
 apply plugin: android.support.SupportLibraryPlugin
 
-archivesBaseName = 'transition'
-
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-v4')
+    api project(':support-annotations')
+    api project(':support-v4')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
diff --git a/transition/tests/src/android/support/transition/AutoTransitionTest.java b/transition/tests/src/android/support/transition/AutoTransitionTest.java
index 137f6d3..2c9a77f 100644
--- a/transition/tests/src/android/support/transition/AutoTransitionTest.java
+++ b/transition/tests/src/android/support/transition/AutoTransitionTest.java
@@ -22,6 +22,7 @@
 
 import android.graphics.Color;
 import android.support.test.annotation.UiThreadTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.view.View;
 import android.widget.LinearLayout;
@@ -48,6 +49,7 @@
         mRoot.addView(mView1, new LinearLayout.LayoutParams(100, 100));
     }
 
+    @LargeTest
     @Test
     public void testLayoutBetweenFadeAndChangeBounds() throws Throwable {
         final LayoutCounter counter = new LayoutCounter();
diff --git a/transition/tests/src/android/support/transition/SlideEdgeTest.java b/transition/tests/src/android/support/transition/SlideEdgeTest.java
index 0ddf210..af8d0b6 100644
--- a/transition/tests/src/android/support/transition/SlideEdgeTest.java
+++ b/transition/tests/src/android/support/transition/SlideEdgeTest.java
@@ -25,6 +25,7 @@
 import static org.mockito.Mockito.verify;
 
 import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.transition.test.R;
 import android.view.Gravity;
@@ -61,6 +62,7 @@
         }
     }
 
+    @LargeTest
     @Test
     public void testSlideOut() throws Throwable {
         for (int i = 0; i < sSlideEdgeArray.length; i++) {
@@ -144,6 +146,7 @@
         }
     }
 
+    @LargeTest
     @Test
     public void testSlideIn() throws Throwable {
         for (int i = 0; i < sSlideEdgeArray.length; i++) {
diff --git a/tv-provider/build.gradle b/tv-provider/build.gradle
index 23146c9..2a129f4 100644
--- a/tv-provider/build.gradle
+++ b/tv-provider/build.gradle
@@ -1,10 +1,10 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-tv-provider'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-compat')
-    androidTestCompile (libs.test_runner) {
+    api project(':support-annotations')
+    api project(':support-compat')
+
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
 }
diff --git a/v13/build.gradle b/v13/build.gradle
index 9c25738..8019c0e 100644
--- a/v13/build.gradle
+++ b/v13/build.gradle
@@ -1,18 +1,17 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-v13'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-v4')
+    api project(':support-annotations')
+    api project(':support-v4')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
diff --git a/v14/preference/build.gradle b/v14/preference/build.gradle
index e36ab82..bdb8c05 100644
--- a/v14/preference/build.gradle
+++ b/v14/preference/build.gradle
@@ -15,13 +15,12 @@
  */
 
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'preference-v14'
 
 dependencies {
-    compile project(':support-v4')
-    compile project(':support-appcompat-v7')
-    compile project(':support-recyclerview-v7')
-    compile project(':support-preference-v7')
+    api project(':support-v4')
+    api project(':support-appcompat-v7')
+    api project(':support-recyclerview-v7')
+    api project(':support-preference-v7')
 }
 
 android {
diff --git a/v17/leanback/build.gradle b/v17/leanback/build.gradle
index a2e7342..a3cac9d 100644
--- a/v17/leanback/build.gradle
+++ b/v17/leanback/build.gradle
@@ -1,22 +1,21 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'leanback-v17'
 
 dependencies {
-    compile project(':support-compat')
-    compile project(':support-core-ui')
-    compile project(':support-media-compat')
-    compile project(':support-fragment')
-    compile project(':support-recyclerview-v7')
+    api project(':support-compat')
+    api project(':support-core-ui')
+    api project(':support-media-compat')
+    api project(':support-fragment')
+    api project(':support-recyclerview-v7')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile libs.multidex
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation libs.multidex
 }
 
 android {
diff --git a/v17/leanback/res/values-bg/strings.xml b/v17/leanback/res/values-bg/strings.xml
index 4099672..917519d 100644
--- a/v17/leanback/res/values-bg/strings.xml
+++ b/v17/leanback/res/values-bg/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Активиране на субтитрите"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Деактивиране на субтитрите"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Вход в режима „Картина в картина“"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Контролите за мултимедия са показани"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Контролите за мултимедия са скрити. Натиснете контролния пад, за да се покажат"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Край"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Напред"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"Код на грешката на MediaPlayer %1$d (допълнително: %2$d)"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ПЪРВИ СТЪПКИ"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Напред"</string>
 </resources>
diff --git a/v17/leanback/res/values-bn/strings.xml b/v17/leanback/res/values-bn/strings.xml
index 949faac..d921817 100644
--- a/v17/leanback/res/values-bn/strings.xml
+++ b/v17/leanback/res/values-bn/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"সাবটাইটেল সক্ষম করুন"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"সাবটাইটেল অক্ষম করুন"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"ছবি মোডে ছবি লগান"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"মিডিয়ার নিয়ন্ত্রণগুলি দেখানো হয়েছে"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"মিডিয়ার নিয়ন্ত্রণগুলি লুকানো আছে, দেখার জন্য ডি-প্যাড টিপুন"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"শেষ করুন"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"চালিয়ে যান"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer ত্রুটি কোড %1$d অতিরিক্ত %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"শুরু করা যাক"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"পরবর্তী"</string>
 </resources>
diff --git a/v17/leanback/res/values-da/strings.xml b/v17/leanback/res/values-da/strings.xml
index 97c4a32..4174eba 100644
--- a/v17/leanback/res/values-da/strings.xml
+++ b/v17/leanback/res/values-da/strings.xml
@@ -47,15 +47,17 @@
     <string name="lb_playback_controls_high_quality_disable" msgid="8637371582779057866">"Deaktiver høj kvalitet"</string>
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Aktivér undertekster"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Deaktiver undertekster"</string>
-    <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Tilstand med integreret billede"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Tilføj billedet i billedtilstand"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Knapperne til afspilning er synlige"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Knapperne til afspilning er skjult. Tryk på D-pad\'en for at se dem"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Afslut"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Fortsæt"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer-fejlkode %1$d ekstra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"KOM GODT I GANG"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Næste"</string>
 </resources>
diff --git a/v17/leanback/res/values-fa/strings.xml b/v17/leanback/res/values-fa/strings.xml
index daa6bab..b85d1fa 100644
--- a/v17/leanback/res/values-fa/strings.xml
+++ b/v17/leanback/res/values-fa/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"فعال کردن زیرنویس"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"غیرفعال کردن زیرنویس"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"وارد حالت تصویر در تصویر شوید"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"کنترل‌های رسانه نشان داده می‌شوند"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"‏کنترل‌های رسانه پنهان هستند، برای نمایش آن‌ها d-pad (پد کنترل) را فشار دهید"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"پایان"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ادامه"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"‏کد خطای MediaPlayer‏ %1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"شروع به‌ کار"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"بعدی"</string>
 </resources>
diff --git a/v17/leanback/res/values-gu/strings.xml b/v17/leanback/res/values-gu/strings.xml
index 12796b3..bf94e68 100644
--- a/v17/leanback/res/values-gu/strings.xml
+++ b/v17/leanback/res/values-gu/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"ઉપશીર્ષક સક્ષમ કરો"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"વિગતવાર ઉપશીર્ષકોને અક્ષમ કરો"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"ચિત્ર મોડમાં ચિત્ર દાખલ કરો"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"મીડિયા નિયંત્રણો બતાવેલા છે"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"મીડિયા નિયંત્રણો છુપાયેલા છે, તે બતાવવા માટે d-પૅડ દબાવો"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"સમાપ્ત કરો"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ચાલુ રાખો"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer ભૂલ કોડ %1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"પ્રારંભ કરો"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"આગલું"</string>
 </resources>
diff --git a/v17/leanback/res/values-hu/strings.xml b/v17/leanback/res/values-hu/strings.xml
index c0f89c3..a2b497d 100644
--- a/v17/leanback/res/values-hu/strings.xml
+++ b/v17/leanback/res/values-hu/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Feliratok engedélyezése"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Feliratok letiltása"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Kép a képben mód indítása"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Médiavezérlők megjelenítve"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"A médiavezérlők el vannak rejtve. Megjelenítésükhöz nyomja le a d-padet."</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Befejezés"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Folytatás"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer-hibakód: %1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"KEZDŐ LÉPÉSEK"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Következő"</string>
 </resources>
diff --git a/v17/leanback/res/values-iw/strings.xml b/v17/leanback/res/values-iw/strings.xml
index f4761a1..a3ea4b9 100644
--- a/v17/leanback/res/values-iw/strings.xml
+++ b/v17/leanback/res/values-iw/strings.xml
@@ -31,8 +31,8 @@
     <string name="lb_playback_controls_fast_forward_multiplier" msgid="1058753672110224526">"‏העברה קדימה של %1$dX"</string>
     <string name="lb_playback_controls_rewind" msgid="2227196334132350684">"הרץ אחורה"</string>
     <string name="lb_playback_controls_rewind_multiplier" msgid="1640629531440849942">"‏העברה לאחור של %1$dX"</string>
-    <string name="lb_playback_controls_skip_next" msgid="2946499493161095772">"ברצוני לדלג אל הפריט הבא"</string>
-    <string name="lb_playback_controls_skip_previous" msgid="2326801832933178348">"ברצוני לדלג אל הפריט הקודם"</string>
+    <string name="lb_playback_controls_skip_next" msgid="2946499493161095772">"דלג אל הפריט הבא"</string>
+    <string name="lb_playback_controls_skip_previous" msgid="2326801832933178348">"דלג אל הפריט הקודם"</string>
     <string name="lb_playback_controls_more_actions" msgid="2330770008796987655">"עוד פעולות"</string>
     <string name="lb_playback_controls_thumb_up" msgid="6530420347129222601">"בטל בחירה באגודל כלפי מעלה"</string>
     <string name="lb_playback_controls_thumb_up_outline" msgid="1577637924003500946">"בחר באגודל כלפי מעלה"</string>
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"הפעל כתוביות"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"השבת כתוביות"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"הזן את התמונה במצב תמונה"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"פקדי המדיה מוצגים"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"‏פקדי המדיה מוסתרים. הקש על ה-d-pad כדי להציג אותם"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"סיום"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"המשך"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"‏קוד שגיאה %1$d‏ של MediaPlayer ועוד %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"התחל"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"הבא"</string>
 </resources>
diff --git a/v17/leanback/res/values-ka/strings.xml b/v17/leanback/res/values-ka/strings.xml
index 19d919c..ef148b0 100644
--- a/v17/leanback/res/values-ka/strings.xml
+++ b/v17/leanback/res/values-ka/strings.xml
@@ -52,14 +52,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"დახურული წარწერების ჩართვა"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"დახურული წარწერების გაუქმება"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"რეჟიმზე „სურათი სურათში“ გადასვლა"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"ნაჩვენებია მედიის მართვის საშუალებები"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"მედიის მართვის საშუალებები დამალულია, გამოსაჩენად დააჭირეთ D-pad-ს"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"დასრულება"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"გაგრძელება"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer-ის შეცდომის კოდი: %1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"დაწყება"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"შემდეგი"</string>
 </resources>
diff --git a/v17/leanback/res/values-km/strings.xml b/v17/leanback/res/values-km/strings.xml
index 8439d31..c2dd333 100644
--- a/v17/leanback/res/values-km/strings.xml
+++ b/v17/leanback/res/values-km/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"បើក​ការ​ដាក់​ចំណង​ដែល​បាន​បិទ"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"បិទ​ការ​ដាក់​ចំណង​ដែល​បាន​បិទ"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"បញ្ចូលរូបភាពនៅក្នុងរបៀបរូបភាព"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"ការ​គ្រប់គ្រង​មេឌៀ​ត្រូវ​បាន​បង្ហាញ"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"ការ​គ្រប់គ្រង​មេឌៀ​ត្រូវ​បាន​លាក់ សូមចុច d-pad ដើម្បី​បង្ហាញ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"បញ្ចប់"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"បន្ត"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">"៖"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"លេខកូដបញ្ហា MediaPlayer %1$d និង %2$d បន្ថែម"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ចាប់ផ្ដើម"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"បន្ទាប់"</string>
 </resources>
diff --git a/v17/leanback/res/values-kn/strings.xml b/v17/leanback/res/values-kn/strings.xml
index dd14e38..f797a9e 100644
--- a/v17/leanback/res/values-kn/strings.xml
+++ b/v17/leanback/res/values-kn/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"ಮುಚ್ಚಿದ ಶೀರ್ಷಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"ಮುಚ್ಚಿದ ಶೀರ್ಷಿಕೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಿ"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"ಚಿತ್ರವನ್ನು ಚಿತ್ರ ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರವೇಶಿಸಿ"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"ಮಾಧ್ಯಮ ನಿಯಂತ್ರಣಗಳನ್ನು ತೋರಿಸಲಾಗಿದೆ"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"ಮಾಧ್ಯಮ ನಿಯಂತ್ರಣಗಳನ್ನು ಮರೆಮಾಡಲಾಗಿದೆ, ತೋರಿಸಲು d-pad ಒತ್ತಿರಿ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ಪೂರ್ಣಗೊಳಿಸು"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ಮುಂದುವರಿಸು"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"ಮೀಡಿಯಾ ಪ್ಲೇಯರ್ ದೋಷ ಕೋಡ್ %1$d ಹೆಚ್ಚುವರಿ %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ಪ್ರಾರಂಭಿಸಿ"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"ಮುಂದೆ"</string>
 </resources>
diff --git a/v17/leanback/res/values-ko/strings.xml b/v17/leanback/res/values-ko/strings.xml
index 8443a25..b418937 100644
--- a/v17/leanback/res/values-ko/strings.xml
+++ b/v17/leanback/res/values-ko/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"자막 사용 설정"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"자막 사용 중지"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"사진 모드에서 사진 입력"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"미디어 컨트롤이 표시되었습니다."</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"미디어 컨트롤이 숨겨져 있습니다. 표시하려면 D-Pad를 누르세요."</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"완료"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"계속"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer 오류 코드 %1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"시작하기"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"다음"</string>
 </resources>
diff --git a/v17/leanback/res/values-ky/strings.xml b/v17/leanback/res/values-ky/strings.xml
index 80c7af2..3c52130 100644
--- a/v17/leanback/res/values-ky/strings.xml
+++ b/v17/leanback/res/values-ky/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Жабык субтитрлерди иштетүү"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Жабык субтитрлерди өчүрүү"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Сүрөт режиминде сүрөт киргизүү"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Медиа файлды башкаруу көрсөтүлдү"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Медиа файлды башкаруу жашырылган, көрүү үчүн d-pad көзөмөлдөө каражатын басыңыз"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Бүтүрүү"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Улантуу"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer\'деги катанын коду: 1$d, кошумча: %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"БАШТАДЫК"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Кийинки"</string>
 </resources>
diff --git a/v17/leanback/res/values-lo/strings.xml b/v17/leanback/res/values-lo/strings.xml
index 7fb28b8..b4f4844 100644
--- a/v17/leanback/res/values-lo/strings.xml
+++ b/v17/leanback/res/values-lo/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"​ເປີດ​ນຳ​ໃຊ້​​ຄຳ​ບັນ​ຍາຍ​ແບບ​ປິດ"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"​ປິດ​ນຳ​ໃຊ້​ຄຳ​ບັນ​ຍາຍ​ແບບ​ປິດ"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"ປ້ອນຮູບພາບໃນໂໝດຮູບພາບ"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"ສະແດງຕົວຄວບຄຸມມີເດຍແລ້ວ"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"ເຊື່ອງຕົວຄວບຄຸມມີເດຍແລ້ວ, ກົດປຸ່ມທິດທາງເພື່ອສະແດງ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ສໍາເລັດ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"​ສືບ​ຕໍ່"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"ລະຫັດ MediaPlayer ຜິດພາດ %1$d ພິເສດ %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ເລີ່ມຕົ້ນນຳໃຊ້"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"ຕໍ່ໄປ"</string>
 </resources>
diff --git a/v17/leanback/res/values-lt/strings.xml b/v17/leanback/res/values-lt/strings.xml
index b9d6076..61692d5 100644
--- a/v17/leanback/res/values-lt/strings.xml
+++ b/v17/leanback/res/values-lt/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Įgalinti subtitrus"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Išjungti subtitrus"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Įjungti vaizdo vaizde režimą"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Medijos valdikliai rodomi"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Medijos valdikliai paslėpti. Paspauskite krypčių valdiklius, kad rodytumėte"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Baigti"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Tęsti"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"%1$d ir %2$d „MediaPlayer“ klaidos kodas"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"PRADĖTI"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Kitas"</string>
 </resources>
diff --git a/v17/leanback/res/values-lv/strings.xml b/v17/leanback/res/values-lv/strings.xml
index 8f69284..b1e36dd 100644
--- a/v17/leanback/res/values-lv/strings.xml
+++ b/v17/leanback/res/values-lv/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Iespējot slēgtos parakstus"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Atspējot slēgtos parakstus"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Aktivizēt režīmu Attēls attēlā"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Multivides vadīklas ir redzamas."</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Multivides vadīklas ir paslēptas. Nospiediet virzienu tastatūru, lai tās tiktu parādītas."</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Pabeigt"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Turpināt"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer kļūdas kods: %1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"SĀKT DARBU"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Nākamā"</string>
 </resources>
diff --git a/v17/leanback/res/values-ml/strings.xml b/v17/leanback/res/values-ml/strings.xml
index 41ac9d5..03dc391 100644
--- a/v17/leanback/res/values-ml/strings.xml
+++ b/v17/leanback/res/values-ml/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"അടച്ച അടിക്കുറിപ്പ് നൽകൽ പ്രവർത്തനക്ഷമമാക്കുക"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"അടച്ച അടിക്കുറിപ്പ് നൽകൽ പ്രവർത്തനരഹിതമാക്കുക"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"\'ചിത്രത്തിനുള്ളിൽ ചിത്രം\' മോഡിലേക്ക് പ്രവേശിക്കുക"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"മീഡിയ നിയന്ത്രണങ്ങൾ ‌കാണിച്ചിരിക്കുന്നു"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"മീഡിയ നിയന്ത്രണങ്ങൾ ‌മറച്ചിരിക്കുന്നു, കാണിക്കുന്നതിന് ഡി-‌പാഡ് അമർത്തുക"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"പൂര്‍ത്തിയാക്കുക"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"തുടരുക"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"മീഡിയ പ്ലെയർ പിശക് കോഡ്: %1$d, കൂടെ %2$d എന്നതും"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ആരംഭിക്കുക"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"അടുത്തത്"</string>
 </resources>
diff --git a/v17/leanback/res/values-mn/strings.xml b/v17/leanback/res/values-mn/strings.xml
index 18e0f91..3369c01 100644
--- a/v17/leanback/res/values-mn/strings.xml
+++ b/v17/leanback/res/values-mn/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Текст тайлбарыг идэвхжүүлэх"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Текст тайлбарыг идэвхгүйжүүлэх"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Зургийн горимд зураг оруулна уу"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Медиа удирдлага харагдаж байна"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Медиа удирдлага нуугдсан байна, харуулахын тулд d-pad-г дарна уу"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Дуусгах"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Үргэлжлүүлэх"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer-н алдааны код %1$d нэмэлт %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ЭХЭЛЦГЭЭЕ"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Дараах"</string>
 </resources>
diff --git a/v17/leanback/res/values-mr/strings.xml b/v17/leanback/res/values-mr/strings.xml
index 79a7b0c..948b536 100644
--- a/v17/leanback/res/values-mr/strings.xml
+++ b/v17/leanback/res/values-mr/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"उपशीर्षके सक्षम करा"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"उपशीर्षके अक्षम करा"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"चित्र मोडमध्ये चित्र प्रविष्ट करा"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"मीडिया नियंत्रणे दर्शवली आहेत"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"मीडिया नियंत्रणे लपलेली आहेत, दर्शवण्‍यासाठी d-pad दाबा"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"समाप्त"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"सुरू ठेवा"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"मीडियाप्लेअर एरर कोड %1$d अतिरिक्त %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"प्रारंभ करा"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"पुढील"</string>
 </resources>
diff --git a/v17/leanback/res/values-ms/strings.xml b/v17/leanback/res/values-ms/strings.xml
index 8cad319..dcfa76b 100644
--- a/v17/leanback/res/values-ms/strings.xml
+++ b/v17/leanback/res/values-ms/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Dayakan Kapsyen Tertutup"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Lumpuhkan Kapsyen Tertutup"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Masukkan Gambar Dalam Mod Gambar"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Kawalan media ditunjukkan"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Kawalan media disembunyikan, tekan d-pad untuk menunjukkan"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Selesai"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Teruskan"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"Kod ralat MediaPlayer %1$d tambahan %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"MULAKAN"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Seterusnya"</string>
 </resources>
diff --git a/v17/leanback/res/values-ne/strings.xml b/v17/leanback/res/values-ne/strings.xml
index c6579a6..5c58907 100644
--- a/v17/leanback/res/values-ne/strings.xml
+++ b/v17/leanback/res/values-ne/strings.xml
@@ -50,14 +50,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"बन्द क्याप्सनहरु सक्षम"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"बन्द क्याप्सनहरु असक्षम"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"चित्रलाई चित्र मोडमा प्रविष्ट गर्नुहोस्"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"मिडियाका नियन्त्रणहरू देखाएइका छन्"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"मिडियाका नियन्त्रणहरू लुकेका छन्, देखाउनका लागि d-pad लाई थिच्नुहोस्"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"समाप्त गर्नुहोस्"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"जारी राख्नुहोस्"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer को त्रुटि सम्बन्धी कोड %1$d अतिरिक्त %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"सुरु गरौँ"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"अर्को"</string>
 </resources>
diff --git a/v17/leanback/res/values-nl/strings.xml b/v17/leanback/res/values-nl/strings.xml
index e5dc9ac..69947ce 100644
--- a/v17/leanback/res/values-nl/strings.xml
+++ b/v17/leanback/res/values-nl/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Ondertiteling inschakelen"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Ondertiteling uitschakelen"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Beeld-in-beeld-modus openen"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Opties voor mediabediening worden weergegeven"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Opties voor mediabediening verborgen. Druk op de D-pad om ze weer te geven."</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Voltooien"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Doorgaan"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"-"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"Mediaspeler: foutcode %1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"AAN DE SLAG"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Volgende"</string>
 </resources>
diff --git a/v17/leanback/res/values-pa/strings.xml b/v17/leanback/res/values-pa/strings.xml
index fe8fbd7..b423a73 100644
--- a/v17/leanback/res/values-pa/strings.xml
+++ b/v17/leanback/res/values-pa/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"ਬੰਦ ਕੈਪਸ਼ਨਿੰਗ ਸਮਰੱਥ ਬਣਾਓ"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"ਬੰਦ ਕੈਪਸ਼ਨਿੰਗ ਅਸਮਰੱਥ ਬਣਾਓ"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"ਤਸਵੀਰ ਮੋਡ ਵਿੱਚ ਤਸਵੀਰ ਦਾਖਲ ਕਰੋ"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"ਮੀਡੀਆ ਕੰਟਰੋਲ ਵਿਖਾਏ ਗਏ"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"ਮੀਡੀਆ ਕੰਟਰੋਲ ਲੁਕੇ ਹੋਏ ਹਨ, ਵਿਖਾਉਣ ਲਈ ਡੀ-ਪੈਡ ਦਬਾਓ"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ਖ਼ਤਮ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ਜਾਰੀ ਰੱਖੋ"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer ਗੜਬੜ ਕੋਡ %1$d ਵਾਧੂ %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ਸ਼ੁਰੂਆਤ ਕਰੋ"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"ਅੱਗੇ"</string>
 </resources>
diff --git a/v17/leanback/res/values-pl/strings.xml b/v17/leanback/res/values-pl/strings.xml
index 879c064..d1c7988 100644
--- a/v17/leanback/res/values-pl/strings.xml
+++ b/v17/leanback/res/values-pl/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Włącz napisy"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Wyłącz napisy"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Włącz tryb obrazu w obrazie"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Elementy sterujące multimediami są wyświetlone"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Elementy sterujące multimediami są ukryte. Naciśnij pad kierunkowy, by je wyświetlić"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Zakończ"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Dalej"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer – kod błędu %1$d, dodatkowo %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ROZPOCZNIJ"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Dalej"</string>
 </resources>
diff --git a/v17/leanback/res/values-si/strings.xml b/v17/leanback/res/values-si/strings.xml
index 54f2f08..238c105 100644
--- a/v17/leanback/res/values-si/strings.xml
+++ b/v17/leanback/res/values-si/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"වැසුණු ශිර්ෂ කිරීම සබල කරන ලදි"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"වැසුණු ශිර්ෂ කිරීම අබල කරන ලදි"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"පින්තූරය-තුළ-පින්තූරය ප්‍රකාරයට ඇතුළු වන්න"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"මාධ්‍ය පාලක පෙන්වා ඇත"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"මාධ්‍ය පාලක සඟවා ඇත, පෙන්වීමට d-pad ඔබන්න"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"අවසානය"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"දිගටම කර ගෙන යන්න"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer දෝෂ කේතය %1$d අමතර %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ආරම්භ කරන්න"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"ඊළඟ"</string>
 </resources>
diff --git a/v17/leanback/res/values-sl/strings.xml b/v17/leanback/res/values-sl/strings.xml
index d47b3af..30c1f11 100644
--- a/v17/leanback/res/values-sl/strings.xml
+++ b/v17/leanback/res/values-sl/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Omogoči podnapise"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Onemogoči podnapise"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Vklop načina za sliko v sliki"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Kontrolniki predstavnosti so prikazani"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Kontrolniki predstavnosti so skriti, za prikaz pritisnite smerni gumb"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Dokončaj"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Naprej"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"Koda napake MediaPlayer %1$d dodatno %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ZAČNITE"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Naprej"</string>
 </resources>
diff --git a/v17/leanback/res/values-sw/strings.xml b/v17/leanback/res/values-sw/strings.xml
index 45ab73b..c586455 100644
--- a/v17/leanback/res/values-sw/strings.xml
+++ b/v17/leanback/res/values-sw/strings.xml
@@ -57,5 +57,5 @@
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
     <string name="lb_media_player_error" msgid="3650250994187305396">"Msimbo wa hitilafu wa Kichezaji Maudhui %1$d %2$d zaidi"</string>
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ANZA KUTUMIA"</string>
-    <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Endelea"</string>
+    <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Inayofuata"</string>
 </resources>
diff --git a/v17/leanback/res/values-te/strings.xml b/v17/leanback/res/values-te/strings.xml
index 6b8d1f4..2d82651 100644
--- a/v17/leanback/res/values-te/strings.xml
+++ b/v17/leanback/res/values-te/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"సంవృత శీర్షికలను ప్రారంభించు"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"సంవృత శీర్షికలను నిలిపివేయి"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"చిత్రంలో చిత్రం మోడ్‌లోకి ప్రవేశించండి"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"మీడియా నియంత్రణలు చూపబడ్డాయి"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"మీడియా నియంత్రణలు దాచబడ్డాయి, చూపించడానికి d-ప్యాడ్ నొక్కండి"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"ముగించు"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"కొనసాగించు"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer ఎర్రర్ కోడ్ %1$d అదనంగా %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"ప్రారంభించు"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"తదుపరి"</string>
 </resources>
diff --git a/v17/leanback/res/values-th/strings.xml b/v17/leanback/res/values-th/strings.xml
index 0dae8eb..1e74c69 100644
--- a/v17/leanback/res/values-th/strings.xml
+++ b/v17/leanback/res/values-th/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"เปิดใช้คำบรรยาย"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"ปิดใช้คำบรรยาย"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"เข้าสู่โหมดการแสดงผลหลายแหล่งพร้อมกัน"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"แสดงการควบคุมสื่ออยู่"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"ซ่อนการควบคุมสื่ออยู่ กด d-pad เพื่อแสดง"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"เสร็จสิ้น"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"ต่อไป"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"รหัสข้อผิดพลาด MediaPlayer %1$d เพิ่มเติม %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"เริ่มต้นใช้งาน"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"ถัดไป"</string>
 </resources>
diff --git a/v17/leanback/res/values-tl/strings.xml b/v17/leanback/res/values-tl/strings.xml
index 0214efc..ac14e41 100644
--- a/v17/leanback/res/values-tl/strings.xml
+++ b/v17/leanback/res/values-tl/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"I-enable ang Paglalagay ng Subtitle"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"I-disable ang Paglalagay ng Subtitle"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Pumasok sa Picture In Picture Mode"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Ipinapakita ang mga kontrol ng media"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Nakatago ang mga kontrol ng media, pindutin ang d-pad upang ipakita"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Tapusin"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Magpatuloy"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"Code ng error na %1$d ng MediaPlayer na may extra na %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"MAGSIMULA"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Susunod"</string>
 </resources>
diff --git a/v17/leanback/res/values-tr/strings.xml b/v17/leanback/res/values-tr/strings.xml
index fbc6a5a..c29b7f8 100644
--- a/v17/leanback/res/values-tr/strings.xml
+++ b/v17/leanback/res/values-tr/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Altyazıları Etkinleştir"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Altyazıları Devre Dışı Bırak"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Resim İçinde Resim Moduna Geç"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"."</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Medya denetimleri gösteriliyor"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Medya denetimleri gizli durumda. Görüntülemek için d-pad\'e basın."</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Son"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Devam"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"."</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer hata kodu %1$d ekstra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"BAŞLA"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Sonraki"</string>
 </resources>
diff --git a/v17/leanback/res/values-ur/strings.xml b/v17/leanback/res/values-ur/strings.xml
index f5b7a25..0978c85 100644
--- a/v17/leanback/res/values-ur/strings.xml
+++ b/v17/leanback/res/values-ur/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"سب ٹائٹلز کو فعال کریں"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"سب ٹائٹلز کو غیر فعال کریں"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"\'تصویر میں تصویر موڈ\' میں داخل ہوں"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"میڈیا کنٹرولز عیاں ہیں"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"‏میڈیا کنٹرولز مخفی ہیں، شو کرنے کیلئے d-pad دبائیں"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"مکمل کریں"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"جاری رکھیں"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"‏میڈیا پلیئر کی خرابی کا کوڈ %1$d اضافی %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"شروع کریں"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"اگلا"</string>
 </resources>
diff --git a/v17/leanback/res/values-uz/strings.xml b/v17/leanback/res/values-uz/strings.xml
index de8558f..915b0b4 100644
--- a/v17/leanback/res/values-uz/strings.xml
+++ b/v17/leanback/res/values-uz/strings.xml
@@ -55,7 +55,7 @@
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Davom etish"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"Media pleyer xatoligi kodi: %1$d (yana: %2$d)"</string>
+    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer xatosi kodi: %1$d, %2$d"</string>
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"BOSHLADIK"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Keyingisi"</string>
 </resources>
diff --git a/v17/leanback/res/values-vi/strings.xml b/v17/leanback/res/values-vi/strings.xml
index 228bef0..db9421b 100644
--- a/v17/leanback/res/values-vi/strings.xml
+++ b/v17/leanback/res/values-vi/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"Bật phụ đề"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"Tắt phụ đề"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"Vào ảnh ở chế độ ảnh"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"Điều khiển phương tiện được hiển thị"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"Điều khiển phương tiện bị ẩn, nhấn d-pad để hiển thị"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"Hoàn tất"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"Tiếp tục"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"Mã lỗi MediaPlayer %1$d %2$d bổ sung"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"BẮT ĐẦU"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"Tiếp theo"</string>
 </resources>
diff --git a/v17/leanback/res/values-zh-rCN/strings.xml b/v17/leanback/res/values-zh-rCN/strings.xml
index d635311..63fd948 100644
--- a/v17/leanback/res/values-zh-rCN/strings.xml
+++ b/v17/leanback/res/values-zh-rCN/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"开启字幕"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"关闭字幕"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"进入画中画模式"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"媒体控件已显示"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"媒体控件已隐藏，按 D-pad 即可显示"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"完成"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"继续"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer 错误代码：%1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"开始使用"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"下一页"</string>
 </resources>
diff --git a/v17/leanback/res/values-zh-rHK/strings.xml b/v17/leanback/res/values-zh-rHK/strings.xml
index 2da2e73..b7a4a2e 100644
--- a/v17/leanback/res/values-zh-rHK/strings.xml
+++ b/v17/leanback/res/values-zh-rHK/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"啟用字幕"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"停用字幕"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"進入「畫中畫模式」"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"畫面已顯示媒體控制項"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"畫面已隱藏媒體控制項，按十字鍵即可顯示"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"完成"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"繼續"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer 錯誤代碼：%1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"開始使用"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"下一頁"</string>
 </resources>
diff --git a/v17/leanback/res/values-zh-rTW/strings.xml b/v17/leanback/res/values-zh-rTW/strings.xml
index 721dc6e..8d0e1d9 100644
--- a/v17/leanback/res/values-zh-rTW/strings.xml
+++ b/v17/leanback/res/values-zh-rTW/strings.xml
@@ -48,14 +48,16 @@
     <string name="lb_playback_controls_closed_captioning_enable" msgid="2429655367176440226">"啟用字幕"</string>
     <string name="lb_playback_controls_closed_captioning_disable" msgid="6133362019475930048">"停用字幕"</string>
     <string name="lb_playback_controls_picture_in_picture" msgid="3040035547765350690">"進入子母畫面模式"</string>
-    <string name="lb_playback_time_separator" msgid="3208380806582304911">"/"</string>
+    <!-- no translation found for lb_playback_time_separator (3208380806582304911) -->
+    <skip />
     <string name="lb_playback_controls_shown" msgid="6382160135512023238">"媒體控制項已顯示"</string>
     <string name="lb_playback_controls_hidden" msgid="8940984081242033574">"媒體控制項已隱藏，按下 D-Pad 即可顯示"</string>
     <string name="lb_guidedaction_finish_title" msgid="4015190340667946245">"完成"</string>
     <string name="lb_guidedaction_continue_title" msgid="8842094924543063706">"繼續"</string>
     <string name="lb_date_separator" msgid="2440386660906697298">"/"</string>
     <string name="lb_time_separator" msgid="2763247350845477227">":"</string>
-    <string name="lb_media_player_error" msgid="3650250994187305396">"MediaPlayer 錯誤代碼：%1$d extra %2$d"</string>
+    <!-- no translation found for lb_media_player_error (3650250994187305396) -->
+    <skip />
     <string name="lb_onboarding_get_started" msgid="6961440391306351139">"開始使用"</string>
     <string name="lb_onboarding_accessibility_next" msgid="2918313444257732434">"繼續"</string>
 </resources>
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseFragmentTest.java b/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseFragmentTest.java
index a1c986e..06a1217 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseFragmentTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseFragmentTest.java
@@ -25,7 +25,7 @@
 import android.content.Intent;
 import android.os.Build;
 import android.support.test.InstrumentationRegistry;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.testutils.PollingCheck;
@@ -42,7 +42,7 @@
 import org.junit.runner.RunWith;
 import org.mockito.Mockito;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class BrowseFragmentTest {
 
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseSupportFragmentTest.java b/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseSupportFragmentTest.java
index 4c86817..34ce596 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseSupportFragmentTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/app/BrowseSupportFragmentTest.java
@@ -28,6 +28,7 @@
 import android.content.Intent;
 import android.os.Build;
 import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
@@ -45,7 +46,7 @@
 import org.junit.runner.RunWith;
 import org.mockito.Mockito;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class BrowseSupportFragmentTest {
 
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/app/RowsFragmentTest.java b/v17/leanback/tests/java/android/support/v17/leanback/app/RowsFragmentTest.java
index f5f7bdf..d167e26 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/app/RowsFragmentTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/app/RowsFragmentTest.java
@@ -25,7 +25,7 @@
 import android.os.Handler;
 import android.os.SystemClock;
 import android.support.test.InstrumentationRegistry;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.testutils.PollingCheck;
 import android.support.v17.leanback.widget.ArrayObjectAdapter;
@@ -47,7 +47,7 @@
 
 import java.lang.ref.WeakReference;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class RowsFragmentTest extends SingleFragmentTestBase {
 
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/app/RowsSupportFragmentTest.java b/v17/leanback/tests/java/android/support/v17/leanback/app/RowsSupportFragmentTest.java
index 7d40644..d37d238 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/app/RowsSupportFragmentTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/app/RowsSupportFragmentTest.java
@@ -28,6 +28,7 @@
 import android.os.Handler;
 import android.os.SystemClock;
 import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.testutils.PollingCheck;
@@ -50,7 +51,7 @@
 
 import java.lang.ref.WeakReference;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class RowsSupportFragmentTest extends SingleSupportFragmentTestBase {
 
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/app/VideoFragmentTest.java b/v17/leanback/tests/java/android/support/v17/leanback/app/VideoFragmentTest.java
index ba5d68e..7fe3902 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/app/VideoFragmentTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/app/VideoFragmentTest.java
@@ -25,7 +25,7 @@
 import android.os.Bundle;
 import android.os.SystemClock;
 import android.support.test.InstrumentationRegistry;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.media.MediaPlayerGlue;
 import android.support.v17.leanback.media.PlaybackGlue;
@@ -42,7 +42,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class VideoFragmentTest extends SingleFragmentTestBase {
 
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/app/VideoSupportFragmentTest.java b/v17/leanback/tests/java/android/support/v17/leanback/app/VideoSupportFragmentTest.java
index 457268d..604e12b 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/app/VideoSupportFragmentTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/app/VideoSupportFragmentTest.java
@@ -28,6 +28,7 @@
 import android.os.Bundle;
 import android.os.SystemClock;
 import android.support.test.InstrumentationRegistry;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.media.MediaPlayerGlue;
@@ -45,7 +46,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class VideoSupportFragmentTest extends SingleSupportFragmentTestBase {
 
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/media/MediaPlayerGlueTest.java b/v17/leanback/tests/java/android/support/v17/leanback/media/MediaPlayerGlueTest.java
index c1f1807..b154635 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/media/MediaPlayerGlueTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/media/MediaPlayerGlueTest.java
@@ -26,7 +26,7 @@
 import android.os.Build;
 import android.os.SystemClock;
 import android.support.test.InstrumentationRegistry;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.SdkSuppress;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.testutils.PollingCheck;
@@ -36,7 +36,7 @@
 import org.mockito.Mockito;
 
 @RunWith(AndroidJUnit4.class)
-@MediumTest
+@LargeTest
 public class MediaPlayerGlueTest {
 
     /**
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/widget/DatePickerTest.java b/v17/leanback/tests/java/android/support/v17/leanback/widget/DatePickerTest.java
index 9a0b1c5..e2d2e99 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/widget/DatePickerTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/widget/DatePickerTest.java
@@ -23,7 +23,7 @@
 import android.content.Context;
 import android.content.Intent;
 import android.support.test.InstrumentationRegistry;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.test.R;
@@ -37,7 +37,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class DatePickerTest {
 
diff --git a/v17/leanback/tests/java/android/support/v17/leanback/widget/TimePickerTest.java b/v17/leanback/tests/java/android/support/v17/leanback/widget/TimePickerTest.java
index 0132e10..7146d31 100644
--- a/v17/leanback/tests/java/android/support/v17/leanback/widget/TimePickerTest.java
+++ b/v17/leanback/tests/java/android/support/v17/leanback/widget/TimePickerTest.java
@@ -22,7 +22,7 @@
 import android.content.Context;
 import android.content.Intent;
 import android.support.test.InstrumentationRegistry;
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v17.leanback.test.R;
@@ -35,7 +35,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
-@MediumTest
+@LargeTest
 @RunWith(AndroidJUnit4.class)
 public class TimePickerTest {
 
diff --git a/v17/preference-leanback/build.gradle b/v17/preference-leanback/build.gradle
index 8de4c00..4222f5b 100644
--- a/v17/preference-leanback/build.gradle
+++ b/v17/preference-leanback/build.gradle
@@ -1,13 +1,12 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'preference-leanback-v17'
 
 dependencies {
-    compile project(':support-v4')
-    compile project(':support-appcompat-v7')
-    compile project(':support-recyclerview-v7')
-    compile project(':support-preference-v7')
-    compile project(':support-preference-v14')
-    compile project(':support-leanback-v17')
+    api project(':support-v4')
+    api project(':support-appcompat-v7')
+    api project(':support-recyclerview-v7')
+    api project(':support-preference-v7')
+    api project(':support-preference-v14')
+    api project(':support-leanback-v17')
 }
 
 android {
diff --git a/v4/build.gradle b/v4/build.gradle
index 87bc171..88a1f9f 100644
--- a/v4/build.gradle
+++ b/v4/build.gradle
@@ -1,12 +1,11 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'support-v4'
 
 dependencies {
-    compile project(':support-compat')
-    compile project(':support-media-compat')
-    compile project(':support-core-utils')
-    compile project(':support-core-ui')
-    compile project(':support-fragment')
+    api project(':support-compat')
+    api project(':support-media-compat')
+    api project(':support-core-utils')
+    api project(':support-core-ui')
+    api project(':support-fragment')
 }
 
 android {
diff --git a/v7/appcompat/build.gradle b/v7/appcompat/build.gradle
index f604aa3..073b923 100644
--- a/v7/appcompat/build.gradle
+++ b/v7/appcompat/build.gradle
@@ -1,21 +1,20 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'appcompat-v7'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-v4')
-    compile project(':support-vector-drawable')
-    compile project(':support-animated-vector-drawable')
+    api project(':support-annotations')
+    api project(':support-v4')
+    api project(':support-vector-drawable')
+    api project(':support-animated-vector-drawable')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(':support-testutils')
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation project(':support-testutils')
 }
 
 android {
diff --git a/v7/appcompat/res/values-bs/strings.xml b/v7/appcompat/res/values-bs/strings.xml
index 922e4a2..05f4a36 100644
--- a/v7/appcompat/res/values-bs/strings.xml
+++ b/v7/appcompat/res/values-bs/strings.xml
@@ -16,7 +16,7 @@
 
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <string name="abc_action_mode_done" msgid="4076576682505996667">"Gotovo"</string>
+    <string name="abc_action_mode_done" msgid="4076576682505996667">"Završeno"</string>
     <string name="abc_action_bar_home_description" msgid="4600421777120114993">"Vrati se na početnu stranicu"</string>
     <string name="abc_action_bar_up_description" msgid="1594238315039666878">"Navigiraj prema gore"</string>
     <string name="abc_action_menu_overflow_description" msgid="3588849162933574182">"Više opcija"</string>
diff --git a/v7/appcompat/res/values-es/strings.xml b/v7/appcompat/res/values-es/strings.xml
index 418866d..5f954e1 100644
--- a/v7/appcompat/res/values-es/strings.xml
+++ b/v7/appcompat/res/values-es/strings.xml
@@ -34,7 +34,7 @@
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Compartir con %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Compartir con"</string>
     <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"+999"</string>
-    <string name="abc_capital_on" msgid="3405795526292276155">"ACTIVADO"</string>
-    <string name="abc_capital_off" msgid="121134116657445385">"DESACTIVADO"</string>
+    <string name="abc_capital_on" msgid="3405795526292276155">"SÍ"</string>
+    <string name="abc_capital_off" msgid="121134116657445385">"NO"</string>
     <string name="search_menu_title" msgid="146198913615257606">"Buscar"</string>
 </resources>
diff --git a/v7/appcompat/res/values-gl/strings.xml b/v7/appcompat/res/values-gl/strings.xml
index 6a86c4c..9ae2b8d 100644
--- a/v7/appcompat/res/values-gl/strings.xml
+++ b/v7/appcompat/res/values-gl/strings.xml
@@ -28,7 +28,7 @@
     <string name="abc_searchview_description_query" msgid="2550479030709304392">"Consulta de busca"</string>
     <string name="abc_searchview_description_clear" msgid="3691816814315814921">"Borrar consulta"</string>
     <string name="abc_searchview_description_submit" msgid="8928215447528550784">"Enviar consulta"</string>
-    <string name="abc_searchview_description_voice" msgid="893419373245838918">"Busca por voz"</string>
+    <string name="abc_searchview_description_voice" msgid="893419373245838918">"Busca de voz"</string>
     <string name="abc_activitychooserview_choose_application" msgid="2031811694353399454">"Escoller unha aplicación"</string>
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Ver todas"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Compartir con %s"</string>
diff --git a/v7/appcompat/res/values-ro/strings.xml b/v7/appcompat/res/values-ro/strings.xml
index e366d52..46f7b33 100644
--- a/v7/appcompat/res/values-ro/strings.xml
+++ b/v7/appcompat/res/values-ro/strings.xml
@@ -34,7 +34,7 @@
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Trimiteți la %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Trimiteți la"</string>
     <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"˃999"</string>
-    <string name="abc_capital_on" msgid="3405795526292276155">"ACTIVAT"</string>
+    <string name="abc_capital_on" msgid="3405795526292276155">"ACTIVAȚI"</string>
     <string name="abc_capital_off" msgid="121134116657445385">"DEZACTIVAȚI"</string>
     <string name="search_menu_title" msgid="146198913615257606">"Căutați"</string>
 </resources>
diff --git a/v7/appcompat/res/values-sk/strings.xml b/v7/appcompat/res/values-sk/strings.xml
index 774740f..31a0d33 100644
--- a/v7/appcompat/res/values-sk/strings.xml
+++ b/v7/appcompat/res/values-sk/strings.xml
@@ -34,7 +34,7 @@
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Zdieľať pomocou %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Zdieľať pomocou"</string>
     <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
-    <string name="abc_capital_on" msgid="3405795526292276155">"ZAPNUTÉ"</string>
-    <string name="abc_capital_off" msgid="121134116657445385">"VYPNUTÉ"</string>
+    <string name="abc_capital_on" msgid="3405795526292276155">"ZAP."</string>
+    <string name="abc_capital_off" msgid="121134116657445385">"VYP."</string>
     <string name="search_menu_title" msgid="146198913615257606">"Vyhľadávanie"</string>
 </resources>
diff --git a/v7/appcompat/tests/src/android/support/v7/app/AlertDialogCursorTest.java b/v7/appcompat/tests/src/android/support/v7/app/AlertDialogCursorTest.java
index 690cc26..11217d7 100644
--- a/v7/appcompat/tests/src/android/support/v7/app/AlertDialogCursorTest.java
+++ b/v7/appcompat/tests/src/android/support/v7/app/AlertDialogCursorTest.java
@@ -44,6 +44,7 @@
 import android.database.sqlite.SQLiteCursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.support.test.espresso.DataInteraction;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
@@ -295,6 +296,7 @@
         verifyMultiChoiceItemsState(expectedContent, expectedAfterClickLast);
     }
 
+    @LargeTest
     @Test
     public void testMultiChoiceItemsFromCursor() {
         mCursor = mDatabase.query("test", mProjectionWithChecked,
@@ -405,6 +407,7 @@
         verifySingleChoiceItemsState(expectedContent, currentlyExpectedSelectionIndex);
     }
 
+    @LargeTest
     @Test
     public void testSingleChoiceItemsFromCursor() {
         mCursor = mDatabase.query("test", mProjectionWithoutChecked,
diff --git a/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutDoubleTest.java b/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutDoubleTest.java
index 8578798..0d81ff5 100755
--- a/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutDoubleTest.java
+++ b/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutDoubleTest.java
@@ -26,7 +26,7 @@
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import android.support.test.filters.MediumTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.SmallTest;
 import android.support.test.rule.ActivityTestRule;
 import android.support.test.runner.AndroidJUnit4;
@@ -157,7 +157,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerOpenCloseLtr() {
         onView(withId(R.id.drawer_layout)).perform(
                 setLayoutDirection(ViewCompat.LAYOUT_DIRECTION_LTR));
@@ -166,7 +166,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerOpenCloseRtl() {
         onView(withId(R.id.drawer_layout)).perform(
                 setLayoutDirection(ViewCompat.LAYOUT_DIRECTION_RTL));
@@ -220,7 +220,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerLockUnlockLtr() {
         onView(withId(R.id.drawer_layout)).perform(
                 setLayoutDirection(ViewCompat.LAYOUT_DIRECTION_LTR));
@@ -229,7 +229,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerLockUnlockRtl() {
         onView(withId(R.id.drawer_layout)).perform(
                 setLayoutDirection(ViewCompat.LAYOUT_DIRECTION_RTL));
diff --git a/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutTest.java b/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutTest.java
index f43c909..6e82df9 100755
--- a/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutTest.java
+++ b/v7/appcompat/tests/src/android/support/v7/app/DrawerLayoutTest.java
@@ -90,7 +90,7 @@
     // Tests for opening and closing the drawer and checking the open state
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerOpenCloseViaAPI() {
         assertFalse("Initial state", mDrawerLayout.isDrawerOpen(GravityCompat.START));
 
@@ -118,7 +118,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerOpenCloseFocus() throws Throwable {
         assertFalse("Initial state", mDrawerLayout.isDrawerOpen(GravityCompat.START));
 
@@ -143,7 +143,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerOpenCloseWithRedundancyViaAPI() {
         assertFalse("Initial state", mDrawerLayout.isDrawerOpen(GravityCompat.START));
 
@@ -191,7 +191,7 @@
     }
 
     @Test
-    @MediumTest
+    @LargeTest
     public void testDrawerOpenCloseViaSwipes() {
         assertFalse("Initial state", mDrawerLayout.isDrawerOpen(GravityCompat.START));
 
diff --git a/v7/cardview/build.gradle b/v7/cardview/build.gradle
index b5a08ef..60e7d77 100644
--- a/v7/cardview/build.gradle
+++ b/v7/cardview/build.gradle
@@ -1,8 +1,7 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'cardview-v7'
 
 dependencies {
-    compile project(':support-annotations')
+    api project(':support-annotations')
 }
 
 android {
diff --git a/v7/gridlayout/build.gradle b/v7/gridlayout/build.gradle
index 63d149f..9ec6714 100644
--- a/v7/gridlayout/build.gradle
+++ b/v7/gridlayout/build.gradle
@@ -1,14 +1,13 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'gridlayout-v7'
 
 dependencies {
-    compile project(':support-compat')
-    compile project(':support-core-ui')
+    api project(':support-compat')
+    api project(':support-core-ui')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
 }
diff --git a/v7/mediarouter/build.gradle b/v7/mediarouter/build.gradle
index f971a0b..90900ac 100644
--- a/v7/mediarouter/build.gradle
+++ b/v7/mediarouter/build.gradle
@@ -1,17 +1,16 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'mediarouter-v7'
 
 dependencies {
-    compile project(":support-appcompat-v7")
-    compile project(":support-palette-v7")
+    api project(":support-appcompat-v7")
+    api project(":support-palette-v7")
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.test_rules
+    androidTestImplementation libs.test_rules
 }
 
 android {
diff --git a/v7/mediarouter/res/values-be/strings.xml b/v7/mediarouter/res/values-be/strings.xml
index 396088f..2d80bca 100644
--- a/v7/mediarouter/res/values-be/strings.xml
+++ b/v7/mediarouter/res/values-be/strings.xml
@@ -22,7 +22,7 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"Кнопка трансляцыі. Адключана"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Кнопка трансляцыі. Ідзе падключэнне"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"Кнопка трансляцыі. Падключана"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"Трансліраваць на"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"Трансляваць на"</string>
     <string name="mr_chooser_searching" msgid="6349900579507521956">"Пошук прылад"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Адлучыць"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Спыніць трансляцыю"</string>
diff --git a/v7/mediarouter/res/values-bs/strings.xml b/v7/mediarouter/res/values-bs/strings.xml
index ab9575e..245b9da 100644
--- a/v7/mediarouter/res/values-bs/strings.xml
+++ b/v7/mediarouter/res/values-bs/strings.xml
@@ -18,11 +18,11 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="mr_system_route_name" msgid="5441529851481176817">"Sistem"</string>
     <string name="mr_user_route_category_name" msgid="7498112907524977311">"Uređaji"</string>
-    <string name="mr_button_content_description" msgid="3698378085901466129">"Dugme za emitiranje"</string>
-    <string name="mr_cast_button_disconnected" msgid="816305490427819240">"Dugme za emitiranje. Veza je prekinuta"</string>
-    <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Dugme za emitiranje. Povezivanje"</string>
-    <string name="mr_cast_button_connected" msgid="5088427771788648085">"Dugme za emitiranje. Povezano"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"Emitiranje na"</string>
+    <string name="mr_button_content_description" msgid="3698378085901466129">"Dugme za prebacivanje"</string>
+    <string name="mr_cast_button_disconnected" msgid="816305490427819240">"Dugme za prebacivanje. Veza je prekinuta"</string>
+    <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Dugme za prebacivanje. Povezivanje"</string>
+    <string name="mr_cast_button_connected" msgid="5088427771788648085">"Dugme za prebacivanje. Povezan"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"Prebacujte na"</string>
     <string name="mr_chooser_searching" msgid="6349900579507521956">"Traženje uređaja"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Prekini vezu"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Zaustavi prebacivanje"</string>
diff --git a/v7/mediarouter/res/values-gl/strings.xml b/v7/mediarouter/res/values-gl/strings.xml
index e509ab7..7e38bb4 100644
--- a/v7/mediarouter/res/values-gl/strings.xml
+++ b/v7/mediarouter/res/values-gl/strings.xml
@@ -22,7 +22,7 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"Botón de emitir. Desconectado"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Botón de emitir. Conectando"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"Botón de emitir. Conectado"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"Emitir a"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"Emitir en"</string>
     <string name="mr_chooser_searching" msgid="6349900579507521956">"Buscando dispositivos"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Desconectar"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Deter emisión"</string>
diff --git a/v7/mediarouter/res/values-iw/strings.xml b/v7/mediarouter/res/values-iw/strings.xml
index 02f50ff..3e7bc50 100644
--- a/v7/mediarouter/res/values-iw/strings.xml
+++ b/v7/mediarouter/res/values-iw/strings.xml
@@ -22,7 +22,7 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"‏לחצן הפעלת Cast. מנותק"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"‏לחצן הפעלת Cast. מתחבר"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"‏לחצן הפעלת Cast. מחובר"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"העברה אל"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"העבר אל"</string>
     <string name="mr_chooser_searching" msgid="6349900579507521956">"מחפש מכשירים"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"נתק"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"הפסק את ההעברה"</string>
diff --git a/v7/mediarouter/res/values-ka/strings.xml b/v7/mediarouter/res/values-ka/strings.xml
index 22480ca..57b76e9 100644
--- a/v7/mediarouter/res/values-ka/strings.xml
+++ b/v7/mediarouter/res/values-ka/strings.xml
@@ -22,8 +22,8 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"ტრანსლირების ღილაკი. გათიშული"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"ტრანსლირების ღილაკი. მიმდინარეობს დაკავშირება"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"ტრანსლირების ღილაკი. დაკავშირებული"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"ტრანსლირება:"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"მოწყობილობების მოძიება..."</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"ტრანსლირებული"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"მიმდინარეობს მოწყობილობების მოძიება"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"კავშირის გაწყვეტა"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"ტრანსლირების შეწყვეტა"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"დახურვა"</string>
diff --git a/v7/mediarouter/res/values-km/strings.xml b/v7/mediarouter/res/values-km/strings.xml
index f9f339d..e9bef13 100644
--- a/v7/mediarouter/res/values-km/strings.xml
+++ b/v7/mediarouter/res/values-km/strings.xml
@@ -22,8 +22,8 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"ខាសប៊ូតុង៖ បានកាត់ផ្តាច់"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"ខាសប៊ូតុង៖ កំពុងភ្ជាប់"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"ខាសប៊ូតុង៖ បានភ្ជាប់ហើយ"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"បញ្ជូនទៅ"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"កំពុងស្វែងរកឧបករណ៍"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"ខាសទៅ"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"ស្វែងរកឧបករណ៍"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"ផ្ដាច់"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"ឈប់ភ្ជាប់"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"បិទ"</string>
diff --git a/v7/mediarouter/res/values-lo/strings.xml b/v7/mediarouter/res/values-lo/strings.xml
index d50ae66..e0703e8 100644
--- a/v7/mediarouter/res/values-lo/strings.xml
+++ b/v7/mediarouter/res/values-lo/strings.xml
@@ -22,7 +22,7 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"ປຸ່ມສົ່ງສັນຍານ. ຕັດການເຊື່ອມຕໍ່ແລ້ວ"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"ປຸ່ມສົ່ງສັນຍານ. ກຳລັງເຊື່ອມຕໍ່"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"ປຸ່ມສົ່ງສັນຍານ. ເຊື່ອມຕໍ່ແລ້ວ"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"ສົ່ງສັນຍານຫາ"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"ຄາ​ສ​ທ໌​ຫາ"</string>
     <string name="mr_chooser_searching" msgid="6349900579507521956">"ກຳລັງ​ຊອກ​ຫາ​ອຸ​ປະ​ກອນ"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"ຕັດການເຊື່ອມຕໍ່"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"ຢຸດການສົ່ງສັນຍານ"</string>
diff --git a/v7/mediarouter/res/values-mk/strings.xml b/v7/mediarouter/res/values-mk/strings.xml
index d5b9365..ae1bfee 100644
--- a/v7/mediarouter/res/values-mk/strings.xml
+++ b/v7/mediarouter/res/values-mk/strings.xml
@@ -23,7 +23,7 @@
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Копче за Cast. Се поврзува"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"Копче за Cast. Поврзано"</string>
     <string name="mr_chooser_title" msgid="414301941546135990">"Емитувај на"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"Се бараат уреди"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"Наоѓање уреди"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Исклучи"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Сопри го емитувањето"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"Затвори"</string>
diff --git a/v7/mediarouter/res/values-my/strings.xml b/v7/mediarouter/res/values-my/strings.xml
index fb0074d..eb33498 100644
--- a/v7/mediarouter/res/values-my/strings.xml
+++ b/v7/mediarouter/res/values-my/strings.xml
@@ -22,7 +22,7 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"ကာစ်ခလုတ်။ ချိတ်ဆက်မထားပါ"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"ကာစ်ခလုတ်။ ချိတ်ဆက်နေသည်"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"ကာစ်ခလုတ်။ ချိတ်ဆက်ထားသည်"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"ကာစ်လုပ်ရန် စက်"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"သို့ ကာစ်တ်လုပ်ရန်"</string>
     <string name="mr_chooser_searching" msgid="6349900579507521956">"စက်ပစ္စည်းများ ရှာဖွေခြင်း"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"ဆက်သွယ်မှု ဖြတ်ရန်"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"ကာစ်လုပ်ခြင်း ရပ်ရန်"</string>
diff --git a/v7/mediarouter/res/values-nb/strings.xml b/v7/mediarouter/res/values-nb/strings.xml
index 7c99442..d31aa73 100644
--- a/v7/mediarouter/res/values-nb/strings.xml
+++ b/v7/mediarouter/res/values-nb/strings.xml
@@ -23,7 +23,7 @@
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Cast-knappen. Kobler til"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"Cast-knappen. Tilkoblet"</string>
     <string name="mr_chooser_title" msgid="414301941546135990">"Cast til"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"Søker etter enheter"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"Finner enheter"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Koble fra"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Stopp castingen"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"Lukk"</string>
diff --git a/v7/mediarouter/res/values-pa/strings.xml b/v7/mediarouter/res/values-pa/strings.xml
index f1a1a30..e058e18 100644
--- a/v7/mediarouter/res/values-pa/strings.xml
+++ b/v7/mediarouter/res/values-pa/strings.xml
@@ -22,8 +22,8 @@
     <string name="mr_cast_button_disconnected" msgid="816305490427819240">"ਕਾਸਟ ਬਟਨ। ਡਿਸਕਨੈਕਟ ਕੀਤਾ ਗਿਆ"</string>
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"ਕਾਸਟ ਬਟਨ। ਕਨੈਕਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"ਕਾਸਟ ਬਟਨ। ਕਨੈਕਟ ਕੀਤਾ ਗਿਆ"</string>
-    <string name="mr_chooser_title" msgid="414301941546135990">"ਏਥੇ ਕਾਸਟ ਕਰੋ"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"ਡੀਵਾਈਸਾਂ ਨੂੰ ਲੱਭਿਆ ਜਾ ਰਿਹਾ ਹੈ"</string>
+    <string name="mr_chooser_title" msgid="414301941546135990">"ਇਸ ਨਾਲ ਕਾਸਟ ਕਰੋ"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"ਡਿਵਾਈਸਾਂ ਲੱਭ ਰਿਹਾ ਹੈ"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"ਡਿਸਕਨੈਕਟ ਕਰੋ"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"ਕਾਸਟ ਕਰਨਾ ਬੰਦ ਕਰੋ"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"ਬੰਦ ਕਰੋ"</string>
diff --git a/v7/mediarouter/res/values-sk/strings.xml b/v7/mediarouter/res/values-sk/strings.xml
index 43a769a..2df58ef 100644
--- a/v7/mediarouter/res/values-sk/strings.xml
+++ b/v7/mediarouter/res/values-sk/strings.xml
@@ -23,7 +23,7 @@
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Tlačidlo prenosu. Pripája sa"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"Tlačidlo prenosu. Pripojené"</string>
     <string name="mr_chooser_title" msgid="414301941546135990">"Prenos do"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"Hľadajú sa zariadenia"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"Vyhľadávanie zariadení"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Odpojiť"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Zastaviť prenášanie"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"Zavrieť"</string>
diff --git a/v7/mediarouter/res/values-sq/strings.xml b/v7/mediarouter/res/values-sq/strings.xml
index d3cae18..9f75316 100644
--- a/v7/mediarouter/res/values-sq/strings.xml
+++ b/v7/mediarouter/res/values-sq/strings.xml
@@ -23,7 +23,7 @@
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Butoni i transmetimit. Po lidhet"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"Butoni i transmetimit. Je i lidhur"</string>
     <string name="mr_chooser_title" msgid="414301941546135990">"Transmeto te"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"Po kërkon pajisje"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"Gjetja e pajisjeve"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Shkëpute"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Ndalo transmetimin"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"Mbyll"</string>
diff --git a/v7/mediarouter/res/values-uz/strings.xml b/v7/mediarouter/res/values-uz/strings.xml
index 2f9a8a2..fae6076 100644
--- a/v7/mediarouter/res/values-uz/strings.xml
+++ b/v7/mediarouter/res/values-uz/strings.xml
@@ -33,7 +33,7 @@
     <string name="mr_controller_expand_group" msgid="8062427022744266907">"Yoyish"</string>
     <string name="mr_controller_collapse_group" msgid="7924809056904240926">"Yig‘ish"</string>
     <string name="mr_controller_album_art" msgid="6422801843540543585">"Albom muqovasi"</string>
-    <string name="mr_controller_volume_slider" msgid="2361785992211841709">"Tovush balandligi slayderi"</string>
+    <string name="mr_controller_volume_slider" msgid="2361785992211841709">"Ovoz balandligi slayderi"</string>
     <string name="mr_controller_no_media_selected" msgid="6547130360349182381">"Multimedia tanlamagan"</string>
     <string name="mr_controller_no_info_available" msgid="5585418471741142924">"Hech qanday ma’lumot yo‘q"</string>
     <string name="mr_controller_casting_screen" msgid="4868457957151124867">"Ekranni translatsiya qilish"</string>
diff --git a/v7/mediarouter/res/values-vi/strings.xml b/v7/mediarouter/res/values-vi/strings.xml
index 3fbc252..5801c4f 100644
--- a/v7/mediarouter/res/values-vi/strings.xml
+++ b/v7/mediarouter/res/values-vi/strings.xml
@@ -23,7 +23,7 @@
     <string name="mr_cast_button_connecting" msgid="2187642765091873834">"Nút truyền. Đang kết nối"</string>
     <string name="mr_cast_button_connected" msgid="5088427771788648085">"Nút truyền. Đã kết nối"</string>
     <string name="mr_chooser_title" msgid="414301941546135990">"Truyền tới"</string>
-    <string name="mr_chooser_searching" msgid="6349900579507521956">"Đang tìm thiết bị"</string>
+    <string name="mr_chooser_searching" msgid="6349900579507521956">"Tìm thiết bị"</string>
     <string name="mr_controller_disconnect" msgid="1227264889412989580">"Ngắt kết nối"</string>
     <string name="mr_controller_stop_casting" msgid="8857886794086583226">"Dừng truyền"</string>
     <string name="mr_controller_close_description" msgid="7333862312480583260">"Đóng"</string>
diff --git a/v7/palette/build.gradle b/v7/palette/build.gradle
index 6ab7995..e4670a7 100644
--- a/v7/palette/build.gradle
+++ b/v7/palette/build.gradle
@@ -1,11 +1,10 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'palette-v7'
 
 dependencies {
-    compile project(':support-compat')
-    compile project(':support-core-utils')
+    api project(':support-compat')
+    api project(':support-core-utils')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
 }
diff --git a/v7/preference/build.gradle b/v7/preference/build.gradle
index a7ad709..df8a477 100644
--- a/v7/preference/build.gradle
+++ b/v7/preference/build.gradle
@@ -15,21 +15,20 @@
  */
 
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'preference-v7'
 
 dependencies {
-    compile project(':support-v4')
-    compile project(':support-appcompat-v7')
-    compile project(':support-recyclerview-v7')
+    api project(':support-v4')
+    api project(':support-appcompat-v7')
+    api project(':support-recyclerview-v7')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
diff --git a/v7/recyclerview/build.gradle b/v7/recyclerview/build.gradle
index 2c8bef3..cde85e5 100644
--- a/v7/recyclerview/build.gradle
+++ b/v7/recyclerview/build.gradle
@@ -1,25 +1,24 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'recyclerview-v7'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-compat')
-    compile project(':support-core-ui')
+    api project(':support-annotations')
+    api project(':support-compat')
+    api project(':support-core-ui')
 
-    androidTestCompile (libs.test_runner) {
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.junit
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
-    androidTestCompile project(':support-testutils')
+    androidTestImplementation libs.junit
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
+    androidTestImplementation project(':support-testutils')
 
-    testCompile libs.junit
-    testCompile libs.mockito_core
-    testCompile ("$libs.test_runner") {
+    testImplementation libs.junit
+    testImplementation libs.mockito_core
+    testImplementation ("$libs.test_runner") {
         exclude module: 'support-annotations'
     }
 }
diff --git a/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewAccessibilityLifecycleTest.java b/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewAccessibilityLifecycleTest.java
index 5529ead..aed18bd 100644
--- a/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewAccessibilityLifecycleTest.java
+++ b/v7/recyclerview/tests/src/android/support/v7/widget/RecyclerViewAccessibilityLifecycleTest.java
@@ -29,6 +29,7 @@
 
 import android.annotation.TargetApi;
 import android.os.Build;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.filters.SdkSuppress;
 import android.support.test.runner.AndroidJUnit4;
@@ -104,6 +105,7 @@
         assertThat(calledA11DuringLayout.get(), is(false));
     }
 
+    @LargeTest
     @SdkSuppress(minSdkVersion = Build.VERSION_CODES.LOLLIPOP)
     @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
     @Test
diff --git a/wear/build.gradle b/wear/build.gradle
index d81f84e..4317cfc 100644
--- a/wear/build.gradle
+++ b/wear/build.gradle
@@ -1,19 +1,19 @@
 apply plugin: android.support.SupportLibraryPlugin
-archivesBaseName = 'wear'
 
 dependencies {
-    compile project(':support-annotations')
-    compile project(':support-core-ui')
-    compile project(':support-percent')
-    compile project(':support-recyclerview-v7')
-    androidTestCompile (libs.test_runner) {
+    api project(':support-annotations')
+    api project(':support-core-ui')
+    api project(':support-percent')
+    api project(':support-recyclerview-v7')
+
+    androidTestImplementation (libs.test_runner) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile (libs.espresso_core) {
+    androidTestImplementation (libs.espresso_core) {
         exclude module: 'support-annotations'
     }
-    androidTestCompile libs.mockito_core
-    androidTestCompile libs.dexmaker_mockito
+    androidTestImplementation libs.mockito_core
+    androidTestImplementation libs.dexmaker_mockito
 }
 
 android {
diff --git a/wear/tests/src/android/support/wear/widget/CircularProgressLayoutControllerTest.java b/wear/tests/src/android/support/wear/widget/CircularProgressLayoutControllerTest.java
index 8d5406d..2f625b6 100644
--- a/wear/tests/src/android/support/wear/widget/CircularProgressLayoutControllerTest.java
+++ b/wear/tests/src/android/support/wear/widget/CircularProgressLayoutControllerTest.java
@@ -22,6 +22,7 @@
 import static org.mockito.Mockito.when;
 
 import android.support.test.annotation.UiThreadTest;
+import android.support.test.filters.LargeTest;
 import android.support.test.filters.MediumTest;
 import android.support.test.runner.AndroidJUnit4;
 import android.support.v4.widget.CircularProgressDrawable;
@@ -76,6 +77,7 @@
         verify(mMockDrawable).stop();
     }
 
+    @LargeTest
     @Test
     @UiThreadTest
     public void testIsTimerRunningAfterStart() {
