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

	<div id="mainBodyFluid">
			<h1>Community</h1>
			<p>Welcome to the Android community! We're glad you're here and invite you to participate in these discussions. Before posting, please red the <a href="#">Groups Charter</a> that covers the community guidelines.</p>
			<p>To get the most out of this group, please do the following before you post:</p>
			<ol>
				<li><a href="{@docRoot}guide/appendix/faq/index.html">Read the FAQs</a> The most common questions 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><strong>Be very clear</strong> 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. Also <strong>give plenty of details</strong> in your post to help others understand your problem. Code or log snippets, as well as pointers to screenshots, may also be helpful.</li>
                        </ol>
			<p>For a great guide to phrasing your questions, please read: <a href="#">How to Ask Questions The Smart Way</a>.</p>

<h2>Subscribe to a Group</h2>
<p>You can subscribe to these groups in one of two ways:</p>
  <ul>
    <li>Follow the web access link (in the first column below) and then click "Join this group" on the right-side of the Groups page. If you'd rather read posts via email, sign in to Groups and click "edit my membership" on the right hand side. Select "email" under "How do you want to read this group?".</li>
    <li>Or simply subscribe via email by clicking the subscribe link (in the last column below).</li>
  </ul>

<h3 class="green">Available Groups</h3>
			<table class="groupTable">
				<tr>
					<th>Group - Web Access</th>
					<th>Description</th>
					<th>Subscribe by email</th>
				</tr>
				<tr class="oddRow">
					<td><a href="http://groups.google.com/group/android-beginners">android-beginners</a></td>
					<td>Discuss developing Android applications using the Android framework. Get help with troubleshooting apps, advice on implementation, and strategies for improving your app's speed and user experience.</td>
					<td><a href="mailto:android-beginners-subscribe@googlegroups.com">android-beginners-subscribe@googlegroups.com</a></td>
				</tr>
				<tr class="evenRow">
					<td><a href="http://groups.google.com/group/android-developers">android-developers</a></td>
					<td>New to ANdroid development? Start here. Open to any discussion around beginner-type questions; this is a great way to get up and running with your new App on the Android platform.</td>
					<td><a href="mailto:android-developers-subscribe@googlegroups.com">android-developers-subscribe@googlegroups.com</a></td>
				</tr>
				<tr class="oddRow">
					<td><a href="http://groups.google.com/group/android-discuss">android-discuss</a></td>
					<td>The "water cooler" of Android discussion. Free-wheeling discussion from ideas about the Android platform to your announcements on other Android resources.</td>
					<td><a href="mailto:android-discuss-subscribe@googlegroups.com">android-discuss-subscribe@googlegroups.com</a></td>
				</tr>
				<tr class="evenRow">
					<td><a href="http://groups.google.com/group/android-security-discuss">android-security-discuss</a></td>
					<td>A place for open discussion on secure development, emerging security concerns, and best practices for and by android developers.</td>
					<td><a href="mailto:android-security-discuss-subscribe@googlegroups.com">android-security-discuss-subscribe@googlegroups.com</a></td>
				</tr>
				<tr class="oddRow">
					<td><nobr><a href="http://groups.google.com/group/android-security-announce">android-security-announce</a></nobr></td>
					<td>A low-volume group for security-related announcements by the Android Security Team.</td>
					<td><a href="mailto:android-security-announce-subscribe@googlegroups.com">android-security-announce-subscribe@googlegroups.com</a></td>
				</tr>
			</table>
</div>