diff options
Diffstat (limited to 'docs')
34 files changed, 2174 insertions, 807 deletions
diff --git a/docs/html/guide/developing/device.jd b/docs/html/guide/developing/device.jd index 3127e10..cb5a0b6 100644 --- a/docs/html/guide/developing/device.jd +++ b/docs/html/guide/developing/device.jd @@ -145,6 +145,9 @@ USB device support on Linux. The USB Vendor ID is the value given to the <td>Kyocera</td> <td><code>0482</code></td></tr> <tr> + <td>Lenevo</td> + <td><code>17EF</code></td></tr> + <tr> <td>LG</td> <td><code>1004</code></td></tr> <tr> diff --git a/docs/html/guide/guide_toc.cs b/docs/html/guide/guide_toc.cs index 55d711f..3ec174e 100644 --- a/docs/html/guide/guide_toc.cs +++ b/docs/html/guide/guide_toc.cs @@ -222,7 +222,8 @@ <li><a href="<?cs var:toroot ?>guide/topics/manifest/receiver-element.html"><receiver></a></li> <li><a href="<?cs var:toroot ?>guide/topics/manifest/service-element.html"><service></a></li> <li><a href="<?cs var:toroot ?>guide/topics/manifest/supports-gl-texture-element.html"><supports-gl-texture></a></li> - <li><a href="<?cs var:toroot ?>guide/topics/manifest/supports-screens-element.html"><supports-screens></a></li> <!-- ##api level 4## --> + <li><a href="<?cs var:toroot ?>guide/topics/manifest/supports-screens-element.html"><supports-screens></a> + <span class="new">updated</span></li> <!-- ##api level 4## --> <li><a href="<?cs var:toroot ?>guide/topics/manifest/uses-configuration-element.html"><uses-configuration></a></li> <li><a href="<?cs var:toroot ?>guide/topics/manifest/uses-feature-element.html"><uses-feature></a></li> <!-- ##api level 4## --> <li><a href="<?cs var:toroot ?>guide/topics/manifest/uses-library-element.html"><uses-library></a></li> @@ -256,7 +257,7 @@ <div><a href="<?cs var:toroot ?>guide/topics/renderscript/index.html"> <span class="en">RenderScript</span> </a> - <span class="new-child">new!</span></div> + <span class="new">new!</span></div> <ul> <li><a href="<?cs var:toroot ?>guide/topics/renderscript/graphics.html"> <span class="en">3D Graphics</span> @@ -270,8 +271,8 @@ </li> <li><a href="<?cs var:toroot ?>guide/topics/media/index.html"> - <span class="en">Audio and Video</span> - </a></li> + <span class="en">Media</span> + </a><span class="new">updated</span></li> <li> <a href="<?cs var:toroot ?>guide/topics/clipboard/copy-paste.html"> <span class="en">Copy and Paste</span> @@ -302,11 +303,13 @@ </li> --> <!--<li><a style="color:gray;">Localization</a></li> --> <li><a href="<?cs var:toroot ?>guide/topics/appwidgets/index.html"> - <span class="en">App Widgets</span> - </a></li> + <span class="en">App Widgets</span></a> + <span class="new">updated</span> + </li> <li><a href="<?cs var:toroot?>guide/topics/wireless/bluetooth.html"> - <span class="en">Bluetooth</span> - </a></li> + <span class="en">Bluetooth</span></a> + <span class="new">updated</span> + </li> <li><a href="<?cs var:toroot?>guide/topics/nfc/index.html"> <span class="en">Near Field Communication</span> </a></li> @@ -337,8 +340,8 @@ </ul> </li> <li><a href="<?cs var:toroot?>guide/topics/admin/device-admin.html"> - <span class="en">Device Administration</span> - </a> + <span class="en">Device Administration</span></a> + <span class="new">updated</span> </li> <li class="toggle-list"> <div> diff --git a/docs/html/guide/publishing/publishing.jd b/docs/html/guide/publishing/publishing.jd index 0cbba53..95d89fa 100644 --- a/docs/html/guide/publishing/publishing.jd +++ b/docs/html/guide/publishing/publishing.jd @@ -23,6 +23,7 @@ page.title=Publishing on Android Market <ol> <li><a href="#OpeningDetails">Opening an app's details page</a></li> <li><a href="#PerformingSearch">Performing a search</a></li> + <li><a href="#BuildaButton">Build an Android Market button</a></li> <li><a href="#UriSummary">Summary of URI formats</a></li> </ol> </li> @@ -317,6 +318,205 @@ publisher name:</p> +<h3 id="BuildaButton">Build an Android Market button</h3> + +<p>Use the following form to input either your application's package name or your publisher name +and generate a button that you can use on your web site. The button will take users to Android +Market to view your application details or view a list of all applications you've published.</p> + +<p>This form offers four versions of the official "Available in Android Market" badge at +recommended sizes. If you would like to create a different size, you can download an EPS file for +the badges from the <a href="http://www.android.com/branding.html">Android Brand Guidelines</a>.</p> + +<style type="text/css"> + +form.button-form { + margin-top:2em; +} + +/* the label and input elements are blocks that float left in order to + keep the left edgets of the input aligned, and IE 6/7 do not fully support "inline-block" */ +label.block { + display: block; + float: left; + width: 100px; + padding-right: 10px; +} + +input.text { + display: block; + float: left; + width: 250px; +} + +div.button-row { + white-space:nowrap; + min-height:80px; +} + +div.button-row input { + vertical-align:120%; +} + +#jd-content div.button-row img { + margin: 0; +} + +</style> + +<script type="text/javascript"> + +// variables for creating 'try it out' demo button +var imagePath = "http://www.android.com/images/brand/" +var linkStart = "<a href=\"http://market.android.com/"; +var imageStart = "\">\n" + + " <img src=\"" + imagePath; +var imageEnd = ".png\"\n" + + " alt=\"Available in Android Market\" />\n</a>"; + +// variables for creating code snippet +var linkStartCode = "<a href=\"http://market.android.com/"; +var imageStartCode = "\">\n" + + " <img src=\"" + imagePath; +var imageEndCode = ".png\"\n" + + " alt=\"Available in Android Market\" />\n</a>"; + +/** Generate the HTML snippet and demo based on form values */ +function buildButton(form) { + if (form["package"].value != "com.android.example") { + $("#preview").show(); + $("#snippet").show().html(linkStartCode + "details?id=" + form["package"].value + + imageStartCode + $('form input[type=radio]:checked').val() + imageEndCode); + $("#button-preview").html(linkStart + "details?id=" + form["package"].value + + imageStart + $('form input[type=radio]:checked').val() + imageEnd); + } else if (form["publisher"].value != "Example, Inc.") { + $("#preview").show(); + $("#snippet").show().html(linkStartCode + "search?q=pub:" + form["publisher"].value + + imageStartCode + $('form input[type=radio]:checked').val() + imageEndCode); + $("#button-preview").html(linkStart + "search?q=pub:" + form["publisher"].value + imageStart + + $('form input[type=radio]:checked').val() + imageEnd); + } else { + alert("Please enter your package name or publisher name"); + } + return false; +} + +/** Listen for Enter key */ +function onTextEntered(event, form, me) { + // 13 = enter + if (event.keyCode == 13) { + buildButton(form); + } +} + +/** When input is focused, remove example text and disable other input */ +function onInputFocus(object, example) { + if (object.value == example) { + $(object).val('').css({'color' : '#000'}); + } + $('input[type="text"]:not(input[name='+object.name+'])', + object.parentNode).attr('disabled','true'); + $('#'+object.name+'-clear').show(); +} + +/** When input is blured, restore example text if appropriate and enable other input */ +function onInputBlur(object, example) { + if (object.value.length < 1) { + $(object).attr('value',example).css({'color':'#ccc'}); + $('input[type="text"]', object.parentNode).removeAttr('disabled'); + $('#'+object.name+'-clear').hide(); + } +} + +/** Clear the form to start over */ +function clearLabel(id, example) { + $("#preview").hide(); + $('#'+id+'').html('').attr('value',example).css({'color':'#ccc'}); + $('input[type="text"]', $('#'+id+'').parent()).removeAttr('disabled'); + $('#'+id+'-clear').hide(); + return false; +} + +/** When the doc is ready, find the inputs and color the input grey if the value is the example + text. This is necessary to handle back-navigation, which can auto-fill the form with previous + values (and text should not be grey) */ +$(document).ready(function() { + $(".button-form input.text").each(function(index) { + if ($(this).val() == $(this).attr("default")) { + $(this).css("color","#ccc"); + } else { + /* This is necessary to handle back-navigation to the page after form was filled */ + $('input[type="text"]:not(input[name='+this.name+'])', + this.parentNode).attr('disabled','true'); + $('#'+this.name+'-clear').show(); + } + }); +}); + +</script> + +<form class="button-form"> + <label class="block" for="package">Package name:</label> + <input class="text" type="text" id="package" name="package" + value="com.android.example" + default="com.android.example" + onfocus="onInputFocus(this, 'com.android.example')" + onblur="onInputBlur(this, 'com.android.example')" + onkeyup="return onTextEntered(event, this.parentNode, this)"/> + <a id="package-clear" style="display:none" href="#" + onclick="return clearLabel('package','com.android.example');">clear</a> + <p style="clear:both;margin:0"> <em>or</em></p> + <label class="block" style="margin-top:5px" for="publisher">Publisher name:</label> + <input class="text" type="text" id="publisher" name="publisher" + value="Example, Inc." + default="Example, Inc." + onfocus="onInputFocus(this, 'Example, Inc.')" + onblur="onInputBlur(this, 'Example, Inc.')" + onkeyup="return onTextEntered(event, this.parentNode, this)"/> + <a id="publisher-clear" style="display:none" href="#" + onclick="return clearLabel('publisher','Example, Inc.');">clear</a> + <br/><br/> + +<div class="button-row"> + <input type="radio" name="buttonStyle" value="45_avail_market_logo1" id="ns" checked="checked" /> + <label for="ns"><img src="http://www.android.com/images/brand/45_avail_market_logo1.png" +alt="narrow and small logo" /></label> + + <input type="radio" name="buttonStyle" value="60_avail_market_logo1" id="nm" /> + <label for="nm"><img src="http://www.android.com/images/brand/60_avail_market_logo1.png" +alt="narrow and large logo" /></label> +</div> + +<div class="button-row"> + <input type="radio" name="buttonStyle" value="45_avail_market_logo2" id="ws" /> + <label for="ws"><img src="http://www.android.com/images/brand/45_avail_market_logo2.png" +alt="wide and small logo" /></label> + + <input type="radio" name="buttonStyle" value="60_avail_market_logo2" id="wm" /> + <label for="wm"><img src="http://www.android.com/images/brand/60_avail_market_logo2.png" +alt="wide and large logo" /></label> +</div> + + <input type="button" onclick="return buildButton(this.parentNode)" value="Build my button" +style="padding:5px" /> + <br/> +</form> + +<div id="preview" style="display:none"> + <p>Copy and paste this HTML into your web site:</p> + <textarea id="snippet" cols="80" rows="4" onclick="this.select()" +style="font-family:monospace;background-color:#efefef;padding:5px;display:none;margin-bottom:1em"> + </textarea > + +<p>Try it out:</p> +<div id="button-preview" style="margin-top:1em"></div> +</div> + + + + + + <h3 id="UriSummary">Summary of URI formats</h3> <p>The table below provides a summary of the URIs currently supported by the Android Market (both on diff --git a/docs/html/guide/topics/appwidgets/index.jd b/docs/html/guide/topics/appwidgets/index.jd index e589292..78b5b51 100644 --- a/docs/html/guide/topics/appwidgets/index.jd +++ b/docs/html/guide/topics/appwidgets/index.jd @@ -213,7 +213,7 @@ dp and for a width of four cells.</p> <p class="note"><strong>Note:</strong> To make your app widget portable across devices, your app widget's minimum size should never be larger than 4 x 4 cells. See the <a -href="{@docRoot}guide/practices/ui_guidelines/widget_design.htmll#sizes">App +href="{@docRoot}guide/practices/ui_guidelines/widget_design.html#sizes">App Widget Design Guidelines</a> for more discussion of Home screen cell sizes.</p> </li> <li>The <code>updatePeriodMillis</code> attribute defines how often the App diff --git a/docs/html/guide/topics/fundamentals/activities.jd b/docs/html/guide/topics/fundamentals/activities.jd index 5cc1b45..cb453da 100644 --- a/docs/html/guide/topics/fundamentals/activities.jd +++ b/docs/html/guide/topics/fundamentals/activities.jd @@ -145,7 +145,7 @@ href="{@docRoot}guide/topics/ui/index.html">User Interface</a> documentation.</p <h3 id="Declaring">Declaring the activity in the manifest</h3> <p>You must declare your activity in the manifest file in order for it to -be accessible to the system. To decalare your activity, open your manifest file and add an <a +be accessible to the system. To declare your activity, open your manifest file and add an <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element as a child of the <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a> @@ -163,9 +163,16 @@ element. For example:</p> <p>There are several other attributes that you can include in this element, to define properties such as the label for the activity, an icon for the activity, or a theme to style the activity's -UI. See the <a +UI. The <a href="{@docRoot}guide/topics/manifest/activity-element.html#nm">{@code android:name}</a> +attribute is the only required attribute—it specifies the class name of the activity. Once +you publish your application, you should not change this name, because if you do, you might break +some functionality, such as application shortcuts (read the blog post, <a +href="http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html">Things +That Cannot Change</a>).</p> + +<p>See the <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code <activity>}</a> element -reference for more information about available attributes.</p> +reference for more information about declaring your activity in the manifest.</p> <h4>Using intent filters</h4> diff --git a/docs/html/guide/topics/fundamentals/services.jd b/docs/html/guide/topics/fundamentals/services.jd index 468a417..9c38897 100644 --- a/docs/html/guide/topics/fundamentals/services.jd +++ b/docs/html/guide/topics/fundamentals/services.jd @@ -203,7 +203,7 @@ it from other application components.</p> <p>Like activities (and other components), you must declare all services in your application's manifest file.</p> -<p>To decalare your service, add a <a +<p>To declare your service, add a <a href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> element as a child of the <a href="{@docRoot}guide/topics/manifest/application-element.html">{@code <application>}</a> @@ -222,9 +222,17 @@ element. For example:</p> <p>There are other attributes you can include in the <a href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> element to define properties such as permissions required to start the service and the process in -which the service should run. See the <a +which the service should run. The <a +href="{@docRoot}guide/topics/manifest/service-element.html#nm">{@code android:name}</a> +attribute is the only required attribute—it specifies the class name of the service. Once +you publish your application, you should not change this name, because if you do, you might break +some functionality where explicit intents are used to reference your service (read the blog post, <a +href="http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html">Things +That Cannot Change</a>). + +<p>See the <a href="{@docRoot}guide/topics/manifest/service-element.html">{@code <service>}</a> element -reference for more information.</p> +reference for more information about declaring your service in the manifest.</p> <p>Just like an activity, a service can define intent filters that allow other components to invoke the service using implicit intents. By declaring intent filters, components @@ -670,7 +678,7 @@ foreground service must provide a notification for the status bar, which is plac either stopped or removed from the foreground.</p> <p>For example, a music player that plays music from a service should be set to run in the -foreground, because the user it explicitly aware +foreground, because the user is explicitly aware of its operation. The notification in the status bar might indicate the current song and allow the user to launch an activity to interact with the music player.</p> diff --git a/docs/html/guide/topics/graphics/index.jd b/docs/html/guide/topics/graphics/index.jd index be1b0fc..2490e39 100644 --- a/docs/html/guide/topics/graphics/index.jd +++ b/docs/html/guide/topics/graphics/index.jd @@ -14,13 +14,20 @@ page.title=Graphics </ol> </li> </ol> + <h2>See also</h2> + <ol> + <li><a href="{@docRoot}guide/topics/graphics/opengl.html">3D with OpenGL</a></li> + <li><a href="{@docRoot}guide/topics/renderscript/index.html">RenderScript</a></li> + </ol> </div> </div> -<p>Android graphics are powered by a custom 2D graphics library and OpenGL ES 1.0 -for high performance 3D graphics. The most common 2D graphics APIs can be found in the -{@link android.graphics.drawable drawable package}. OpenGL APIs are available -from the Khronos {@link javax.microedition.khronos.opengles OpenGL ES package}, -plus some Android {@link android.opengl OpenGL utilities}.</p> + +<p>Android graphics are powered by a custom 2D graphics library, and the framework provides +support for high performance 3D graphics in the form of OpenGL ES and RenderScript. The most +common 2D graphics APIs can be found in the {@link android.graphics.drawable drawable package}. +OpenGL APIs are available from the Khronos {@link javax.microedition.khronos.opengles OpenGL ES} and +the {@link android.opengl} packages. The RenderScript APIs are available in the +{@link android.renderscript} package.</p> <p>When starting a project, it's important to consider exactly what your graphical demands will be. Varying graphical tasks are best accomplished with varying techniques. For example, graphics and animations @@ -32,10 +39,10 @@ and which tasks they're best suited for.</p> <p>If you're specifically looking for information on drawing 3D graphics, this page won't help a lot. However, the information below about how to <a href="#draw-with-canvas">Draw with a -Canvas</a> (and the section on SurfaceView), -will give you a quick idea of how you should draw to the View hierarchy. For more information -on Android's 3D graphic utilities (provided by the OpenGL ES API), -read <a href="opengl.html">3D with OpenGL</a> and refer to other OpenGL documentation.</p> +Canvas</a> (and the section on SurfaceView), will give you a quick idea of how you should draw to +the View hierarchy. For more information on Android's 3D graphics APIs, see +the <a href="opengl.html">3D with OpenGL</a> and +<a href="{@docRoot}guide/topics/renderscript/index.html">RenderScript</a> documents.</p> <h2 id="options">Consider your Options</h2> diff --git a/docs/html/guide/topics/graphics/opengl.jd b/docs/html/guide/topics/graphics/opengl.jd index 9f88954..cc467f2 100644 --- a/docs/html/guide/topics/graphics/opengl.jd +++ b/docs/html/guide/topics/graphics/opengl.jd @@ -3,51 +3,215 @@ parent.title=Graphics parent.link=index.html @jd:body +<div id="qv-wrapper"> + <div id="qv"> + <h2>In this document</h2> + + <ol> + <li><a href="#basics">The Basics</a></li> + <li><a href="#compatibility">OpenGL Versions and Device Compatibility</a> + <ol> + <li><a href="#textures">Texture Compression Support</a></li> + <li><a href="#declare-compression">Declaring Use of Compressed Textures</a></li> + </ol> + </li> + </ol> + <h2>Key classes</h2> + <ol> + <li>{@link android.opengl.GLSurfaceView}</li> + <li>{@link android.opengl.GLSurfaceView.Renderer}</li> + <li>{@link javax.microedition.khronos.opengles}</li> + <li>{@link android.opengl}</li> + </ol> + <h2>Related Samples</h2> + <ol> + <li><a href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/graphics/ +GLSurfaceViewActivity.html">GLSurfaceViewActivity</a></li> + <li><a href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/graphics/ +GLES20Activity.html">GLES20Activity</a></li> + <li><a href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/graphics/ +TouchRotateActivity.html">TouchRotateActivity</a></li> + <li><a href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/graphics/ +CompressedTextureActivity.html">Compressed Textures</a></li> + </ol> + <h2>See also</h2> + <ol> + <li><a href="{@docRoot}resources/articles/glsurfaceview.html">Introducing +GLSurfaceView</a></li> + <li><a href="http://www.khronos.org/opengles/">OpenGL ES</a></li> + <li><a href="http://www.khronos.org/opengles/1_X/">OpenGL ES 1.x Specification</a></li> + <li><a href="http://www.khronos.org/opengles/2_X/">OpenGL ES 2.x specification</a></li> + </ol> + </div> +</div> -<p>Android includes support for high performance 3D graphics -via the OpenGL API—specifically, the OpenGL ES API.</p> +<p>Android includes support for high performance 2D and 3D graphics with the Open Graphics Library +(OpenGL) API—specifically, the OpenGL ES API. OpenGL is a cross-platform graphics API that +specifies a standard software interface for 3D graphics processing hardware. OpenGL ES is a flavor +of the OpenGL specification intended for embedded devices. The OpenGL ES 1.0 and 1.1 API +specifications have been supported since Android 1.0. Beginning with Android 2.2 (API +Level 8), the framework supports the OpenGL ES 2.0 API specification.</p> -<p>OpenGL ES is a flavor of the OpenGL specification intended for embedded devices. Versions of <a -href="http://www.khronos.org/opengles/">OpenGL ES</a> are loosely peered to versions of the primary -OpenGL standard. Beginning with Android 2.2, the platform supports OpenGL ES 2.0 (with -backward compatibility support for OpenGL ES 1.1). For information about the relative number of -Android-powered devices that support a given version of OpenGL ES, see the <a -href="http://developer.android.com/resources/dashboard/opengl.html">OpenGL ES Versions</a> -dashboard.</p> +<p class="note"><b>Note:</b> The specific API provided by the Android framework is similar to the + J2ME JSR239 OpenGL ES API, but is not identical. If you are familiar with J2ME JSR239 + specification, be alert for variations.</p> -<p>The specific API provided by Android is similar to the J2ME JSR239 OpenGL -ES API. However, it may not be identical, so watch out for deviations.</p> -<h2>Using the API</h2> +<h2 id="basics">The Basics</h2> -<p>Here's how to use the API at an extremely high level:</p> +<p>Android supports OpenGL both through its framework API and the Native Development +Kit (NDK). This topic focuses on the Android framework interfaces. For more information about the +NDK, see the <a href="{@docRoot}sdk/ndk/index.html">Android NDK</a>. -<ol> -<li>Write a custom {@link android.view.View} subclass.</li> -<li>Obtain a handle to an OpenGLContext, which provides access to the OpenGL functionality.</li> -<li>In your View's {@link android.view.View#onDraw onDraw()} method, get a handle to a GL object, -and use its methods to perform GL operations.</li> -</ol> +<p> + There are two foundational classes in the Android framework that let you create and manipulate +graphics with the OpenGL ES API: {@link android.opengl.GLSurfaceView} and {@link +android.opengl.GLSurfaceView.Renderer}. If your goal is to use OpenGL in your Android application, +understanding how to implement these classes in an activity should be your first objective. +</p> + +<dl> + <dt>{@link android.opengl.GLSurfaceView}</dt> + <dd>This class is a container on which you can draw and manipulate objects using OpenGL API calls. + This class is similar in function to a {@link android.view.SurfaceView}, except that it is + specifically for use with OpenGL. You can use this class by simply creating an instance of + {@link android.opengl.GLSurfaceView} and adding your + {@link android.opengl.GLSurfaceView.Renderer Renderer} to it. However, if you want to capture + touch screen events, you should extend the {@link android.opengl.GLSurfaceView} class to + implement the touch listeners, as shown in the <a +href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/graphics/TouchRotateActivity +.html">TouchRotateActivity</a> sample.</dd> + + <dt>{@link android.opengl.GLSurfaceView.Renderer}</dt> + <dd>This interface defines the methods required for drawing graphics in an OpenGL {@link + android.opengl.GLSurfaceView}. You must provide an implementation of this interface as a + separate class and attach it to your {@link android.opengl.GLSurfaceView} instance using + {@link android.opengl.GLSurfaceView#setRenderer(android.opengl.GLSurfaceView.Renderer) + GLSurfaceView.setRenderer()}. + + <p>The {@link android.opengl.GLSurfaceView.Renderer} interface requires that you implement the + following methods:</p> + <ul> + <li> + {@link + android.opengl.GLSurfaceView.Renderer#onSurfaceCreated(javax.microedition.khronos.opengles.GL10, + javax.microedition.khronos.egl.EGLConfig) onSurfaceCreated()}: The system calls this + method once, when creating the {@link android.opengl.GLSurfaceView}. Use this method to perform + actions that need to happen only once, such as setting OpenGL environment parameters or + initializing OpenGL graphic objects. + </li> + <li> + {@link + android.opengl.GLSurfaceView.Renderer#onDrawFrame(javax.microedition.khronos.opengles.GL10) + onDrawFrame()}: The system calls this method on each redraw of the {@link + android.opengl.GLSurfaceView}. Use this method as the primary execution point for + drawing (and re-drawing) graphic objects.</li> + <li> + {@link + android.opengl.GLSurfaceView.Renderer#onSurfaceChanged(javax.microedition.khronos.opengles.GL10, + int, int) onSurfaceChanged()}: The system calls this method when the {@link + android.opengl.GLSurfaceView} geometry changes, including changes in size of the {@link + android.opengl.GLSurfaceView} or orientation of the device screen. For example, the system calls + this method when the device changes from portrait to landscape orientation. Use this method to + respond to changes in the {@link android.opengl.GLSurfaceView} container. + </li> + </ul> + </dd> +</dl> + +<p>Once you have established a container view for OpenGL using {@link +android.opengl.GLSurfaceView} and {@link android.opengl.GLSurfaceView.Renderer}, you can begin +calling OpenGL APIs using the following classes:</p> + +<ul> + <li>OpenGL ES 1.0/1.1 API Packages + <ul> + <li>{@link javax.microedition.khronos.opengles} - This package provides the standard +implementation of OpenGL ES 1.0 and 1.1. + <ul> + <li>{@link javax.microedition.khronos.opengles.GL10}</li> + <li>{@link javax.microedition.khronos.opengles.GL10Ext}</li> + <li>{@link javax.microedition.khronos.opengles.GL11}</li> + <li>{@link javax.microedition.khronos.opengles.GL11Ext}</li> + <li>{@link javax.microedition.khronos.opengles.GL11ExtensionPack}</li> + </ul> + </li> + <li>{@link android.opengl} - This package provides a static interface to the OpenGL classes + above. These interfaces were added with Android 1.6 (API Level 4). + <ul> + <li>{@link android.opengl.GLES10}</li> + <li>{@link android.opengl.GLES10Ext}</li> + <li>{@link android.opengl.GLES11}</li> + <li>{@link android.opengl.GLES10Ext}</li> + </ul> + </li> + </ul> + </li> + <li>OpenGL ES 2.0 API Class + <ul> + <li>{@link android.opengl.GLES20 android.opengl.GLES20}</li> + </ul> + </li> +</ul> -<p>Several samples using OpenGL ES are available in the <a -href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/graphics/index.html">API -Demos</a> sample application. +<h2 id="compatibility">OpenGL Versions and Device Compatibility</h2> + +<p> + The OpenGL ES 1.0 and 1.1 API specifications have been supported since Android 1.0. +Beginning with Android 2.2 (API Level 8), the framework supports the OpenGL ES 2.0 API +specification. OpenGL ES 2.0 is supported by most Android devices and is recommended for new +applications being developed with OpenGL. For information about the relative number of +Android-powered devices that support a given version of OpenGL ES, see the <a +href="{@docRoot}resources/dashboard/opengl.html">OpenGL ES Versions Dashboard</a>.</p> + +<h3 id="textures">Texture compression support</h3> +<p>Texture compression can significantly increase the performance of your OpenGL application by +reducing memory requirements and making more efficient use of memory bandwidth. The Android +framework provides support for the ETC1 compression format as a standard feature, including a {@link +android.opengl.ETC1Util} utility class and the {@code etc1tool} compression tool (located in your +Android SDK at {@code <sdk>/tools/}).</p> + +<p>For an example of an Android application that uses texture compression, see the <a +href="{@docRoot}resources/samples/ApiDemos/src/com/example/android/apis/graphics/ +CompressedTextureActivity.html">CompressedTextureActivity</a> code sample. </p> -<p>A summary of how to actually write 3D applications using OpenGL is -beyond the scope of this text and is left as an exercise for the reader.</p> +<p>To check if the ETC1 format is supported on a device, call the {@link +android.opengl.ETC1Util#isETC1Supported() ETC1Util.isETC1Supported()} method.</p> -<h2>Links to Additional Information</h2> +<p class="note"><b>Note:</b> The ETC1 texture compression format does not support textures with an +alpha channel. If your application requires textures with an alpha channel, you should +investigate other texture compression formats available on your target devices.</p> -<p>Information about OpenGL ES can be -found at <a title="http://www.khronos.org/opengles/" -href="http://www.khronos.org/opengles/">http://www.khronos.org/opengles/</a>.</p> +<p>Beyond the ETC1 format, Android devices have varied support for texture compression based on +their GPU chipsets. You should investigate texture compression support on the the devices you are +are targeting to determine what compression types your application should support.</p> -<p>Information specifically -about OpenGL ES 1.0 (including a detailed specification) can be found -at <a title="http://www.khronos.org/opengles/1_X/" -href="http://www.khronos.org/opengles/1_X/">http://www.khronos.org/opengles/1_X/</a>.</p> +<p>To determine if texture compression formats other than ETC1 are supported on a particular +device:</p> +<ol> + <li>Run the following code on your target devices to determine what texture compression +formats are supported: +<pre> + String extensions = javax.microedition.khronos.opengles.GL10.glGetString(GL10.GL_EXTENSIONS); +</pre> + <p class="warning"><b>Warning:</b> The results of this call vary by device! You must run this +call on several target devices to determine what compression types are commonly supported on +your target devices.</p> + </li> + <li>Review the output of this method to determine what extensions are supported on the +device.</li> +</ol> -<p>The documentation for the Android OpenGL ES implementations are available in {@link -android.opengl} and {@link javax.microedition.khronos.opengles}.</p> +<h3 id="declare-compression">Declaring compressed textures</h3> +<p>Once you have decided which texture compression types your application will support, you +must declare them in your manifest file using <a +href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html"> +<supports-gl-texture></a>. Declaring this information in your manifest file hides your +application from users with devices that do not support at least one of your declared +compression types. For more information on how Android Market filtering works for texture +compressions, see the <a +href="{@docRoot}guide/topics/manifest/supports-gl-texture-element.html#market-texture-filtering"> +Android Market and texture compression filtering</a> section of the {@code +<supports-gl-texture>} documentation. diff --git a/docs/html/guide/topics/manifest/activity-element.jd b/docs/html/guide/topics/manifest/activity-element.jd index c910686..3486212 100644 --- a/docs/html/guide/topics/manifest/activity-element.jd +++ b/docs/html/guide/topics/manifest/activity-element.jd @@ -507,6 +507,10 @@ However, as a shorthand, if the first character of the name is a period package name specified in the <code><a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a></code> element. +<p>Once you publish your application, you <a +href="http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html">should not +change this name</a> (unless you've set <code><a +href="#exported">android:exported</a>="false"</code>).</p> <p> There is no default. The name must be specified. diff --git a/docs/html/guide/topics/manifest/manifest-element.jd b/docs/html/guide/topics/manifest/manifest-element.jd index 598e88f..d737a67 100644 --- a/docs/html/guide/topics/manifest/manifest-element.jd +++ b/docs/html/guide/topics/manifest/manifest-element.jd @@ -47,12 +47,15 @@ and specify {@code xlmns:android} and {@code package} attributes.</dd> to "{@code http://schemas.android.com/apk/res/android}".</dd> <dt><a name="package"></a>{@code package}</dt> -<dd>A full Java package name for the application. The name should +<dd>A full Java-language-style package name for the application. The name should be unique. The name may contain uppercase or lowercase letters ('A' through 'Z'), numbers, and underscores ('_'). However, individual -package name parts may only start with letters. For example, applications -published by Google could have names in the form -<code>com.google.app.<i>application_name</i></code>. +package name parts may only start with letters. + +<p>To avoid conflicts with other developers, you should use Internet domain ownership as the +basis for your package names (in reverse). For example, applications published by Google start with +<code>com.google</code>. You should also never use the <code>com.example</code> namespace when +publishing your applications.</p> <p> The package name serves as a unique identifier for the application. @@ -66,6 +69,12 @@ published by Google could have names in the form element's <code><a href="{@docRoot}guide/topics/manifest/activity-element.html#aff">taskAffinity</a></code> attribute). </p> + + <p class="caution"><strong>Caution:</strong> Once you publish your application, you +<strong>cannot change the package name</strong>. The package name defines your application's +identity, so if you change it, then it is considered to be a different application and users of +the previous version cannot update to the new version.</p> + </dd> <dt><a name="uid"></a>{@code android:sharedUserId}</dt> diff --git a/docs/html/guide/topics/manifest/receiver-element.jd b/docs/html/guide/topics/manifest/receiver-element.jd index 7012c0f..8416c0c 100644 --- a/docs/html/guide/topics/manifest/receiver-element.jd +++ b/docs/html/guide/topics/manifest/receiver-element.jd @@ -122,6 +122,11 @@ as a shorthand, if the first character of the name is a period (for example, "{@code . ReportReceiver}"), it is appended to the package name specified in the <code><a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a></code> element. +<p>Once you publish your application, you <a +href="http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html">should not +change this name</a> (unless you've set <code><a +href="#exported">android:exported</a>="false"</code>).</p> + <p> There is no default. The name must be specified. </p></dd> diff --git a/docs/html/guide/topics/manifest/service-element.jd b/docs/html/guide/topics/manifest/service-element.jd index d9a81b3..82d1f6a 100644 --- a/docs/html/guide/topics/manifest/service-element.jd +++ b/docs/html/guide/topics/manifest/service-element.jd @@ -6,7 +6,7 @@ parent.link=manifest-intro.html <dl class="xml"> <dt>syntax:</dt> <dd><pre class="stx"><service android:<a href="#enabled">enabled</a>=["true" | "false"] - android:<a href="#exported">exported[</a>="true" | "false"] + android:<a href="#exported">exported</a>=["true" | "false"] android:<a href="#icon">icon</a>="<i>drawable resource</i>" android:<a href="#label">label</a>="<i>string resource</i>" android:<a href="#nm">name</a>="<i>string</i>" @@ -121,6 +121,11 @@ the first character of the name is a period (for example, "{@code .RoomService}" it is appended to the package name specified in the <code><a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a></code> element. +<p>Once you publish your application, you <a +href="http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html">should not +change this name</a> (unless you've set <code><a +href="#exported">android:exported</a>="false"</code>).</p> + <p> There is no default. The name must be specified. </p></dd> diff --git a/docs/html/guide/topics/manifest/supports-screens-element.jd b/docs/html/guide/topics/manifest/supports-screens-element.jd index ee99a37..605a2bb 100644 --- a/docs/html/guide/topics/manifest/supports-screens-element.jd +++ b/docs/html/guide/topics/manifest/supports-screens-element.jd @@ -8,12 +8,15 @@ parent.link=manifest-intro.html <dt>syntax:</dt> <dd> <pre class="stx"> -<supports-screens android:<a href="#resizeable">resizeable</a>=["true" | "false"] - android:<a href="#small">smallScreens</a>=["true" | "false"] - android:<a href="#normal">normalScreens</a>=["true" | "false"] - android:<a href="#large">largeScreens</a>=["true" | "false"] +<supports-screens android:<a href="#requiresSmallest">requiresSmallestWidthDp</a>="<em>integer</em>" + android:<a href="#compatibleWidth">compatibleWidthLimitDp</a>="<em>integer</em>" + android:<a href="#largestWidth">largestWidthLimitDp</a>="<em>integer</em>" + android:<a href="#resizeable">resizeable</a>=["true"| "false"] + android:<a href="#small">smallScreens</a>=["true" | "false"] + android:<a href="#normal">normalScreens</a>=["true" | "false"] + android:<a href="#large">largeScreens</a>=["true" | "false"] android:<a href="#xlarge">xlargeScreens</a>=["true" | "false"] - android:<a href="#any">anyDensity</a>=["true" | "false"] /> + android:<a href="#any">anyDensity</a>=["true" | "false"] /> </pre> </dd> @@ -21,36 +24,37 @@ parent.link=manifest-intro.html <dd><code><a href="{@docRoot}guide/topics/manifest/manifest-element.html"><manifest></a></code></dd> <dt>description:</dt> -<dd>Lets you specify the screen dimensions the -application supports. By default, a modern application (using API Level 4 or higher) supports all -screen sizes; older applications are assumed to support only the "normal" screen size. Screen -size is determined as the available pixels to an application after density scaling has been -applied. (Note that screen size is a separate axis from screen density.) - -<p>An application "supports" a given screen size if it fills the entire screen and works as -expected. By default, the system will resize your application to fill the screen, if you have set +<dd>Lets you specify the screen sizes your application supports and enable screen +compatibility mode for screens larger than what your application supports. By default, a modern +application (using API Level 4 or higher) supports all screen sizes; older applications are assumed +to support only the "normal" screen size. Screen size is determined by the number of pixels on the +screen after the system accounts for screen density scaling. + +<p>An application "supports" a given screen size if it resizes properly to fill the entire screen. +By default, the system resizes your application UI to fill the screen if you have set either <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code minSdkVersion}</a> or <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code -targetSdkVersion}</a> to {@code "4"} or higher. Resizing works well for most applications and -you don't have to do any extra work to make your application work on larger screens.</p> +targetSdkVersion}</a> to {@code "4"} or higher. Normal resizing works well for most applications and +you don't have to do any extra work to make your application work on screens larger than a +handset device.</p> -<p>In addition to allowing the system to resize your application, you can add additional support -for different screen sizes by providing <a +<p>In addition to allowing the system to resize your application to fit the current screen, you can +optimize your UI for different screen sizes by providing <a href="{@docRoot}guide/topics/resources/providing-resources.html#AlternativeResources">alternative layout resources</a> for different sizes. For instance, you might want to modify the layout of an activity when it is on a tablet or similar device that has an <em>xlarge</em> screen.</p> -<p>If your application does not support <em>large</em> or <em>xlarge</em> screens, then you should -declare that it is not resizeable by setting <a href="#resizeable">{@code android:resizeable}</a> to -{@code "false"}, so that the system will not resize your application on larger screens.</p> - -<p>If your application does not support <em>small</em> screens, then -there isn't much the system can do to make the application work well on a smaller screen, so -external services (such as Android Market) should not allow users to install the application on such -screens.</p> - - -<p>For more information, see +<p>However, if your application does not work well when resized to fit different screen sizes, +you can use the attributes of the {@code <supports-screens>} element to control whether +your application should be distributed to smaller screens or have its UI scaled up to fit larger +screens using the system's screen compatibility mode. When you have not designed for larger screen +sizes and the normal resizing does not achieve the appropriate results, <em>screen compatibility +mode</em> will scale your UI by emulating a <em>normal</em> size screen and then zooming in on it so +that it fills the entire screen—thus achieving the same layout as a normal handset device on +the large screen (but this usually causes pixelation and blurring of your UI).</p> + +<p>For more information about how to properly support different screen sizes so that you can avoid +using screen compatibility mode, read <a href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple Screens</a>.</p> @@ -59,6 +63,74 @@ screens.</p> <dd> <dl class="attr"> + <dt id="requiresSmallest">{@code android:requiresSmallestWidthDp}</dt> + <dd>This attribute specifies the minimum "smallest screen width" with which your +application is compatible. In order for a device to be considered compatible with your +application, the shortest side of the available screen space must be equal to or greater than this +value. +<p>The width against which your value is compared takes into account screen decorations and system +UI. For example, if the device has some persistent UI elements on the left or right edge of the +display, the system declares the device's available width as one that is smaller than the actual +screen size, accounting for these UI elements because those are screen pixels not available for your +UI. Thus, the value you use should be the actual smallest width required by your layout.</p> +<p>If your application properly resizes for smaller screen sizes (down to the +<em>small</em> size or a minimum width of 320dp), you do +not need to use this attribute. Otherwise, you should use a value for this attribute that +matches the smallest value used by your application for the <a +href="{@docRoot}guide/topics/resources/providing-resources.html#SmallestScreenWidthQualifier"> +smallest screen width qualifier</a> ({@code sw<N>dp}).</p> + +<p>For example, a typical handset screen has a minimum width of 320dp, a 7" tablet has a minimum +width of 600dp, and a 10" tablet has a minimum width of 720dp. If the smallest available screen +width on a device is less than the value you supply here, then the application is considered +incompatible with that +device. External services such as Android Market use this to determine whether a device +is compatible with your application and prevent incompatible devices from installing it.</p> +<p>Beginning with Android 3.2 (API level 13), using this attribute is the preferred way to +specify the minimum screen size your application requires, instead of using the other attributes +for small, normal, large, and xlarge screens. The advantage of using this attribute is that you +have more control over exactly how much screen space your application needs at a minimum in order +to properly display its UI, rather than relying on the generalized size groups.</p> +<p>This attribute has no default value. If this attribute is not specified, then any of the old +<code><a href="#small">smallScreens</a></code>, <code><a href="#normal">normalScreens</a></code>, +<code><a href="#large">largeScreens</a></code>, or <code><a href="#xlarge">xlargeScreens</a></code> +attributes are used instead to determine the smallest screen required.</p> + <p>This attribute was introduced in API level 13.</p> + </dd> + + <dt id="compatibleWidth">{@code android:compatibleWidthLimitDp}</dt> + <dd>This attribute allows you to enable screen compatibility mode as a user-optional feature by +specifying the maximum "smallest screen width" for which your application is designed. If the value +you supply here is less than the shortest side of the available screen space, users can still +install your application, but are offered to run it in screen compatibility mode. By default, screen +compatibility mode is disabled and your layout is resized to fit the screen as usual, but a +button is available in the system bar that allows the user to toggle screen compatibility mode on +and off. + <p>If your application is compatible with all screen sizes and its layout properly resizes, you do +not need to use this attribute.</p> + <p class="note"><strong>Note:</strong> Currently, screen compatibility mode only emulates handset +screens with a 320dp width, so screen compatibility mode is not applied if your value for {@code +android:compatibleWidthLimitDp} is larger than 320.</p> + <p>This attribute was introduced in API level 13.</p> + </dd> + + <dt id="largestWidth">{@code android:largestWidthLimitDp}</dt> + <dd>This attribute allows you to force enable screen compatibility mode by specifying the maximum +"smallest screen width" for which your application is designed. If the value you supply here is less +than the shortest side of the available screen space, the application runs in screen +compatibility mode with no way for the user to disable it. + <p>If your application is compatible with all screen sizes and its layout properly resizes, you do +not need to use this attribute. Otherwise, you should first consider using the <a +href="#compatibleWidth">{@code android:compatibleWidthLimitDp}</a> attribute. You should use the +{@code android:largestWidthLimitDp} attribute only when your application is functionally broken when +resized for larger screens and screen compatibility mode is the only way that users should use +your application.</p> + <p class="note"><strong>Note:</strong> Currently, screen compatibility mode only emulates handset +screens with a 320dp width, so screen compatibility mode is not applied if your value for {@code +android:largestWidthLimitDp} is larger than 320.</p> + <p>This attribute was introduced in API level 13.</p> + </dd> + <dt><a name="resizeable"></a>{@code android:resizeable}</dt> <dd>Indicates whether the application is resizeable for different screen sizes. This attribute is true, by default, if you have set either <a @@ -75,6 +147,7 @@ when resized.</p> application does not work well on larger screens, follow the guide to <a href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple Screens</a> to enable additional screen support.</p> + <p><strong>This attribute is deprecated</strong> as of API level 13.</p> </dd> @@ -91,6 +164,7 @@ href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code targe {@code "4"} or higher, the default value for this is {@code "true"}, any value less than {@code "4"} results in this set to {@code "false"}. + <p><strong>This attribute is deprecated</strong> as of API level 13.</p> </dd> <dt><a name="normal"></a>{@code android:normalScreens}</dt> @@ -99,12 +173,13 @@ the default value for this is {@code "true"}, any value less than {@code "4"} re screen, but WQVGA low density and WVGA high density are also considered to be normal. This attribute is "true" by default, and applications currently should leave it that way. + <p><strong>This attribute is deprecated</strong> as of API level 13.</p> </dd> <dt><a name="large"></a>{@code android:largeScreens}</dt> <dd>Indicates whether the application supports larger screen form-factors. A large screen is defined as a screen that is significantly larger - than a "normal" phone screen, and thus might require some special care + than a "normal" handset screen, and thus might require some special care on the application's part to make good use of it, though it may rely on resizing by the system to fill the screen. If the application has set either <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code minSdkVersion}</a> or <a @@ -112,6 +187,7 @@ href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code targe {@code "4"} or higher, the default value for this is {@code "true"}, any value less than {@code "4"} results in this set to {@code "false"}. + <p><strong>This attribute is deprecated</strong> as of API level 13.</p> </dd> <dt><a name="xlarge"></a>{@code android:xlargeScreens}</dt> @@ -125,7 +201,8 @@ href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#target">{@code targe {@code "4"} or higher, the default value for this is {@code "true"}, any value less than {@code "4"} results in this set to {@code "false"}. - <p>This attribute was introduced in API Level 9.</p> + <p>This attribute was introduced in API level 9.</p> + <p><strong>This attribute is deprecated</strong> as of API level 13.</p> </dd> <dt><a name="any"></a>{@code android:anyDensity}</dt> @@ -142,6 +219,7 @@ the default value for this is {@code "true"}. Otherwise, it is {@code "false"}. down application assets by a factor of 0.75 (low dpi screens) or scale them up by a factor of 1.5 (high dpi screens), when you don't provide alternative resources for a specifc screen density. The screen density is expressed as dots-per-inch (dpi).</p> + <p><strong>This attribute is deprecated</strong> as of API level 13.</p> </dd> diff --git a/docs/html/guide/topics/media/images/notification1.png b/docs/html/guide/topics/media/images/notification1.png Binary files differnew file mode 100644 index 0000000..9b01971 --- /dev/null +++ b/docs/html/guide/topics/media/images/notification1.png diff --git a/docs/html/guide/topics/media/images/notification2.png b/docs/html/guide/topics/media/images/notification2.png Binary files differnew file mode 100644 index 0000000..488648e --- /dev/null +++ b/docs/html/guide/topics/media/images/notification2.png diff --git a/docs/html/guide/topics/media/index.jd b/docs/html/guide/topics/media/index.jd index b6d1629..06e6208 100644 --- a/docs/html/guide/topics/media/index.jd +++ b/docs/html/guide/topics/media/index.jd @@ -1,4 +1,4 @@ -page.title=Audio and Video +page.title=Media @jd:body <div id="qv-wrapper"> @@ -6,30 +6,44 @@ page.title=Audio and Video <h2>Quickview</h2> <ul> -<li>Audio playback and record</li> -<li>Video playback</li> -<li>Handles data from raw resources, files, streams</li> -<li>Built-in codecs for a variety of media. See <a href="{@docRoot}guide/appendix/media-formats.html">Android Supported Media Formats</a></li> +<li>MediaPlayer APIs allow you to play and record media</li> +<li>You can handle data from raw resources, files, and streams</li> +<li>The platform supports a variety of media formats. See <a +href="{@docRoot}guide/appendix/media-formats.html">Android Supported Media Formats</a></li> </ul> <h2>In this document</h2> <ol> -<li><a href="#playback">Audio and Video Playback</a> - <ol> - <li><a href="#playraw">Playing from a Raw Resource</li> - <li><a href="#playfile">Playing from a File or Stream</li> - <li><a href="#jet">Playing JET Content</li> - </ol> +<li><a href="#mediaplayer">Using MediaPlayer</a> + <ol> + <li><a href='#preparingasync'>Asynchronous Preparation</a></li> + <li><a href='#managestate'>Managing State</a></li> + <li><a href='#releaseplayer'>Releasing the MediaPlayer</a></li> + </ol> </li> -<li><a href="#capture">Audio Capture</a></li> +<li><a href="#mpandservices">Using a Service with MediaPlayer</a> + <ol> + <li><a href="#asyncprepare">Running asynchronously</a></li> + <li><a href="#asyncerror">Handling asynchronous errors</a></li> + <li><a href="#wakelocks">Using wake locks</a></li> + <li><a href="#foregroundserv">Running as a foreground service</a></li> + <li><a href="#audiofocus">Handling audio focus</a></li> + <li><a href="#cleanup">Performing cleanup</a></li> + </ol> +</li> +<li><a href="#noisyintent">Handling the AUDIO_BECOMING_NOISY Intent</a> +<li><a href="#viacontentresolver">Retrieving Media from a Content Resolver</a> +<li><a href="#jetcontent">Playing JET content</a> +<li><a href="#audiocapture">Performing Audio Capture</a> </ol> <h2>Key classes</h2> <ol> -<li>{@link android.media.MediaPlayer MediaPlayer}</li> -<li>{@link android.media.MediaRecorder MediaRecorder}</li> -<li>{@link android.media.JetPlayer JetPlayer}</li> -<li>{@link android.media.SoundPool SoundPool}</li> +<li>{@link android.media.MediaPlayer}</li> +<li>{@link android.media.MediaRecorder}</li> +<li>{@link android.media.AudioManager}</li> +<li>{@link android.media.JetPlayer}</li> +<li>{@link android.media.SoundPool}</li> </ol> <h2>See also</h2> @@ -41,129 +55,729 @@ page.title=Audio and Video </div> </div> -<p>The Android platform offers built-in encoding/decoding for a variety of -common media types, so that you can easily integrate audio, video, and images into your -applications. Accessing the platform's media capabilities is fairly straightforward -— you do so using the same intents and activities mechanism that the rest of -Android uses.</p> - -<p>Android lets you play audio and video from several types of data sources. You -can play audio or video from media files stored in the application's resources -(raw resources), from standalone files in the filesystem, or from a data stream -arriving over a network connection. To play audio or video from your -application, use the {@link android.media.MediaPlayer} class.</p> - -<p>The platform also lets you record audio and video, where supported by the -mobile device hardware. To record audio or video, use the {@link -android.media.MediaRecorder} class. Note that the emulator doesn't have hardware -to capture audio or video, but actual mobile devices are likely to provide these -capabilities, accessible through the MediaRecorder class. </p> - -<p>For a list of media formats for which Android offers built-in support, -see the <a href="{@docRoot}guide/appendix/media-formats.html">Android Media -Formats</a> appendix. </p> - -<h2 id="playback">Audio and Video Playback</h2> -<p>Media can be played from anywhere: from a raw resource, from a file from the system, -or from an available network (URL).</p> - -<p>You can play back the audio data only to the standard -output device; currently, that is the mobile device speaker or Bluetooth headset. You -cannot play sound files in the conversation audio. </p> - -<h3 id="playraw">Playing from a Raw Resource</h3> -<p>Perhaps the most common thing to want to do is play back media (notably sound) -within your own applications. Doing this is easy:</p> -<ol> - <li>Put the sound (or other media resource) file into the <code>res/raw</code> - folder of your project, where the Eclipse plugin (or aapt) will find it and - make it into a resource that can be referenced from your R class</li> - <li>Create an instance of <code>MediaPlayer</code>, referencing that resource using - {@link android.media.MediaPlayer#create MediaPlayer.create}, and then call - {@link android.media.MediaPlayer#start() start()} on the instance:</li> -</ol> +<p>The Android multimedia framework includes support for encoding and decoding a +variety of common media types, so that you can easily integrate audio, +video and images into your applications. You can play audio or video from media files stored in your +application's resources (raw resources), from standalone files in the filesystem, or from a data +stream arriving over a network connection, all using {@link android.media.MediaPlayer} APIs.</p> + +<p>You can also record audio and video using the {@link android.media.MediaRecorder} APIs if +supported by the device hardware. Note that the emulator doesn't have hardware to capture audio or +video, but actual mobile devices are likely to provide these capabilities.</p> + +<p>This document shows you how to write a media-playing application that interacts with the user and +the system in order to obtain good performance and a pleasant user experience.</p> + +<p class="note"><strong>Note:</strong> You can play back the audio data only to the standard output +device. Currently, that is the mobile device speaker or a Bluetooth headset. You cannot play sound +files in the conversation audio during a call.</p> + + +<h2 id="mediaplayer">Using MediaPlayer</h2> + +<p>One of the most important components of the media framework is the +{@link android.media.MediaPlayer MediaPlayer} +class. An object of this class can fetch, decode, and play both audio and video +with minimal setup. It supports several different media sources such as: +<ul> + <li>Local resources</li> + <li>Internal URIs, such as one you might obtain from a Content Resolver</li> + <li>External URLs (streaming)</li> +</ul> +</p> + +<p>For a list of media formats that Android supports, +see the <a href="{@docRoot}guide/appendix/media-formats.html">Android Supported Media +Formats</a> document. </p> + +<p>Here is an example +of how to play audio that's available as a local raw resource (saved in your application's +{@code res/raw/} directory):</p> + +<pre>MediaPlayer mediaPlayer = MediaPlayer.create(context, R.raw.sound_file_1); +mediaPlayer.start(); // no need to call prepare(); create() does that for you +</pre> + +<p>In this case, a "raw" resource is a file that the system does not +try to parse in any particular way. However, the content of this resource should not +be raw audio. It should be a properly encoded and formatted media file in one +of the supported formats.</p> + +<p>And here is how you might play from a URI available locally in the system +(that you obtained through a Content Resolver, for instance):</p> + +<pre>Uri myUri = ....; // initialize Uri here +MediaPlayer mediaPlayer = new MediaPlayer(); +mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC); +mediaPlayer.setDataSource(getApplicationContext(), myUri); +mediaPlayer.prepare(); +mediaPlayer.start();</pre> + +<p>Playing from a remote URL via HTTP streaming looks like this:</p> + +<pre>String url = "http://........"; // your URL here +MediaPlayer mediaPlayer = new MediaPlayer(); +mediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC); +mediaPlayer.setDataSource(url); +mediaPlayer.prepare(); // might take long! (for buffering, etc) +mediaPlayer.start();</pre> + +<p class="note"><strong>Note:</strong> +If you're passing a URL to stream an online media file, the file must be capable of +progressive download.</p> + +<p class="caution"><strong>Caution:</strong> You must either catch or pass +{@link java.lang.IllegalArgumentException} and {@link java.io.IOException} when using +{@link android.media.MediaPlayer#setDataSource setDataSource()}, because +the file you are referencing might not exist.</p> + +<h3 id='#preparingasync'>Asynchronous Preparation</h3> + +<p>Using {@link android.media.MediaPlayer MediaPlayer} can be straightforward in +principle. However, it's important to keep in mind that a few more things are +necessary to integrate it correctly with a typical Android application. For +example, the call to {@link android.media.MediaPlayer#prepare prepare()} can +take a long time to execute, because +it might involve fetching and decoding media data. So, as is the case with any +method that may take long to execute, you should <strong>never call it from your +application's UI thread</strong>. Doing that will cause the UI to hang until the method returns, +which is a very bad user experience and can cause an ANR (Application Not Responding) error. Even if +you expect your resource to load quickly, remember that anything that takes more than a tenth +of a second to respond in the UI will cause a noticeable pause and will give +the user the impression that your application is slow.</p> + +<p>To avoid hanging your UI thread, spawn another thread to +prepare the {@link android.media.MediaPlayer} and notify the main thread when done. However, while +you could write the threading logic +yourself, this pattern is so common when using {@link android.media.MediaPlayer} that the framework +supplies a convenient way to accomplish this task by using the +{@link android.media.MediaPlayer#prepareAsync prepareAsync()} method. This method +starts preparing the media in the background and returns immediately. When the media +is done preparing, the {@link android.media.MediaPlayer.OnPreparedListener#onPrepared onPrepared()} +method of the {@link android.media.MediaPlayer.OnPreparedListener +MediaPlayer.OnPreparedListener}, configured through +{@link android.media.MediaPlayer#setOnPreparedListener setOnPreparedListener()} is called.</p> + +<h3 id='#managestate'>Managing State</h3> + +<p>Another aspect of a {@link android.media.MediaPlayer} that you should keep in mind is +that it's state-based. That is, the {@link android.media.MediaPlayer} has an internal state +that you must always be aware of when writing your code, because certain operations +are only valid when then player is in specific states. If you perform an operation while in the +wrong state, the system may throw an exception or cause other undesireable behaviors.</p> + +<p>The documentation in the +{@link android.media.MediaPlayer MediaPlayer} class shows a complete state diagram, +that clarifies which methods move the {@link android.media.MediaPlayer} from one state to another. +For example, when you create a new {@link android.media.MediaPlayer}, it is in the <em>Idle</em> +state. At that point, you should initialize it by calling +{@link android.media.MediaPlayer#setDataSource setDataSource()}, bringing it +to the <em>Initialized</em> state. After that, you have to prepare it using either the +{@link android.media.MediaPlayer#prepare prepare()} or +{@link android.media.MediaPlayer#prepareAsync prepareAsync()} method. When +the {@link android.media.MediaPlayer} is done preparing, it will then enter the <em>Prepared</em> +state, which means you can call {@link android.media.MediaPlayer#start start()} +to make it play the media. At that point, as the diagram illustrates, +you can move between the <em>Started</em>, <em>Paused</em> and <em>PlaybackCompleted</em> states by +calling such methods as +{@link android.media.MediaPlayer#start start()}, +{@link android.media.MediaPlayer#pause pause()}, and +{@link android.media.MediaPlayer#seekTo seekTo()}, +amongst others. When you +call {@link android.media.MediaPlayer#stop stop()}, however, notice that you +cannot call {@link android.media.MediaPlayer#start start()} again until you +prepare the {@link android.media.MediaPlayer} again.</p> + +<p>Always keep <a href='{@docRoot}images/mediaplayer_state_diagram.gif'>the state diagram</a> +in mind when writing code that interacts with a +{@link android.media.MediaPlayer} object, because calling its methods from the wrong state is a +common cause of bugs.</p> + +<h3 id='#releaseplayer'>Releasing the MediaPlayer</h3> + +<p>A {@link android.media.MediaPlayer MediaPlayer} can consume valuable +system resources. +Therefore, you should always take extra precautions to make sure you are not +hanging on to a {@link android.media.MediaPlayer} instance longer than necessary. When you +are done with it, you should always call +{@link android.media.MediaPlayer#release release()} to make sure any +system resources allocated to it are properly released. For example, if you are +using a {@link android.media.MediaPlayer} and your activity receives a call to {@link +android.app.Activity#onStop onStop()}, you must release the {@link android.media.MediaPlayer}, +because it +makes little sense to hold on to it while your activity is not interacting with +the user (unless you are playing media in the background, which is discussed in the next section). +When your activity is resumed or restarted, of course, you need to +create a new {@link android.media.MediaPlayer} and prepare it again before resuming playback.</p> + +<p>Here's how you should release and then nullify your {@link android.media.MediaPlayer}:</p> <pre> - MediaPlayer mp = MediaPlayer.create(context, R.raw.sound_file_1); - mp.start(); +mediaPlayer.release(); +mediaPlayer = null; </pre> -<p>To stop playback, call {@link android.media.MediaPlayer#stop() stop()}. If -you wish to later replay the media, then you must -{@link android.media.MediaPlayer#reset() reset()} and -{@link android.media.MediaPlayer#prepare() prepare()} the MediaPlayer object -before calling {@link android.media.MediaPlayer#start() start()} again. -(<code>create()</code> calls <code>prepare()</code> the first time.)</p> -<p>To pause playback, call {@link android.media.MediaPlayer#pause() pause()}. -Resume playback from where you paused with -{@link android.media.MediaPlayer#start() start()}.</p> - -<h3 id="playfile">Playing from a File or Stream</h3> -<p>You can play back media files from the filesystem or a web URL:</p> -<ol> - <li>Create an instance of the <code>MediaPlayer</code> using <code>new</code></li> - <li>Call {@link android.media.MediaPlayer#setDataSource setDataSource()} - with a String containing the path (local filesystem or URL) - to the file you want to play</li> - <li>First {@link android.media.MediaPlayer#prepare prepare()} then - {@link android.media.MediaPlayer#start() start()} on the instance:</li> -</ol> + +<p>As an example, consider the problems that could happen if you +forgot to release the {@link android.media.MediaPlayer} when your activity is stopped, but create a +new one when the activity starts again. As you may know, when the user changes the +screen orientation (or changes the device configuration in another way), +the system handles that by restarting the activity (by default), so you might quickly +consume all of the system resources as the user +rotates the device back and forth between portrait and landscape, because at each +orientation change, you create a new {@link android.media.MediaPlayer} that you never +release. (For more information about runtime restarts, see <a +href="{@docRoot}guide/topics/resources/runtime-changes.html">Handling Runtime Changes</a>.)</p> + +<p>You may be wondering what happens if you want to continue playing +"background media" even when the user leaves your activity, much in the same +way that the built-in Music application behaves. In this case, what you need is +a {@link android.media.MediaPlayer MediaPlayer} controlled by a {@link android.app.Service}, as +discussed in <a href="mpandservices">Using a Service with MediaPlayer</a>.</p> + +<h2 id="mpandservices">Using a Service with MediaPlayer</h2> + +<p>If you want your media to play in the background even when your application +is not onscreen—that is, you want it to continue playing while the user is +interacting with other applications—then you must start a +{@link android.app.Service Service} and control the +{@link android.media.MediaPlayer MediaPlayer} instance from there. +You should be careful about this setup, because the user and the system have expectations +about how an application running a background service should interact with the rest of the +system. If your application does not fulfil those expectations, the user may +have a bad experience. This section describes the main issues that you should be +aware of and offers suggestions about how to approach them.</p> + + +<h3 id="asyncprepare">Running asynchronously</h3> + +<p>First of all, like an {@link android.app.Activity Activity}, all work in a +{@link android.app.Service Service} is done in a single thread by +default—in fact, if you're running an activity and a service from the same application, they +use the same thread (the "main thread") by default. Therefore, services need to +process incoming intents quickly +and never perform lengthy computations when responding to them. If any heavy +work or blocking calls are expected, you must do those tasks asynchronously: either from +another thread you implement yourself, or using the framework's many facilities +for asynchronous processing.</p> + +<p>For instance, when using a {@link android.media.MediaPlayer} from your main thread, +you should call {@link android.media.MediaPlayer#prepareAsync prepareAsync()} rather than +{@link android.media.MediaPlayer#prepare prepare()}, and implement +a {@link android.media.MediaPlayer.OnPreparedListener MediaPlayer.OnPreparedListener} +in order to be notified when the preparation is complete and you can start playing. +For example:</p> + <pre> - MediaPlayer mp = new MediaPlayer(); - mp.setDataSource(PATH_TO_FILE); - mp.prepare(); - mp.start(); +public class MyService extends Service implements MediaPlayer.OnPreparedListener { + private static final ACTION_PLAY = "com.example.action.PLAY"; + MediaPlayer mMediaPlayer = null; + + public int onStartCommand(Intent intent, int flags, int startId) { + ... + if (intent.getAction().equals(ACTION_PLAY)) { + mMediaPlayer = ... // initialize it here + mMediaPlayer.setOnPreparedListener(this); + mMediaPlayer.prepareAsync(); // prepare async to not block main thread + } + } + + /** Called when MediaPlayer is ready */ + public void onPrepared(MediaPlayer player) { +Â Â player.start(); + } +} </pre> -<p>{@link android.media.MediaPlayer#stop() stop()} and -{@link android.media.MediaPlayer#pause() pause()} work the same as discussed -above.</p> - <p class="note"><strong>Note:</strong> - <code>IllegalArgumentException</code> and <code>IOException</code> either - need to be caught or passed on when using <code>setDataSource()</code>, since - the file you are referencing may not exist.</p> -<p class="note"><strong>Note:</strong> -If you're passing a URL to an online media file, the file must be capable of -progressive download.</p> -<h3 id="jet">Playing JET content</h3> -<p>The Android platform includes a JET engine that lets you add interactive playback of JET audio content in your applications. You can create JET content for interactive playback using the JetCreator authoring application that ships with the SDK. To play and manage JET content from your application, use the {@link android.media.JetPlayer JetPlayer} class.</p> -<p>For a description of JET concepts and instructions on how to use the JetCreator authoring tool, see the <a href="{@docRoot}guide/topics/media/jet/jetcreator_manual.html">JetCreator User Manual</a>. The tool is available fully-featured on the OS X and Windows platforms and the Linux version supports all the content creation features, but not the auditioning of the imported assets. </p> +<h3 id="asyncerror">Handling asynchronous errors</h3> + +<p>On synchronous operations, errors would normally +be signaled with an exception or an error code, but whenever you use asynchronous +resources, you should make sure your application is notified +of errors appropriately. In the case of a {@link android.media.MediaPlayer MediaPlayer}, +you can accomplish this by implementing a +{@link android.media.MediaPlayer.OnErrorListener MediaPlayer.OnErrorListener} and +setting it in your {@link android.media.MediaPlayer} instance:</p> + +<pre> +public class MyService extends Service implements MediaPlayer.OnErrorListener { + MediaPlayer mMediaPlayer; + + public void initMediaPlayer() { + // ...initialize the MediaPlayer here... + + mMediaPlayer.setOnErrorListener(this); + } + + @Override + public boolean onError(MediaPlayer mp, int what, int extra) { + // ... react appropriately ... + // The MediaPlayer has moved to the Error state, must be reset! + } +} +</pre> + +<p>It's important to remember that when an error occurs, the {@link android.media.MediaPlayer} +moves to the <em>Error</em> state (see the documentation for the +{@link android.media.MediaPlayer MediaPlayer} class for the full state diagram) +and you must reset it before you can use it again. + + +<h3 id="wakelocks">Using wake locks</h3> + +<p>When designing applications that play media +in the background, the device may go to sleep +while your service is running. Because the Android system tries to conserve +battery while the device is sleeping, the system tries to shut off any +of the phone's features that are +not necessary, including the CPU and the WiFi hardware. +However, if your service is playing or streaming music, you want to prevent +the system from interfering with your playback.</p> + +<p>In order to ensure that your service continues to run under +those conditions, you have to use "wake locks." A wake lock is a way to signal to +the system that your application is using some feature that should +stay available even if the phone is idle.</p> + +<p class="caution"><strong>Notice:</strong> You should always use wake locks sparingly and hold them +only for as long as truly necessary, because they significantly reduce the battery life of the +device.</p> -<p>Here's an example of how to set up JET playback from a .jet file stored on the SD card:</p> +<p>To ensure that the CPU continues running while your {@link android.media.MediaPlayer} is +playing, call the {@link android.media.MediaPlayer#setWakeMode +setWakeMode()} method when initializing your {@link android.media.MediaPlayer}. Once you do, +the {@link android.media.MediaPlayer} holds the specified lock while playing and releases the lock +when paused or stopped:</p> <pre> -JetPlayer myJet = JetPlayer.getJetPlayer(); -myJet.loadJetFile("/sdcard/level1.jet"); +mMediaPlayer = new MediaPlayer(); +// ... other initialization here ... +mMediaPlayer.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK); +</pre> + +<p>However, the wake lock acquired in this example guarantees only that the CPU remains awake. If +you are streaming media over the +network and you are using Wi-Fi, you probably want to hold a +{@link android.net.wifi.WifiManager.WifiLock WifiLock} as +well, which you must acquire and release manually. So, when you start preparing the +{@link android.media.MediaPlayer} with the remote URL, you should create and acquire the Wi-Fi lock. +For example:</p> + +<pre> +WifiLock wifiLock = ((WifiManager) getSystemService(Context.WIFI_SERVICE)) + .createWifiLock(WifiManager.WIFI_MODE_FULL, "mylock"); + +wifiLock.acquire(); +</pre> + +<p>When you pause or stop your media, or when you no longer need the +network, you should release the lock:</p> + +<pre> +wifiLock.release(); +</pre> + + +<h3 id="foregroundserv">Running as a foreground service</h3> + +<p>Services are often used for performing background tasks, such as fetching emails, +synchronizing data, downloading content, amongst other possibilities. In these +cases, the user is not actively aware of the service's execution, and probably +wouldn't even notice if some of these services were interrupted and later restarted.</p> + +<p>But consider the case of a service that is playing music. Clearly this is a service that the user +is actively aware of and the experience would be severely affected by any interruptions. +Additionally, it's a service that the user will likely wish to interact with during its execution. +In this case, the service should run as a "foreground service." A +foreground service holds a higher level of importance within the system—the system will +almost never kill the service, because it is of immediate importance to the user. When running +in the foreground, the service also must provide a status bar notification to ensure that users are +aware of the running service and allow them to open an activity that can interact with the +service.</p> + +<p>In order to turn your service into a foreground service, you must create a +{@link android.app.Notification Notification} for the status bar and call +{@link android.app.Service#startForeground startForeground()} from the {@link +android.app.Service}. For example:</p> + +<pre>String songName; +// assign the song name to songName +PendingIntent pi = PendingIntent.getActivity(getApplicationContext(), 0, +Â Â Â Â Â Â Â Â new Intent(getApplicationContext(), MainActivity.class), +Â Â Â Â Â Â Â Â PendingIntent.FLAG_UPDATE_CURRENT); +Notification notification = new Notification(); +notification.tickerText = text; +notification.icon = R.drawable.play0; +notification.flags |= Notification.FLAG_ONGOING_EVENT; +notification.setLatestEventInfo(getApplicationContext(), "MusicPlayerSample", +Â Â Â Â Â Â Â Â "Playing: " + songName, pi); +startForeground(NOTIFICATION_ID, notification); +</pre> + +<p>While your service is running in the foreground, the notification you +configured is visible in the notification area of the device. If the user +selects the notification, the system invokes the {@link android.app.PendingIntent} you supplied. In +the example above, it opens an activity ({@code MainActivity}).</p> + +<p>Figure 1 shows how your notification appears to the user:</p> + +<img src='images/notification1.png' /> + +<img src='images/notification2.png' /> +<p class="img-caption"><strong>Figure 1.</strong> Screenshots of a foreground service's notification, showing the notification icon in the status bar (left) and the expanded view (right).</p> + +<p>You should only hold on to the "foreground service" status while your +service is actually performing something the user is actively aware of. Once +that is no longer true, you should release it by calling +{@link android.app.Service#stopForeground stopForeground()}:</p> + +<pre> +stopForeground(true); +</pre> + +<p>For more information, see the documentation about <a +href="{@docRoot}guide/topics/fundamentals/services.html#Foreground">Services</a> and +<a href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Status Bar Notifications</a>.</p> + + +<h3 id="audiofocus">Handling audio focus</h3> + +<p>Even though only one activity can run at any given time, Android is a +multi-tasking environment. This poses a particular challenge to applications +that use audio, because there is only one audio output and there may be several +media services competing for its use. Before Android 2.2, there was no built-in +mechanism to address this issue, which could in some cases lead to a bad user +experience. For example, when a user is listening to +music and another application needs to notify the user of something very important, +the user might not hear the notification tone due to the loud music. Starting with +Android 2.2, the platform offers a way for applications to negotiate their +use of the device's audio output. This mechanism is called Audio Focus.</p> + +<p>When your application needs to output audio such as music or a notification, +you should always request audio focus. Once it has focus, it can use the sound output freely, but it should +always listen for focus changes. If it is notified that it has lost the audio +focus, it should immediately either kill the audio or lower it to a quiet level +(known as "ducking"—there is a flag that indicates which one is appropriate) and only resume +loud playback after it receives focus again.</p> + +<p>Audio Focus is cooperative in nature. That is, applications are expected +(and highly encouraged) to comply with the audio focus guidelines, but the +rules are not enforced by the system. If an application wants to play loud +music even after losing audio focus, nothing in the system will prevent that. +However, the user is more likely to have a bad experience and will be more +likely to uninstall the misbehaving application.</p> + +<p>To request audio focus, you must call +{@link android.media.AudioManager#requestAudioFocus requestAudioFocus()} from the {@link +android.media.AudioManager}, as the example below demonstrates:</p> + +<pre> +AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); +int result = audioManager.requestAudioFocus(this, AudioManager.STREAM_MUSIC, + AudioManager.AUDIOFOCUS_GAIN); + +if (result != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) { + // could not get audio focus. +} +</pre> + +<p>The first parameter to {@link android.media.AudioManager#requestAudioFocus requestAudioFocus()} +is an {@link android.media.AudioManager.OnAudioFocusChangeListener +AudioManager.OnAudioFocusChangeListener}, +whose {@link android.media.AudioManager.OnAudioFocusChangeListener#onAudioFocusChange +onAudioFocusChange()} method is called whenever there is a change in audio focus. Therefore, you +should also implement this interface on your service and activities. For example:</p> + +<pre> +class MyService extends Service + implements AudioManager.OnAudioFocusChangeListener { + // .... + public void onAudioFocusChange(int focusChange) { + // Do something based on focus change... + } +} +</pre> + +<p>The <code>focusChange</code> parameter tells you how the audio focus has changed, and +can be one of the following values (they are all constants defined in +{@link android.media.AudioManager AudioManager}):</p> + +<ul> +<li>{@link android.media.AudioManager#AUDIOFOCUS_GAIN}: You have gained the audio focus.</li> + +<li>{@link android.media.AudioManager#AUDIOFOCUS_LOSS}: You have lost the audio focus for a +presumably long time. +You must stop all audio playback. Because you should expect not to have focus back +for a long time, this would be a good place to clean up your resources as much +as possible. For example, you should release the {@link android.media.MediaPlayer}.</li> + +<li>{@link android.media.AudioManager#AUDIOFOCUS_LOSS_TRANSIENT}: You have +temporarily lost audio focus, but should receive it back shortly. You must stop +all audio playback, but you can keep your resources because you will probably get +focus back shortly.</li> + +<li>{@link android.media.AudioManager#AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK}: You have temporarily +lost audio focus, +but you are allowed to continue to play audio quietly (at a low volume) instead +of killing audio completely.</li> +</ul> + +<p>Here is an example implementation:</p> + +<pre> +public void onAudioFocusChange(int focusChange) { + switch (focusChange) { + case AudioManager.AUDIOFOCUS_GAIN: + // resume playback + if (mMediaPlayer == null) initMediaPlayer(); + else if (!mMediaPlayer.isPlaying()) mMediaPlayer.start(); + mMediaPlayer.setVolume(1.0f, 1.0f); + break; + + case AudioManager.AUDIOFOCUS_LOSS: + // Lost focus for an unbounded amount of time: stop playback and release media player + if (mMediaPlayer.isPlaying()) mMediaPlayer.stop(); + mMediaPlayer.release(); + mMediaPlayer = null; + break; + + case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT: + // Lost focus for a short time, but we have to stop + // playback. We don't release the media player because playback + // is likely to resume + if (mMediaPlayer.isPlaying()) mMediaPlayer.pause(); + break; + + case AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK: + // Lost focus for a short time, but it's ok to keep playing + // at an attenuated level + if (mMediaPlayer.isPlaying()) mMediaPlayer.setVolume(0.1f, 0.1f); + break; + } +} +</pre> + +<p>Keep in mind that the audio focus APIs are available only with API level 8 (Android 2.2) +and above, so if you want to support previous +versions of Android, you should adopt a backward compatibility strategy that +allows you to use this feature if available, and fall back seamlessly if not.</p> + +<p>You can achieve backward compatibility either by calling the audio focus methods by reflection +or by implementing all the audio focus features in a separate class (say, +<code>AudioFocusHelper</code>). Here is an example of such a class:</p> + +<pre> +public class AudioFocusHelper implements AudioManager.OnAudioFocusChangeListener { + AudioManager mAudioManager; + + // other fields here, you'll probably hold a reference to an interface + // that you can use to communicate the focus changes to your Service + + public AudioFocusHelper(Context ctx, /* other arguments here */) { + mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); + // ... + } + + public boolean requestFocus() { + return AudioManager.AUDIOFOCUS_REQUEST_GRANTED == + mAudioManager.requestAudioFocus(mContext, AudioManager.STREAM_MUSIC, + AudioManager.AUDIOFOCUS_GAIN); + } + + public boolean abandonFocus() { + return AudioManager.AUDIOFOCUS_REQUEST_GRANTED == + mAudioManager.abandonAudioFocus(this); + } + + @Override + public void onAudioFocusChange(int focusChange) { + // let your service know about the focus change + } +} +</pre> + + +<p>You can create an instance of <code>AudioFocusHelper</code> class only if you detect that +the system is running API level 8 or above. For example:</p> + +<pre> +if (android.os.Build.VERSION.SDK_INT >= 8) { + mAudioFocusHelper = new AudioFocusHelper(getApplicationContext(), this); +} else { + mAudioFocusHelper = null; +} +</pre> + + +<h3 id="cleanup">Performing cleanup</h3> + +<p>As mentioned earlier, a {@link android.media.MediaPlayer} object can consume a significant +amount of system resources, so you should keep it only for as long as you need and call +{@link android.media.MediaPlayer#release release()} when you are done with it. It's important +to call this cleanup method explicitly rather than rely on system garbage collection because +it might take some time before the garbage collector reclaims the {@link android.media.MediaPlayer}, +as it's only sensitive to memory needs and not to shortage of other media-related resources. +So, in the case when you're using a service, you should always override the +{@link android.app.Service#onDestroy onDestroy()} method to make sure you are releasing +the {@link android.media.MediaPlayer}:</p> + +<pre> +public class MyService extends Service { + MediaPlayer mMediaPlayer; + // ... + + @Override + public void onDestroy() { + if (mMediaPlayer != null) mMediaPlayer.release(); + } +} +</pre> + +<p>You should always look for other opportunities to release your {@link android.media.MediaPlayer} +as well, apart from releasing it when being shut down. For example, if you expect not +to be able to play media for an extended period of time (after losing audio focus, for example), +you should definitely release your existing {@link android.media.MediaPlayer} and create it again +later. On the +other hand, if you only expect to stop playback for a very short time, you should probably +hold on to your {@link android.media.MediaPlayer} to avoid the overhead of creating and preparing it +again.</p> + + + +<h2 id="noisyintent">Handling the AUDIO_BECOMING_NOISY Intent</h2> + +<p>Many well-written applications that play audio automatically stop playback when an event +occurs that causes the audio to become noisy (ouput through external speakers). For instance, +this might happen when a user is listening to music through headphones and accidentally +disconnects the headphones from the device. However, this behavior does not happen automatically. +If you don't implement this feature, audio plays out of the device's external speakers, which +might not be what the user wants.</p> + +<p>You can ensure your app stops playing music in these situations by handling +the {@link android.media.AudioManager#ACTION_AUDIO_BECOMING_NOISY} intent, for which you can register a receiver by +adding the following to your manifest:</p> + +<pre> +<receiver android:name=".MusicIntentReceiver"> + <intent-filter> + <action android:name="android.media.AUDIO_BECOMING_NOISY" /> + </intent-filter> +</receiver> +</pre> + +<p>This registers the <code>MusicIntentReceiver</code> class as a broadcast receiver for that +intent. You should then implement this class:</p> + +<pre> +public class MusicIntentReceiver implements android.content.BroadcastReceiver { + @Override + public void onReceive(Context ctx, Intent intent) { + if (intent.getAction().equals( + android.media.AudioManager.ACTION_AUDIO_BECOMING_NOISY)) { + // signal your service to stop playback + // (via an Intent, for instance) + } + } +} +</pre> + + + + +<h2 id="viacontentresolver">Retrieving Media from a Content Resolver</h2> + +<p>Another feature that may be useful in a media player application is the ability to +retrieve music that the user has on the device. You can do that by querying the {@link +android.content.ContentResolver} for external media:</p> + +<pre> +ContentResolver contentResolver = getContentResolver(); +Uri uri = android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI; +Cursor cursor = contentResolver.query(uri, null, null, null, null); +if (cursor == null) { + // query failed, handle error. +} else if (!cursor.moveToFirst()) { + // no media on the device +} else { + int titleColumn = cursor.getColumnIndex(android.provider.MediaStore.Audio.Media.TITLE); + int idColumn = cursor.getColumnIndex(android.provider.MediaStore.Audio.Media._ID); + do { + long thisId = cursor.getLong(idColumn); + String thisTitle = cursor.getString(titleColumn); + // ...process entry... + } while (cursor.moveToNext()); +} +</pre> + +<p>To use this with the {@link android.media.MediaPlayer}, you can do this:</p> + +<pre> +long id = /* retrieve it from somewhere */; +Uri contentUri = ContentUris.withAppendedId( + android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, id); + +mMediaPlayer = new MediaPlayer(); +mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC); +mMediaPlayer.setDataSource(getApplicationContext(), contentUri); + +// ...prepare and start... +</pre> + + + +<h2 id="jetcontent">Playing JET content</h2> + +<p>The Android platform includes a JET engine that lets you add interactive playback of JET audio +content in your applications. You can create JET content for interactive playback using the +JetCreator authoring application that ships with the SDK. To play and manage JET content from your +application, use the {@link android.media.JetPlayer JetPlayer} class.</p> + +<p>For a description of JET concepts and instructions on how to use the JetCreator authoring tool, +see the <a href="{@docRoot}guide/topics/media/jet/jetcreator_manual.html">JetCreator User +Manual</a>. The tool is available on Windows, OS X, and Linux platforms (Linux does not +support auditioning of imported assets like with the Windows and OS X versions). +</p> + +<p>Here's an example of how to set up JET playback from a <code>.jet</code> file stored on the SD card:</p> + +<pre> +JetPlayer jetPlayer = JetPlayer.getJetPlayer(); +jetPlayer.loadJetFile("/sdcard/level1.jet"); byte segmentId = 0; // queue segment 5, repeat once, use General MIDI, transpose by -1 octave -myJet.queueJetSegment(5, -1, 1, -1, 0, segmentId++); +jetPlayer.queueJetSegment(5, -1, 1, -1, 0, segmentId++); // queue segment 2 -myJet.queueJetSegment(2, -1, 0, 0, 0, segmentId++); +jetPlayer.queueJetSegment(2, -1, 0, 0, 0, segmentId++); -myJet.play(); +jetPlayer.play(); </pre> -<p>The SDK includes an example application — JetBoy — that shows how to use {@link android.media.JetPlayer JetPlayer} to create an interactive music soundtrack in your game. It also illustrates how to use JET events to synchronize music and game logic. The application is located at <code><sdk>/platforms/android-1.5/samples/JetBoy</code>. +<p>The SDK includes an example application — JetBoy — that shows how to use {@link +android.media.JetPlayer JetPlayer} to create an interactive music soundtrack in your game. It also +illustrates how to use JET events to synchronize music and game logic. The application is located at +<code><sdk>/platforms/android-1.5/samples/JetBoy</code>.</p> + -<h2 id="capture">Audio Capture</h2> -<p>Audio capture from the device is a bit more complicated than audio/video playback, but still fairly simple:</p> +<h2 id="audiocapture">Performing Audio Capture</h2> + +<p>Audio capture from the device is a bit more complicated than audio and video playback, but still fairly simple:</p> <ol> - <li>Create a new instance of {@link android.media.MediaRecorder android.media.MediaRecorder} using <code>new</code></li> + <li>Create a new instance of {@link android.media.MediaRecorder android.media.MediaRecorder}.</li> <li>Set the audio source using {@link android.media.MediaRecorder#setAudioSource MediaRecorder.setAudioSource()}. You will probably want to use - <code>MediaRecorder.AudioSource.MIC</code></li> + <code>MediaRecorder.AudioSource.MIC</code>.</li> <li>Set output file format using - {@link android.media.MediaRecorder#setOutputFormat MediaRecorder.setOutputFormat()} + {@link android.media.MediaRecorder#setOutputFormat MediaRecorder.setOutputFormat()}. </li> <li>Set output file name using - {@link android.media.MediaRecorder#setOutputFile MediaRecorder.setOutputFile()} + {@link android.media.MediaRecorder#setOutputFile MediaRecorder.setOutputFile()}. </li> - <li>Set the audio encoder using - {@link android.media.MediaRecorder#setAudioEncoder MediaRecorder.setAudioEncoder()} + <li>Set the audio encoder using + {@link android.media.MediaRecorder#setAudioEncoder MediaRecorder.setAudioEncoder()}. </li> <li>Call {@link android.media.MediaRecorder#prepare MediaRecorder.prepare()} on the MediaRecorder instance.</li> - <li>To start audio capture, call + <li>To start audio capture, call {@link android.media.MediaRecorder#start MediaRecorder.start()}. </li> <li>To stop audio capture, call {@link android.media.MediaRecorder#stop MediaRecorder.stop()}. <li>When you are done with the MediaRecorder instance, call @@ -354,3 +968,4 @@ public class AudioRecordTest extends Activity </pre> + diff --git a/docs/html/guide/topics/resources/providing-resources.jd b/docs/html/guide/topics/resources/providing-resources.jd index a996ccc..ea778c1 100644 --- a/docs/html/guide/topics/resources/providing-resources.jd +++ b/docs/html/guide/topics/resources/providing-resources.jd @@ -335,80 +335,101 @@ indicates the current locale.</p> </tr> <tr id="SmallestScreenWidthQualifier"> <td>Smallest screen width</td> - <td>Examples:<br/> + <td><code>sw<N>dp</code><br/><br/> + Examples:<br/> <code>sw320dp</code><br/> <code>sw600dp</code><br/> <code>sw720dp</code><br/> etc. </td> <td> - <p>Specifies a minimum "smallest screen width," in "dp" units, at which the resource - should be used. This configuration value represents the base screen size - of the device, regardless of the orientation of the display. It is based - on the smallest width the application will have in which to perform its - UI layout (in dp units) regardless of the orientation of the screen. The - value here takes into account screen decorations so if the device has some - persistent UI elements on the left or right edge of the display it must - present a value here that is smaller than the real screen size, accounting - for these UI elements reducing the application's available space.</p> - <p>Some values you may use here for common screen sizes:</p> + <p>Specifies the "smallest width" in {@code dp} units that must be available to your + application in order for the resources to be used, regardless of the screen's current + orientation. For example, if your layout requires that its shortest side be at least 600 + dp in length at all times, then you can use this to create the layout resources, {@code + res/layout-sw600dp/}, and the system will use them only when the shortest side of + available screen space it at least 600dp.</p> + <p>The width against which the system compares your value takes into account screen + decorations and system UI. For example, if the device has some persistent UI elements on the + left or right edge of the display, the system declares its own available width as one that + is smaller than the actual screen size, accounting for these UI elements because those are + screen pixels not available for your UI. Thus, the value you use should be the actual + smallest width required by your layout.</p> + <p>Some values you might use here for common screen sizes:</p> <ul> - <li>240x320 ldpi (QVGA phone): 320 - <li>320x480 mdpi (phone): 320 - <li>480x800 hdpi (high density phone): 320 - <li>480x800 mdpi (tablet/phone): 480 - <li>600x1024 mdpi (7" tablet): 600 - <li>720x1280 mdpi (10" tablet): 720 + <li>320, for devices with screen configurations such as: + <ul> + <li>240x320 ldpi (QVGA handset)</li> + <li>320x480 mdpi (handset)</li> + <li>480x800 hdpi (high density handset)</li> + </ul> + </li> + <li>480, for screens such as 480x800 mdpi (tablet/handset).</li> + <li>600, for screens such as 600x1024 mdpi (7" tablet).</li> + <li>720, for screens such as 720x1280 mdpi (10" tablet).</li> </ul> - <p><em>Added in API Level 13.</em></p> - <p>Also see the {@link android.content.res.Configuration#smallestScreenWidthDp} - configuration field, which holds the current smallest screen width.</p> + <p>When your application provides multiple resource directories with different values for + this qualifier, the system uses the one closest to (without exceeding) the smallest width + for the available space. </p> + <p><em>Added in API level 13.</em></p> + <p>Also see the <a + href="{@docRoot}guide/topics/manifest/supports-screens-element.html#requiresSmallest">{@code + android:requiresSmallestWidthDp}</a> attribute, which declares the smallest available width + with which your application is compatible, and the {@link + android.content.res.Configuration#smallestScreenWidthDp} configuration field, which holds + the current smallest screen width for the device.</p> </td> </tr> <tr id="ScreenWidthQualifier"> <td>Screen width</td> - <td>Examples:<br/> + <td><code>w<N>dp</code><br/><br/> + Examples:<br/> <code>w720dp</code><br/> <code>w1024dp</code><br/> etc. </td> <td> - <p>Specifies a minimum screen width, in "dp" units, at which the resource - should be used. This configuration value will change when the orientation - changes between landscape and portrait to match the current actual width. - When multiple screen width configurations are available, the closest to - the current screen width will be used. The - value here takes into account screen decorations so if the device has some - persistent UI elements on the left or right edge of the display it must - present a value here that is smaller than the real screen size, accounting - for these UI elements reducing the application's available space.</p> - <p><em>Added in API Level 13.</em></p> + <p>Specifies a minimum screen width, in {@code dp} units at which the resource + should be used—defined by the <code><N></code> value. This + configuration value will change when the orientation + changes between landscape and portrait to match the current actual width.</p> + <p>When your application provides multiple resource directories with different values + for this configuration, the system uses the one closest to (without exceeding) + the device's current screen width. The + value here takes into account screen decorations, so if the device has some + persistent UI elements on the left or right edge of the display, it + uses a value for the width that is smaller than the real screen size, accounting + for these UI elements and reducing the application's available space.</p> + <p><em>Added in API level 13.</em></p> <p>Also see the {@link android.content.res.Configuration#screenWidthDp} configuration field, which holds the current screen width.</p> </td> </tr> <tr id="ScreenHeightQualifier"> <td>Screen height</td> - <td>Examples:<br/> + <td><code>h<N>dp</code><br/><br/> + Examples:<br/> <code>h720dp</code><br/> <code>h1024dp</code><br/> etc. </td> <td> - <p>Specifies a minimum screen height, in "dp" units, at which the resource - should be used. This configuration value will change when the orientation - changes between landscape and portrait to match the current actual height. - When multiple screen height configurations are available, the closest to - the current screen height will be used. The - value here takes into account screen decorations so if the device has some - persistent UI elements on the left or right edge of the display it must - present a value here that is smaller than the real screen size, accounting - for these UI elements reducing the application's available space. Screen + <p>Specifies a minimum screen height, in "dp" units at which the resource + should be used—defined by the <code><N></code> value. This + configuration value will change when the orientation + changes between landscape and portrait to match the current actual height.</p> + <p>When your application provides multiple resource directories with different values + for this configuration, the system uses the one closest to (without exceeding) + the device's current screen height. The + value here takes into account screen decorations, so if the device has some + persistent UI elements on the top or bottom edge of the display, it uses + a value for the height that is smaller than the real screen size, accounting + for these UI elements and reducing the application's available space. Screen decorations that are not fixed (such as a phone status bar that can be hidden when full screen) are <em>not</em> accounted for here, nor are - window decorations like title bar, so applications must be prepared to + window decorations like the title bar or action bar, so applications must be prepared to deal with a somewhat smaller space than they specify. - <p><em>Added in API Level 13.</em></p> + <p><em>Added in API level 13.</em></p> <p>Also see the {@link android.content.res.Configuration#screenHeightDp} configuration field, which holds the current screen width.</p> </td> @@ -444,9 +465,9 @@ indicates the current locale.</p> medium-density HVGA screen. The minimum layout size for this screen configuration is approximately 720x960 dp units. In most cases, devices with extra large screens would be too large to carry in a pocket and would most likely - be tablet-style devices. <em>Added in API Level 9.</em></li> + be tablet-style devices. <em>Added in API level 9.</em></li> </ul> - <p><em>Added in API Level 4.</em></p> + <p><em>Added in API level 4.</em></p> <p>See <a href="{@docRoot}guide/practices/screens_support.html">Supporting Multiple Screens</a> for more information.</p> <p>Also see the {@link android.content.res.Configuration#screenLayout} configuration field, @@ -465,7 +486,7 @@ or large.</p> <li>{@code long}: Long screens, such as WQVGA, WVGA, FWVGA</li> <li>{@code notlong}: Not long screens, such as QVGA, HVGA, and VGA</li> </ul> - <p><em>Added in API Level 4.</em></p> + <p><em>Added in API level 4.</em></p> <p>This is based purely on the aspect ratio of the screen (a "long" screen is wider). This is not related to the screen orientation.</p> <p>Also see the {@link android.content.res.Configuration#screenLayout} configuration field, @@ -503,7 +524,7 @@ which indicates the current device orientation.</p> <li>{@code car}: Device is in a car dock</li> <li>{@code desk}: Device is in a desk dock</li> </ul> - <p><em>Added in API Level 8.</em></p> + <p><em>Added in API level 8.</em></p> <p>This can change during the life of your application if the user places the device in a dock. You can enable or disable this mode using {@link android.app.UiModeManager}. See <a href="runtime-changes.html">Handling Runtime Changes</a> for @@ -521,7 +542,7 @@ information about how this affects your application during runtime.</p> <li>{@code night}: Night time</li> <li>{@code notnight}: Day time</li> </ul> - <p><em>Added in API Level 8.</em></p> + <p><em>Added in API level 8.</em></p> <p>This can change during the life of your application if night mode is left in auto mode (default), in which case the mode changes based on the time of day. You can enable or disable this mode using {@link android.app.UiModeManager}. See <a @@ -549,7 +570,7 @@ Level 8</em></li> <li>{@code nodpi}: This can be used for bitmap resources that you do not want to be scaled to match the device density.</li> </ul> - <p><em>Added in API Level 4.</em></p> + <p><em>Added in API level 4.</em></p> <p>There is thus a 3:4:6:8 scaling ratio between the four densities, so a 9x9 bitmap in ldpi is 12x12 in mdpi, 18x18 in hdpi and 24x24 in xhdpi.</p> <p>When Android selects which resource files to use, @@ -689,17 +710,17 @@ orientation" described above.</p> </tr> --> <tr id="VersionQualifier"> - <td>Platform Version (API Level)</td> + <td>Platform Version (API level)</td> <td>Examples:<br/> <code>v3</code><br/> <code>v4</code><br/> <code>v7</code><br/> etc.</td> <td> - <p>The API Level supported by the device. For example, <code>v1</code> for API Level -1 (devices with Android 1.0 or higher) and <code>v4</code> for API Level 4 (devices with Android + <p>The API level supported by the device. For example, <code>v1</code> for API level +1 (devices with Android 1.0 or higher) and <code>v4</code> for API level 4 (devices with Android 1.6 or higher). See the <a -href="{@docRoot}guide/appendix/api-levels.html">Android API Levels</a> document for more information +href="{@docRoot}guide/appendix/api-levels.html">Android API levels</a> document for more information about these values.</p> <p class="caution"><strong>Caution:</strong> Android 1.5 and 1.6 only match resources with this qualifier when it exactly matches the platform version. See the section below about <a @@ -863,7 +884,7 @@ cannot use the resources named with the new qualifier. For example, if your <a href="{@docRoot}guide/topics/manifest/uses-sdk-element.html#min">{@code minSdkVersion}</a> is set to 4, and you qualify all of your drawable resources using <a href="#NightQualifier">night mode</a> ({@code night} or {@code notnight}, which were added in API -Level 8), then an API Level 4 device cannot access your drawable resources and will crash. In this +Level 8), then an API level 4 device cannot access your drawable resources and will crash. In this case, you probably want {@code notnight} to be your default resources, so you should exclude that qualifier so your drawable resources are in either {@code drawable/} or {@code drawable-night/}.</p> @@ -896,7 +917,7 @@ compatibility for these versions.</p> <dd>{@code long} and {@code notlong}</dd> </dl> -<p>These configuration qualifiers were introduced in Android 1.6, so Android 1.5 (API Level 3) and +<p>These configuration qualifiers were introduced in Android 1.6, so Android 1.5 (API level 3) and lower does not support them. If you use these configuration qualifiers and do not provide corresponding default resources, then an Android 1.5 device might use any one of the resource directories named with the above screen configuration qualifiers, because it ignores these @@ -926,9 +947,9 @@ is r6 or greater. <p>You need SDK Tools, Revision 6 (or greater), because it includes a new packaging tool that automatically applies an appropriate <a href="#VersionQualifier">version qualifier</a> to any resource directory named with a qualifier that does not exist in Android 1.0. For example, because -the density qualifier was introduced in Android 1.6 (API Level 4), when the packaging tool +the density qualifier was introduced in Android 1.6 (API level 4), when the packaging tool encounters a resource directory using the density qualifier, it adds {@code v4} to the directory -name to ensure that older versions do not use those resources (only API Level 4 and higher support +name to ensure that older versions do not use those resources (only API level 4 and higher support that qualifier). Thus, by putting your medium-density resources in a directory <em>without</em> the {@code mdpi} qualifier, they are still accessible by Android 1.5, and any device that supports the density qualifer and has a medium-density screen also uses the default resources (which are mdpi) @@ -937,7 +958,7 @@ resources).</p> </li> </ol> -<p class="note"><strong>Note:</strong> Later versions of Android, such as API Level 8, +<p class="note"><strong>Note:</strong> Later versions of Android, such as API level 8, introduce other configuration qualifiers that older version do not support. To provide the best compatibility, you should always include a set of default resources for each type of resource that your application uses, as discussed above to provide the best device compatibility.</p> @@ -1068,7 +1089,7 @@ href="accessing-resources.html">Accessing Resources</a>.</p> <p>The correct behavior is for the system to match resources marked with a <a href="#VersionQualifier">version qualifier</a> equal -to or less than the platform version on the device, but on Android 1.5 and 1.6, (API Level 3 and 4), +to or less than the platform version on the device, but on Android 1.5 and 1.6, (API level 3 and 4), there is a bug that causes the system to match resources marked with the version qualifier only when it exactly matches the version on the device.</p> diff --git a/docs/html/guide/topics/search/index.jd b/docs/html/guide/topics/search/index.jd index 7ac5ff1..218511b 100644 --- a/docs/html/guide/topics/search/index.jd +++ b/docs/html/guide/topics/search/index.jd @@ -52,7 +52,13 @@ example of the search dialog with optional search suggestions.</p> <p class="note"><strong>Note</strong>: The search framework does <em>not</em> provide APIs to search your data. To perform a search, you need to use APIs appropriate for your data. For example, if your data is stored in an SQLite database, you should use the {@link android.database.sqlite} -APIs to perform searches.</p> +APIs to perform searches. +<br/><br/> +Also, there is no guarantee that every device provides a dedicated SEARCH button to invoke the +search interface in your application. When using the search dialog or a custom interface, you +must always provide a search button in your UI that activates the search interface. For more +information, see <a href="search-dialog.html#InvokingTheSearchDialog">Invoking the search +dialog</a>.</p> <p>The following documents show you how to use Android's framework to implement search:</p> diff --git a/docs/html/guide/topics/search/search-dialog.jd b/docs/html/guide/topics/search/search-dialog.jd index af6c8f2..d869a44 100644 --- a/docs/html/guide/topics/search/search-dialog.jd +++ b/docs/html/guide/topics/search/search-dialog.jd @@ -17,29 +17,30 @@ access</li> <h2>In this document</h2> <ol> -<li><a href="#TheBasics">The Basics</a></li> -<li><a href="#SearchableConfiguration">Creating a Searchable Configuration</a></li> -<li><a href="#SearchableActivity">Creating a Searchable Activity</a> - <ol> - <li><a href="#DeclaringSearchableActivity">Declaring a searchable activity</a></li> - <li><a href="#EnableSearch">Enabling the search dialog and search widget</a></li> - <li><a href="#PerformingSearch">Performing a search</a></li> - </ol> -</li> -<li><a href="#UsingTheSearchDialog">Using the Search Dialog</a> - <ol> - <li><a href="#LifeCycle">The impact of the search dialog on your activity lifecycle</a></li> - <li><a href="#SearchContextData">Passing search context data</a></li> - </ol> -</li> -<li><a href="#UsingSearchWidget">Using the Search Widget</a> - <ol> - <li><a href="#ConfiguringWidget">Configuring the search widget</a></li> - <li><a href="#WidgetFeatures">Other search widget features</a></li> - </ol> -</li> -<li><a href="#VoiceSearch">Adding Voice Search</a></li> -<li><a href="#SearchSuggestions">Adding Search Suggestions</a></li> + <li><a href="#TheBasics">The Basics</a></li> + <li><a href="#SearchableConfiguration">Creating a Searchable Configuration</a></li> + <li><a href="#SearchableActivity">Creating a Searchable Activity</a> + <ol> + <li><a href="#DeclaringSearchableActivity">Declaring a searchable activity</a></li> + <li><a href="#PerformingSearch">Performing a search</a></li> + </ol> + </li> + <li><a href="#SearchDialog">Using the Search Dialog</a> + <ol> + <li><a href="#InvokingTheSearchDialog">Invoking the search dialog</a></li> + <li><a href="#LifeCycle">The impact of the search dialog on your activity lifecycle</a></li> + <li><a href="#SearchContextData">Passing search context data</a></li> + </ol> + </li> + <li><a href="#UsingSearchWidget">Using the Search Widget</a> + <ol> + <li><a href="#ConfiguringWidget">Configuring the search widget</a></li> + <li><a href="#WidgetFeatures">Other search widget features</a></li> + <li><a href="#UsingBoth">Using both the widget and the dialog</a></li> + </ol> + </li> + <li><a href="#VoiceSearch">Adding Voice Search</a></li> + <li><a href="#SearchSuggestions">Adding Search Suggestions</a></li> </ol> <h2>Key classes</h2> @@ -494,13 +495,13 @@ searches.</p> <h3 id="InvokingTheSearchDialog">Invoking the search dialog</h3> -<p>As mentioned above, the device SEARCH button and {@link android.app.Activity#onSearchRequested -onSearchRequested()} method will open the search dialog, as long as the current activity -has declared the searchable activity to use, as shown in the previous section.</p> +<p>As mentioned above, the device SEARCH button will open the search dialog as long as the current +activity has declared in the manifest the searchable activity to use.</p> -<p>However, you should not assume that a SEARCH button is available on the user's device. You -should always provide another search button in your UI that activates the search dialog by calling -{@link android.app.Activity#onSearchRequested()}.</p> +<p>However, some devices do not include a dedicated SEARCH button, so you should not assume that +it's always available. When using the search dialog, you must <strong>always provide another search +button in your UI</strong> that activates the search dialog by calling {@link +android.app.Activity#onSearchRequested()}.</p> <p>For instance, you should either provide a menu item in your <a href="{@docRoot}guide/topics/ui/menus.html#options-menu">Options Menu</a> or a button in your @@ -510,12 +511,6 @@ href="{@docRoot}shareables/search_icons.zip">search_icons.zip</a> file includes medium and high density screens, which you can use for your search menu item or button (low-density screens scale-down the hdpi image by one half). </p> -<!-- ... maybe this should go into the Creating Menus document .... -<p>If you chose to provide a shortcut key for the menu item, using {@link -android.view.MenuItem#setAlphabeticShortcut(char)}, then SearchManager.MENU_KEY is the recommended -key character, representing the default search key.</p> ---> - <p>You can also enable "type-to-search" functionality, which activates the search dialog when the user starts typing on the keyboard—the keystrokes are inserted into the search dialog. You can enable type-to-search in your activity by calling diff --git a/docs/html/guide/topics/usb/adk.jd b/docs/html/guide/topics/usb/adk.jd index 0e35637..b5a3f30 100644 --- a/docs/html/guide/topics/usb/adk.jd +++ b/docs/html/guide/topics/usb/adk.jd @@ -54,6 +54,11 @@ page.title=Android Open Accessory Development Kit </li> </ol> + <h2>Download</h2> + <ol> + <li><a href="https://dl-ssl.google.com/android/adk/adk_release_0512.zip">ADK package</a></li> + </ol> + <h2>See also</h2> @@ -321,7 +326,7 @@ page.title=Android Open Accessory Development Kit <li>To open the firmware code (a sketch), click <strong>File > Open</strong> and select <code>firmware/demokit/demokit.pde</code>.</li> - <li>Click <strong>Sketch > Compile/Verify</strong> to ensure that the sketch has no + <li>Click <strong>Sketch > Verify/Compile</strong> to ensure that the sketch has no errors.</li> <li>Select <strong>File > Upload to I/O Board</strong>. When Arduino outputs <strong>Done @@ -351,7 +356,8 @@ page.title=Android Open Accessory Development Kit <li>In the <strong>Project name:</strong> field, type DemoKit.</li> <li>Choose <strong>Create project from existing source</strong>, click <strong>Browse</strong>, - select the <code>app</code> directory, and click <strong>Finish</strong>.</li> + select the <code>app</code> directory, click <strong>Open</strong> to close that dialog and then + click <strong>Finish</strong>.</li> <li>For Build Target, select <strong>Google APIs</strong> (Platform 2.3.3, API Level 10). diff --git a/docs/html/guide/topics/wireless/bluetooth.jd b/docs/html/guide/topics/wireless/bluetooth.jd index 48632ea..0af1d2c 100644 --- a/docs/html/guide/topics/wireless/bluetooth.jd +++ b/docs/html/guide/topics/wireless/bluetooth.jd @@ -1,57 +1,61 @@ page.title=Bluetooth @jd:body -<div id="qv-wrapper"> -<div id="qv"> - - <h2>Quickview</h2> - <ul> +<div id="qv-wrapper"> +<div id="qv"> + + <h2>Quickview</h2> + <ul> <li>Android's bluetooth APIs allow your application to perform wireless data transactions with -other devices</li> - </ul> - - <h2>In this document</h2> - <ol> - <li><a href="#TheBasics">The Basics</a></li> - <li><a href="#Permissions">Bluetooth Permissions</a></li> - <li><a href="#SettingUp">Setting Up Bluetooth</a></li> - <li><a href="#FindingDevices">Finding Devices</a> - <ol> - <li><a href="#QueryingPairedDevices">Querying paired devices</a></li> - <li><a href="#DiscoveringDevices">Discovering devices</a></li> - </ol></li> - <li><a href="#ConnectingDevices">Connecting Devices</a> +other devices</li> + </ul> + + <h2>In this document</h2> + <ol> + <li><a href="#TheBasics">The Basics</a></li> + <li><a href="#Permissions">Bluetooth Permissions</a></li> + <li><a href="#SettingUp">Setting Up Bluetooth</a></li> + <li><a href="#FindingDevices">Finding Devices</a> + <ol> + <li><a href="#QueryingPairedDevices">Querying paired devices</a></li> + <li><a href="#DiscoveringDevices">Discovering devices</a></li> + </ol></li> + <li><a href="#ConnectingDevices">Connecting Devices</a> + <ol> + <li><a href="#ConnectingAsAServer">Connecting as a server</a></li> + <li><a href="#ConnectingAsAClient">Connecting as a client</a></li> + </ol></li> + <li><a href="#ManagingAConnection">Managing a Connection</a></li> + <li><a href="#Profiles">Working with Profiles</a> <ol> - <li><a href="#ConnectingAsAServer">Connecting as a server</a></li> - <li><a href="#ConnectingAsAClient">Connecting as a client</a></li> + <li><a href="#AT-Commands">Vendor-specific AT commands</a> </ol></li> - <li><a href="#ManagingAConnection">Managing a Connection</a></li> - </ol> - - <h2>Key classes</h2> - <ol> - <li>{@link android.bluetooth.BluetoothAdapter}</li> - <li>{@link android.bluetooth.BluetoothDevice}</li> - <li>{@link android.bluetooth.BluetoothSocket}</li> - <li>{@link android.bluetooth.BluetoothServerSocket}</li> - </ol> - - <h2>Related samples</h2> - <ol> - <li><a href="{@docRoot}resources/samples/BluetoothChat/index.html">Bluetooth Chat</a></li> - </ol> - -</div> -</div> - - + </ol> + + <h2>Key classes</h2> + <ol> + <li>{@link android.bluetooth.BluetoothAdapter}</li> + <li>{@link android.bluetooth.BluetoothDevice}</li> + <li>{@link android.bluetooth.BluetoothSocket}</li> + <li>{@link android.bluetooth.BluetoothServerSocket}</li> + </ol> + + <h2>Related samples</h2> + <ol> + <li><a href="{@docRoot}resources/samples/BluetoothChat/index.html">Bluetooth Chat</a></li> + </ol> + +</div> +</div> + + <p>The Android platform includes support for the Bluetooth network stack, which allows a device to wirelessly exchange data with other Bluetooth devices. The application framework provides access to the Bluetooth functionality through the Android Bluetooth APIs. These APIs let applications wirelessly connect to other Bluetooth devices, enabling point-to-point and multipoint -wireless features.</p> - +wireless features.</p> + <p>Using the Bluetooth APIs, an Android application can perform the following:</p> <ul> @@ -66,17 +70,17 @@ following:</p> <h2 id="TheBasics">The Basics</h2> -<p>This document describes how to us the Android Bluetooth APIs to accomplish +<p>This document describes how to use the Android Bluetooth APIs to accomplish the four major tasks necessary to communicate using Bluetooth: setting up Bluetooth, finding devices that are either paired or available in the local -area, connecting devices, and transferring data between devices.</p> - +area, connecting devices, and transferring data between devices.</p> + <p>All of the Bluetooth APIs are available in the {@link android.bluetooth} -package. Here's a summary of the classes you will need to create Bluetooth -connections:</p> - -<dl> -<dt>{@link android.bluetooth.BluetoothAdapter}</dt> +package. Here's a summary of the classes and interfaces you will need to create Bluetooth +connections:</p> + +<dl> +<dt>{@link android.bluetooth.BluetoothAdapter}</dt> <dd>Represents the local Bluetooth adapter (Bluetooth radio). The {@link android.bluetooth.BluetoothAdapter} is the entry-point for all Bluetooth interaction. Using this, @@ -84,51 +88,72 @@ you can discover other Bluetooth devices, query a list of bonded (paired) devices, instantiate a {@link android.bluetooth.BluetoothDevice} using a known MAC address, and create a {@link android.bluetooth.BluetoothServerSocket} to listen for communications -from other devices.</dd> - -<dt>{@link android.bluetooth.BluetoothDevice}</dt> +from other devices.</dd> + +<dt>{@link android.bluetooth.BluetoothDevice}</dt> <dd>Represents a remote Bluetooth device. Use this to request a connection with a remote device through a {@link android.bluetooth.BluetoothSocket} or query information about the -device such as its name, address, class, and bonding state.</dd> - -<dt>{@link android.bluetooth.BluetoothSocket}</dt> +device such as its name, address, class, and bonding state.</dd> + +<dt>{@link android.bluetooth.BluetoothSocket}</dt> <dd>Represents the interface for a Bluetooth socket (similar to a TCP {@link java.net.Socket}). This is the connection point that allows an application to exchange data with another Bluetooth device via InputStream -and OutputStream.</dd> - -<dt>{@link android.bluetooth.BluetoothServerSocket}</dt> +and OutputStream.</dd> + +<dt>{@link android.bluetooth.BluetoothServerSocket}</dt> <dd>Represents an open server socket that listens for incoming requests (similar to a TCP {@link java.net.ServerSocket}). In order to connect two Android devices, one device must open a server socket with this class. When a remote Bluetooth device makes a connection request to the this device, the {@link android.bluetooth.BluetoothServerSocket} will return a connected {@link android.bluetooth.BluetoothSocket} when the -connection is accepted.</dd> - -<dt>{@link android.bluetooth.BluetoothClass}</dt> +connection is accepted.</dd> + +<dt>{@link android.bluetooth.BluetoothClass}</dt> <dd>Describes the general characteristics and capabilities of a Bluetooth device. This is a read-only set of properties that define the device's major and minor device classes and its services. However, this does not reliably describe all Bluetooth profiles and services supported by the device, but is useful as a -hint to the device type.</dd> -</dl> - - - - -<h2 id="Permissions">Bluetooth Permissions</h2> - +hint to the device type.</dd> + +<dt>{@link android.bluetooth.BluetoothProfile}</dt> <dd>An interface that +represents a Bluetooth profile. A <em>Bluetooth profile</em> is a wireless +interface specification for Bluetooth-based communication between devices. An +example is the Hands-Free profile. For more discussion of profiles, see <a +href="#Profiles">Working with Profiles</a></dd> + +<dt>{@link android.bluetooth.BluetoothHeadset}</dt> <dd>Provides support for +Bluetooth headsets to be used with mobile phones. This includes both Bluetooth +Headset and Hands-Free (v1.5) profiles.</dd> + +<dt>{@link android.bluetooth.BluetoothA2dp}</dt> <dd> Defines how high quality +audio can be streamed from one device to another over a Bluetooth connection. +"A2DP" stands for Advanced Audio Distribution Profile.</dd> + +<dt>{@link android.bluetooth.BluetoothProfile.ServiceListener}</dt> + +<dd>An interface that notifies {@link android.bluetooth.BluetoothProfile} IPC +clients when they have been connected to or disconnected from the service (that +is, the internal service that runs a particular profile). </dd> + +</dl> + + + + +<h2 id="Permissions">Bluetooth Permissions</h2> + <p>In order to use Bluetooth features in your application, you need to declare at least one of two Bluetooth permissions: {@link android.Manifest.permission#BLUETOOTH} and {@link -android.Manifest.permission#BLUETOOTH_ADMIN}.</p> - +android.Manifest.permission#BLUETOOTH_ADMIN}.</p> + <p>You must request the {@link android.Manifest.permission#BLUETOOTH} permission in order to perform any Bluetooth communication, such as requesting a -connection, accepting a connection, and transferring data.</p> - +connection, accepting a connection, and transferring data.</p> + <p>You must request the {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission in order to initiate device discovery or manipulate Bluetooth settings. Most applications need this permission solely for the @@ -136,40 +161,40 @@ ability to discover local Bluetooth devices. The other abilities granted by this permission should not be used, unless the application is a "power manager" that will modify Bluetooth settings upon user request. <strong>Note:</strong> If you use {@link android.Manifest.permission#BLUETOOTH_ADMIN} permission, then must -also have the {@link android.Manifest.permission#BLUETOOTH} permission.</p> - +also have the {@link android.Manifest.permission#BLUETOOTH} permission.</p> + <p>Declare the Bluetooth permission(s) in your application manifest file. For -example:</p> - -<pre> +example:</p> + +<pre> <manifest ... > <uses-permission android:name="android.permission.BLUETOOTH" /> ... </manifest> -</pre> - +</pre> + <p>See the <a -href="{@docRoot}guide/topics/manifest/uses-permission-element.html"><uses-permission></a> -reference for more information about declaring application permissions.</p> - - -<h2 id="SettingUp">Setting Up Bluetooth</h2> - -<div class="figure" style="width:200px"> -<img src="{@docRoot}images/bt_enable_request.png" /> +href="{@docRoot}guide/topics/manifest/uses-permission-element.html"><uses-permission></a> +reference for more information about declaring application permissions.</p> + + +<h2 id="SettingUp">Setting Up Bluetooth</h2> + +<div class="figure" style="width:200px"> +<img src="{@docRoot}images/bt_enable_request.png" /> <strong>Figure 1:</strong> The enabling Bluetooth dialog. -</div> - +</div> + <p>Before your application can communicate over Bluetooth, you need to verify -that Bluetooth is supported on the device, and if so, ensure that it is enabled.</p> - +that Bluetooth is supported on the device, and if so, ensure that it is enabled.</p> + <p>If Bluetooth is not supported, then you should gracefully disable any Bluetooth features. If Bluetooth is supported, but disabled, then you can request that the user enable Bluetooth without leaving your application. This setup is -accomplished in two steps, using the {@link android.bluetooth.BluetoothAdapter}.</p> - - -<ol> +accomplished in two steps, using the {@link android.bluetooth.BluetoothAdapter}.</p> + + +<ol> <li>Get the {@link android.bluetooth.BluetoothAdapter} <p>The {@link android.bluetooth.BluetoothAdapter} is required for any and all Bluetooth activity. To get the {@link android.bluetooth.BluetoothAdapter}, call the static {@link @@ -178,15 +203,15 @@ android.bluetooth.BluetoothAdapter#getDefaultAdapter()} method. This returns a Bluetooth adapter (the Bluetooth radio). There's one Bluetooth adapter for the entire system, and your application can interact with it using this object. If {@link android.bluetooth.BluetoothAdapter#getDefaultAdapter()} returns null, -then the device does not support Bluetooth and your story ends here. For example:</p> -<pre> +then the device does not support Bluetooth and your story ends here. For example:</p> +<pre> BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); if (mBluetoothAdapter == null) { // Device does not support Bluetooth } -</pre> -</li> - +</pre> +</li> + <li>Enable Bluetooth <p>Next, you need to ensure that Bluetooth is enabled. Call {@link android.bluetooth.BluetoothAdapter#isEnabled()} to check whether Bluetooth is @@ -195,26 +220,26 @@ request that Bluetooth be enabled, call {@link android.app.Activity#startActivityForResult(Intent,int) startActivityForResult()} with the {@link android.bluetooth.BluetoothAdapter#ACTION_REQUEST_ENABLE} action Intent. This will issue a request to enable Bluetooth through the system settings (without -stopping your application). For example:</p> -<pre> +stopping your application). For example:</p> +<pre> if (!mBluetoothAdapter.isEnabled()) { Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT); } -</pre> - +</pre> + <p>A dialog will appear requesting user permission to enable Bluetooth, as shown in Figure 1. If the user responds "Yes," the system will begin to enable Bluetooth -and focus will return to your application once the process completes (or fails).</p> +and focus will return to your application once the process completes (or fails).</p> <p>If enabling Bluetooth succeeds, your Activity will receive the {@link android.app.Activity#RESULT_OK} result code in the {@link android.app.Activity#onActivityResult(int,int,Intent) onActivityResult()} callback. If Bluetooth was not enabled due to an error (or the user responded "No") then the result code will be {@link -android.app.Activity#RESULT_CANCELED}.</p> -</li> -</ol> - +android.app.Activity#RESULT_CANCELED}.</p> +</li> +</ol> + <p>Optionally, your application can also listen for the {@link android.bluetooth.BluetoothAdapter#ACTION_STATE_CHANGED} broadcast Intent, which the system will broadcast whenever the Bluetooth state has changed. This broadcast contains @@ -226,21 +251,21 @@ android.bluetooth.BluetoothAdapter#STATE_ON}, {@link android.bluetooth.BluetoothAdapter#STATE_TURNING_OFF}, and {@link android.bluetooth.BluetoothAdapter#STATE_OFF}. Listening for this broadcast can be useful to detect changes made to the Bluetooth state while your -app is running.</p> - +app is running.</p> + <p class="note"><strong>Tip:</strong> Enabling discoverability will automatically enable Bluetooth. If you plan to consistently enable device discoverability before performing Bluetooth activity, you can skip step 2 above. Read about <a href="#EnablingDiscoverability">enabling discoverability</a>, -below.</p> - - -<h2 id="FindingDevices">Finding Devices</h2> - +below.</p> + + +<h2 id="FindingDevices">Finding Devices</h2> + <p>Using the {@link android.bluetooth.BluetoothAdapter}, you can find remote Bluetooth devices either through device discovery or by querying the list of paired (bonded) -devices.</p> - +devices.</p> + <p>Device discovery is a scanning procedure that searches the local area for Bluetooth enabled devices and then requesting some information about each one (this is sometimes referred to as "discovering," "inquiring" or "scanning"). @@ -249,15 +274,15 @@ request only if it is currently enabled to be discoverable. If a device is discoverable, it will respond to the discovery request by sharing some information, such as the device name, class, and its unique MAC address. Using this information, the device performing discovery can then choose to initiate a -connection to the discovered device.</p> - +connection to the discovered device.</p> + <p>Once a connection is made with a remote device for the first time, a pairing request is automatically presented to the user. When a device is paired, the basic information about that device (such as the device name, class, and MAC address) is saved and can be read using the Bluetooth APIs. Using the known MAC address for a remote device, a connection can be initiated with it at -any time without performing discovery (assuming the device is within range).</p> - +any time without performing discovery (assuming the device is within range).</p> + <p>Remember there is a difference between being paired and being connected. To be paired means that two devices are aware of each other's existence, have a shared link-key that can be used for authentication, and are capable of @@ -265,28 +290,28 @@ establishing an encrypted connection with each other. To be connected means that the devices currently share an RFCOMM channel and are able to transmit data with each other. The current Android Bluetooth API's require devices to be paired before an RFCOMM connection can be established. (Pairing is automatically performed -when you initiate an encrypted connection with the Bluetooth APIs.)</p> - +when you initiate an encrypted connection with the Bluetooth APIs.)</p> + <p>The following sections describe how to find devices that have been paired, or -discover new devices using device discovery.</p> - +discover new devices using device discovery.</p> + <p class="note"><strong>Note:</strong> Android-powered devices are not discoverable by default. A user can make the device discoverable for a limited time through the system settings, or an application can request that the user enable discoverability without leaving the -application. How to <a href="#EnablingDiscoverability">enable discoverability</a> -is discussed below.</p> - - -<h3 id="QueryingPairedDevices">Querying paired devices</h3> - +application. How to <a href="#EnablingDiscoverability">enable discoverability</a> +is discussed below.</p> + + +<h3 id="QueryingPairedDevices">Querying paired devices</h3> + <p>Before performing device discovery, its worth querying the set of paired devices to see if the desired device is already known. To do so, call {@link android.bluetooth.BluetoothAdapter#getBondedDevices()}. This will return a Set of {@link android.bluetooth.BluetoothDevice}s representing paired devices. For example, you can query all paired devices and then -show the name of each device to the user, using an ArrayAdapter:</p> -<pre> +show the name of each device to the user, using an ArrayAdapter:</p> +<pre> Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices(); // If there are paired devices if (pairedDevices.size() > 0) { @@ -296,24 +321,24 @@ if (pairedDevices.size() > 0) { mArrayAdapter.add(device.getName() + "\n" + device.getAddress()); } } -</pre> - +</pre> + <p>All that's needed from the {@link android.bluetooth.BluetoothDevice} object in order to initiate a connection is the MAC address. In this example, it's saved as a part of an ArrayAdapter that's shown to the user. The MAC address can later be extracted in order to initiate the connection. You can learn more about creating -a connection in the section about <a href="#ConnectingDevices">Connecting Devices</a>.</p> - - -<h3 id="DiscoveringDevices">Discovering devices</h3> - +a connection in the section about <a href="#ConnectingDevices">Connecting Devices</a>.</p> + + +<h3 id="DiscoveringDevices">Discovering devices</h3> + <p>To start discovering devices, simply call {@link android.bluetooth.BluetoothAdapter#startDiscovery()}. The process is asynchronous and the method will immediately return with a boolean indicating whether discovery has successfully started. The discovery process usually involves an inquiry scan of about 12 seconds, followed by a page scan of -each found device to retrieve its Bluetooth name.</p> - +each found device to retrieve its Bluetooth name.</p> + <p>Your application must register a BroadcastReceiver for the {@link android.bluetooth.BluetoothDevice#ACTION_FOUND} Intent in order to receive information about each @@ -324,8 +349,8 @@ Intent carries the extra fields {@link android.bluetooth.BluetoothDevice#EXTRA_CLASS}, containing a {@link android.bluetooth.BluetoothDevice} and a {@link android.bluetooth.BluetoothClass}, respectively. For example, here's how you can -register to handle the broadcast when devices are discovered:</p> -<pre> +register to handle the broadcast when devices are discovered:</p> +<pre> // Create a BroadcastReceiver for ACTION_FOUND private final BroadcastReceiver mReceiver = new BroadcastReceiver() { public void onReceive(Context context, Intent intent) { @@ -342,15 +367,15 @@ private final BroadcastReceiver mReceiver = new BroadcastReceiver() { // Register the BroadcastReceiver IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND); registerReceiver(mReceiver, filter); // Don't forget to unregister during onDestroy -</pre> - +</pre> + <p>All that's needed from the {@link android.bluetooth.BluetoothDevice} object in order to initiate a connection is the MAC address. In this example, it's saved as a part of an ArrayAdapter that's shown to the user. The MAC address can later be extracted in order to initiate the connection. You can learn more about creating a connection -in the section about <a href="#ConnectingDevices">Connecting Devices</a>.</p> - +in the section about <a href="#ConnectingDevices">Connecting Devices</a>.</p> + <p class="caution"><strong>Caution:</strong> Performing device discovery is a heavy procedure for the Bluetooth adapter and will consume a lot of its resources. Once you have found a device to @@ -359,41 +384,44 @@ connect, be certain that you always stop discovery with attempting a connection. Also, if you already hold a connection with a device, then performing discovery can significantly reduce the bandwidth available for the connection, so you should -not perform discovery while connected.</p> - -<h4 id="EnablingDiscoverability">Enabling discoverability</h4> - +not perform discovery while connected.</p> + +<h4 id="EnablingDiscoverability">Enabling discoverability</h4> + <p>If you would like to make the local device discoverable to other devices, call {@link android.app.Activity#startActivityForResult(Intent,int)} with the -{@link android.bluetooth.BluetoothAdapter#ACTION_REQUEST_DISCOVERABLE} action Intent. -This will issue a request to enable discoverable mode through the system settings (without -stopping your application). By default, the device will become discoverable for -120 seconds. You can define a different duration by adding the -{@link android.bluetooth.BluetoothAdapter#EXTRA_DISCOVERABLE_DURATION} Intent extra -(maximum duration is 300 seconds). For example:</p> -<pre> -Intent discoverableIntent = new +{@link android.bluetooth.BluetoothAdapter#ACTION_REQUEST_DISCOVERABLE} action +Intent. This will issue a request to enable discoverable mode through the system +settings (without stopping your application). By default, the device will become +discoverable for 120 seconds. You can define a different duration by adding the +{@link android.bluetooth.BluetoothAdapter#EXTRA_DISCOVERABLE_DURATION} Intent +extra. The maximum duration an app can set is 3600 seconds, and a value of 0 +means the device is always discoverable. Any value below 0 or above 3600 is +automatically set to 120 secs). For example, this snippet sets the duration to +300:</p> + +<pre>Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300); startActivity(discoverableIntent); -</pre> - -<div class="figure" style="width:200px"> -<img src="{@docRoot}images/bt_enable_discoverable.png" /> +</pre> + +<div class="figure" style="width:200px"> +<img src="{@docRoot}images/bt_enable_discoverable.png" /> <strong>Figure 2:</strong> The enabling discoverability dialog. -</div> - +</div> + <p>A dialog will be displayed, requesting user permission to make the device discoverable, as shown in Figure 2. If the user responds "Yes," then the device will become discoverable for the specified amount of time. Your Activity will then receive a call to the {@link android.app.Activity#onActivityResult(int,int,Intent) onActivityResult())} callback, with the result code equal to the duration that the device is discoverable. If the user responded "No" or if an error occurred, the result code will -be Activity.RESULT_CANCELLED.</p> - +be Activity.RESULT_CANCELLED.</p> + <p class="note"><strong>Note:</strong> If Bluetooth has not been enabled on the device, -then enabling device discoverability will automatically enable Bluetooth.</p> - +then enabling device discoverability will automatically enable Bluetooth.</p> + <p>The device will silently remain in discoverable mode for the allotted time. If you would like to be notified when the discoverable mode has changed, you can register a BroadcastReceiver for the {@link @@ -407,18 +435,18 @@ new and old scan mode, respectively. Possible values for each are android.bluetooth.BluetoothAdapter#SCAN_MODE_NONE}, which indicate that the device is either in discoverable mode, not in discoverable mode but still able to receive connections, or not in discoverable -mode and unable to receive connections, respectively.</p> - +mode and unable to receive connections, respectively.</p> + <p>You do not need to enable device discoverability if you will be initiating the connection to a remote device. Enabling discoverability is only necessary when you want your application to host a server socket that will accept incoming connections, because the remote devices must be able to discover the device -before it can initiate the connection.</p> - - - -<h2 id="ConnectingDevices">Connecting Devices</h2> - +before it can initiate the connection.</p> + + + +<h2 id="ConnectingDevices">Connecting Devices</h2> + <p>In order to create a connection between your application on two devices, you must implement both the server-side and client-side mechanisms, because one device must open a server socket and the other one must initiate the connection @@ -428,36 +456,36 @@ client are considered connected to each other when they each have a connected point, each device can obtain input and output streams and data transfer can begin, which is discussed in the section about <a href="#ManagingAConnection">Managing a Connection</a>. This section describes how -to initiate the connection between two devices.</p> - +to initiate the connection between two devices.</p> + <p>The server device and the client device each obtain the required {@link android.bluetooth.BluetoothSocket} in different ways. The server will receive it when an incoming connection is accepted. The client will receive it when it -opens an RFCOMM channel to the server.</p> - -<div class="figure" style="width:200px"> -<img src="{@docRoot}images/bt_pairing_request.png" /> +opens an RFCOMM channel to the server.</p> + +<div class="figure" style="width:200px"> +<img src="{@docRoot}images/bt_pairing_request.png" /> <strong>Figure 3:</strong> The Bluetooth pairing dialog. -</div> - +</div> + <p>One implementation technique is to automatically prepare each device as a server, so that each one has a server socket open and listening for connections. Then either device can initiate a connection with the other and become the client. Alternatively, one device can explicitly "host" the connection and open a server socket on demand and the other device can simply initiate the -connection.</p> - +connection.</p> + <p class="note"><strong>Note:</strong> If the two devices have not been previously paired, then the Android framework will automatically show a pairing request notification or dialog to the user during the connection procedure, as shown in Figure 3. So when attempting to connect devices, your application does not need to be concerned about whether or not the devices are paired. Your RFCOMM connection attempt will block until the user has successfully paired, -or will fail if the user rejects pairing, or if pairing fails or times out. </p> - - -<h3 id="ConnectingAsAServer">Connecting as a server</h3> - +or will fail if the user rejects pairing, or if pairing fails or times out. </p> + + +<h3 id="ConnectingAsAServer">Connecting as a server</h3> + <p>When you want to connect two devices, one must act as a server by holding an open {@link android.bluetooth.BluetoothServerSocket}. The purpose of the server socket is to listen for incoming connection requests and when one is accepted, @@ -465,26 +493,26 @@ provide a connected {@link android.bluetooth.BluetoothSocket}. When the {@link android.bluetooth.BluetoothSocket} is acquired from the {@link android.bluetooth.BluetoothServerSocket}, the {@link android.bluetooth.BluetoothServerSocket} can (and should) be -discarded, unless you want to accept more connections.</p> - -<div class="sidebox-wrapper"> -<div class="sidebox"> -<h2>About UUID</h2> - +discarded, unless you want to accept more connections.</p> + +<div class="sidebox-wrapper"> +<div class="sidebox"> +<h2>About UUID</h2> + <p>A Universally Unique Identifier (UUID) is a standardized 128-bit format for a string ID used to uniquely identify information. The point of a UUID is that it's big enough that you can select any random and it won't clash. In this case, it's used to uniquely identify your application's Bluetooth service. To get a UUID to use with your application, you can use one of the many random UUID generators on the web, then initialize a {@link java.util.UUID} with {@link -java.util.UUID#fromString(String)}.</p> -</div> -</div> - +java.util.UUID#fromString(String)}.</p> +</div> +</div> + <p>Here's the basic procedure to set up a server socket and accept a -connection:</p> - -<ol> +connection:</p> + +<ol> <li>Get a {@link android.bluetooth.BluetoothServerSocket} by calling the {@link android.bluetooth.BluetoothAdapter#listenUsingRfcommWithServiceRecord(String, @@ -496,9 +524,9 @@ UUID is also included in the SDP entry and will be the basis for the connection agreement with the client device. That is, when the client attempts to connect with this device, it will carry a UUID that uniquely identifies the service with which it wants to connect. These UUIDs must match in order for the connection to -be accepted (in the next step).</p> -</li> - +be accepted (in the next step).</p> +</li> + <li>Start listening for connection requests by calling {@link android.bluetooth.BluetoothServerSocket#accept()}. <p>This is a blocking call. It will return when either a connection has been @@ -506,9 +534,9 @@ accepted or an exception has occurred. A connection is accepted only when a remote device has sent a connection request with a UUID matching the one registered with this listening server socket. When successful, {@link android.bluetooth.BluetoothServerSocket#accept()} will -return a connected {@link android.bluetooth.BluetoothSocket}.</p> -</li> - +return a connected {@link android.bluetooth.BluetoothSocket}.</p> +</li> + <li>Unless you want to accept additional connections, call {@link android.bluetooth.BluetoothServerSocket#close()}. <p>This releases the server socket and all its resources, but does <em>not</em> close the @@ -517,10 +545,10 @@ android.bluetooth.BluetoothServerSocket#accept()}. Unlike TCP/IP, RFCOMM only al connected client per channel at a time, so in most cases it makes sense to call {@link android.bluetooth.BluetoothServerSocket#close()} on the {@link android.bluetooth.BluetoothServerSocket} immediately after accepting a connected -socket.</p> -</li> -</ol> - +socket.</p> +</li> +</ol> + <p>The {@link android.bluetooth.BluetoothServerSocket#accept()} call should not be executed in the main Activity UI thread because it is a blocking call and will prevent any other interaction with the application. It usually makes @@ -533,16 +561,16 @@ android.bluetooth.BluetoothServerSocket} (or {@link android.bluetooth.BluetoothSocket}) from another thread and the blocked call will immediately return. Note that all methods on a {@link android.bluetooth.BluetoothServerSocket} or {@link android.bluetooth.BluetoothSocket} -are thread-safe.</p> - -<h4>Example</h4> - +are thread-safe.</p> + +<h4>Example</h4> + <p>Here's a simplified thread for the server component that accepts incoming -connections:</p> -<pre> +connections:</p> +<pre> private class AcceptThread extends Thread { private final BluetoothServerSocket mmServerSocket; - + public AcceptThread() { // Use a temporary object that is later assigned to mmServerSocket, // because mmServerSocket is final @@ -553,7 +581,7 @@ private class AcceptThread extends Thread { } catch (IOException e) { } mmServerSocket = tmp; } - + public void run() { BluetoothSocket socket = null; // Keep listening until exception occurs or a socket is returned @@ -572,7 +600,7 @@ private class AcceptThread extends Thread { } } } - + /** Will cancel the listening socket, and cause the thread to finish */ public void cancel() { try { @@ -580,37 +608,37 @@ private class AcceptThread extends Thread { } catch (IOException e) { } } } -</pre> - +</pre> + <p>In this example, only one incoming connection is desired, so as soon as a connection is accepted and the {@link android.bluetooth.BluetoothSocket} is acquired, the application sends the acquired {@link android.bluetooth.BluetoothSocket} to a separate thread, closes the -{@link android.bluetooth.BluetoothServerSocket} and breaks the loop.</p> - +{@link android.bluetooth.BluetoothServerSocket} and breaks the loop.</p> + <p>Note that when {@link android.bluetooth.BluetoothServerSocket#accept()} returns the {@link android.bluetooth.BluetoothSocket}, the socket is already connected, so you should <em>not</em> call {@link android.bluetooth.BluetoothSocket#connect()} (as you do from the -client-side).</p> - +client-side).</p> + <p><code>manageConnectedSocket()</code> is a fictional method in the application that will initiate the thread for transferring data, which is discussed in the section -about <a href="#ManagingAConnection">Managing a Connection</a>.</p> - +about <a href="#ManagingAConnection">Managing a Connection</a>.</p> + <p>You should usually close your {@link android.bluetooth.BluetoothServerSocket} as soon as you are done listening for incoming connections. In this example, {@link android.bluetooth.BluetoothServerSocket#close()} is called as soon as the {@link android.bluetooth.BluetoothSocket} is acquired. You may also want to provide a public method in your thread that can close the private {@link android.bluetooth.BluetoothSocket} in the event that you need to stop listening on the -server socket.</p> - - -<h3 id="ConnectingAsAClient">Connecting as a client</h3> - +server socket.</p> + + +<h3 id="ConnectingAsAClient">Connecting as a client</h3> + <p>In order to initiate a connection with a remote device (a device holding an open server socket), you must first obtain a {@link @@ -619,11 +647,11 @@ android.bluetooth.BluetoothDevice} object that represents the remote device. section about <a href="#FindingDevices">Finding Devices</a>.) You must then use the {@link android.bluetooth.BluetoothDevice} to acquire a {@link -android.bluetooth.BluetoothSocket} and initiate the connection.</p> - -<p>Here's the basic procedure:</p> - -<ol> +android.bluetooth.BluetoothSocket} and initiate the connection.</p> + +<p>Here's the basic procedure:</p> + +<ol> <li>Using the {@link android.bluetooth.BluetoothDevice}, get a {@link android.bluetooth.BluetoothSocket} by calling {@link android.bluetooth.BluetoothDevice#createRfcommSocketToServiceRecord(UUID)}. @@ -634,9 +662,9 @@ must match the UUID used by the server device when it opened its android.bluetooth.BluetoothAdapter#listenUsingRfcommWithServiceRecord(String, UUID)}). Using the same UUID is simply a matter of hard-coding the UUID string into your application and then referencing it from both the server and client -code.</p> -</li> - +code.</p> +</li> + <li>Initiate the connection by calling {@link android.bluetooth.BluetoothSocket#connect()}. <p>Upon this call, the system will perform an SDP lookup on the remote device in @@ -647,34 +675,34 @@ android.bluetooth.BluetoothSocket#connect()} will return. This method is a blocking call. If, for any reason, the connection fails or the {@link android.bluetooth.BluetoothSocket#connect()} method times out (after about -12 seconds), then it will throw an exception.</p> +12 seconds), then it will throw an exception.</p> <p>Because {@link android.bluetooth.BluetoothSocket#connect()} is a blocking call, this connection procedure should always be performed in a thread separate from the main Activity -thread.</p> +thread.</p> <p class="note">Note: You should always ensure that the device is not performing device discovery when you call {@link android.bluetooth.BluetoothSocket#connect()}. If discovery is in progress, then the -connection attempt will be significantly slowed and is more likely to fail.</p> -</li> -</ol> - -<h4>Example</h4> - +connection attempt will be significantly slowed and is more likely to fail.</p> +</li> +</ol> + +<h4>Example</h4> + <p>Here is a basic example of a thread that initiates a Bluetooth -connection:</p> -<pre> +connection:</p> +<pre> private class ConnectThread extends Thread { private final BluetoothSocket mmSocket; private final BluetoothDevice mmDevice; - + public ConnectThread(BluetoothDevice device) { // Use a temporary object that is later assigned to mmSocket, // because mmSocket is final BluetoothSocket tmp = null; mmDevice = device; - + // Get a BluetoothSocket to connect with the given BluetoothDevice try { // MY_UUID is the app's UUID string, also used by the server code @@ -682,11 +710,11 @@ private class ConnectThread extends Thread { } catch (IOException e) { } mmSocket = tmp; } - + public void run() { // Cancel discovery because it will slow down the connection mBluetoothAdapter.cancelDiscovery(); - + try { // Connect the device through the socket. This will block // until it succeeds or throws an exception @@ -698,11 +726,11 @@ private class ConnectThread extends Thread { } catch (IOException closeException) { } return; } - + // Do work to manage the connection (in a separate thread) manageConnectedSocket(mmSocket); } - + /** Will cancel an in-progress connection, and close the socket */ public void cancel() { try { @@ -710,42 +738,42 @@ private class ConnectThread extends Thread { } catch (IOException e) { } } } -</pre> - +</pre> + <p>Notice that {@link android.bluetooth.BluetoothAdapter#cancelDiscovery()} is called before the connection is made. You should always do this before connecting and it is safe to call without actually checking whether it is running or not (but if you do want to -check, call {@link android.bluetooth.BluetoothAdapter#isDiscovering()}).</p> - +check, call {@link android.bluetooth.BluetoothAdapter#isDiscovering()}).</p> + <p><code>manageConnectedSocket()</code> is a fictional method in the application that will initiate the thread for transferring data, which is discussed in the section -about <a href="#ManagingAConnection">Managing a Connection</a>.</p> - +about <a href="#ManagingAConnection">Managing a Connection</a>.</p> + <p>When you're done with your {@link android.bluetooth.BluetoothSocket}, always call {@link android.bluetooth.BluetoothSocket#close()} to clean up. Doing so will immediately close the connected socket and clean up all internal -resources.</p> - - -<h2 id="ManagingAConnection">Managing a Connection</h2> - +resources.</p> + + +<h2 id="ManagingAConnection">Managing a Connection</h2> + <p>When you have successfully connected two (or more) devices, each one will have a connected {@link android.bluetooth.BluetoothSocket}. This is where the fun begins because you can share data between devices. Using the {@link android.bluetooth.BluetoothSocket}, the general procedure to transfer arbitrary data is -simple:</p> -<ol> +simple:</p> +<ol> <li>Get the {@link java.io.InputStream} and {@link java.io.OutputStream} that handle transmissions through the socket, via {@link android.bluetooth.BluetoothSocket#getInputStream()} and -{@link android.bluetooth.BluetoothSocket#getOutputStream}, respectively.</li> - +{@link android.bluetooth.BluetoothSocket#getOutputStream}, respectively.</li> + <li>Read and write data to the streams with {@link -java.io.InputStream#read(byte[])} and {@link java.io.OutputStream#write(byte[])}.</li> -</ol> - -<p>That's it.</p> - +java.io.InputStream#read(byte[])} and {@link java.io.OutputStream#write(byte[])}.</li> +</ol> + +<p>That's it.</p> + <p>There are, of course, implementation details to consider. First and foremost, you should use a dedicated thread for all stream reading and writing. This is important because both {@link java.io.InputStream#read(byte[])} and {@link @@ -756,37 +784,37 @@ block, but can block for flow control if the remote device is not calling {@link java.io.InputStream#read(byte[])} quickly enough and the intermediate buffers are full. So, your main loop in the thread should be dedicated to reading from the {@link java.io.InputStream}. A separate public method in the thread can be used to initiate -writes to the {@link java.io.OutputStream}.</p> - -<h4>Example</h4> - -<p>Here's an example of how this might look:</p> -<pre> +writes to the {@link java.io.OutputStream}.</p> + +<h4>Example</h4> + +<p>Here's an example of how this might look:</p> +<pre> private class ConnectedThread extends Thread { private final BluetoothSocket mmSocket; private final InputStream mmInStream; private final OutputStream mmOutStream; - + public ConnectedThread(BluetoothSocket socket) { mmSocket = socket; InputStream tmpIn = null; OutputStream tmpOut = null; - + // Get the input and output streams, using temp objects because // member streams are final try { tmpIn = socket.getInputStream(); tmpOut = socket.getOutputStream(); } catch (IOException e) { } - + mmInStream = tmpIn; mmOutStream = tmpOut; } - + public void run() { byte[] buffer = new byte[1024]; // buffer store for the stream int bytes; // bytes returned from read() - + // Keep listening to the InputStream until an exception occurs while (true) { try { @@ -800,14 +828,14 @@ private class ConnectedThread extends Thread { } } } - + /* Call this from the main Activity to send data to the remote device */ public void write(byte[] bytes) { try { mmOutStream.write(bytes); } catch (IOException e) { } } - + /* Call this from the main Activity to shutdown the connection */ public void cancel() { try { @@ -815,27 +843,124 @@ private class ConnectedThread extends Thread { } catch (IOException e) { } } } -</pre> - +</pre> + <p>The constructor acquires the necessary streams and once executed, the thread will wait for data to come through the InputStream. When {@link java.io.InputStream#read(byte[])} returns with bytes from the stream, the data is sent to the main Activity using a member Handler from the parent class. Then it goes back and waits for more bytes from -the stream.</p> - +the stream.</p> + <p>Sending outgoing data is as simple as calling the thread's <code>write()</code> method from the main Activity and passing in the bytes to be sent. This method then simply calls {@link -java.io.OutputStream#write(byte[])} to send the data to the remote device.</p> - +java.io.OutputStream#write(byte[])} to send the data to the remote device.</p> + <p>The thread's <code>cancel()</code> method is important so that the connection can be terminated at any time by closing the {@link android.bluetooth.BluetoothSocket}. This should always be called when you're done using the Bluetooth -connection.</p> - -<div class="special"> -<p>For a complete demonstration using the Bluetooth APIs, see the <a -href="{@docRoot}resources/samples/BluetoothChat/index.html">Bluetooth Chat sample app</a>.</p> -</div> +connection.</p> + +<div class="special"> +<p>For a demonstration of using the Bluetooth APIs, see the <a +href="{@docRoot}resources/samples/BluetoothChat/index.html">Bluetooth Chat sample app</a>.</p> +</div> + +<h2 id="Profiles">Working with Profiles</h2> + +<p>Starting in Android 3.0, the Bluetooth API includes support for working with +Bluetooth profiles. A <em>Bluetooth profile</em> is a wireless interface +specification for Bluetooth-based communication between devices. An example +is the Hands-Free profile. For a mobile phone to connect to a wireless headset, +both devices must support the Hands-Free profile. </p> + +<p>You can implement the interface {@link android.bluetooth.BluetoothProfile} to write +your own classes to support a particular Bluetooth profile. The Android +Bluetooth API provides implementations for the following Bluetooth +profiles:</p> +<ul> + + <li><strong>Headset</strong>. The Headset profile provides support for +Bluetooth headsets to be used with mobile phones. Android provides the {@link +android.bluetooth.BluetoothHeadset} class, which is a proxy for controlling the +Bluetooth Headset Service via interprocess communication (<a +href="{@docRoot}guide/topics/fundamentals/processes-and-threads.html#IPC">IPC</a +>). This includes both Bluetooth Headset and Hands-Free (v1.5) profiles. The +{@link android.bluetooth.BluetoothHeadset} class includes support for AT commands. +For more discussion of this topic, see <a href="#AT-Commands">Vendor-specific AT commands</a></li> + + <li><strong>A2DP</strong>. The Advanced Audio Distribution Profile (A2DP) +profile defines how high quality audio can be streamed from one device to +another over a Bluetooth connection. Android provides the {@link +android.bluetooth.BluetoothA2dp} class, which is a proxy for controlling +the Bluetooth A2DP Service via IPC.</li> + +</ul> + +<p>Here are the basic steps for working with a profile:</p> +<ol> + + <li>Get the default adapter, as described in <a href="{@docRoot}guide/topics/wireless/bluetooth. +html#SettingUp">Setting Up Bluetooth</a>.</li> + + <li>Use {@link +android.bluetooth.BluetoothAdapter#getProfileProxy(android.content.Context, +android.bluetooth.BluetoothProfile.ServiceListener, int) getProfileProxy()} to +establish a connection to the profile proxy object associated with the profile. +In the example below, the profile proxy object is an instance of {@link +android.bluetooth.BluetoothHeadset}. </li> + + <li>Set up a {@link android.bluetooth.BluetoothProfile.ServiceListener}. This +listener notifies {@link android.bluetooth.BluetoothProfile} IPC clients when +they have been connected to or disconnected from the service.</li> + + <li>In {@link +android.bluetooth.BluetoothProfile.ServiceListener#onServiceConnected(int, +android.bluetooth.BluetoothProfile) onServiceConnected()}, get a handle +to the profile proxy object.</li> + + <li>Once you have the profile proxy object, you can use it to monitor the +state of the connection and perform other operations that are relevant to that +profile.</li> +</ol> +<p> For example, this code snippet shows how to connect to a {@link android.bluetooth.BluetoothHeadset} proxy object so that you can control the +Headset profile:</p> + +<pre>BluetoothHeadset mBluetoothHeadset; + +// Get the default adapter +BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); + +// Establish connection to the proxy. +mBluetoothAdapter.getProfileProxy(context, mProfileListener, BluetoothProfile.HEADSET); + +private BluetoothProfile.ServiceListener mProfileListener = new BluetoothProfile.ServiceListener() { + public void onServiceConnected(int profile, BluetoothProfile proxy) { + if (profile == BluetoothProfile.HEADSET) { + mBluetoothHeadset = (BluetoothHeadset) proxy; + } + } + public void onServiceDisconnected(int profile) { + if (profile == BluetoothProfile.HEADSET) { + mBluetoothHeadset = null; + } + } +}; + +// ... call functions on mBluetoothHeadset + +// Close proxy connection after use. +mBluetoothAdapter.closeProfileProxy(mBluetoothHeadset); +</pre> + +<h3 id="AT-Commands">Vendor-specific AT commands</h3> + +<p>Starting in Android 3.0, applications can register to receive system +broadcasts of pre-defined vendor-specific AT commands sent by headsets (such as +a Plantronics +XEVENT command). For example, an application could receive +broadcasts that indicate a connected device's battery level and could notify the +user or take other action as needed. Create a broadcast receiver for the {@link +android.bluetooth.BluetoothHeadset#ACTION_VENDOR_SPECIFIC_HEADSET_EVENT} intent +to handle vendor-specific AT commands for the headset.</p> diff --git a/docs/html/resources/dashboard/opengl.jd b/docs/html/resources/dashboard/opengl.jd index dac8ce5..3fcfa89 100644 --- a/docs/html/resources/dashboard/opengl.jd +++ b/docs/html/resources/dashboard/opengl.jd @@ -57,7 +57,7 @@ ending on the data collection date noted below.</p> <div class="dashboard-panel"> <img alt="" width="400" height="250" -src="http://chart.googleapis.com/chart?cht=p&chs=400x250&chco=c4df9b,6fad0c&chl=GL%20ES%201.1|GL%20ES%202.0&chd=t%3A8.9,91.1" /> +src="http://chart.googleapis.com/chart?cht=p&chs=400x250&chco=c4df9b,6fad0c&chl=GL%201.1|GL%202.0%20%26%201.1&chd=t%3A8.9,91" /> <table> <tr> @@ -66,11 +66,11 @@ src="http://chart.googleapis.com/chart?cht=p&chs=400x250&chco=c4df9b,6fad0c&chl= </tr> <tr> <td>1.1</th> -<td>8.9%</td> +<td>9%</td> </tr> <tr> <td>2.0</th> -<td>91.1%</td> +<td>91%</td> </tr> </table> diff --git a/docs/html/resources/dashboard/platform-versions.jd b/docs/html/resources/dashboard/platform-versions.jd index 368164d..d9adb36 100644 --- a/docs/html/resources/dashboard/platform-versions.jd +++ b/docs/html/resources/dashboard/platform-versions.jd @@ -51,8 +51,8 @@ Android Market within a 14-day period ending on the data collection date noted b <div class="dashboard-panel"> -<img alt="" height="250" width="460" -src="http://chart.apis.google.com/chart?&cht=p&chs=460x250&chd=t:2.3,3.0,24.5,65.9,1.0,3.0,0.3&chl=Android%201.5|Android%201.6|Android%202.1|Android%202.2|Android%202.3|Android%202.3.3|Android%203.0&chco=c4df9b,6fad0c" /> +<img alt="" height="250" width="470" +src="http://chart.apis.google.com/chart?&cht=p&chs=460x250&chd=t:1.4,2.2,17.5,59.4,1.0,17.6,0.4,0.5&chl=Android%201.5|Android%201.6|Android%202.1|Android%202.2|Android%202.3%20-%202.3.2|Android%202.3.3%20-%202.3.4|Android%203.0|Android%203.1&chco=c4df9b,6fad0c" /> <table> <tr> @@ -60,16 +60,19 @@ src="http://chart.apis.google.com/chart?&cht=p&chs=460x250&chd=t:2.3,3.0,24.5,65 <th>API Level</th> <th>Distribution</th> </tr> -<tr><td>Android 1.5</td><td>3</td><td>2.3%</td></tr> -<tr><td>Android 1.6</td><td>4</td><td>3.0%</td></tr> -<tr><td>Android 2.1</td><td>7</td><td>24.5%</td></tr> -<tr><td>Android 2.2</td><td>8</td><td>65.9%</td></tr> -<tr><td>Android 2.3</td><td>9</td><td>1.0%</td></tr> -<tr><td>Android 2.3.3</td><td>10</td><td>3.0%</td></tr> -<tr><td>Android 3.0</td><td>11</td><td>0.3%</td></tr> +<tr><td>Android 1.5</td><td>3</td><td>1.4%</td></tr> +<tr><td>Android 1.6</td><td>4</td><td>2.2%</td></tr> +<tr><td>Android 2.1</td><td>7</td><td>17.5%</td></tr> +<tr><td>Android 2.2</td><td>8</td><td>59.4%</td></tr> +<tr><td>Android 2.3 -<br/> + Android 2.3.2</td><td>9</td><td>1%</td></tr> +<tr><td>Android 2.3.3 -<br/> + Android 2.3.4</td><td>10</td><td>17.6%</td></tr> +<tr><td>Android 3.0</td><td>11</td><td>0.4%</td></tr> +<tr><td>Android 3.1</td><td>12</td><td>0.5%</td></tr> </table> -<p><em>Data collected during two weeks ending on May 2, 2011</em></p> +<p><em>Data collected during a 14-day period ending on July 5, 2011</em></p> <!-- <p style="font-size:.9em">* <em>Other: 0.1% of devices running obsolete versions</em></p> --> @@ -98,9 +101,9 @@ Android Market within a 14-day period ending on the date indicated on the x-axis <div class="dashboard-panel"> <img alt="" height="250" width="660" style="padding:5px;background:#fff" -src="http://chart.apis.google.com/chart?&cht=lc&chs=660x250&chxt=x,x,y,r&chxr=0,0,12|1,0,12|2,0,100|3,0,100&chxl=0%3A%7C11/01%7C11/15%7C12/01%7C12/15%7C01/01%7C01/15%7C02/01%7C02/15%7C03/01%7C03/15%7C04/01%7C04/15%7C05/01%7C1%3A%7C2010%7C%7C%7C%7C2011%7C%7C%7C%7C%7C%7C%7C%7C2011%7C2%3A%7C0%25%7C25%25%7C50%25%7C75%25%7C100%25%7C3%3A%7C0%25%7C25%25%7C50%25%7C75%25%7C100%25&chxp=0,0,1,2,3,4,5,6,7,8,9,10,11,12&chxtc=0,5&chd=t:100.0,99.9,99.8,99.7,100.0,99.9,99.9,99.9,100.0,99.8,99.7,99.6,99.6|92.0,92.7,93.4,94.1,95.2,95.6,96.0,96.3,96.7,96.8,97.0,97.1,97.3|77.4,79.6,82.2,84.4,87.2,88.3,89.7,90.5,91.5,92.0,93.5,93.9,94.3|37.1,40.5,44.3,47.7,51.8,54.3,58.3,59.7,61.5,63.0,66.4,68.0,69.8|0.0,0.0,0.0,0.0,0.4,0.6,0.7,0.8,1.1,1.7,2.5,3.1,4.0|0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,1.0,1.7,2.2,3.0&chm=b,c3df9b,0,1,0|tAndroid 1.6,689326,1,0,15,,t::-5|b,b4db77,1,2,0|tAndroid 2.1,547a19,2,0,15,,t::-5|b,a5db51,2,3,0|tAndroid 2.2,3f5e0e,3,0,15,,t::-5|b,96dd28,3,4,0|b,83c916,4,5,0|B,6fad0c,5,6,0&chg=7,25&chdl=Android 1.5|Android 1.6|Android 2.1|Android 2.2|Android 2.3|Android 2.3.3&chco=add274,9dd14f,8ece2a,7ab61c,659b11,507d08" /> +src="http://chart.apis.google.com/chart?&cht=lc&chs=660x250&chxt=x,x,y,r&chxr=0,0,12|1,0,12|2,0,100|3,0,100&chxl=0%3A%7C01/01%7C01/15%7C02/01%7C02/15%7C03/01%7C03/15%7C04/01%7C04/15%7C05/01%7C05/15%7C06/01%7C06/15%7C07/01%7C1%3A%7C2011%7C%7C%7C%7C%7C%7C%7C%7C%7C%7C%7C%7C2011%7C2%3A%7C0%25%7C25%25%7C50%25%7C75%25%7C100%25%7C3%3A%7C0%25%7C25%25%7C50%25%7C75%25%7C100%25&chxp=0,0,1,2,3,4,5,6,7,8,9,10,11,12&chxtc=0,5&chd=t:100.0,99.9,99.9,99.9,100.0,99.8,99.7,99.6,99.6,99.5,99.4,99.3,99.2|95.2,95.6,96.0,96.3,96.7,96.8,97.0,97.1,97.3,97.5,97.5,97.5,97.7|87.2,88.3,89.7,90.5,91.5,92.0,93.5,93.9,94.3,94.8,95.0,95.2,95.5|51.8,54.3,58.3,59.7,61.5,63.0,66.4,68.0,69.8,71.5,73.9,75.4,77.6|0.4,0.6,0.7,0.8,1.1,1.7,2.5,3.1,4.0,6.1,9.5,13.6,17.8|0.0,0.0,0.0,0.0,0.0,1.0,1.7,2.2,3.0,5.1,8.4,12.6,16.8&chm=b,c3df9b,0,1,0|b,b4db77,1,2,0|tAndroid 2.1,547a19,2,0,15,,t::-5|b,a5db51,2,3,0|tAndroid2.2,3f5e0e,3,0,15,,t::-5|b,96dd28,3,4,0|b,83c916,4,5,0|tAndroid2.3.3,131d02,5,11,15,,t::-5|B,6fad0c,5,6,0&chg=7,25&chdl=Android 1.5|Android 1.6|Android 2.1|Android2.2|Android 2.3|Android 2.3.3&chco=add274,9dd14f,8ece2a,7ab61c,659b11,507d08" /> -<p><em>Last historical dataset collected during two weeks ending on May 2, 2011</em></p> +<p><em>Last historical dataset collected during a 14-day period ending on July 5, 2011</em></p> </div><!-- end dashboard-panel --> diff --git a/docs/html/resources/dashboard/screens.jd b/docs/html/resources/dashboard/screens.jd index bdaae0d..e61e799 100644 --- a/docs/html/resources/dashboard/screens.jd +++ b/docs/html/resources/dashboard/screens.jd @@ -60,7 +60,7 @@ ending on the data collection date noted below.</p> <div class="dashboard-panel"> <img alt="" width="400" height="250" -src="http://chart.googleapis.com/chart?cht=p&chs=400x250&chco=c4df9b,6fad0c&chl=xlarge%20/%20mdpi|large%20/%20mdpi|normal%20/%20hdpi|normal%20/%20ldpi|normal%20/%20mdpi|small%20/%20hdpi&chd=t%3A0.5,2.6,75.5,1.2,17.1,3.2" /> +src="http://chart.googleapis.com/chart?cht=p&chs=400x250&chco=c4df9b,6fad0c&chl=Xlarge%20/%20mdpi|Large%20/%20mdpi|Normal%20/%20hdpi|Normal%20/%20ldpi|Normal%20/%20mdpi|Small%20/%20hdpi&chd=t%3A0.9,2.8,75,1.0,17,3.3" /> <table> <tr> @@ -71,31 +71,31 @@ src="http://chart.googleapis.com/chart?cht=p&chs=400x250&chco=c4df9b,6fad0c&chl= <th scope="col">xhdpi</th> </tr> <tr><th scope="row">small</th> -<td></td> <!-- ldpi --> -<td></td> <!-- mdpi --> -<td>3.2%</td> <!-- hdpi --> -<td></td> <!-- xhdpi --> +<td></td> <!-- small/ldpi --> +<td></td> <!-- small/mdpi --> +<td>3.3%</td> <!-- small/hdpi --> +<td></td> <!-- small/xhdpi --> </tr> <tr><th scope="row">normal</th> -<td>1.2%</td> <!-- ldpi --> -<td>17.1%</td> <!-- mdpi --> -<td>75.5%</td> <!-- hdpi --> -<td></td> <!-- xhdpi --> +<td>1%</td> <!-- normal/ldpi --> +<td>17%</td> <!-- normal/mdpi --> +<td>75%</td> <!-- normal/hdpi --> +<td></td> <!-- normal/xhdpi --> </tr> <tr><th scope="row">large</th> -<td></td> <!-- ldpi --> -<td>2.6%</td> <!-- mdpi --> -<td></td> <!-- hdpi --> -<td></td> <!-- xhdpi --> +<td></td> <!-- large/ldpi --> +<td>2.8%</td> <!-- large/mdpi --> +<td></td> <!-- large/hdpi --> +<td></td> <!-- large/xhdpi --> </tr> <tr><th scope="row">xlarge</th> -<td></td> <!-- ldpi --> -<td>0.5%</td> <!-- mdpi --> -<td></td> <!-- hdpi --> -<td></td> <!-- xhdpi --> +<td></td> <!-- xlarge/ldpi --> +<td>0.9%</td> <!-- xlarge/mdpi --> +<td></td> <!-- xlarge/hdpi --> +<td></td> <!-- xlarge/xhdpi --> </tr> </table> -<p><em>Data collected during a 7-day period ending on May 6, 2011</em></p> +<p><em>Data collected during a 7-day period ending on July 1, 2011</em></p> </div> diff --git a/docs/html/resources/resources-data.js b/docs/html/resources/resources-data.js index 097d004..0fc10bf 100644 --- a/docs/html/resources/resources-data.js +++ b/docs/html/resources/resources-data.js @@ -547,6 +547,16 @@ var ANDROID_RESOURCES = [ } }, { + tags: ['sample', 'new', 'media' ], + path: 'samples/RandomMusicPlayer/index.html', + title: { + en: 'Random Music Player' + }, + description: { + en: 'Demonstrates how to write a multimedia application that plays music from the device and from URLs. It manages media playback from a service and can play music in the background, respecting audio focus changes.' + } + }, + { tags: ['sample', 'new', 'newfeature', 'performance', 'gamedev', 'gl'], path: 'samples/RenderScript/index.html', title: { @@ -716,6 +726,16 @@ var ANDROID_RESOURCES = [ en: 'Binding data to views using XML Adapters examples.' } }, + { + tags: ['sample', 'new', 'accessibility'], + path: 'samples/TtsEngine/index.html', + title: { + en: 'Text To Speech Engine' + }, + description: { + en: 'An example Text To Speech engine written using the android text to speech engine API.' + } + }, ///////////////// /// TUTORIALS /// diff --git a/docs/html/resources/samples/images/randommusicplayer.png b/docs/html/resources/samples/images/randommusicplayer.png Binary files differnew file mode 100644 index 0000000..e16e067 --- /dev/null +++ b/docs/html/resources/samples/images/randommusicplayer.png diff --git a/docs/html/resources/tutorials/views/hello-spinner.jd b/docs/html/resources/tutorials/views/hello-spinner.jd index 7a3a9c3..e9dc20f 100644 --- a/docs/html/resources/tutorials/views/hello-spinner.jd +++ b/docs/html/resources/tutorials/views/hello-spinner.jd @@ -105,7 +105,7 @@ public class MyOnItemSelectedListener implements OnItemSelectedListener { public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) { - Toast.makeText(parent.getContext()), "The planet is " + + Toast.makeText(parent.getContext(), "The planet is " + parent.getItemAtPosition(pos).toString(), Toast.LENGTH_LONG).show(); } diff --git a/docs/html/sdk/android-3.1-highlights.jd b/docs/html/sdk/android-3.1-highlights.jd index 3d132a3..88bc1ee 100644 --- a/docs/html/sdk/android-3.1-highlights.jd +++ b/docs/html/sdk/android-3.1-highlights.jd @@ -143,8 +143,8 @@ point, select, drag, scroll, hover, and other standard actions.</p> <p>To make the platform even better for gaming, Android 3.1 adds support for most PC joysticks and gamepads that are connected over USB or Bluetooth HID.</p> -<p>For example, users can connect Sony Playstation™ 3 and XBox 360™ game -controllers over USB (but not Bluetooth), Logitech Dual Action™ gamepads and +<p>For example, users can connect PlayStation<sup>®</sup>3 and Xbox 360<sup>®</sup> +game controllers over USB (but not Bluetooth), Logitech Dual Action™ gamepads and flight sticks, or a car racing controller. Game controllers that use proprietary networking or pairing are not supported by default, but in general, the platform supports most PC-connectible joysticks and gamepads.</p> diff --git a/docs/html/sdk/eclipse-adt.jd b/docs/html/sdk/eclipse-adt.jd index 935bf63..b4f1b27 100644 --- a/docs/html/sdk/eclipse-adt.jd +++ b/docs/html/sdk/eclipse-adt.jd @@ -1,8 +1,8 @@ page.title=ADT Plugin for Eclipse -adt.zip.version=11.0.0 -adt.zip.download=ADT-11.0.0.zip -adt.zip.bytes=TODO -adt.zip.checksum=TODO +adt.zip.version=12.0.0 +adt.zip.download=ADT-12.0.0.zip +adt.zip.bytes=5651973 +adt.zip.checksum=8ad85d0f3da4a2b8dadfddcc2d66dbcb @jd:body @@ -95,13 +95,64 @@ padding: .25em 1em; </style> - <div class="toggleable opened"> <a href="#" onclick="return toggleDiv(this)"> <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-img" height="9px" width="9px" /> +ADT 12.0.0</a> <em>(June 2011)</em> + <div class="toggleme"> +<dl> + +<dt>Dependencies:</dt> + +<dd>ADT 12.0.0 is designed for use with <a href="{@docRoot}sdk/tools-notes.html">SDK Tools r12</a>. If you haven't +already installed SDK Tools r12 into your SDK, use +the Android SDK and AVD Manager to do so.</dd> + +<dt>Visual Layout Editor:</dt> +<dd> +<ul> + <li>New RelativeLayout drop support with guideline suggestions for + attachments and cycle prevention + (<a href="http://tools.android.com/recent/revampedrelativelayoutsupport">more info</a>).</li> + <li>Resize support in most layouts along with + guideline snapping to the sizes dictated by <code>wrap_content</code> and <code>match_parent</code>. + In LinearLayout, sizes are mapped to weights instead of pixel widths. + (<a href="http://tools.android.com/recent/resizesupport">more info</a>).</li> + <li>Previews of drawables and colors in the resource chooser dialogs + (<a href="http://tools.android.com/recent/imageandcolorpreviews">more info</a>).</li> + <li>Improved error messages and links for rendering errors including + detection of misspelled class names + (<a href="http://tools.android.com/recent/improvedrenderingerrordiagnostics">more info</a>).</li> +</ul> +</dd> + +<dt>Build system</dt> +<dd> +<ul> + <li>A new option lets you disable the packaging step in the automatic + builders. This improves performance when saving files by not + performing a full build, which can take a long time for large projects. + If the option is enabled, the APK is packaged when the + application is deployed to a device or emulator or when the + release APK is exported (<a href="http://tools.android.com/recent/finercontroloveradtbuildprocess">more info</a>).</li> +</ul> +</dd> + +<dt>Bug fixes</dt> +<dd>Many bug fixes are part of this release +(<a href="http://tools.android.com/recent/adt12bugfixroundup">more info</a>).</dd> + +</div> +</div> + + +<div class="toggleable closed"> + <a href="#" onclick="return toggleDiv(this)"> + <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" +width="9px" /> ADT 11.0.0</a> <em>(June 2011)</em> - <dd class="toggleme"> + <div class="toggleme"> <dl> @@ -229,6 +280,9 @@ href="http://tools.android.com/recent">Android Tools Project Site</a>.</p> </div> + + + <div class="toggleable closed"> <a href="#" onclick="return toggleDiv(this)"> <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" diff --git a/docs/html/sdk/index.jd b/docs/html/sdk/index.jd index e7b8fbb..5cf37c1 100644 --- a/docs/html/sdk/index.jd +++ b/docs/html/sdk/index.jd @@ -1,21 +1,21 @@ page.title=Android SDK sdk.redirect=0 -sdk.win_installer=installer_r11-windows.exe -sdk.win_installer_bytes=32883649 -sdk.win_installer_checksum=3dc8a29ae5afed97b40910ef153caa2b +sdk.win_installer=installer_r12-windows.exe +sdk.win_installer_bytes=36531492 +sdk.win_installer_checksum=367f0ed4ecd70aefc290d1f7dcb578ab -sdk.win_download=android-sdk_r11-windows.zip -sdk.win_bytes=32837554 -sdk.win_checksum=0a2c52b8f8d97a4871ce8b3eb38e3072 +sdk.win_download=android-sdk_r12-windows.zip +sdk.win_bytes=36486190 +sdk.win_checksum=8d6c104a34cd2577c5506c55d981aebf -sdk.mac_download=android-sdk_r11-mac_x86.zip -sdk.mac_bytes=28844968 -sdk.mac_checksum=85bed5ed25aea51f6a447a674d637d1e +sdk.mac_download=android-sdk_r12-mac_x86.zip +sdk.mac_bytes=30231118 +sdk.mac_checksum=341544e4572b4b1afab123ab817086e7 -sdk.linux_download=android-sdk_r11-linux_x86.tgz -sdk.linux_bytes=26984929 -sdk.linux_checksum=026c67f82627a3a70efb197ca3360d0a +sdk.linux_download=android-sdk_r12-linux_x86.tgz +sdk.linux_bytes=30034243 +sdk.linux_checksum=f8485275a8dee3d1929936ed538ee99a @jd:body diff --git a/docs/html/sdk/oem-usb.jd b/docs/html/sdk/oem-usb.jd index 27e742a..3c2ba8b 100644 --- a/docs/html/sdk/oem-usb.jd +++ b/docs/html/sdk/oem-usb.jd @@ -80,6 +80,12 @@ href="http://www.kttech.co.kr/cscenter/download05.asp">http://www.kttech.co.kr/c <td><a href="http://www.kyocera-wireless.com/support/phone_drivers.htm">http://www.kyocera-wireless.com/support/phone_drivers.htm</a> </td> </tr> + <tr> + <td>Lenevo</td> + <td><a href="http://developer.lenovomm.com/developer/download.jsp" + >http://developer.lenovomm.com/developer/download.jsp</a> + </td> + </tr> <tr><td>LGE</td> <td><a href="http://www.lg.com/us/mobile-phones/mobile-support/mobile-lg-mobile-phone-support.jsp">http://www.lg.com/us/mobile-phones/mobile-support/mobile-lg-mobile-phone-support.jsp</a></td> </tr><tr><td>Motorola</td> <td><a diff --git a/docs/html/sdk/sdk_toc.cs b/docs/html/sdk/sdk_toc.cs index d02c13d..0607aad 100644 --- a/docs/html/sdk/sdk_toc.cs +++ b/docs/html/sdk/sdk_toc.cs @@ -134,7 +134,7 @@ class="new">new!</span></li> </li> </ul> <ul> - <li><a href="<?cs var:toroot ?>sdk/tools-notes.html">SDK Tools, r11</a> <span + <li><a href="<?cs var:toroot ?>sdk/tools-notes.html">SDK Tools, r12</a> <span class="new">new!</span></li> <li><a href="<?cs var:toroot ?>sdk/win-usb.html">Google USB Driver, r4</a></li> <li><a href="<?cs var:toroot ?>sdk/compatibility-library.html">Compatibility Library, r2</a> <span @@ -153,7 +153,7 @@ class="new">new!</span></li> <span style="display:none" class="zh-TW"></span> </h2> <ul> - <li><a href="<?cs var:toroot ?>sdk/eclipse-adt.html">ADT 11.0.0 + <li><a href="<?cs var:toroot ?>sdk/eclipse-adt.html">ADT 12.0.0 <span style="display:none" class="de"></span> <span style="display:none" class="es"></span> <span style="display:none" class="fr"></span> diff --git a/docs/html/sdk/tools-notes.jd b/docs/html/sdk/tools-notes.jd index 64c8f2a..d4ebf8a 100644 --- a/docs/html/sdk/tools-notes.jd +++ b/docs/html/sdk/tools-notes.jd @@ -62,9 +62,36 @@ padding: .25em 1em; } </style> + <div class="toggleable opened"> <a href="#" onclick="return toggleDiv(this)"> <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-img" height="9px" width="9px" /> +SDK Tools, Revision 12</a> <em>(June 2011)</em> + <div class="toggleme"> + <dl> +<dt>Dependencies:</dt> +<dd> +<p>If you are developing in Eclipse with ADT, note that the SDK Tools r12 is designed for use with +ADT 12.0.0 and later. If you haven't already, we highly recommend updating your <a +href="{@docRoot}sdk/eclipse-adt.html">ADT Plugin</a> to 12.0.0.</p> + +<p>If you are developing outside Eclipse, you must have <a href="http://ant.apache.org/">Apache +Ant</a> 1.8 or later.</p> + +<dt>General notes:</dt> +<dd> + <ul> + <li>The AVD manager and emulator can now use system images + compiled for ARM v7 and x86 CPUs.</li> + </ul> +</dd> +</dl> +</div> +</div> + +<div class="toggleable closed"> + <a href="#" onclick="return toggleDiv(this)"> + <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-img" height="9px" width="9px" /> SDK Tools, Revision 11</a> <em>(May 2011)</em> <div class="toggleme"> <dl> diff --git a/docs/html/search.jd b/docs/html/search.jd index 609ade9..339ce2d 100644 --- a/docs/html/search.jd +++ b/docs/html/search.jd @@ -1,144 +1,140 @@ page.title=Search Results
@jd:body
-<script src="http://www.google.com/jsapi" type="text/javascript"></script> +<script src="http://www.google.com/jsapi" type="text/javascript"></script>
<script src="{@docRoot}assets/jquery-history.js" type="text/javascript"></script>
-<script type="text/javascript"> - var tabIndex = 0; - - google.load('search', '1'); - - function OnLoad() { - document.getElementById("search_autocomplete").style.color = "#000"; - - // create search control - searchControl = new google.search.SearchControl(); - - // use our existing search form and use tabs when multiple searchers are used - drawOptions = new google.search.DrawOptions(); - drawOptions.setDrawMode(google.search.SearchControl.DRAW_MODE_TABBED); - drawOptions.setInput(document.getElementById("search_autocomplete")); - - // configure search result options - searchOptions = new google.search.SearcherOptions(); - searchOptions.setExpandMode(GSearchControl.EXPAND_MODE_OPEN); - - // configure each of the searchers, for each tab - devSiteSearcher = new google.search.WebSearch(); - devSiteSearcher.setUserDefinedLabel("All Developers Site"); - devSiteSearcher.setSiteRestriction("http://developer.android.com/"); - - devGuideSearcher = new google.search.WebSearch(); - devGuideSearcher.setUserDefinedLabel("Dev Guide"); - devGuideSearcher.setSiteRestriction("http://developer.android.com/guide/"); - - referenceSearcher = new google.search.WebSearch(); - referenceSearcher.setUserDefinedLabel("Reference"); - referenceSearcher.setSiteRestriction("http://developer.android.com/reference/"); - - blogSearcher = new google.search.WebSearch(); - blogSearcher.setUserDefinedLabel("Blog"); - blogSearcher.setSiteRestriction("http://android-developers.blogspot.com"); - - groupsSearcher = new google.search.WebSearch(); - groupsSearcher.setUserDefinedLabel("Developer Groups"); - groupsSearcher.setSiteRestriction("001283715400630100512:ggqrtvkztwm"); - - sourceSiteSearcher = new google.search.WebSearch(); - sourceSiteSearcher.setUserDefinedLabel("Android Source"); - sourceSiteSearcher.setSiteRestriction("http://source.android.com"); - - homeSiteSearcher = new google.search.WebSearch(); - homeSiteSearcher.setUserDefinedLabel("Android Home"); - homeSiteSearcher.setSiteRestriction("http://www.android.com"); - - // add each searcher to the search control - searchControl.addSearcher(devSiteSearcher, searchOptions); - searchControl.addSearcher(devGuideSearcher, searchOptions); - searchControl.addSearcher(referenceSearcher, searchOptions); - searchControl.addSearcher(groupsSearcher, searchOptions); - searchControl.addSearcher(sourceSiteSearcher, searchOptions); - searchControl.addSearcher(blogSearcher, searchOptions); - - // configure result options - searchControl.setResultSetSize(google.search.Search.LARGE_RESULTSET); - searchControl.setLinkTarget(google.search.Search.LINK_TARGET_SELF); - searchControl.setTimeoutInterval(google.search.SearchControl.TIMEOUT_LONG); - searchControl.setNoResultsString(google.search.SearchControl.NO_RESULTS_DEFAULT_STRING); - - // upon ajax search, refresh the url and search title - searchControl.setSearchStartingCallback(this, function(control, searcher, query) { - // save the tab index from the hash - tabIndex = location.hash.split("&t=")[1]; - - $("#searchTitle").html("search results for <em>" + escapeHTML(query) + "</em>"); - $.history.add('q=' + query + '&t=' + tabIndex); - openTab(); - }); - - // draw the search results box - searchControl.draw(document.getElementById("leftSearchControl"), drawOptions); - - // get query and execute the search - if (location.hash.indexOf("&t=") != -1) { - searchControl.execute(decodeURI(getQuery(location.hash))); - } - - document.getElementById("search_autocomplete").focus(); - addTabListeners(); - } - // End of OnLoad - - - google.setOnLoadCallback(OnLoad, true); - - // when an event on the browser history occurs (back, forward, load) perform a search - $(window).history(function(e, hash) { - var query = decodeURI(getQuery(hash)); - searchControl.execute(query); - - $("#searchTitle").html("search results for <em>" + escapeHTML(query) + "</em>"); - }); - - // forcefully regain key-up event control (previously jacked by search api) - $("#search_autocomplete").keyup(function(event) { - return search_changed(event, false, '/'); - }); - - // open a tab, specified by its array position - function openTab() { - tabIndex = location.hash.split("&t=")[1]; - - // show the appropriate tab - var tabHeaders = $(".gsc-tabHeader"); - $(tabHeaders[tabIndex]).click(); - } - - // add event listeners to each tab so we can track the browser history - function addTabListeners() { - var tabHeaders = $(".gsc-tabHeader"); - for (var i = 0; i < tabHeaders.length; i++) { - $(tabHeaders[i]).attr("id",i).click(function() { - var tabHeaders = $(".gsc-tabHeader"); +<script type="text/javascript">
+ var tabIndex = 0;
+
+ google.load('search', '1');
+
+ function OnLoad() {
+ document.getElementById("search_autocomplete").style.color = "#000";
+
+ // create search control
+ searchControl = new google.search.SearchControl();
+
+ // use our existing search form and use tabs when multiple searchers are used
+ drawOptions = new google.search.DrawOptions();
+ drawOptions.setDrawMode(google.search.SearchControl.DRAW_MODE_TABBED);
+ drawOptions.setInput(document.getElementById("search_autocomplete"));
+
+ // configure search result options
+ searchOptions = new google.search.SearcherOptions();
+ searchOptions.setExpandMode(GSearchControl.EXPAND_MODE_OPEN);
+
+ // configure each of the searchers, for each tab
+ devSiteSearcher = new google.search.WebSearch();
+ devSiteSearcher.setUserDefinedLabel("All");
+ devSiteSearcher.setSiteRestriction("001482626316274216503:zu90b7s047u");
+
+ devGuideSearcher = new google.search.WebSearch();
+ devGuideSearcher.setUserDefinedLabel("Dev Guide");
+ devGuideSearcher.setSiteRestriction("http://developer.android.com/guide/");
+
+ referenceSearcher = new google.search.WebSearch();
+ referenceSearcher.setUserDefinedLabel("Reference");
+ referenceSearcher.setSiteRestriction("http://developer.android.com/reference/");
+
+ blogSearcher = new google.search.WebSearch();
+ blogSearcher.setUserDefinedLabel("Blog");
+ blogSearcher.setSiteRestriction("http://android-developers.blogspot.com");
+
+ groupsSearcher = new google.search.WebSearch();
+ groupsSearcher.setUserDefinedLabel("Developer Groups");
+ groupsSearcher.setSiteRestriction("001283715400630100512:ggqrtvkztwm");
+
+ sourceSiteSearcher = new google.search.WebSearch();
+ sourceSiteSearcher.setUserDefinedLabel("Android Source");
+ sourceSiteSearcher.setSiteRestriction("http://source.android.com");
+
+ // add each searcher to the search control
+ searchControl.addSearcher(devSiteSearcher, searchOptions);
+ searchControl.addSearcher(devGuideSearcher, searchOptions);
+ searchControl.addSearcher(referenceSearcher, searchOptions);
+ searchControl.addSearcher(groupsSearcher, searchOptions);
+ searchControl.addSearcher(sourceSiteSearcher, searchOptions);
+ searchControl.addSearcher(blogSearcher, searchOptions);
+
+ // configure result options
+ searchControl.setResultSetSize(google.search.Search.LARGE_RESULTSET);
+ searchControl.setLinkTarget(google.search.Search.LINK_TARGET_SELF);
+ searchControl.setTimeoutInterval(google.search.SearchControl.TIMEOUT_LONG);
+ searchControl.setNoResultsString(google.search.SearchControl.NO_RESULTS_DEFAULT_STRING);
+
+ // upon ajax search, refresh the url and search title
+ searchControl.setSearchStartingCallback(this, function(control, searcher, query) {
+ // save the tab index from the hash
+ tabIndex = location.hash.split("&t=")[1];
+
+ $("#searchTitle").html("search results for <em>" + escapeHTML(query) + "</em>");
+ $.history.add('q=' + query + '&t=' + tabIndex);
+ openTab();
+ });
+
+ // draw the search results box
+ searchControl.draw(document.getElementById("leftSearchControl"), drawOptions);
+
+ // get query and execute the search
+ if (location.hash.indexOf("&t=") != -1) {
+ searchControl.execute(decodeURI(getQuery(location.hash)));
+ }
+
+ document.getElementById("search_autocomplete").focus();
+ addTabListeners();
+ }
+ // End of OnLoad
+
+
+ google.setOnLoadCallback(OnLoad, true);
+
+ // when an event on the browser history occurs (back, forward, load) perform a search
+ $(window).history(function(e, hash) {
+ var query = decodeURI(getQuery(hash));
+ searchControl.execute(query);
+
+ $("#searchTitle").html("search results for <em>" + escapeHTML(query) + "</em>");
+ });
+
+ // forcefully regain key-up event control (previously jacked by search api)
+ $("#search_autocomplete").keyup(function(event) {
+ return search_changed(event, false, '/');
+ });
+
+ // open a tab, specified by its array position
+ function openTab() {
+ tabIndex = location.hash.split("&t=")[1];
+
+ // show the appropriate tab
+ var tabHeaders = $(".gsc-tabHeader");
+ $(tabHeaders[tabIndex]).click();
+ }
+
+ // add event listeners to each tab so we can track the browser history
+ function addTabListeners() {
+ var tabHeaders = $(".gsc-tabHeader");
+ for (var i = 0; i < tabHeaders.length; i++) {
+ $(tabHeaders[i]).attr("id",i).click(function() {
+ var tabHeaders = $(".gsc-tabHeader");
var tabIndex = $(this).attr("id");
- $.history.add('q=' + getQuery(location.hash) + '&t=' + tabIndex); // update the hash with the new tab - }); - } - } - + $.history.add('q=' + getQuery(location.hash) + '&t=' + tabIndex); // update the hash with the new tab
+ });
+ }
+ }
+
function getQuery(hash) {
- var hashParts = hash.split('&t='); - var queryParts = hashParts[0].split('='); - return queryParts[1]; - } - - /* returns the given string with all HTML brackets converted to entities - TODO: move this to the site's JS library */ - function escapeHTML(string) { - return string.replace(/</g,"<") - .replace(/>/g,">"); - } - + var hashParts = hash.split('&t=');
+ var queryParts = hashParts[0].split('=');
+ return queryParts[1];
+ }
+
+ /* returns the given string with all HTML brackets converted to entities
+ TODO: move this to the site's JS library */
+ function escapeHTML(string) {
+ return string.replace(/</g,"<")
+ .replace(/>/g,">");
+ }
+
</script>
<div id="mainBodyFixed" style="width:auto; margin:20px">
|
