page.title=Android, the world's most popular mobile platform
excludeFromSuggestions=true
walkthru=0
header.hide=0

@jd:body

<div style="position:absolute;width:440px;">
<p>Android powers hundreds of millions of mobile devices in more than 190
countries around the world. It's the largest installed base of any mobile platform
and growing fast&mdash;every day another million users power up their
Android devices for the first time and start looking for apps, games,
and other digital content. </p>

<div style="width:330px">
<p>Android gives you a world-class platform for creating apps and games for
Android users everywhere, as well as an open marketplace for distributing
to them instantly.</p>
</div>
</div>

<img src="{@docRoot}images/about/growth-chart.png" alt="" height="400" width="681"
style="margin:20px 0 10px 30px;" />
<div style="position:relative;left: 450px;width: 250px;top: -20px;color: #777;">
  <em>Android growth in device activations</em></div>


<h3>Global partnerships and large installed base</h3>

<p>Building on the contributions of the open-source Linux community and more
than 300 hardware, software, and carrier partners, Android has rapidly become
the fastest-growing mobile OS.</p>

<blockquote>Every day more than 1 million new Android devices are activated worldwide.</blockquote>

<p>Android’s openness has made it a favorite for consumers and developers alike,
driving strong growth in app consumption. Android users download more than 
1.5 billion apps and games from Google Play each month. </p>

<p>With its partners, Android is continuously pushing the boundaries of hardware and software
forward to bring new capabilities to users and developers. For developers, 
Android innovation lets you build powerful, differentiated applications
that use the latest mobile technologies.</p>

<!-- <h3>Rapid innovation</h3>

<p>Android is continuously pushing the boundaries of hardware and software
forward, to bring new capabilities to users and developers. For developers, the
rapid evolution of Android technology lets you stay in front with powerful,
differentiated applications.</p>

<p>Android gives you access to the latest technologies and innovations across a
multitude of device form-factors, chipset architectures, and price points. From
multicore processing and high-performance graphics to state-of-the-art sensors,
vibrant touchscreens, and emerging mobile technologies such as Near Field
Communication (NFC), Wi-Fi P2P, and face tracking.</p> -->

<h3>Powerful development framework</h3>

<blockquote>Easily optimize a single binary for phones, tablets, and other devices.</blockquote>

<p>Android gives you everything you need to build best-in-class app experiences.
It gives you a single application model that lets you deploy
your apps broadly to hundreds of millions of users across a wide range of
devices&mdash;from phones to tablets and beyond.</p>

<p>Android also gives you tools for creating apps that look great and take
advantage of the hardware capabilities available on each device. It
automatically adapts your UI to look its best on each device, while giving you
as much control as you want over your UI on different device
types. </p> 

<p>For example, you can create a single app binary that's optimized for
both phone and tablet form factors. You declare your UI in lightweight sets of XML
resources, one set for parts of the UI that are common to all form factors and
other sets for optimzations specific to phones or tablets.
At runtime, Android applies the correct resource sets based on its screen size,
density, locale,
and so on.</p>


<p>To help you develop efficiently, the <a href="{@docRoot}tools/index.html">Android 
    Developer Tools</a>
offer a full Java IDE with advanced features for developing, debugging, and
packaging Android apps. Using the IDE, you can develop on any available Android
device or create virtual devices that emulate any hardware configuration.</p>

<blockquote>1.5 billion downloads a month and growing. Get your apps in front
of millions of users at Google's scale.</blockquote>

<h3>Open marketplace for distributing your apps</h3>

<p>Google Play is the premier marketplace for selling and distributing Android apps.
When you publish an app on Google Play, you reach the huge installed base of
Android.</p>

<div style="float:left;margin-right:24px;margin-top:12px;">
<img src="{@docRoot}images/gp-device.png">
</div>

<p>As an open marketplace, Google Play puts you in control of how you sell your
products. You can publish whenever you want, as often as you want, and to the
customers you want. You can distribute broadly to all markets and
devices or focus on specific segments, devices, or ranges of hardware
capabilities.</p>

<p>You can monetize in the way that works best for your business&mdash;priced or
free, with in-app products or subscriptions&mdash;for highest engagement and
revenues. You also have complete control of the pricing for your apps
and in-app products and can set or change prices in any supported currency at
any time.<p>

<p>Beyond growing your customer base, Google Play helps you build visibility and
engagement across your apps and brand. As your apps rise in popularity, Google
Play gives them higher placement in weekly "top" charts and rankings, and for
the best apps promotional slots in curated collections.
</p>

<p>Preinstalled on hundreds of millions of Android devices around the world,
Google Play can be a growth engine for your business.</p>

<p><a class="landing-page-link" href="{@docRoot}about/start.html">GET STARTED</a></p>

<div style="background: #F0F0F0;
            border-top: 1px solid #DDD;
            padding: 20px 0 24px 0;
            overflow: auto;
            clear:both;
            margin-bottom:-10px;
            margin-top:60px;"">
   <div style="padding:0 0 0 29px;">
        <h4>Developer Story: Robot Invader</h4>
          <img alt="" class="screenshot thumbnail" style="-webkit-border-radius: 5px;
            -moz-border-radius: 5px;
            border-radius: 5px height:78px;
            width: 78px;
            float: left;
            margin: 17px 20px 9px 0;" src=
            "//g0.gstatic.com/android/market/com.robotinvader.knightmare/hi-256-0-9e08d83bc8d01649e167131d197ada1cd1783fb0">
          <div style="width:700px;">
          <p style="margin-top:26px;margin-bottom:12px;">Robot Invader chose 
              Android as the launch platform for their first game, 
              <a data-g-event="Developers Page" data-g-label="Case Study Link" href=
              "//play.google.com/store/apps/details?id=com.robotinvader.knightmare"><em>Wind-up
              Knight</em></a>.
           </p>
           <p>
              Hear from the developers themselves how Android helped them reach more
              than 100 devices with a single app binary, then iterate rapidly to ensure
              a great experience for users.
           </p>
           </div>
           <iframe style="float:left;
             margin-right:24px;
             margin-top:14px;" width="700" height="394" src=
             "http://www.youtube.com/embed/hTtlLiUTowY" frameborder="0" allowfullscreen></iframe>
   </div> 
</div>