Códifica un Widget para Android: Introducir y Mostrar

Spanish (Español) translation by Jean Perez (you can also view the original English article)

Desde Android 1.5, widgets de la aplicación han permitido a los usuarios obtener información, aplicaciones de control y realizar tareas cruciales, todo desde la comodidad de sus pantallas de inicio.

En esta serie de dos partes, va ser que muestra cómo proporcionar una mejor experiencia de usuario añadiendo un widget de aplicación a los proyectos de Android.

Al final de la serie, habrá creado un widget:

Muestra varios conjuntos de datos.
Realiza una acción única cuando el usuario interactúa con una vista específica en diseño de ese widget.
Actualiza automáticamente cada vez que haya transcurrido un periodo de tiempo establecido.
Se actualiza con nuevos datos en respuesta a la interacción con el usuario.

En este primer post, utilizaremos herramientas integradas de estudio Android rápida y fácilmente generar todos los archivos necesarios para entregar cualquier widget de la aplicación para Android. Luego podrá ampliar sobre esta base crear un widget que recupera y muestra los datos y responde a eventos onClick.

¿Qué una Aplicación Widgets?

Un widget de la aplicación es una aplicación ligera, de miniatura que normalmente entra en una de las siguientes categorías:

Widget de información. Un widget no desplazable que muestra información importante, como un widget de tiempo o reloj.
Widgets de colección. Un widget de desplazamiento que muestra una serie de elementos relacionados, como una galería de fotos o artículos de la misma publicación. Widgets de colección por lo general están respaldados por un origen de datos como una Matriz o base de datos. Un widget de colección debe incluir un control ListView, GridView, StackView o un AdapterViewFlipper.
Widgets de control. Un widget que actúa como un control remoto para su aplicación, permitiendo al usuario disparar con frecuencia utiliza funciones sin necesariamente tener que lanzar la aplicación. Aplicaciones que jugar música a menudo proporcionan un widget que permite al usuario reproducir, pausar y saltar pistas directamente desde su pantalla de inicio.
Widgets híbrido. ¿Por qué se restringe a una categoría, cuando usted puede escoger elementos de varias categorías? Sólo ten en cuenta que mezclar y combinar pueden conducir a una confusa experiencia de usuario, así los mejores resultados debe diseñar su widget con una sola categoría en la mente y luego agregar elementos de otras categorías como sea necesario. Por ejemplo, si desea crear un widget que muestra la previsión del tiempo de hoy pero también permite a los usuarios ver la previsión para diferentes días y lugares, entonces usted debe crea un widget de información y añadimos luego los elementos de control necesarios.

Además de las funciones anteriores, mayoría de los widgets responde a eventos onClick con el lanzamiento de su aplicación asociada, similar a un acceso directo de aplicación, pero también pueden proporcionar acceso directo a contenidos específicos dentro de esa aplicación.

Widgets de aplicación deben colocarse en un Host de aplicación Widget, comúnmente el stock Android pantalla de inicio, aunque hay algunos Hosts de terceros aplicación Widget, como el popular Nova Launcher y Apex Launcher.

A lo largo de esta serie, que va hablando de widgets como algo que pone en la pantalla de inicio, pero si tienes un vago recuerdo de poder poner widgets en el lockscreen, entonces no era sólo una especie de sueño maravilloso! Entre API los niveles 17 y 20, fue posible poner widgets en la pantalla de inicio o el lockscreen.

Desde lockscreen widgets fueron desaprobados en nivel 21 de la API, en esta serie nos va creando un widget para el homescreen solo.

¿Por Qué Debo Crear un Widget de Aplicación?

Hay varias razones por qué usted debe considerar añadir un widget de la aplicación a su último proyecto Android.

Fácil Acceso a Información Importante y Características

Widgets permiten al usuario ver la información más importante de la aplicación, directamente desde su pantalla de inicio. Por ejemplo, si has desarrollado una aplicación de calendario podría crear un widget que muestra detalles sobre la próxima cita del usuario. Esto es mucho más conveniente que obligar al usuario a lanzar su aplicación y potencialmente navegar por varias pantallas, para recuperar la misma información.

