java类android.provider.ContactsContract的实例源码

@SuppressLint("NewApi")
@Override
public Uri getSelfIdentityUri() {
  String[] PROJECTION = new String[] {
      PhoneLookup.DISPLAY_NAME,
      PhoneLookup.LOOKUP_KEY,
      PhoneLookup._ID,
  };

  Cursor cursor = null;

  try {
    cursor = context.getContentResolver().query(ContactsContract.Profile.CONTENT_URI,
                                                  PROJECTION, null, null, null);

    if (cursor != null && cursor.moveToFirst()) {
      return Contacts.getLookupUri(cursor.getLong(2), cursor.getString(1));
    }
  } finally {
    if (cursor != null)
      cursor.close();
  }

  return null;
}

@Override
public Loader<Cursor> onCreateLoader(int id, Bundle args) {

    String[]  projectionFields = new String[]{
        ContactsContract.Contacts._ID,
            ContactsContract.Contacts.DISPLAY_NAME,
            ContactsContract.Contacts.PHOTO_URI
    };


    CursorLoader cursorLoader = new CursorLoader(MainActivity.this,
            ContactsContract.Contacts.CONTENT_URI,
            projectionFields,
            null,
            null,
            null);

    return cursorLoader;
}

private void readContactDetails(Cursor cursor) {
    if (cursor != null && cursor.moveToFirst()) {
        cursor.moveToPrevious();
        while (cursor.moveToNext()) {
            String lookupKey = cursor.getString(cursor.getColumnIndex(ContactsContract.Data.LOOKUP_KEY));
            ContactImpl contact = mContactsByLookupKey.get(lookupKey);

            if (contact != null) {
                readContactDetails(cursor, contact);
            }
        }
    }

    sortAndPostCopy(mContacts);
    joinContactsAndGroups(mContacts);
}

@Override
public Loader<Cursor> onCreateLoader(int i, Bundle bundle) {
    return new CursorLoader(this,
            // Retrieve data rows for the device user's 'profile' contact.
            Uri.withAppendedPath(ContactsContract.Profile.CONTENT_URI,
                    ContactsContract.Contacts.Data.CONTENT_DIRECTORY), ProfileQuery.PROJECTION,

            // Select only email addresses.
            ContactsContract.Contacts.Data.MIMETYPE +
                    " = ?", new String[]{ContactsContract.CommonDataKinds.Email
            .CONTENT_ITEM_TYPE},

            // Show primary email addresses first. Note that there won't be
            // a primary email address if the user hasn't specified one.
            ContactsContract.Contacts.Data.IS_PRIMARY + " DESC");
}

public static List<String> getNameEmailDetails(ContentResolver resolver) {
    ArrayList<String> names = new ArrayList<>();
    Cursor cur = resolver.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
    if (cur.getCount() > 0) {
        while (cur.moveToNext()) {
            String id = cur.getString(cur.getColumnIndex(ContactsContract.Contacts._ID));
            Cursor cur1 =
                resolver.query(ContactsContract.CommonDataKinds.Email.CONTENT_URI, null,
                    ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = ?",
                    new String[] { id }, null);
            getEmailFromCursor(names, cur1);
            cur1.close();
        }
    }
    return names;
}

private void setPersonInfo(final @NonNull Recipient recipient) {
  this.recipient = recipient;
  this.recipient.addListener(this);

  final Context context = getContext();

  new AsyncTask<Void, Void, ContactPhoto>() {
    @Override
    protected ContactPhoto doInBackground(Void... params) {
      DisplayMetrics metrics       = new DisplayMetrics();
      WindowManager  windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      Uri            contentUri    = ContactsContract.Contacts.lookupContact(context.getContentResolver(),
                                                                             recipient.getContactUri());
      windowManager.getDefaultDisplay().getMetrics(metrics);
      return ContactPhotoFactory.getContactPhoto(context, contentUri, null, metrics.widthPixels);
    }

    @Override
    protected void onPostExecute(final ContactPhoto contactPhoto) {
      WebRtcCallScreen.this.photo.setImageDrawable(contactPhoto.asCallCard(context));
    }
  }.execute();

  this.name.setText(recipient.getName());
  this.phoneNumber.setText(recipient.getNumber());
}

