CURSO DE DESARROLLO DE APLICACIONES ANDROID

Tema 18

Widgets
TEMA 18. WIDGETS

Introducción

Android permite la inclusión de widgets (aplicaciones en miniatura) en otras aplicaciones

como, por ejemplo, en la Pantalla de Inicio, los cuales podrán recibir actualizaciones periódicas
de la información que muestran. Los widgets son vistas (View) publicadas a través del
Proveedor de Widgets (App Widget Provider). Las aplicaciones que poseen componentes
capaces de contener widgets de otras aplicaciones se denominan aplicaciones Widget Host.
Existen diferentes categorías de widgets:

• Widgets informativos: muestran la información más importante, manteniéndola

actualizada. Al pulsar el widget se suele abrir la aplicación asociada para mostrar la
información con detalle.
• Widgets de colecciones: son widgets especializados en mostrar conjuntos de
elementos del mismo tipo, como por ejemplo un listado de contactos, o un listado de
mails. Son utilizados para explorar el listado de elementos así como para abrir un
elemento, visualizar su detalle y eliminarlo de la colección, si es necesario (como por
ejemplo, en el caso de un listado de mails sin leer).
• Widgets de control: son widgets especializados en mostrar controles asociados a
funciones que el usuario puede activar o desactivar directamente desde la Pantalla de
Inicio, sin necesidad de abrir la aplicación asociada.
• Widgets híbridos: están compuestos por una combinación de los tres tipos de widgets
anteriores.

Los widgets tienen ciertas limitaciones. Debido a que viven en la Pantalla de Inicio, deben
coexistir con los gestos que se aplican para navegar en dicha Pantalla de Inicio. Esto implica
que un widget solo puede gestionar gestos de deslizamientos verticales (vertical swipe) y
toques (touch).
Para crear un widget, se necesita, como mínimo:

• Una instancia de AppWidgetProviderInfo, que describe los metadatos del widget

tales como su layout, la frecuencia de actualización o la clase de tipo
AppWidgetProvider asociada, todo ello a través de un archivo XML.
• Una implementación de AppWidgetProvider, donde serán definidos los métodos
básicos que permiten interactuar con el widget, basados en eventos broadcast. Estos
eventos informarán cuándo el widget es actualizado, habilitado, deshabilitado o
borrado.
• Un layout asociado al widget, definido en un archivo XML.

También se puede implementar una actividad especializada en configurar el widget y que será
iniciada cuando el usuario añada el widget a la Pantalla de Inicio.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 2

TEMA 18. WIDGETS

Declaración del widget en el manifiesto y archivo de metadatos

AppWidgetProviderInfo

El proveedor del widget, la clase que extiende a AppWidgetProvider, es en realidad un

receptor de broadcast 1, por lo que se deberá declarar como tal en el manifiesto de la
aplicación, añadiendo, dentro del elemento <application>, el siguiente elemento
<receiver>:

<receiver android:name="MyWidgetProvider" >

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

<meta-data
android:name="android.appwidget.provider"
android:resource="@xml/my_widget_provider_info" />

</receiver>

El elemento <receiver> especifica el nombre de la clase que extenderá a

AppWidgetProvider.

Es necesario especificar a través de un <intent-filter> que el proveedor acepta el

broadcast ACTION_WIDGET_UPDATE. Además, este será el único filtro explícito que deberá ser
declarado. El gestor de widgets, AppWidgetManager, enviará automáticamente cualquier otro
tipo de broadcast del widget a su proveedor.
El elemento <meta-data> especifica la localización del archivo que define el recurso
AppWidgetProviderInfo.

A través del atributo android:name=”android.appwidget.provider” se especifica que el

archivo referenciado contiene el descriptor de AppProviderInfo. El atributo
android:resource contiene la referencia del archivo XML, que estará ubicado en la carpeta
“res/xml/” y cuyo nombre será my_widget_provider_info.xml
AppWidgetProviderInfo define las características principales del widget, entre las que se
encuentran las dimensiones mínimas de su layout, el layout inicial, la frecuencia de
actualización o la actividad de configuración que será iniciada cuando se cree el widget, en
caso de que exista. Este objeto será definido como un recurso XML utilizando un único
elemento <appwidget-provider>. Por ejemplo:

