Membuat widget sederhana

Widget aplikasi adalah tampilan aplikasi mini yang dapat Anda sematkan di aplikasi—seperti layar utama—dan menerima update berkala. Ini disebut sebagai widget di antarmuka pengguna, dan Anda dapat memublikasikan satu dengan penyedia widget aplikasi (atau penyedia widget). Komponen aplikasi yang menampung widget lain disebut host widget aplikasi (atau host widget). Gambar 1 menunjukkan widget musik contoh:

Contoh widget musik
Gambar 1. Contoh widget musik.

Dokumen ini menjelaskan cara memublikasikan widget menggunakan penyedia widget. Sebagai detail tentang membuat AppWidgetHost Anda sendiri untuk menghosting widget aplikasi, lihat Membangun host widget.

Untuk mengetahui informasi tentang cara mendesain widget, lihat Ringkasan widget aplikasi.

Komponen widget

Untuk membuat widget, Anda memerlukan komponen dasar berikut:

Objek AppWidgetProviderInfo
Menjelaskan metadata untuk widget, seperti tata letak, pembaruan frekuensi, dan class AppWidgetProvider. AppWidgetProviderInfo ditentukan dalam XML, sebagai yang dijelaskan dalam dokumen ini.
Class AppWidgetProvider
Menentukan metode dasar yang memungkinkan Anda berinteraksi secara terprogram dengan . Melalui ini, Anda menerima siaran saat widget diperbarui, diaktifkan, dinonaktifkan, atau dihapus. Anda mendeklarasikan AppWidgetProvider dalam manifes, lalu implementasikan, sebagai yang dijelaskan di dokumen ini.
Tata letak tampilan
Menentukan tata letak awal widget. Tata letak ini ditentukan dalam XML, seperti yang dijelaskan dalam dokumen ini.

Gambar 2 menunjukkan cara menyesuaikan komponen ini dengan pemrosesan widget aplikasi secara keseluruhan alur kerja.

Alur pemrosesan widget aplikasi
Gambar 2. Alur pemrosesan widget aplikasi.

Jika widget Anda memerlukan konfigurasi pengguna, terapkan konfigurasi widget aplikasi aktivitas Anda. Aktivitas ini memungkinkan pengguna mengubah setelan widget—misalnya, zona waktu untuk widget jam.

Kami juga menyarankan peningkatan berikut: tata letak widget yang fleksibel, penyempurnaan lainnya, widget lanjutan, widget koleksi, dan membangun widget host.

Mendeklarasikan XML AppWidgetProviderInfo

Objek AppWidgetProviderInfo menentukan kualitas penting dari widget. Tentukan objek AppWidgetProviderInfo dalam file resource XML menggunakan satu <appwidget-provider> dan simpan di folder res/xml/ project.

Hal ini ditunjukkan dalam contoh berikut:

<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>

Atribut ukuran widget

Layar utama default memosisikan widget di jendelanya berdasarkan petak sel yang memiliki tinggi dan lebar yang ditentukan. Sebagian besar layar utama hanya mengizinkan widget ukuran yang merupakan kelipatan bilangan bulat dari sel petak—misalnya, dua sel secara horizontal dengan tiga sel secara vertikal.

Atribut ukuran widget memungkinkan Anda menentukan ukuran default untuk widget Anda dan menyediakan batas bawah dan atas pada ukuran widget. Dalam konteks ini, ukuran default widget adalah ukuran yang digunakan widget saat pertama kali ditambahkan ke layar beranda.

Tabel berikut menjelaskan atribut <appwidget-provider> yang terkait ke ukuran widget:

Atribut dan deskripsi
targetCellWidth dan targetCellHeight (Android 12), minWidth dan minHeight
  • Mulai Android 12, targetCellWidth dan targetCellHeight menentukan ukuran default widget dalam hal petak sel. Atribut ini diabaikan di Android 11 dan lebih rendah, serta dapat diabaikan jika layar utama tidak mendukung tata letak berbasis {i>grid<i}.
  • minWidth dan Atribut minHeight menentukan ukuran default widget dalam dp. Jika nilai untuk lebar atau tinggi minimum widget tidak sesuai dimensi sel, kemudian nilai dibulatkan ke atas ukuran sel terdekat.
