page.title=Cómo determinar y controlar el tipo de conector y el estado de la conexión
parent.title=Cómo optimizar la duración de la batería
parent.link=index.html

trainingnavtop=true
previous.title=Cómo controlar el nivel de batería y el estado de carga
previous.link=battery-monitoring.html
next.title=Cómo determinar y controlar el estado de la conectividad
next.link=connectivity-monitoring.html

@jd:body

<div id="tb-wrapper"> 
<div id="tb">

<h2>En esta sección puedes aprender:</h2>
<ol>
  <li><a href="#CurrentDockState">Cómo solicitar el foco de audio</a></li>
  <li><a href="#DockType">Cómo determinar el tipo de conector actual</a></li>
  <li><a href="#MonitorDockState">Cómo supervisar los cambios en el tipo de conector o en el estado del mismo</a></li>
</ol>


<h2>También puedes consultar:</h2>
<ul>
  <li><a href="{@docRoot}guide/components/intents-filters.html">Intentos y filtros de intentos</a>
</ul>

</div> 
</div>

<p>Los dispositivos Android se pueden conectar a distintos tipos de conectores. Por ejemplo, se puede utilizar conectores para coche o domésticos y tanto digitales como analógicos. Normalmente, el estado del conector está vinculado al estado de carga, ya que muchos conectores cargan el dispositivo mientras está conectado.</p>

<p>El modo en el que el estado del conector del teléfono afecta a la frecuencia de actualización depende de tu aplicación. Puedes aumentar la frecuencia de actualización de una aplicación sobre noticias cuando el dispositivo esté conectado a un conector de escritorio o inhabilitar las actualizaciones completamente si está conectado a un conector de coche. Por el contrario, puedes maximizar las actualizaciones si el dispositivo está conectado a un conector de coche y tu servicio en segundo plano se actualiza con el estado del tráfico.</p>

<p>El estado del conector se emite también como un {@link android.content.Intent} persistente, lo que te permite consultar si el dispositivo está conectado o no y, si lo está, determinar el tipo de conector.</p>


<h2 id="CurrentDockState">Cómo determinar el estado de conexión actual</h2> 
 
<p>La información sobre el estado del conector se incluye como información adicional en una emisión persistente de la acción {@link android.content.Intent#ACTION_DOCK_EVENT}. Por ello, no es necesario registrar un {@link android.content.BroadcastReceiver}. Solo tienes que ejecutar {@link android.content.Context#registerReceiver registerReceiver()} transmitiendo {@code null} como el receptor de emisión, como se muestra en el fragmento de código que aparece a continuación.</p>

<pre>IntentFilter ifilter = new IntentFilter(Intent.ACTION_DOCK_EVENT);
Intent dockStatus = context.registerReceiver(null, ifilter);</pre>

<p>Puedes extraer el estado actual de la conexión de la información adicional de {@code EXTRA_DOCK_STATE}:<p>

<pre>int dockState = battery.getIntExtra(EXTRA_DOCK_STATE, -1);
boolean isDocked = dockState != Intent.EXTRA_DOCK_STATE_UNDOCKED;</pre>


<h2 id="DockType">Cómo determinar el tipo de conector actual</h2> 

<p>Si un dispositivo está insertado en un conector, se puede conectar a cualquiera de estos cuatro tipos de conectores: 
<ul><li>coche,</li>
<li>escritorio,</li>
<li>escritorio de gama baja (analógico),</li>
<li>escritorio de gama alta (digital).</li></ul></p>

<p>Ten en cuenta que las últimas dos opciones se introdujeron en Android únicamente en el nivel 11 del API. Por ello, te recomendamos que compruebes las tres opciones solo cuando te interese más el tipo de conector que si se trata de un conector digital o analógico:</p>

<pre>boolean isCar = dockState == EXTRA_DOCK_STATE_CAR;
boolean isDesk = dockState == EXTRA_DOCK_STATE_DESK || 
                 dockState == EXTRA_DOCK_STATE_LE_DESK ||
                 dockState == EXTRA_DOCK_STATE_HE_DESK;</pre>


<h2 id="MonitorDockState">Cómo supervisar los cambios en el tipo de conector o en el estado del mismo</h2> 

<p>Cuando el dispositivo está conectado a un conector o desconectado del mismo, se emite la acción {@link android.content.Intent#ACTION_DOCK_EVENT}. Para controlar los cambios que se produzcan en el estado del conector del dispositivo, solo tienes que registrar un receptor de emisión en el archivo de manifiesto de la aplicación, como se muestra en el fragmento que aparece a continuación:</p>

<pre>&lt;action android:name="android.intent.action.ACTION_DOCK_EVENT"/></pre>

<p>Puedes extraer el estado y el tipo de conector en la implementación del receptor con las mismas técnicas que se han descrito en el paso anterior.</p>
