page.title=Building Audio Accessories
@jd:body

<!--
    Copyright 2015 The Android Open Source Project

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->
<div id="qv-wrapper">
  <div id="qv">
    <h2>In this document</h2>
    <ol id="auto-toc">
    </ol>
  </div>
</div>

<p>When implementing an audio accessory such as a headset, headphone amplifier,
microphone, DAC/ADC, or dock, consider how the accessory connects to Android
devices. The following sections describe wired 3.5 mm headset connections,
Universal Serial Bus (USB) connections, and Bluetooth connections for streaming
music or other audio content.</p>

<h2 id="audio-over-35mm">Audio over 3.5 mm headset connector</h2>
<p>Many Android devices include a 3.5 mm (&#8220;mini&#8221;) headset connector.
In addition to traditional stereo output and mono input features, the
<a href="headset/plug-headset-spec.html">3.5 mm headset specification</a>
defines standard impedances and functions that enable interoperability between
a range of Android devices and headsets.</p>

<h2 id="audio-over-usb">Audio over USB</h2>
<p>Android can use USB in several modes:</p>
  <ul>
    <li><strong>Development</strong>. Does not support audio. </li>
    <li><strong>Accessory</strong>. Provided by Android Open Accessory (AOA) 2.0
    and provides limited audio capability, as described in
    <a href="custom.html#audio-over-usb">Connecting custom audio over USB</a>.
    </li>
    <li><strong>Host</strong>. Enables the Android device to drive the USB bus
    and operate with a wide range of USB-based peripherals, including audio
    interfaces. Devices that implement host mode will be compatible with USB
    headsets that follow the
    <a href="{@docRoot}devices/accessories/headset/usb-headset-spec.html">USB
    headset specification</a>.
     Host mode audio is described in
    <a href="{@docRoot}devices/audio/usb.html">USB Digital Audio</a>.
  </ul>

<h2 id="audio-over-bluetooth">Audio over Bluetooth</h2>
<p>An accessory that connects with Android over Bluetooth can use an Advanced
Audio Distribution Profile (A2DP) connection to stream music for playback. Playing
audio over Bluetooth with A2DP is supported on Android 1.5 (API Level 3) and
higher. An Android user can connect to an accessory that supports this profile
using the system Settings &gt; Bluetooth and play music directly to the
accessory without a secondary application.</p>

<p>As of Android 3.0 (API Level 11), applications can operate an A2DP connection
using the
<a href="http://developer.android.com/reference/android/bluetooth/BluetoothA2dp.html">
<code>BluetoothA2dp</code></a> class. To provide a custom application for
output to an audio accessory, you must use Android 3.0 or higher.
</p>

<h3 id="next-steps_1">Next steps</h3>
<p>To get started building an audio accessory that uses a Bluetooth connection:
</p>
<ul>
<li>Select a hardware platform or build a hardware device that can support
Bluetooth communications and the A2DP connection profile.</li>
<li>Review the ADK 2012
  <a href="http://developer.android.com/tools/adk/adk2.html#src-download">firmware
  source code</a> (<code>&lt;adk-src&gt;/adk2012/board/library/ADK2/</code>),
  which includes an example implementation of an audio playback accessory using
  a Bluetooth connection.</li>
</ul>

<p class="note"><strong>Note:</strong> The ADK 2012 source code includes an open
source Bluetooth stack built for the Texas Instruments CC2564 chip, but is
designed to work with any Bluetooth chip that implements a standard
Host/Controller Interface (HCI).</p>

<h2 id="midi-over-usb">MIDI over USB and Bluetooth LE</h2>
<p>Both USB and Bluetooth Low Energy can be used as transports for the
<a href="http://en.wikipedia.org/wiki/MIDI">MIDI</a> protocol. For details, see
<a href="{@docRoot}devices/audio/midi.html">MIDI</a>.</p>
