In un precedente articolo su questo sito, a cui rimando per una doverosa lettura preliminare, abbiamo visto come Android struttura i dati dei nostri contatti internamente al suo database. In questo articolo, vedremo come interagire con questi dati e come effettuare ricerche, inserimenti o modifiche sui contatti.

 Estrazione di tutti i contatti che hanno un numero telefonico

Per effettuare questa estrazione ci serviremo della classe ContactsContract.CommonDataKinds.Phone. Gli esempi di codice riportati di seguito, sono stati inseriti in una fìunzione custom all' interno di una Activity. Vediamo come estrarre tutti i telefonici in questo esempio di codice.

 
String Telefono = "";
 String Nome = "";
 long Id = 0;
 long RawContactId = 0;
//Tabella di tutti i record data telefonici presenti in rubrica
Uri uriTelefono = ContactsContract.CommonDataKinds.Phone.CONTENT_URI;
String[] colonneTelefono = new String[] {
ContactsContract.CommonDataKinds.Phone._ID,
 ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME,
 ContactsContract.CommonDataKinds.Phone.NUMBER,
 ContactsContract.CommonDataKinds.Phone.RAW_CONTACT_ID
 };

In questo primo spezzone di codice, stabiliamo quali sono le colonne da estrarre dalla tabella Phone (che poi sarebbe la tabella generica Data i cui record sono però solo con mimetype di tipo telefonico). Infatti stiamo utilizzando la classe Phone (uriTelefono) pertanto, comer appena detto, verranno estratti tutti i record "data" caraterizzati con mimetype "vnd.android.cursor.item/phone_v2" che contengono quindi il numero telefonico.Tale classe,  per default estrae tutti i record data con mimetype "phone_v2" e viene quindi utilizzata esclusivamente per la manipolazione dei record data di tipo telefonico.

 
//ordina i record Phone per nome 
 String sortOrder = ContactsContract.Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC";
//esegue la query di estrazione , Cursortelefoni conterrà tutti i record di tipo Phone
 Cursor Cursortelefoni = getContentResolver().query(uriTelefono, colonneTelefono, null, null, sortOrder);

In questo secondo spezzone di codice , decidiamo di ordinare i record alfabeticamente per nome e poi lanciamo la query. Ora, non rimane che leggere i record data presenti su Cursortelefoni. 

 
 Cursortelefoni.moveToFirst();//mi sposto sul primo record, per sicurezza...