1
AppWidgetProvider es subclase de BroadcastReceiver.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 3

TEMA 18. WIDGETS

<?xml version="1.0" encoding="utf-8"?>

<appwidget-provider
xmlns:android="http://schemas.android.com/apk/res/android"
android:configure=
"com.cursoandroid.ui.widget.MyWidgetConfigurationActivity"
android:initialKeyguardLayout="@layout/my_keyguard_widget_layout"
android:initialLayout="@layout/my_initial_widget_layout"
android:minHeight="40dp"
android:minWidth="40dp"
android:previewImage="@drawable/my_widget_preview"
android:resizeMode="horizontal|vertical"
android:updatePeriodMillis="3600000"
android:widgetCategory="home_screen|keyguard" >

</appwidget-provider>

En este descriptor se debe especificar el espacio mínimo que ocupará el widget por defecto
(minWidth y minHeight). La Pantalla de Inicio ubica los widgets en una cuadrícula cuyas celdas
tienen un ancho y un alto específico 2. El ancho y alto mínimo especificados serán utilizados
para redondear al alza el tamaño del widget en función del tamaño de estas celdas.
El tamaño del widget también se verá afectado por los márgenes de las celdas. En función del
número de celdas que se ocupen, se puede estimar el tamaño del widget a través de esta
tabla:

Número de celdas que ocupa el widget Tamaño disponible para el widget

(en vertical u horizontal) (minWidth o minHeight)
1 40 dp
2 110 dp
3 180 dp
… …
n (70 × n − 30) dp

Para especificar el tamaño mínimo absoluto del widget se utilizarán los atributos
minResizeWidht y minResizeHeight. Por debajo de estas dimensiones, el widget será
ilegible o no podrá ser utilizado. Estos atributos son introducidos en Android 3.1 y permiten
que el usuario redimensione el widget a un tamaño menor que el tamaño por defecto,
especificado a través de minWidth y minHeight.
La frecuencia de actualización de los datos que muestra el widget es especificada a través del
atributo updatePeriodMillis (en milisegundos), lo cual se traduce en la frecuencia con la que
el sistema invoca al método onUpdate() en el proveedor (AppWidgetProvider). No se
garantiza que el momento de la actualización sea exacto, por lo que se recomienda que se

2
El número de filas y columnas de esta cuadrícula, así como el tamaño de cada celda, varía en función del
dispositivo. Por ejemplo, los dispositivos móviles utilizan una cuadrícula de 4x4 mientras que las tablets utilizan una
cuadrícula de 8x7. Por lo tanto, para que un widget sea compatible con la mayor cantidad de dispositivos distintos
posible deberá tener un tamaño mínimo no superior a 4x4 celdas.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 4

TEMA 18. WIDGETS

utilice la frecuencia de actualización más baja posible (se ha de tener en cuenta que un
dispositivo en stand-by será encendido para poder realizar la actualización).
Para realizar actualizaciones frecuentes del widget solamente cuando el dispositivo está
encendido se deberá establecer updatePeriodMillis="0" y utilizar una alarma que lance un
Intent que reciba el proveedor del widget, a través de AlarmManager. La alarma deberá ser
de tipo ELAPSED_REALTIME o RTC, ya que estos tipos solo envían la alarma si el dispositivo
está encendido.
Los atributos initialLayout e initialKeyguardLayout referencian a los layouts que
definen el aspecto del widget en la Pantalla de Inicio y en la Pantalla de Bloqueo del
dispositivo 3 respectivamente. Estos layouts se consideran iniciales ya que son los que el
sistema muestra inmediatamente, mientras el widget se inicializa y es capaz de actualizar su
layout.

Para definir una actividad que permita que al usuario configurar las propiedades del widget en
el momento en que sea creado, se utiliza el atributo configure.

El atributo previewImage referencia a una imagen que será utilizada como previsualización del
aspecto del widget una vez configurado, y que será mostrada por el sistema cuando el usuario
navegue por la lista de widgets disponibles. En caso de que esta imagen no exista, el sistema
utilizará el icono launcher asociado a la aplicación. Esta imagen puede ser creada gracias a la
aplicación Widget Preview, que viene preinstalada en los AVDs.

El atributo resizeMode especifica cómo puede redimensionarse el widget: horizontalmente,

