Obtenga información de contacto específica de la URI devuelta por Intent.ACTION_PICK

De acuerdo, después de mucha excavación, encontré lo que creo que son las respuestas. Las soluciones que encontré difieren según el nivel de API de Android que utilices. Sin embargo, no son bastante en absoluto, así que si hay mejores soluciones, me encantaría saber.

En cualquier caso, el primer paso es obtener el ID del contacto, haciendo una consulta en el URI devuelto de Intent.ACTION_PICK. Mientras estamos aquí, también debemos obtener el nombre para mostrar y la cadena que representa si el contacto tiene un número de teléfono o no. (No los necesitaremos para la solución moderna, pero los necesitamos para la solución heredada.)

 String id, name, phone, hasPhone; int idx; Cursor cursor = getContentResolver().query(contactUri, null, null, null, null); if (cursor.moveToFirst()) { idx = cursor.getColumnIndex(ContactsContract.Contacts._ID); id = cursor.getString(idx); idx = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME); name = cursor.getString(idx); idx = cursor.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER); hasPhone = cursor.getString(idx); } 

Para el registro, las columnas devueltas de este URI son la mayoría de los campos representados por constantes en la clase ContactsContract.Profile (incluidas las constantes heredadas de otras interfaces). No se incluyen PHOTO_FILE_ID, PHOTO_THUMBNAIL_URI o PHOTO_URI (pero se incluye PHOTO_ID).

Ahora que tenemos la identificación, necesitamos obtener los datos relevantes. La primera (y la más simple) solución es consultar una Entidad. Las consultas de entidades recuperan todos los datos de contactos de un contacto o contacto sin procesar a la vez. Cada fila representa un único contacto sin procesar, al que se accede mediante las constantes de ContactsContract.Contacts.Entity . Normalmente sólo se ocupará de RAW_CONTACT_ID, DATA1 y MIMETYPE. Sin embargo, si desea el nombre y los apellidos por separado, el tipo de nombre MIME contiene el primer nombre en DATA2 y el apellido en DATA3.

Se carga las variables haciendo coincidir la columna MIMETYPE con las constantes de ContactsContract.CommonDataKinds ; Por ejemplo, el tipo MIME de correo electrónico está en ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE .

 // Build the Entity URI. Uri.Builder b = Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_URI, id).buildUpon(); b.appendPath(ContactsContract.Contacts.Entity.CONTENT_DIRECTORY); URI contactUri = b.build(); // Create the projection (SQL fields) and sort order. String[] projection = { ContactsContract.Contacts.Entity.RAW_CONTACT_ID, ContactsContract.Contacts.Entity.DATA1, ContactsContract.Contacts.Entity.MIMETYPE }; String sortOrder = ContactsContract.Contacts.Entity.RAW_CONTACT_ID + " ASC"; cursor = getContentResolver().query(contactUri, projection, null, null, sortOrder); String mime; int mimeIdx = cursor.getColumnIndex(ContactsContract.Contacts.Entity.MIMETYPE); int dataIdx = cursor.getColumnIndex(ContactsContract.Contacts.Entity.DATA1); if (cursor.moveToFirst()) { do { mime = cursor.getString(mimeIdx); if (mime.equalsIgnoreCase(ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)) { email = cursor.getString(dataIdx); } if (mime.equalsIgnoreCase(ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)) { phone = cursor.getString(dataIdx); } // ...etc. } while (cursor.moveToNext()); } 

Desafortunadamente, las entidades no fueron introducidas hasta la API 11 (Android 3.0, Honeycomb), lo que significa que este código es incompatible con aproximadamente el 65% de los dispositivos Android en el mercado (a partir de este escrito). Si lo intentas, obtendrás una IllegalArgumentException de la URI.

La segunda solución es crear una cadena de consulta y realizar una consulta para cada tipo de datos que desee utilizar:

 // Get phone number - if they have one if ("1".equalsIgnoreCase(hasPhone)) { cursor = getContentResolver().query( ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, ContactsContract.CommonDataKinds.Phone.CONTACT_ID + " = "+ id, null, null); if (cursor.moveToFirst()) { colIdx = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER); phone = cursor.getString(colIdx); } cursor.close(); } // Get email address cursor = getContentResolver().query( ContactsContract.CommonDataKinds.Email.CONTENT_URI, null, ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = " + id, null, null); if (cursor.moveToFirst()) { colIdx = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Email.ADDRESS); email = cursor.getString(colIdx); } cursor.close(); // ...etc. 

Obviamente, esta manera dará lugar a una gran cantidad de consultas de base de datos por separado, por lo que no es recomendable por razones de eficiencia.

