community=true
page.title=Community
@jd:body

	<div id="mainBodyFluid">
<h1>Community</h1>
<p>Welcome to the Android developers community! We're glad you're here and invite you to participate in these discussions. Before posting, please read the <a href="http://source.android.com/community/groups-charter.html">Groups Charter</a> that covers the community guidelines.</p>

<p class="note"><strong>Note:</strong> If you are seeking discussion about Android source code (not application development),
then please refer to the <a href="http://source.android.com/community">Open Source Project Mailing lists</a>.</p>

<p style="margin-bottom:.5em"><strong>Contents</strong></p>
<ol class="toc">
  <li><a href="#BeforeYouPost">Before you post</a></li>
  <li><a href="#ApplicationDeveloperLists">Application developer mailing lists</a></li>
  <li><a href="#UsingEmail">Using email with the mailing lists</a></li>
  <li><a href="#UsingIRC">Using IRC</a></li>
</ol>

<h2 id="BeforeYouPost">Before you post</h2>
<p>Before writing a post, please try the following:</p>

<ol>
<li><a href="{@docRoot}guide/appendix/faq/index.html">Read the FAQs</a> The most common questions about developing Android applications are addressed in this frequently updated list.</li>
<li><strong>Type in keywords of your questions in the main Android site's search bar</strong> (such as the one above). This search encompasses all previous discussions, across all groups, as well as the full contents of the site, documentation, and blogs. Chances are good that somebody has run into the same issue before.</li>
<li><b>Search the mailing list archives</b> to see whether your questions have already been discussed.
  </li>
</ol>

<p>If you can't find your answer, then we encourage you to address the community.
As you write your post, please do the following:
<ol>
<li><b>Read
the <a href="http://source.android.com/community/groups-charter.html">mailing list charter</a></b> that covers the community guidelines. 
</li>
<li><b>Select the most appropriate mailing list for your question</b>. There are several different lists for 
developers, described below.</li>
<li>
    <b>Be very clear</b> about your question
in the subject -- it helps everyone, both those trying to answer your
question as well as those who may be looking for information in the
future.</li>
<li><b>Give plenty of details</b> in your post to
help others understand your problem. Code or log snippets, as well as
pointers to screenshots, may also be helpful. 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>.
  </li>
</ol>


<h3 id="ApplicationDeveloperLists">Application developer mailing lists</h3>
<ul>
<li><b>Android beginners</b> - You're new to Android application development. You want to figure out how to get started with the Android SDK and the basic Android APIs? Start here. This list is open to any discussion around beginner-type questions for developers using the SDK; this is a great way to get up and running with your new application on the Android platform. Ask about getting your development environment set up, get help with the first steps of Android development (your first User Interface, your first permission, your first file on the Android filesystem, your first app on the Android Market...). Be sure to check the archives first before asking new questions. Please avoid advanced subjects, which belong on android-developers, and user questions, which will get a better reception on android-discuss.
<ul>
<li>Subscribe using Google Groups:&nbsp;<a href="http://groups.google.com/group/android-beginners">android-beginners</a></li>
<li>Subscribe via email:&nbsp;<a href="mailto:android-beginners-subscribe@googlegroups.com">android-beginners-subscribe@googlegroups.com</a></li>
</ul>
</li>

<li><b>Android developers</b> - You're now an experienced Android application developer. You've grasped the basics of Android app development, you're comfortable using the SDK, now you want to move to advanced topics. Get help here with troubleshooting applications, advice on implementation, and strategies for improving your application's performance and user experience. This is the not the right place to discuss user issues (use android-discuss for that) or beginner questions with the Android SDK (use android-beginners for that).
<ul>
<li>Subscribe using Google Groups:&nbsp;<a href="http://groups.google.com/group/android-developers">android-developers</a></li>
<li>Subscribe via email:&nbsp;<a href="mailto:android-developers-subscribe@googlegroups.com">android-developers-subscribe@googlegroups.com</a></li>
</ul>
</li>

<li><b>Android discuss</b> - The "water cooler" of Android discussion. You can discuss just about anything Android-related here, ideas for the Android platform, announcements about your applications, discussions about Android devices, community resources... As long as your discussion is related to Android, it's on-topic here. However, if you have a discussion here that could belong on another list, you are probably not reaching all of your target audience here and may want to consider shifting to a more targeted list.
<ul>
<li>Subscribe using Google Groups:&nbsp;<a href="http://groups.google.com/group/android-discuss">android-discuss</a></li>
<li>Subscribe via email:&nbsp;<a href="mailto:android-discuss-subscribe@googlegroups.com">android-discuss-subscribe@googlegroups.com</a></li>
</ul>
</li>

<li><b>Android ndk</b> - A place for discussing the Android NDK and topics related to using native code in Android applications. 
<ul>
<li>Subscribe using Google Groups:&nbsp;<a href="http://groups.google.com/group/android-ndk">android-ndk</a></li>
<li>Subscribe via email:&nbsp;<a href="mailto:android-ndk-subscribe@googlegroups.com">android-ndk-subscribe@googlegroups.com</a></li>
</ul>
</li>

<li><b>Android security discuss</b> - A place for open discussion on secure development, emerging security concerns, and best practices for and by android developers. Please don't disclose vulnerabilities directly on this list, you'd be putting all Android users at risk.
<ul>
<li>Subscribe using Google Groups:&nbsp;<a href="http://groups.google.com/group/android-security-discuss">android-security-discuss</a></li>
<li>Subscribe via email:&nbsp;<a href="mailto:android-security-discuss@googlegroups.com">android-security-discuss@googlegroups.com</a></li>
</ul>
</li>

<li><b>Android security announce</b> - A low-volume group for security-related announcements by the Android Security Team.
<ul>
<li>Subscribe using Google Groups:&nbsp;<a href="http://groups.google.com/group/android-security-announce">android-security-announce</a></li>
<li>Subscribe via email:&nbsp;<a href="mailto:android-security-announce-subscribe@googlegroups.com">android-security-announce-subscribe@googlegroups.com</a></li>
</ul>
</li>

<li><b>Android Market Help Forum</b> - A web-based discussion forum where you can ask questions or report issues relating to Android Market.
<ul>
<li>URL:&nbsp;<a href="http://www.google.com/support/forum/p/Android+Market?hl=en">http://www.google.com/support/forum/p/Android+Market?hl=en</a></li>
</ul>
</li>

</ul>



<h2 id="UsingEmail">Using email with the mailing lists</h2>
<p>Instead of using the <a href="http://groups.google.com/">Google Groups</a> site, you can use your email client of choice to participate in the mailing lists.</p>
<p>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>Sign into the group via the Google Groups site. For example, for the android-framework group you would visit <a href="http://groups.google.com/group/android-framework">http://groups.google.com/group/android-framework</a>.</li>
<li>Click "Edit
my membership" on the right side.</li>
<li>Under "How do
you want to read this group?" select one of the email options. </li>
</ol>

<h2 id="UsingIRC">Using IRC</h2>
<p>The Android community is using the #android channel on the irc.freenode.net server.
</p>







</div>
