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

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

/**
 * write and delete contacts info, {@link Manifest.permission#WRITE_CONTACTS}
 * and we should get read contacts permission first.
 *
 * @param activity
 * @return true if success
 * @throws Exception
 */
private static boolean checkWriteContacts(Context activity) throws Exception {
    if (checkReadContacts(activity)) {
        // write some info
        ContentValues values = new ContentValues();
        ContentResolver contentResolver = activity.getContentResolver();
        Uri rawContactUri = contentResolver.insert(ContactsContract.RawContacts
                .CONTENT_URI, values);
        long rawContactId = ContentUris.parseId(rawContactUri);
        values.put(ContactsContract.Contacts.Data.MIMETYPE, ContactsContract.CommonDataKinds
                .StructuredName.CONTENT_ITEM_TYPE);
        values.put(ContactsContract.Contacts.Data.RAW_CONTACT_ID, rawContactId);
        values.put(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, TAG);
        values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, TAG_NUMBER);
        contentResolver.insert(ContactsContract.Data.CONTENT_URI, values);

        // delete info
        Uri uri = Uri.parse("content://com.android.contacts/raw_contacts");
        ContentResolver resolver = activity.getContentResolver();
        Cursor cursor = resolver.query(uri, new String[]{ContactsContract.Contacts.Data._ID},
                "display_name=?", new String[]{TAG}, null);
        if (cursor != null) {
            if (cursor.moveToFirst()) {
                int id = cursor.getInt(0);
                resolver.delete(uri, "display_name=?", new String[]{TAG});
                uri = Uri.parse("content://com.android.contacts/data");
                resolver.delete(uri, "raw_contact_id=?", new String[]{id + ""});
            }
            cursor.close();
        }
        return true;
    } else {
        return false;
    }
}

/**
 * Add a phone to a list of database actions to be performed
 *
 * @param ops the list of database actions
 * @param phone the item to be inserted
 */
private void insertPhone(ArrayList<ContentProviderOperation> ops,
        JSONObject phone) {
    ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
            .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
            .withValue(ContactsContract.Data.MIMETYPE, CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
            .withValue(CommonDataKinds.Phone.NUMBER, getJsonString(phone, "value"))
            .withValue(CommonDataKinds.Phone.TYPE, getPhoneType(getJsonString(phone, "type")))
            .withValue(Phone.LABEL, getJsonString(phone, "type"))
            .build());
}

/**
 * When the system finishes retrieving the Cursor through the CursorLoader,
 * a call to the onLoadFinished() method takes place.
 **/
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor cursor) {
    if(cursor.moveToFirst()){
        do{
            String displayName = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
            String communication = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
            Contact newContact = new Contact(displayName);

            Contact suggestion = new Contact(displayName);
            suggestion.addCommunication(communication);
            mSuggestions.add(suggestion);

            if(!mContacts.contains(newContact)){
                newContact.addCommunication(communication);
                mContacts.add(newContact);
            }else{
                Contact existingContact = mContacts.get(mContacts.indexOf(newContact));
                existingContact.addCommunication(communication);
            }

        }while(cursor.moveToNext());
    }
    if(mContactAdapter != null) {
        mContactAdapter.notifyDataSetChanged();
    }

    setRecyclerView();
    AutoCompleteAdapter adapter = new AutoCompleteAdapter(getContext(),R.layout.cp_suggestion_row, mSuggestions);
    this.mNachoTextView.setAdapter(adapter);
}

public void setOrganization(String org) {
    if (isAndroidContact()) {
        if (androidRawId != null) {
            String select = ContactsContract.Data.CONTACT_ID + "=? AND " + ContactsContract.Data.MIMETYPE + "='" + CommonDataKinds.Organization.CONTENT_ITEM_TYPE + "'";
            String[] args = new String[]{ getAndroidId() };

            if (organization != null) {
                changesToCommit.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                    .withSelection(select, args)
                    .withValue(ContactsContract.Data.MIMETYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
                    .withValue(CommonDataKinds.Organization.COMPANY, org)
                    .build());
            } else {
                changesToCommit.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                    .withValue(ContactsContract.Data.RAW_CONTACT_ID, androidRawId)
                    .withValue(ContactsContract.Data.MIMETYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
                    .withValue(CommonDataKinds.Organization.COMPANY, org)
                    .build());
            }
        } else {
            changesToCommit.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
                .withValue(ContactsContract.Data.MIMETYPE, CommonDataKinds.Organization.CONTENT_ITEM_TYPE)
                .withValue(CommonDataKinds.Organization.COMPANY, org)
                .build());
        }
    }

    organization = org;
}