La solución que he encontrado es probar la versión que usa consultas de Entity, capturar la IllegalArgumentException y poner el código heredado dentro del bloque catch:

 try { // Build the Entity URI. Uri.Builder b = Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_URI, id).buildUpon(); b.appendPath(ContactsContract.Contacts.Entity.CONTENT_DIRECTORY); // ...etc... } catch (IllegalArgumentException e) { // Get phone number - if they have one if ("1".equalsIgnoreCase(hasPhone)) { // ...etc... } finally { // If you want to display the info in GUI objects, put the code here } 

Espero que esto ayude a alguien. Y, de nuevo, si hay mejores maneras de hacer esto, soy todo oídos.

Como resulta, hay una mejor manera de hacer esto.

Como mencioné, la clase ContactsContract.Contacts.Entity no estaba disponible hasta la API 11. Sin embargo, la clase ContactsContract.Data estaba disponible en la API 5, y puede utilizar esa clase en gran parte de la misma manera que utiliza la clase Entity .

He actualizado mi código. Es muy similar al código de la clase Entity, y funciona en gran medida de la misma manera. Sin embargo, lo he probado con mi teléfono con Gingerbread, y funciona bien.

Un cambio que tuve que hacer es esto: No parece haber una manera de obtener el ContactsContract.Data.RAW_CONTACT_ID de la consulta inicial, y ese ID no es el mismo que el ID que obtiene de, por ejemplo, ContactsContract.Contacts._ID . En su lugar, consultaba la constante ContactsContract.Contacts.DISPLAY_NAME , que es consistente en prácticamente todas las clases de ContactsContract.

Aquí está el código de trabajo:

  Cursor cursor; // Cursor object String mime; // MIME type int dataIdx; // Index of DATA1 column int mimeIdx; // Index of MIMETYPE column int nameIdx; // Index of DISPLAY_NAME column // Get the name cursor = getContentResolver().query(params[0], new String[] { ContactsContract.Contacts.DISPLAY_NAME }, null, null, null); if (cursor.moveToFirst()) { nameIdx = cursor.getColumnIndex( ContactsContract.Contacts.DISPLAY_NAME); name = cursor.getString(nameIdx); // Set up the projection String[] projection = { ContactsContract.Data.DISPLAY_NAME, ContactsContract.Contacts.Data.DATA1, ContactsContract.Contacts.Data.MIMETYPE }; // Query ContactsContract.Data cursor = getContentResolver().query( ContactsContract.Data.CONTENT_URI, projection, ContactsContract.Data.DISPLAY_NAME + " = ?", new String[] { name }, null); if (cursor.moveToFirst()) { // Get the indexes of the MIME type and data mimeIdx = cursor.getColumnIndex( ContactsContract.Contacts.Data.MIMETYPE); dataIdx = cursor.getColumnIndex( ContactsContract.Contacts.Data.DATA1); // Match the data to the MIME type, store in variables do { mime = cursor.getString(mimeIdx); if (ContactsContract.CommonDataKinds.Email .CONTENT_ITEM_TYPE.equalsIgnoreCase(mime)) { email = cursor.getString(dataIdx); } if (ContactsContract.CommonDataKinds.Phone .CONTENT_ITEM_TYPE.equalsIgnoreCase(mime)) { phone = cursor.getString(dataIdx); phone = PhoneNumberUtils.formatNumber(phone); } } while (cursor.moveToNext()); } } 

 //Add a permission to read contacts data to your application manifest. <uses-permission android:name="android.permission.READ_CONTACTS"/> //Use Intent.ACTION_PICK in your Activity Intent contactPickerIntent = new Intent(Intent.ACTION_PICK, ContactsContract.CommonDataKinds.Phone.CONTENT_URI); startActivityForResult(contactPickerIntent, RESULT_PICK_CONTACT); //Then Override the onActivityResult() and retrieve the ID,Phone number and Name in the data. @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { // check whether the result is ok if (resultCode == RESULT_OK) { // Check for the request code, we might be usign multiple startActivityForReslut switch (requestCode) { case RESULT_PICK_CONTACT: Cursor cursor = null; try { String phoneNo = null ; String name = null; Uri uri = data.getData(); cursor = getContentResolver().query(uri, null, null, null, null); cursor.moveToFirst(); int phoneIndex =cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER); phoneNo = cursor.getString(phoneIndex); textView2.setText(phoneNo); } catch (Exception e) { e.printStackTrace(); } break; } } else { Log.e("MainActivity", "Failed to pick contact"); } } 

Nota: Antes de Android 2.3 (API nivel 9), realizar una consulta en el proveedor de contactos (como el que se muestra arriba) requiere que la aplicación declare el permiso READ_CONTACTS (consulte Seguridad y permisos). Sin embargo, a partir de Android 2.3, la aplicación Contactos / Personas concede a tu aplicación un permiso temporal para leer del proveedor de contactos cuando te devuelve un resultado. El permiso temporal se aplica sólo al contacto específico solicitado, por lo que no puede consultar un contacto distinto del especificado por el Uri de la intención, a menos que declare el permiso READ_CONTACTS.