Kami sarankan untuk menentukan kedua jenis atribut—targetCellWidth dan targetCellHeight, dan minWidth, serta minHeight—sehingga aplikasi Anda dapat kembali menggunakan minWidth dan minHeight jika perangkat pengguna tidak mendukung targetCellWidth dan targetCellHeight. Jika didukung, Atribut targetCellWidth dan targetCellHeight lebih diutamakan daripada minWidth dan minHeight .
minResizeWidth dan minResizeHeight Tentukan ukuran minimum widget yang mutlak. Nilai ini menentukan ukuran widget yang tidak terbaca atau tidak dapat digunakan. Menggunakan Dengan atribut ini, pengguna dapat mengubah ukuran widget ke ukuran yang lebih kecil. daripada ukuran {i>default widget<i}. Atribut minResizeWidth memiliki diabaikan jika lebih besar dari minWidth atau jika horizontal pengubahan ukuran tidak diaktifkan. Lihat resizeMode Demikian juga, Atribut minResizeHeight diabaikan jika lebih besar dari minHeight atau jika pengubahan ukuran secara vertikal tidak diaktifkan.
maxResizeWidth dan maxResizeHeight Tentukan ukuran maksimum yang direkomendasikan widget. Jika nilai tersebut tidak kelipatan dari dimensi sel {i>grid<i}, maka akan dibulatkan ke atas ke nilai ukuran sel. Atribut maxResizeWidth diabaikan jika lebih kecil dari minWidth atau jika pengubahan ukuran horizontal tidak mengaktifkan pembuatan versi. Lihat resizeMode. Demikian juga, Atribut maxResizeHeight diabaikan jika lebih besar daripada minHeight atau jika pengubahan ukuran secara vertikal tidak diaktifkan. Diperkenalkan di Android 12.
resizeMode Menentukan aturan yang digunakan untuk mengubah ukuran widget. Anda dapat menggunakan untuk membuat widget layar utama dapat diubah ukurannya secara horizontal, vertikal, atau pada kedua sumbu. Pengguna menyentuh & tahan widget untuk menampilkan {i>resize handle<i}, kemudian seret {i>handle<i} horizontal atau vertikal untuk mengubah ukurannya pada kisi tata letak. Nilai untuk atribut resizeMode mencakup horizontal, vertical, dan none. Kepada mendeklarasikan widget sebagai dapat diubah secara horizontal dan vertikal, gunakan horizontal|vertical.

Contoh

Untuk menggambarkan bagaimana atribut dalam tabel sebelumnya mempengaruhi ukuran widget, asumsikan spesifikasi berikut:

  • Sel petak memiliki lebar 30 dp dan tinggi 50 dp.
  • Spesifikasi atribut berikut diberikan:
<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" />

Mulai Android 12:

Gunakan atribut targetCellWidth dan targetCellHeight sebagai default ukuran widget.

Ukuran widget adalah 2x2 secara default. Ukuran widget dapat diubah menjadi 2x1 atau hingga 4x3.

Android 11 dan yang lebih lama:

Gunakan atribut minWidth dan minHeight untuk menghitung ukuran default widget tersebut.

Lebar default = Math.ceil(80 / 30) = 3

Tinggi default = Math.ceil(80 / 50) = 2

Ukuran widget adalah 3x2 secara default. Ukuran widget dapat diubah menjadi 2x1 atau hingga layar penuh.

Atribut widget tambahan

Tabel berikut menjelaskan atribut <appwidget-provider> yang terkait dengan kualitas selain ukuran widget.

Atribut dan deskripsi
updatePeriodMillis Menentukan seberapa sering framework widget meminta update dari AppWidgetProvider dengan memanggil onUpdate() . Pembaruan yang sebenarnya tidak dijamin akan terjadi tepat pada dengan nilai ini, dan sebaiknya perbarui frekuensinya memungkinkan—tidak lebih dari sekali per jam—untuk menghemat baterai. Untuk daftar lengkap pertimbangan guna memilih periode update yang tepat, lihat Pengoptimalan untuk mengupdate widget .
initialLayout Mengarah ke resource tata letak yang menentukan tata letak widget.
configure Menentukan aktivitas yang diluncurkan saat pengguna menambahkan widget, dan mengizinkannya mengonfigurasi properti widget. Lihat Izinkan pengguna mengonfigurasi widget. Mulai Android 12, aplikasi Anda dapat melewati langkah awal konfigurasi Anda. Lihat Menggunakan konfigurasi default widget untuk mengetahui detailnya.
description Menentukan deskripsi alat pilih widget yang akan ditampilkan untuk . Diperkenalkan di Android 12.
previewLayout (Android 12) dan previewImage (Android 11 dan yang lebih lama)
  • Mulai Android 12, Atribut previewLayout menentukan pratinjau skalabel, yang yang Anda sediakan sebagai tata letak XML yang disetel ke ukuran default widget. Idealnya, XML tata letak yang ditetapkan sebagai atribut ini merupakan XML tata letak yang sama dengan widget aktual dengan nilai default yang realistis.
  • Di Android 11 atau yang lebih lama, previewImage menentukan pratinjau tampilan widget setelah dikonfigurasi, yang akan dilihat pengguna saat memilih widget aplikasi. Jika tidak disediakan, pengguna akan melihat ikon peluncur aplikasi Anda. Ini sesuai dengan atribut android:previewImage di elemen <receiver> di File AndroidManifest.xml.
Catatan: Sebaiknya tentukan previewImage dan previewLayout sehingga aplikasi Anda dapat melakukan penggantian penggunaan previewImage jika perangkat pengguna tidak mendukung previewLayout. Untuk detail selengkapnya, lihat Kompatibilitas mundur dengan skalabel pratinjau widget.
autoAdvanceViewId Menentukan ID tampilan sub-tampilan widget yang dilanjutkan otomatis oleh {i>host<i} widget tersebut.
widgetCategory Mendeklarasikan apakah widget Anda dapat ditampilkan di layar utama (home_screen), layar kunci (keyguard), atau keduanya. Untuk Android 5.0 dan yang lebih tinggi, hanya home_screen yang valid.
widgetFeatures Mendeklarasikan fitur yang didukung oleh widget. Misalnya, jika Anda ingin untuk menggunakan konfigurasi {i>default<i} saat pengguna menambahkannya, tentukan baik configuration_optional dan reconfigurable penanda. Tindakan ini akan mengabaikan peluncuran aktivitas konfigurasi setelah pengguna yang akan menambahkan widget tersebut. Pengguna masih bisa mengonfigurasi ulang widget setelahnya.

Menggunakan class AppWidgetProvider untuk menangani siaran widget

Class AppWidgetProvider menangani siaran widget dan mengupdate widget sebagai respons terhadap peristiwa siklus proses widget. Bagian berikut menjelaskan cara mendeklarasikan AppWidgetProvider dalam manifes, lalu mengimplementasikannya.

Mendeklarasikan widget dalam manifes

Pertama, deklarasikan class AppWidgetProvider di AndroidManifest.xml aplikasi Anda seperti yang ditunjukkan dalam contoh berikut:

<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>

Elemen <receiver> memerlukan atribut android:name, yang menentukan AppWidgetProvider yang digunakan oleh widget. Komponen tidak boleh diekspor kecuali jika proses terpisah perlu disiarkan ke AppWidgetProvider Anda, yang biasanya tidak seperti itu.

Elemen <intent-filter> harus menyertakan elemen <action> dengan Atribut android:name. Atribut ini menentukan bahwa AppWidgetProvider menyetujui ACTION_APPWIDGET_UPDATE . Siaran ini merupakan satu-satunya yang harus Anda deklarasikan secara eksplisit. Tujuan AppWidgetManager otomatis mengirim semua siaran widget lainnya ke AppWidgetProvider sebagai diperlukan.

Elemen <meta-data> menentukan resource AppWidgetProviderInfo dan memerlukan atribut berikut:

  • android:name: menentukan nama metadata. Gunakan android.appwidget.provider untuk mengidentifikasi data sebagai Deskripsi AppWidgetProviderInfo.
  • android:resource: menentukan resource AppWidgetProviderInfo lokasi HTTP/HTTPS.

Menerapkan class AppWidgetProvider

