Diese Seite wurde von der Cloud Translation API übersetzt.

Schnellkontakt-Badge anzeigen

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:

Contacts._ID
Contacts.LOOKUP_KEY

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 untergeordneten View-Objekte des Layouts, einschließlich des untergeordneten QuickContactBadge. Auf diese Weise vermeiden Sie, dass Sie jedes Mal, wenn Sie ein neues Layout aufblasen, Handles an die untergeordneten View-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 in CursorAdapter.bindView() steuern.
CursorAdapter.bindView(): Verschiebt Daten aus der aktuellen Cursor-Zeile zu den untergeordneten View-Objekten des Elementlayouts. Sie müssen diese Methode überschreiben, damit Sie sowohl den URI des Kontakts als auch die Miniaturansicht an QuickContactBadge binden können. Die Standardimplementierung erlaubt nur eine 1:1-Zuordnung zwischen einer Spalte und einem View.

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

Zurück

Modifying contacts using intents