do {
 Telefono = Cursortelefoni.getString(Cursortelefoni.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
 Nome = Cursortelefoni.getString(Cursortelefoni.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
 Id = Cursortelefoni.getLong(Cursortelefoni.getColumnIndex(ContactsContract.CommonDataKinds.Phone._ID));
 RawContactId = Cursortelefoni.getLong(Cursortelefoni.getColumnIndex(ContactsContract.CommonDataKinds.Phone.RAW_CONTACT_ID));
}while (Cursortelefoni.moveToNext());

Ad ogni ripetizione del ciclo <do while> vengono letti i 4 valori ed assegnati alle ripsettive 4 variabili. Esistono varie tipologie di classi per interagire con record data specifici.Per esempio la classe Photo per ecuperare/filtrare i contatti che possiedono una foto, la classe Email per recuperare/filtrare i contatti che possiedono un account email, etc.

Inserimento di un record data custum.

Supponiamo che la nostra applicazione abbia la necessita di caratterizzare un contatto telefonico. Un buon metodo per ottenere ciò e aggiungere un record data con un nostro mimetype. Ciò, infatti, non comporta il dover modificare un record data già presente (si potrebbe fare , visto la presenza dei campi dataXX di cui , la maggior parte, non sono utilizzati ma,  forse, e meglio lasciar stare i record data nativi Android già presenti). Vediamo quindi come fare per aggiugere un record data custom per un determinato contatto.

 
//qui sotto abbiamo creato il nostro item Android mimetype , che poi non è altro che una stringa!
final String MIMETYPE_DILLOFACILE = "vnd.android.cursor.item/dillofacile";
ArrayList<ContentProviderOperation> ops =
new ArrayList<ContentProviderOperation>();
ops.add(ContentProviderOperation.newInsert(Data.CONTENT_URI)
 .withValue(Data.RAW_CONTACT_ID, rawContactId)
 .withValue(Data.MIMETYPE, MIMETYPE_DILLOFACILE)
.withValue(DATA1, Telefono)
 .withValue(DATA2, Nome)
.withValue(DATA3, "MIO DATO")
 .build());
 try {
 ContentProviderResult[] cpr = getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
 } catch (RemoteException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 } catch (OperationApplicationException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }

Come possiamo vedere dal codice riportato quì sopra , creiamo una stringa MIMETYPE_DILLOFACILE che caratterizzerà il record data che ci accingiamo ad inserire , com mimetype "vnd.android.cursor.item/dillofacile", che è il nostro nuovo mimetype.

Tale record che andremo ad inserire, avrà un RAW_CONTACT_ID uguale alla variabile rawContactId. Questa viariabile dovrà quindi contenere il raw contact id univoco del nostro contatto, a cui vogliamo aggiungere un record data custom (caratterizzato quindi con il nostro nuovo mimetype). Inseriamo anche su DATA1 e DATA2 , come esempio, rispettivamente il numero telefonico e il nome del contatto e su DATA3 il valore custom vero e proprio che vogliamo caratterizzi il nostro nuovo record data. 

Dopo questo inserimento, pertanto, il nostro contatto (tabella raw_contatc tramite il sui _id e quindi relativo raw_contac_id nella tabella data) punterà a vari record data tipicamente presenti (e cioè quelli con mimetype nativi android come "vnd.android.cursor.item/phone_v2" , "vnd.android.cursor.item/email_v2" , etc.) ma anche al nostro nuovo record data con mimetype "vnd.android.cursor.item/dillofacile".

Ecco quindi che siamo riusciti a caratterizzare il nostro contatto inserendo un record data con un mimetype custom. Ora è chiaro che, in ogni momento, possiamo verificare se, per quel determinato contatto, è presente la caratterizzazione che abbiamo deciso di utilizzare nella nostra applicazione.

Verifichiamo la presenza di un record data custom.

Analogamente a quanto già riportato per l' estrazione di tutti i record data di tipo telefonico, possiamo scrivere il seguente codice che ci permette di verificare se, per un determinato Telefono e Nome, esiste l' unico record data con mimetype MIMETYPE_DILLOFACILE da noi inserito precedentemente. A seguire il codice.

 
//qui sotto abbiamo creato il nostro mimetype , che poi non è altro che una stringa!
final String MIMETYPE_DILLOFACILE = "vnd.android.cursor.item/dillofacile";
Uri uri = Data.CONTENT_URI;//tabella data
final String[] colonne = new String[] {Data.MIMETYPE,Data.DATA1,Data.DATA2,Data.DATA3,Data._ID,Data.RAW_CONTACT_ID};
String where = Data.MIMETYPE + "=? AND " +Data.DATA1 + "=? AND " + Data.DATA2 + "=?";
 String [] whereParam = whereParam = new String[] {MIMETYPE_DILLOFACILE, Telefono,Nome};
//esegue la query di estrazione , CursorRecordData conterrà tutti i record di tipo Data e 
 //mimetype MIMETYPE_DILLOFACILE estratti in base a where e whereParam.
 Cursor CursorRecordData = getContentResolver().query(uri, colonne, where, whereParam, null);
if (CursorRecordData.getCount()==0)
 return false;
CursorRecordData.moveToFirst();
String NumeroTelefono = String.valueOf(CursorRecordData.getString(CursorRecordData.getColumnIndex(Data.DATA1)));
String NomeContatto = String.valueOf(CursorRecordData.getString(CursorRecordData.getColumnIndex(Data.DATA2)));
String CustomData = String.valueOf(CursorRecordData.getString(CursorRecordData.getColumnIndex(Data.DATA3)));
long id = Long.valueOf(CursorRecordData.getString(CursorRecordData.getColumnIndex(Data._ID)));
long raw_id = Long.valueOf(CursorRecordData.getString(CursorRecordData.getColumnIndex(Data.RAW_CONTACT_ID)));
return true;

Come si può notare, la query di ricerca  viene effettuata sulla tabella "data" (Uri uri = Data.CONTENT_URI) la quale, e bene ricordarlo ancora, contiene svariate tipologie di record (mimetype) e di questa tabella ne verifica i campi Data.MIMETYPE , Data.DATA1 e Data.DATA2 per l' estrazione dell' eventuale unico recorda data con nostro mimetype MIMETYPE_DILLOFACILE presente.

Rimozione di un record data custum.

Se vogliamo rimuovere il nostro record data, possiamo utilizzare il seguente codice.

 
//qui sotto abbiamo creato il nostro mimetype , che poi non è altro che una stringa!
final String MIMETYPE_DILLOFACILE = "vnd.android.cursor.item/dillofacile";
ArrayList<ContentProviderOperation> ops =
new ArrayList<ContentProviderOperation>();
String[] selectionArgs = {Telefono,MIMETYPE_DILLOFACILE,Nome};
ops.add(ContentProviderOperation.newDelete(Data.CONTENT_URI)
 .withSelection(Data.DATA1+"=? AND "+Data.MIMETYPE+"=? AND "+Data.DATA2+"=?", selectionArgs)
 .build());
 try {
 ContentProviderResult[] cpr = getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
 } catch (RemoteException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 } catch (OperationApplicationException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }
 return true;
 }
 

Come si può notare , gli sempi si assomigliano un pò tutti. Da notare anche che, sia in questo esempio di rimozione che nell' esempio precedente di estrazione del record data di un determinato contatto, potevamo anche solo utilizzare il "raw contact id" del contatto e ovviamente, il mimetype custom da noi creato.

 Vediamo un altro esempio.

Estrazione delle email presenti nei contatti 

 
Cursor emailCur = cr.query( 
		ContactsContract.CommonDataKinds.Email.CONTENT_URI, 
		null,
		ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = ?", 
		new String[]{id}, null); 
	while (emailCur.moveToNext()) { 
	    
            // gli indirizzi email sono stati memorizzati
	    String email = emailCur.getString(
                      emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA));
 	    String emailType = emailCur.getString(
                      emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.TYPE)); 
 	} 
 	emailCur.close();
 

Per qualsiasi approfondimento sul tema dei contatti e della loro gestione, consiglio la lettura del sito degli sviluppatori Android. Avendo inoltre pochissima esperienza nella programmazione Android, sono graditi commenti/suggerimenti. Grazie per la lettura.

Pensi che questo articolo possa essere d' aiuto anche ad altri? Allora condividilo subito nel tuo social preferito.