Si desarrollas un widget de control (o un widget híbrido con elementos de control) el usuario también podrá realizar tareas directamente desde su pantalla de inicio. Continuando con nuestro ejemplo de calendario, que widget puede permitir al usuario crear, editar y Cancelar citas, potencialmente sin necesidad de lanzar su aplicación. Esto tiene el potencial para eliminar varios pasos de la navegación de algunas de las tareas más importantes de su aplicación, que sólo pueden tener un impacto positivo en la experiencia del usuario!

Acceso Directo a Todos las Pantallas Más Importantes de Su Aplicación

Aprovechando un widget típicamente toma el usuario para el nivel superior de la aplicación asociada, similar a un acceso directo de la aplicación. Sin embargo, a diferencia de los métodos abreviados de app, widgets pueden vincular a áreas específicas dentro de la aplicación asociada. Por ejemplo, aprovechando el Nuevo email de un widget notificación recibida puede iniciar la aplicación con el nuevo mensaje seleccionado, mientras aprovechando Crear nuevo correo podría llevarlos directamente a la actividad de ComposeEmail de su aplicación.

Por incrustar enlaces múltiples en el diseño de tu widget, puede proporcionar acceso conveniente, un toque a todas las actividades más importantes de su aplicación.

Crear una Base de Usuarios Leales, Comprometidos

Como el entero Pokemon Go explosión y posterior entrega, consiguiendo un montón de gente a descargar su aplicación no garantiza automáticamente una base de usuarios leales que todavía estar usando su aplicación días, semanas o incluso meses por la línea.

Los usuarios de móviles son un grupo bastante inconstante, y con la memoria disponible en su típico smartphone Android o tablet aumentando todo el tiempo, es fácil perder la pista de las aplicaciones que has instalado en tu dispositivo. Es probable que, si usted levanta su teléfono inteligente Android o tableta ahora y pase a través de la aplicación de cajón entonces usted descubrirá al menos una aplicación que has olvidado por completo sobre.

Mediante la creación de un widget que muestra toda su aplicación más valiosa información y características, asegúrese de que cada vez que el usuario miradas en su pantalla de inicio está recordaron no sólo existe su aplicación, sino que también lo tiene un gran contenido.

Añadir un Widget de Aplicación al Proyecto

Incluso el más básico widget requiere múltiples clases y recursos, pero cuando se crea un widget usando herramientas integradas de Android Studio, todos estos archivos se generan para usted. Puesto que hay ningún punto en hacer todo más difícil de lo que tiene que ser Android desarrollo, utilizaremos estas herramientas para obtener una ventaja en la construcción de nuestro widget.

Un widget de aplicación debe ser siempre tan ligada a una subyacente de la aplicación, cree un nuevo proyecto Android con la configuración de su elección.

Una vez Android Studio ha construido su proyecto, seleccione Archivo > Nueva > Widget > AppWidget desde la barra de herramientas de estudio Android. Esto lanza un menú Configurar Componentes donde puede definir algunas de configuración inicial del widget.

Configure your widgets settings in Android Studio

La mayoría de estas opciones son bastante explica por sí mismo, pero hay algunos que vale la pena explorar con más detalle.

Tamaño Variable (API 12+)

Si un widget es de tamaño variable, el usuario puede aumentar o disminuir el número de "células" que ocupa en su pantalla de inicio, largo-presionar el widget y luego arrastrando las asas azules que aparecen alrededor de su contorno.

Siempre que sea posible, debe dar el widget la capacidad para cambiar el tamaño horizontal y vertical, ya que esto ayudará a tu widget de adaptarse a una gama de configuraciones de pantalla y configuraciones de la pantalla de inicio. Si un usuario tiene un serio desorden homescreen, entonces puede ser imposible para su widget caber incluso en esa pantalla de inicio, a menos que el widget se puede cambiar.

Si desea crear un widget de invariable, luego abrir el menú desplegable de Tamaño variable y seleccione ya sea Sólo horizontalmente, Sólo verticalmente, o No puede cambiar.

Altura y Anchura Mínima

La anchura mínima y altura especifica el número de células widget ocupará inicialmente cuando se coloca en la pantalla de inicio.

Para los widgets de tamaño variable, esto es el más pequeño el usuario puede cambiar el tamaño el widget, puede utilizar estos valores para evitar que los usuarios que encoge el widget hasta el punto donde se convierte en inutilizable.

Si el widget no puede cambiar el tamaño, los valores mínimos de anchura y altura son el widget permanente de anchura y altura.

