Se usó la API de Cloud Translation para traducir esta página.

API de Android 3.0

Nivel de API: 11

Para los desarrolladores, la plataforma de Android 3.0 (HONEYCOMB) está disponible como componente descargable del SDK de Android. La plataforma descargable incluye una biblioteca de Android, una imagen del sistema, un conjunto de máscaras de emulador y mucho más. La plataforma descargable no incluye bibliotecas externas.

Para los desarrolladores, la plataforma Android 3.0 está disponible como componente descargable del SDK de Android. La plataforma descargable incluye una biblioteca de Android, una imagen del sistema, un conjunto de máscaras de emulador y mucho más. Para comenzar a desarrollar o probar con Android 3.0, usa el SDK Manager de Android para descargar la plataforma en tu SDK.

Descripción general de la API

En las siguientes secciones, se proporciona una descripción general técnica de las novedades para desarrolladores de Android 3.0, que incluyen las nuevas funciones y los cambios en la API de framework desde la versión anterior.

Fragmentos

Un fragmento es un nuevo componente de framework que te permite separar distintos elementos de una actividad en módulos independientes que definen su propia IU y ciclo de vida. Para crear un fragmento, debes extender la clase Fragment e implementar varios métodos de devolución de llamada de ciclo de vida, similares a Activity. Luego, puedes combinar varios fragmentos en una sola actividad para compilar una IU de varios paneles en la que cada uno administre su propio ciclo de vida y las entradas del usuario.

También puedes usar un fragmento sin proporcionar una IU y, en su lugar, utilizar el fragmento como trabajador de la actividad (por ejemplo, para administrar el progreso de una descarga que se produce solo mientras se ejecuta la actividad).

Además:

Los fragmentos son independientes y puedes volver a usarlos en varias actividades
Puedes agregar, quitar, reemplazar y animar fragmentos dentro de la actividad
Puedes agregar fragmentos a una pila de actividades administrada por la actividad y conservar el estado de los fragmentos a medida que se modifican y permitir que el usuario navegue hacia atrás por los diferentes estados.
Si proporcionas diseños alternativos, podrás mezclar y combinar fragmentos según el tamaño y la orientación de la pantalla.
Los fragmentos tienen acceso directo a su actividad de contenedor y pueden contribuir con elementos a la barra de acciones de la actividad (se explica a continuación).

Para administrar los fragmentos de tu actividad, debes usar FragmentManager, que proporciona varias APIs para interactuar con fragmentos, como encontrar fragmentos en la actividad y quitar fragmentos de la pila de actividades para restablecer su estado anterior.

Para realizar una transacción, como agregar o quitar un fragmento, debes crear un FragmentTransaction. Luego, puedes llamar a métodos como add() remove() o replace(). Una vez que hayas aplicado todos los cambios que quieras realizar en la transacción, debes llamar a commit(), y el sistema aplicará la transacción del fragmento a la actividad.

Para obtener más información sobre el uso de fragmentos, consulta la documentación de Fragmentos. También hay varios ejemplos disponibles en la aplicación de demostraciones de la API.

Barra de acciones

La barra de acciones reemplaza la barra de título tradicional en la parte superior de la ventana de actividades. Incluye el logotipo de la aplicación en la esquina izquierda y proporciona una nueva interfaz para los elementos del Menú de opciones. Además, la barra de acciones te permite hacer lo siguiente:

Agregar elementos de menú directamente en la barra de acciones como "elementos de acción".
En tu declaración XML para el elemento de menú, incluye el atributo android:showAsAction con un valor de "ifRoom". Cuando haya suficiente espacio, el elemento del menú aparecerá directamente en la barra de acciones. De lo contrario, el elemento se coloca en el menú ampliado, que se revela a través del ícono de menú a la derecha de la barra de acciones.
Reemplazar un elemento de acción por un widget (como un cuadro de búsqueda), es decir, crear una "vista de acción".
En la declaración XML del elemento de menú, agrega el atributo android:actionViewLayout con un recurso de diseño o el atributo android:actionViewClass con el nombre de clase de un widget. (También debes declarar el atributo android:showAsAction para que el elemento aparezca en la barra de acciones). Si no hay suficiente espacio en la barra de acciones y el elemento aparece en el menú ampliado, se comporta como un elemento de menú normal y no muestra el widget.
Agrega una acción al logotipo de la aplicación y reemplázalo por un logotipo personalizado
Al logotipo de la aplicación se le asigna automáticamente el ID de android.R.id.home, que el sistema entrega a la devolución de llamada de onOptionsItemSelected() de tu actividad cuando se toca. Simplemente responde a este ID en tu método de devolución de llamada para realizar una acción, como ir a la actividad "inicio" de tu aplicación.

