Questa pagina mostra come aggiungere un elemento QuickContactBadge
alla UI
e come associare i dati. QuickContactBadge
è un widget che inizialmente viene visualizzato come immagine in miniatura. Anche se puoi utilizzare qualsiasi Bitmap
per l'immagine in miniatura, in genere utilizzi un Bitmap
decodificato dall'immagine in miniatura
della foto del contatto.
L'immagine piccola funge da controllo; quando gli utenti la toccano, QuickContactBadge
si espande in una finestra di dialogo contenente quanto segue:
- Un'immagine grande
- L'immagine di grandi dimensioni associata al contatto o, se non è disponibile alcuna immagine, un'immagine segnaposto.
- Icone delle app
- Un'icona dell'app per ogni dato dettagliato che può essere gestito da un'app integrata. Ad esempio, se i dettagli del contatto includono uno o più indirizzi email, viene visualizzata un'icona email. Quando gli utenti toccano l'icona, vengono visualizzati tutti gli indirizzi email del contatto. Quando gli utenti toccano uno degli indirizzi, l'app email mostra una schermata per la scrittura di un messaggio all'indirizzo email selezionato.
La visualizzazione QuickContactBadge
fornisce accesso immediato ai dettagli
di un contatto e offre un modo rapido per comunicare con il contatto. Gli utenti non devono cercare un contatto, trovare e copiare informazioni e incollarle nell'app appropriata. Possono invece toccare QuickContactBadge
, scegliere il metodo di comunicazione da utilizzare e inviare le informazioni relative a quel metodo direttamente all'app appropriata.
Aggiungi una visualizzazione QuickContactBadge
Per aggiungere un elemento QuickContactBadge
, inserisci un
elemento <QuickContactBadge>
nel layout, come mostrato nell'esempio seguente:
<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>
Recupera i dati del provider
Per visualizzare un contatto in QuickContactBadge
, sono necessari un URI dei contenuti
per il contatto e un Bitmap
per l'immagine piccola. Puoi generare
sia l'URI dei contenuti sia il valore Bitmap
dalle colonne recuperate dal
provider di contatti. Specifica queste colonne come parte della proiezione che utilizzi per caricare i dati in Cursor
.
Per Android 3.0 (livello API 11) e versioni successive, includi le seguenti colonne nella proiezione:
Per Android 2.3.3 (livello API 10) e versioni precedenti, utilizza le seguenti colonne:
Gli esempi in questa pagina presuppongono che sia stato caricato un elemento
Cursor
che contiene queste colonne e qualsiasi altra
colonna selezionata. Per informazioni su come recuperare le colonne in un elemento Cursor
, consulta
Recuperare un elenco di contatti.
Imposta l'URI e la miniatura del contatto
Una volta che hai a disposizione le colonne necessarie, puoi associare i dati a
QuickContactBadge
.
Imposta l'URI del contatto
Per impostare l'URI dei contenuti per il contatto, chiama
getLookupUri(id,lookupKey)
per
ricevere un CONTENT_LOOKUP_URI
, quindi
chiama assignContactUri()
per impostare il
contatto. Questo è quanto mostrato nell'esempio seguente:
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);
Quando gli utenti toccano l'icona QuickContactBadge
, i dettagli del contatto vengono visualizzati nella finestra di dialogo.
Impostare la miniatura della foto
L'impostazione dell'URI del contatto per QuickContactBadge
non comporta il caricamento
automatico della foto in miniatura del contatto. Per caricare la foto, recupera un URI dalla riga Cursor
del contatto, utilizzalo per aprire il file contenente la miniatura compressa e leggi il file in un Bitmap
.
Nota: la colonna PHOTO_THUMBNAIL_URI
non è disponibile nelle versioni della piattaforma precedenti alla 3.0. Per queste versioni, devi recuperare l'URI dalla sottotabella Contacts.Photo
.
Innanzitutto, configura le variabili per accedere alle colonne Cursor
contenenti le colonne
Contacts._ID
e
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); ...
Definisci un metodo che acquisisca i dati relativi alle foto per il contatto e le dimensioni per la
visualizzazione della destinazione e restituisca la miniatura delle dimensioni corrette in un
Bitmap
. Inizia costruendo un URI che indirizzi alla
miniatura:
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; }
Chiama il metodo loadContactPhotoThumbnail()
nel codice per ottenere la
miniatura Bitmap
e utilizza il risultato per impostare la miniatura della foto nel
tuo 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);
Aggiungi un QuickContactBadge a una ListView
Un QuickContactBadge
è un'aggiunta utile a un ListView
che mostra un elenco di contatti. Usa QuickContactBadge
per visualizzare una miniatura per ogni contatto; quando gli utenti toccano la miniatura, viene visualizzata la finestra di dialogo QuickContactBadge
.
Aggiungere l'elemento QuickContactBadge
Per iniziare, aggiungi un elemento vista QuickContactBadge
al layout dell'elemento
Ad esempio, se vuoi visualizzare un QuickContactBadge
e un nome per ogni contatto recuperato, inserisci il seguente XML in un file di layout:
<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>
Nelle sezioni seguenti, questo file è denominato contact_item_layout.xml
.
Configurazione di un adattatore cursore personalizzato
Per associare un CursorAdapter
a un ListView
contenente un QuickContactBadge
, definisci un adattatore personalizzato che
estende CursorAdapter
. Questo approccio consente di elaborare i
dati nella sezione Cursor
prima di associarli a
QuickContactBadge
. Questo approccio consente anche di associare più
colonne Cursor
a QuickContactBadge
. Nessuna di queste operazioni è possibile in un CursorAdapter
normale.
La sottoclasse di CursorAdapter
che definisci deve eseguire l'override dei seguenti metodi:
CursorAdapter.newView()
-
Gonfia un nuovo oggetto
View
per contenere il layout dell'elemento. Nell'override di questo metodo, archivia gli handle negli oggettiView
secondari del layout, incluso quello secondarioQuickContactBadge
. Con questo approccio, eviterai di dover ottenere handle per gli oggettiView
secondari ogni volta che gonfi un nuovo layout.Devi eseguire l'override di questo metodo in modo da poter ottenere handle per i singoli oggetti
View
secondari. Questa tecnica consente di controllarne l'associazione inCursorAdapter.bindView()
. CursorAdapter.bindView()
-
Sposta i dati dalla riga
Cursor
corrente agli oggettiView
secondari del layout degli elementi. Devi eseguire l'override di questo metodo in modo da poter associare sia l'URI e la miniatura del contatto aQuickContactBadge
. L'implementazione predefinita consente solo una mappatura one-to-one tra una colonna e unView
.
Il seguente snippet di codice contiene un esempio di sottoclasse personalizzata di
CursorAdapter
:
Definisci l'adattatore dell'elenco personalizzato
Definisci la sottoclasse di
CursorAdapter
,
incluso il suo costruttore, e sostituisci
newView()
e
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); }
Impostazione delle variabili
Nel codice, configura le variabili tra cui una proiezione Cursor
che include le colonne necessarie, come mostrato nell'esempio seguente.
Nota: i seguenti snippet di codice utilizzano il metodo loadContactPhotoThumbnail()
, definito nella sezione Impostare l'URI e la miniatura del contatto.
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; ...
Configurazione di ListView
In Fragment.onCreate()
, crea un'istanza dell'adattatore cursore personalizzato e ottieni un handle per 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); } ... } ...
In onViewCreated()
, associa
ContactsAdapter
a 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); } ... } ...
Quando ricevi un Cursor
contenente i dati dei contatti, che in genere si trova in onLoadFinished()
, chiama il numero swapCursor()
per spostare i dati di Cursor
su ListView
. Viene visualizzato QuickContactBadge
per ogni voce nell'elenco dei contatti.
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); }
Quando associ un Cursor
a un ListView
con CursorAdapter
(o una sottoclasse) e utilizzi CursorLoader
per caricare Cursor
, devi sempre fare in modo che i riferimenti a Cursor
siano chiari nell'implementazione di onLoaderReset()
.
Questo è quanto mostrato nell'esempio seguente:
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); }