/**
 * Start the activity to add information to an existing contact or add a
 * new one.
 *
 * @param email An {@link Address} instance containing the email address
 *              of the entity you want to add to the contacts. Optionally
 *              the instance also contains the (display) name of that
 *              entity.
 */
public void createContact(final Address email) {
    final Uri contactUri = Uri.fromParts("mailto", email.getAddress(), null);

    final Intent contactIntent = new Intent(ContactsContract.Intents.SHOW_OR_CREATE_CONTACT);
    contactIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    contactIntent.setData(contactUri);

    // Pass along full E-mail string for possible create dialog
    contactIntent.putExtra(ContactsContract.Intents.EXTRA_CREATE_DESCRIPTION,
            email.toString());

    // Only provide personal name hint if we have one
    final String senderPersonal = email.getPersonal();
    if (senderPersonal != null) {
        contactIntent.putExtra(ContactsContract.Intents.Insert.NAME, senderPersonal);
    }

    mContext.startActivity(contactIntent);
}

/**
 * Starts the contacts intent and requests permission to write to contacts if permission doesn't exist
 */
public void startContactsActivityIntent(){
    String[] permissions = {"android.permission.WRITE_CONTACTS"};
    Intent intent = new Intent(ContactsContract.Intents.Insert.ACTION);
    intent.setType(ContactsContract.RawContacts.CONTENT_TYPE);
    if(ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_CONTACTS) != PackageManager
            .PERMISSION_GRANTED){
        ActivityCompat.requestPermissions(this, permissions, CONTACTS_PERMISSION);
    }
    else {
        if (intent.resolveActivity(getPackageManager()) != null) {
            intent.putExtra(ContactsContract.Intents.Insert.NAME, name);
            intent.putExtra(ContactsContract.Intents.Insert.EMAIL, email);
            intent.putExtra(ContactsContract.Intents.Insert.PHONE, phone);
            startActivity(intent);
        }
    }
}

private InputStream getInputStream(Request data) throws IOException {
  ContentResolver contentResolver = context.getContentResolver();
  Uri uri = data.uri;
  switch (matcher.match(uri)) {
    case ID_LOOKUP:
      uri = ContactsContract.Contacts.lookupContact(contentResolver, uri);
      if (uri == null) {
        return null;
      }
      // Resolved the uri to a contact uri, intentionally fall through to process the resolved uri
    case ID_CONTACT:
      return openContactPhotoInputStream(contentResolver, uri, true);
    case ID_THUMBNAIL:
    case ID_DISPLAY_PHOTO:
      return contentResolver.openInputStream(uri);
    default:
      throw new IllegalStateException("Invalid uri: " + uri);
  }
}

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();

    switch (id) {
        case android.R.id.home:
            finish();
            return true;
        case R.id.action_invite_friends:
            Intent intent = new Intent(Intent.ACTION_PICK, ContactsContract.CommonDataKinds.Phone.CONTENT_URI);
            startActivityForResult(intent, Constants.REQUEST_PERMISSIONS_CONTACT);
            return true;
        case R.id.action_add_friends:
            AddContactDialog addContactDialog = new AddContactDialog();
            addContactDialog.setOnAdded(this);
            addContactDialog.show(getSupportFragmentManager(), "AddContactDialog");
            return true;
    }

    return super.onOptionsItemSelected(item);
}

@Override
public CName getName() {

    CName cName = new CName();
    String familyName = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME));
    String displayName = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME));
    String givenName = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME));
    String photoUri = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.StructuredName.PHOTO_URI));


    cName.setFamilyName(familyName);
    cName.setDisplayName(displayName);
    cName.setGivenName(givenName);
    cName.setPhotoUri(photoUri);

    return cName;
}

@Override
public Loader<Cursor> onCreateLoader(int i, Bundle bundle) {
    return new CursorLoader(this,
            // Retrieve data rows for the device user's 'profile' contact.
            Uri.withAppendedPath(ContactsContract.Profile.CONTENT_URI,
                    ContactsContract.Contacts.Data.CONTENT_DIRECTORY), ProfileQuery.PROJECTION,

            // Select only email addresses.
            ContactsContract.Contacts.Data.MIMETYPE +
                    " = ?", new String[]{ContactsContract.CommonDataKinds.Email
            .CONTENT_ITEM_TYPE},

            // Show primary email addresses first. Note that there won't be
            // a primary email address if the user hasn't specified one.
            ContactsContract.Contacts.Data.IS_PRIMARY + " DESC");
}

