page.title=Open Distribution
@jd:body

<p>As an open platform, Android offers choice. You
distribute your Android apps to users in any way you want, using any
distribution approach or combination of approaches that meets your needs. 
From publishing in an app marketplace to serving your apps from a web site or
emailing them directly users, you are never locked into any
particular distribution platform.</p>

<p>The process for building and packaging your app for distribution is the same,
regardless of how you will distribute your app. This saves you time and lets you
automate parts of the process as needed. You can read <a 
href="{@docRoot}tools/publishing/preparing.html">Preparing 
for Release</a> for more information.</p>

<p>The sections below highlight some of the alternatives for distributing
your apps to users.</p>

<h2 id="publishing-marketplace">Distributing through an App Marketplace</h2>

<p>Usually, to reach the broadest possible audience, you would distribute your
apps through a marketplace, such as Google Play.</p>

<p>Google Play is the premier marketplace for Android apps and is particularly
useful if you want to distribute your applications to a large global audience.
However, you can distribute your apps through any app marketplace you want or
you can use multiple marketplaces.</p>

<h2 id="publishing-email">Distributing your application through email</h2>

<div class="figure" style="width:246px">
  <img src="{@docRoot}images/publishing/publishing_via_email.png"
       alt="Screenshot showing the graphical user interface users see when you send them an app"
       style="width:240px;" />
  <p class="img-caption">
    <strong>Figure 1.</strong> Users can simply click <strong>Install</strong> when you send them
    an application via email.
  </p>
</div>

<p>The easiest and quickest way to release your application is to send it to users through
email. To do this, you prepare your application for release and then attach it to an email
and send it to a user. When users open your email message on their Android-powered device,
the Android system will recognize the APK and display an <strong>Install Now</strong>
button in the email message (see figure 1). Users can install your application by touching the
button.</p>

<p class="note"><strong>Note:</strong> The <strong>Install Now</strong> button
shown in Figure 1 appears only if users have configured their device to allow
installation from <a href="#unknown-sources">unknown sources</a> and have opened your 
email with the native Gmail application.</p>

<p>Distributing applications through email is convenient if you are sending your application to
only a few trusted users, but it provides few protections from piracy and unauthorized
distribution; that is, anyone you send your application to can simply forward it to someone else.</p>

<h2 id="publishing-website">Distributing through a web site</h2>

<p>If you do not want to release your app on a marketplace like Google Play, you
can make the app available for download on your own website or server, including
on a private or enterprise server. To do this, you must first prepare your
application for release in the normal way. Then all you need to do is host the
release-ready APK file on your website and provide a download link to users.
</p>

<p>When users browse to the download link from their Android-powered devices,
the file is downloaded and Android system automatically starts installing it on
the device. However, the installation process will start automatically only if
users have configured their Settings to allow the installation of apps from
<a href="#unknown-sources">unknown sources</a>.</p>

<p>Although it is relatively easy to release your application on your own
website, it can be inefficient. For example, if you want to monetize your
application you will have to process and track all financial transactions
yourself and you will not be able to use Google Play's <a
href="{@docRoot}guide/google/play/billing/index.html">In-app Billing service</a>
to sell in-app products. In addition, you will not be able to use the <a
href="{@docRoot}guide/google/play/licensing/index.html">Licensing service</a> to
help prevent unauthorized installation and use of your application.</p>


<h2 id="unknown-sources">User Opt-In for Apps from Unknown Sources</h2>

<div class="figure" style="width:246px;margin-top:0;">
  <img src="{@docRoot}images/publishing/publishing_unknown_sources_sm.png"
       alt="Screenshot showing the setting for accepting download and install of
       apps from unknown sources." style="width:240px;" />
  <p class="img-caption">
    <strong>Figure 2.</strong> Users must enable the <strong>Unknown sources</strong>
    setting before they can install apps not downloaded from Google Play. 
  </p>
</div> 

<p>Android protects users from inadvertent download and install of apps from
locations other than Google Play (which is trusted). It blocks such installs
until the user opts-in <strong>Unknown sources</strong> in
Settings&nbsp;<strong>&gt;</strong>&nbsp;Security, shown in Figure 2. To allow
the installation of applications from other sources, users need to enable the
Unknown sources setting on their devices, and they need to make this
configuration change <em>before</em> they download your application to their
devices.</p> 

<p class="note">Note that some network providers do not allow users to install
applications from unknown sources.</p>


