Koleksiyon widget'larını kullanma

Compose yöntemini deneyin

Jetpack Compose, Android için önerilen kullanıcı arayüzü araç setidir. Compose tarzı API'leri kullanarak widget oluşturmayı öğrenin.

Jetpack Glance →

Koleksiyon widget'ları, aynı türden birçok öğeyi görüntüleme konusunda uzmanlaşmıştır. Örneğin, bir galeri uygulamasındaki resim koleksiyonları, bir haber uygulamasındaki makaleler veya bir iletişim uygulamasındaki mesajlar. Koleksiyon widget'ları genellikle iki kullanım alanına odaklanır: koleksiyona göz atma ve koleksiyonun bir öğesini ayrıntılı görünümüne açma. Koleksiyon widget'ları dikey olarak kaydırılabilir.

Bu widget'lar, içerik sağlayıcı gibi uzak verilerle desteklenen koleksiyonları görüntülemek için RemoteViewsService kullanır. Widget, verileri koleksiyon görünümleri olarak bilinen aşağıdaki görünüm türlerinden birini kullanarak sunar:

ListView: Öğeleri dikey olarak kaydırılan bir listede gösteren görünüm.

GridView: Öğeleri iki boyutlu kaydırılabilir bir ızgarada gösteren görünüm.

StackView: Kullanıcının önceki veya sonraki kartı görmek için ön kartı yukarı ya da aşağı kaydırabileceği, kartvizitlik benzeri yığın kart görünümü.

AdapterViewFlipper: İki veya daha fazla görünüm arasında animasyon oluşturan, adaptör destekli bir ViewAnimator. Aynı anda yalnızca bir çocuk gösterilir.

Bu koleksiyon görünümleri, uzak verilerle desteklenen koleksiyonları gösterdiğinden, kullanıcı arayüzlerini verilerine bağlamak için bir Adapter kullanırlar. Adapter, bir veri kümesindeki bağımsız öğeleri bağımsız View nesnelerine bağlar.

Bu koleksiyon görünümleri adaptörlerle desteklendiğinden Android çerçevesi, widget'larda kullanımlarını desteklemek için ek mimari içermelidir. Widget bağlamında Adapter, Adapter arayüzünün ince bir sarmalayıcısı olan RemoteViewsFactory ile değiştirilir. Koleksiyondaki belirli bir öğe istendiğinde RemoteViewsFactory, koleksiyon için öğeyi oluşturur ve RemoteViews nesnesi olarak döndürür. Widget'ınıza koleksiyon görünümü eklemek için RemoteViewsService ve RemoteViewsFactory öğelerini uygulayın.

RemoteViewsService, uzak bir bağdaştırıcının RemoteViews nesneleri istemesine olanak tanıyan bir hizmettir. RemoteViewsFactory, ListView, GridView ve StackView gibi bir koleksiyon görünümü ile bu görünümün temelindeki veriler arasında bir adaptör arayüzüdür. StackWidgetÖrnekten, bu hizmeti ve arayüzü uygulamak için ortak metin kodu örneğini burada bulabilirsiniz:

class StackWidgetService : RemoteViewsService() {
    override fun onGetViewFactory(intent: Intent): RemoteViewsFactory =
        StackRemoteViewsFactory(this.applicationContext, intent)
}

class StackRemoteViewsFactory(
    private val context: Context, intent: Intent
) : RemoteViewsService.RemoteViewsFactory {

    // See the RemoteViewsFactory API reference for the full list of methods to implement.

}
Collections.kt

Örnek uygulama

Bu bölümdeki kod alıntıları da StackWidget örneğinden alınmıştır:

Şekil 1. StackWidget.

Bu örnek, sıfırdan dokuza kadar olan değerleri gösteren on görünümden oluşan bir yığından oluşur. Örnek widget'ın temel davranışları şunlardır:

• Kullanıcı, sonraki veya önceki görünümü görüntülemek için widget'taki üst görünümü dikey olarak kaydırabilir. Bu, yerleşik bir StackView davranışıdır.

• Kullanıcı etkileşimi olmadan widget, görünümleri arasında otomatik olarak ilerler. Bu, slayt gösterisine benzer. Bunun nedeni, res/xml/stackwidgetinfo.xml dosyasındaki android:autoAdvanceViewId="@id/stack_view" ayarıdır. Bu ayar, görünüm kimliği için geçerlidir. Bu örnekte, yığın görünümünün görünüm kimliğidir.

