page.title=Content License		
@jd:body

<div id="mainBodyFluid">
<h1>Content License</h1>

<p>For the purposes of licensing, the content of this site is divided
into two categories:</p>
<ul>
  <li>Documentation content, found under the "Dev Guide" and "Reference"
  tabs, including both static content 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>All other content on this site, except 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>


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

<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 Restrictions 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>


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

<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 	
ANDROID stylized typeface logo) are not included in the license.
Please see <a href="http://www.google.com/permissions/guidelines.html">
Guidelines for Third Party Use of Google Brand Features</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="{@docRoot}sdk/terms.html">SDK Terms and Conditions</a>.</li>
</ul>
</h3>

<h3 id="attribution">Attribution</h3>
<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>
<h4>Exact Reproductions</h4>
<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>
<blockquote>
 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>.

</blockquote>
<p>
 Also, please link back to the original source page so that readers can
 refer there for more information.
</p>
<h4>Modified Versions</h4>
<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>
<blockquote>
 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>.
</blockquote>
<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>
<h4>Other Media</h4>
<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>	