Para aumentar las posibilidades de un widget de conexión cómodamente a través de una gama de pantallas de inicio, se recomienda nunca utilizar nada más grande que 4 por 4 para los valores mínimos de anchura y altura.

Mientras que el grosor y altura de una pantalla de inicio "la célula" varía entre los dispositivos, puede obtener una estimación aproximada de cuántas PPP (puntos por pulgada) el widget se ocupan mediante la fórmula siguiente:

70 × number of cells -30

Por ejemplo, si el widget es 2 x 3 celdas:

70 x 2 - 30 = 110
70 x 3 - 30 = 180

Este widget ocupa alrededor de 110 x 180 PPP en pantalla de inicio del usuario. Si estos valores no se alinean con las dimensiones de las células de un determinado dispositivo, Android automáticamente redondeará su widget para el tamaño de celda más cercano.

Revisar todas las opciones de este menú y cualquier cambio que desee (me quedo con los valores predeterminados) y a continuación, haga clic en Finalizar.

Estudio Android ahora generará todos los archivos y recursos necesarios para ofrecer un widget de aplicación básica. Este widget no exactamente emocionante (básicamente es sólo un bloque azul con la palabra Ejemplo escrito a través de él) pero es un widget funcional que puede probar en su dispositivo.

Para probar el widget:

Instalar su proyecto en un dispositivo físico de Android o AVD (Android Virtual dispositivo).
Lanzamiento Widget Picker de Android pulsando cualquier espacio vacío en la pantalla de inicio, y luego golpeando ligeramente la palabra Widget que aparece hacia la parte inferior de la pantalla.
Pase a través del selector Widget hasta que ves el widget de Ejemplo azul.
Presione en este widget para caer en tu pantalla de inicio.
El modo de cambiar el tamaño pulsando sobre el widget hasta que un juego de agarraderas azul aparece y luego arrastre estas manijas para aumentar o disminuir el número de celdas que ocupa este widget.

Test your widget on an Android Virtual Device

Explorando los Archivos de Aplicación Widget

Este widget no puede hacer todo lo que mucho, pero que incluye todas las clases y recursos que estará trabajando en el resto de esta serie, así que echemos un vistazo a estos archivos y el papel que desempeñan en la entrega de un widget de la aplicación.

NewAppWidget.java

El proveedor de widget es una clase de conveniencia que contiene los métodos para interactuar mediante programación con un widget a través de eventos de difusión. Bajo el capó, un widget es esencialmente sólo un BroadcastReceiver que puede responder a diversas acciones, tales como el usuario colocar una nueva instancia del widget en su pantalla de inicio.

En particular, el proveedor de la aplicación widget está donde defines los métodos del ciclo de vida de widget, que sea llamada para cada instancia del widget o para casos concretos sólo.

Aunque tendemos a pensar en un widget como una entidad única que el usuario pone en su pantalla de inicio una vez, no hay nada que les impiden crear múltiples instancias del mismo widget. Tal vez su widget es personalizable, hasta el punto donde diferentes instancias pueden tener funcionalidades significativamente diferentes, o tal vez el usuario le encanta el widget tanto que quieran para yeso en toda su pantalla de inicio!

Echemos un vistazo a los métodos del ciclo de vida diferentes que se pueden implementar en la clase de proveedor de widget:

La `onReceive` evento

Android llama al método onReceive() registrado BroadcastReceiver cuando se produce el evento especificado.

Normalmente no necesitará poner en práctica este método manualmente, como la clase de AppWidgetProvider automáticamente filtra todas las transmisiones de widget y delega las operaciones de los métodos apropiados.

`OnEnabled` Evento

El método de ciclo de vida de onEnabled() es llamado en respuesta a ACTION_APPWIDGET_ENABLED, que se emite cuando el usuario agrega la primer instancia del widget a su pantalla de inicio. Si el usuario crea dos instancias del widget, onEnabled() se denomina para la primera instancia, pero no para el segundo.

Este método de ciclo de vida es donde realizan cualquier configuración que sólo ocurren una vez por todas las instancias de widget, como crear una base de datos o un servicio.

Tenga en cuenta que si el usuario elimina todas las instancias del widget de su dispositivo y luego crea una nueva instancia, entonces esto es clasificado como primera instancia, y en consecuencia se se llama al método onEnabled() una vez más.

`OnAppWidgetOptionsChanged` Evento