@Override
public Loader<Cursor> onCreateLoader(int i, Bundle bundle) {
    return new CursorLoader(this,
            // Retrieve data rows for the device user's 'profile' contact.
            Uri.withAppendedPath(ContactsContract.Profile.CONTENT_URI,
                    ContactsContract.Contacts.Data.CONTENT_DIRECTORY), ProfileQuery.PROJECTION,

            // Select only email addresses.
            ContactsContract.Contacts.Data.MIMETYPE +
                    " = ?", new String[]{ContactsContract.CommonDataKinds.Email
            .CONTENT_ITEM_TYPE},

            // Show primary email addresses first. Note that there won't be
            // a primary email address if the user hasn't specified one.
            ContactsContract.Contacts.Data.IS_PRIMARY + " DESC");
}

private SparseArray<Group> getGroupsMap() {
    SparseArray<Group> idGroupMap = new SparseArray<>();
    Cursor groupCursor = mResolver.query(
        ContactsContract.Groups.CONTENT_URI,
        new String[]{
            ContactsContract.Groups._ID,
            ContactsContract.Groups.TITLE
        }, null, null, null
    );
    if (groupCursor != null) {
        while (groupCursor.moveToNext()) {
            int id = groupCursor.getInt(groupCursor.getColumnIndex(ContactsContract.Groups._ID));
            String title = groupCursor.getString(groupCursor.getColumnIndex(ContactsContract.Groups.TITLE));
            idGroupMap.put(id, new Group()
                .setGroupId(id)
                .setGroupTitle(title));
        }
        groupCursor.close();
    }
    return idGroupMap;
}

@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
    contactsAdapter.clear();

    Set<String> favoriteContacts = CustodeUtils.getFavoriteContacts(this);
    LinkedList<ContactsAdapter.ContactItem> tempArray = new LinkedList<>();
    int favoriteLimit = 0; // usato per ordinare i contatti preferiti in cima alla lista

    int nameColumnIndex = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME);
    int numberColumnIndex = cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);

    while (cursor.moveToNext()) {
        String name = cursor.getString(nameColumnIndex);
        String number = cursor.getString(numberColumnIndex);

        boolean favorite = favoriteContacts.remove(number);
        if (favorite)
            tempArray.add(favoriteLimit++, new ContactsAdapter.ContactItem(name, number, true));
        else
            tempArray.addLast(new ContactsAdapter.ContactItem(name, number, false));
    }

    if (favoriteContacts.size() > 0) // => favoriteContacts contiene numeri che non sono più presenti in rubrica
        for (String favoriteContact : favoriteContacts)
            tempArray.addFirst(new ContactsAdapter.ContactItem("", favoriteContact, true));

    contactsAdapter.addAll(tempArray);
}

@Override
public Loader<Cursor> onCreateLoader(int i, Bundle bundle) {
    return new CursorLoader(this,
            // Retrieve data rows for the device user's 'profile' contact.
            Uri.withAppendedPath(ContactsContract.Profile.CONTENT_URI,
                    ContactsContract.Contacts.Data.CONTENT_DIRECTORY), ProfileQuery.PROJECTION,

            // Select only email addresses.
            ContactsContract.Contacts.Data.MIMETYPE +
                    " = ?", new String[]{ContactsContract.CommonDataKinds.Email
            .CONTENT_ITEM_TYPE},

            // Show primary email addresses first. Note that there won't be
            // a primary email address if the user hasn't specified one.
            ContactsContract.Contacts.Data.IS_PRIMARY + " DESC");
}

