En mi proyecto de obtención de contactos es tomar un largo tiempo para cargar.

  • ¿Cuáles son las maneras de reducir el tiempo de obtención de contactos
  • Suponga que hay 1000 contactos en mi teléfono.
  • Ahora se toma más de 2 minutos para cargar todos los contactos

¿Cómo puedo reducir el tiempo de carga de los contactos ?
Los Pensamientos?

Me he referido a la el siguiente enlace al programar el método inicial.

http://www.coderzheaven.com/2011/06/13/get-all-details-from-contacts-in-android/

OriginalEl autor Bharathi D | 2012-06-01

5 Comentarios

  1. 7

    Tiempo Total dependerá de cuáles son los campos que usted está tratando de acceder a partir de la tabla de Contactos.
    El acceso a menos de campo significa menos bucle , menos de procesamiento y, por tanto, resultados más rápidos.

    También para acelerar tus contactos operación de captura puede utilizar el ContentProvideClient en lugar de llamar a consulta en ContentResolver cada vez. Esto hará que usted consulta a la tabla en lugar de consultar de primera para el ContentProvider y luego a la mesa.

    Crear una instancia de ContentProviderClient

    ContentResolver cResolver=context.getContextResolver();
    ContentProviderClient mCProviderClient = cResolver.acquireContentProviderClient(ContactsContract.Contacts.CONTENT_URI);

    A continuación, volver a este mCProviderClient para conseguir Contactos(datos desde cualquier ContentProvider) datos sobre su llamada.
    Por ejemplo, en el método siguiente, yo soy el acceso a un solo campo.

    private ArrayList<String> fetchContactsCProviderClient()
        {
            ArrayList<String> mContactList = null;
            try
            {
                Cursor mCursor = mCProviderClient.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
                if (mCursor != null && mCursor.getCount() > 0)
                {
                    mContactList = new ArrayList<String>();
                    mCursor.moveToFirst();
                    while (!mCursor.isLast())
                    {
                        String displayName = mCursor.getString(mCursor.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME));
                        mContactList.add(displayName);
                        mCursor.moveToNext();
                    }
                    if (mCursor.isLast())
                    {
                        String displayName = mCursor.getString(mCursor.getColumnIndexOrThrow(ContactsContract.Contacts.DISPLAY_NAME));
                        mContactList.add(displayName);
                    }
                }
    
                mCursor.close();
            }
            catch (RemoteException e)
            {
                e.printStackTrace();
                mContactList = null;
            }
            catch (Exception e)
            {
                e.printStackTrace();
                mContactList = null;
            }
    
            return mContactList;
        }

    OriginalEl autor Napolean

  2. 15

    MEJOR SOLUCIÓN AQUÍ…..

    private static final String[] PROJECTION = new String[] {
            ContactsContract.CommonDataKinds.Phone.CONTACT_ID,
            ContactsContract.Contacts.DISPLAY_NAME,
            ContactsContract.CommonDataKinds.Phone.NUMBER
        };
    .
    .
    .
    
    ContentResolver cr = getContentResolver();
            Cursor cursor = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, PROJECTION, null, null, null);
            if (cursor != null) {
                try {
                    final int nameIndex = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
                    final int numberIndex = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);
    
                    String name, number;
                    while (cursor.moveToNext()) {
                        name = cursor.getString(nameIndex);
                        number = cursor.getString(numberIndex);
                    }
                } finally {
                    cursor.close();
                }
            }

    SALUDOS…:)

    esta es una solución inteligente, pero ¿y si el contacto tiene varios números de teléfono ?
    Lopes – sólo lectura sólo número de teléfono, ¿cómo puedo leer el correo electrónico de identificación junto con eso.
    ¿Por qué es esta una solución mejor?
    Debido a la optimización de la proyección en la consulta que se le da resultados muy rápido 🙂
    muy rápido.. 400 contactos dentro de la segunda.. debe ser aceptado responder a esta

    OriginalEl autor Melbourne Lopes

  3. 5

    Carga de Contacto rápido como otras aplicaciones haciendo.

    He probado este código con múltiples contactos de su trabajo fino y rápido como otras aplicaciones dentro de 500 ms (a menos de medio segundo o menos) yo soy capaz de cargar 1000+ contactos.

    Tiempo Total dependerá de cuáles son los campos que usted está tratando de acceder a partir de la tabla de Contactos.

    La sarna de su consulta de acuerdo a su requerimiento no tienen acceso a los campos innecesarios. El acceso a menos de campo significa menos bucle , menos de procesamiento y, por tanto, resultados más rápidos.

    Acceder a la tabla de la derecha en contacto también ayuda a reducir el contacto tiempo de carga.

    La Optimización de la consulta para cargar en contacto con más y más rápido utilizar projection

     String[] projection = {
                ContactsContract.Data.MIMETYPE,
                ContactsContract.Data.CONTACT_ID,
                ContactsContract.Contacts.DISPLAY_NAME,
                ContactsContract.Contacts.PHOTO_URI,
                ContactsContract.Contacts.STARRED,
                ContactsContract.RawContacts.ACCOUNT_TYPE,
                ContactsContract.CommonDataKinds.Contactables.DATA,
                ContactsContract.CommonDataKinds.Contactables.TYPE
        };

    Y de selección argumento

    String selection = ContactsContract.Data.MIMETYPE + " in (?, ?)" + " AND " /*+ ContactsContract.Contacts.IN_VISIBLE_GROUP + " = '" + 1 + "' AND "*/ +
                ContactsContract.Data.HAS_PHONE_NUMBER + " = '" + 1 + "'";
    
        String[] selectionArgs = {
                ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE,
                ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,
        };

    Para ordenar los contactos por orden alfabético utilizar el siguiente código

     try {
            Collections.sort(listview_address, new Comparator<ContactBook>() {
                @Override
                public int compare(ContactBook lhs, ContactBook rhs) {
                    return lhs.name.toUpperCase().compareTo(rhs.name.toUpperCase());
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }

    Siguiente es el código fuente completo

     public void initeContacts() {
    List<ContactBook> listview_address = new LinkedList<ContactBook>();
    SparseArray<ContactBook> addressbook_array = null;
    {
    addressbook_array = new SparseArray<ContactBook>();
    long start = System.currentTimeMillis();
    String[] projection = {
    ContactsContract.Data.MIMETYPE,
    ContactsContract.Data.CONTACT_ID,
    ContactsContract.Contacts.DISPLAY_NAME,
    ContactsContract.Contacts.PHOTO_URI,
    ContactsContract.Contacts.STARRED,
    ContactsContract.RawContacts.ACCOUNT_TYPE,
    ContactsContract.CommonDataKinds.Contactables.DATA,
    ContactsContract.CommonDataKinds.Contactables.TYPE
    };
    String selection = ContactsContract.Data.MIMETYPE + " in (?, ?)" + " AND " /*+ ContactsContract.Contacts.IN_VISIBLE_GROUP + " = '" + 1 + "' AND "*/ +
    ContactsContract.Data.HAS_PHONE_NUMBER + " = '" + 1 + "'";
    String[] selectionArgs = {
    ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE,
    ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,
    };
    String sortOrder = ContactsContract.Contacts.SORT_KEY_ALTERNATIVE;
    Uri uri = null;
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN_MR2) {
    uri = ContactsContract.CommonDataKinds.Contactables.CONTENT_URI;
    } else {
    uri = ContactsContract.Data.CONTENT_URI;
    }
    //we could also use Uri uri = ContactsContract.Data.CONTENT_URI;
    //we could also use Uri uri = ContactsContract.Contact.CONTENT_URI;
    Cursor cursor = getActivity().getContentResolver().query(uri, projection, selection, selectionArgs, sortOrder);
    final int mimeTypeIdx = cursor.getColumnIndex(ContactsContract.Data.MIMETYPE);
    final int idIdx = cursor.getColumnIndex(ContactsContract.Data.CONTACT_ID);
    final int nameIdx = cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
    final int dataIdx = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Contactables.DATA);
    final int photo = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Contactables.PHOTO_URI);
    final int typeIdx = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Contactables.TYPE);
    final int account_type = cursor.getColumnIndex(ContactsContract.RawContacts.ACCOUNT_TYPE);
    while (cursor.moveToNext()) {
    int contact_id = cursor.getInt(idIdx);
    String photo_uri = cursor.getString(photo);
    String contact_name = cursor.getString(nameIdx);
    String contact_acc_type = cursor.getString(account_type);
    int contact_type = cursor.getInt(typeIdx);
    String contact_data = cursor.getString(dataIdx);
    ContactBook contactBook = addressbook_array.get(contact_id);
    /* if (contactBook == null) {
    //list  contact add to avoid duplication
    //load All contacts fro device
    //to add contacts number with name add one extra veriable in ContactBook as number and pass contact_data this give number to you (contact_data is PHONE NUMBER)
    contactBook = new ContactBook(contact_id, contact_name, getResources(), photo_uri, contact_acc_type, "phone number");
    addressbook_array.put(contact_id, contactBook);
    listview_address.add(contactBook);
    }*/
    String Contact_mimeType = cursor.getString(mimeTypeIdx);
    //here am checking Contact_mimeType to get mobile number asociated with perticular contact and email adderess asociated
    if (Contact_mimeType.equals(ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)) {
    if (contactBook != null) {
    contactBook.addEmail(contact_type, contact_data);
    }
    } else {
    if (contactBook == null) {
    //list  contact add to avoid duplication
    //load All contacts fro device
    //to add contacts number with name add one extra veriable in ContactBook as number and pass contact_data this give number to you (contact_data is PHONE NUMBER)
    contactBook = new ContactBook(contact_id, contact_name, getResources(), photo_uri, contact_acc_type, "phone number");
    addressbook_array.put(contact_id, contactBook);
    listview_address.add(contactBook);
    }
    //contactBook.addPhone(contact_type, contact_data);
    }
    }
    cursor.close();
    try {
    Collections.sort(listview_address, new Comparator<ContactBook>() {
    @Override
    public int compare(ContactBook lhs, ContactBook rhs) {
    return lhs.name.toUpperCase().compareTo(rhs.name.toUpperCase());
    }
    });
    } catch (Exception e) {
    e.printStackTrace();
    }
    }

    Puede utilizar el siguiente código en el código anterior que he comentado .Es el club el que el único contacto con sus múltiples número.Para obtener todos los números asociados con el solo contacto de uso de la matriz en la clase de Objeto.

     if (contactBook == null) {
    //irst  contact add to avoid duplication
    //load All contacts fro device
    contactBook = new ContactBook(contact_id, contact_name, getResources(), photo_uri, contact_acc_type, "");
    addressbook_array.put(contact_id, contactBook);
    listview_address.add(contactBook);
    }
    String Contact_mimeType = cursor.getString(mimeTypeIdx);
    //here am checking Contact_mimeType to get mobile number asociated with perticular contact and email adderess asociated
    if (Contact_mimeType.equals(ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)) {
    contactBook.addEmail(contact_type, contact_data);
    } else {
    contactBook.addPhone(contact_type, contact_data);
    }

    Clase de objeto

    public class ContactBook {
    public int id;
    public Resources res;
    public String name;
    public String photo;
    public String contact_acc_type;
    public SparseArray<String> emails;
    public SparseArray<String> phones;
    /*  public LongSparseArray<String> emails;
    public LongSparseArray<String> phones;*/
    public String header = "";
    public ContactBook(int id, String name, Resources res, String photo, String contact_acc_type, String header) {
    this.id = id;
    this.name = name;
    this.res = res;
    this.photo = photo;
    this.contact_acc_type = contact_acc_type;
    this.header = header;
    }
    @Override
    public String toString() {
    return toString(false);
    }
    public String toString(boolean rich) {
    //testing method to check ddata
    SpannableStringBuilder builder = new SpannableStringBuilder();
    if (rich) {
    builder.append("id: ").append(Long.toString(id))
    .append(", name: ").append("\u001b[1m").append(name).append("\u001b[0m");
    } else {
    builder.append(name);
    }
    if (phones != null) {
    builder.append("\n\tphones: ");
    for (int i = 0; i < phones.size(); i++) {
    int type = (int) phones.keyAt(i);
    builder.append(ContactsContract.CommonDataKinds.Phone.getTypeLabel(res, type, ""))
    .append(": ")
    .append(phones.valueAt(i));
    if (i + 1 < phones.size()) {
    builder.append(", ");
    }
    }
    }
    if (emails != null) {
    builder.append("\n\temails: ");
    for (int i = 0; i < emails.size(); i++) {
    int type = (int) emails.keyAt(i);
    builder.append(ContactsContract.CommonDataKinds.Email.getTypeLabel(res, type, ""))
    .append(": ")
    .append(emails.valueAt(i));
    if (i + 1 < emails.size()) {
    builder.append(", ");
    }
    }
    }
    return builder.toString();
    }
    public void addEmail(int type, String address) {
    //this is the array in object class where i am storing contact all emails of perticular contact (single)
    if (emails == null) {
    //  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    emails = new SparseArray<String>();
    emails.put(type, address);
    /*} else {
    //add emails to array below Jelly bean //use single array list
    }*/
    }
    }
    public void addPhone(int type, String number) {
    //this is the array in object class where i am storing contact numbers of perticular contact
    if (phones == null) {
    // if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    phones = new SparseArray<String>();
    phones.put(type, number);
    /* } else {
    //add emails to array below Jelly bean //use single array list
    }*/
    }
    }}

    OriginalEl autor Sagar

  4. 3

    Para la carga de los contactos con el mínimo de tiempo la solución óptima es utilizar el concepto de proyección y selección argumento mientras se consulta el cursor para contactos.

    esto puede hacerse en la siguiente forma

    void getAllContacts() {
    long startnow;
    long endnow;
    startnow = android.os.SystemClock.uptimeMillis();
    ArrayList arrContacts = new ArrayList();
    Uri uri = ContactsContract.CommonDataKinds.Phone.CONTENT_URI;
    String selection = ContactsContract.Contacts.HAS_PHONE_NUMBER;
    Cursor cursor = ctx.getContentResolver().query(uri, new String[]{ContactsContract.CommonDataKinds.Phone.NUMBER,   ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME, ContactsContract.CommonDataKinds.Phone._ID, ContactsContract.Contacts._ID}, selection, null, ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME + " ASC");
    cursor.moveToFirst();
    while (cursor.isAfterLast() == false) {
    String contactNumber = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
    String contactName = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
    int phoneContactID = cursor.getInt(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone._ID));
    int contactID = cursor.getInt(cursor.getColumnIndex(ContactsContract.Contacts._ID));
    Log.d("con ", "name " + contactName + " " + " PhoeContactID " + phoneContactID + "  ContactID " + contactID)
    cursor.moveToNext();
    }
    cursor.close();
    cursor = null;
    endnow = android.os.SystemClock.uptimeMillis();
    Log.d("END", "TimeForContacts " + (endnow - startnow) + " ms");
    }

    Con el método anterior, se llevó a 400 ms(menos de un segundo) para cargar los contactos donde como en normall camino que estaba tomando 10-12 seg.

    Para los detalles de la información de este post puede ayudar a como me tomé la ayuda de la ti
    http://www.blazin.in/2016/02/loading-contacts-fast-from-android.html

    REALMENTE debe ser aceptada respuesta. Wayyyyy más eficiente

    OriginalEl autor Bhushan Shirsath

  5. 0

    Creo que esta es una mejor solución:

    public ContentValues getAllContacts() {
    ContentValues contacts = new ContentValues();
    ContentResolver cr = getContentResolver();
    Cursor cur = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
    if (cur != null && cur.getCount() > 0) {
    while (cur.moveToNext()) {
    String id = cur.getString(cur.getColumnIndex(ContactsContract.Contacts._ID));
    String name = cur.getString(cur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
    if (cur.getInt(cur.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER)) > 0) {
    Cursor pCur = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null,
    ContactsContract.CommonDataKinds.Phone.CONTACT_ID + " = ?", new String[]{id}, null);
    if (pCur != null) {
    while (pCur.moveToNext()) {
    String phoneNo = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
    contacts.put(phoneNo, name);
    }
    pCur.close();
    }
    }
    }
    cur.close();
    }
    return contacts;
    }

    para utilizarla es necesario llamar a esta líneas una vez:

    ContentValues contacts = new ContentValues();
    contacts = getAllContacts();

    y cuando desee ponerse en contacto con nombre, por número, sólo tiene que utilizar:

    String number = "12345";
    String name = (String) G.contacts.get(number);

    este algoritmo es un poco más rápido…

    OriginalEl autor Nobody8

Dejar respuesta

Please enter your comment!
Please enter your name here