page.title=Content License
fullpage=1
@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="https://android.googlesource.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. Source code modules that are used in the generation
of documentation and have licenses that require attribution can be
found in the <a href="#doclicenses">Documentation Licences section</a> below.</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="http://developer.android.com/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="https://developer.android.com/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="https://code.google.com/p/android/">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="https://code.google.com/p/android/">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>

<h2 id="doclicenses">Documentation Licenses</h2>
<h3 id="icu">ICU License</h3>
<p>The Android public API documentation incorporates text from the following source code libraries under the ICU License:</p>
<ul>
<li><a href="https://developer.android.com/reference/android/icu/lang/package-summary.html">android.icu.lang</a></li>
<li><a href="https://developer.android.com/reference/android/icu/math/package-summary.html">android.icu.math</a></li>
<li><a href="https://developer.android.com/reference/android/icu/text/package-summary.html">android.icu.text</a></li>
<li><a href="https://developer.android.com/reference/android/icu/util/package-summary.html">android.icu.util</a></li>
</ul>

<div class="aside" style="overflow:scroll; height:250px;">
<p>COPYRIGHT AND PERMISSION NOTICE</p>

<p>
Copyright (c) 1995-2015 International Business Machines Corporation and others
</p>
<p>
All rights reserved.
</p>
<p>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, and/or sell
copies of the Software, and to permit persons
to whom the Software is furnished to do so, provided that the above
copyright notice(s) and this permission notice appear in all copies
of the Software and that both the above copyright notice(s) and this
permission notice appear in supporting documentation.
</p>
<p>
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL
THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM,
OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
USE OR PERFORMANCE OF THIS SOFTWARE.
</p>
<p>
Except as contained in this notice, the name of a copyright holder shall not be
used in advertising or otherwise to promote the sale, use or other dealings in
this Software without prior written authorization of the copyright holder.
</p>
</div>

<h3 id="w3c_license">W3C Software and Document Notice and License</h3>
<p>The Android public API documentation incorporates text from the following source code libraries under the W3C Software and Document Notice and License:</p>
<ul>
<li><a href="https://developer.android.com/reference/org/w3c/dom/package-summary.html">org.w3c.dom</a></li>
<li><a href="https://developer.android.com/reference/org/w3c/dom/ls/package-summary.html">org.w3c.dom.ls</a></li>
</ul>

<div class="aside" style="overflow:scroll; height:250px;">
<p>This work is being provided by the copyright holders under the following license.</p>
<h5>License</h5>
<p>
 By obtaining and/or copying this work, you (the licensee) agree that you have read, understood,
 and will comply with the following terms and conditions.
</p>
<p>
 Permission to copy, modify, and distribute this work, with or without modification, for any
 purpose and without fee or royalty is hereby granted, provided that you include the following on
 ALL copies of the work or portions thereof, including modifications:
</p>
<ul>
<li>
 The full text of this NOTICE in a location viewable to users of the redistributed or
 derivative work.
</li>
<li>
 Any pre-existing intellectual property disclaimers, notices, or terms and conditions. If none
 exist, the W3C Software and Document Short Notice should be included.
</li>
<li>
 Notice of any changes or modifications, through a copyright statement on the new code or document
 such as "This software or document includes material copied from or derived from [title and URI of
 the W3C document]. Copyright © [YEAR] W3C® (MIT, ERCIM, Keio, Beihang)."
</li>
</ul>
<h5>Disclaimers</h5>
<p>
 THIS WORK IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY
 PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY
 PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
</p>
<p>
 COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES
 ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT.
</p>
<p>
 The name and trademarks of copyright holders may NOT be used in advertising or publicity
 pertaining to the work without specific, written prior permission. Title to copyright in this work
 will at all times remain with copyright holders.
</p>
</div>
</div>