private void readContacts(Cursor cursor) {
    mContacts.clear();
    mContactsByLookupKey.clear();
    mNrOfSelectedContacts = 0;

    int count = 0;
    if (cursor.moveToFirst()) {
        cursor.moveToPrevious();
        while (cursor.moveToNext()) {
            ContactImpl contact = ContactImpl.fromCursor(cursor);
            mContacts.add(contact);

            // LOOKUP_KEY is the one we use to retrieve the contact when the contact details are loaded
            String lookupKey = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY));
            mContactsByLookupKey.put(lookupKey, contact);

            boolean isChecked = mSelectedContactIds.contains(contact.getId());
            contact.setChecked(isChecked, true);
            mNrOfSelectedContacts += isChecked ? 1 : 0;

            contact.addOnContactCheckedListener(mContactListener);

            // update the ui once some contacts have loaded
            if (++count >= BATCH_SIZE) {
                sortAndPostCopy(mContacts);
                count = 0;
            }
        }
    }

    if (count > 0) {
        sortAndPostCopy(mContacts);
    }

    updateTitle();
}

public Map<String,String> ReadKontakte(ContentResolver cr) {
    Cursor cursor = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
    Map<String,String> alContacts = new HashMap<String,String>();
    if(cursor.moveToFirst())
    {
        do
        {
            String id = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts._ID));

            if(Integer.parseInt(cursor.getString(cursor.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);
                while (pCur.moveToNext())
                {
                    String contactNumber = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
                    //String contactNumber = "11111111";
                    String name = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
                    //Invalid key: Dr. Jakob Ott. Keys must not contain '/', '.', '#', '$', '[', or ']'
                    name = name.replace(".", "");
                    name = name.replace("/", "");
                    name = name.replace("#", "");
                    name = name.replace("$", "");
                    name = name.replace("[", "");
                    name = name.replace("]", "");
                    contactNumber = contactNumber.replace(" ", "");
                    contactNumber = standardisiereAUT(contactNumber);       // fügt +43 an alles
                    alContacts.put(name, contactNumber);
                    break;
                }
                pCur.close();
            }
        } while (cursor.moveToNext()) ;
    }
    return alContacts;
}

public static ArrayList<String> readContacts(ContentResolver contentResolver) {
  long startTime;
  long endTime;
  ArrayList<String> contactsList = new ArrayList<>();
  startTime = System.currentTimeMillis();
  Timber.d(String.valueOf("CONTACTS-SYNC : START- TIME" + startTime));

  Cursor phones =
      contentResolver.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, null, null,
          null);
  if (phones != null) {
    while (phones.moveToNext()) {
      String phoneNumber =
          phones.getString(phones.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
      if (!contactsList.contains(RegexHandler.removeSpecialCharacters(phoneNumber))) {
        contactsList.add(RegexHandler.removeSpecialCharacters(phoneNumber));
      }
      Timber.d(String.valueOf(phoneNumber + " size: " + contactsList.size()));
    }
    phones.close();
    endTime = System.currentTimeMillis();
    Timber.d(String.valueOf("CONTACTS-SYNC : END- TIME : " + endTime));
    Timber.d(String.valueOf("CONTACTS-SYNC : START- TIME : " + startTime));
    Timber.d(String.valueOf("CONTACTS-SYNC : ELAPSED- TIME : " + (endTime - startTime) / 6000));
    return contactsList;
  }
  return contactsList;
}

@NonNull
@Override
public Cursor rows(@NonNull UriParams uriParams, @NonNull Projection<ContactsContract.RawContacts> projection, @NonNull Predicate predicate, @NonNull Optional<String> sorting) throws RemoteException
{
    return mDelegate.rows(uriParams,
            projection,
            new AllOf(predicate, new IsNull(ContactsContract.RawContacts.ACCOUNT_NAME), new IsNull(ContactsContract.RawContacts.ACCOUNT_TYPE)), sorting);
}

private void createLinphoneContactTag() {
    ArrayList<ContentProviderOperation> batch = new ArrayList<ContentProviderOperation>();

    batch.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
        .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, ContactsManager.getInstance().getString(R.string.sync_account_type))
        .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, ContactsManager.getInstance().getString(R.string.sync_account_name))
        .withValue(ContactsContract.RawContacts.AGGREGATION_MODE, ContactsContract.RawContacts.AGGREGATION_MODE_DEFAULT)
        .build());

    batch.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
        .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
        .withValue(ContactsContract.Data.MIMETYPE, CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
        .withValue(CommonDataKinds.StructuredName.DISPLAY_NAME, getFullName())
        .build());

    batch.add(ContentProviderOperation.newUpdate(ContactsContract.AggregationExceptions.CONTENT_URI)
        .withValue(ContactsContract.AggregationExceptions.TYPE, ContactsContract.AggregationExceptions.TYPE_KEEP_TOGETHER)
        .withValue(ContactsContract.AggregationExceptions.RAW_CONTACT_ID1, androidRawId)
        .withValueBackReference(ContactsContract.AggregationExceptions.RAW_CONTACT_ID2, 0)
        .build());

    if (changesToCommit2.size() > 0) {
        for(ContentProviderOperation cpo : changesToCommit2) {
            batch.add(cpo);
        }
    }

    try {
        ContactsManager.getInstance().getContentResolver().applyBatch(ContactsContract.AUTHORITY, batch);
        androidTagId = findLinphoneRawContactId();
    } catch (Exception e) {
        Log.e(e);
    }
}