page.title=Legal Notice
fullpage=1
@jd:body

<div class="wrap" style="width:940px;">
  
<h1>Legal Notice</h1>
  
<p>Android is an open platform that's freely available to you as an app developer. You can
immediately download the Android SDK, develop apps, and distribute them to the world without any
registration or fees.</p>

<p>Android is developed by Google Inc. and the <a
href="http://www.openhandsetalliance.com/">Open Handset Alliance</a>. We've made it available to you
as a development platform pursuant to our commitment to openness, freedom, and innovation in
mobile.</p>

<p>To start developing apps for Android, <a
href="{@docRoot}sdk/index.html">download the free Android SDK</a>.</p>

<h2 id="Brands">Android Brands</h2>

<p>The "Android" name, the <img src="images/android-logo.png" alt="Android"
style="margin:0;padding:0 2px;vertical-align:baseline" /> logo, and
<a href="http://www.google.com/permissions/">other trademarks</a> are property of Google Inc.
You may not use the logo or the logo's custom typeface.</p>

<p>You may use the word "Android" in a product name only as a descriptor, such as "for Android"
and the first instance should be followed by a TM symbol, "for Android&trade;." In other
messaging, the word "Android" may be used in text as a descriptor, as long as it is followed by a
proper generic term (for example, "Android&trade; application"). Any use of the Android name
must include footer attribution in your communications: "Android is a trademark of Google Inc."</p>

<p>The Android Robot logo <img src="images/robot-tiny.png" alt=""
style="margin:0;padding:0;vertical-align:baseline" /> can be used, reproduced, and modified freely
in marketing communications. Our standard color value for print is PMS 376C. Our online hex color is
#A4C639. The Android Robot logo is licensed under the terms of the <a
href="http://creativecommons.org/licenses/by/2.5/">Creative Commons Attribution</a> license and any
use of it must be attributed as such.</p>

<p>For more information about Android brands, see the <a
href="{@docRoot}distribute/googleplay/promote/brand.html">Android Branding Guidelines</a>.</p>

<p>All other trademarks are the property of their respective owners.</p>

<h2 id="WebSite">Web Site Content</h2>

<p>We are pleased to license the Android documentation and sample code on this web site under terms
that encourage you to take, modify, reuse, re-purpose, and remix the content as you see fit. The
documentation content on this web site is made available to you as part of the <a
href="http://source.android.com">Android Open Source Project</a>. This documentation, including any
code shown in it, is licensed under the <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache
2.0 license</a>. All other content on this site, except the license documents themselves and as
otherwise noted, is licensed under the <a
href="http://creativecommons.org/licenses/by/2.5/">Creative Commons Attribution 2.5</a> license.
</p>

<p>For more information about licenses provided for the content of this web site and the
restrictions for re-use, read the complete <a href="license.html">Content License</a>.</p>

<p>Your use of this site is subject to <a href="http://www.google.com/policies/">Google's Privacy
Policy &amp; Terms of Service</a>.</p>



<h2 id="Other">Other Android Services</h2>

<p>Google provides other optional services for your Android apps that have their own legal terms and
restrictions. Such services include:</p>

<dl>
  <dt>Eclipse Android Developer Tools Plugin</dt>
    <dd>If you're developing apps with the Eclipse IDE, we offer a free plugin called the
<a href="{@docRoot}tools/sdk/eclipse-adt.html">Android Developer Tools</a> (ADT) to speed up your
development and debugging. Certain code within the ADT plugin and other packages available
from the SDK Manager require that you agree to terms and conditions for use, reproduction and
distribution upon installation.</dd>

  <dt>Google Play</dt>
    <dd>Google Play is a publicly available service through which you can distribute your apps for
Android-powered devices. Google Play not only makes your app available to millions of devices, but
also offers your app powerful services such as in-app billing and license verification. In order to
distribute your apps on Google Play and use the associated services, you must agree to the Developer
Distribution Agreement and acquire a valid Developer Account.
      <p><a
href="http://www.android.com/us/developer-distribution-agreement.html">Developer Distribution
Agreement</a>, <a
href="http://www.android.com/us/developer-content-policy.html#showlanguages">Developer Program
Policies</a></p></dd>

  <dt>Google Maps API</dt>
    <dd>The Android Maps APIs are a collection of services (including, but not limited to, the
MapView and MapActivity classes) that allow you to include
maps, geocoding, geolocation, and other content from Google and its content providers in your
Android
apps. If you want to develop an Android app that displays Google Maps data, you must agree
to the terms of service, register, and get an API Key. Registration is free.    
      <p><a
href="https://developers.google.com/maps/documentation/android/maps-api-signup"
>Google Maps Android API Key Signup</a>, <a href="http://m.google.com/legalnotices">Mobile Legal
Notices</a></p>
    </dd>

  <dt>Android Cloud to Device Messaging</dt>
    <dd>Android Cloud to Device Messaging (C2DM) is a service that helps you send data from
your servers to your users' Android devices. The service provides a simple, lightweight
mechanism that your servers can use to tell your Android app to contact your server directly to
fetch updated app or user data. Before you can sign up for Android Cloud to Device Messaging, you
must agree to the terms of a legal agreement between you and Google. Registration is free.
    <p><a href="https://developers.google.com/android/c2dm/terms">Android Cloud to Device
Messaging Terms of Service</a></p>
    </dd>
    
  <dt>Android Backup Service</dt>
    <dd>Android Backup Service is integrated with Android's data backup framework to perform data
backup and restore for most devices running Android 2.2 or greater, using Google servers and a
backup transport on the device. Before you can sign up for Android Backup Service, you
must agree to the terms of a legal agreement between you and Google. Registration is free.
    <p><a href="https://developers.google.com/android/backup/terms">Android Backup Service
Terms of Service</a></p>
    </dd>
</dl>

<p>Any and all other services available for Android but not documented on <a
href="http://developer.android.com">developer.android.com</a> are subject to their own terms, as
documented on their respective web sites. </p>



</div>