page.title=Licenses
@jd:body

<!--
    Copyright 2013 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 Open Source Project uses a few 
<a href="http://www.opensource.org/">open source initiative</a>
approved open source licenses for our software.</p>
<h2 id="android-open-source-project-license">Android Open Source Project License</h2>
<p>The preferred license for the Android Open Source Project is the
<a href="http://www.apache.org/licenses/LICENSE-2.0">Apache
Software License, Version 2.0</a> ("Apache 2.0"),
and the majority of the Android software is licensed
with Apache 2.0. While the project will strive to adhere to the preferred
license, there may be exceptions that will be handled on a case-by-case
basis. For example, the Linux kernel patches are under the GPLv2 license with
system exceptions, which can be found on <a href="http://www.kernel.org/pub/linux/kernel/COPYING">kernel.org</a>.</p>
<h2 id="contributor-license-grants">Contributor License Agreements</h2>
<p>All <em>individual</em> contributors (that is, contributors making contributions
only on their own behalf) of ideas, code, or documentation to the Android Open
Source Project will be required to complete, sign, and submit an <a
href="https://cla.developers.google.com/about/google-individual">Individual
Contributor License Agreement</a>. The agreement can be executed online through the
<a href="https://android-review.googlesource.com/#/settings/agreements">code review tool</a>.
The agreement clearly defines the terms under which intellectual
property has been contributed to the Android Open Source Project. This license
is for your protection as a contributor as well as the protection of the
project; it does not change your rights to use your own contributions for any
other purpose.</p>
<p>For a <em>corporation</em> (or other entity) that has assigned employees to
work on the Android Open Source Project, a <a
href="https://cla.developers.google.com/about/google-corporate">Corporate
Contributor License Agreement</a> is available.
This version of the agreement allows a
corporation to authorize contributions submitted by its designated employees
and to grant copyright and patent licenses. Note that a Corporate Contributor
License Agreement does not remove the need for any developer to sign their own
Individual Contributor License Agreement as an individual. The individual
agreement is needed to cover any of their contributions that are <em>not</em>
owned by the corporation signing the Corporate Contributor License Agreement.</p>
<p>Please note we based our agreements on the ones the
<a href="http://www.apache.org">Apache Software Foundation</a> uses, which can
be found on the <a href="http://www.apache.org/licenses/">Apache web site</a>.</p>
<h2 id="why-apache-software-license">Why Apache Software License?</h2>
<p>We are sometimes asked why Apache Software License 2.0 is the preferred
license for Android. For userspace (that is, non-kernel) software, we do in
fact prefer ASL2.0 (and similar licenses like BSD, MIT, etc.) over other
licenses such as LGPL.</p>
<p>Android is about freedom and choice. The purpose of Android is promote
openness in the mobile world, and we don't believe it's possible to predict or
dictate all the uses to which people will want to put our software. So, while
we encourage everyone to make devices that are open and modifiable, we don't
believe it is our place to force them to do so. Using LGPL libraries would
often force them to do just that.</p>
<p>Here are some of our specific concerns:</p>
<ul>
<li>
<p>LGPL (in simplified terms) requires either: shipping of source to the
application; a written offer for source; or linking the LGPL-ed library
dynamically and allowing users to manually upgrade or replace the library.
Since Android software is typically shipped in the form of a static system
image, complying with these requirements ends up restricting OEMs' designs.
(For instance, it's difficult for a user to replace a library on read-only
flash storage.)</p>
</li>
<li>
<p>LGPL requires allowance of customer modification and reverse
engineering for debugging those modifications.  Most device makers do
not want to have to be bound by these terms. So to minimize the burden on
these companies, we minimize usage of LGPL software in userspace.</li></p>
</li>
<li>
<p>Historically, LGPL libraries have been the source of a large number
of compliance problems for downstream device makers and application
developers. Educating engineers on these issues is difficult and slow-going,
unfortunately. It's critical to Android's success that it be as easy as
possible for device makers to comply with the licenses.  Given the
difficulties with complying with LGPL in the past, it is most prudent to
simply not use LGPL libraries if we can avoid it.</p>
</li>
</ul>
<p>The issues discussed above are our reasons for preferring ASL2.0 for
our own code. They aren't criticisms of LGPL or other licenses. We are
passionate about this topic, even to the point where we've gone out of our
way to make sure as much code as possible is ASL2.0 licensed. However, we love all free
and open source licenses, and respect others' opinions and preferences. We've
simply decided ASL2.0 is the right license for our goals.</p>