Para reemplazar el ícono por un logotipo, especifica el logotipo de tu aplicación en el archivo de manifiesto con el atributo android:logo y, luego, llama a setDisplayUseLogoEnabled(true) en tu actividad.
Agrega rutas de navegación para navegar hacia atrás por la pila de actividades de fragmentos
Agrega pestañas o una lista desplegable para navegar por los fragmentos
Personaliza la barra de acciones con temas y fondos

La barra de acciones es estándar para todas las aplicaciones que usan el nuevo tema holográfico, que también es estándar cuando configuras la android:minSdkVersion o la android:targetSdkVersion en "11".

Para obtener más información sobre la barra de acciones, consulta la documentación sobre la barra de acciones. También hay varios ejemplos disponibles en la aplicación de demostraciones de la API.

Portapapeles del sistema

Las aplicaciones ahora pueden copiar y pegar datos (más allá del mero texto) desde y hacia el portapapeles de todo el sistema. Los datos recortados pueden ser texto sin formato, un URI o un intent.

Si le brindas al sistema acceso a los datos que quieres que el usuario copie, a través de un proveedor de contenido, el usuario podrá copiar contenido complejo (como una imagen o una estructura de datos) desde tu aplicación y pegarlo en otra aplicación que admita ese tipo de contenido.

Para comenzar a usar el portapapeles, llama a getSystemService(CLIPBOARD_SERVICE) para obtener el objeto ClipboardManager global.

Para copiar un elemento en el portapapeles, debes crear un objeto ClipData nuevo, que contenga uno o más objetos ClipData.Item, y cada uno describa una sola entidad. Para crear un objeto ClipData que contenga solo un ClipData.Item, puedes usar uno de los métodos auxiliares, como newPlainText(), newUri() y newIntent(), que muestran un objeto ClipData precargado con la ClipData.Item que proporcionas.

Para agregar el ClipData al portapapeles, pásalo a setPrimaryClip() para tu instancia de ClipboardManager.

Luego, puedes leer un archivo desde el portapapeles (para pegarlo) llamando a getPrimaryClip() en ClipboardManager. Manejar el ClipData que recibes puede ser complicado, y debes asegurarte de poder controlar el tipo de datos en el portapapeles antes de intentar pegarlos.

El portapapeles contiene solo una porción de datos recortados (un objeto ClipData) a la vez, pero un ClipData puede contener varios ClipData.Item.

Para obtener más información, lee la documentación sobre Copiar y pegar. También puedes ver una implementación simple de la función de copiar y pegar en la muestra de demostraciones de la API y una implementación más completa en la muestra de bloc de notas.

Arrastrar y soltar

Las nuevas API simplifican las operaciones de arrastrar y soltar en la interfaz de usuario de tu aplicación. Una operación de arrastre es la transferencia de algún tipo de datos, que se lleva a cabo en un objeto ClipData, de un lugar a otro. El punto de inicio y finalización de la operación de arrastre es un View, por lo que las APIs que controlan directamente las operaciones de arrastrar y soltar están en la clase View.

Una operación de arrastrar y soltar tiene un ciclo de vida definido por varias acciones de arrastre, cada una definida por un objeto DragEvent, como ACTION_DRAG_STARTED, ACTION_DRAG_ENTERED y ACTION_DROP. Cada vista que desea participar en una operación de arrastre puede escuchar estas acciones.

Para comenzar a arrastrar contenido en tu actividad, llama a startDrag() en un View y proporciona un objeto ClipData que represente los datos que se arrastrarán, un View.DragShadowBuilder para facilitar la "sombra" que los usuarios ven debajo de sus dedos mientras arrastran y un Object que pueda compartir información sobre el objeto de arrastre con vistas que podrían recibir el objeto.

Para aceptar un objeto de arrastre en una View (recibir la "soltar"), llama a setOnDragListener() para registrar la vista con un OnDragListener. Cuando se produce un evento de arrastre en la vista, el sistema llama a onDrag() para OnDragListener, que recibe un DragEvent que describe el tipo de acción de arrastre que se produjo (como ACTION_DRAG_STARTED, ACTION_DRAG_ENTERED y ACTION_DROP). Durante un arrastre, el sistema llama repetidamente a onDrag() para la vista debajo del arrastre a fin de enviar una transmisión de eventos de arrastre. La vista receptora puede consultar el tipo de evento entregado a onDragEvent() llamando a getAction() en DragEvent.

Nota: Si bien un evento de arrastre puede llevar un objeto ClipData, no está relacionado con el portapapeles del sistema. Una operación de arrastrar y soltar nunca debe colocar los datos arrastrados en el portapapeles del sistema.

Para obtener más información, consulta la documentación Cómo arrastrar y soltar. También puedes ver una implementación de la función de arrastrar y soltar en la aplicación de demostraciones de API y la aplicación de la galería de Honeycomb.

Widgets de apps

Android 3.0 admite varias clases nuevas de widgets para widgets de apps más interactivos en la pantalla principal de los usuarios, como GridView, ListView, StackView, ViewFlipper y AdapterViewFlipper.

Lo más importante es que puedes usar el nuevo RemoteViewsService para crear widgets de apps con colecciones mediante widgets (como GridView, ListView y StackView) respaldados por datos remotos, como los de un proveedor de contenido.

La clase AppWidgetProviderInfo (definida en XML con un elemento <appwidget-provider>) también admite dos campos nuevos: autoAdvanceViewId y previewImage. El campo autoAdvanceViewId te permite especificar el ID de vista de la subvista del widget de la app que el host del widget de la app debe avanzar automáticamente. El campo previewImage especifica una vista previa de cómo se ve el widget de la app y se le muestra al usuario desde el selector de widgets. Si no se proporciona este campo, se usa el ícono del widget de la app para la vista previa.

A fin de ayudar a crear una imagen de vista previa para el widget de tu app (para especificar en el campo previewImage), el emulador de Android incluye una aplicación llamada "Widget Preview". Para crear una imagen de vista previa, inicia esta aplicación, selecciona el widget de tu aplicación y configura cómo deseas que aparezca la imagen de vista previa. Luego, guárdala y colócala en los recursos de elementos de diseño de la aplicación.

Puedes ver la implementación de las nuevas funciones del widget de la app en las aplicaciones del widget de la app de StackView y del widget de la lista de clima.

Notificaciones de la barra de estado

Las APIs de Notification se ampliaron para admitir más notificaciones de la barra de estado con mucho contenido, y una nueva clase Notification.Builder te permite crear objetos Notification con facilidad.

Las nuevas funciones incluyen las siguientes:

Compatibilidad con un ícono grande en la notificación mediante setLargeIcon(). Por lo general, las aplicaciones sociales muestran la foto de contacto de la persona que es la fuente de la notificación o las apps de redes sociales muestran la miniatura de un álbum.
Compatibilidad con diseños personalizados en el visor de la barra de estado mediante setTicker()
Se agregó compatibilidad con diseños de notificaciones personalizados para incluir botones con PendingIntent a fin de obtener widgets de notificación más interactivos. Por ejemplo, una notificación puede controlar la reproducción de música sin iniciar una actividad.

Cargadores de contenido

Las nuevas APIs de framework facilitan la carga asíncrona de datos a través de la clase Loader. Puedes usarla junto con los componentes de la IU, como vistas y fragmentos, para cargar datos de forma dinámica desde los subprocesos de trabajo. La subclase CursorLoader está diseñada especialmente para ayudarte a hacerlo con datos respaldados por un ContentProvider.

Lo único que debes hacer es implementar la interfaz LoaderCallbacks para recibir devoluciones de llamada cuando se solicite un cargador nuevo o cuando los datos cambien y, luego, llama a initLoader() para inicializar el cargador de tu actividad o fragmento.

Para obtener más información, consulta la documentación sobre cargadores. También puedes ver ejemplos de código con cargadores en las muestras de LoaderCursor y LoaderThrottle.

A2DP de Bluetooth y APIs de auriculares

Android ahora incluye APIs para que las aplicaciones verifiquen el estado de los dispositivos con perfiles de auriculares y A2DP Bluetooth conectados. Por ejemplo, las aplicaciones pueden identificar cuándo se conectan auriculares Bluetooth para escuchar música y notificar al usuario según corresponda. Las aplicaciones también pueden recibir transmisiones de comandos de AT específicos del proveedor y notificar al usuario sobre el estado del dispositivo conectado, como cuando la batería del dispositivo está baja.

Puedes inicializar el BluetoothProfile respectivo llamando a getProfileProxy() con la constante de perfil A2DP o HEADSET y un BluetoothProfile.ServiceListener para recibir devoluciones de llamada cuando el cliente Bluetooth esté conectado o desconectado.

Framework de animación

Con el nuevo framework de animación flexible, puedes animar propiedades arbitrarias de cualquier objeto (vista, elemento de diseño, fragmento, objeto o cualquier otra cosa). Te permite definir varios aspectos de una animación, como los siguientes:

Duración
Importe y comportamiento de repetición
Tipo de interpolación de tiempo
Conjuntos de animaciones para reproducir animaciones juntas, secuencialmente o después de retrasos específicos
Retraso de la actualización de fotogramas

Puedes definir estos aspectos de animación, entre otros, para los valores de color int, flotante y hexadecimales de un objeto, de forma predeterminada. Es decir, cuando un objeto tiene un campo de propiedad para uno de estos tipos, puedes cambiar su valor con el tiempo para afectar una animación. Para animar cualquier otro tipo de valor, debes indicarle al sistema cómo calcular los valores para ese tipo determinado mediante la implementación de la interfaz TypeEvaluator.

