page.title=Android Community
@jd:body

<!--
    Copyright 2015 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>Welcome to the Android community!</p>

<p>The key to any community is communication. Like most projects, Android
communicates via mailing lists. Because Android is an extremely large
project with many components, we have many discussion forums, each focusing on
a different topic. View the available <a href="#open-source-project-discussions">groups</a>
and join any that seem interesting to you. You can also discuss Android on
<a href="#android-on-irc">IRC</a>.</p>

<p>If you are a user looking for help with the Android UI or an Android device,
details on Android updates or security issues, or how to build applications for
Android, see the list of <a href="#resources">resources</a> below.</p>

<h2 id="resources">Resources</h2>

<p>This site covers creating custom Android stacks, porting devices and
accessories, and meeting compatibility requirements. For other information about
Android, refer to the following resources.</p>

<div class="wrap">
<div class="col-4">

<h4>Using Android</h4>

<h5>Help centers</h5>
<a href="https://support.google.com/android/?hl=en">General</a><br>
<a href="https://support.google.com/nexus/?hl=en#topic=3415518">Nexus Phones/Tablets</a><br>
<a href="https://support.google.com/playedition#topic=3450794">Google Play Edition</a><br>
<a href="https://support.google.com/androidauto/?hl=en">Auto</a><br>
<a href="https://support.google.com/androidtv/?hl=en#topic=6121147">TV</a><br>
<a href="https://support.google.com/androidwear/?hl=en#topic=6056405">Wear</a><br>
<a href="https://support.google.com/android/answer/3123680">Apps</a>
<p></p>

<h5>Communities</h5>
<a href="#open-source-project-discussions">AOSP communities</a><br>
<a href="http://developer.android.com/support.html">Developer communities</a>
<p></p>

<h5>Send feedback</h5>
<a href="{@docRoot}source/report-bugs.html">Report AOSP bug</a><br>
<a href="https://code.google.com/p/android/issues/entry?template=Feature%20request">Suggest
a feature</a>
<p></p>

</div>
<div class="col-4">


<h4>Updates &#38; security</h4>

<h5>Android releases</h5>
<a href="https://www.android.com/history/#/marshmallow">Android History</a><br>
<a href="https://www.android.com/versions/marshmallow-6-0/">Current Release</a>
<p></p>

<h5>Device images</h5>
<a href="https://developers.google.com/android/nexus/images?hl=en">Nexus devices</a><br>
<a href="https://support.google.com/android/answer/3094742">Other devices</a>
<p></p>

<h5>Security assistance</h5>
<a href="https://www.google.com/safetycenter/everyone/start/">Google Safety Center</a><br>
<a href="https://support.google.com/android/answer/6215472?hl=en">Tips for users</a><br>
<a href="http://developer.android.com/training/articles/security-tips.html">Tips
for developers</a><br>
<a href="{@docRoot}security/index.html">Platform security</a>
<p></p>

<h5>Security announcements</h5>
<a href="{@docRoot}security/enhancements/index.html">Release
Enhancements</a><br>
<a href="{@docRoot}security/bulletin/index.html">Bulletins</a>
<p></p>

</div>
<div class="col-4">

<h4>Getting involved</h4>

<h5>Developer resources</h5>
<a href="http://developer.android.com/">Developer.android.com</a><br>
<a href="http://developer.android.com/support.html">Developer support</a><br>
<a href="http://android-developers.blogspot.com/">Android developers blog</a><br>
<a href="https://developers.google.com/groups/">Google Developer Groups (GDGs)</a>
<p></p>

<h5>Training</h5>
<a href="https://developer.android.com/training/index.html">Google</a><br>
<a href="https://www.udacity.com/google">Udacity</a>

</div>
</div>
<div style="clear: both;"></div>