• Kullanıcı üstteki görünüme dokunursa widget, Toast "n görünümüne dokunuldu" mesajını gösterir. Burada n, dokunulan görünümün dizinidir (konumudur). Davranışların nasıl uygulanacağı hakkında daha fazla bilgi için Öğelere tek tek davranış ekleme bölümüne bakın.

Koleksiyonlarla widget'ları uygulama

Koleksiyon içeren bir widget uygulamak için herhangi bir widget'ı uygulama prosedürünü uygulayın ve ardından birkaç ek adım uygulayın: manifesti değiştirin, widget düzenine bir koleksiyon görünümü ekleyin ve AppWidgetProvider alt sınıfınızı değiştirin.

Koleksiyon içeren widget'lar için manifest

Manifest dosyasında widget tanımlama bölümünde listelenen şartların yanı sıra, koleksiyon içeren widget'ların RemoteViewsService uygulamanıza bağlanabilmesini sağlamanız gerekir. Bunu yapmak için manifest dosyanızda BIND_REMOTEVIEWS izniyle hizmeti beyan edin. Bu sayede diğer uygulamalar widget'ınızın verilerine serbestçe erişemez.

Örneğin, bir koleksiyon görünümünü doldurmak için RemoteViewsService kullanan bir widget oluştururken manifest girişi aşağıdaki gibi görünebilir:

<service android:name="MyWidgetService"
    android:permission="android.permission.BIND_REMOTEVIEWS" />

Bu örnekte android:name="MyWidgetService", RemoteViewsService alt sınıfınızı ifade eder.

Koleksiyon içeren widget'ların düzeni

Widget düzeni XML dosyanızın temel şartı, şu koleksiyon görünümlerinden birini içermesidir: ListView, GridView, StackView veya AdapterViewFlipper. StackWidget örneği için widget_layout.xml dosyası:

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <StackView
        android:id="@+id/stack_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:loopViews="true" />
    <TextView
        android:id="@+id/empty_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:background="@drawable/widget_item_background"
        android:textColor="#ffffff"
        android:textStyle="bold"
        android:text="@string/empty_view_text"
        android:textSize="20sp" />
</FrameLayout>
widget_layout.xml

Boş görünümler, boş görünümün boş durumu temsil ettiği koleksiyon görünümünün kardeşleri olmalıdır.

Tüm widget'ınızın düzen dosyasının yanı sıra koleksiyondaki her bir öğenin düzenini tanımlayan başka bir düzen dosyası oluşturun. Örneğin, bir kitap koleksiyonundaki her kitap için bir düzen oluşturun. StackWidget örneğinde, tüm öğeler aynı düzeni kullandığı için yalnızca bir öğe düzeni dosyası (widget_item.xml) vardır.

Koleksiyon içeren widget'lar için AppWidgetProvider sınıfı

Normal widget'larda olduğu gibi, AppWidgetProvider alt sınıfınızdaki kodun büyük kısmı genellikle onUpdate() içinde yer alır. Koleksiyon içeren bir widget oluştururken onUpdate() için uygulamanızdaki en büyük fark, setRemoteAdapter() yöntemini çağırmanız gerekmesidir. Bu, koleksiyon görünümüne verilerini nereden alacağını bildirir. Ardından RemoteViewsService, RemoteViewsFactory uygulamanızı döndürebilir ve widget uygun verileri sunabilir. Bu yöntemi çağırdığınızda, RemoteViewsService uygulamanızı işaret eden bir intent ve güncellenecek widget'ı belirten widget kimliğini iletin.

Örneğin, StackWidget örneği, widget koleksiyonu için uzak bağdaştırıcı olarak RemoteViewsService öğesini ayarlamak üzere onUpdate() geri çağırma yöntemini şu şekilde uygular:

override fun onUpdate(
    context: Context, appWidgetManager: AppWidgetManager, appWidgetIds: IntArray
) {
    // Update each of the widgets with the remote adapter.
    appWidgetIds.forEach { appWidgetId ->

        // Set up the intent that starts the StackViewService, which
        // provides the views for this collection.
        val intent = Intent(context, StackWidgetService::class.java).apply {
            // Add the widget ID to the intent extras.
            putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
            data = Uri.parse(toUri(Intent.URI_INTENT_SCHEME))
        }
        // Instantiate the RemoteViews object for the widget layout.
        val views = RemoteViews(context.packageName, R.layout.widget_layout).apply {
            // Set up the RemoteViews object to use a RemoteViews adapter.
            // This adapter connects to a RemoteViewsService through the
            // specified intent.
            // This is how you populate the data.
            setRemoteAdapter(R.id.stack_view, intent)

            // The empty view is displayed when the collection has no items.
            // It must be in the same layout used to instantiate the
            // RemoteViews object.
            setEmptyView(R.id.stack_view, R.id.empty_view)
        }

        // Do additional processing specific to this widget.

        appWidgetManager.updateAppWidget(appWidgetId, views)
    }
    super.onUpdate(context, appWidgetManager, appWidgetIds)
}
Collections.kt

