Note: With the release of Android 9.0 (API level 28) there is a new version of the support library called AndroidX which is part of Jetpack. The AndroidX library contains the existing support library and also includes the latest Jetpack components.
You can continue to use the support library. Historical artifacts (those versioned 27 and earlier, and packaged as android.support.*) will remain available on Google Maven. However, all new library development will occur in the AndroidX library.
We recommend using the AndroidX libraries in all new projects. You should also consider migrating existing projects to AndroidX as well.
When developing apps that support multiple API versions, you may want a standard way to provide newer features on earlier versions of Android or gracefully fall back to equivalent functionality. Rather than building code to handle earlier versions of the platform, you can leverage these libraries to provide that compatibility layer. In addition, the Support Libraries provide additional convenience classes and features not available in the standard Framework API for easier development and support across more devices.
Originally a single binary library for apps, the Android Support Library has evolved into a suite of libraries for app development. Many of these libraries are now a strongly recommended, if not essential, part of app development.
This document provides an overview of the support library to help you understand its components and how to use it effectively in your app.
JDiff is a Javadoc doclet which emits an HTML report of all the packages, classes, methods, and so on, which are different (the 'diff' part) when two Java APIs are compared. Great for reporting what has changed between two releases of your product. X 10-8-0.5 0 0.5 differential jitter Jdiff(UI) time. Impact of Clock to Data Skew on Jitter Tracking 12. Assuming infinite jitter tracking bandwidth (JTB). For a given skew, as the jitter frequency increases the differential jitter increases and become a maximum of 2X.
Caution: Starting with Support Library release 26.0.0 (July 2017), the minimum supported API level across most support libraries has increased to Android 4.0 (API level 14) for most library packages. For more information, see Version Support and Package Names in this document.
Uses for the Support Libraries
There are a few distinct uses for the support libraries. Backward compatibility classes for earlier versions of the platform is just one of them. Here is a more complete list of ways you can use the support libraries in your app:
- Backward Compatibility for newer APIs - A large amount of the support libraries provide backward compatibility for newer framework classes and methods. For example, the
Fragmentsupport class provides support for fragments on devices running versions earlier than Android 3.0 (API level 11). - Convenience and Helper Classes - The support libraries provides a number of helper classes, particularly for user interface development. For example the
RecyclerViewclass provides an user interface widget for displaying and managing very long lists, useable on versions of Android from API level 7 and up. - Debugging and Utilities - There are a number of features that provide utility beyond code you incorporate into your app, including the
support-annotationslibrary for improved code lint checks on method inputs and Multidex support for configuring and distributing apps with over 65,536 methods.
Using Support versus Framework APIs
Support Libraries provide classes and methods that closely resemble APIs in the Android Framework. Upon discovering this, you may wonder if you should use the framework version of the API or the support library equivalent. Here are the guidelines for when you should use support library classes in place of Framework APIs:
- Compatibility for a Specific Feature - If you want to support a recent platform feature on devices that are running earlier versions of the platform, use the equivalent classes and methods from the support library.
- Compatibility for Related Library Features - More sophisticated support library classes may depend on one or more additional support library classes, so you should use support library classes for those dependencies. For example, the
ViewPagersupport class should be used withFragmentPagerAdapteror theFragmentStatePagerAdaptersupport classes. - General Device Compatibility - If you do not have a specific platform feature you intend to use with your app in a backward compatible way, it is still a good idea to use support library classes in your app. For example, you may want to use
ActivityCompatin place of the frameworkActivityclass, so you can take advantage of newer features later on, such as incorporating the new permissions model introduced in Android 6.0 (API level 23).
Support Library classes that provide a compatible implementation of platform API classes may not be able to provide the full set of functionality available in the latest release, due to the limitations of the host device platform version. In these cases, Support Library classes are designed to degrade gracefully, and may not provide the all the functionality or data of the current, platform API. For this reason, you should review the reference documentation for the library classes and methods you use, and thoroughly test on devices running the earliest version of the platform supported by your app.
Note: The support libraries do not provide equivalent classes and methods for each framework API. In some cases, you may need to wrap a framework method call with an explicit SDK version check and provide alternative code to handle methods not available on a device. For more information on using version checks in your code, see Supporting Different Platform Versions.
Version Support and Package Names
Some of the Support Library packages have package names to indicate the minimum level of the API they originally supported, using a v# notation, such as the support-v4 package. Starting with Support Library version 26.0.0 (released in July 2017), the minimum supported API level has changed to Android 4.0 (API level 14) for all support library packages. For this reason, when working with any recent release of the support library, you should not assume that the the v# package notation indicates a minimum API support level. This change in recent releases also means that library packages with the v4 and v7 are essentially equivalent in the minimum level of API they support. For example, the support-v4 and the support-v7 package both support a minimum API level of 14, for releases of the Support Library from 26.0.0 and higher.
Support Library Release Versions
The release version of the Support Library, such as 24.2.0 or 25.0.1, is different from the minimum API level supported by any library in that release.The release version number indicates which version of the platform API it was built against, and therefore, what the most recent APIs may be included in this version of the libraries.
Specifically, the first section of the release version number, for example the 24 in version 24.2.0, generally corresponds with the version of the platform API available when it was released. The release version level of the support library indicates it incorporates some features of that API level, but you should not assume it provides compatibility with all features released in the new platform API version.
Library Dependencies
Most libraries in the Android Support Library suite have some dependency on one or more libraries. For example, nearly all support libraries have a dependency on the support-compat package. In general, you do not need to worry about support library dependencies, because the gradle build tool manages library dependencies for you, by automatically including dependent libraries.
If you want to see what libraries and library dependencies are included in your app, run the following command at the build root of your app development project to get a report of the dependencies for that project, including Android Support Libraries and other libraries:
For more information about adding support libraries to your development project using Gradle, see Support Library Setup. For more information about working with Gradle, see Configure Your Build.
Note that all Android Support Libraries also depend on some base level of the platform, for recent releases, that is Android 4.0 (API level 14) or higher.
Source Repository
This project uses Subversion to manage its source code. Instructions for using Subversion can be found at http://svnbook.red-bean.com/.
Anonymous Access with Maven
This project's source can be checked out anonymously from SVN with the following instruction set on a single line:
Anonymous Access
This project's source can be checked out anonymously from SVN with the following command:
Developer Access with Maven
Even though everyone can checkout the Subversion repository via HTTPS, committers have to use HTTPS if they want to be able to check back in their changes. Use the following instruction set on a single line:
Developer Access
Even though everyone can checkout the Subversion repository via HTTPS, committers have to use HTTPS if they want to be able to check back in their changes. Use the following command:
Access from behind a firewall
For those users who are stuck behind a corporate firewall which is blocking http access to the Subversion repository, you can try to access it via the developer connection:
Access through a proxy
Jiff Xylitol
The Subversion client can go through a proxy, if you configure it to do so. First, edit your 'servers' configuration file to indicate which proxy to use. The files location depends on your operating system. On Linux or Unix it is located in the directory '~/.subversion'. On Windows it is in '%APPDATA%Subversion'. (Try 'echo %APPDATA%', note this is a hidden directory.)
Diff Xml
There are comments in the file explaining what to do. If you don't have that file, get the latest Subversion client and run any command; this will cause the configuration directory and template files to be created.
Example : Edit the 'servers' file and add something like: