Cree un widget de Android para su aplicación

  Crear un widget de Android Porque dormimos Audible Homescreen

Desde los primeros días del sistema operativo, los widgets para Android han permitido a los usuarios interactuar con sus aplicaciones favoritas, ya que comodidad de su pantalla de inicio. Entonces, ¿cómo se crea un widget de Android?

Para el desarrollador, los widgets le dan a su aplicación una valiosa presencia en la pantalla de inicio del usuario. En lugar de ocultarse en el cajón de la aplicación, los usuarios recordarán su aplicación cada vez que miren la pantalla de inicio, incluso obteniendo una vista previa del contenido más interesante y útil de su aplicación. [19659005] Los widgets le dan a su aplicación una presencia valiosa en la pantalla de inicio del usuario

En este artículo, le mostraré cómo proporcionar una mejor experiencia de usuario alentando a los usuarios a interactuar con su aplicación, creando un Widget de Android! Al final de este artículo, habrá creado un widget de colección desplazable que muestra un conjunto completo de datos en la pantalla de inicio del usuario.

Para garantizar que proporcione el tipo de widget que los usuarios desean en su pantalla de inicio, también crearemos una tarea de configuración, que permitirá a los usuarios personalizar el contenido, la apariencia y la funcionalidad del widget. Finalmente, le mostraré cómo puede alentar a las personas a usar su widget, creando una imagen de vista previa del widget que muestre lo mejor que su widget tiene para ofrecer.

Lea también: Desarrollo para dispositivos plegables: lo que necesita saber

¿Qué son los widgets para Android?

Un widget de aplicación es una aplicación ligera y en miniatura que vive en la pantalla de inicio del usuario.

  Los widgets para aplicaciones de Android pueden contener una variedad de contenido

Los widgets para Android pueden proporcionar una variedad de contenido, pero generalmente se dividen en una de las siguientes categorías :

  • Widget de información . Este es un widget sin desplazamiento que muestra cierta información, como el pronóstico del tiempo de hoy o la fecha y la hora.
  • Widget de colección . Este es un widget desplazable que muestra un conjunto de datos relacionado, formateado como ListView, GridView, StackView o AdapterViewFlipper. Los widgets de recopilación generalmente son compatibles con una fuente de datos, como una base de datos o una matriz.
  • Control widget . Estos widgets actúan como un control remoto que permite a los usuarios interactuar con la aplicación, sin tener que ponerla en primer plano. Las aplicaciones que reproducen contenido multimedia, como podcasts o música, a menudo tienen widgets de control que permiten al usuario activar las acciones Reproducir, Pausa y Saltar directamente desde la pantalla principal.
  • Widgets híbridos . En ocasiones, puede ofrecer una mejor experiencia de usuario combinando elementos de varias categorías. Por ejemplo, si está desarrollando un widget de control para una aplicación de música, puede proporcionar los controles Reproducir, Pausa y Saltar, pero también puede decidir mostrar cierta información, como el título de la canción y el artista. Si decides mezclar y combinar, ¡no te dejes llevar! Los widgets tienden a ofrecer la mejor experiencia de usuario cuando proporcionan un acceso fácil a una pequeña cantidad de información oportuna y relevante, o a algunas funciones de uso común. Para ayudar a mantener ligeros los widgets híbridos, recomendamos identificar la categoría principal de widgets, desarrollarla según esa categoría y y luego agregar algunos elementos de la subcategoría del widget.

¿Mi proyecto realmente necesita un widget de aplicación?

Hay varias razones por las que debería considerar agregar un widget de aplicación a su proyecto de Android.

Los widgets para Android pueden mejorar la experiencia del usuario

Como regla general, la cantidad de pasos de navegación necesarios para completar una actividad, mejor es la experiencia del # 39; usuario.

Al proporcionar un widget de aplicación, puede eliminar múltiples pasos de navegación de las transmisiones más utilizadas de su aplicación. En el mejor de los casos, sus usuarios podrán obtener la información que necesitan simplemente mirando su pantalla principal o ejecutando la actividad deseada simplemente tocando un botón en el widget de control.

Más potente que los accesos directos a aplicaciones

Los widgets de aplicaciones a menudo responden a eventos onClick iniciando el nivel superior en la aplicación asociada, de forma similar a un enlace de aplicación. Sin embargo, los widgets también pueden proporcionar acceso directo a actividades específicas dentro de una aplicación, por ejemplo, tocando la notificación Nuevo mensaje recibido de un widget podría iniciar la aplicación asociada con el nuevo mensaje ya abierto.

  Widgets para la pantalla de inicio de Android

Al incorporar varios enlaces en el diseño del widget, puede proporcionar acceso de un toque a todas las actividades más importantes de su aplicación, eliminando aún más pasos de navegación de las transmisiones más comúnmente utilizado

Al incorporar múltiples enlaces en sus diseños de widgets, puede proporcionar acceso de un toque a todas las tareas más importantes en su aplicación.

Tenga en cuenta que los widgets solo responden a eventos onClick, lo que evita que los usuarios interactúen accidentalmente con su widget mientras se desplazan en la pantalla principal. La única excepción es cuando el usuario intenta eliminar el widget arrastrándolo a la acción Eliminar en la pantalla de inicio, ya que en este escenario el widget responderá a un gesto de desplazamiento vertical.

Esta interacción es administrada por el sistema Android, por lo que no tiene que preocuparse por implementar manualmente el soporte de desplazamiento vertical en su widget.

Crear un widget de Android para fomentar la participación a largo plazo

Convencer a la gente de que descargue su aplicación es solo el primer paso para crear una aplicación de Android exitosa. ¡Es probable que si toma su teléfono inteligente o tableta Android y desliza el cajón de aplicaciones, descubrirá más aplicaciones que no ha usado en días, semanas o incluso meses!

Lea también: Introducción al SDK de Facebook para Android

Una vez que la aplicación se haya instalado correctamente en su dispositivo, tendrá que trabajar duro para involucrarlos y disfrutarlos. tu aplicación Darle presencia a su aplicación en la pantalla de inicio puede ser una herramienta poderosa para alentar la participación a largo plazo, ¡simplemente porque es un recordatorio constante de la existencia de su aplicación!

Un widget bien diseñado también puede servir como un anuncio continuo para su aplicación. Cada vez que el usuario mira su pantalla de inicio, su widget tiene la oportunidad de alentarlo activamente a interactuar con su aplicación nuevamente, presentándole todo el contenido más interesante y útil de su aplicación.

Creación de un widget para la aplicación de colección [19659010] En este tutorial, crearemos un widget de colección que muestra una matriz como ListView desplazable.

  En este tutorial, crearemos un widget de colección deslizante.

Para ayudarlo a realizar un seguimiento del ciclo de vida del widget de la aplicación, este widget también activará varios brindis a medida que avanza por los diferentes estados del ciclo de vida. Hacia el final de este tutorial, mejoraremos nuestro widget con una imagen de vista previa personalizada que se mostrará en el selector de widgets de Android y una tarea de configuración, que permitirá a los usuarios personalizar el widget antes de colocarlo en la pantalla principal. [19659022] ¡Crea un nuevo proyecto de Android con la configuración que prefieras y comencemos!

Creación del diseño del widget

Para comenzar, definamos la interfaz de usuario (UI) del widget.

Los widgets de la aplicación se muestran en un proceso externo a su aplicación, por lo que solo puede usar diseños y vistas compatibles con RemoteViews.

Al crear su diseño, está limitado a lo siguiente:

  • Botón de reloj analógico
  • cronómetro
  • FrameLayout
  • GridLayout
  • ImageButton
  • ImageView
  • LinearLayout
  • ProgressBar
  • ] RelativeLayout
  • TextView
  • ViewStub
  • AdapterViewFlipper
  • GridView
  • ListView
  • StackView
  • ViewFlipper

Tenga en cuenta que las subclases de las clases y vistas anteriores son no ] apoyado.

Cree un nuevo archivo de recursos de diseño llamado list_widget.xml. Dado que mostraremos nuestros datos utilizando ListView, este diseño sirve principalmente como contenedor para un elemento :



   

       
       
   

Rellenar el widget de colección

A continuación, necesitamos crear un proveedor de datos para nuestro ListView. Cree una nueva clase Java llamada DataProvider.java y agregue lo siguiente:

  import android.content.Context;
importar android.content.Intent;
importar android.widget.RemoteViews;
importar android.widget.RemoteViewsService;

import java.util.ArrayList;
import java.util.List;

importar android.R.id.text1 estático;
importar android.R.layout.simple_list_item_1 estático;

La clase pública DataProvider implementa RemoteViewsService.RemoteViewsFactory {

Lista  myListView = new ArrayList <> ();
Contexto mContext = null;

DataProvider público (contexto de contexto, intención de intención) {
mContext = contexto;
}

@Oltrepassare
public void onCreate () {
initdata ();
}

@Oltrepassare
public void onDataSetChanged () {
initdata ();
}

@Oltrepassare
public void onDestroy () {

}

@Oltrepassare
public int getCount () {
devuelve myListView.size ();
}

@Oltrepassare
publicViewView remoto getViewAt (posición int) {
Ver RemoteViews = new RemoteViews (mContext.getPackageName (),
simple_list_item_1);
view.setTextViewText (text1, myListView.get (posición));
vista de retorno;
}

@Oltrepassare
RemoteViews públicos getLoadingView () {
devuelve nulo;
}

@Oltrepassare
public int getViewTypeCount () {
retorno 1;
}

@Oltrepassare
public long getItemId (int position) {
posición de retorno;
}

@Oltrepassare
hasStableIds () público booleano {
verdadero retorno;
}

privado vacío initData () {
myListView.clear ();
para (int i = 1; i <= 15; i ++) {
myListView.add ("elemento ListView" + i);
}

}
} 

AppWidgetProvider: configuración de widgets

Para crear un widget de Android, debe crear varios archivos.

Nuestro primer archivo específico de widget es un AppWidgetProvider, que es un BroadcastReceiver en el que define los diversos métodos de ciclo de vida de los widgets, como el método llamado cuando se crea el widget por primera vez y el método llamado cuando el widget Finalmente se elimina.

Cree una nueva clase Java (Archivo> Nuevo> Clase Java) llamada CollectionWidget.

Para comenzar, todos los archivos del proveedor de widgets deben extenderse desde la clase AppWidgetProvider. Luego debemos cargar el archivo de recursos de diseño list_widget.xml en un objeto RemoteViews e informar al AppWidgetManager sobre el objeto RemoteViews actualizado:

  La clase pública CollectionWidget extiende AppWidgetProvider {

anular la actualización estática de AppWidget (contexto contextual, AppWidgetManager appWidgetManager,
int appWidgetId) {

// Crear una instancia del objeto RemoteViews //

Vistas RemoteViews = nuevas RemoteViews (context.getPackageName (), R.layout.list_widget);
setRemoteAdapter (contexto, vistas);

// Solicite que AppWidgetManager actualice el widget de la aplicación //

appWidgetManager.updateAppWidget (appWidgetId, vistas);

} 

Cree el adaptador

Dado que estamos mostrando nuestros datos en un ListView, necesitamos definir un método setRemoteAdapter () en nuestro AppWidgetProvider. SetRemoteAdapter () es equivalente a llamar a AbsListView.setRemoteViewsAdapter () pero está diseñado para usarse en widgets de aplicaciones.

En este método, es necesario definir la identificación de AdapterView (R.id.widget_list) y la intención del servicio que eventualmente proporcionará los datos a nuestro RemoteViewsAdapter; pronto crearemos esta clase WidgetService.

  setRemoteAdapter estático privado y vacío (Contexto contextual, @NonNull vistas remotas finales RemoteViews) {
views.setRemoteAdapter (R.id.widget_list,
nueva intención (contexto, WidgetService.class));
}

} 

Definición de los métodos del ciclo de vida del widget

En nuestro AppWidgetProvider, también debemos definir los siguientes métodos del ciclo de vida del widget:

Recuperación de nuevo contenido con onUpdate

El método del ciclo de widget life onUpdate () es responsable de actualizar sus vistas de widgets con nueva información.

Este método se llama cada vez:

  • El usuario realiza una acción que activa manualmente el método onUpdate ().
  • El intervalo de actualización especificado por la aplicación ha expirado.
  • una nueva instancia de este widget en su pantalla principal.
  • Una intención de transmisión ACTION_APPWIDGET_RESTORED se envía a AppWidgetProvider. Esta intención de transmisión se activa si el widget nunca se restaura desde la copia de seguridad.

Aquí también es donde grabará todos los controladores de eventos que debe utilizar su widget.

Al actualizar un widget de Android, es importante recordar que los usuarios pueden crear varias instancias del mismo widget. Por ejemplo, tal vez su widget sea personalizable y el usuario decida crear diferentes "versiones" que muestren información diferente o proporcionen acceso a funciones únicas.

Cuando llama a onUpdate (), debe especificar si está actualizando cada instancia de este widget o solo una instancia específica. Si desea actualizar cada instancia, puede usar appWidgetIds, que es una matriz de ID que identifica cada instancia en el dispositivo.

En el siguiente fragmento, estoy actualizando cada instancia:

  @Override
public void onUpdate (contexto contextual, AppWidgetManager appWidgetManager, int [] appWidgetIds) {
for (int appWidgetId: appWidgetIds) {

// Actualiza todas las instancias de este widget //

updateAppWidget (contexto, appWidgetManager, appWidgetId);
}
super.onUpdate (contexto, appWidgetManager, appWidgetIds);
} 

Tenga en cuenta que para ayudar a mantener el código simple, este método onUpdate () actualmente no está haciendo cambios en el widget.

onEnabled: ejecución de la configuración inicial

Se llama al método del ciclo de vida onEnabled () en respuesta a ACTION_APPWIDGET_ENABLED, que se envía cuando se agrega una instancia del widget a la pantalla principal por primera vez . Si el usuario crea dos instancias del widget, se llamará onEnabled () para la primera instancia, pero no para la segunda.