Llama a este método de ciclo de vida en respuesta a ACTION_APPWIDGET_OPTIONS_CHANGED, que se emite cuando se crea una instancia del widget y cada vez que se cambia el tamaño de este widget. Puede utilizar este método para revelar u ocultar contenido basado en cómo el usuario tamaños de widget, aunque esta devolución de llamada sólo se admite en Android 4.1 y superior.

`OnUpdate` Evento

Cada vez se llama al método de ciclo de vida de onUpdate():

Transcurrido el intervalo de actualización.
El usuario realiza una acción que desencadena el método onUpdate().
El usuario coloca una nueva instancia del widget en su pantalla de inicio (a menos que tu widget contiene una configuración de la actividad, que nos va cubriendo en parte dos).

El método de ciclo de vida de onUpdate() también es llamado en respuesta a ACTION_APPWIDGET_RESTORED, que se emite cada vez que un widget es restaurado desde copia de seguridad.

Para la mayoría de los proyectos, el método onUpdate() contendrá la mayor parte del código de proveedor de widget, especialmente puesto que es también donde se registra los controladores de eventos de su widget.

`OnDeleted` Evento

Se llama al método onDeleted() cada vez que se elimina una instancia del widget de la App Widget, que provoca la emisión ACTION_APPWIDGET_DELETED del sistema.

`OnDisabled` Evento

Este método es llamado en respuesta a la difusión de la ACTION_APPWIDGET_DISABLED, que se envía cuando se quita la última instancia del widget Widget de la aplicación. Por ejemplo, si el usuario crea tres instancias del widget, luego el método onDisabled() sólo se llamaría cuando el usuario elimina la tercera y última instancia de su pantalla de inicio.

El método de ciclo de vida de onDisabled() es donde debe limpiar cualquier recursos que creó en el onEnabled(), así que si configura una base de datos en onEnabled() entonces te eliminas lo en onDisabled().

`OnRestored` Evento

Se llama al método onRestored() en respuesta a ACTION_APPWIDGET_RESTORED, que se emite cada vez que una instancia de un widget de la aplicación se restaura desde la copia de seguridad. Si desea mantener los datos persistentes, entonces usted necesitará reemplazar este método y reasignar los AppWidgetIds anteriores a los nuevos valores, por ejemplo:

public void onRestored(Context context, int[] oldWidgetIds,
           int[] newWidgetIds) {
   }
}

Si abre el archivo NewAppWidget.java que Android Studio genera automáticamente, a ver que ya contiene implementaciones para algunos de estos métodos de ciclo de vida del widget:

import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.Context;
import android.widget.RemoteViews;

//All widgets extend the AppWidgetProvider class//

public class NewAppWidget extends AppWidgetProvider {

static void updateAppWidget(Context context, AppWidgetManager appWidgetManager,
                              int appWidgetId) {

      CharSequence widgetText = context.getString(R.string.appwidget_text);

    //Load the layout resource file into a RemoteViews object//

      RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.new_app_widget);
      views.setTextViewText(R.id.appwidget_text, widgetText);

 //Tell the AppWidgetManager about the updated RemoteViews object//

      appWidgetManager.updateAppWidget(appWidgetId, views);
  }

//Define the onUpdate lifecycle method//

  @Override
  public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {

//appWidgetIds is an array of IDs that identifies every instance of your widget, so this 
//particular onUpdate() method will update all instances of our application widget//

      for (int appWidgetId : appWidgetIds) {
          updateAppWidget(context, appWidgetManager, appWidgetId);
      }
  }

  @Override

//Define the onEnabled lifecycle method//

  public void onEnabled(Context context) {
      
      //To do//
  }

  @Override

//Define the onDisabled method//

  public void onDisabled(Context context) {
      
//To do//

  }
}

El Archivo de Diseño Widget

El archivo res/layout/new_app_widget.xml define la disposición de nuestro widget, que actualmente es sólo un fondo azul con la palabra Ejemplo escrito a través de él.

La gran diferencia entre crear un diseño para una actividad y la creación de un diseño para un widget es ese widget diseños deben basarse en RemoteViews, como esto permite Android mostrar el diseño de un proceso fuera de la aplicación (es decir, en la pantalla de inicio del usuario).

RemoteViews no admiten todo tipo de diseño o la vista, por lo que al construir un diseño de widget, usted está limitado a los siguientes tipos:

AnalogClock
Button
Chromometer
FrameLayout
GridLayout
ImageButton
ImageView
LinearLayout
ProgressBar
RelativeLayout
TextView
ViewStub

Si está creando un widget de la colección, entonces también puede utilizar los siguientes tipos cuando la aplicación se instala en Android 3.0 y superior:

AdapterViewFlipper
GridView
ListView
StackView
ViewFlipper

Subclases y descendientes de las vistas y las clases no son compatibles.

Clics y Golpes Fuertes

Para asegurar que los usuarios accidentalmente no interactúan con un widget mientras está navegando alrededor de su pantalla de inicio, widgets responden a sucesos de onClick.

La excepción es cuando el usuario quita un widget arrastrándolo hacia la acción de Desinstalación de su pantalla de inicio, como en esta situación que su widget responderá al gesto de barrido vertical. Sin embargo, puesto que esta interacción es administrada por el sistema Android, no necesita preocuparse sobre la implementación de golpe vertical de apoyo en su aplicación.

El Archivo de Información del Widget

El archivo res/xml/new_app_widget_info.xml (también conocido como el archivo AppWidgetProviderInfo) define una serie de propiedades del widget, incluyendo muchos de la configuración seleccionada en el menú de Configurar Componentes de Android Studio, como dimensiones mínimas de widget y si se puede colocar en el lockscreen.

El archivo de configuración especifica la frecuencia con el widget pide nueva información desde el servicio de actualización de la aplicación Widget. Decidir en esta frecuencia requiere un delicado equilibrio: actualización más intervalos le ayudará a conservar la batería del dispositivo, pero Coloque sus intervalos demasiado lejos aparte y su widget puede mostrar información notablemente desactualizada.

También debe tener en cuenta que el sistema activará un dispositivo para dormir en recuperar nueva información sobre pedido, por lo que aunque actualizar el widget una vez cada media hora no puede sonar excesiva, podría resultar en su widget despertar el dispositivo una vez cada 30 minutos, que va afectar el consumo de la batería.

Si abre el archivo del proyecto new_app_widget_info.xml, a ver que ya define un número de propiedades del widget, incluyendo el intervalo de actualización.

<?xml version="1.0" encoding="utf-8"?>
<appwidget-provider xmlns:android="https://schemas.android.com/apk/res/android"

//The layout your widget should use when it’s placed on the lockscreen on supported devices//

  android:initialKeyguardLayout="@layout/new_app_widget"

//The layout your widget should use when it’s placed on the homescreen//

  android:initialLayout="@layout/new_app_widget"

//The minimum space your widget consumes, which is also its initial size//

  android:minHeight="40dp"
  android:minWidth="40dp"

//The drawable that represents your widget in the Widget Picker//

  android:previewImage="@drawable/example_appwidget_preview"

//Whether the widget can be resized horizontally, vertically, or along both axes, on Android 3.1 and higher//  

  android:resizeMode="horizontal|vertical"

//How frequently your widget should request new information from the app widget provider//

  android:updatePeriodMillis="86400000"

//Whether the widget can be placed on the homescreen, lockscreen (“keyguard”) or both.//
//On Android 5.0 and higher, home_screen is the only valid option//

  android:widgetCategory="home_screen"></appwidget-provider>

Si usted da a sus usuarios la opción de colocar el widget en el lockscreen, entonces tener en cuenta que contenido del widget se vea a quien miradas tanto como en el lockscreen. Si su diseño de "default" contiene alguna información potencialmente sensible o personal, debe proporcionar un diseño alternativo para su widget para utilizar cuando se coloca en el lockscreen.

Res/values/dimens.xml Archivo

Widgets no vean lo mejor posible cuando está presionados contra el uno al otro, o cuando se extienden hasta el borde mismo de la pantalla de inicio.

Cada vez que aparece el widget en Android 4.0 o superior, sistema operativo Android inserta automáticamente un acolchado entre el marco del widget y el cuadro delimitador.

A widget consists of a bounding box frame widget margins widget padding and widget controls

Si termina su aplicación en un dispositivo que está ejecutando cualquier cosa antes que Android 4.0, entonces el widget debe suministrar este relleno sí mismo.

Cuando se crea un widget con el Archivo > Nuevo > Widget > AppWidget menú Android Studio genera dos archivos dimens.xml que garantizan su widget tiene siempre el relleno correcto, independientemente de la versión de Android que se instala en.

Encontrará usted dos de estos archivos en su carpeta de res:

res/Values/dimens.XML

Este archivo define el dpi 8 de acolchado que el widget tiene que proporcionar cada vez que se instala a nivel de API 13 o versiones anterior.

<dimen name="widget_margin">8dp</dimen>

res/values-v14/dimens.xml

Android 4.0 y superior aplica automáticamente el relleno para cada widget, cualquier relleno que proporciona el widget será además de este relleno por defecto.

Para asegurar que el widget se alinea con los iconos de cualquier app u otros widgets que el usuario ha depositado en su pantalla de inicio, este archivo dimens.xml especifica que el widget no debe proporcionar márgenes adicionales para Android 4.0 y superior:

<dimen name="widget_margin">0dp</dimen>

Este margen predeterminado ayuda a equilibrio visual la pantalla de inicio, así que usted debe evitar modificarlo — no desea su widget para ser el impar hacia fuera, después de todo!

Diseño del widget ya hace referencia a esta dimensión valor (android:padding="@dimen/widget_margin") así que cuidado de no cambiar esta línea mientras se trabaja en el diseño del widget.

Aunque estos archivos dimens.xml son la forma más fácil de asegurar su widget siempre tiene el relleno correcto, si esta técnica no es adecuada para su proyecto en particular, entonces una alternativa es crear varios fondos de 9-patch con diferentes márgenes de Nivel API 14 y mayor y el nivel de API 13 e inferior. Puede crear nueve-parches utilizando herramienta de Android Studio Draw 9-patch, o con una gráfica dedicada de edición de programa tales como Adobe Photoshop.

El Manifiesto del Proyecto

En el archivo del proyecto AndroidManifest.xml, necesita registrar su widget como un BroadcastReceiver y especificar el proveedor de widget y el archivo AppWidgetProviderInfo que debe usar este widget.

Si abre el manifiesto, verás que Android Studio ya ha agregado toda esta información para usted.

//The widget’s AppWidgetProvider; in this instance that’s NewAppWidget.java//

<receiver android:name=".NewAppWidget">
      <intent-filter>

//An intent filter for the android.appwidget.action.APPWIDGET_UPDATE action//

          <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
      </intent-filter>

      <meta-data
          android:name="android.appwidget.provider"

//The widget’s AppWidgetProviderInfo object//

          android:resource="@xml/new_app_widget_info" />

  </receiver>
</application>

Recursos de Selector Widget

El archivo res/drawable/example_appwidget_preview.png es el recurso drawable que representa su widget en el selector de Widget.

Para animar a los usuarios seleccionar el widget de todas las opciones disponibles, este dibujable deberá mostrar el widget, correctamente configurado en una pantalla de inicio y muestra un montón de contenido útil.

Cuando se crea un widget con el Archivo > Nueva > Widget > AppWidget menú Android Studio genera automáticamente una vista previa dibujable (example_appwidget_preview.png).

En la segunda parte, va ser mostrando cómo rápida y fácilmente reemplazar esta acción drawable, utilizando herramientas integradas de Android Studio para generar su propia imagen de vista previa.

Construyendo Su Diseño

Ahora tenemos una visión general de cómo estos archivos vienen juntos crear un widget de la aplicación, vamos a ampliar sobre esta base y crean un widget que muestra más que la palabra Ejemplo sobre un fondo azul!

Se va añadiendo la siguiente funcionalidad a nuestro widget:

Un TextView que muestra una etiqueta de ID del Widget de Aplicación.
Un TextView que recupera y muestra el ID para este caso particular widget.
Un TextView que responde a eventos onClick lanzando el navegador del usuario predeterminado y carga una dirección URL.

Si bien podríamos arrastrar tres TextViews de la paleta de estudio Android y suéltelos en la lona, si el widget se ve bien y luego los usuarios estarán más propensos a colocar en su pantalla de inicio, así que vamos a crear algunos recursos que dan nuestro widget extra estética.

Crear Widget de Fondo

Voy a crear un rectángulo con esquinas redondeadas, un fondo degradado y una frontera, que va a utilizar como fondo para mi widget:

Control y haga clic en la carpeta drawable de su proyecto y seleccione Nuevo > Drawable archivo de recursos de estas características.
Nombre este archivo widget_background y haga clic en Aceptar.
Introduzca el siguiente código:

<?xml version="1.0" encoding="UTF-8"?>
http://schemas.android.com/apk/res/android"
  android:shape="rectangle">

  <stroke
      android:width="1dp"
      android:color="#ffffff" />

  <gradient
      android:angle="225"
      android:endColor="#00FFFFFF"
      android:startColor="#DD000000" />

  <corners
      android:topRightRadius="10dp"
      android:topLeftRadius="10dp"
      android:bottomRightRadius="10dp"
      android:bottomLeftRadius="10dp" />
</shape>

2. Crear el Fondo `TextView`

A continuación, crear una forma para utilizar como fondo para nuestro TextViews:

Control y haga clic en la carpeta drawable de su proyecto y seleccione Nuevo > Archivo de Recursos Drawable.
Nombre este archivo tvbackground y haga clic en Aceptar.
Introduzca el siguiente código:

<?xml version="1.0" encoding="utf-8"?>
http://schemas.android.com/apk/res/android"
  android:shape="rectangle" >

  <stroke
      android:width="1dp"
      android:color="#000000" />

  <solid android:color="#FFFFFFFF" />

  <corners
      android:topRightRadius="15dp"
      android:topLeftRadius="15dp"
      android:bottomRightRadius="15dp"
      android:bottomLeftRadius="15dp" />
</shape>

3. Crear Algunos Estilos

También voy a utilizar los siguientes estilos:

widget_text. Un efecto de negrita que aplicaremos al texto del widget.
widget_views. Los diversos márgenes y relleno que lo aplico a mi TextViews.

Abra el archivo del proyecto styles.xml y agregar lo siguiente:

<style name="widget_views" parent="@android:style/Widget">
      <item name="android:padding">8dp</item>
      <item name="android:layout_marginTop">12dp</item>
      <item name="android:layout_marginLeft">12dp</item>
      <item name="android:layout_marginRight">12dp</item>
      <item name="android:textStyle">bold</item>
  </style>

<style name="widget_text" parent="@android:style/Widget">
  <item name="android:textStyle">bold</item>
</style>

¡4. Construir Tu Diseño!

Ahora que todos nuestros recursos están en su lugar, podemos crear diseño de nuestro widget. Abra el archivo new_app_widget.xml y añadir lo siguiente:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:padding="@dimen/widget_margin"
  android:background="@drawable/widget_background"
  android:orientation="vertical" >

  <LinearLayout
      android:background="@drawable/tvbackground"
      style="@style/widget_views"
      android:layout_width="match_parent"
      android:layout_height="wrap_content"
      android:orientation="horizontal">

      <TextView
          android:id="@+id/id_label"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@string/widget_id"
          style="@style/widget_text" />

      <TextView
          android:id="@+id/id_value"
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="."
          style="@style/widget_text" />
  </LinearLayout>

  <TextView
      android:id="@+id/launch_url"
      style="@style/widget_views"
      android:layout_width="wrap_content"
      android:layout_height="wrap_content"
      android:text="@string/URL"
      android:background="@drawable/tvbackground"/>
</LinearLayout>

Por último, abra el archivo strings.xml y definir los recursos de cadena que hace referencia en nuestro diseño:

<resources>
  <string name="app_name">Widget</string>
  <string name="widget_id">App Widget ID\u0020</string>
  <string name="URL">Tap to launch URL</string>
</resources>

Ficha de Diseño Android Studio le ayuda a trabajar más eficientemente, por previsualizar cómo hará que su diseño en una amplia gama de dispositivos. Cambiar a la ficha Diseño es mucho más fácil que ejecuta su proyecto en un dispositivo Android cada vez que realiza un cambio en su diseño.

Frustrante, estudio Android no suministrar una piel widget dedicado, así que por defecto diseño del widget se representa como una actividad regular, que no proporciona la mejor visión de cómo se verá tu widget en la pantalla de inicio del usuario.

Una potencial solución es hacer tu diseño con la piel usar Android Wear (Cuadrado), que es comparable con el tamaño y la forma de un widget de la aplicación para Android:

Asegúrese de que está seleccionada la ficha de Dispositivo Android Studio.
Abra el menú desplegable Dispositivo.
Seleccione 280 x 280, hdpi (Cuadrado) en el menú desplegable.

Try rendering your widget layout using the Android Wear Square skin

Crear la Funcionalidad del Widget

Ahora que nuestro widget se ve a la parte, es hora de darle algunas funciones:

Recuperar y mostrar datos. Cada instancia de un widget se le asigna un ID cuando se agrega al Host de la aplicación de Widget. Este identificador persiste a través del ciclo de vida del widget y será totalmente única para esa instancia del widget, incluso si el usuario agrega varias instancias del mismo widget a su pantalla de inicio.
Agregar una acción. Vamos a crear un OnClickListener que lanza el navegador del usuario predeterminado y carga una dirección URL.

Abra el archivo de proveedor de widget (NewAppWidget.java) y borrar la línea que recupera el recurso de cadena de appwidget_text:

static void updateAppWidget(Context context, AppWidgetManager appWidgetManager,
                          int appWidgetId) {

//Delete the following line//

  CharSequence widgetText = context.getString(R.string.appwidget_text);
  RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.new_app_widget);
  views.setTextViewText(R.id.appwidget_text, widgetText);

  appWidgetManager.updateAppWidget(appWidgetId, views);

}

En el bloque de updateAppWidget, ahora tenemos que actualizar el marcador de posición de R.id.id_value con el ID único del widget:

  RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.new_app_widget);
      views.setTextViewText(R.id.id_value, String.valueOf(appWidgetId));

También necesitamos crear un objeto por intención que contiene la dirección URL que se debe cargar cada vez que el usuario interactúa con este TextView.

      Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://code.tutsplus.com/"));
      PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, 0);

//Attach an OnClickListener to our “launch_url” button, using setOnClickPendingIntent//

      views.setOnClickPendingIntent(R.id.launch_url, pendingIntent);

Aquí está el archivo de proveedor de widget completo:

import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProvider;
import android.content.Context;
import android.widget.RemoteViews;
import android.app.PendingIntent;
import android.content.Intent;
import android.net.Uri;

public class NewAppWidget extends AppWidgetProvider {

  static void updateAppWidget(Context context,

                              AppWidgetManager appWidgetManager,

                              int appWidgetId) {

//Instantiate the RemoteViews object//

      RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.new_app_widget);

//Update your app’s text, using the setTextViewText method of the RemoteViews class//

      views.setTextViewText(R.id.id_value, String.valueOf(appWidgetId));

//Register the OnClickListener//

      Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse("https://code.tutsplus.com/"));
      PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, 0);
      views.setOnClickPendingIntent(R.id.launch_url, pendingIntent);
      appWidgetManager.updateAppWidget(appWidgetId, views);

  }

  @Override
  public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {

      //Update all instances of this widget//

      for (int appWidgetId : appWidgetIds) {
          updateAppWidget(context, appWidgetManager, appWidgetId);
      }
  }
}

Probando el Widget

¡Es el momento de poner este widget a prueba!

Instalar el proyecto actualizado en tu dispositivo Android.
Para asegurar que estás viendo la versión más reciente de este widget, quite las instancias existentes de cualquier widget desde tu pantalla de inicio.
Presione una sección vacía de la pantalla de inicio y luego seleccione el widget en el selector Widget.
Reubicar y redimensionar el widget como desee.

Put your Android application widget to the test

Comprobar que el widget responde a eventos de entrada de usuario, seleccionando el Grifo Para Lanzar URL TextView. El widget de la aplicación debe responder con el lanzamiento de su navegador predeterminado y carga una dirección URL.

Si has estado siguiendo junto con este tutorial, entonces en este punto tienes un widget completamente funcional que muestra muchos de los conceptos base de widgets de la aplicación para Android. También puede descargar el proyecto terminado desde nuestro repositorio de GitHub.

Conclusión

En este post hemos examinado todos los archivos necesarios para ofrecer un widget de la aplicación para Android, antes de crear un widget que recupera y muestra algunos datos y responde a eventos de entrada de usuario.

Actualmente, hay una pieza importante de la funcionalidad todavía falta en nuestro widget: no muestra ninguna información nueva. En el próximo post, daremos este widget a la capacidad de recuperar y mostrar nuevos datos automáticamente, basado en un horario establecido y en respuesta directa a los eventos de entrada de usuario.

Mientras tanto, revisa algunos de nuestros otros grandes posts sobre desarrollo de aplicaciones Android aquí en Envato Tuts+!