page.title=Accessories for Android
@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.
-->
<p>Using a suite of standard protocols, you can implement compelling accessories
that extend Android capabilities in a wide range of Android-powered devices.
</p>

<div class="layout-content-row">

  <div class="layout-content-col span-6">
        <h4 id="audio-accessories">Audio Accessories</h4>
        <p>Android supports local on-device audio and remote off-device audio
        over a wired 3.5 mm headset jack, USB connection, or Bluetooth.
        Manufacturers should see the <a
        href="headset/index.html">headset
        specifications</a>, while users can learn how to <a
        href="https://support.google.com/nexus/answer/6127700">record and play
        back audio using USB host mode</a>.</p>
        <p><a href="audio.html">&raquo; Audio Accessories</a></p>
  </div>

  <div class="layout-content-col span-6">
        <h4 id="custom-accessories">Custom Accessories</h4>
        <p>What do you want to connect to your Android device? Alarm clock?
        Keyboard? Thermostat? Robot? Learn how to connect existing equipment or
        your own unique hardware to Android using the Android Open Accessory
        (AOA) protocol.</p>
        <p><a href="custom.html">&raquo; Custom Accessories</a></p>
 </div>

</div>