verticalmente, de las dos formas o de tamaño fijo.

Para especificar las pantallas (de Inicio y/o de Bloqueo) en las que el widget aparecerá, se
utiliza el atributo widgetCategory. El valor por defecto es home_screen.

3
A partir de Android 4.2 se permite la inclusión de widgets en la Pantalla de Bloqueo.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 5

TEMA 18. WIDGETS

Layout del widget

El layout inicial del widget será almacenado como archivo XML en el directorio “res/layout/”.
Debido a que los layouts de los widgets se basan en RemoteViews 4, existen ciertos tipos de
componentes y layouts que no pueden formar parte de los widgets. Los objetos de tipo
RemoteViews (y por tanto los widgets) solo soportan los layouts FrameLayout,
LinearLayout, RelativeLayout y GridLayout, así como las clases (vistas) AnalogClock,
Button, Chronometer, ImageButton, ImageView, ProgressBar, TextView, ViewFlipper,
ListView, GridView, StackView y AdapterViewFlipper. Además, no están soportadas clases
que hereden de las anteriores. También se puede usar ViewStub, vista que es invisible y que
no ocupa espacio, para inflar en segundo plano recursos en tiempo de ejecución.

Los widgets deben especificar cierto margen ya que no deben alcanzar los límites de la pantalla
del dispositivo o solapar con otros widgets.

A partir de Android 4.0, el sistema asigna automáticamente cierto padding 5 a los widgets para
proporcionar un mejor alineamiento de iconos y widgets. Es muy recomendable aplicar este
comportamiento, para lo cual será necesario asociar targetSdkVersion al nivel de API 14 (o
superior).

Para crear un único layout que tenga márgenes específicos para versiones anteriores de
Android y que no tenga márgenes a partir de Android 4.0 (ya que tendrá padding), se
establecerá targetSdkVersion="14" y se creará un layout similar al siguiente, que referencie
a recursos de tipo dimension en los márgenes:

<?xml version="1.0" encoding="utf-8"?>

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:padding="@dimen/my_widget_margin" >

<LinearLayout
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="@drawable/my_widget_background"
android:orientation="horizontal" >

<!-- etc. -->

</LinearLayout>
</FrameLayout>

4
RemoteViews es una clase que describe una jerarquía de vistas (View) que pueden ser mostradas en otro proceso
(como por ejemplo, en una aplicación host tipo launcher). Proporciona métodos para inflar remotamente el layout
así como para modificar las propiedades de sus componentes.
5
Este padding es el espacio libre que existe entre el límite del widget y el límite del conjunto de celdas que ocupe
en la pantalla.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 6

TEMA 18. WIDGETS

Además, se crearán dos recursos de tipo dimension que serán almacenados en las carpetas
“res/values/” y “res/values-v14/” para proporcionar márgenes específicos en versiones
anteriores a Android 4.0 y para no añadir padding extra en versiones posteriores,
respectivamente:

• Recurso res/values/dimens.xml:

<?xml version="1.0" encoding="utf-8"?>

<resources>
<dimen name="my_widget_margin">10dp</dimen>
</resources>

• Recurso res/values-v14/dimens.xml:

<?xml version="1.0" encoding="utf-8"?>

<resources>
<dimen name="my_widget_margin">0dp</dimen>
</resources>

Cuando un widget es añadido a la Pantalla de Bloqueo, se ignoran los atributos minWidth,

minHeight, minResizeWidth y minResizeHeight especificados en los metadatos del
proveedor (sí son tenidos en cuenta si se añade a la Pantalla de Inicio).

El ancho que ocupará el widget en la Pantalla de Bloqueo se ajustará al espacio asignado. La

altura, en cambio, adoptará diferentes valores. Si se ha especificado el widget como
redimensionable verticalmente (android:resizeMode="vertical"), la altura será la mínima
posible si la orientación es vertical, y ocupará el espacio disponible en cualquier otro caso.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 7

TEMA 18. WIDGETS

Proveedor del widget

El proveedor del widget es una clase que extenderá a AppWidgetProvider quien a su vez
hereda de BroadcastReceiver. Es, por lo tanto, un receptor de broadcasts y así tiene que ser
declarado en el manifiesto, a través de <receiver>, tal y como ya se ha comentado
previamente.

