page.title=Android Compatibility
@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>Android's purpose is to establish an open platform for developers to build
innovative apps.</p>
<ul>
<li>The Android Compatibility program defines technical details of the
Android platform and provides tools for OEMs to ensure developer applications
run on a variety of devices.</li>
<li>The Android SDK provides built-in tools for developers to clearly state the
device features required by their applications.
<li>Google Play shows applications only to those devices that can properly run
those applications.</li></li>

<h2 id="why-build-compatible-android-devices">Why build compatible Android
devices?</h2>

<h3 id="users-want-a-customizable-device">Users want customizable devices</h3>

<div class="figure">
  <img src="images/compat-ecosystem.png" alt="Compatibility ecosystem" id="figure1" />
  <p class="img-caption">
    <strong>Figure 1.</strong> The Android ecosystem thrives with device compatibility
  </p>
</div>

<p>A mobile phone is a highly personal, always-on, always-present gateway to
the Internet. We haven't met a user yet who didn't want to customize it by
extending its functionality. That's why Android was designed as a robust
platform for running aftermarket applications.</p>

<h3 id="developers-outnumber-us-all">Developers outnumber us all</h3>
<p>No device manufacturer can write all the software a user could conceivably
need. We need third-party developers to write the apps users want, so the
Android Open Source Project (AOSP) aims to make application development as easy
and open as possible.</p>

<h3 id="everyone-needs-a-common-ecosystem">Everyone needs a common ecosystem</h3>
<p>Every line of code developers write to work around a bug is a line of code
that didn't add a new feature. The more compatible mobile devices are, the more
applications we'll have to run on those devices. By building a fully compatible
Android device, you benefit from the huge pool of apps written for Android while
increasing the incentive for developers to build more apps.</p>

<h2 id="android-compatibility-is-free-and-its-easy">Android compatibility is
free, and it's easy</h2>
<p>To build an Android-compatible mobile device, follow this three-step
process:</p>
<ol>
<li><em>Obtain the <a href="{@docRoot}source/index.html">Android software source
code</a></em>. This is the source code for the Android platform that you port
to your hardware.</li>
<li><em>Comply with the Android Compatibility Definition Document (CDD)</em>
(<a href="{@docRoot}compatibility/android-cdd.pdf">PDF</a>, <a
href="{@docRoot}compatibility/android-cdd.html">HTML</a>). The CDD enumerates
the software and hardware requirements of a compatible Android device.</li>
<li><em>Pass the <a href="{@docRoot}compatibility/cts-intro.html">Compatibility
Test Suite (CTS)</a></em>. Use the CTS as an ongoing aid to evaluate
compatibility during the development process.</li> </ol>

<p>After complying with the CDD and passing the CTS, your device is Android
compatible, meaning Android apps in the ecosystem provide a consistent
experience when running on your device. For details about the Android
compatibility program, see the <a href="overview.html">program overview</a>.</p>

<h2 id="licensing-gms">Licensing Google Mobile Services (GMS)</h2>
<p>After building an Android compatible device, consider licensing Google Mobile
Services (GMS), Google’s proprietary suite of apps (Google Play, YouTube, Google
Maps, Gmail, and more ) that run on top of Android. GMS is not part of the
Android Open Source Project and is available only through a license with Google.
For information on how to request a GMS license, see
<a href="contact-us.html">Contact Us</a>.</p>