@Override
public void onBindItemViewHolder(ViewHolder viewHolder, @NonNull Cursor cursor) {
  long   id          = cursor.getLong(cursor.getColumnIndexOrThrow(ContactsDatabase.ID_COLUMN));
  int    contactType = cursor.getInt(cursor.getColumnIndexOrThrow(ContactsDatabase.CONTACT_TYPE_COLUMN));
  String name        = cursor.getString(cursor.getColumnIndexOrThrow(ContactsDatabase.NAME_COLUMN));
  String number      = cursor.getString(cursor.getColumnIndexOrThrow(ContactsDatabase.NUMBER_COLUMN));
  int    numberType  = cursor.getInt(cursor.getColumnIndexOrThrow(ContactsDatabase.NUMBER_TYPE_COLUMN));
  String label       = cursor.getString(cursor.getColumnIndexOrThrow(ContactsDatabase.LABEL_COLUMN));
  String labelText   = ContactsContract.CommonDataKinds.Phone.getTypeLabel(getContext().getResources(),
                                                                           numberType, label).toString();

  int color = (contactType == ContactsDatabase.PUSH_TYPE) ? drawables.getColor(0, 0xa0000000) :
              drawables.getColor(1, 0xff000000);

  boolean preSelected = numbers != null && numbers.contains(number);

  viewHolder.getView().unbind();
  viewHolder.getView().set(id, contactType, name, number, labelText, color, multiSelect);
  viewHolder.getView().setChecked(preSelected || selectedContacts.containsKey(id));
  viewHolder.getView().setEnabled(!preSelected);
}

private static void addContactToGroup(ContentResolver mResolver, int contactId, int groupId)
{
    // judge whether the contact has been in the group
    boolean b1 = ifExistContactInGroup(mResolver, contactId, groupId);
    if (b1)
    {
        // the contact has been in the group
        return;
    }
    else
    {
        ContentValues values = new ContentValues();
        values.put(ContactsContract.CommonDataKinds.GroupMembership.RAW_CONTACT_ID, contactId);
        values.put(ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID, groupId);
        values.put(ContactsContract.CommonDataKinds.GroupMembership.MIMETYPE,
            ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE);
        mResolver.insert(ContactsContract.Data.CONTENT_URI, values);
    }
}

private void initializeContactUpdatesReceiver() {
  observer = new ContentObserver(null) {
    @Override
    public void onChange(boolean selfChange) {
      super.onChange(selfChange);
      Log.w(TAG, "Detected android contact data changed, refreshing cache");
      RecipientFactory.clearCache(ConversationListActivity.this);
      ConversationListActivity.this.runOnUiThread(new Runnable() {
        @Override
        public void run() {
          chatsFragment.getListAdapter().notifyDataSetChanged();
        }
      });
    }
  };

  getContentResolver().registerContentObserver(ContactsContract.Contacts.CONTENT_URI,
          true, observer);
}

private void setAvatarClickHandler(final Recipients recipients, boolean quickContactEnabled) {
  if (!recipients.isGroupRecipient() && quickContactEnabled) {
    setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        Recipient recipient = recipients.getPrimaryRecipient();

        if (recipient != null && recipient.getContactUri() != null) {
          ContactsContract.QuickContact.showQuickContact(getContext(), AvatarImageView.this, recipient.getContactUri(), ContactsContract.QuickContact.MODE_LARGE, null);
        } else if (recipient != null) {
          final Intent intent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
          intent.putExtra(ContactsContract.Intents.Insert.PHONE, recipient.getNumber());
          intent.setType(ContactsContract.Contacts.CONTENT_ITEM_TYPE);
          getContext().startActivity(intent);
        }
      }
    });
  } else {
    setOnClickListener(null);
  }
}

private void loadUserInfoFromPhone(){
    User user = AppManager.getSession();
    if (user != null) {
        etName.setText(user.getName());
        Util.setProfileImage(user.getPhoto(), imgProfile);
    } else {
        if (checkPermissions()) {
            String[] projection = new String[] {
                    Phone.DISPLAY_NAME,
                    Phone.HAS_PHONE_NUMBER,
                    Phone.NUMBER,
                    Phone.CONTACT_ID};

            Cursor cursor = getApplication().getContentResolver().query(ContactsContract.Profile.CONTENT_URI, null, null, null, null);
            if (cursor.moveToFirst()){
                etName.setText(cursor.getString(cursor.getColumnIndex("display_name")));
            }
            cursor.close();
        }
    }
}

@Override
/**
 * This method will remove a Contact from the database based on ID.
 * @param id the unique ID of the contact to remove
 */
public boolean remove(String id) {
    int result = 0;
    Cursor cursor = mApp.getActivity().getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,
            null,
            ContactsContract.Contacts._ID + " = ?",
            new String[] { id }, null);

    if (cursor.getCount() == 1) {
        cursor.moveToFirst();
        String lookupKey = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY));
        Uri uri = Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_LOOKUP_URI, lookupKey);
        result = mApp.getActivity().getContentResolver().delete(uri, null, null);
    } else {
        LOG.d(LOG_TAG, "Could not find contact with ID");
    }

    return (result > 0) ? true : false;
}

/**
 * read contacts, {@link android.Manifest.permission#READ_CONTACTS}
 *
 * @param activity
 * @return true if success
 * @throws Exception
 */
private static boolean checkReadContacts(Activity activity) throws Exception {
    Cursor cursor = activity.getContentResolver().query(ContactsContract.CommonDataKinds.Phone
            .CONTENT_URI, null, null, null, null);
    if (cursor != null) {
        if (ManufacturerSupportUtil.isForceManufacturer()) {
            if (isNumberIndexInfoIsNull(cursor, cursor.getColumnIndex(ContactsContract.CommonDataKinds
                    .Phone.NUMBER))) {
                cursor.close();
                return false;
            }
        }
        cursor.close();
        return true;
    } else {
        return false;
    }
}

public void matchContactEmails(Map<String, Contact> contactsMap) {
    // Get email
    final String[] emailProjection = new String[]{
            Email.DATA,
            Email.TYPE,
            Email.CONTACT_ID,
    };

    Cursor email = new CursorLoader(context,
            Email.CONTENT_URI,
            emailProjection,
            null,
            null,
            null).loadInBackground();

    if (email.moveToFirst()) {
        final int contactEmailColumnIndex = email.getColumnIndex(Email.DATA);
        final int contactTypeColumnIndex = email.getColumnIndex(Email.TYPE);
        final int contactIdColumnsIndex = email.getColumnIndex(Email.CONTACT_ID);

        while (!email.isAfterLast()) {
            final String address = email.getString(contactEmailColumnIndex);
            final String contactId = email.getString(contactIdColumnsIndex);
            final int type = email.getInt(contactTypeColumnIndex);
            String customLabel = "Custom";
            Contact contact = contactsMap.get(contactId);
            if (contact == null) {
                continue;
            }
            CharSequence emailType = ContactsContract.CommonDataKinds.Email.getTypeLabel(context.getResources(), type, customLabel);
            contact.addEmail(address, emailType.toString());
            email.moveToNext();
        }
    }

    email.close();
}

@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
protected InputStream getContactPhotoStream(Uri uri) {
    ContentResolver res = context.getContentResolver();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
        return ContactsContract.Contacts.openContactPhotoInputStream(res, uri, true);
    } else {
        return ContactsContract.Contacts.openContactPhotoInputStream(res, uri);
    }
}

public RawContactsProjection()
{
    // TODO: it's probably better to compose this from smaller projections with just a few columns
    super(new MultiProjection<ContactsContract.RawContacts>(
            ContactsContract.RawContacts._ID,
            ContactsContract.RawContacts.CONTACT_ID,
            ContactsContract.RawContacts.AGGREGATION_MODE,
            ContactsContract.RawContacts.DELETED,
            // the following column doesn't seem to work on Android 7.1
            //ContactsContract.RawContacts.RAW_CONTACT_IS_READ_ONLY,

            // values from ContactNameColumns
            ContactsContract.RawContacts.DISPLAY_NAME_SOURCE,
            ContactsContract.RawContacts.DISPLAY_NAME_PRIMARY,
            ContactsContract.RawContacts.DISPLAY_NAME_ALTERNATIVE,
            ContactsContract.RawContacts.PHONETIC_NAME_STYLE,
            ContactsContract.RawContacts.PHONETIC_NAME,
            ContactsContract.RawContacts.SORT_KEY_PRIMARY,
            ContactsContract.RawContacts.SORT_KEY_ALTERNATIVE,

            // values from SyncColumns
            ContactsContract.RawContacts.ACCOUNT_NAME,
            ContactsContract.RawContacts.ACCOUNT_TYPE,
            ContactsContract.RawContacts.DIRTY,
            ContactsContract.RawContacts.SOURCE_ID,
            ContactsContract.RawContacts.VERSION));
}