El método del ciclo de vida onEnabled () es donde debe realizar cualquier configuración requerida para todas las instancias del widget, como la creación de la base de datos que proporcionará información sobre el widget.

Mostraré un brindis, para que pueda ver exactamente cuándo se llama este método del ciclo de vida:

  @ Pass
public void onEnabled (contexto contextual) {
Toast.makeText (contexto, "onEnabled llamado", Toast.LENGTH_LONG) .show ();
} 

Si el usuario elimina todas las instancias del widget y luego crea una nueva instancia, se clasifica como la primera instancia y se llama nuevamente al método de ciclo de vida onEnabled ().

Limpieza, con onDisabled

Se llama al método onDisabled () en respuesta a ACTION_APPWIDGET_DISABLED, que se activa cuando el usuario elimina la instancia última del widget.

Este método de ciclo de vida del widget es donde necesita limpiar los recursos creados en el método onEnabled (), por ejemplo, eliminando la base de datos creada en onEnabled ().

Para ayudar a mantener nuestro código simple, simplemente mostraré un brindis cada vez que se active este método:

  @Over Pass
public void onDisabled (contexto contextual) {
Toast.makeText (contexto, "onDisabled llamado", Toast.LENGTH_LONG) .show ();
} 

El AppWidgetProvider completado

Su archivo CollectionWidget ahora debería verse así:

  import android.appwidget.AppWidgetManager;
importar android.appwidget.AppWidgetProvider;
importar android.content.Context;
importar androidx.annotation.NonNull;
importar android.content.Intent;
importar android.widget.RemoteViews;
importar android.widget.Toast;

// Ampliar desde la clase AppWidgetProvider //

la clase pública CollectionWidget extiende AppWidgetProvider {

anular la actualización estática de AppWidget (contexto contextual, AppWidgetManager appWidgetManager,
int appWidgetId) {

// Cargue el archivo de recursos de diseño en un objeto RemoteViews //

Vistas RemoteViews = nuevas RemoteViews (context.getPackageName (), R.layout.list_widget);
setRemoteAdapter (contexto, vistas);

// Informar a AppWidgetManager sobre el objeto RemoteViews //

appWidgetManager.updateAppWidget (appWidgetId, vistas);

}

@Oltrepassare
public void onUpdate (contexto contextual, AppWidgetManager appWidgetManager, int [] appWidgetIds) {
for (int appWidgetId: appWidgetIds) {
updateAppWidget (contexto, appWidgetManager, appWidgetId);
}
super.onUpdate (contexto, appWidgetManager, appWidgetIds);
}

@Oltrepassare
public void onEnabled (contexto contextual) {
Toast.makeText (contexto, "onEnabled llamado", Toast.LENGTH_LONG) .show ();
}

@Oltrepassare
public void onDisabled (contexto contextual) {
Toast.makeText (contexto, "onDisabled llamado", Toast.LENGTH_LONG) .show ();
}

sets estáticos privados vacíosRemoteAdapter (contexto de contexto, vistas finales remotas de @NonNull) {
views.setRemoteAdapter (R.id.widget_list,
nueva intención (contexto, WidgetService.class));
}

} 

El archivo AppWidgetProviderInfo

El widget de la aplicación también requiere un archivo AppWidgetProviderInfo, que define varias propiedades importantes, incluido el tamaño mínimo del widget y la frecuencia con la que debe actualizarse.

El archivo AppWidgetProviderInfo se almacena en la resolución de la carpeta project / xml.

  Si su proyecto aún no contiene un archivo XML, deberá crear uno.