Hay dos animadores que puedes usar para animar los valores de una propiedad: ValueAnimator y ObjectAnimator. ValueAnimator calcula los valores de animación, pero no conoce la propiedad o el objeto específico que se anima como resultado. Solo realiza los cálculos, y tú debes escuchar las actualizaciones y procesar los datos con tu propia lógica. ObjectAnimator es una subclase de ValueAnimator, que te permite configurar el objeto y la propiedad para animar, y controla todo el trabajo de animación. Es decir, le das a ObjectAnimator el objeto que quieres animar, la propiedad del objeto que cambiará con el tiempo y un conjunto de valores para aplicar a la propiedad en el tiempo y, luego, inicias la animación.

Además, la clase LayoutTransition habilita animaciones de transición automáticas para los cambios que realices en el diseño de tu actividad. Para habilitar las transiciones en una parte del diseño, crea un objeto LayoutTransition y establécelo en cualquier ViewGroup llamando a setLayoutTransition(). Esto hace que se ejecuten animaciones predeterminadas cada vez que se agreguen elementos al grupo o se quiten de él. Para especificar animaciones personalizadas, llama a setAnimator() en LayoutTransition y proporciona un Animator personalizado, como ValueAnimator o ObjectAnimator, que se mencionaron anteriormente.

Para obtener más información, consulta la documentación sobre Animación de propiedades. También puedes ver varios ejemplos usando las APIs de Animation en la aplicación API Demos.

Framework de IU extendido

Selección de opción múltiple para ListView y GridView
El nuevo modo CHOICE_MODE_MULTIPLE_MODAL para setChoiceMode() permite a los usuarios seleccionar varios elementos de ListView o GridView. Cuando se usan en conjunto con la barra de acciones, los usuarios pueden seleccionar varios elementos y, luego, seleccionar la acción que desean realizar de una lista de opciones en la barra de acciones (que se transformó en un modo de acción de opción múltiple).

Para habilitar la selección de opción múltiple, llama a setChoiceMode(CHOICE_MODE_MULTIPLE_MODAL) y registra un MultiChoiceModeListener con setMultiChoiceModeListener().

Cuando el usuario mantiene presionado un elemento, la barra de acciones cambia al modo de acción de opción múltiple. El sistema notifica a MultiChoiceModeListener cuando se seleccionan elementos llamando a onItemCheckedStateChanged().

Para ver un ejemplo de selección múltiple, consulta la clase List15.java en la aplicación de ejemplo API Demos.
Nuevas APIs para transformar vistas
Las nuevas APIs te permiten aplicar fácilmente transformaciones en 2D y 3D a las vistas del diseño de tu actividad. Las transformaciones nuevas son posibles con un conjunto de propiedades del objeto que definen la posición del diseño, la orientación, la transparencia y otras opciones de la vista.

Entre los métodos nuevos para establecer las propiedades de la vista, se incluyen los siguientes: setAlpha(), setBottom(), setLeft(), setRight(), setBottom(), setPivotX(), setPivotY(), setRotationX(), setRotationY(), setScaleX(), setScaleY(), setAlpha(), entre otros.

Algunos métodos también tienen un atributo XML correspondiente que puedes especificar en tu archivo de diseño para aplicar una transformación predeterminada. Entre los atributos disponibles, se incluyen translationX, translationY, rotation, rotationX, rotationY, scaleX, scaleY, transformPivotX, transformPivotY y alpha.

Si combinas algunas de estas propiedades de vista con el nuevo marco de animación (descrito anteriormente), puedes aplicar fácilmente algunas animaciones elegantes a tus vistas. Por ejemplo, para rotar una vista en su eje Y, proporciona a ObjectAnimator el View, la propiedad "rotationY" y los valores de inicio y fin:
Kotlin
```
ObjectAnimator.ofFloat(myView, "rotationY", 0f, 360f).apply {
    duration = 2000
    start()
}
```
Java
```
ObjectAnimator animator = ObjectAnimator.ofFloat(myView, "rotationY", 0, 360);
animator.setDuration(2000);
animator.start();
```
Nuevos temas holográficos
Se rediseñaron los widgets estándar del sistema y el aspecto general y, además, incorporan un nuevo tema "holográfico" de la interfaz de usuario. El sistema aplica el tema nuevo con el sistema estándar de estilo y temas.

Cualquier aplicación que se oriente a la plataforma de Android 3.0 (estableciendo el valor android:minSdkVersion o android:targetSdkVersion en "11") hereda el tema holográfico de forma predeterminada. Sin embargo, si tu aplicación también aplica su propio tema, este anulará el tema holográfico, a menos que actualices tus estilos para heredar este tema.

