page.title=Brand Guidelines
@jd:body

<!--
    Copyright 2014 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" name, the <img src="{@docRoot}assets/images/sac_logo.png"
alt="Android" style="margin:0;padding:0 2px;vertical-align:baseline" /> logo,
the "Google Play" brand, and other trademarks are property of Google Inc. and
not part of the assets available through the Android Open Source Project.</p>

<p>If you are interested in using these brands to indicate their association
with your device, adhere to the guidelines on this page. These guidelines
correspond to and complement the
<a href="http://developer.android.com/distribute/tools/promote/brand.html">Brand
Guidelines for Android App Developers</a> and
<a href="http://www.google.com/permissions/">Google Brand Permissions</a>.</p>

<h2 id="brand-android">Android</h2>

<p>Here are manufacturer guidelines for the Android brand and related
assets.</p>

<h3 id="text-android" style="clear:right">Android in text</h3>
<ul>
  <li>Android&trade; should have a trademark symbol the first time it appears in
  a creative.</li>
  <li>"Android" should always be capitalized and is never plural or possessive.
  </li>
  <li>The use of “Android” on hardware, packaging or marketing materials of
  device is restricted to
  <a href="{@docRoot}compatibility/index.html">Android-compatible</a> devices
  only.</li>
  <li>“Android” should never be used in the name of your product or as the
  primary or dominant mark on your packaging or device.</li>
  <li>"Android” should be used only as a term to refer to the operating system
  (OS) of your device. If you are unsure whether your use meets our guidelines,
  follow this simple test: If you can replace "Android" with "the Android
  platform" and the text still makes sense, then you may use this term.
  <ul>
    <li><span style="color:red">Incorrect</span>: "Android XBrand Phone"</li>
    <li><span style="color:green">Correct</span>: "XBrand phone on Android"</li>
  </ul>
  </li>
  <li>You may use “with Android” in plain black text with your logo. If used
  with your logo, "with Android" should be no larger than 90% of your logo’s
  size. First or most prominent instance of this use should be followed by a
  &trade; symbol.</li>
  <li>Android may be used <em>only as a descriptor</em>, as long as it is
  followed by a proper generic term. It cannot be framed as the product name or
  brand of your device.
  <ul>
    <li><span style="color:red">Incorrect</span>: "Android XBrand Phone"</li>
    <li><span style="color:green">Correct</span>: "Android mobile device"</li>
  </ul>
  <p><strong>Any use of the Android name must include this attribution in your
  communication</strong>:</p>
  <blockquote><em>Android is a trademark of Google Inc.</em></blockquote></p>
  </li>
</ul>

<h4>Acceptable examples</h4>
<img src="images/JB-TM-example.png" alt="Jelly Bean trademark example" />
<img src="images/8100-TM-example.png" alt="8100 series trademark example" />

<h4>Unacceptable example</h4>
<img src="images/XBrand-TM-example.jpg" alt="XBrand trademark example" />

<h3 id="logo-android">Android logo</h3>
<p>Unless expressly authorized by Google through written agreement, the Android
logo and custom typeface may not be used (with or without the Android robot).</p>
<img alt="No Logo" src="images/android_logo_new_crossed_out.png">
<img alt="No Logo" src="http://developer.android.com/images/brand/android_logo_no.png">

<h3 id="robot-android">Android robot</h3>

<div class="wrap">
<div class="col-4">
  <img alt="android-robot" style="float:left;margin-right:10px" src="/source/images/Android_Robot_100.png">
  <p style="padding-top:20px">
  <a href="http://developer.android.com/images/brand/Android_Robot_100.png">100x118</a><br>
  <a href="http://developer.android.com/images/brand/Android_Robot_200.png">200x237</a><br>
  <a href="http://developer.android.com/downloads/brand/Android_Robot_outlined.ai">Illustrator</a>
  </p>
</div>
<div class="col-8">
<p style="padding-top:20px">The Android robot can be used, reproduced, and
modified freely in marketing communications with proper attribution. For
details, refer to
<a href="http://developer.android.com/distribute/tools/promote/brand.html">App
Developers Brand Guidelines</a> and the
<a href="http://creativecommons.org/licenses/by/3.0/">Creative Commons
license</a>.</p>
</div>
</div>

<div class="wrap" style="padding-top:20px">
<div class="col-4" style="align:center">
<img alt="no-peace-robot" style="width:60%;height:60%" src="images/No_PeaceBot_200.jpg">
</div>
<div class="col-8">
<p style="padding-top:20px">The Android Peace Robot or any variation of the
Android Peace Robot (such as the Android robot with a peace sign) may not be
used in partner marketing.</p>
</div>
</div>

<div style="clear:both"></div>
<h2 id="brand-google_play">Google Play</h2>

<p>Use of the “Google Play” name and the Google Play Store icon on the
packaging of the hardware, marketing materials of the hardware, or the hardware
itself is allowed only on devices
<a href="{@docRoot}source/faqs.html#if-my-device-is-compatible-does-it-automatically-have-access-to-google-play-and-branding">licensed
to access Google Play</a>. For a list of devices licensed to use Google Play,
refer to
<a href="https://support.google.com/googleplay/answer/1727131">Supported
devices</a>.</p>


<h2>Other brands</h2>
<p><a href="http://www.android.com/auto/">Android Auto</a>,
<a href="http://www.android.com/tv/">Android TV</a>, and
<a href="http://www.android.com/wear/">Android Wear</a> are brands owned by
Google. These brands require Google proprietary software that runs on top of
Android and is available only through a license with Google. For information on
how to request a license, see
<a href="{@docRoot}compatibility/contact-us.html">Contact Us</a>.

<h2 id="Questions">Questions</h2>

<p>For additional brand usage information, contact the Android Partner
Marketing team by submitting the <a
href="https://support.google.com/googleplay/contact/brand_developer">Partner
Brand Inquiry Form</a>.</p>
