page.title=Content License
page.type=about
fullpage=1
excludeFromSuggestions=true
@jd:body

<div class="wrap" style="width:940px;">
  <h1>Content License</h1>
<p>For the purposes of licensing, the content of this web site is divided
into two categories:</p>
<ul>
  <li>Documentation content, including both static documentation and content extracted from source 
  code modules, as well as sample code, and </li>
<li>All other site content</li>
</ul>

<p>The documentation content on this 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>, the preferred license for all parts of the of the Android
Open Source Project.</p>

<p>Apache 2.0 is a commercial and open-source-friendly software
license. The majority of the Android platform and documentation is
licensed under the Apache 2.0 license. While the project strives to
adhere to the preferred license, there may be exceptions, such as for
documentation (code comments) extracted from a source code module that
is licensed under GPLv2 or other license. In those cases, the license
covering the source code module will apply to the documentation
extracted from it. </p>

<p>Third-party components of this site such as JavaScript libraries are included in the Android
Open Source Project under the licenses specified by their authors. For information about these
licenses, refer to the source files in the Android Open Source Project.</p>

<p>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>You may use the content of this site in any way that is consistent
with the specific license that applies to the content, as described
above. For content licensed under Creative Commons Attribution 2.5, we
ask that you give proper <a href="#attribution">attribution</a>. </p>


<h2 id="terms">Terms of Use</h2>

<p>We are pleased to license the Android documentation and sample code under
terms that encourage you to take, modify, reuse, re-purpose, and remix the
content as you see fit. Except as noted in the <a href="#restrictions">Restrictions</a> section
below, you
are free to use the documentation content in your own creations. For example,
you could quote the text in a book, cut-and-paste sections to your blog, record
it as an audiobook for the visually impaired, or even translate it. </p>


<h2 id="restrictions">Restrictions</h2>

<ul>
<li>While the documentation itself is available to you under the Apache 2.0
license, note that proprietary trademarks and brand features are not
included in that license.</li>

<li>Google's trademarks and other brand features (including the 	
<img src="images/android-logo.png" alt="Android"
style="margin:0;padding:0 2px;vertical-align:baseline" /> stylized typeface logo) are not included
in the license.
Please see <a
href="{@docRoot}distribute/tools/promote/brand.html">Brand Guidelines</a> for
information about this usage. </li>

<li>In some cases, a page may include content, such as an image, that is not 
covered by the license. In that case, we will label the content that is not licensed. </li>

<li>In addition, content linked from a page on this site is not covered
by the license unless specifically noted. For example, pages may link to videos or
slide decks that are not covered.</li>

<li>The use of sample source code provided in the SDK or shown in this
documentation is subject to the conditions detailed in the <a
href="http://www.apache.org/licenses/LICENSE-2.0">Apache 2.0 license</a>.</li>
</ul>

<h2 id="attribution">Attribution</h2>
<p>
Proper attribution is required when you reuse or create modified
versions of content that appears on a page made available under the
terms of the Creative Commons Attribution license. On this site, the
requirement for attribution applies only to the non-documentation
content, as described earlier in this document. The complete 
requirements for attribution can be found in section 4b of the 
<a href="http://creativecommons.org/licenses/by/2.5/legalcode">
Creative Commons legal code</a>.
</p>
<p>
 In practice we ask that you provide attribution to the Android Open
 Source project to the best of the ability of the medium in which you 
 are producing the work. There are several typical ways in which this 
 might apply:
</p>
<h3>Exact Reproductions</h3>
<p>
 If your online work <em>exactly reproduces</em> text or images from this
 site, in whole or in part, please include a paragraph at the bottom
 of your page that reads: 
</p>
<p style="margin-left:20px;font-style:italic">
 Portions of this page are reproduced from work created and <a
 href="http://code.google.com/policies.html">shared by the Android Open Source Project</a>
 and used according to terms described in the <a
 href="http://creativecommons.org/licenses/by/2.5/">Creative Commons
 2.5 Attribution License</a>.

</p>
<p>
 Also, please link back to the original source page so that readers can
 refer there for more information.
</p>
<h3>Modified Versions</h3>
<p>
 If your online work shows <em>modified</em> text or images based on
 the content from this site, please include a paragraph at the bottom of
 your page that reads:
</p>
<p style="margin-left:20px;font-style:italic">
 Portions of this page are modifications based on work created and <a
 href="http://code.google.com/policies.html">shared by the Android Open
 Source Project</a> and used according to terms described in the <a
 href="http://creativecommons.org/licenses/by/2.5/">Creative Commons
 2.5 Attribution License</a>.
</p>
<p>
 Again, please link back to the original source page so that readers can
 refer there for more information. This is even more important when
 the content has been modified.
</p>
<h3>Other Media</h3>
<p>
 If you produce non-hypertext works, such as books, audio, or
 video, we ask that you make a best effort to include a spoken or
 written attribution in the spirit of the messages above.
</p>

</div>