Para aplicar el tema holográfico a actividades individuales o para heredarlas en tus propias definiciones de temas, usa uno de varios temas Theme.Holo nuevos. Si tu aplicación es compatible con una versión de Android anterior a la 3.0 y aplica temas personalizados, debes seleccionar un tema según la versión de la plataforma.
Widgets nuevos
- AdapterViewAnimator
  Es la clase base para un AdapterView que realiza animaciones cuando se alterna entre sus vistas.
- AdapterViewFlipper
  ViewAnimator simple que anima entre dos o más vistas que se le agregaron. Solo se muestra un elemento secundario a la vez. Si se solicita, puede alternar automáticamente entre cada elemento secundario a intervalos regulares.
- CalendarView
  Permite a los usuarios seleccionar fechas de un calendario cuando la tocan y pueden desplazarse o lanzar el calendario hasta una fecha deseada. Puedes configurar el rango de fechas disponibles en el widget.
- ListPopupWindow
  Se ancla a una vista del host y muestra una lista de opciones, por ejemplo, para una lista de sugerencias cuando se escribe en una vista EditText.
- NumberPicker
  Permite que el usuario seleccione un número de un rango predefinido. El widget presenta un campo de entrada y botones de arriba y abajo para seleccionar un número. Tocar el campo de entrada le permite al usuario desplazarse por los valores o volver a tocarlo para editar directamente el valor actual. También te permite asignar posiciones a strings, de modo que se muestre la string correspondiente en lugar de la posición del índice.
- PopupMenu
  Muestra un objeto Menu en una ventana emergente modal que está anclada a una vista. La ventana emergente aparece debajo de la vista anclada si hay espacio, o bien encima de ella si no lo hay. Si el IME (teclado en pantalla) está visible, la ventana emergente no se superpone con el IME hasta que el usuario toca el menú.
- SearchView
  Proporciona un cuadro de búsqueda que puedes configurar para que muestre búsquedas en una actividad específica y muestre sugerencias de búsqueda (de la misma manera que el diálogo de búsqueda tradicional). Este widget es particularmente útil para ofrecer un widget de búsqueda en la barra de acciones. Para obtener más información, consulta Cómo crear una interfaz de búsqueda.
- StackView
  Una vista que muestra sus elementos secundarios en una pila 3D y permite a los usuarios deslizar las vistas como un rolodex.

Gráficos

Gráficos 2D acelerados por hardware
Ahora puedes habilitar el procesador de OpenGL para tu aplicación estableciendo android:hardwareAccelerated="true" en el elemento <application> del elemento del manifiesto o para elementos <activity> individuales.

Esta marca ayuda a las aplicaciones, ya que las hace más rápidas. De esta manera, se obtienen animaciones y desplazamientos más fluidos, además de un mejor rendimiento y una mejor respuesta a la interacción del usuario en general.
Consulta la compatibilidad con las capas de hardware y software
De forma predeterminada, un View no tiene ninguna capa especificada. Puedes especificar que la vista esté respaldada por una capa de hardware o software, especificada por los valores LAYER_TYPE_HARDWARE y LAYER_TYPE_SOFTWARE, mediante el atributo setLayerType() o layerType.

Una capa de hardware está respaldada por una textura específica de hardware (por lo general, objetos de búfer de marco o FBO en el hardware de OpenGL) y hace que la vista se renderice mediante la canalización de renderización de hardware de Android, pero solo si la aceleración de hardware está activada para la jerarquía de vistas. Cuando la aceleración de hardware está desactivada, las capas de hardware se comportan exactamente como las capas de software.

Una capa de software está respaldada por un mapa de bits y hace que la vista se renderice mediante la canalización de renderización de software de Android, incluso si la aceleración de hardware está habilitada. Se deben evitar las capas de software cuando el árbol de vistas afectado se actualiza con frecuencia. Para cada actualización, se deberá volver a renderizar la capa de software, lo que puede ser lento.

Para obtener más información, consulta la documentación de LAYER_TYPE_HARDWARE y LAYER_TYPE_SOFTWARE.
Motor de gráficos 3D de Renderscript
Renderscript es un framework 3D en tiempo de ejecución que proporciona una API para compilar escenas 3D y un lenguaje de sombreador especial independiente de la plataforma para obtener el máximo rendimiento. Con Renderscript, puedes acelerar las operaciones gráficas y el procesamiento de datos. Renderscript es una forma ideal de crear efectos 3D de alto rendimiento para aplicaciones, fondos de pantalla, carruseles y mucho más.

Para obtener más información, consulta la documentación de Renderización y procesamiento 3D con RenderScript.

Contenido multimedia