Verileri kalıcı hale getirme

Bu sayfada açıklandığı gibi, RemoteViewsService alt sınıfı, uzak koleksiyon görünümünü doldurmak için kullanılan RemoteViewsFactory değerini sağlar.

Özellikle şu adımları uygulayın:

1. Alt sınıf RemoteViewsService. RemoteViewsService, uzak bir bağdaştırıcının RemoteViews isteyebileceği hizmettir.

2. RemoteViewsService alt sınıfınıza RemoteViewsFactory arayüzünü uygulayan bir sınıf ekleyin. RemoteViewsFactory, ListView, GridView, StackView gibi uzak koleksiyon görünümü ile bu görünümün temel verileri arasındaki adaptör için bir arayüzdür. Uygulamanız, veri kümesindeki her öğe için bir RemoteViews nesnesi oluşturmaktan sorumludur. Bu arayüz, Adapter için ince bir sarmalayıcıdır.

Hizmetinizin tek bir örneğinin veya içerdiği verilerin kalıcı olacağına güvenemezsiniz. Statik olmadığı sürece RemoteViewsService içinde veri depolamayın. Widget'ınızın verilerinin kalıcı olmasını istiyorsanız en iyi yaklaşım, verileri işlem yaşam döngüsünün ötesinde kalıcı olan bir ContentProvider kullanmaktır. Örneğin, bir market widget'ı, her market listesi öğesinin durumunu SQL veritabanı gibi kalıcı bir konumda depolayabilir.

Not: ContentProvider kullanarak bir widget'ın temel verilerinin nasıl kalıcı hale getirileceğini gösteren kod örneği için WeatherDataProvider.java sayfasına bakın.

RemoteViewsService uygulamasının birincil içeriği, sonraki bölümde açıklanan RemoteViewsFactory öğesidir.

RemoteViewsFactory arayüzü

RemoteViewsFactory arayüzünü uygulayan özel sınıfınız, widget'a koleksiyonundaki öğelerin verilerini sağlar. Bunun için widget öğesi XML düzen dosyanızı bir veri kaynağıyla birleştirir. Bu veri kaynağı, veritabanından diziye kadar her şey olabilir. StackWidget örneğinde veri kaynağı bir WidgetItems dizisidir. RemoteViewsFactory, verileri uzak koleksiyon görünümüne bağlamak için bir adaptör görevi görür.

RemoteViewsFactory alt sınıfınız için uygulamanız gereken en önemli iki yöntem onCreate() ve getViewAt() yöntemleridir.

Sistem, fabrikanızı ilk kez oluştururken onCreate() yöntemini çağırır. Veri kaynağınızla ilgili bağlantıları veya imleçleri buradan ayarlayabilirsiniz. Örneğin, StackWidget örneği, bir WidgetItem nesnesi dizisini ilk kullanıma hazırlamak için onCreate() kullanır. Widget'ınız etkin olduğunda sistem, dizideki dizin konumlarını kullanarak bu nesnelere erişir ve içerdikleri metni gösterir.

StackWidget örneğinin RemoteViewsFactory uygulamasından, onCreate() yönteminin bölümlerini gösteren bir alıntıyı aşağıda bulabilirsiniz:

private const val REMOTE_VIEW_COUNT: Int = 10

class StackRemoteViewsFactory(
    private val context: Context
) : RemoteViewsService.RemoteViewsFactory {

    private lateinit var widgetItems: List<WidgetItem>

    override fun onCreate() {
        // In onCreate(), set up any connections or cursors to your data
        // source. Heavy lifting, such as downloading or creating content,
        // must be deferred to onDataSetChanged() or getViewAt(). Taking
        // more than 20 seconds on this call results in an ANR.
        widgetItems = List(REMOTE_VIEW_COUNT) { index -> WidgetItem("$index!") }
    }

}
Collections.kt