El proveedor recibirá solamente los eventos de broadcast que son relevantes para el widget,
como por ejemplo cuándo este es actualizado, habilitado, deshabilitado o borrado. Cuando
estos eventos ocurren, se invocan a los siguientes métodos callback en el proveedor del
widget:

• onUpdate(Context, AppWidgetManager, int[]): método callback más importante,

y, en general, el único necesario. Es invocado para actualizar el widget en función de la
frecuencia establecida por updatePeriodMillis en AppWidgetProviderInfo.
También es invocado cuando el usuario añade el widget al host host (Pantalla de Inicio
o de Bloqueo). En este método se realizará la inicialización del widget como, por
ejemplo, la definición de gestores de eventos de las diferentes View, o la creación de
servicios. Este método no es invocado cuando el usuario añade el widget si se ha
declarado una actividad de configuración, la cual tendrá la responsabilidad de realizar
la primera actualización del widget una vez haya sido configurado.
• onAppWidgetOptionsChanged(Context, AppWidgetManager, int, Bundle):
método invocado cuando el widget es situado en un o cuando cambia su tamaño. Este
método se utilizará para mostrar u ocultar elementos (View) en función del nuevo
tamaño del widget. Para obtener las nuevas medidas, se invocará a
getAppWidgetOptions(), método que devolverá un Bundle con las nuevas medidas
máximas y mínimas, en dp (OPTION_APPWIDGET_MIN_WIDTH,
OPTION_APPWIDGET_MIN_HEIGHT, OPTION_APPWIDGET_MAX_WIDTH,
OPTION_APPWIDGET_MAX_HEIGHT).
• onDeleted(Context, int[])): método invocado cuando el widget es eliminado del
host.
• onEnabled(Context): método invocado cuando se crea una instancia del widget por
primera vez. Será utilizado por ejemplo para abrir una nueva base de datos o para
realizar cualquier otro tipo de inicialización de recursos que sean compartidos por
todas las instancias del widget.
• onDisabled(Context): método invocado cuando la última instancia del widget es
eliminada del host. Será utilizado para limpiar el trabajo realizado en el método
onEnabled() como, por ejemplo, eliminar una base de datos temporal.
• onReceive(Context, Intent): método invocado en cada evento de broadcast y
antes que cualquiera de los métodos anteriores. Este método no suele ser
implementado ya que la implementación por defecto de AppWidgetProvider ya filtra

CURSO DE DESARROLLO DE APLICACIONES ANDROID 8

TEMA 18. WIDGETS

los eventos de brodcast del widget, invocando a los métodos anteriores

automáticamente 6.

Tal y como ya se ha comentado, el método más importante del proveedor será onUpdate(),
que recibe como parámetro un array con los identificadores de todas las instancias del widget
que haya. Por ejemplo, en el caso de un widget que muestre un número aleatorio distinto en
cada instancia, será necesario realizar la inicialización para cada una de dichas instancias del
widget, de un modo similar al siguiente:

public void onUpdate(Context context, AppWidgetManager appWidgetManager,

int[] appWidgetIds) {

Log.d(TAG, "onUpdate");
final int N = appWidgetIds.length;
// Se realiza la inicialización de cada instancia del widget que
// exista
for (int i = 0; i < N; i++) {
int appWidgetId = appWidgetIds[i];
Log.d(TAG, "onUpdate. appWidgetId=" + appWidgetId);
updateAppWidget(context, appWidgetManager, appWidgetId);
}
}

static void updateAppWidget(Context context,

AppWidgetManager appWidgetManager, int appWidgetId) {

// Se obtiene un número aleatorio

int rndNmbr = new Random().nextInt();

Log.d(TAG, "updateAppWidget appWidgetId=" + appWidgetId +

" rndNmbr=" + rndNmbr);

// Se construye el objeto RemoteViews a través del nombre del paquete

// (en este caso, es el propio paquete, pero es necesario porque el
// host que infla el layout del widget está fuera de este paquete)
RemoteViews views = new RemoteViews(context.getPackageName(),
R.layout.my_widget_layout);

// Se crea un Intent para invocar al proveedor cuando se pulse el

// widget y así actualizar cambiar el número aleatorio
Intent widgetIntent = new Intent(context, MyWidgetProvider.class);
widgetIntent.setAction(ACTION_WIDGET_GET_NEXT_RANDOM);
// Es importante añadir el id del widget para luego poder actualizar
// la instancia correcta
widgetIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID,
appWidgetId);