Video en time lapse
Las API de Videocámara ahora admiten la capacidad de grabar videos en time lapse. setCaptureRate() establece la velocidad a la que se deben capturar las tramas.
Compatibilidad con texturas en transmisiones de imágenes
El nuevo SurfaceTexture te permite capturar una transmisión de imágenes como una textura de OpenGL ES. Si llamas a setPreviewTexture() para tu instancia de Camera, puedes especificar el SurfaceTexture en el que se debe dibujar la reproducción de video o la vista previa de fotogramas desde la cámara.
Transmisión en vivo HTTP
Las aplicaciones ahora pueden pasar una URL de lista de reproducción de M3U al framework multimedia para iniciar una sesión de transmisión en vivo HTTP. El framework multimedia admite la mayor parte de la especificación de transmisión en vivo de HTTP, incluida la tasa de bits adaptable. Consulta el documento Formatos de medios compatibles para obtener más información.
Datos EXIF
ExifInterface incluye campos nuevos para la apertura de la foto, la ISO y el tiempo de exposición.
Perfiles de videocámara
El nuevo método hasProfile() y varios perfiles de calidad de video (como QUALITY_1080P, QUALITY_720P, QUALITY_CIF y otros) te permiten determinar las opciones de calidad de la videocámara.
Transferencia de archivos multimedia digitales
La plataforma incluye compatibilidad integrada con el Protocolo de transferencia de contenido multimedia/imagen (MTP/PTP) a través de USB, que permite a los usuarios transferir fácilmente cualquier tipo de archivo multimedia entre dispositivos y a una computadora host. Los desarrolladores pueden aprovechar esta compatibilidad y crear aplicaciones que permitan a los usuarios crear o administrar archivos de rich media que quieran transferir o compartir entre dispositivos.
Administración de derechos digitales (DRM)
Nuevo framework de administración de derechos digitales (DRM) extensible para verificar y aplicar derechos digitales. Se implementa en dos capas de arquitectura:
- Una API del framework de DRM, que se expone a las aplicaciones y se ejecuta a través de la VM Dalvik para aplicaciones estándar.
- Un administrador de DRM de código nativo que implementa la API de framework y expone una interfaz para complementos de DRM a fin de controlar la administración de derechos y la desencriptación para varios esquemas de DRM.
Para los desarrolladores de aplicaciones, el framework ofrece una API abstracta y unificada que simplifica la administración del contenido protegido. La API oculta la complejidad de las operaciones de DRM y permite un modo de operación coherente para el contenido protegido y no protegido, y en una variedad de esquemas de DRM.

Para los fabricantes de dispositivos, los propietarios de contenido y los proveedores de medios digitales de Internet, la API del complemento del framework de DRM proporciona un medio para agregar compatibilidad con un esquema DRM elegido en el sistema Android a fin de aplicar de manera segura la protección del contenido.

La versión preliminar no proporciona ningún complemento DRM nativo para verificar y aplicar derechos digitales. Sin embargo, los fabricantes de dispositivos pueden enviar complementos DRM con sus dispositivos.

Puedes encontrar todas las APIs de DRM en el paquete android.drm.

Compatibilidad con el teclado

Compatibilidad con los modificadores Control, Meta, Bloq Mayús, Bloqueo numérico y Bloqueo de desplazamiento. Para obtener más información, consulta META_CTRL_ON y los campos relacionados.
Compatibilidad con teclados completos tipo escritorio, incluida la compatibilidad con teclas como Escape, Inicio, Fin, Borrar y otras. Para determinar si los eventos de tecla provienen de un teclado completo, consulta getKeyboardType() y comprueba si hay KeyCharacterMap.FULL.
TextView ahora admite cortar, copiar, pegar y seleccionar todo según el teclado mediante las combinaciones de teclas Control + X, Control + C, Control + V y Control + A. También admite PageUp/PageDown, Home/End y la selección de texto basada en el teclado.
KeyEvent agrega varios métodos nuevos para facilitar la verificación del estado del modificador de claves de forma correcta y coherente. Consulta hasModifiers(int), hasNoModifiers(), metaStateHasModifiers() y metaStateHasNoModifiers().
Las aplicaciones pueden implementar combinaciones de teclas personalizadas dividiendo en subclases Activity, Dialog o View e implementando onKeyShortcut(). El framework llama a este método cada vez que se combina una clave con la tecla Control. Cuando creas un menú de opciones, puedes registrar combinaciones de teclas configurando el atributo android:alphabeticShortcut o android:numericShortcut para cada elemento <item> (o con setShortcut()).
Android 3.0 incluye un nuevo dispositivo de "teclado virtual" con el ID KeyCharacterMap.VIRTUAL_KEYBOARD. El teclado virtual tiene un mapa de teclas de EE.UU. similar al de una computadora de escritorio que sirve para sintetizar eventos clave con el objetivo de probar las entradas.

Eventos táctiles divididos

Anteriormente, solo una vista podía aceptar eventos táctiles a la vez. Android 3.0 agrega compatibilidad con la división de eventos táctiles entre vistas y ventanas, de modo que diferentes vistas puedan aceptar eventos táctiles simultáneos.

