Sammlungs-Widgets sind auf die Anzeige vieler Elemente desselben Typs spezialisiert, z. B. als Bildersammlungen aus einer Galerie-App, Artikeln aus einer Nachrichten-App oder Nachrichten von einer Kommunikations-App. Sammlungs-Widgets konzentrieren sich in der Regel auf zwei Verwendungsmöglichkeiten: Cases: Sammlung durchsuchen und ein Element der Sammlung in der zugehörigen Detailansicht. Sammlungs-Widgets können vertikal scrollen.
Diese Widgets verwenden die Methode
RemoteViewsService zum Anzeigen
Sammlungen, die durch Remote-Daten gestützt werden, beispielsweise aus Inhalten
Dienstanbieter. Das Widget zeigt die
mit einem der folgenden Ansichtstypen, die als Sammlungstypen bezeichnet werden
Ansichten
ListView- Eine Ansicht, die Elemente in einem Liste vertikal scrollen.
GridView- Eine Ansicht, die Elemente in einem ein zweidimensionales Scrollraster.
StackView- Eine gestapelte Karte eine Art Rolodex-Ansicht, in der der Nutzer Karte nach oben oder unten, um die vorherige bzw. die nächste Karte aufzurufen.
AdapterViewFlipper- Ein
adaptergestütztes einfaches Format
ViewAnimator, die animiert zwischen zwei oder mehr Ansichten. Es wird jeweils nur ein Kind angezeigt.
Da diese Sammlungsansichten auf Remote-Daten gestützte Sammlungen zeigen,
einen Adapter verwenden, um den Nutzer zu binden
Schnittstelle zu ihren Daten. Ein Adapter bindet einzelne Elemente aus einem Datensatz
für einzelne View-Objekte.
Da diese Sammlungsansichten von Adaptern gestützt werden, kann das Android-Framework
muss eine zusätzliche Architektur enthalten, die ihre Verwendung in Widgets unterstützt. Im Kontext
eines Widgets wird der Adapter durch einen
RemoteViewsFactory,
Dies ist ein Thin Wrapper um die Adapter-Schnittstelle. Auf Anforderung einer
für ein bestimmtes Element in der Sammlung, wird der RemoteViewsFactory erstellt und
das Element für die Sammlung als
Objekt RemoteViews. Um eine
Sammlungsansicht in Ihr Widget aufnehmen, implementieren Sie RemoteViewsService und
RemoteViewsFactory.
RemoteViewsService ist ein Dienst, mit dem ein Remote-Adapter eine Anfrage stellen kann.
RemoteViews-Objekte. RemoteViewsFactory ist eine Schnittstelle für einen Adapter
zwischen einer Sammlungsansicht wie ListView, GridView und
StackView und die zugrunde liegenden Daten für diese Ansicht. Aus der StackWidget
Stichprobe,
Hier ist ein Beispiel für den Boilerplate-Code zur Implementierung dieses Dienstes
Schnittstelle:
Kotlin
class StackWidgetService : RemoteViewsService() {
override fun onGetViewFactory(intent: Intent): RemoteViewsFactory {
return 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.
}
Java
public class StackWidgetService extends RemoteViewsService {
@Override
public RemoteViewsFactory onGetViewFactory(Intent intent) {
return new StackRemoteViewsFactory(this.getApplicationContext(), intent);
}
}
class StackRemoteViewsFactory implements RemoteViewsService.RemoteViewsFactory {
// See the RemoteViewsFactory API reference for the full list of methods to
// implement.
}
Beispielanwendung
Die Code-Auszüge in diesem Abschnitt stammen ebenfalls aus dem StackWidget
Beispiel:
StackWidget.Dieses Beispiel besteht aus einem Stapel von zehn Ansichten, in denen die Werte null angezeigt werden. bis neun. Das Beispiel-Widget hat folgende primäre Verhaltensweisen:
Der Nutzer kann über die Draufsicht im Widget vertikal schwenken, um den nächsten oder vorherige Ansicht. Dies ist ein integriertes
StackView-Verhalten.Ohne Nutzerinteraktion navigiert das Widget automatisch durch die wie bei einer Diashow. Das liegt an der Einstellung
android:autoAdvanceViewId="@id/stack_view"in derres/xml/stackwidgetinfo.xml-Datei. Diese Einstellung gilt für die ID der Datenansicht, In diesem Fall ist das die ID der Ansicht.Berührt der Nutzer die Draufsicht, zeigt das Widget die
Toasthat die Meldung "Berührte Ansicht n", Wo? n ist der Index (Position) der berührten Ansicht. Weitere Informationen dazu, Informationen zur Implementierung von Verhaltensweisen finden Sie im Artikel Verhalten zu einzelnen Nutzern hinzufügen Artikel an.
Widgets mit Sammlungen implementieren
Um ein Widget mit Sammlungen zu implementieren, folgen Sie der Anleitung zum Implementieren von
Widget, gefolgt von einigen zusätzlichen Schritten:
das Manifest ändern, dem Layout des Widgets eine Sammlungsansicht hinzufügen und
AppWidgetProvider abgeleitet.
Manifest für Widgets mit Sammlungen
Über die Anforderungen hinaus, die unter Widget deklarieren in der
Manifest müssen Sie es für Widgets mit
Sammlungen, die an RemoteViewsService gebunden werden sollen. Deklarieren Sie dazu die
in Ihrer Manifestdatei mit der Berechtigung
BIND_REMOTEVIEWS
Dadurch wird verhindert, dass andere Anwendungen ungehindert auf die Daten Ihres Widgets zugreifen.
Wenn Sie beispielsweise ein Widget erstellen, das mit RemoteViewsService ein
Sammlungsansicht hat, könnte der Manifesteintrag so aussehen:
<service android:name="MyWidgetService"
android:permission="android.permission.BIND_REMOTEVIEWS" />
In diesem Beispiel bezieht sich android:name="MyWidgetService" auf die abgeleitete Klasse von
RemoteViewsService.
Layout für Widgets mit Sammlungen
Die Hauptanforderung an Ihre Widget-Layout-XML-Datei ist, dass sie eines der folgenden Elemente enthält:
der Sammlungsansichten: ListView, GridView, StackView oder
AdapterViewFlipper. Hier ist die Datei widget_layout.xml für den
StackWidget
Beispiel:
<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>
Leere Ansichten müssen der Sammlungsansicht gleichgeordnet sein, für die der Eine leere Ansicht steht für einen leeren Zustand.
Erstellen Sie zusätzlich zur Layoutdatei für Ihr gesamtes Widget ein weiteres Layout
-Datei, die das Layout für jedes Element in der Sammlung definiert, z. B.
ein Layout für jedes Buch in einer Büchersammlung. Das Beispiel StackWidget hat
nur eine Element-Layoutdatei, widget_item.xml, da alle Elemente dasselbe
Layout.
AppWidgetProvider-Klasse für Widgets mit Sammlungen
Wie bei normalen Widgets ist der Großteil des Codes
Abgeleitete AppWidgetProvider-Klasse
geht normalerweise in
onUpdate()
Der Hauptunterschied bei der Implementierung von onUpdate() beim Erstellen einer
für Sammlungen besteht darin, dass Sie
setRemoteAdapter() So erfahren Sie, wo die Daten der Sammlung abgerufen werden können.
RemoteViewsService kann dann die Implementierung
RemoteViewsFactory und das Widget kann die entsprechenden Daten bereitstellen. Wenn Sie
Methode aufrufen, übergeben Sie einen Intent, der auf Ihre Implementierung
RemoteViewsService und die Widget-ID, die das zu aktualisierende Widget angibt.
So wird beispielsweise im StackWidget-Beispiel die onUpdate()
Callback-Methode zur Festlegung von RemoteViewsService als Remote-Adapter für die
Widget-Sammlung:
Kotlin
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)
}
Java
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
// Update each of the widgets with the remote adapter.
for (int i = 0; i < appWidgetIds.length; ++i) {
// Set up the intent that starts the StackViewService, which
// provides the views for this collection.
Intent intent = new Intent(context, StackWidgetService.class);
// Add the widget ID to the intent extras.
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetIds[i]);
intent.setData(Uri.parse(intent.toUri(Intent.URI_INTENT_SCHEME)));
// Instantiate the RemoteViews object for the widget layout.
RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.widget_layout);
// 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.
views.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.
views.setEmptyView(R.id.stack_view, R.id.empty_view);
// Do additional processing specific to this widget.
appWidgetManager.updateAppWidget(appWidgetIds[i], views);
}
super.onUpdate(context, appWidgetManager, appWidgetIds);
}
Daten beibehalten
Wie auf dieser Seite beschrieben, bietet die abgeleitete RemoteViewsService-Klasse
Das RemoteViewsFactory, das zum Füllen der Remote-Sammlungsansicht verwendet wird.
Führen Sie insbesondere folgende Schritte aus:
Abgeleitete Klasse
RemoteViewsService.RemoteViewsServiceist der Dienst über den ein Remote-AdapterRemoteViewsanfordern kann.Nehmen Sie in die abgeleitete
RemoteViewsService-Klasse eine Klasse auf, die die KlasseRemoteViewsFactory-Schnittstelle.RemoteViewsFactoryist eine Schnittstelle für ein zwischen einer Remote-Sammlungsansicht wieListView,GridView,StackViewund die zugrunde liegenden Daten für diese Ansicht. Ihr -Implementierung ist dafür verantwortlich, einRemoteViews-Objekt für jedes -Element im Dataset. Diese Schnittstelle ist ein Thin Wrapper umAdapter.
Sie können sich nicht darauf verlassen, dass eine einzelne Instanz Ihres Dienstes oder die darin enthaltenen Daten
dauerhaft. Speichere keine Daten in deinem RemoteViewsService, es sei denn, sie sind statisch. Wenn
die Daten Ihres Widgets bestehen bleiben sollen, ist die Verwendung eines
ContentProvider, dessen Daten
über den Prozesslebenszyklus hinaus. Ein Lebensmittelgeschäft-Widget kann beispielsweise
den Status jedes Einkaufslisteneintrags an einem dauerhaften Ort speichern, z. B.
SQL-Datenbank.
Der Hauptinhalt der RemoteViewsService-Implementierung ist die
RemoteViewsFactory, wie im folgenden Abschnitt beschrieben.
RemoteViewsFactory-Schnittstelle
Ihre benutzerdefinierte Klasse, die die RemoteViewsFactory-Schnittstelle implementiert, bietet
das Widget mit den Daten für die Elemente in seiner Sammlung. Um dies zu tun,
kombiniert die XML-Layoutdatei Ihres Widget-Elements mit einer Datenquelle. Diese Quelle von
Daten können alles von einer Datenbank bis hin zu einem einfachen Array sein. Im StackWidget
Beispiel ist die Datenquelle ein Array von WidgetItems. Das RemoteViewsFactory
dient als Adapter, um die Daten in der Remote-Sammlungsansicht zusammenzuführen.
Die beiden wichtigsten Methoden, die Sie für Ihre
RemoteViewsFactory Unterklasse ist
onCreate() und
getViewAt()
Beim erstmaligen Erstellen Ihrer Factory ruft das System onCreate() auf.
Hier richten Sie alle Verbindungen oder Cursors zur Datenquelle ein. Für
Im Beispiel StackWidget wird onCreate() verwendet, um ein Array von
WidgetItem-Objekte. Wenn Ihr Widget aktiv ist, greift das System auf diese
-Objekte, die ihre Indexposition im Array verwenden, und zeigt den Text an, den sie
enthalten.
Hier ist ein Auszug aus dem RemoteViewsFactory des StackWidget-Beispiels.
-Implementierung, die Teile der Methode onCreate() zeigt:
Kotlin
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!") }
...
}
...
}
Java
class StackRemoteViewsFactory implements RemoteViewsService.RemoteViewsFactory {
private static final int REMOTE_VIEW_COUNT = 10;
private List<WidgetItem> widgetItems = new ArrayList<WidgetItem>();
public void onCreate() {
// In onCreate(), setup 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.
for (int i = 0; i < REMOTE_VIEW_COUNT; i++) {
widgetItems.add(new WidgetItem(i + "!"));
}
...
}
...
Die RemoteViewsFactory-Methode getViewAt() gibt ein RemoteViews-Objekt zurück.
entspricht den Daten an der angegebenen position im Dataset. Hier ist
Auszug aus der RemoteViewsFactory-Implementierung des StackWidget-Beispiels:
Kotlin
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)
}
}
Java
public RemoteViews getViewAt(int position) {
// Construct a remote views item based on the widget item XML file
// and set the text based on the position.
RemoteViews views = new RemoteViews(context.getPackageName(), R.layout.widget_item);
views.setTextViewText(R.id.widget_item, widgetItems.get(position).text);
return views;
}
Verhalten für einzelne Elemente hinzufügen
In den vorherigen Abschnitten wird gezeigt, wie Sie Ihre Daten an Ihre Widget-Sammlung binden. Aber wenn Sie den einzelnen Elementen in Ihrem Konto dynamisches Verhalten hinzufügen möchten, Sammlungsansicht?
Wie unter Ereignisse mit dem onUpdate()-Objekt verarbeitet
Klasse verwenden, verwenden Sie normalerweise
setOnClickPendingIntent() zum Festlegen des Klickverhaltens eines Objekts, z. B.
bewirken, dass eine Schaltfläche Activity startet. Aber
Diese Vorgehensweise ist für untergeordnete Ansichten eines einzelnen Sammlungselements nicht zulässig.
Du kannst beispielsweise setOnClickPendingIntent() verwenden, um eine globale Schaltfläche einzurichten.
zum Beispiel im Gmail-Widget zum Starten der App, aber nicht im
für einzelne Listenelemente.
Um ein Klickverhalten für einzelne Elemente in einer Sammlung hinzuzufügen, verwenden Sie
setOnClickFillInIntent() Dazu muss eine ausstehende Intent-Vorlage für
Sammlungsansicht aufrufen und dann für jedes Element in der Ansicht
über Ihr RemoteViewsFactory.
In diesem Abschnitt wird anhand des StackWidget-Beispiels beschrieben, wie Sie Verhalten zu
einzelne Elemente. Berührt der Nutzer im Beispiel StackWidget die Draufsicht,
zeigt das Widget die Toast-Meldung "Berührte Ansicht n" an. wobei n der Wert
Index (Position) der Berührungsansicht. So funktioniert's:
Die
StackWidgetProvider– einAppWidgetProviderabgeleitete Klasse: erstellt einen ausstehenden Intent mit einer benutzerdefinierten Aktion namensTOAST_ACTIONWenn der Nutzer eine Ansicht berührt, wird der Intent ausgelöst und eine Nachricht an alle gesendet.
TOAST_ACTIONDiese Übertragung wird von der Klasse
StackWidgetProviderabgefangenonReceive()und das Widget zeigt dieToast-Meldung an. für die berührte Ansicht aus. Die Daten für die Sammlungselemente werden vomRemoteViewsFactorydurchRemoteViewsService.
Ausstehende Intent-Vorlage einrichten
Das StackWidgetProvider (eine
AppWidgetProvider abgeleitet)
einen ausstehenden Intent eingerichtet. Einzelne Elemente einer Sammlung können nicht
eigene ausstehende Intents. Stattdessen richtet die Sammlung als Ganzes einen ausstehenden Intent ein.
und die einzelnen Elemente legen einen Fill-In-Intent fest, um eindeutige
für jedes einzelne Produkt zu erkennen.
Diese Klasse empfängt auch die Übertragung, die gesendet wird, wenn der Nutzer einen
Ansicht. Dieses Ereignis wird in der Methode onReceive() verarbeitet. Wenn der Intent
Aktion TOAST_ACTION ist, zeigt das Widget eine Toast-Meldung für die aktuelle
Ansicht.
Kotlin
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))
PendingIntent.getBroadcast(context, 0, this, PendingIntent.FLAG_UPDATE_CURRENT)
}
rv.setPendingIntentTemplate(R.id.stack_view, toastPendingIntent)
appWidgetManager.updateAppWidget(appWidgetId, rv)
}
super.onUpdate(context, appWidgetManager, appWidgetIds)
}
}
Java
public class StackWidgetProvider extends AppWidgetProvider {
public static final String TOAST_ACTION = "com.example.android.stackwidget.TOAST_ACTION";
public static final String EXTRA_ITEM = "com.example.android.stackwidget.EXTRA_ITEM";
...
// 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
public void onReceive(Context context, Intent intent) {
AppWidgetManager mgr = AppWidgetManager.getInstance(context);
if (intent.getAction().equals(TOAST_ACTION)) {
int appWidgetId = 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.
int viewIndex = intent.getIntExtra(EXTRA_ITEM, 0);
Toast.makeText(context, "Touched view " + viewIndex, Toast.LENGTH_SHORT).show();
}
super.onReceive(context, intent);
}
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
// Update each of the widgets with the remote adapter.
for (int i = 0; i < appWidgetIds.length; ++i) {
// Sets up the intent that points to the StackViewService that
// provides the views for this collection.
Intent intent = new Intent(context, StackWidgetService.class);
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetIds[i]);
// When intents are compared, the extras are ignored, so embed
// the extras into the data so that the extras are not
// ignored.
intent.setData(Uri.parse(intent.toUri(Intent.URI_INTENT_SCHEME)));
RemoteViews rv = new RemoteViews(context.getPackageName(), R.layout.widget_layout);
rv.setRemoteAdapter(appWidgetIds[i], 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.
rv.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.
Intent toastIntent = new Intent(context, StackWidgetProvider.class);
// Set the action for the intent.
// When the user touches a particular view, it has the effect of
// broadcasting TOAST_ACTION.
toastIntent.setAction(StackWidgetProvider.TOAST_ACTION);
toastIntent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetIds[i]);
intent.setData(Uri.parse(intent.toUri(Intent.URI_INTENT_SCHEME)));
PendingIntent toastPendingIntent = PendingIntent.getBroadcast(context, 0, toastIntent,
PendingIntent.FLAG_UPDATE_CURRENT);
rv.setPendingIntentTemplate(R.id.stack_view, toastPendingIntent);
appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
}
super.onUpdate(context, appWidgetManager, appWidgetIds);
}
}
Fill-in-Intent festlegen
RemoteViewsFactory muss für jedes Element im
. So kann zwischen den einzelnen Aktionen bei einem Klick unterschieden werden.
eines bestimmten Artikels. Der Fill-in-Intent wird dann mit dem
Vorlage PendingIntent, um festzulegen,
den endgültigen Intent, der ausgeführt wird, wenn auf das Element getippt wird.
Kotlin
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)
...
}
}
...
}
Java
public class StackWidgetService extends RemoteViewsService {
@Override
public RemoteViewsFactory onGetViewFactory(Intent intent) {
return new StackRemoteViewsFactory(this.getApplicationContext(), intent);
}
}
class StackRemoteViewsFactory implements RemoteViewsService.RemoteViewsFactory {
private static final int count = 10;
private List<WidgetItem> widgetItems = new ArrayList<WidgetItem>();
private Context context;
private int appWidgetId;
public StackRemoteViewsFactory(Context context, Intent intent) {
this.context = context;
appWidgetId = intent.getIntExtra(AppWidgetManager.EXTRA_APPWIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
}
// Initialize the data set.
public void 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.
for (int i = 0; i < count; i++) {
widgetItems.add(new WidgetItem(i + "!"));
}
...
}
// Given the position (index) of a WidgetItem in the array, use the
// item's text value in combination with the widget item XML file to
// construct a RemoteViews object.
public RemoteViews getViewAt(int position) {
// Position always ranges from 0 to getCount() - 1.
// Construct a RemoteViews item based on the widget item XML
// file and set the text based on the position.
RemoteViews rv = new RemoteViews(context.getPackageName(), R.layout.widget_item);
rv.setTextViewText(R.id.widget_item, widgetItems.get(position).text);
// Set a fill-intent to fill in the pending
// intent template that is set on the collection view in
// StackWidgetProvider.
Bundle extras = new Bundle();
extras.putInt(StackWidgetProvider.EXTRA_ITEM, position);
Intent fillInIntent = new Intent();
fillInIntent.putExtras(extras);
// Make it possible to distinguish the individual on-click
// action of a given item.
rv.setOnClickFillInIntent(R.id.widget_item, fillInIntent);
// Return the RemoteViews object.
return rv;
}
...
}
Sammlungsdaten aktuell halten
Abbildung 2 zeigt den Aktualisierungsfluss in einem Widget, das Sammlungen verwendet. Er zeigt
wie der Widgetcode mit RemoteViewsFactory interagiert
Updates auslösen:
RemoteViewsFactory während Updates.Widgets, die Sammlungen verwenden, können Nutzern aktuelle Inhalte liefern. Für
Beispiel: Das Gmail-Widget zeigt Nutzern einen Überblick über ihren Posteingang. Damit
lösen Sie nach Möglichkeit die Ansicht RemoteViewsFactory und die Sammlungsansicht aus,
neue Daten anzuzeigen.
Verwenden Sie dazu die Methode
AppWidgetManager zum Anrufen
notifyAppWidgetViewDataChanged() Dieser Aufruf führt zu einem Callback des RemoteViewsFactory-Objekts.
onDataSetChanged()
, mit der Sie neue Daten abrufen können.
Verarbeitungsintensive Vorgänge lassen sich synchron im
onDataSetChanged()-Callback. Dieser Anruf wird garantiert beendet
bevor die Metadaten- oder Ansichtsdaten aus dem RemoteViewsFactory abgerufen werden. Ich
können auch verarbeitungsintensive Vorgänge innerhalb der getViewAt() ausführen
. Dauert dieser Aufruf lange, wird die durch den
RemoteViewsFactory-Objekt
getLoadingView()
Methode: wird an der entsprechenden Position der Sammlungsansicht angezeigt.
bis sie zurückkehrt.
Mit RemoteCollectionItems eine Sammlung direkt übergeben
Unter Android 12 (API-Level 31) wird die setRemoteAdapter(int viewId,
RemoteViews.RemoteCollectionItems
items) hinzugefügt.
, mit der Ihre App eine Sammlung direkt übergeben kann, wenn ein Nutzer
Sammlungsansicht. Wenn Sie Ihren Adapter mit dieser Methode einrichten, müssen Sie
implementieren Sie eine RemoteViewsFactory und Sie müssen nicht
notifyAppWidgetViewDataChanged().
Dieser Ansatz erleichtert nicht nur das
Befüllen des Adapters,
verringert sich die Latenz für das Befüllen neuer Elemente,
wenn Nutzer in der Liste nach unten scrollen,
um ein neues Element aufzudecken. Diese Methode zum Einstellen des Adapters wird bevorzugt, wenn
dass Ihre Sammlung relativ klein ist. Dies ist zum Beispiel der Fall,
Dieser Ansatz funktioniert nicht gut, wenn Ihre Sammlung zahlreiche Bitmaps enthält, die
an setImageViewBitmap übergeben.
Wenn die Sammlung keinen festen Satz von Layouts verwendet, d. h., wenn einige
Elemente sind nur manchmal vorhanden – verwenden Sie setViewTypeCount, um das
Maximale Anzahl eindeutiger Layouts, die die Sammlung enthalten kann. Dadurch kann das
Adapter bei Updates Ihres App-Widgets wiederverwendet.
Hier ein Beispiel für die Implementierung von vereinfachten RemoteViews-Sammlungen.
Kotlin
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()
)
Java
List<Integer> itemLayouts = Arrays.asList(
R.layout.item_type_1,
R.layout.item_type_2,
...
);
remoteView.setRemoteAdapter(
R.id.list_view,
new RemoteViews.RemoteCollectionItems.Builder()
.addItem(/* id= */ ID_1, new RemoteViews(context.getPackageName(), R.layout.item_type_1))
.addItem(/* id= */ ID_2, new RemoteViews(context.getPackageName(), R.layout.item_type_2))
...
.setViewTypeCount(itemLayouts.size())
.build()
);