<h2 id="open-source-project-discussions">Open Source Project discussions</h2>
<ul>
<li>
<p><em>android-platform</em>:
This list is for general discussion about the Android Open Source Project or
the platform technologies.</p>
<ul>
<li>Subscribe using Google Groups:
<a href="https://groups.google.com/forum/?fromgroups#!forum/android-platform">
android-platform</a></li>
<li>Subscribe via email:
<a href="mailto:android-platform+subscribe@googlegroups.com">android-platform
</a></li>
</ul>
</li>
<li>
<p><em>android-building</em>:
Subscribe to this list for discussion and help on building the Android source
code, and on the build system. If you've just checked out the source code and
have questions about how to turn it into binaries, start here.</p>
<ul>
<li>Subscribe using Google Groups:
<a href="https://groups.google.com/forum/?fromgroups#!forum/android-building">
android-building</a></li>
<li>Subscribe via email:
<a href="mailto:android-building+subscribe@googlegroups.com">android-building
</a></li>
</ul>
</li>
<li>
<p><em>android-porting</em>:
This list is for developers who want to port Android to a new device. If
you're wondering how to combine the Android source code with your hardware,
this is the right group for you. Discuss here the specifics of porting Android
to individual devices, from obtaining toolchains and merging kernel drivers
all the way to configuring or modifying applications for your specific
configuration.</p>
<ul>
<li>Subscribe using Google Groups:
<a href="https://groups.google.com/forum/?fromgroups#!forum/android-porting">
android-porting</a></li>
<li>Subscribe via email:
<a href="mailto:android-porting+subscribe@googlegroups.com">android-porting</a>
</li>
</ul>
</li>
<li>
<p><em>android-contrib</em>:
This list is for developers who want to contribute code to Android. This is a
working list, and is not appropriate for general discussion. We ask that
general discussion go to android-platform (and contributors to the Android
kernel should go to android-kernel).</p>
<ul>
<li>Subscribe using Google Groups:
<a href="https://groups.google.com/forum/?fromgroups#!forum/android-contrib">
android-contrib</a></li>
<li>Subscribe via email:
<a href="mailto:android-contrib+subscribe@googlegroups.com">android-contrib</a>
</li>
</ul>
</li>
<li>
<p><em>android-kernel</em>:
This list is for developers who want to contribute to the Linux kernel used by
Android devices. If you've downloaded the kernel code, know how to compile it,
and want to write kernel code to support Android, this is your place. This
group is <em>not</em> for user-space topics (see android-platform); people
will shake their fingers at you and call you naughty if you ask user-space
questions here.</p>
<ul>
<li>Subscribe using Google Groups:
<a href="https://groups.google.com/forum/?fromgroups#!forum/android-kernel">
android-kernel</a></li>
<li>Subscribe via email:
<a href="mailto:android-kernel+subscribe@googlegroups.com">android-kernel</a>
</li>
</ul>
<li>
<p><em>android-ota</em>:
This list is for developers working on the Android OTA system (the recovery
image and the scripts that generate OTAs).</p>
<ul>
<li>Subscribe using Google Groups:
<a href="https://groups.google.com/forum/?fromgroups#!forum/android-ota">
android-ota</a></li>
<li>Subscribe via email:
<a href="mailto:android-ota+subscribe@googlegroups.com">android-ota</a></li>
</ul>
</li>
</ul>

<h3 id="audience">Audience</h3>
<p>These discussion groups are intended for developers working with the Android
platform. Everyone is welcome to join in, provided you follow the community
policies described below. Our users help each other, and many experts post to
these groups, including members of the Open Handset Alliance.</p>
<p>No topic is off-limits, provided it relates to Android in some way. However,
since these are very busy lists, search the archives before posting your
question; you may find your question has already been answered.</p>


<h3 id="getting-the-most-from-our-lists">Getting the Most from Our Lists</h3>
<p>Please consider the following before you post to our lists.</p>
<ul>
<li>
<p><em>Read the <a href="#mailing">Charter for our forums.</a></em> This
explains the (few) rules and guidelines for our community.</p>
</li>
<li>
<p><em>Search the group archives to see whether your questions have already
been discussed.</em> This avoids time-wasting redundant discussions.</p>
</li>
<li>
<p><em>Use a clear, relevant message subject.</em> This helps everyone, both
those trying to answer your question as well as those who may be looking for
information in the future.</p>
</li>
<li>
<p><em>Give plenty of details in your post.</em> Code or log snippets,
pointers to screenshots, and similar details will get better results and make
for better discussions. For a great guide to phrasing your questions, read
<a href="http://www.catb.org/%7Eesr/faqs/smart-questions.html">How to Ask
Questions the Smart Way</a>.</p>
</li>
</ul>

<h3 id="mailing">Mailing list rules</h3>
<p>We love simplicity and hate restrictions, so we keep our policies minimal.
The rules below describe what's expected of subscribers to the Android mailing
lists.</h2>