6
Existe un bug en Android 1.5 que hace que no se invoque el método onDeleted(). Este bug puede ser solventado
implementando el método onReceive() para invocar a onDeleted() tal y como se explica en este post:
https://groups.google.com/forum/?fromgroups=#!msg/android-developers/Nl0e06rDCRY/4nAh3xnKBeQJ

CURSO DE DESARROLLO DE APLICACIONES ANDROID 9

TEMA 18. WIDGETS

// El PendingIntent está dirigido a receptor de broadcast (esta clase)

// Hay que invocar a getBroadcast(). Se asocia appWidgetId a
// requestParameter para que no se sobrescriban los distintos
// PendingIntent de las distintas instancias del widget.
PendingIntent widgetPendingIntent =
PendingIntent.getBroadcast(context, appWidgetId,
widgetIntent, 0);

// Se obtiene el layout del widget y se establece el listener

// onClick a la TextView, así como el número aleatorio
views.setOnClickPendingIntent(R.id.rootWidgetLayout,
widgetPendingIntent);
views.setTextViewText(R.id.textViewRandomNumber, "" + rndNmbr);

// Se solicita al manager que actualice el widget

appWidgetManager.updateAppWidget(appWidgetId, views);
}

En el código anterior puede observarse cómo se inicializan todas las instancias del widget. La
inicialización consiste en acceder a su layout (a través de RemoteViews) para añadir un
PendingIntent que hará un broadcast al proveedor del widget cada vez que se pulse el
widget (y que hará que se actualice el número aleatorio mostrado), ya que se añade como
evento on-click a rootWidgetLayout (identificador del elemento raíz del layout del widget;
por ejemplo, un RelativeLayout). Además, se actualiza el número que se muestra,
accediendo a una TextView contenida en el layout.

Todas las instancias que existan del widget serán actualizadas a la vez. Como sólo existe un
único valor del atributo updatePeriodMillis, el evento de actualización se envía a la vez a
todas las instancias. Pese a que se hayan añadido en distintos momentos, todas se actualizarán
con el periodo establecido por la primera instancia añadida.

Debido a que el proveedor del widget es un receptor de broadcast (extiende a

BroadcastReceiver), después de que se hayan ejecutado los métodos callback, el sistema
puede finalizar el proceso del widget si lo considera necesario. Si la inicialización del widget
lleva cierto tiempo, debido por ejemplo a la descarga de recursos adicionales, y es necesario
que el proceso no sea finalizado (es decir, para que el sistema no lance Application Not
Responding - ANR), se deberá iniciar un servicio para realizar dicha tarea. Desde dicho servicio
se podrá actualizar el widget, evitando así el error ANR.

Pese a que el proveedor gestiona los broadcasts del widget automáticamente, invocando a los
métodos callback correspondientes, se podrá modificar este comportamiento sobrescribiendo
el método onReceive() para gestionar los Intent con las acciones
ACTION_APPWIDGET_UPDATE, ACTION_APPWIDGET_DELETED, ACTION_APPWIDGET_ENABLED,
ACTION_APPWIDGET_DISABLED, ACTION_APPWIDGET_OPTIONS_CHANGED 7.

7
Se deberán declarar los correspondientes filtros para el proveedor, en el manifiesto del widget.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 10

TEMA 18. WIDGETS

Actividad de configuración del widget

Como ya se ha mencionado, se puede crear una actividad que configure los parámetros
iniciales del widget y que será iniciada por la aplicación host cuando se añada cada instancia
del widget.

Esta actividad deberá declararse, como de costumbre, en el manifiesto, y deberá aceptar el

Intent con action ACTION_WIDGET_CONFIGURE, declarando el correspondiente filtro:

<activity android:name=
"com.cursoandroid.ui.widget.MyWidgetConfigurationActivity">
<intent-filter>
<action android:name=
"android.appwidget.action.APPWIDGET_CONFIGURE" />
</intent-filter>
</activity>

