page.title=Compatibility Program Overview
@jd:body

<!--
    Copyright 2015 The Android Open Source Project     

    Licensed under the Apache License, Version 2.0 (the "License");    
    you may not use this file except in compliance with the License.   
    You may obtain a copy of the License at    

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software    
    distributed under the License is distributed on an "AS IS" BASIS,    
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   
    See the License for the specific language governing permissions and    
    limitations under the License.   
-->
<div id="qv-wrapper">
  <div id="qv">
    <h2>In this document</h2>
    <ol id="auto-toc">
    </ol>
  </div>
</div>

<p>The Android compatibility program makes it easy for mobile device
manufacturers to develop compatible Android devices.</p>

<h2 id="program-goals">Program goals</h2>

<p>The Android compatibility program works for the benefit of the entire
Android community, including users, developers, and device manufacturers.</p>
<p>Each group depends on the others. Users want a wide selection of devices
and great apps; great apps come from developers motivated by a large market
for their apps with many devices in users' hands; device manufacturers rely
on a wide variety of great apps to increase their products' value for
consumers.</p>
<p>Our goals were designed to benefit each of these groups:</p>
<ul>
<li>
<p><em>Provide a consistent application and hardware environment to application
developers.</em> 
    Without a strong compatibility standard, devices can vary so
greatly that developers must design different versions of their applications
for different devices. The compatibility program provides a precise definition
of what developers can expect from a compatible device in terms of APIs and
capabilities. Developers can use this information to make good design
decisions, and be confident that their apps will run well on any compatible
device.</p>
</li>
<li>
<p><em>Enable a consistent application experience for consumers.</em>
    If an application runs well on one compatible Android device, it should run well on
any other device that is compatible with the same Android platform version.
Android devices will differ in hardware and software capabilities, so the
compatibility program also provides the tools needed for distribution systems
such as Google Play to implement appropriate filtering. This means
users see only the applications they can actually run.</p>
</li>
<li>
<p><em>Enable device manufacturers to differentiate while being
compatible.</em>
    The Android compatibility program focuses on the aspects of
Android relevant to running third-party applications, which allows device
manufacturers the flexibility to create unique devices that are nonetheless
compatible.</p>
</li>
<li>
<p><em>Minimize costs and overhead associated with compatibility.</em>
    Ensuring compatibility should be easy and inexpensive to
device manufacturers. The testing tool is free, open source, and
available for <a href="cts/downloads.html">download</a>.
It is designed to be used for continuous self-testing
during the device development process to eliminate the cost of changing your
workflow or sending your device to a third party for testing. Meanwhile, there
are no required certifications, and thus no corresponding costs and
fees.</p>
</li>
</ul>

<h2 id="program-components">Program components</h2>

<p>The Android compatibility program consists of three key components:</p>
<ul>
<li>The <a href="https://android.googlesource.com/">Android Open Source Project</a> source code</li>
<li>The <a href="cdd.html">Compatilbility Definition Document (CDD)<a/>, representing the "policy" aspect of compatibility</li>
<li>The <a href="cts/index.html">Compatilbility Test Suite (CTS)</a>, representing the "mechanism" of compatibility</li>
</ul>

<p>Just as each version of the Android platform exists in a separate branch in
the source code tree, there is a separate CTS and CDD for each version as
well. The CDD, CTS, and source code are -- along with your hardware and your
software customizations -- everything you need to create a compatible device.</p>