RemoteViewsFactory yöntemi getViewAt(), veri kümesinde belirtilen position konumundaki verilere karşılık gelen bir RemoteViews nesnesi döndürür. StackWidget örneğinin RemoteViewsFactory uygulamasından bir alıntıyı aşağıda bulabilirsiniz:

override fun getViewAt(position: Int): RemoteViews {
    // Construct a remote views item based on the widget item XML file
    // and set the text based on the position.
    return RemoteViews(context.packageName, R.layout.widget_item).apply {
        setTextViewText(R.id.widget_item, widgetItems[position].text)
    }
}
Collections.kt

Öğelere tek tek davranış ekleme

Önceki bölümlerde, verilerinizi widget koleksiyonunuza nasıl bağlayacağınız gösterilmiştir. Peki, koleksiyon görünümünüzdeki öğelere dinamik davranış eklemek isterseniz ne yapmanız gerekir?

onUpdate() sınıfıyla etkinlikleri işleme bölümünde açıklandığı gibi, bir nesnenin tıklama davranışını ayarlamak için normalde setOnClickPendingIntent() kullanırsınız. Örneğin, bir düğmenin Activity başlatmasını sağlayabilirsiniz. Ancak bu yaklaşıma, tek bir koleksiyon öğesindeki çocuk ekranları için izin verilmez. Örneğin, Gmail widget'ında uygulamayı başlatan genel bir düğme oluşturmak için setOnClickPendingIntent() kullanabilirsiniz ancak bu düğmeyi her bir liste öğesinde kullanamazsınız.

Bunun yerine, bir koleksiyondaki öğelere ayrı ayrı tıklama davranışı eklemek için setOnClickFillInIntent() kullanın. Koleksiyon görünümünüz için beklemede olan intent şablonu oluşturun ve RemoteViewsFactory kullanarak koleksiyondaki her öğe için doldurma intent'i ayarlayın.

Bu bölümde, öğelere ayrı ayrı davranış ekleme işlemini açıklamak için StackWidget örneği kullanılmıştır. StackWidget örneğinde, kullanıcı üstteki görünüme dokunursa widget, Toast "Dokunulan görünüm n" mesajını gösterir. Burada n, dokunulan görünümün dizinidir (konumudur). İşleyişi:

• StackWidgetProvider (bir AppWidgetProvider alt sınıfı), TOAST_ACTION adlı özel bir işlemle beklemede olan bir intent oluşturur.

• Kullanıcı bir görünüme dokunduğunda intent tetiklenir ve TOAST_ACTION yayınlanır.

• Bu yayın, StackWidgetProvider sınıfının onReceive() yöntemi tarafından kesilir ve widget, dokunulan görünüm için Toast mesajını gösterir. Koleksiyon öğelerinin verileri, RemoteViewsService aracılığıyla RemoteViewsFactory tarafından sağlanır.

Not: StackWidget örneğinde bir yayın kullanılır ancak genellikle widget'lar bu tür senaryolarda bir etkinlik başlatır.

Beklemede olan intent şablonunu ayarlama

StackWidgetProvider (AppWidgetProvider alt sınıfı), beklemede olan intent oluşturur. Bir koleksiyonun ayrı ayrı öğeleri kendi beklemede olan intent'lerini ayarlayamaz. Bunun yerine, koleksiyon bir bütün olarak beklemede olan intent şablonu oluşturur ve her bir öğe, öğe bazında benzersiz davranış oluşturmak için doldurma intent'i ayarlar.

Bu sınıf, kullanıcı bir görünüme dokunduğunda gönderilen yayını da alır. Bu etkinliği onReceive() yönteminde işler. Intent'in işlemi TOAST_ACTION ise widget, geçerli görünüm için Toast mesajı gösterir.

const val TOAST_ACTION = "com.example.android.stackwidget.TOAST_ACTION"
const val EXTRA_ITEM = "com.example.android.stackwidget.EXTRA_ITEM"

class StackWidgetProvider : AppWidgetProvider() {

    // ...

    // Called when the BroadcastReceiver receives an Intent broadcast.
    // Checks whether the intent's action is TOAST_ACTION. If it is, the
    // widget displays a Toast message for the current item.
    override fun onReceive(context: Context, intent: Intent) {
        val mgr: AppWidgetManager = AppWidgetManager.getInstance(context)
        if (intent.action == TOAST_ACTION) {
            val appWidgetId: Int = intent.getIntExtra(
                AppWidgetManager.EXTRA_APPWIDGET_ID,
                AppWidgetManager.INVALID_APPWIDGET_ID
            )
            // EXTRA_ITEM represents a custom value provided by the Intent
            // passed to the setOnClickFillInIntent() method to indicate the
            // position of the clicked item. See StackRemoteViewsFactory in
            // Set the fill-in Intent for details.
            val viewIndex: Int = intent.getIntExtra(EXTRA_ITEM, 0)
            Toast.makeText(context, "Touched view $viewIndex", Toast.LENGTH_SHORT).show()
        }
        super.onReceive(context, intent)
    }