/**
     * 同步返回联系人列表
     */
    public static List<ContactsInfo> getContactsList(Context context) {

        //检查权限
        if (Build.VERSION.SDK_INT >= 23) {
            if (ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
                return  new ArrayList<>();
            }
        }

        final ContentResolver contentResolver = context.getContentResolver();
        Cursor cursor = contentResolver.query(ContactsContract.Contacts.CONTENT_URI, new String[]{"_id"}, null, null, null);
        List<ContactsInfo> contactsInfos = new ArrayList<>();

        if (cursor != null) {
            //枚举所有联系人的id
            if (cursor.getCount() > 0) {
                L.w("联系人总数量:" + cursor.getCount()); //就是联系人的总数
                int count = 0;
                if (cursor.moveToFirst()) {
                    do {
                        int contactIdIndex = cursor.getColumnIndex(ContactsContract.Contacts._ID);//获取 id 所在列的索引
                        String contactId = cursor.getString(contactIdIndex);//联系人id

                        final List<String> phones = getData1(contentResolver, contactId, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                        if (phones.isEmpty()) {
                            continue;
                        } else {
                            String name;
                            final List<String> names = getData1(contentResolver, contactId, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
                            if (names.isEmpty()) {
                                name = phones.get(0);
                            } else {
                                name = names.get(0);
                            }

                            //相同联系人的不同手机号码视为不同的联系人
                            for (String phone : phones) {
                                // 去除非手机号
                                if (!RegexUtils.isMobileExact(StringUtil.removeBlanks(phone))) {
                                    continue;
                                }
                                ContactsInfo io = new ContactsInfo();
                                io.contactId = contactId;
                                io.name = name;
                                io.phone = StringUtil.removeBlanks(phone);
                                io.letter = String.valueOf(Pinyin.toPinyin(name.charAt(0)).toUpperCase().charAt(0));
                                contactsInfos.add(io);
                            }
                        }

//                    L.e("-------------------------" + count + "----------------------");
//                    L.w("联系人ID:" + contactId);
//                    final String name = getData1(contentResolver, contactId, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
//                    L.w("联系人名称:" + Pinyin.toPinyin(name.charAt(0)).toUpperCase().charAt(0) + " " + name);
//                    L.w("联系人电话:" + getData1(contentResolver, contactId, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE));
//                    logData(contentResolver, contactId);
//                    count++;
                    } while (cursor.moveToNext());
                }
            }
            cursor.close();
        }
        return contactsInfos;
    }

@NonNull
@Override
public ContentProviderOperation.Builder updatedBuilder(TransactionContext transactionContext, @NonNull ContentProviderOperation.Builder builder)
{
    return mDelegate.updatedBuilder(transactionContext, builder)
            .withValue(ContactsContract.CommonDataKinds.Organization.OFFICE_LOCATION, mOfficeLocation == null ? null : mOfficeLocation.toString());
}

@Override
public CEvents getEvents() {

    CEvents cEvents = new CEvents();

    String startData = cursor.getString(
            cursor.getColumnIndex(ContactsContract.CommonDataKinds.Event.START_DATE));

    int type = cursor.getInt(
            cursor.getColumnIndex(ContactsContract.CommonDataKinds.Event.TYPE));

    switch (type) {
        case ContactsContract.CommonDataKinds.Event.TYPE_ANNIVERSARY:
            cEvents.setAnniversay(startData);
            break;

        case ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY:
            cEvents.setBirthDay(startData);
            break;
        default:
            break;
    }

    cEvents.setDisplayName(cursor.getString(
            cursor.getColumnIndex(ContactsContract.CommonDataKinds.Event.DISPLAY_NAME)));

    cEvents.setPhotoUri(cursor.getString(
            cursor.getColumnIndex(ContactsContract.CommonDataKinds.Event.PHOTO_URI)));

    return cEvents;
}

/**
 * 查询数据等操作放在这里执行
 */
@Override
protected Cursor onLoadInBackground() {
    Cursor cursor = mContext.getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,
            mContactProjection, null,null, null);
    return cursor;
}