Class AppWidgetProvider memperluas BroadcastReceiver sebagai untuk menangani siaran widget. Asisten hanya menerima peristiwa siaran yang relevan dengan widget, seperti saat widget diperbarui, dihapus, diaktifkan, dan dinonaktifkan. Saat peristiwa siaran ini terjadi, hal berikut Metode AppWidgetProvider dipanggil:

onUpdate()
Perintah ini dipanggil untuk mengupdate widget pada interval yang ditentukan oleh updatePeriodMillis di AppWidgetProviderInfo. Lihat tabel yang menjelaskan atribut widget tambahan di halaman ini untuk informasi selengkapnya.
Metode ini juga dipanggil ketika pengguna menambahkan widget, sehingga melakukan tindakan seperti menentukan pengendali peristiwa untuk Objek View atau memulai tugas untuk memuat data ditampilkan di widget. Namun, jika Anda mendeklarasikan aktivitas konfigurasi tanpa flag configuration_optional, metode ini tidak dipanggil saat pengguna menambahkan widget, tetapi akan dipanggil untuk update berikutnya. Ini adalah tanggung jawab aktivitas konfigurasi untuk melakukan pembaruan pertama saat konfigurasi selesai. Lihat Memungkinkan pengguna mengonfigurasi widget aplikasi untuk informasi selengkapnya.
Callback yang paling penting adalah onUpdate(). Lihat Menangani peristiwa dengan onUpdate() class di halaman ini untuk mengetahui informasi selengkapnya.
onAppWidgetOptionsChanged()

Fungsi ini dipanggil saat widget pertama kali ditempatkan dan kapan pun widget tersebut ditempatkan diubah ukurannya. Gunakan callback ini untuk menampilkan atau menyembunyikan konten berdasarkan ukuran widget rentang. Dapatkan rentang ukuran—dan, mulai Android 12, daftar kemungkinan ukuran yang dapat diambil instance widget—dengan memanggil getAppWidgetOptions(), yang menampilkan Bundle yang menyertakan berikut ini:

onDeleted(Context, int[])

Fungsi ini akan dipanggil setiap kali widget dihapus dari host widget.

onEnabled(Context)

Fungsi ini dipanggil saat instance widget dibuat untuk pertama kalinya. Misalnya, jika pengguna menambahkan dua instance widget Anda, hal ini hanya dipanggil pertama kalinya. Jika Anda perlu membuka {i>database<i} baru atau melakukan pengaturan lain yang hanya perlu terjadi sekali untuk semua instance widget, maka ini adalah tempat yang baik untuk melakukannya.

onDisabled(Context)

Fungsi ini dipanggil saat instance terakhir widget Anda dihapus dari {i>host<i} widget. Di sinilah Anda menyelesaikan semua pekerjaan yang dilakukan di onEnabled(Context), seperti menghapus sebuah {i>database<i} sementara.

onReceive(Context, Intent)

Metode ini dipanggil untuk setiap siaran dan sebelum setiap callback sebelumnya metode. Anda biasanya tidak perlu mengimplementasikan metode ini, karena metode Implementasi AppWidgetProvider memfilter semua siaran widget dan memanggil metode metode sebelumnya sebagaimana mestinya.

Anda harus mendeklarasikan penerapan class AppWidgetProvider sebagai siaran penerima menggunakan elemen <receiver> di AndroidManifest. Lihat Mendeklarasikan di manifes di halaman ini untuk mendapatkan informasi selengkapnya.

Menangani peristiwa dengan class onUpdate()

Callback AppWidgetProvider yang paling penting adalah onUpdate(), karena dipanggil ketika setiap widget ditambahkan ke host, kecuali jika Anda menggunakan konfigurasi aktivitas tanpa flag configuration_optional. Jika widget Anda menerima peristiwa interaksi pengguna, lalu daftarkan pengendali peristiwa dalam callback ini. Jika widget Anda tidak membuat file atau database sementara, atau melakukan pekerjaan lain yang memerlukan pembersihan, maka onUpdate() mungkin satu-satunya metode callback yang Anda perlu didefinisikan.

Misalnya, jika Anda ingin widget dengan tombol yang meluncurkan aktivitas saat diketuk, Anda dapat menggunakan implementasi AppWidgetProvider berikut:

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);
        }
    }
}

AppWidgetProvider ini hanya menentukan metode onUpdate(), yang menggunakannya untuk membuat PendingIntent yang meluncurkan Activity dan melampirkannya ke menggunakan setOnClickPendingIntent(int, PendingIntent). Ini mencakup loop yang melakukan iterasi melalui setiap entri di appWidgetIds, yang merupakan array ID yang mengidentifikasi setiap widget yang dibuat oleh penyedia ini. Jika pengguna membuat lebih dari satu instance widget, semuanya diperbarui secara bersamaan. Namun, hanya satu jadwal updatePeriodMillis dikelola untuk semua instance widget. Misalnya, jika jadwal update didefinisikan sebagai setiap dua jam, dan instance kedua dari widget ditambahkan satu jam setelah yang pertama, kemudian keduanya diperbarui pada periode yang ditentukan oleh periode pembaruan pertama, dan kedua akan diabaikan. Keduanya diperbarui setiap dua jam, bukan setiap jam.

Lihat ExampleAppWidgetProvider.java untuk detail selengkapnya.

Menerima intent siaran widget

AppWidgetProvider adalah class praktis. Jika Anda ingin menerima widget secara langsung, Anda dapat mengimplementasikan BroadcastReceiver atau mengganti tindakan Callback onReceive(Context,Intent). Intent yang perlu Anda perhatikan adalah berikut ini:

Membuat tata letak widget

Anda harus mendefinisikan tata letak awal untuk widget Anda dalam XML dan menyimpannya dalam res/layout/ project. Lihat Desain panduan untuk mengetahui detailnya.

Membuat tata letak widget mudah jika Anda sudah terbiasa dengan tata letak. Namun, perhatikan bahwa widget tata letak didasarkan pada RemoteViews, yang tidak mendukung setiap jenis tata letak atau widget tampilan. Anda tidak dapat menggunakan tampilan atau subclass tampilan yang didukung oleh RemoteViews.

RemoteViews juga mendukung ViewStub, yaitu View tidak terlihat berukuran nol yang dapat Anda gunakan untuk meng-inflate tata letak secara lambat resource pada runtime.

Dukungan untuk perilaku stateful

Android 12 menambahkan dukungan untuk perilaku stateful menggunakan komponen yang sudah ada:

Widget tetap stateless. Aplikasi Anda harus menyimpan status dan mendaftar peristiwa perubahan status.

Contoh widget daftar belanja yang menampilkan perilaku stateful
Gambar 3. Contoh perilaku stateful.

Contoh kode berikut menunjukkan cara menerapkan komponen ini.

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));

Menyediakan dua tata letak: satu tata letak yang menargetkan perangkat yang menjalankan Android 12 atau lebih tinggi di res/layout-v31, dan penargetan lainnya Android 11 atau yang lebih lama di folder res/layout default.

Menerapkan sudut bulat

Android 12 memperkenalkan parameter sistem berikut untuk menyetel radius sudut bulat widget Anda:

Contoh berikut menunjukkan widget yang menggunakan system_app_widget_background_radius untuk sudut widget dan system_app_widget_inner_radius untuk tampilan di dalam widget.

Widget yang menunjukkan radius latar belakang widget dan tampilan di dalam widget
Gambar 4. Sudut membulat.

1 Sudut widget.

2 Sudut tampilan di dalam widget.

Pertimbangan penting untuk sudut lengkung

  • Peluncur pihak ketiga dan produsen perangkat dapat mengganti system_app_widget_background_radius agar lebih kecil dari 28 dp. Parameter system_app_widget_inner_radius selalu 8 dp lebih kecil dari nilai system_app_widget_background_radius.
  • Jika widget Anda tidak menggunakan @android:id/background atau menentukan latar belakang yang mengklip kontennya berdasarkan garis batas—dengan android:clipToOutline disetel ke true—peluncur secara otomatis mengidentifikasi latar belakang dan mengklip widget menggunakan persegi panjang dengan sudut membulat hingga 16 dp. Lihat Memastikan widget Anda kompatibel dengan Android 12.

Untuk kompatibilitas widget dengan versi Android sebelumnya, sebaiknya menentukan atribut khusus dan menggunakan tema khusus untuk menggantikannya Android 12, seperti yang ditunjukkan dalam contoh file XML berikut:

/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" />