    override fun onUpdate(
        context: Context,
        appWidgetManager: AppWidgetManager,
        appWidgetIds: IntArray
    ) {
        // Update each of the widgets with the remote adapter.
        appWidgetIds.forEach { appWidgetId ->

            // Sets up the intent that points to the StackViewService that
            // provides the views for this collection.
            val intent = Intent(context, StackWidgetService::class.java).apply {
                putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
                // When intents are compared, the extras are ignored, so embed
                // the extra sinto the data so that the extras are not ignored.
                data = Uri.parse(toUri(Intent.URI_INTENT_SCHEME))
            }
            val rv = RemoteViews(context.packageName, R.layout.widget_layout).apply {
                setRemoteAdapter(R.id.stack_view, intent)

                // The empty view is displayed when the collection has no items.
                // It must be a sibling of the collection view.
                setEmptyView(R.id.stack_view, R.id.empty_view)
            }

            // This section makes it possible for items to have individualized
            // behavior. It does this by setting up a pending intent template.
            // Individuals items of a collection can't set up their own pending
            // intents. Instead, the collection as a whole sets up a pending
            // intent template, and the individual items set a fillInIntent
            // to create unique behavior on an item-by-item basis.
            val toastPendingIntent: PendingIntent = Intent(
                context,
                StackWidgetProvider::class.java
            ).run {
                // Set the action for the intent.
                // When the user touches a particular view, it has the effect of
                // broadcasting TOAST_ACTION.
                action = TOAST_ACTION
                putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId)
                data = Uri.parse(toUri(Intent.URI_INTENT_SCHEME))

                // The template must be mutable, because each item fills in its
                // own extras through setOnClickFillInIntent().
                PendingIntent.getBroadcast(
                    context, 0, this,
                    PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
                )
            }
            rv.setPendingIntentTemplate(R.id.stack_view, toastPendingIntent)

            appWidgetManager.updateAppWidget(appWidgetId, rv)
        }
        super.onUpdate(context, appWidgetManager, appWidgetIds)
    }
}
Collections.kt

Doldurma niyetini ayarlama

RemoteViewsFactory, koleksiyondaki her öğe için bir doldurma amacı ayarlamalıdır. Bu sayede, belirli bir öğenin tıklama işleminden sonraki davranışını ayırt etmek mümkün olur. Ardından, doldurma intent'i PendingIntent şablonuyla birleştirilerek öğeye dokunulduğunda yürütülecek nihai intent belirlenir.

private const val REMOTE_VIEW_COUNT: Int = 10

class StackRemoteViewsFactory(
    private val context: Context,
    intent: Intent
) : RemoteViewsService.RemoteViewsFactory {

    private lateinit var widgetItems: List<WidgetItem>
    private val appWidgetId: Int = intent.getIntExtra(
        AppWidgetManager.EXTRA_APPWIDGET_ID,
        AppWidgetManager.INVALID_APPWIDGET_ID
    )

    override fun onCreate() {
        // In onCreate(), set up any connections or cursors to your data source.
        // Heavy lifting, such as downloading or creating content, must be
        // deferred to onDataSetChanged() or getViewAt(). Taking more than 20
        // seconds on this call results in an ANR.
        widgetItems = List(REMOTE_VIEW_COUNT) { index -> WidgetItem("$index!") }
        // ...
    }

    // ...

    override fun getViewAt(position: Int): RemoteViews {
        // Construct a remote views item based on the widget item XML file
        // and set the text based on the position.
        return RemoteViews(context.packageName, R.layout.widget_item).apply {
            setTextViewText(R.id.widget_item, widgetItems[position].text)

            // Set a fill-intent to fill in the pending intent template.
            // that is set on the collection view in StackWidgetProvider.
            val fillInIntent = Intent().apply {
                Bundle().also { extras ->
                    extras.putInt(EXTRA_ITEM, position)
                    putExtras(extras)
                }
            }
            // Make it possible to distinguish the individual on-click
            // action of a given item.
            setOnClickFillInIntent(R.id.widget_item, fillInIntent)
            // ...
        }
    }
    // ...
}
Collections.kt

