<html devsite>
  <head>
    <title>Content License</title>
    <meta name="project_path" value="/_project.yaml" />
    <meta name="book_path" value="/_book.yaml" />
  </head>
  <body>
  <!--
      Copyright 2017 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.
  -->

<p>
  The Android Open Source Project (AOSP) uses a few
  <a href="http://www.opensource.org/" class="external">open source
  initiative</a> approved open source licenses for our software.
</p>
<h2 id="android-open-source-project-license">AOSP license</h2>
<p>
  The preferred license for AOSP is the
  <a href="http://www.apache.org/licenses/LICENSE-2.0" class="external">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 strives 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" class="external">kernel.org</a>.
</p>
<h2 id="contributor-license-grants">Contributor License Agreements</h2>
<p>All <em>individual</em> contributors (those making contributions only on
  their own behalf) of ideas, code, or documentation to AOSP will be required to
  complete, sign, and submit an
  <a href="https://cla.developers.google.com/about/google-individual" class="external">Individual
  Contributor License Agreement</a>. The agreement can be executed online
  through the
  <a href="https://android-review.googlesource.com/#/settings/agreements" class="external">code
  review tool</a>. The agreement clearly defines the terms under which
  intellectual property has been contributed to AOSP. 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 AOSP, a
  <a href="https://cla.developers.google.com/about/google-corporate" class="external">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. 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>
  We based our agreements on the ones used by the
  <a href="http://www.apache.org">Apache Software Foundation</a>, which can
  be found on the
  <a href="http://www.apache.org/licenses/" class="external">Apache website</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 (non-kernel) software, we prefer ASL2.0
  (and similar licenses such as BSD, MIT, etc.) over other licenses such as
  LGPL.
</p>
<p>
  Android is about freedom and choice. The purpose of Android is to 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>
    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 restricts OEMs' designs. For
    instance, it's difficult for a user to replace a library on read-only
    flash storage.)
  </li>
  <li>
    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>
  </li>
  <li>
    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.
  </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>

  </body>
</html>