<ul>
<li><em>Please be friendly</em>: Showing courtesy and respect to others is a
vital part of the Android culture, and we expect everyone participating in the
Android community to join us in accepting nothing less. Being courteous does
not mean we can't constructively disagree with each other, but it does mean
that we must be polite when we do so. There's never a reason to be
antagonistic or dismissive toward anyone; if you think there is, think again
before you post. Mobile development is serious business, but it's also a lot
of fun. Let's keep it that way. Let's strive to be one of the friendliest
communities in all of open source.
</li>
<li><em>Allowed discussion topics</em>: Most of our groups are for technical
discussions of Android or users helping each other. Generally we don't put
hard restrictions on the topics discussed in the group: as long as the topic
is relevant to Android in some way, it's welcome on our groups. We welcome
announcements and discussion of products, libraries, publications, and other
interesting Android-related news, but please do not cross-post. Post only to
the most relevant group for your message. We even welcome (polite!) discussion
of articles and ideas critical of Android&mdash;after all, we can't improve if
we don't listen.
</li>
<li><em>Working Lists</em>: Some of our groups are considered "working lists",
by which we mean that the list is intended to be used in support of the
completion of specific tasks. On these groups, we don't welcome off-topic
conversations, and will generally ask you to take general discussions to a
different list. Since these are lists where people are trying to get work
done, we will be pretty aggressive about keeping the noise level low. We ask
that you respect our contributors' time and keep general discussions to
appropriate lists.
</li>
<li><em>Spam</em>: We hate spam almost as passionately as we love courtesy and
respect, so we reserve the right to limit discussions that amount to spam.
Outright spam will result in the spammer being immediately and permanently
banned from the list.
</li>
</ul>
<p>The most important rule is friendliness. Remember: disrespect and rudeness
are not welcome in our community under any circumstances. We don't have a
formal policy on dealing with troublemakers, and we hope we never need one.
That said, we do pledge to do our best to be fair, and we will always try to
warn someone before banning him or her.</p>

<h3 id="contacting">Contacting the moderators</h3>
<p>If you see anyone being rude, call them out on it. This is your group too,
and you don't have to accept someone else being disrespectful just because it
wasn't directed at you. Just remember to be polite and courteous yourself!
Don't add fuel to the fire.</p>
<p>But if you see an outrageous violation, want to report spam, feel strongly
about something, or just want to chat, then contact the mailing list owners.
It's what we're here for!</p>

<h3 id="using-email-with-google-groups">Using email with Google Groups</h3>
<p>Instead of using the <a href="https://groups.google.com/">Google groups</a>
site, you can use your email client of choice to participate in the mailing
lists. To subscribe to a group without using the Google Groups site, use the link
under "subscribe via email" in the lists above.</p>
<p>To set up how you receive mailing list postings by email:</p>
<ol>
<li>
<p>Sign into the group via the Google Groups site. For example, for the
android-platform group you would use
<a href="https://groups.google.com/forum/?fromgroups#!forum/android-platform">
https://groups.google.com/forum/?fromgroups#!forum/android-platform</a>.</p>
</li>
<li>
<p>Click "My membership" on the right side.</p>
</li>
<li>
<p>Under "How do you want to read this group?" select one of the email options.</p>
</li>
</ol>
<h2 id="android-on-irc">Android on IRC</h2>
<p>Android has a presence on IRC via
<a href="http://freenode.net/">freenode</a>. We maintain two official IRC
channels on <a href="irc://irc.freenode.net/">irc.freenode.net</a> (access via
the web at <a href="http://webchat.freenode.net/">freenode webchat</a>)</p>
<ul>
<li>
<p><a href="irc://irc.freenode.net/android">#android</a> - dedicated to
general Android discussion and porting concerns</p>
</li>
<li>
<p><a href="irc://irc.freenode.net/android-dev">#android-dev</a> - dedicated to discussion about writing Android applications</p>
</li>
</ul>
<p>The community also uses several <em>unofficial</em> channels that are not not officially moderated or managed. The Open Handset Alliance does not endorse unofficial channels and there's no warranty express or implied, so use them at your own risk. Here's a list of a few unofficial channels (many more may exist):</p>

<ul>
<li>
<p><a href="irc://irc.freenode.net/android-firehose">#android-firehose</a> -
displays in real-time the commits to the Android Open Source Project</p>
</li>
<li>
<p><a href="irc://irc.freenode.net/android-fr">#android-fr</a> - pour discuter
d'Android en français</p>
</li>
<li>
<p><a href="irc://irc.freenode.net/android-offtopic">#android-offtopic</a> -
for, well, off-topic discussions</p>
</li>
<li>
<p><a href="irc://irc.freenode.net/android-root">#android-root</a> - for
discussion related to off-label uses of hardware</p>
</li>
</ul>