Si su proyecto aún no contiene esta carpeta, deberá crearla:

  • Presione Ctrl y haga clic en la carpeta res de su proyecto.
  • Seleccione Nuevo> Directorio de recursos de Android.
  • En la siguiente ventana, abra el menú desplegable Tipo de recurso y seleccione xml.
  • El nombre del directorio debe actualizarse automáticamente a xml, pero de lo contrario tendrá que cambiarlo manualmente.
  • Haga clic en Aceptar. [19659063] Luego, crea un archivo collection_widget_info, que usaremos como AppWidgetProviderInfo:

    • Ctrl-clic en la carpeta xml de tu proyecto.
    • Seleccione Nuevo> Archivo de recursos XML.
    • Nombre este archivo collection_widget_info.
    • Haga clic en Aceptar.

    En nuestro archivo AppWidgetProviderInfo, debemos definir las siguientes propiedades:

    1. android: previewImage

    Este es el dibujo que representa el widget de la aplicación en el widget del dispositivo.

      Los usuarios pueden elegir un widget del Selector de widgets de Android.

    Si no proporciona una imagen de vista previa, Android utilizará el icono de la aplicación. Para alentar a los usuarios a seleccionar el widget del selector de widgets, debe proporcionar un diseño que muestre la apariencia del widget una vez que esté configurado correctamente en la pantalla de inicio del usuario.

    La forma más fácil de crear una imagen de vista previa es usar el widget de aplicación de vista previa incluido en el emulador de Android. Esta aplicación le permite configurar su widget y luego generar una imagen, que luego puede usar en su proyecto de Android.

    Crearemos esta imagen una vez que finalice la construcción de nuestro widget, por lo que por ahora utilizaré el recurso mipmap / ic_launcher generado automáticamente como una imagen de vista previa temporal.

    2. android: widgetCategory

    Los widgets de la aplicación deben colocarse dentro de una aplicación de widget host, que suele ser la pantalla de inicio estándar de Android, pero también puede ser un lanzador de terceros como Evie Launcher o Nova Launcher.

    Entre los niveles API 17 y 20, fue posible colocar widgets de aplicaciones en la pantalla principal o en la pantalla de bloqueo, pero el soporte de la pantalla de bloqueo ha quedado en desuso en el nivel API 21.

    Puede especificar si el widget de la aplicación se puede colocar en la pantalla principal, la pantalla de bloqueo (que Android llama "bloqueo de teclas") o ambos, utilizando el atributo de Android: widgetCategory. Como no es posible colocar widgets en la pantalla de bloqueo en las versiones más recientes de Android, solo apuntaremos a la pantalla de inicio.

    Para preservar la privacidad del usuario, su widget no debe mostrar ninguna información confidencial o privada cuando se coloca en la pantalla de bloqueo.

    Si ofrece a los usuarios la opción de colocar su widget en la pantalla de bloqueo, cualquiera que vea el dispositivo del usuario podría ver su widget y todo su contenido. Para ayudar a preservar la privacidad del usuario, su widget no debe mostrar ninguna información confidencial o privada cuando se coloca en la pantalla de bloqueo. Si su widget contiene datos personales, puede considerar proporcionar diseños separados para la pantalla de inicio y la pantalla de bloqueo.

    3. android: initialLayout

    Este es el archivo de recursos de diseño que su widget debe usar cuando se coloca en la pantalla de inicio, que para nuestro proyecto es list_widget.xml.

    4. android: resizeMode = "horizontal | vertical"

    El atributo android: resizeMode le permite especificar si su widget se puede cambiar de tamaño horizontal, vertical o a lo largo de ambos ejes.

    Para garantizar que su widget se muestre y funcione correctamente en una variedad de pantallas, se recomienda permitir que el widget se redimensione horizontalmente y verticalmente, a menos que tenga una razón específica para no lo hagas

    5. android: minHeight y android: minWidth

    Si su widget es redimensionable, debe asegurarse de que el usuario no lo reduzca hasta el punto en que quede inutilizable. Puede usar los atributos minHeight y minWidth para definir lo más pequeño que se reducirá su aplicación cuando el usuario cambie su tamaño.

    Estos valores también representan el tamaño inicial del widget, por lo que si el widget no es redimensionable, minHeight y minWidth definirán el tamaño permanente del widget.

    6. android: updatePeriodMillis

    AppWidgetProviderInfo también es el lugar donde se especifica con qué frecuencia el widget necesita solicitar nueva información.

    El intervalo de actualización más pequeño admitido es una vez cada 1800000 milisegundos (30 minutos). Incluso si declara un intervalo de actualización más corto, su widget se actualizará solo una vez cada media hora.

    Si bien es posible que desee ver la información más reciente lo más rápido posible, el sistema activará el dispositivo para dormir para recuperar nueva información. Las actualizaciones frecuentes pueden quemarse a través de la batería de un dispositivo, especialmente durante los períodos en que el dispositivo permanece inactivo durante un período de tiempo significativo, como durante la noche. Brindar la mejor experiencia de usuario posible significa encontrar un equilibrio entre limitar el consumo de batería y proporcionar nueva información en un tiempo razonable.

    También debe considerar el tipo de contenido que mostrará su widget.

    También debes considerar el tipo de contenido que mostrarán tus widgets para Android. Por ejemplo, un widget del clima puede necesitar recuperar un pronóstico actualizado solo una vez al día, mientras que una aplicación que muestra las últimas noticias tendrá que actualizarse con más frecuencia.

    Para encontrar este equilibrio perfecto, es posible que deba probar su widget en un rango de frecuencias de actualización y medir el impacto en la vida útil de la batería y la puntualidad del contenido de su widget. Si tiene un grupo de evaluadores disponible, también puede configurar pruebas A / B para ver si algunas frecuencias de actualización se reciben de manera más positiva que otras.

    También lea: AndroidManifest.xml todo lo que necesita saber [19659022] Finalmente, una vez que haya identificado el intervalo de actualización perfecto, es posible que desee utilizar un intervalo más corto durante el desarrollo y prueba de su aplicación . Por ejemplo, podría usar la tasa de actualización más corta posible (android: updatePeriodMillis = ”1800000 ″) cuando esté probando que el método onUpdate () de su aplicación se está activando correctamente, así que cambie este valor antes de lanzar su aplicación al público .

    El AppWidgetProviderInfo completo

    El archivo collection_widget_info.xml terminado debería verse así:

      
    
    
     

    ¡No abarrotes tu pantalla de inicio!

    Para garantizar que la pantalla de inicio nunca aparezca abarrotada, agregaremos un poco de relleno y márgenes a nuestro widget. Si su proyecto aún no contiene un archivo dimens.xml, deberá crear uno:

    • Ctrl-clic en la carpeta de valor de su proyecto.
    • Seleccione Nuevo> Archivo de recursos de valor.
    • Proporcione a este archivo el nombre dimens.
    • Haga clic en Aceptar.

    Abra su archivo dimens.xml y defina los siguientes valores de margen y relleno:

      
     10dp [19659164] 8DP 
     

    Envío de datos al widget

    A continuación, debe crear un servicio de widget, que será responsable de enviar los datos de nuestra colección al widget.

    Cree una nueva clase Java (Nueva> Clase Java) llamada WidgetService y agregue lo siguiente:

      import android.content.Intent;
    importar android.widget.RemoteViewsService;
    
    public class WidgetService extiende RemoteViewsService {
    @Oltrepassare
    RemoteViewsFactory público enGetViewFactory (intento de intención) {
    devuelve un nuevo DataProvider (esto, intento);
    }
    } 

    Registrando el widget en Manifiesto

    Ahora necesitamos hacer algunos cambios en el Manifiesto de nuestro proyecto.

    Para comenzar, abre Manifiesto y registra tu widget como BroadcastReceiver. También necesitamos agregar una intención de filtro para la acción android.appwidget.action.APPWIDGET_UPDATE:

      
    
    
     

    A continuación, debe especificar el proveedor de widgets de la aplicación:

      
     

    Finalmente, debemos declarar el servicio que enviará los datos a nuestro widget, que en este caso es la clase WidgetService. Este servicio requiere la autorización android.permission.BIND_REMOTEVIEWS:

       

    Pruebe su widget

    Si siguió este tutorial, ahora tendrá un widget de colección completo que muestra una serie de datos en la pantalla de inicio del usuario.

      Crear widgets para Android

    Si se tratara de un proyecto de Android en la vida real, los métodos del ciclo de vida generalmente se expanden, en particular el método onUpdate (), pero eso es todo lo que necesitamos para crear un widget que pueda instalar y probar en su dispositivo Android:

    • Instale este proyecto en un teléfono inteligente, tableta o AVD (dispositivo virtual Android) compatible con Android. [19659047] Mantenga presionada cualquier sección vacía de la pantalla de inicio y seleccione Widgets cuando se le solicite; Esto inicia el selector de widgets.
    • Desplaza el selector de widgets hasta que encuentres el widget de la aplicación que acabas de crear.
    • Mantenga presionado este widget para agregarlo a su pantalla de inicio.
    • Dado que esta es la primera instancia de este widget en particular, el método onEnabled () debe ejecutarse y verá un brindis "onEnabled" llamado.
    • Cambiar el tamaño del widget. Si establece un tamaño mínimo admitido, asegúrese de no poder reducir el widget más allá de este valor.
    • Verifique que ListView se esté desplazando, como se esperaba.
    • A continuación, debe verificar el método onDisabled (), eliminando el widget. Mantenga presionado el widget, luego seleccione Eliminar de la pantalla principal. Dado que este es el último recurso de este widget en particular, se debe ejecutar el método onDisabled () y verá un brindis "onDisabled llamado".

    Questo è tutto ciò che serve per fornire un widget di applicazione Android funzionante, ma c&#39;è un alcune aggiunte che spesso possono migliorare l&#39;esperienza dell&#39;utente. Nelle sezioni seguenti, incoraggeremo gli utenti a scegliere questo widget dal Selettore widget, creando un&#39;immagine di anteprima che mostri il widget al meglio. Ti mostrerò anche come creare un widget completamente personalizzabile, aggiungendo un&#39;attività di configurazione al tuo progetto.

    Creazione di un&#39;immagine di anteprima del widget Android

    Se prendi il tuo dispositivo Android e scorri il Widget Picker, tu vedrai che ogni widget è rappresentato da un&#39;immagine, che di solito dimostra come apparirà questo widget una volta configurato nella schermata iniziale dell&#39;utente.

    Per incoraggiare gli utenti a selezionare il tuo widget, devi fornire un&#39;immagine di anteprima che evidenzi tutti i informazioni utili e funzionalità che il tuo widget ha da offrire.

    Puoi creare rapidamente e facilmente un&#39;immagine di anteprima, utilizzando l&#39;applicazione Anteprima widget inclusa nell&#39;emulatore Android.

    Nota che l&#39;anteprima del widget non è inclusa nell&#39;ultima Immagini di sistema Android, quindi dovrai creare un AVD usando Nougat (API Level 25) o precedente:

    • Installa la tua applicazione su un AVD che esegue API 25 o precedente.
    • Apri il cassetto delle app di AVD e avvia l&#39;app Anteprima widget.
    • L&#39;anteprima widget visualizzerà un elenco di tutte le applicazioni attualmente installate su questo AVD; seleziona la tua applicazione dall&#39;elenco.

     Crea un&#39;immagine di anteprima utilizzando l&#39;applicazione Anteprima widget.

    • Il tuo widget verrà ora visualizzato su uno sfondo vuoto. Dedica un po &#39;di tempo al ridimensionamento e all&#39;ottimizzazione del tuo widget fino a quando mostra il meglio che il tuo widget ha da offrire.
    • Quando sei soddisfatto dell&#39;aspetto e del contenuto del tuo widget, seleziona Scatta istantanea.

     Configura il tuo widget e fai uno screenshot, facendo clic sul pulsante Fotocamera.

    • Per recuperare la tua istantanea, torna ad Android Studio e seleziona Visualizza> Strumenti Windows> Esplora file dispositivo dalla barra degli strumenti . Questo avvia Device File Explorer di Android Studio.
    • In Device File Explorer, passa a sdcard / Download. Dovresti trovare l&#39;immagine di anteprima salvata nel seguente formato: [application_name] _ori_ [orientation] .png

     Estrai lo screenshot dall&#39;AVD

    • Trascina l&#39;immagine da Android Studio e rilasciarlo da qualche parte facilmente accessibile, come ad esempio il desktop.
    • Assegna a questo file immagine un nome descrittivo.
    • Trascina e rilascia il file nella cartella disegnabile del progetto.
    • Apri AppWidgetProviderInfo, che per questo progetto è collection_widget_info. xml.
    • Trova la linea android: previewImage = "@ mipmap / ic_launcher" e aggiornala per fare riferimento all&#39;immagine di anteprima.

    Il tuo widget ora utilizzerà questa nuova risorsa immagine come immagine di anteprima:

    • Installa l&#39;aggiornamento aggiornato progetto sul tuo dispositivo Android fisico o AVD.
    • Premi a lungo qualsiasi sezione vuota della schermata iniziale.
    • Tocca Widget, che avvia il Widget Picker.
    • Scorri fino al tuo widget; it should now be using the updated preview image.

    Customizable widgets: Adding a configuration Activity

    A configuration Activity launches automatically when the user places each instance of your widget on their homescreen.

    There’s several reasons why you might want to add a configuration Activity to your project.

    widgets tend to provide the best user experience when they provide access to the information or features that are most important to the individual user.

    Firstly, some widgets require initial setup, for example a widget that displays traffic alerts might need to know the user’s home address, where they work, and the times when they typically commute. Without some way to enter this information, your widget might be completely useless!

    In addition, widgets tend to provide the best user experience when they provide access to the information or features that are most important to the individual user. By adding a configuration Activity to your project, you can give users the freedom to pick and choose exactly what’s included in your widget.

    Even relatively straightforward customizations, such as changing a widget’s background or font, can have a positive impact on the user experience – after all, no-one’s going to appreciate a widget that visually clashes with the rest of their homescreen!

    No-one’s going to appreciate a widget that visually clashes with the rest of their homescreen!

    Alternatively, sometimes you may have a long list of content that you want to include in your widget, and you’re struggling to narrow down your options. A configuration Activity can be a way to put all of your ideas to good use, without creating a cluttered, confusing widget. Just bear in mind that setting up a widget shouldn’t feel like a chore, so if you do provide a configuration Activity then it’s recommended that you limit yourself to three configuration options.

    Let’s add a configuration Activity to our project!

    Firstly, our configuration Activity needs a layout, so create a new layout resource file named config_activity.xml.

    I’m going to add the following buttons to this layout:

    • A configuration button. In a real-life project, this button would modify the widget in some way, for example adding or removing content, or changing how frequently the widget updates. To help keep our code straightforward, clicking this button will simply display a Configuration Options toast.
    • A setup button. Once the user is happy with how their widget is configured, pressing this button will place the newly-configured widget on their homescreen.

    Here’s my completed config_activity.xml file:

    
    
    
        

    Create the Configuration Activity

    Now, we need to create our configuration Activity.

    To start, create a new Java class named ConfigActivity. In this Activity, we’re going to retrieve the App Widget ID from the intent that launched the configuration Activity. If this intent doesn’t have a widget ID, then we’ll need to call the finish() method:

            Intent intent = getIntent();
            Bundle extras = intent.getExtras();
            if (extras != null) {
                appWidgetId = extras.getInt(
                        AppWidgetManager.EXTRA_APPWIDGET_ID,
                        AppWidgetManager.INVALID_APPWIDGET_ID);
           if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
                    finish();
                }

    Next, we need to create a return intent, pass the original appWidgetId and set the results from the configuration Activity:

                Intent resultValue = new Intent();
                resultValue.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
                setResult(RESULT_OK, resultValue);
                finish();
            }
        }
    }

    If you provide a configuration Activity, then the ACTION_APPWIDGET_UPDATE broadcast won’t be sent automatically when the configuration Activity is launched, which means the onUpdate() method won’t be called when the user creates an instance of your widget.

    To ensure your widget is created with up-to-date information and content, your configuration Activity must trigger the first onUpdate() request.

    Here’s the completed ConfigActivity:

    import android.app.Activity;
    import android.appwidget.AppWidgetManager;
    import android.os.Bundle;
    import android.widget.Button;
    import android.content.Intent;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Toast;
    
    public class ConfigActivity extends Activity {
    
         @Override
         protected void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
             setContentView(R.layout.config_activity);
             setResult(RESULT_CANCELED);
             Button setupWidget = (Button) findViewById(R.id.setupWidget);
             setupWidget.setOnClickListener(new OnClickListener() {
    
                 @Override
                 public void onClick(View v) {
                     handleSetupWidget();
                 }
    });
            Button configButton = (Button) findViewById(R.id.configButton);
            configButton.setOnClickListener(new OnClickListener() {
    
                @Override
                public void onClick(View v) {
                    handleConfigWidget();
                }
    });
    
        }
    
        private void handleSetupWidget() {
            showAppWidget();
    
        }
    
        private void handleConfigWidget() {
            Toast.makeText(ConfigActivity.this,
                    "Configuration options", Toast.LENGTH_LONG).show();
    
        }
    
        int appWidgetId;
        private void showAppWidget() {
            appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
    
            Intent intent = getIntent();
            Bundle extras = intent.getExtras();
            if (extras != null) {
                appWidgetId = extras.getInt(
                       AppWidgetManager.EXTRA_APPWIDGET_ID,
                       AppWidgetManager.INVALID_APPWIDGET_ID);
    
                if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
                    finish();
                }
    
    //TO DO: Perform the configuration//
    
                Intent resultValue = new Intent();
                resultValue.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId);
                setResult(RESULT_OK, resultValue);
                finish();
            }
        }
    }

    Once you’ve created a configuration Activity, you need to declare this Activity in the Manifest and specify that it accepts the APPWIDGET_CONFIGURE action:

           
               
                   
               
            

    Finally, since a configuration Activity is referenced outside of the package scope, we need to declare this Activity in our AppWidgetProviderInfo, which in this instance is the collection_widget_info.xml file:

       android:configure="com.jessicathornsby.collectionwidget.ConfigActivity">

    Testing your project

    Now it’s time to put your finished project to the test:

    • Install your updated project on a physical Android device or AVD.
    • Delete all previous instances of your widget, to ensure you’re working with the very latest version.
    • Long-press any empty area of the homescreen and select Widgets when prompted.
    • Find your widget in the Widget Picker and long-press to select it.
    • Drop the widget onto your homescreen. The Configuration Activity should launch automatically.
    • Give the Perform Some Configuration button a click, and a Configuration Options toast should appear, confirming that this interaction has been registered successfully.
    • Imagine that you’ve tweaked the widget’s settings and are now ready to place it on your homescreen; give the Create The Widget button a tap, and this widget should be created successfully.

    You can download the completed collection widget project from GitHub.

    Wrapping up

    How to Make an Android Widget

    In this article, we created a scrollable collection widget that displays a data set on the user’s homescreen.

    If you want to continue working with this project, then you could try adding your own code to the onUpdate() method, to create a widget that updates with new information at the interval defined in your AppWidgetProviderInfo file (collection_widget_info).

    If you do create an Android widget, then be sure to share your creations in the comments below!

    More posts about Android Development

    Save 60% on our Introduction to Android Development Course

    Android Authority has created a course to help you learn how to develop Android Apps! No Coding Experience Required. Start Your Journey on Becoming an Android Developer today.

    Visit DGiT Academy today. Enter discount code: SIXTYOFF at checkout to receive 60% off.

Compruebe también

Ayudar a las familias a encontrar aplicaciones de alta calidad para niños

Publicado por Mindy Brooks, Gerente General, Niños y FamiliaLas aplicaciones juegan un papel cada vez …

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *