Auf dieser Seite wird beschrieben, wie Sie Ihrer UI ein QuickContactBadge
-Objekt hinzufügen und Daten damit verknüpfen. Ein QuickContactBadge
ist ein Widget, das zuerst als Miniaturansicht angezeigt wird. Sie können ein beliebiges Bitmap
für die Miniaturansicht verwenden, verwenden aber normalerweise ein Bitmap
, das aus der Miniaturansicht des Kontakts decodiert wurde.
Das kleine Bild fungiert als Steuerelement. Wenn Nutzer auf das Bild tippen, wird das QuickContactBadge
zu einem Dialogfeld erweitert, das Folgendes enthält:
- Ein großes Bild
- Das große Bild für den Kontakt oder, wenn kein Bild verfügbar ist, eine Platzhaltergrafik.
- App-Symbole
- Ein App-Symbol für alle Detaildaten, die von einer integrierten Anwendung verarbeitet werden können. Wenn die Details des Kontakts beispielsweise eine oder mehrere E-Mail-Adressen enthalten, wird ein E-Mail-Symbol angezeigt. Wenn ein Nutzer auf das Symbol tippt, werden alle E-Mail-Adressen des Kontakts angezeigt. Wenn Nutzer auf eine der Adressen tippen, wird in der E-Mail-App ein Bildschirm angezeigt, in dem sie eine Nachricht an die ausgewählte E-Mail-Adresse verfassen können.
Die Ansicht QuickContactBadge
bietet sofortigen Zugriff auf die Details eines Kontakts und eine schnelle Möglichkeit, mit dem Kontakt zu kommunizieren. Nutzer müssen nicht erst nach einem Kontakt suchen, Informationen suchen, kopieren und dann in die entsprechende App einfügen. Stattdessen können sie auf QuickContactBadge
tippen, die gewünschte Kommunikationsmethode auswählen und die Informationen für diese Methode direkt an die entsprechende App senden.
QuickContactBadge-Ansicht hinzufügen
Um ein QuickContactBadge
hinzuzufügen, füge ein <QuickContactBadge>
-Element in dein Layout ein, wie im folgenden Beispiel gezeigt:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent"> ... <QuickContactBadge android:id=@+id/quickbadge android:layout_height="wrap_content" android:layout_width="wrap_content" android:scaleType="centerCrop"/> ... </RelativeLayout>
Anbieterdaten abrufen
Damit ein Kontakt im QuickContactBadge
angezeigt wird, benötigen Sie einen Inhalts-URI für den Kontakt und ein Bitmap
für das kleine Bild. Sie generieren sowohl den Inhalts-URI als auch den Bitmap
aus Spalten, die vom Contacts Provider abgerufen wurden. Geben Sie diese Spalten als Teil der Projektion an, mit der Sie Daten in die Cursor
laden.
Schließen Sie für Android 3.0 (API-Level 11) und höher die folgenden Spalten in Ihre Projektion ein:
Verwenden Sie für Android 2.3.3 (API-Level 10) und niedriger die folgenden Spalten:
Bei den Beispielen auf dieser Seite wird davon ausgegangen, dass ein Cursor
geladen wurde, der diese Spalten und andere ausgewählte Spalten enthält. Informationen zum Abrufen von Spalten in einem Cursor
finden Sie unter Liste mit Kontakten abrufen.
Kontakt-URI und Miniaturansicht festlegen
Sobald Sie die erforderlichen Spalten haben, können Sie Daten an die QuickContactBadge
binden.
Kontakt-URI festlegen
Wenn Sie den Inhalts-URI für den Kontakt festlegen möchten, rufen Sie getLookupUri(id,lookupKey)
auf, um ein CONTENT_LOOKUP_URI
zu erhalten. Rufen Sie dann assignContactUri()
auf, um den Kontakt festzulegen. Dies wird im folgenden Beispiel veranschaulicht:
Kotlin
// The Cursor that contains contact rows var cursor: Cursor? = null // The index of the _ID column in the Cursor var idColumn: Int = 0 // The index of the LOOKUP_KEY column in the Cursor var lookupKeyColumn: Int = 0 // A content URI for the desired contact var contactUri: Uri? = null // A handle to the QuickContactBadge view ... cursor?.let { cursor -> /* * Insert code here to move to the desired cursor row */ // Gets the _ID column index idColumn = cursor.getColumnIndex(ContactsContract.Contacts._ID) // Gets the LOOKUP_KEY index lookupKeyColumn = cursor.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY) // Gets a content URI for the contact contactUri = ContactsContract.Contacts.getLookupUri( cursor.getLong(idColumn), cursor.getString(lookupKeyColumn) ) binding.badge.assignContactUri(contactUri) }
Java
// The Cursor that contains contact rows Cursor cursor; // The index of the _ID column in the Cursor int idColumn; // The index of the LOOKUP_KEY column in the Cursor int lookupKeyColumn; // A content URI for the desired contact Uri contactUri; ... /* * Insert code here to move to the desired cursor row */ // Gets the _ID column index idColumn = cursor.getColumnIndex(ContactsContract.Contacts._ID); // Gets the LOOKUP_KEY index lookupKeyColumn = cursor.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY); // Gets a content URI for the contact contactUri = Contacts.getLookupUri( cursor.getLong(idColumn), cursor.getString(lookupKeyColumn) ); binding.badge.assignContactUri(contactUri);
Wenn Nutzer auf das Symbol QuickContactBadge
tippen, werden die Details des Kontakts im Dialogfeld angezeigt.
Miniaturansicht für Foto festlegen
Wenn Sie den Kontakt-URI für QuickContactBadge
festlegen, wird nicht automatisch die Miniaturansicht des Kontakts geladen. Um das Foto zu laden, rufen Sie einen URI für das Foto aus der Zeile Cursor
des Kontakts ab, öffnen Sie damit die Datei mit der komprimierten Miniaturansicht und lesen Sie die Datei in ein Bitmap
-Element ein.
Hinweis: Die Spalte PHOTO_THUMBNAIL_URI
ist in Plattformversionen vor 3.0 nicht verfügbar. Für diese Versionen müssen Sie den URI aus der untergeordneten Tabelle Contacts.Photo
abrufen.
Richten Sie zuerst Variablen für den Zugriff auf die Cursor
mit den Spalten Contacts._ID
und Contacts.LOOKUP_KEY
ein:
Kotlin
// The column in which to find the thumbnail ID var thumbnailColumn: Int = 0 /* * The thumbnail URI, expressed as a String. * Contacts Provider stores URIs as String values. */ var thumbnailUri: String? = null ... cursor?.let { cursor -> /* * Gets the photo thumbnail column index if * platform version >= Honeycomb */ thumbnailColumn = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { cursor.getColumnIndex(ContactsContract.Contacts.PHOTO_THUMBNAIL_URI) // Otherwise, sets the thumbnail column to the _ID column } else { idColumn } /* * Assuming the current Cursor position is the contact you want, * gets the thumbnail ID */ thumbnailUri = cursor.getString(thumbnailColumn) }
Java
// The column in which to find the thumbnail ID int thumbnailColumn; /* * The thumbnail URI, expressed as a String. * Contacts Provider stores URIs as String values. */ String thumbnailUri; ... /* * Gets the photo thumbnail column index if * platform version >= Honeycomb */ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { thumbnailColumn = cursor.getColumnIndex(ContactsContract.Contacts.PHOTO_THUMBNAIL_URI); // Otherwise, sets the thumbnail column to the _ID column } else { thumbnailColumn = idColumn; } /* * Assuming the current Cursor position is the contact you want, * gets the thumbnail ID */ thumbnailUri = cursor.getString(thumbnailColumn); ...
Definieren Sie eine Methode, die fotobezogene Daten für den Kontakt und Abmessungen für die Zielansicht aufnimmt und die Miniaturansicht der richtigen Größe in einem Bitmap
zurückgibt. Erstellen Sie zuerst einen URI, der auf die Miniaturansicht verweist:
Kotlin
/** * Load a contact photo thumbnail and return it as a Bitmap, * resizing the image to the provided image dimensions as needed. * @param photoData photo ID Prior to Honeycomb, the contact's _ID value. * For Honeycomb and later, the value of PHOTO_THUMBNAIL_URI. * @return A thumbnail Bitmap, sized to the provided width and height. * Returns null if the thumbnail is not found. */ private fun loadContactPhotoThumbnail(photoData: String): Bitmap? { // Creates an asset file descriptor for the thumbnail file var afd: AssetFileDescriptor? = null // try-catch block for file not found try { // Creates a holder for the URI val thumbUri: Uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { // If Android 3.0 or later, // sets the URI from the incoming PHOTO_THUMBNAIL_URI Uri.parse(photoData) } else { // Prior to Android 3.0, constructs a photo Uri using _ID /* * Creates a contact URI from the Contacts content URI * incoming photoData (_ID) */ val contactUri: Uri = Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_URI, photoData) /* * Creates a photo URI by appending the content URI of * Contacts.Photo */ Uri.withAppendedPath(contactUri, ContactsContract.Contacts.Photo.CONTENT_DIRECTORY) } /* * Retrieves an AssetFileDescriptor object for the thumbnail URI * using ContentResolver.openAssetFileDescriptor */ afd = activity?.contentResolver?.openAssetFileDescriptor(thumbUri, "r") /* * Gets a file descriptor from the asset file descriptor. * This object can be used across processes. */ return afd?.fileDescriptor?.let {fileDescriptor -> // Decodes the photo file and returns the result as a Bitmap // if the file descriptor is valid BitmapFactory.decodeFileDescriptor(fileDescriptor, null, null) } } catch (e: FileNotFoundException) { /* * Handle file not found errors */ null } finally { // In all cases, close the asset file descriptor try { afd?.close() } catch (e: IOException) { } } }
Java
/** * Load a contact photo thumbnail and return it as a Bitmap, * resizing the image to the provided image dimensions as needed. * @param photoData photo ID Prior to Honeycomb, the contact's _ID value. * For Honeycomb and later, the value of PHOTO_THUMBNAIL_URI. * @return A thumbnail Bitmap, sized to the provided width and height. * Returns null if the thumbnail is not found. */ private Bitmap loadContactPhotoThumbnail(String photoData) { // Creates an asset file descriptor for the thumbnail file AssetFileDescriptor afd = null; // try-catch block for file not found try { // Creates a holder for the URI Uri thumbUri; // If Android 3.0 or later if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { // Sets the URI from the incoming PHOTO_THUMBNAIL_URI thumbUri = Uri.parse(photoData); } else { // Prior to Android 3.0, constructs a photo Uri using _ID /* * Creates a contact URI from the Contacts content URI * incoming photoData (_ID) */ final Uri contactUri = Uri.withAppendedPath( ContactsContract.Contacts.CONTENT_URI, photoData); /* * Creates a photo URI by appending the content URI of * Contacts.Photo */ thumbUri = Uri.withAppendedPath( contactUri, ContactsContract.Contacts.Photo.CONTENT_DIRECTORY); } /* * Retrieves an AssetFileDescriptor object for the thumbnail URI * using ContentResolver.openAssetFileDescriptor */ afd = getActivity().getContentResolver(). openAssetFileDescriptor(thumbUri, "r"); /* * Gets a file descriptor from the asset file descriptor. * This object can be used across processes. */ FileDescriptor fileDescriptor = afd.getFileDescriptor(); // Decodes the photo file and returns the result as a Bitmap // if the file descriptor is valid if (fileDescriptor != null) { // Decodes the bitmap return BitmapFactory.decodeFileDescriptor( fileDescriptor, null, null); } // If the file isn't found } catch (FileNotFoundException e) { /* * Handle file not found errors */ // In all cases, close the asset file descriptor } finally { if (afd != null) { try { afd.close(); } catch (IOException e) {} } } return null; }
Rufen Sie die Methode loadContactPhotoThumbnail()
in Ihrem Code auf, um die Miniaturansicht Bitmap
zu erhalten, und verwenden Sie das Ergebnis, um die Miniaturansicht des Fotos in Ihrem QuickContactBadge
festzulegen:
Kotlin
... /* * Decodes the thumbnail file to a Bitmap */ mThumbnailUri?.also { thumbnailUri -> loadContactPhotoThumbnail(thumbnailUri).also { thumbnail -> /* * Sets the image in the QuickContactBadge. * QuickContactBadge inherits from ImageView. */ badge.setImageBitmap(thumbnail) } }
Java
... /* * Decodes the thumbnail file to a Bitmap */ Bitmap mThumbnail = loadContactPhotoThumbnail(thumbnailUri); /* * Sets the image in the QuickContactBadge. * QuickContactBadge inherits from ImageView. */ badge.setImageBitmap(mThumbnail);
QuickContactBadge zu einer Listenansicht hinzufügen
Ein QuickContactBadge
ist eine nützliche Ergänzung zu einer ListView
, die eine Liste von Kontakten anzeigt. Mit QuickContactBadge
kannst du für jeden Kontakt eine Miniaturansicht anzeigen lassen. Wenn Nutzer auf die Miniaturansicht tippen, wird das Dialogfeld QuickContactBadge
angezeigt.
QuickContactBadge-Element hinzufügen
Fügen Sie Ihrem Elementlayout zuerst ein QuickContactBadge
-Ansichtselement hinzu. Wenn Sie beispielsweise für jeden abgerufenen Kontakt ein QuickContactBadge
und einen Namen anzeigen möchten, fügen Sie den folgenden XML-Code in eine Layoutdatei ein:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="wrap_content"> <QuickContactBadge android:id="@+id/quickcontact" android:layout_height="wrap_content" android:layout_width="wrap_content" android:scaleType="centerCrop"/> <TextView android:id="@+id/displayname" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_toRightOf="@+id/quickcontact" android:gravity="center_vertical" android:layout_alignParentRight="true" android:layout_alignParentTop="true"/> </RelativeLayout>
In den folgenden Abschnitten wird diese Datei als contact_item_layout.xml
bezeichnet.
Benutzerdefinierten CursorAdapter einrichten
Definieren Sie einen benutzerdefinierten Adapter, der CursorAdapter
erweitert, um einen CursorAdapter
an eine ListView
zu binden, die eine QuickContactBadge
enthält. Mit diesem Ansatz können Sie die Daten in der Cursor
verarbeiten, bevor Sie sie an die QuickContactBadge
binden. Mit diesem Ansatz können Sie auch mehrere Cursor
-Spalten an die QuickContactBadge
binden. Keiner dieser Vorgänge ist in einer regulären CursorAdapter
möglich.
Die von Ihnen definierte abgeleitete Klasse von CursorAdapter
muss die folgenden Methoden überschreiben:
CursorAdapter.newView()
-
Gruppiert ein neues
View
-Objekt auf, das das Artikellayout enthält. Speichern Sie bei der Überschreibung dieser Methode Ziehpunkte für die untergeordnetenView
-Objekte des Layouts, einschließlich des untergeordnetenQuickContactBadge
. Auf diese Weise vermeiden Sie, dass Sie jedes Mal, wenn Sie ein neues Layout aufblasen, Handles an die untergeordnetenView
-Objekte benötigen.Sie müssen diese Methode überschreiben, damit Sie Handles für die einzelnen untergeordneten
View
-Objekte erhalten können. Mit diesem Verfahren können Sie deren Bindung inCursorAdapter.bindView()
steuern. CursorAdapter.bindView()
-
Verschiebt Daten aus der aktuellen
Cursor
-Zeile zu den untergeordnetenView
-Objekten des Elementlayouts. Sie müssen diese Methode überschreiben, damit Sie sowohl den URI des Kontakts als auch die Miniaturansicht anQuickContactBadge
binden können. Die Standardimplementierung erlaubt nur eine 1:1-Zuordnung zwischen einer Spalte und einemView
.
Das folgende Code-Snippet enthält ein Beispiel für eine benutzerdefinierte abgeleitete Klasse von CursorAdapter
:
Adapter für benutzerdefinierte Liste definieren
Definieren Sie die abgeleitete Klasse von CursorAdapter
einschließlich ihres Konstruktors und überschreiben Sie newView()
und bindView()
:
Kotlin
/** * Defines a class that holds resource IDs of each item layout * row to prevent having to look them up each time data is * bound to a row */ private data class ViewHolder( internal var displayname: TextView? = null, internal var quickcontact: QuickContactBadge? = null ) /** * * */ private inner class ContactsAdapter( context: Context, val inflater: LayoutInflater = LayoutInflater.from(context) ) : CursorAdapter(context, null, 0) { ... override fun newView( context: Context, cursor: Cursor, viewGroup: ViewGroup ): View { /* Inflates the item layout. Stores view references * in a ViewHolder class to prevent having to look * them up each time bindView() is called. */ return ContactListLayoutBinding.inflate(inflater, viewGroup, false).also { binding -> view.tag = ViewHolder().apply { displayname = binding.displayname quickcontact = binding.quickcontact } }.root } ... override fun bindView(view: View?, context: Context?, cursor: Cursor?) { (view?.tag as? ViewHolder)?.also { holder -> cursor?.apply { ... // Sets the display name in the layout holder.displayname?.text = getString(displayNameIndex) ... /* * Generates a contact URI for the QuickContactBadge */ ContactsContract.Contacts.getLookupUri( getLong(idIndex), cursor.getString(lookupKeyIndex) ).also { contactUri -> holder.quickcontact?.assignContactUri(contactUri) } getString(photoDataIndex)?.also {photoData -> /* * Decodes the thumbnail file to a Bitmap. * The method loadContactPhotoThumbnail() is defined * in the section "Set the contact URI and thumbnail." */ loadContactPhotoThumbnail(photoData)?.also { thumbnailBitmap -> /* * Sets the image in the QuickContactBadge. * QuickContactBadge inherits from ImageView. */ holder.quickcontact?.setImageBitmap(thumbnailBitmap) } } } } } }
Java
private class ContactsAdapter extends CursorAdapter { private LayoutInflater inflater; ... public ContactsAdapter(Context context) { super(context, null, 0); /* * Gets an inflater that can instantiate * the ListView layout from the file */ inflater = LayoutInflater.from(context); ... } ... /** * Defines a class that holds resource IDs of each item layout * row to prevent having to look them up each time data is * bound to a row */ private class ViewHolder { TextView displayname; QuickContactBadge quickcontact; } ... @Override public View newView( Context context, Cursor cursor, ViewGroup viewGroup) { /* Inflates the item layout. Stores view references * in a ViewHolder class to prevent having to look * them up each time bindView() is called. */ final ContactListLayoutBinding binding = ContactListLayoutBinding.inflate(inflater, viewGroup, false); final ViewHolder holder = new ViewHolder(); holder.displayname = binding.displayName; holder.quickcontact = binding.quickContact; view.setTag(holder); return binding.root; } ... @Override public void bindView( View view, Context context, Cursor cursor) { final ViewHolder holder = (ViewHolder) view.getTag(); final String photoData = cursor.getString(photoDataIndex); final String displayName = cursor.getString(displayNameIndex); ... // Sets the display name in the layout holder.displayname = cursor.getString(displayNameIndex); ... /* * Generates a contact URI for the QuickContactBadge */ final Uri contactUri = Contacts.getLookupUri( cursor.getLong(idIndex), cursor.getString(lookupKeyIndex)); holder.quickcontact.assignContactUri(contactUri); String photoData = cursor.getString(photoDataIndex); /* * Decodes the thumbnail file to a Bitmap. * The method loadContactPhotoThumbnail() is defined * in the section "Set the contact URI and thumbnail." */ Bitmap thumbnailBitmap = loadContactPhotoThumbnail(photoData); /* * Sets the image in the QuickContactBadge. * QuickContactBadge inherits from ImageView. */ holder.quickcontact.setImageBitmap(thumbnailBitmap); }
Variablen einrichten
Richten Sie in Ihrem Code Variablen ein, einschließlich einer Cursor
-Projektion, die die erforderlichen Spalten enthält, wie im folgenden Beispiel gezeigt.
Hinweis:In den folgenden Code-Snippets wird die Methode loadContactPhotoThumbnail()
verwendet, die im Abschnitt Kontakt-URI und Miniaturansicht festlegen definiert ist.
Kotlin
/* * Defines a projection based on platform version. This ensures * that you retrieve the correct columns. */ private val PROJECTION: Array<out String> = arrayOf( ContactsContract.Contacts._ID, ContactsContract.Contacts.LOOKUP_KEY, if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { ContactsContract.Contacts.DISPLAY_NAME_PRIMARY } else { ContactsContract.Contacts.DISPLAY_NAME }, if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { ContactsContract.Contacts.PHOTO_FILE_ID } else { /* * Although it's not necessary to include the * column twice, this keeps the number of * columns the same regardless of version */ ContactsContract.Contacts._ID } ) ... class ContactsFragment : Fragment(), LoaderManager.LoaderCallbacks<Cursor> { ... // Defines a ListView private val listView: ListView? = null // Defines a ContactsAdapter private val adapter: ContactsAdapter? = null ... // Defines a Cursor to contain the retrieved data private val cursor: Cursor? = null /* * As a shortcut, defines constants for the * column indexes in the Cursor. The index is * 0-based and always matches the column order * in the projection. */ // Column index of the _ID column private val idIndex = 0 // Column index of the LOOKUP_KEY column private val lookupKeyIndex = 1 // Column index of the display name column private val displayNameIndex = 3 /* * Column index of the photo data column. * It's PHOTO_THUMBNAIL_URI for Honeycomb and later, * and _ID for previous versions. */ private val photoDataIndex: Int = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) 3 else 0 ...
Java
public class ContactsFragment extends Fragment implements LoaderManager.LoaderCallbacks<Cursor> { ... // Defines a ListView private ListView listView; // Defines a ContactsAdapter private ContactsAdapter adapter; ... // Defines a Cursor to contain the retrieved data private Cursor cursor; /* * Defines a projection based on platform version. This ensures * that you retrieve the correct columns. */ private static final String[] PROJECTION = { ContactsContract.Contacts._ID, ContactsContract.Contacts.LOOKUP_KEY, (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) ? ContactsContract.Contacts.DISPLAY_NAME_PRIMARY : ContactsContract.Contacts.DISPLAY_NAME (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) ? ContactsContract.Contacts.PHOTO_FILE_ID : /* * Although it's not necessary to include the * column twice, this keeps the number of * columns the same regardless of version */ ContactsContract.Contacts._ID }; /* * As a shortcut, defines constants for the * column indexes in the Cursor. The index is * 0-based and always matches the column order * in the projection. */ // Column index of the _ID column private int idIndex = 0; // Column index of the LOOKUP_KEY column private int lookupKeyIndex = 1; // Column index of the display name column private int displayNameIndex = 3; /* * Column index of the photo data column. * It's PHOTO_THUMBNAIL_URI for Honeycomb and later, * and _ID for previous versions. */ private int photoDataIndex = Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB ? 3 : 0; ...
ListView einrichten
Instanziieren Sie in Fragment.onCreate()
den benutzerdefinierten Cursoradapter und rufen Sie einen Handle für ListView
ab:
Kotlin
override fun onCreateView( inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle? ): View? { return FragmentListViewBinding.inflate(...).let { binding -> ... /* * Gets a handle to the ListView in the file * contact_list_layout.xml */ listView = binding.contactList mAdapter?.also { listView?.adapter = it } ... }.root } ...
Java
@Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { FragmentListViewBinding binding = FragmentListViewBinding.inflate(...) ... /* * Gets a handle to the ListView in the file * contact_list_layout.xml */ if (binding.contactListView != null && adapter != null) { binding.contactListView.setAdapter(adapter); } ... } ...
Binden Sie in onViewCreated()
den ContactsAdapter
an den ListView
:
Kotlin
override fun onViewCreated(view: View, savedInstanceState: Bundle?) { super.onViewCreated(view, savedInstanceState) /* * Instantiates the subclass of * CursorAdapter */ mAdapter = activity?.let { ContactsAdapter(it).also { adapter -> // Sets up the adapter for the ListView listView?.adapter = adapter } } }
Java
@Override public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) { ... /* * Instantiates the subclass of * CursorAdapter */ mAdapter = new ContactsAdapter(getActivity()); // Sets up the adapter for the ListView if (listView != null && mAdapter != null) { listView.setAdapter(mAdapter); } ... } ...
Wenn du eine Cursor
mit den Kontaktdaten zurückgibst, normalerweise in onLoadFinished()
, rufst du swapCursor()
auf, um die Cursor
-Daten in die ListView
zu verschieben. Dadurch wird der QuickContactBadge
für jeden Eintrag in der Kontaktliste angezeigt.
Kotlin
override fun onLoadFinished(loader: Loader<Cursor>, cursor: Cursor) { // When the loader has completed, swap the cursor into the adapter mAdapter?.swapCursor(cursor) }
Java
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) { // When the loader has completed, swap the cursor into the adapter mAdapter.swapCursor(cursor); }
Wenn Sie einen Cursor
an einen ListView
mit einer CursorAdapter
(oder Unterklasse) binden und einen CursorLoader
zum Laden des Cursor
verwenden, sollten Sie in Ihrer Implementierung von onLoaderReset()
immer eindeutige Verweise auf die Cursor
verwenden.
Dies wird im folgenden Beispiel veranschaulicht:
Kotlin
override fun onLoaderReset(loader: Loader<Cursor>) { // Removes remaining reference to the previous Cursor adapter?.swapCursor(null) }
Java
@Override public void onLoaderReset(Loader<Cursor> loader) { // Removes remaining reference to the previous Cursor adapter.swapCursor(null); }