Android如何检测联系人列表已更改？

Question

我已经实现了一个ContentObserver，使用这种方法，我只能够被通知如果一个联系人发生变化

但我不知道哪个联系人被添加，删除或更新？

！有什么建议么 ？我如何知道哪个特定联系人被修改？

我通过使用以下方法获取所有联系人列表。

public void readContacts() { 

    System.out.println(" reading contact "); 
    String phoneNumber = null; 
    Uri CONTENT_URI = ContactsContract.Contacts.CONTENT_URI; 
    String _ID = ContactsContract.Contacts._ID; 
    String DISPLAY_NAME = ContactsContract.Contacts.DISPLAY_NAME; 
    String HAS_PHONE_NUMBER = ContactsContract.Contacts.HAS_PHONE_NUMBER; 

    Uri PhoneCONTENT_URI = ContactsContract.CommonDataKinds.Phone.CONTENT_URI; 
    String Phone_CONTACT_ID = ContactsContract.CommonDataKinds.Phone.CONTACT_ID; 
    String NUMBER = ContactsContract.CommonDataKinds.Phone.NUMBER; 

    StringBuffer output = new StringBuffer(); 
    ContentResolver contentResolver = getContentResolver(); 

    Cursor cursor = contentResolver.query(CONTENT_URI, null, null, null, 
      null); 

    if (cursor.getCount() > 0) { 
     while (cursor.moveToNext()) { 
      String contact_id = cursor 
        .getString(cursor.getColumnIndex(_ID)); 
      String name = cursor.getString(cursor 
        .getColumnIndex(DISPLAY_NAME)); 
      // int id = 
      // Integer.parseInt(cursor.getString(cursor.getColumnIndex(
      // HAS_PHONE_NUMBER))); 
      int hasPhoneNumber = Integer.parseInt(cursor.getString(cursor 
        .getColumnIndex(HAS_PHONE_NUMBER))); 
      if (hasPhoneNumber > 0) { 
       output.append("\n First Name:" + name); 

       System.out.println(" CONTACT NAME : " + name); 
       Contact_Name.add(name); 

       // Query and loop for every phone number of the contact 
       Cursor phoneCursor = contentResolver.query(
         PhoneCONTENT_URI, null, Phone_CONTACT_ID + " = ?", 
         new String[] { contact_id }, null); 

       phoneCursor.moveToNext(); 

       phoneNumber = phoneCursor.getString(phoneCursor 
         .getColumnIndex(NUMBER)); 
       output.append("\n Phone number:" + phoneNumber); 
       System.out.println(" CONTACT number : " + phoneNumber); 

       phoneNumber = phoneNumber.replaceAll("\\s", ""); 
       // phoneNumber = phoneNumber.substring(phoneNumber.length() 
       // - 10); 
       // System.err.println("Mobile no."+phoneNumber); 
       Contact_Number.add(phoneNumber); 

       phoneCursor.close(); 
      } 
      output.append("\n"); 
     } 
    } 

} 

并且我正在观察联系人列表正在通过regestring并使用以下代码进行更改。

this.getContentResolver().registerContentObserver(
      ContactsContract.Contacts.CONTENT_URI, true, mObserver); 

private ContentObserver mObserver = new ContentObserver(new Handler()) { 

    @Override 
    public void onChange(boolean selfChange) { 
     super.onChange(selfChange); 

     final int currentCount = getContactCount(); 
     if (currentCount < mContactCount) { 
      System.out.println(" Deleted contact"); 
     } else if (currentCount == mContactCount) { 
      System.out.println(" upated contact"); 
     } else { 
      System.out.println(" inserted contact"); 
     } 
     mContactCount = currentCount; 

    } 

}; 

Answer 1

检查版本是否大于您已有的版本（针对当前联系人）。由于OnChange被称为所有物品（删除,加或更新），这是快速和更准确的，然后您当前正在跟踪的过程。

因此，统计联系人数并没有多大意义，因为联系人已被更新，然后被删除并添加了新联系人。在这种情况下计数是相同的。

http://developer.android.com/reference/android/provider/ContactsContract.SyncColumns.html#VERSION

Answer 2

尝试使用此实施您联系阵列

import java.io.Serializable; 
import java.util.ArrayList; 
import java.util.Collection; 
import java.util.List; 

public class ActiveList<T> extends ArrayList<T> implements Serializable { 

    private static final long serialVersionUID = 870605912858223939L; 
    transient private List<ActiveListListener<T>> listeners; 

    public interface ActiveListListener<T> { 
     void onAdd(T item); 

     void onInsert(int location, T item); 

     void onAddAll(Collection<? extends T> items); 

     void onClear(); 
    } 

    @Override 
    public synchronized void clear() { 
     super.clear(); 
     fireChangedEvent(); 
    } 

    @Override 
    public synchronized int size() { 
     return super.size(); 
    } 

    @Override 
    public synchronized T get(int index) { 
     return super.get(index); 
    } 

    @Override 
    public synchronized boolean add(T item) { 
     boolean success = super.add(item); 
     if (success) { 
      fireAddEvent(item); 
     } 
     return success; 
    } 

    @Override 
    public synchronized void add(int index, T item) { 
     super.add(index, item); 
     fireInsertEvent(index, item); 
    } 

    @Override 
    public synchronized boolean addAll(int index, Collection<? extends T> items) { 
     boolean success = super.addAll(index, items); 
     if (success) { 
      fireAddAllEvent(items); 
     } 
     return success; 
    } 

    @Override 
    public synchronized boolean addAll(Collection<? extends T> items) { 
     boolean success = super.addAll(items); 
     if (success) { 
      fireAddAllEvent(items); 
     } 
     return success; 

    } 

    public synchronized void addListener(ActiveListListener<T> listener) { 
     if (this.listeners == null) { 
      listeners = Lists.newArrayList(); 
     } 
     this.listeners.add(listener); 
    } 

    public synchronized void removeListener(ActiveListListener<T> listener) { 
     if (this.listeners != null) { 
      this.listeners.remove(listener); 
     } 
    } 

    private void fireChangedEvent() { 
     if (this.listeners == null) 
      return; 
     for (ActiveListListener<T> listener : listeners) { 
      listener.onClear(); 
     } 
    } 

    private void fireInsertEvent(int location, T item) { 
     if (this.listeners == null) 
      return; 
     for (ActiveListListener<T> listener : listeners) { 
      listener.onInsert(location, item); 
     } 
    } 

    private void fireAddEvent(T item) { 
     if (this.listeners == null) 
      return; 
     for (ActiveListListener<T> listener : listeners) { 
      listener.onAdd(item); 
     } 
    } 

    private void fireAddAllEvent(Collection<? extends T> items) { 
     if (this.listeners == null) 
      return; 
     for (ActiveListListener<T> listener : listeners) { 
      listener.onAddAll(items); 
     } 
    } 
} 

您的活动或适配器

protected ActiveList.ActiveListListener<Contact> activeListListener = new ActiveList.ActiveListListener<Contact>() { 
     @Override 
     public void onAdd(Contact c) { 
      // do something 
     } 

     @Override 
     public void onInsert(final int location, final Contact c) { 
      // do something 
     } 

     @Override 
     public void onClear() { 
      // do something 
     } 

     @Override 
     public void onAddAll(List<Contact> cs) { 
      // do something 
     } 
    }; 

并在阵列

((ActiveList<Contact>) this.contacts).addListener(activeListListener); 

见例如https://github.com/davidevallicella/UnivrApp/