Koleksiyon verilerini güncel tutma

Şekil 2'de, koleksiyonları kullanan bir widget'taki güncelleme akışı gösterilmektedir. Bu örnekte, widget kodunun RemoteViewsFactory ile nasıl etkileşim kurduğu ve güncellemeleri nasıl tetikleyebileceğiniz gösterilmektedir:

Şekil 2. Güncellemeler sırasında RemoteViewsFactory ile etkileşim.

Koleksiyonları kullanan widget'lar, kullanıcılara güncel içerikler sunabilir. Örneğin, Gmail widget'ı kullanıcılara gelen kutularının anlık görüntüsünü sunar. Bunu mümkün kılmak için RemoteViewsFactory ve koleksiyon görünümünüzü yeni verileri alıp gösterecek şekilde tetikleyin.

Bunun için AppWidgetManager kullanarak notifyAppWidgetViewDataChanged() yöntemini çağırın. Bu çağrı, RemoteViewsFactory nesnenizin onDataSetChanged() yöntemine geri çağırma ile sonuçlanır. Bu sayede yeni verileri getirebilirsiniz.

onDataSetChanged() geri çağırma işlevinde yoğun işlem gerektiren işlemleri eşzamanlı olarak gerçekleştirebilirsiniz. Bu çağrı, meta veriler veya görüntüleme verileri RemoteViewsFactory üzerinden getirilmeden önce tamamlanır. Ayrıca, getViewAt() yönteminde yoğun işlem gerektiren işlemler de gerçekleştirebilirsiniz. Bu çağrı uzun sürerse RemoteViewsFactory nesnesinin getLoadingView() yöntemiyle belirtilen yükleme görünümü, döndürülene kadar koleksiyon görünümünün ilgili konumunda gösterilir.

Koleksiyonu doğrudan iletmek için RemoteCollectionItems'ı kullanın.

Android 12 (API düzeyi 31), uygulamanızın bir koleksiyon görünümünü doldururken doğrudan bir koleksiyonu iletmesine olanak tanıyan setRemoteAdapter(int viewId, RemoteViews.RemoteCollectionItems items) yöntemini ekler. Adaptörünüzü bu yöntemi kullanarak ayarlarsanız RemoteViewsFactory uygulamanız ve notifyAppWidgetViewDataChanged() yöntemini çağırmanız gerekmez.

Bu yaklaşım, adaptörünüzü doldurmayı kolaylaştırmanın yanı sıra kullanıcılar yeni bir öğeyi görmek için listeyi kaydırdığında yeni öğelerin doldurulmasıyla ilgili gecikmeyi de ortadan kaldırır. Koleksiyon öğesi grubunuz nispeten küçük olduğu sürece adaptörü ayarlamak için bu yaklaşım tercih edilir. Ancak örneğin, koleksiyonunuzda setImageViewBitmap öğesine iletilen çok sayıda Bitmaps varsa bu yaklaşım pek işe yaramaz.

Koleksiyon sabit bir düzen grubu kullanmıyorsa (yani bazı öğeler yalnızca bazen mevcutsa) koleksiyonun içerebileceği maksimum benzersiz düzen sayısını belirtmek için setViewTypeCount kullanın. Bu sayede adaptör, uygulama widget'ınızdaki güncellemelerde yeniden kullanılabilir.

Basitleştirilmiş RemoteViews koleksiyonlarının nasıl uygulanacağına dair bir örneği aşağıda bulabilirsiniz.

val itemLayouts = listOf(
    R.layout.item_type_1,
    R.layout.item_type_2,
    // ...
)

remoteView.setRemoteAdapter(
    R.id.list_view,
    RemoteViews.RemoteCollectionItems.Builder()
        .addItem(/* id= */ ID_1, RemoteViews(context.packageName, R.layout.item_type_1))
        .addItem(/* id= */ ID_2, RemoteViews(context.packageName, R.layout.item_type_2))
        // ...
        .setViewTypeCount(itemLayouts.count())
        .build()
)
Collections.kt

Not: setViewTypeCount() çağrılırken bu koleksiyonda RemoteViews tarafından kullanılan farklı düzen kimliklerinin maksimum sayısını iletin. Aksi takdirde, görünüm türü sayısı sağlanan öğelerden tahmin edilir ve ek düzenler kullanan bir güncelleme gönderilirken bağdaştırıcı yeniden oluşturulur.