Cette page vous explique comment ajouter un QuickContactBadge à votre interface utilisateur et lui associer des données. Un QuickContactBadge est un widget qui apparaît initialement sous forme de vignette. Bien que vous puissiez utiliser n'importe quel Bitmap pour la vignette, vous utilisez généralement un Bitmap décodé à partir de la vignette photo du contact.
La petite image sert de commande. Lorsque l'utilisateur appuie dessus, l'QuickContactBadge se développe dans une boîte de dialogue contenant les éléments suivants:
- Une grande image
- Grande image associée au contact ou, si aucune image n'est disponible, un espace réservé graphique.
- Icônes d'application
- Une icône d'application pour chaque donnée détaillée pouvant être gérée par une application intégrée. Par exemple, si les coordonnées du contact incluent une ou plusieurs adresses e-mail, une icône d'e-mail s'affiche. Lorsque les utilisateurs appuient sur l'icône, toutes les adresses e-mail du contact s'affichent. Lorsque les utilisateurs appuient sur l'une des adresses, l'application de messagerie affiche un écran permettant de rédiger un message à l'adresse e-mail sélectionnée.
La vue QuickContactBadge permet d'accéder instantanément aux informations d'un contact et de communiquer rapidement avec lui. Les utilisateurs n'ont pas besoin de rechercher un contact, de rechercher et de copier des informations, puis de les coller dans l'application appropriée. À la place, ils peuvent appuyer sur le QuickContactBadge, choisir le mode de communication qu'ils souhaitent utiliser et envoyer ces informations directement à l'application appropriée.
Ajouter une vue QuickContactBadge
Pour ajouter un QuickContactBadge, insérez un élément <QuickContactBadge> dans votre mise en page, comme illustré dans l'exemple suivant:
<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>
Récupérer les données du fournisseur
Pour afficher un contact dans QuickContactBadge, vous avez besoin d'un URI de contenu pour le contact et d'un élément Bitmap pour la petite image. Vous générez à la fois l'URI de contenu et le Bitmap à partir des colonnes extraites du fournisseur de contacts. Spécifiez ces colonnes dans le cadre de la projection que vous utilisez pour charger des données dans votre Cursor.
Pour Android 3.0 (niveau d'API 11) ou version ultérieure, incluez les colonnes suivantes dans votre projection:
Pour Android 2.3.3 (niveau d'API 10) ou version antérieure, utilisez les colonnes suivantes:
Les exemples de cette page supposent qu'un objet Cursor contenant ces colonnes et toutes les autres colonnes sélectionnées a été chargé. Pour savoir comment récupérer les colonnes d'un Cursor, consultez Récupérer une liste de contacts.
Définir l'URI et la vignette du contact
Une fois que vous disposez des colonnes nécessaires, vous pouvez lier des données à QuickContactBadge.
Définir l'URI du contact
Pour définir l'URI de contenu du contact, appelez getLookupUri(id,lookupKey) pour obtenir un CONTENT_LOOKUP_URI, puis appelez assignContactUri() pour définir le contact. Ce processus est illustré dans l'exemple suivant :
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);
Lorsque les utilisateurs appuient sur l'icône QuickContactBadge, les coordonnées du contact s'affichent dans la boîte de dialogue.
Définir la vignette de la photo
La définition de l'URI de contact pour QuickContactBadge ne charge pas automatiquement la vignette du contact. Pour charger la photo, obtenez l'URI de la photo à partir de la ligne Cursor du contact, utilisez-le pour ouvrir le fichier contenant la vignette compressée, puis lisez le fichier dans un Bitmap.
Remarque:La colonne PHOTO_THUMBNAIL_URI n'est pas disponible dans les versions de plate-forme antérieures à la version 3.0. Pour ces versions, vous devez récupérer l'URI à partir du sous-tableau Contacts.Photo.
Commencez par configurer des variables pour accéder au Cursor contenant les colonnes Contacts._ID et Contacts.LOOKUP_KEY:
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);
...
Définissez une méthode qui récupère les données liées à la photo pour le contact et les dimensions pour la vue de destination, puis renvoie la vignette correctement dimensionnée dans un Bitmap. Commencez par créer un URI qui pointe vers la vignette:
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;
}
Appelez la méthode loadContactPhotoThumbnail() dans votre code pour obtenir la vignette Bitmap, puis utilisez le résultat pour définir la vignette de la photo dans votre QuickContactBadge:
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);
Ajouter un QuickContactBadge à un ListView
Un QuickContactBadge est un complément utile à un ListView qui affiche une liste de contacts. Utilisez QuickContactBadge pour afficher une vignette pour chaque contact. Lorsque les utilisateurs appuient sur la vignette, la boîte de dialogue QuickContactBadge s'affiche.
Ajouter l'élément QuickContactBadge
Pour commencer, ajoutez un élément de vue QuickContactBadge à la mise en page de votre élément. Par exemple, si vous souhaitez afficher une QuickContactBadge et un nom pour chaque contact que vous récupérez, placez le code XML suivant dans un fichier de mise en page:
<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>
Dans les sections suivantes, ce fichier est appelé contact_item_layout.xml.
Configurer un CursorAdapter personnalisé
Pour lier un CursorAdapter à un ListView contenant un QuickContactBadge, définissez un adaptateur personnalisé qui étend CursorAdapter. Cette approche vous permet de traiter les données dans le Cursor avant de les lier à QuickContactBadge. Cette approche vous permet également de lier plusieurs colonnes Cursor au QuickContactBadge. Aucune de ces opérations n'est possible dans une CursorAdapter standard.
La sous-classe de CursorAdapter que vous définissez doit remplacer les méthodes suivantes:
CursorAdapter.newView()- Gonfle un nouvel objet
Viewpour contenir la mise en page de l'élément. Dans le forçage de cette méthode, stockez les poignées sur les objetsViewenfants de la mise en page, y compris l'élémentQuickContactBadgeenfant. Cette approche vous évite d'avoir à accéder aux poignées des objetsViewenfants chaque fois que vous gonflez une nouvelle mise en page.Vous devez ignorer cette méthode afin de pouvoir obtenir des handle vers chaque objet
Viewenfant. Cette technique vous permet de contrôler leur liaison dansCursorAdapter.bindView(). CursorAdapter.bindView()- Déplace les données de la ligne
Cursoractuelle vers les objetsViewenfants de la mise en page de l'élément. Vous devez ignorer cette méthode afin de pouvoir lier l'URI et la vignette du contact àQuickContactBadge. L'implémentation par défaut ne permet qu'un mappage de type un à un entre une colonne et uneView.
L'extrait de code suivant contient un exemple de sous-classe personnalisée de CursorAdapter:
Définir l'adaptateur de liste personnalisée
Définissez la sous-classe de CursorAdapter, y compris son constructeur, puis remplacez newView() et 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);
}
Configurer des variables
Dans votre code, configurez des variables incluant une projection Cursor qui inclut les colonnes nécessaires, comme illustré dans l'exemple suivant.
Remarque:Les extraits de code suivants utilisent la méthode loadContactPhotoThumbnail(), qui est définie dans la section Définir l'URI et la vignette du contact.
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;
...
Configurer ListView
Dans Fragment.onCreate(), instanciez l'adaptateur de curseur personnalisé et obtenez un handle vers ListView:
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);
}
...
}
...
Dans onViewCreated(), liez ContactsAdapter à 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);
}
...
}
...
Lorsque vous recevez un Cursor contenant les données de contacts, généralement dans onLoadFinished(), appelez swapCursor() pour déplacer les données Cursor vers ListView. Le QuickContactBadge s'affiche pour chaque entrée de la liste de contacts.
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);
}
Lorsque vous liez un Cursor à un ListView avec un CursorAdapter (ou une sous-classe) et que vous utilisez un CursorLoader pour charger le Cursor, effacez toujours les références à Cursor dans votre implémentation de onLoaderReset().
Ce processus est illustré dans l'exemple suivant :
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);
}