Los eventos táctiles divididos se habilitan de forma predeterminada cuando una aplicación se orienta a Android 3.0. Es decir, cuando la aplicación establece el valor del atributo android:minSdkVersion o android:targetSdkVersion en "11".

Sin embargo, las siguientes propiedades te permiten inhabilitar los eventos táctiles divididos en vistas dentro de grupos de vistas específicos y entre ventanas.

El atributo android:splitMotionEvents para grupos de vistas te permite inhabilitar los eventos táctiles divididos que se producen entre vistas secundarias en un diseño. Por ejemplo:
```
<LinearLayout android:splitMotionEvents="false" ... >
    ...
</LinearLayout>
```
.
De esta manera, las vistas secundarias en el diseño lineal no pueden dividir los eventos táctiles: solo una vista puede recibir eventos táctiles a la vez.
La propiedad de estilo android:windowEnableSplitTouch te permite inhabilitar los eventos táctiles divididos en diferentes ventanas aplicándolos a un tema para la actividad o toda la aplicación. Por ejemplo:
```
<style name="NoSplitMotionEvents" parent="android:Theme.Holo">
    <item name="android:windowEnableSplitTouch">false</item>
    ...
</style>
```
.
Cuando se aplica este tema a una <activity> o una <application>, solo se aceptan eventos táctiles dentro de la ventana de la actividad actual. Por ejemplo, si inhabilitas los eventos táctiles divididos en distintas ventanas, la barra del sistema no puede recibir eventos táctiles al mismo tiempo que la actividad. Esto no afecta si las vistas dentro de la actividad pueden dividir los eventos táctiles. De forma predeterminada, la actividad puede dividir los eventos táctiles entre las vistas.

Para obtener más información sobre cómo crear un tema, consulta Cómo aplicar estilos y temas.

WebKit

Nueva clase WebViewFragment para crear un fragmento compuesto por un WebView.
Nuevos métodos WebSettings:
- setDisplayZoomControls() te permite ocultar los controles de zoom en pantalla y, al mismo tiempo, permitir al usuario hacer zoom con gestos del dedo (se debe establecer setBuiltInZoomControls() en true).
- El nuevo método WebSettings, setEnableSmoothTransition(), te permite habilitar transiciones fluidas durante el desplazamiento lateral y el zoom. Cuando se habilita, WebView elegirá una solución para maximizar el rendimiento (por ejemplo, es posible que el contenido de WebView no se actualice durante la transición).
Nuevos métodos WebView:
- Devolución de llamada onPause(), para pausar cualquier procesamiento asociado con WebView cuando se oculta Esto es útil para reducir el tráfico innecesario de CPU o de red cuando WebView no está en primer plano.
- Devolución de llamada onResume(), para reanudar el procesamiento asociado con WebView, que se pausó durante onPause()
- saveWebArchive() te permite guardar la vista actual como un archivo web en el dispositivo.
- showFindDialog() inicia una búsqueda de texto en la vista actual.

Navegador

La aplicación Navegador agrega las siguientes funciones para admitir aplicaciones web:

Captura de contenido multimedia
Según se define en la especificación de captura de contenido multimedia HTML, el navegador permite que las aplicaciones web accedan a las capacidades de captura de audio, imagen y video del dispositivo. Por ejemplo, el siguiente código HTML proporciona una entrada para que el usuario tome una foto y la suba:
```
<input type="file" accept="image/*;capture=camera" />
```
O bien, si se excluye el parámetro capture=camera, el usuario puede optar por capturar una imagen nueva con la cámara o seleccionar una del dispositivo (por ejemplo, desde la aplicación de Galería).
Orientación del dispositivo
Según se define en la especificación de Evento de orientación del dispositivo, el navegador permite que las aplicaciones web escuchen eventos del DOM que proporcionan información sobre la orientación física y el movimiento del dispositivo.

La orientación del dispositivo se expresa con los ejes x, y, y z, en grados, y el movimiento se expresa con datos de aceleración y velocidad de rotación. Una página web puede registrarse para recibir eventos de orientación llamando a window.addEventListener con el tipo de evento "deviceorientation" y registrarse para los eventos de movimiento registrando el tipo de evento "devicemotion".
Transformaciones CSS 3D
Según se define en la especificación del Módulo de transformación 3D de CSS, el navegador permite que los elementos renderizados por CSS se transformen en tres dimensiones.

Utilidades JSON

Las clases nuevas, JsonReader y JsonWriter, te ayudan a leer y escribir transmisiones JSON. Las nuevas APIs complementan las clases org.json, que manipulan un documento en la memoria.

Para crear una instancia de JsonReader, llama a su método de constructor y pasa el InputStreamReader que alimenta la cadena JSON. Luego, comienza a leer un objeto llamando a beginObject(), lee un nombre de clave con nextName(), lee el valor con métodos respectivos para el tipo, como nextString() y nextInt(), y continúa haciéndolo mientras hasNext() sea verdadero.

Para crear una instancia de JsonWriter, llama a su constructor y pasa el OutputStreamWriter correspondiente. Luego, escribe los datos JSON de manera similar al lector con name() para agregar un nombre de propiedad y un método de value() apropiado para agregar el valor correspondiente.

Estas clases son estrictas de forma predeterminada. El método setLenient() de cada clase las configura para que sean más liberales en lo que aceptan. Este modo de análisis flexible también es compatible con el analizador predeterminado de org.json.

Nuevas constantes de funciones

El elemento de manfest <uses-feature> se debe usar para informar a entidades externas (como Google Play) sobre el conjunto de funciones de hardware y software de las que depende tu aplicación. En esta versión, Android agrega las siguientes constantes nuevas que las aplicaciones pueden declarar con este elemento:

"android.hardware.faketouch"
Si se declara, esto indica que la aplicación es compatible con un dispositivo que ofrece una pantalla táctil emulada (o mejor). Un dispositivo que ofrece una pantalla táctil emulada proporciona al usuario un sistema de entrada que puede emular un subconjunto de capacidades de pantalla táctil. Un ejemplo de este sistema de entrada es un mouse o un control remoto que controla un cursor en pantalla. Estos sistemas de entrada admiten eventos táctiles básicos, como hacer clic hacia abajo, hacia arriba y arrastrar. Sin embargo, los tipos de entrada más complicados (como gestos, deslizamientos, etc.) pueden ser más difíciles o imposibles en dispositivos falsos (y los gestos multitáctiles definitivamente no son posibles).

Si tu aplicación no requiere gestos complicados y no quieres que se filtre de los dispositivos con una pantalla táctil emulada, debes declarar "android.hardware.faketouch" con un elemento <uses-feature>. De esta manera, tu aplicación estará disponible para la mayor cantidad de tipos de dispositivos, incluidos los que proporcionan solo una entrada de pantalla táctil emulada.

Todos los dispositivos que incluyen una pantalla táctil también admiten "android.hardware.faketouch", porque las capacidades de pantalla táctil son un superconjunto de las capacidades de faketouch. Por lo tanto, a menos que necesites una pantalla táctil, debes agregar un elemento <uses-feature> para el faketouch.

Permisos nuevos

"android.permission.BIND_REMOTEVIEWS"
Se debe declarar como un permiso obligatorio en el elemento <service> del manifiesto para una implementación de RemoteViewsService. Por ejemplo, cuando creas un widget de la app que usa RemoteViewsService para propagar una vista de colección, es posible que la entrada del manifiesto se vea de la siguiente manera:
```
<service android:name=".widget.WidgetService"
    android:exported="false"
    android:permission="android.permission.BIND_REMOTEVIEWS" />
```

Nuevas tecnologías de plataforma

Almacenamiento
- Compatibilidad con el sistema de archivos ext4 para habilitar el almacenamiento eMMC integrado.
- El sistema de archivos FUSE admite dispositivos MTP.
- Compatibilidad con el modo de host USB para teclados y concentradores USB.
- Compatibilidad con MTP/PTP
Kernel de Linux
- Se actualizó a la versión 2.6.36
Máquina virtual Dalvik
- Nuevo código para admitir y optimizar en SMP
- Varias mejoras en la infraestructura JIT
- Mejoras en el recolector de elementos no utilizados:
  - Ajustado para SMP
  - Compatibilidad con tamaños de montón más grandes
  - Control unificado para mapas de bits y búferes de bytes
Bibliotecas principales de Dalvik
- Implementación nueva y mucho más rápida de NIO (biblioteca de E/S moderna)
- Mensajes de excepción mejorados
- Correcciones de corrección y rendimiento en todo

Informe de diferencias de las APIs

Para obtener una vista detallada de todos los cambios de la API en Android 3.0 (nivel de API 11), consulta el Informe de diferencias de las APIs.

Nivel de API

La plataforma de Android 3.0 ofrece una versión actualizada de la API de framework. A la API de Android 3.0 se le asigna un identificador de número entero, 11, que se almacena en el propio sistema. Este identificador, llamado "nivel de API", permite que el sistema determine correctamente si una aplicación es compatible con él antes de instalarla.

Para usar las APIs de Android 3.0 en tu aplicación, deberás compilarla en la biblioteca de Android que se proporciona en la plataforma de SDK de Android 3.0. Según tus necesidades, es posible que también debas agregar un atributo android:minSdkVersion="11" al elemento <uses-sdk> en el manifiesto de la aplicación. Si tu aplicación está diseñada para ejecutarse solo en Android 2.3 y versiones posteriores, declarar el atributo evita que la aplicación se instale en versiones anteriores de la plataforma.

Para obtener más información, consulta ¿Qué es el nivel de API?