Les widgets d'application sont des vues d'application miniatures que vous pouvez intégrer à d'autres applications, telles que l'écran d'accueil, et recevoir des mises à jour périodiques. Ces vues sont appelées widgets dans l'interface utilisateur, et vous pouvez en publier une avec un fournisseur de widgets d'application (ou fournisseur de widgets). Un composant d'application qui contient d'autres widgets est appelé "hôte de widget d'application" (ou hôte de widget). La figure 1 présente un exemple de widget musical:
Ce document explique comment publier un widget à l'aide d'un fournisseur de widgets. Pour en savoir plus sur la création de vos propres AppWidgetHost
pour héberger des widgets d'application, consultez Créer un hôte de widget.
Pour en savoir plus sur la conception de votre widget, consultez Présentation des widgets d'application.
Composants du widget
Pour créer un widget, vous avez besoin des composants de base suivants:
- Objet
AppWidgetProviderInfo
- Décrit les métadonnées d'un widget, telles que sa mise en page, la fréquence de mise à jour et la classe
AppWidgetProvider
.AppWidgetProviderInfo
est défini en XML, comme décrit dans ce document. - Classe
AppWidgetProvider
- Définit les méthodes de base qui vous permettent d'interagir avec le widget de manière programmatique. Grâce à lui, vous recevez des annonces lorsque le widget est mis à jour, activé, désactivé ou supprimé. Vous déclarez
AppWidgetProvider
dans le fichier manifeste, puis vous l'implémentez, comme décrit dans ce document. - Afficher la mise en page
- Définit la mise en page initiale du widget. La mise en page est définie en XML, comme décrit dans ce document.
La figure 2 montre comment ces composants s'intègrent dans le flux de traitement global du widget d'application.
Si votre widget nécessite une configuration utilisateur, implémentez l'activité de configuration du widget d'application. Cette activité permet aux utilisateurs de modifier les paramètres d'un widget, par exemple le fuseau horaire d'un widget d'horloge.
- À partir d'Android 12 (niveau d'API 31), vous pouvez fournir une configuration par défaut et permettre aux utilisateurs de reconfigurer le widget ultérieurement. Pour en savoir plus, consultez Utiliser la configuration par défaut du widget et Autoriser les utilisateurs à reconfigurer les widgets placés.
- Sous Android 11 (niveau d'API 30) ou version antérieure, cette activité est lancée chaque fois que l'utilisateur ajoute le widget à son écran d'accueil.
Nous vous recommandons également les améliorations suivantes: mises en page de widgets flexibles, améliorations diverses, widgets avancés, widgets de collection et création d'un hôte de widgets.
Déclarer le fichier XML AppWidgetProviderInfo
L'objet AppWidgetProviderInfo
définit les qualités essentielles d'un widget.
Définissez l'objet AppWidgetProviderInfo
dans un fichier de ressources XML à l'aide d'un seul élément <appwidget-provider>
, puis enregistrez-le dans le dossier res/xml/
du projet.
Ce processus est illustré dans l'exemple suivant :
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
android:minWidth="40dp"
android:minHeight="40dp"
android:targetCellWidth="1"
android:targetCellHeight="1"
android:maxResizeWidth="250dp"
android:maxResizeHeight="120dp"
android:updatePeriodMillis="86400000"
android:description="@string/example_appwidget_description"
android:previewLayout="@layout/example_appwidget_preview"
android:initialLayout="@layout/example_loading_appwidget"
android:configure="com.example.android.ExampleAppWidgetConfigurationActivity"
android:resizeMode="horizontal|vertical"
android:widgetCategory="home_screen"
android:widgetFeatures="reconfigurable|configuration_optional">
</appwidget-provider>
Attributs de dimensionnement des widgets
L'écran d'accueil par défaut positionne les widgets dans sa fenêtre en fonction d'une grille de cellules ayant une hauteur et une largeur définies. La plupart des écrans d'accueil ne permettent aux widgets que de prendre des tailles correspondant à des multiples entiers des cellules de la grille (par exemple, deux cellules horizontalement et trois cellules verticalement).
Les attributs de dimensionnement du widget vous permettent de spécifier une taille par défaut pour votre widget et d'indiquer des limites inférieure et supérieure de la taille du widget. Dans ce contexte, la taille par défaut d'un widget correspond à la taille qu'il prend lorsqu'il est ajouté pour la première fois à l'écran d'accueil.
Le tableau suivant décrit les attributs <appwidget-provider>
relatifs au dimensionnement des widgets:
Attributs et description | |
---|---|
targetCellWidth et targetCellHeight (Android 12), minWidth et minHeight |
targetCellWidth et targetCellHeight , ainsi que minWidth et minHeight ), afin que votre application puisse utiliser minWidth et minHeight si l'appareil de l'utilisateur n'est pas compatible avec targetCellWidth et targetCellHeight . S'ils sont compatibles, les attributs targetCellWidth et targetCellHeight sont prioritaires sur les attributs minWidth et minHeight .
|
minResizeWidth et minResizeHeight |
Spécifiez la taille minimale absolue du widget. Ces valeurs spécifient la taille en dessous de laquelle le widget est illisible ou inutilisable. L'utilisation de ces attributs permet à l'utilisateur de redimensionner le widget à une taille inférieure à la taille de widget par défaut. L'attribut minResizeWidth est ignoré s'il est supérieur à minWidth ou si le redimensionnement horizontal n'est pas activé. Consultez resizeMode . De même, l'attribut minResizeHeight est ignoré s'il est supérieur à minHeight ou si le redimensionnement vertical n'est pas activé. |
maxResizeWidth et maxResizeHeight |
Spécifiez la taille maximale recommandée pour le widget. Si les valeurs ne sont pas un multiple des dimensions des cellules de grille, elles sont arrondies à la taille de cellule supérieure la plus proche. L'attribut maxResizeWidth est ignoré s'il est inférieur à minWidth ou si le redimensionnement horizontal n'est pas activé. Voir resizeMode . De même, l'attribut maxResizeHeight est ignoré s'il est supérieur à minHeight ou si le redimensionnement vertical n'est pas activé.
Introduit dans Android 12. |
resizeMode |
Spécifie les règles selon lesquelles un widget peut être redimensionné. Vous pouvez utiliser cet attribut pour permettre aux widgets de l'écran d'accueil de redimensionner horizontalement, verticalement ou les deux axes. Les utilisateurs appuient de manière prolongée sur un widget pour afficher ses poignées de redimensionnement, puis font glisser les poignées horizontales ou verticales pour modifier sa taille sur la grille de mise en page. Les valeurs de l'attribut resizeMode incluent horizontal , vertical et none . Pour déclarer un widget comme redimensionnable horizontalement et verticalement, utilisez horizontal|vertical . |
Exemple
Pour illustrer l'impact des attributs du tableau précédent sur le dimensionnement des widgets, supposons les spécifications suivantes:
- Une cellule de grille fait 30 dp de large et 50 dp de hauteur.
- Les spécifications d'attribut suivantes sont fournies:
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
android:minWidth="80dp"
android:minHeight="80dp"
android:targetCellWidth="2"
android:targetCellHeight="2"
android:minResizeWidth="40dp"
android:minResizeHeight="40dp"
android:maxResizeWidth="120dp"
android:maxResizeHeight="120dp"
android:resizeMode="horizontal|vertical" />
À partir d'Android 12:
Utilisez les attributs targetCellWidth
et targetCellHeight
comme taille par défaut du widget.
Par défaut, la taille du widget est 2 x 2. Le widget peut être redimensionné jusqu'à 2 x 1 ou 4 x 3.
Android 11 ou version antérieure:
Utilisez les attributs minWidth
et minHeight
pour calculer la taille par défaut du widget.
Largeur par défaut = Math.ceil(80 / 30)
= 3
Hauteur par défaut = Math.ceil(80 / 50)
= 2
Par défaut, la taille du widget est 3 x 2. Le widget peut être redimensionné jusqu'à 2 x 1 pixels ou jusqu'en plein écran.
Autres attributs de widget
Le tableau suivant décrit les attributs <appwidget-provider>
associés à des qualités autres que le dimensionnement des widgets.
Attributs et description | |
---|---|
updatePeriodMillis |
Définit la fréquence à laquelle le framework de widget demande une mise à jour de AppWidgetProvider en appelant la méthode de rappel onUpdate() . Il n'est pas garanti que la mise à jour réelle ait lieu exactement à l'heure avec cette valeur. Nous vous recommandons d'effectuer une mise à jour le moins possible (pas plus d'une fois par heure) afin d'économiser la batterie.
Pour obtenir la liste complète des points à prendre en compte pour choisir une période de mise à jour appropriée, consultez la section Optimisations pour la mise à jour du contenu des widgets. |
initialLayout |
Pointe vers la ressource de mise en page qui définit la mise en page du widget. |
configure |
Définit l'activité qui se lance lorsque l'utilisateur ajoute le widget, ce qui lui permet de configurer les propriétés du widget. Consultez la section Autoriser les utilisateurs à configurer des widgets. À partir d'Android 12, votre application peut ignorer la configuration initiale. Pour en savoir plus, consultez Utiliser la configuration par défaut du widget. |
description |
Spécifie la description du sélecteur de widgets à afficher pour votre widget. Introduit dans Android 12. |
previewLayout (Android 12) et previewImage (Android 11 ou version antérieure) |
previewImage et previewLayout afin que votre application puisse utiliser previewImage si l'appareil de l'utilisateur n'est pas compatible avec previewLayout . Pour en savoir plus, consultez la section Rétrocompatibilité avec les aperçus de widgets évolutifs.
|
autoAdvanceViewId |
Spécifie l'ID de la vue de la sous-vue de widget avancée automatiquement par l'hôte du widget. |
widgetCategory |
Indique si votre widget peut être affiché sur l'écran d'accueil (home_screen ), l'écran de verrouillage (keyguard ) ou les deux. Pour Android 5.0 ou version ultérieure, seul home_screen est valide.
|
widgetFeatures |
Déclare les fonctionnalités compatibles avec le widget. Par exemple, si vous souhaitez que votre widget utilise sa configuration par défaut lorsqu'un utilisateur l'ajoute, spécifiez les options configuration_optional et reconfigurable . Cela permet de contourner le lancement de l'activité de configuration une fois qu'un utilisateur a ajouté le widget. L'utilisateur peut toujours reconfigurer le widget par la suite. |
Utiliser la classe AppWidgetProvider pour gérer les diffusions de widget
La classe AppWidgetProvider
gère les diffusions de widget et met à jour le widget en réponse aux événements de cycle de vie du widget. Les sections suivantes décrivent comment déclarer AppWidgetProvider
dans le fichier manifeste et comment l'implémenter.
Déclarer un widget dans le fichier manifeste
Commencez par déclarer la classe AppWidgetProvider
dans le fichier AndroidManifest.xml
de votre application, comme indiqué dans l'exemple suivant:
<receiver android:name="ExampleAppWidgetProvider"
android:exported="false">
<intent-filter>
<action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
</intent-filter>
<meta-data android:name="android.appwidget.provider"
android:resource="@xml/example_appwidget_info" />
</receiver>
L'élément <receiver>
nécessite l'attribut android:name
, qui spécifie le AppWidgetProvider
utilisé par le widget. Le composant ne doit pas être exporté, sauf si un processus distinct doit être diffusé sur votre AppWidgetProvider
, ce qui n'est généralement pas le cas.
L'élément <intent-filter>
doit inclure un élément <action>
avec l'attribut android:name
. Cet attribut indique que AppWidgetProvider
accepte la diffusion ACTION_APPWIDGET_UPDATE
. Il s'agit de la seule diffusion que vous devez déclarer explicitement. AppWidgetManager
envoie automatiquement toutes les autres annonces de widget à AppWidgetProvider
si nécessaire.
L'élément <meta-data>
spécifie la ressource AppWidgetProviderInfo
et nécessite les attributs suivants:
android:name
: spécifie le nom des métadonnées. Utilisezandroid.appwidget.provider
pour identifier les données en tant que descripteurAppWidgetProviderInfo
.android:resource
: spécifie l'emplacement de la ressourceAppWidgetProviderInfo
.
Implémenter la classe AppWidgetProvider
La classe AppWidgetProvider
étend BroadcastReceiver
en tant que classe pratique permettant de gérer les diffusions de widget. Il ne reçoit que les diffusions d'événements pertinentes pour le widget, par exemple lorsque le widget est mis à jour, supprimé, activé et désactivé. Lorsque ces événements de diffusion se produisent, les méthodes AppWidgetProvider
suivantes sont appelées:
onUpdate()
- Cette méthode est appelée pour mettre à jour le widget à des intervalles définis par l'attribut
updatePeriodMillis
dansAppWidgetProviderInfo
. Pour en savoir plus, consultez le tableau décrivant les attributs de widget supplémentaires de cette page. - Cette méthode est également appelée lorsque l'utilisateur ajoute le widget afin d'effectuer la configuration essentielle, comme la définition de gestionnaires d'événements pour les objets
View
ou le démarrage de tâches pour charger des données à afficher dans le widget. Toutefois, si vous déclarez une activité de configuration sans l'optionconfiguration_optional
, cette méthode n'est pas appelée lorsque l'utilisateur ajoute le widget, mais est appelée pour les mises à jour ultérieures. Il appartient à l'activité de configuration d'effectuer la première mise à jour une fois la configuration terminée. Pour en savoir plus, consultez Permettre aux utilisateurs de configurer des widgets d'application. - Le rappel le plus important est
onUpdate()
. Pour en savoir plus, consultez la section Gérer les événements avec la classeonUpdate()
sur cette page. onAppWidgetOptionsChanged()
Cette méthode est appelée lorsque le widget est placé pour la première fois et chaque fois qu'il est redimensionné. Utilisez ce rappel pour afficher ou masquer le contenu en fonction des plages de tailles du widget. Obtenez les plages de tailles et, à partir d'Android 12, la liste des tailles possibles d'une instance de widget en appelant
getAppWidgetOptions()
, qui renvoie unBundle
comprenant les éléments suivants:OPTION_APPWIDGET_MIN_WIDTH
: contient la limite inférieure de la largeur, en dp, d'une instance de widget.OPTION_APPWIDGET_MIN_HEIGHT
: contient la limite inférieure de la hauteur, en dp, d'une instance de widget.OPTION_APPWIDGET_MAX_WIDTH
: contient la limite supérieure sur la largeur, en dp, d'une instance de widget.OPTION_APPWIDGET_MAX_HEIGHT
: contient la limite supérieure de la hauteur, en dp, d'une instance de widget.OPTION_APPWIDGET_SIZES
: contient la liste des tailles possibles (List<SizeF>
), en dp, qu'une instance de widget peut prendre. Introduit dans Android 12.
onDeleted(Context, int[])
Cette méthode est appelée chaque fois qu'un widget est supprimé de son hôte.
onEnabled(Context)
Cette méthode est appelée lorsqu'une instance du widget est créée pour la première fois. Par exemple, si l'utilisateur ajoute deux instances de votre widget, l'appel n'est effectué que la première fois. Si vous devez ouvrir une nouvelle base de données ou effectuer une autre configuration qui ne doit se produire qu'une seule fois pour toutes les instances de widget, c'est l'endroit idéal pour effectuer cette opération.
onDisabled(Context)
Cette méthode est appelée lorsque la dernière instance de votre widget est supprimée de l'hôte du widget. C'est ici que vous nettoyez tout le travail effectué dans
onEnabled(Context)
, tel que la suppression d'une base de données temporaire.onReceive(Context, Intent)
Cette méthode est appelée pour chaque diffusion et avant chacune des méthodes de rappel précédentes. Normalement, vous n'avez pas besoin d'implémenter cette méthode, car l'implémentation par défaut de
AppWidgetProvider
filtre toutes les diffusions de widget et appelle les méthodes précédentes, le cas échéant.
Vous devez déclarer votre implémentation de classe AppWidgetProvider
en tant que broadcast receiver à l'aide de l'élément <receiver>
dans AndroidManifest
. Pour en savoir plus, consultez la section Déclarer un widget dans le fichier manifeste de cette page.
Gérer les événements avec la classe onUpdate()
Le rappel AppWidgetProvider
le plus important est onUpdate()
, car il est appelé lorsque chaque widget est ajouté à un hôte, sauf si vous utilisez une activité de configuration sans l'option configuration_optional
. Si votre widget accepte des événements d'interaction utilisateur, enregistrez les gestionnaires d'événements dans ce rappel. Si votre widget ne crée pas de fichiers ou de bases de données temporaires, ou n'effectue pas d'autres tâches nécessitant un nettoyage, onUpdate()
peut être la seule méthode de rappel que vous devez définir.
Par exemple, si vous souhaitez disposer d'un widget avec un bouton qui lance une activité lorsque l'utilisateur appuie dessus, vous pouvez utiliser l'implémentation suivante de AppWidgetProvider
:
Kotlin
class ExampleAppWidgetProvider : AppWidgetProvider() { override fun onUpdate( context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray ) { // Perform this loop procedure for each widget that belongs to this // provider. appWidgetIds.forEach { appWidgetId -> // Create an Intent to launch ExampleActivity. val pendingIntent: PendingIntent = PendingIntent.getActivity( /* context = */ context, /* requestCode = */ 0, /* intent = */ Intent(context, ExampleActivity::class.java), /* flags = */ PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE ) // Get the layout for the widget and attach an onClick listener to // the button. val views: RemoteViews = RemoteViews( context.packageName, R.layout.appwidget_provider_layout ).apply { setOnClickPendingIntent(R.id.button, pendingIntent) } // Tell the AppWidgetManager to perform an update on the current // widget. appWidgetManager.updateAppWidget(appWidgetId, views) } } }
Java
public class ExampleAppWidgetProvider extends AppWidgetProvider { public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) { // Perform this loop procedure for each widget that belongs to this // provider. for (int i=0; i < appWidgetIds.length; i++) { int appWidgetId = appWidgetIds[i]; // Create an Intent to launch ExampleActivity Intent intent = new Intent(context, ExampleActivity.class); PendingIntent pendingIntent = PendingIntent.getActivity( /* context = */ context, /* requestCode = */ 0, /* intent = */ intent, /* flags = */ PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE ); // Get the layout for the widget and attach an onClick listener to // the button. RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.example_appwidget_layout); views.setOnClickPendingIntent(R.id.button, pendingIntent); // Tell the AppWidgetManager to perform an update on the current app // widget. appWidgetManager.updateAppWidget(appWidgetId, views); } } }
Ce AppWidgetProvider
définit uniquement la méthode onUpdate()
, en l'utilisant pour créer un PendingIntent
qui lance un Activity
et l'associe au bouton du widget à l'aide de setOnClickPendingIntent(int,
PendingIntent)
. Il inclut une boucle qui parcourt chaque entrée de appWidgetIds
, qui est un tableau d'ID identifiant chaque widget créé par ce fournisseur. Si l'utilisateur crée plusieurs instances du widget, elles sont toutes mises à jour simultanément. Cependant, une seule planification updatePeriodMillis
est gérée pour toutes les instances du widget. Par exemple, si le calendrier des mises à jour est défini pour être effectué toutes les deux heures et qu'une deuxième instance du widget est ajoutée une heure après la première, les deux sont mises à jour selon la période définie par la première. La seconde période de mise à jour est ignorée. Elles sont mises à jour toutes les deux
heures, et non toutes les heures.
Pour en savoir plus, consultez l'exemple de classe ExampleAppWidgetProvider.java
.
Recevoir des intents de diffusion de widget
AppWidgetProvider
est une classe de commodité. Si vous souhaitez recevoir directement les diffusions du widget, vous pouvez implémenter votre propre BroadcastReceiver
ou ignorer le rappel onReceive(Context,Intent)
. Voici les intents dont vous devez vous soucier:
ACTION_APPWIDGET_UPDATE
ACTION_APPWIDGET_DELETED
ACTION_APPWIDGET_ENABLED
ACTION_APPWIDGET_DISABLED
ACTION_APPWIDGET_OPTIONS_CHANGED
Créer la mise en page de widget
Vous devez définir une mise en page initiale pour votre widget au format XML et l'enregistrer dans le répertoire res/layout/
du projet. Pour en savoir plus, consultez les consignes de conception.
La création de la mise en page du widget est simple si vous connaissez les mises en page. Toutefois, sachez que les mises en page de widgets sont basées sur RemoteViews
, qui n'est pas compatible avec tous les types de widgets de mise en page ou de vue. Vous ne pouvez pas utiliser de vues ni de sous-classes personnalisées des vues compatibles avec RemoteViews
.
RemoteViews
est également compatible avec ViewStub
, un View
invisible de taille nulle que vous pouvez utiliser pour gonfler, de manière différée, des ressources de mise en page au moment de l'exécution.
Compatibilité avec le comportement avec état
Android 12 prend en charge le comportement avec état à l'aide des composants existants suivants:
Le widget est toujours sans état. Votre application doit stocker l'état et s'enregistrer aux événements de changement d'état.
L'exemple de code suivant montre comment implémenter ces composants.
Kotlin
// Check the view. remoteView.setCompoundButtonChecked(R.id.my_checkbox, true) // Check a radio group. remoteView.setRadioGroupChecked(R.id.my_radio_group, R.id.radio_button_2) // Listen for check changes. The intent has an extra with the key // EXTRA_CHECKED that specifies the current checked state of the view. remoteView.setOnCheckedChangeResponse( R.id.my_checkbox, RemoteViews.RemoteResponse.fromPendingIntent(onCheckedChangePendingIntent) )
Java
// Check the view. remoteView.setCompoundButtonChecked(R.id.my_checkbox, true); // Check a radio group. remoteView.setRadioGroupChecked(R.id.my_radio_group, R.id.radio_button_2); // Listen for check changes. The intent has an extra with the key // EXTRA_CHECKED that specifies the current checked state of the view. remoteView.setOnCheckedChangeResponse( R.id.my_checkbox, RemoteViews.RemoteResponse.fromPendingIntent(onCheckedChangePendingIntent));
Fournissez deux mises en page: l'une cible les appareils équipés d'Android 12 ou version ultérieure dans res/layout-v31
, et l'autre cible les versions antérieures d'Android 11 ou d'une version antérieure dans le dossier res/layout
par défaut.
Implémenter des angles arrondis
Android 12 introduit les paramètres système suivants pour définir les rayons des angles arrondis de votre widget:
system_app_widget_background_radius
: rayon d'angle de l'arrière-plan du widget, qui n'est jamais supérieur à 28 dp.system_app_widget_inner_radius
: rayon d'angle de toute vue à l'intérieur du widget. Cela correspond exactement à 8 dp de moins que le rayon de l'arrière-plan, pour un alignement correct lorsque vous utilisez une marge intérieure de 8 dp.
L'exemple suivant montre un widget qui utilise system_app_widget_background_radius
pour l'angle du widget et system_app_widget_inner_radius
pour les vues à l'intérieur du widget.
1 Coin du widget
2 Angle d'une vue dans le widget.
Remarques importantes concernant les angles arrondis
- Les lanceurs d'applications et les fabricants d'appareils tiers peuvent remplacer le paramètre
system_app_widget_background_radius
pour qu'il soit inférieur à 28 dp. Le paramètresystem_app_widget_inner_radius
est toujours inférieur de 8 dp à la valeur desystem_app_widget_background_radius
. - Si votre widget n'utilise pas
@android:id/background
ou ne définit pas d'arrière-plan qui rogne son contenu en fonction du contour (avecandroid:clipToOutline
défini surtrue
), le lanceur identifie automatiquement l'arrière-plan et rogne le widget à l'aide d'un rectangle avec des angles arrondis allant jusqu'à 16 dp. Consultez Vérifier que votre widget est compatible avec Android 12.
Pour assurer la compatibilité des widgets avec les versions précédentes d'Android, nous vous recommandons de définir des attributs personnalisés et d'utiliser un thème personnalisé pour les remplacer pour Android 12, comme illustré dans les exemples de fichiers XML suivants:
/values/attrs.xml
<resources>
<attr name="backgroundRadius" format="dimension" />
</resources>
/values/styles.xml
<resources>
<style name="MyWidgetTheme">
<item name="backgroundRadius">@dimen/my_background_radius_dimen</item>
</style>
</resources>
/values-31/styles.xml
<resources>
<style name="MyWidgetTheme" parent="@android:style/Theme.DeviceDefault.DayNight">
<item name="backgroundRadius">@android:dimen/system_app_widget_background_radius</item>
</style>
</resources>
/drawable/my_widget_background.xml
<shape xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle">
<corners android:radius="?attr/backgroundRadius" />
...
</shape>
/layout/my_widget_layout.xml
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
...
android:background="@drawable/my_widget_background" />