Además, esta
actividad también debe referenciarse en el archivo XML de
AppWidgetProviderInfo a través del atributo android:configure 8.

Cuando la aplicación host del widget invoca a la actividad de configuración, espera que esta
devuelva un resultado a través de un Intent, que deberá contener el identificador del widget
(guardado en los extras como AppWidgetManager.EXTRA_APPWIDGET_ID). Además se ha de
tener en cuenta que el método callback del widget onUpdate() no será invocado cuando el
widget sea creado, ya que el sistema no envía el broadcast ACTION_WIDGET_UPDATE cuando es
invocada la actividad de configuración. Por lo tanto, esta actividad, una vez haya configurado
el widget, deberá solicitar a AppWidgetManager que actualice el widget por primera vez. A
partir de ese momento, el método onUpdate() será invocado normalmente.

Para actualizar el widget y finalizar la actividad de configuración, primero se deberá obtener el

identificador del widget del Intent que lanza la actividad:

Intent intent = getIntent();

Bundle extras = intent.getExtras();
if (extras != null) {
mMyWidgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
}

8
La referencia a la actividad de configuración en el archivo XML de AppWidgetProviderInfo debe incluir el espacio
de nombres (el nombre del paquete) ya que la aplicación host invoca a dicha actividad desde fuera del contexto de
la misma.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 11

TEMA 18. WIDGETS

Una vez completada la configuración del widget, este deberá ser actualizado. Para ello, se
obtendrá AppWidgetManager, así como el layout del widget a través de RemoteViews, y se
actualizará a través de updateAppWidget(int, RemoteViews):

AppWidgetManager appWidgetManager = AppWidgetManager.getInstance(this);

RemoteViews views = new RemoteViews(context.getPackageName(),
R.layout.my_widget_layout);
appWidgetManager.updateAppWidget(mMyWidgetId, views);

Para finalizar la actividad, se deberá crear el Intent que se devolverá a la aplicación host:

Intent resultValue = new Intent();

resultValue.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, mMyWidgetId);
setResult(RESULT_OK, resultValue);
finish();

CURSO DE DESARROLLO DE APLICACIONES ANDROID 12

TEMA 18. WIDGETS

Gestión de widgets en la Pantalla de Bloqueo

A partir de Android 4.2 se permite la inclusión de widgets en la Pantalla de Bloqueo del

dispositivo, a través del atributo android:widgetCategory="keyguard" del archivo XML de
AppWidgetProviderInfo 9.

El aspecto del widget podrá variar en función del host al cual se añada. Además de poder
asociar distintos layouts iniciales a través de los atributos android:initialLayout y
android:initialKeyguardLayout, se podrá detectar en tiempo de ejecución dónde se está
mostrando el widget a través del método AppWidgetManager.getAppWidgetOptions() 10,
que devuelve un Bundle que contiene diversas propiedades y características del widget. De
este modo, se podrán mantener diferenciados los distintos layouts del widget en las sucesivas
actualizaciones del mismo, así como establecer diferentes propiedades:

public void onUpdate(Context context, AppWidgetManager appWidgetManager,

int[] appWidgetIds) {

// Se determina dónde está el widget (Lockscreen o Home screen)

Bundle myWidgetOptions =
appWidgetManager.getAppWidgetOptions(appWidgetId);

// Categoría del widget

int category =
myWidgetOptions.getInt(
AppWidgetManager.OPTION_APPWIDGET_HOST_CATEGORY, -1);

// Si la categoría es WIDGET_CATEGORY_KEYGUARD, el widget está en la

// Lockscreen
boolean isKeyguard =
(category == AppWidgetProviderInfo.WIDGET_CATEGORY_KEYGUARD);

// Se elige el layout del widget

int widgetLayoutId = isKeyguard ? R.layout.my_widget_keyguard_layout :
R.layout.my_widget_layout;

RemoteViews views = new RemoteViews(context.getPackageName(),

widgetLayoutId);

// Se solicita al manager que actualice el widget

appWidgetManager.updateAppWidget(appWidgetId, views);
}

9
Para que el widget pueda ser añadido a ambas pantallas, se especificará
android:widgetCategory="home_screen|keyguard"
10
Método disponible solo a partir de Android 4.2.

CURSO DE DESARROLLO DE APLICACIONES ANDROID 13