Android完整的通讯录获取多个手机号码、多个邮箱、多个地址、生日、备份等信息的代码

于 2021-10-18 14:41:33 发布
阅读量3.2k 收藏 1
点赞数 1
分类专栏： 通讯录 android 文章标签： android 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32324617/article/details/120825597
版权

Android完整的通讯录获取多个手机号码、多个邮箱、多个地址、生日、备份等信息的代码

整个删除通讯录

方法一：
 //删除整个通讯录
    public static void deleteAllContacts(Context context) {
        ContentResolver cr = context.getContentResolver();
        Uri uri4 = ContactsContract.RawContacts.CONTENT_URI.buildUpon().appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true").build();
        cr.delete(uri4, null, null);
        }
方法二：
 //删除整个通讯录
    public static void deleteAllContacts(Context context) {
        ContentResolver cr = context.getContentResolver();
        // 查询contacts表的所有记录
        Cursor cursor = cr.query(ContactsContract.Contacts.CONTENT_URI, null,
                null, null, null);
        // 如果记录不为空
        if (cursor.getCount() > 0) {
            // 游标初始指向查询结果的第一条记录的上方，执行moveToNext函数会判断
            // 下一条记录是否存在，如果存在，指向下一条记录。否则，返回false。
            while (cursor.moveToNext()) {
                //	String rawContactId = "";
                // 从Contacts表当中取得ContactId
//    				String id = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts._ID));

                @SuppressLint("Range") String name = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));

                //根据姓名求id
                Uri uri = Uri.parse("content://com.android.contacts/raw_contacts");

                Cursor cursor1 = cr.query(uri, new String[]{ContactsContract.Data._ID}, "display_name=?", new String[]{name}, null);
                if (cursor1.moveToFirst()) {
                    int id = cursor1.getInt(0);
                    //根据id删除data中的相应数据
                    cr.delete(uri, "display_name=?", new String[]{name});
                    uri = Uri.parse("content://com.android.contacts/data");
                    cr.delete(uri, "raw_contact_id=?", new String[]{id + ""});
                 }
                cursor1.close();
             }
          }
          cursor.close();
        }
获取通讯录姓名、id、多个手机号码、多个邮箱、多个地址、生日、备注信息
 private static List<ContactsBean> list;

    @SuppressLint("Range")
    public static void fetchContact(Context context) {
        list = new ArrayList<>();

        ContentResolver cr = context.getContentResolver();
        Cursor cur = cr.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));
                String name = cur.getString(cur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));

                ContactsBean contactClass = new ContactsBean();
                contactClass.id = id;
                contactClass.name = 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);

                    contactClass.phone = new ContactsBean.Phone();
                    //获取手机号码
                    while (pCur.moveToNext()) {
                        String phoneNo = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
                        int type = pCur.getInt(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.TYPE));

                        switch (type) {
                            case ContactsContract.CommonDataKinds.Phone.TYPE_HOME:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.home = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }
                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.mobile1 = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }

                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_WORK:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.work = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }

                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.faxhome = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }

                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_FAX_WORK:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.faxwork = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }

                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_MAIN:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.main = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }

                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_OTHER:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.other = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }

                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_CUSTOM:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.custom = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }

                                break;
                            case ContactsContract.CommonDataKinds.Phone.TYPE_PAGER:
                                try {
                                    if (phoneNo.equals("") || phoneNo != null) {
                                        contactClass.phone.pager = phoneNo;
                                    }
                                } catch (Exception e) {
                                    Log.d(TAG, e.toString());
                                }
                                break;
                        }
                    }
                    pCur.close();
                }

                //获取邮箱地址
                Cursor emailCur = cr.query(ContactsContract.CommonDataKinds.Email.CONTENT_URI, null,
                        ContactsContract.CommonDataKinds.Email.CONTACT_ID + " = " + id, null, null);
                if (emailCur.getCount() > 0) {
                    contactClass.email = new ContactsBean.Email();
                    while (emailCur.moveToNext()) {
                        int emailType = emailCur.getInt(emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.TYPE));
                        String email = emailCur.getString(emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA));
                        switch (emailType) {
                            case ContactsContract.CommonDataKinds.Email.TYPE_HOME:
                                contactClass.email.home = email;
                                break;
                            case ContactsContract.CommonDataKinds.Email.TYPE_WORK:
                                contactClass.email.work = email;
                                break;
                            case ContactsContract.CommonDataKinds.Email.TYPE_OTHER:
                                contactClass.email.other = email;
                                break;
                            case ContactsContract.CommonDataKinds.Email.TYPE_MOBILE:
                                contactClass.email.mobile = email;
                                break;
                            default:
                                throw new IllegalStateException("Unexpected value: " + emailType);
                        }
                        Log.e(TAG, " emailType： " + emailType + "  email： " + email);
                    }
                }
                emailCur.close();

                // 获取该联系人地址
                Cursor addressCur = cr.query(ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_URI, null,
                        ContactsContract.CommonDataKinds.StructuredPostal.CONTACT_ID + " = " + id, null, null);
                if (addressCur.getCount() > 0) {
                    contactClass.address = new ContactsBean.Address();
                    while (addressCur.moveToNext()) {
                        // 遍历所有的地址
                        String country = addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY));
                        String city = addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.CITY));
                        String street = addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.STREET));
                        String region = addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.REGION));
                        String postCode = addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE));
                        String formatAddress = addressCur.getString(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS));
                        int addressType = addressCur.getInt(addressCur.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.TYPE));
                        switch (addressType) {
                            case ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME:
                                contactClass.address.home = new ContactsBean.Address.AddressInfo();
                                contactClass.address.home.country = country;
//                                contactClass.address.home.province = region;
                                contactClass.address.home.city = city;
                                contactClass.address.home.street = street;
                                contactClass.address.home.region = region;
                                contactClass.address.home.postalCode = postCode;
                                contactClass.address.home.formatAddress = formatAddress;
                                break;
                            case ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK:
                                contactClass.address.work = new ContactsBean.Address.AddressInfo();
                                contactClass.address.work.country = country;
//                                contactClass.address.work.province = region;
                                contactClass.address.work.city = city;
                                contactClass.address.work.street = street;
                                contactClass.address.work.region = region;
                                contactClass.address.work.postalCode = postCode;
                                contactClass.address.work.formatAddress = formatAddress;
                                break;
                            case ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER:
                                contactClass.address.other = new ContactsBean.Address.AddressInfo();
                                contactClass.address.other.country = country;
//                                contactClass.address.other.province = region;
                                contactClass.address.other.city = city;
                                contactClass.address.other.street = street;
                                contactClass.address.other.region = region;
                                contactClass.address.other.postalCode = postCode;
                                contactClass.address.other.formatAddress = formatAddress;
                                break;
                            default:
                                break;
                        }

                        Log.e(TAG, " country :" + country + " city： " + city + "  street： " + street +
                                "  region： " + region + " postCode： " + postCode + "  formatAddress： " + formatAddress);

                        Log.e(TAG, "addressType : " + addressType);
                    }
                }
                addressCur.close();
                //获取生日
                String[] columns = {ContactsContract.CommonDataKinds.Event.START_DATE,
                        ContactsContract.CommonDataKinds.Event.TYPE,
                        ContactsContract.CommonDataKinds.Event.MIMETYPE};

                String where = ContactsContract.CommonDataKinds.Event.TYPE + "=" + ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY +
                        " and " + ContactsContract.CommonDataKinds.Event.MIMETYPE + " = '" + ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE
                        + "' and " + ContactsContract.Data.CONTACT_ID + " = " + id;

                String sortOrder = ContactsContract.Contacts.DISPLAY_NAME;
                Cursor birthdayCur = cr.query(ContactsContract.Data.CONTENT_URI, columns, where, null, sortOrder);

                if (birthdayCur.getCount() > 0) {
                    while (birthdayCur.moveToNext()) {
                        String birthday = birthdayCur.getString(birthdayCur.getColumnIndex(ContactsContract.CommonDataKinds.Event.START_DATE));
                        int birthdayType = birthdayCur.getInt(birthdayCur.getColumnIndex(ContactsContract.CommonDataKinds.Event.TYPE));
                        Log.e(TAG, "birthday : " + birthday + "  birthdayType: " + birthdayType);
                        contactClass.birthday_g = birthday;
                    }
                    birthdayCur.close();
                }

                // 获取备注信息
                Cursor noteCur = cr.query(ContactsContract.Data.CONTENT_URI,
                        new String[]{ContactsContract.Data._ID, ContactsContract.CommonDataKinds.Note.NOTE},
                        ContactsContract.Data.CONTACT_ID + "=?" + " AND " + ContactsContract.Data.MIMETYPE + "='"
                                + ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE + "'", new String[]{id}, null);

                if (noteCur.getCount() > 0) {
                    while (noteCur.moveToNext()) {
                        String note = noteCur.getString(noteCur.getColumnIndex(ContactsContract.CommonDataKinds.Note.NOTE));
                        Log.e(TAG, "note: " + note);
                        contactClass.remark = note;
                    }
                }
                noteCur.close();

                list.add(contactClass);
            }

            //FastJson， list集合序列化为json格式的字符串
            String s = JSON.toJSONString(list);
            Log.e(TAG, s);
        }
        cur.close();
    }
插入多个手机号码、邮箱、地址等信息
/**
     * 向系统通讯录插入数据
     */
    public static void addContact(Context context, ContactsBean contactsBean) {
        ContentValues values = new ContentValues();

        // 向RawContacts.CONTENT_URI空值插入，
        // 先获取Android系统返回的rawContactId
        // 后面要基于此id插入值
        ContentResolver cr = context.getContentResolver();
        Uri rawContactUri = cr.insert(ContactsContract.RawContacts.CONTENT_URI, values);
        long rawContactId = ContentUris.parseId(rawContactUri);
        values.clear();

        values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
        // 内容类型
        values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
        // 联系人名字
        values.put(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, contactsBean.name);
        // 向联系人URI添加联系人名字
        cr.insert(ContactsContract.Data.CONTENT_URI, values);
//        values.clear();

        //插入电话号码
        if (contactsBean.phone != null) {
            if (contactsBean.phone.mobile1 != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.mobile1);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.mobile2 != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.mobile2);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.home != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.home);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_HOME);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.work != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.work);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_WORK);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.faxhome != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.faxhome);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.faxwork != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.faxwork);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_FAX_WORK);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.main != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.main);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MAIN);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.other != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.other);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_OTHER);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.custom != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.custom);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_CUSTOM);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
            if (contactsBean.phone.pager != null) {
                values.clear();
                values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
                // 联系人的电话号码
                values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, contactsBean.phone.pager);
                // 电话类型
                values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_PAGER);
                // 向联系人电话号码URI添加电话号码
                cr.insert(ContactsContract.Data.CONTENT_URI, values);

            }
        }

        //插入地址
        if (contactsBean.address != null) {
            if (contactsBean.address.home != null) {
                values.clear();
                values.put(Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.TYPE, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, contactsBean.address.home.country);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.CITY, contactsBean.address.home.city);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.REGION, contactsBean.address.home.region);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.STREET, contactsBean.address.home.street);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, contactsBean.address.home.postalCode);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, contactsBean.address.home.formatAddress);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }

            if (contactsBean.address.work != null) {
                values.clear();
                values.put(Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.TYPE, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, contactsBean.address.work.country);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.CITY, contactsBean.address.work.city);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.REGION, contactsBean.address.work.region);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.STREET, contactsBean.address.work.street);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, contactsBean.address.work.postalCode);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, contactsBean.address.work.formatAddress);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }

            if (contactsBean.address.other != null) {
                values.clear();
                values.put(Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.TYPE, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, contactsBean.address.other.country);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.CITY, contactsBean.address.other.city);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.REGION, contactsBean.address.other.region);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.STREET, contactsBean.address.other.street);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, contactsBean.address.other.postalCode);
                values.put(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS, contactsBean.address.other.formatAddress);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
        }

        //插入邮箱
        if (contactsBean.email != null) {
            if (contactsBean.email.home != null) {
                values.clear();
                values.put(Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.Email.DATA, contactsBean.email.home);
                values.put(Email.TYPE, Email.TYPE_HOME);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }

            if (contactsBean.email.work != null) {
                values.clear();
                values.put(Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.Email.DATA, contactsBean.email.work);
                values.put(Email.TYPE, Email.TYPE_WORK);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }

            if (contactsBean.email.other != null) {
                values.clear();
                values.put(Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.Email.DATA, contactsBean.email.other);
                values.put(Email.TYPE, Email.TYPE_OTHER);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }

            if (contactsBean.email.mobile != null) {
                values.clear();
                values.put(Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.Email.DATA, contactsBean.email.mobile);
                values.put(Email.TYPE, Email.TYPE_MOBILE);
                cr.insert(ContactsContract.Data.CONTENT_URI, values);
            }
        }

        //插入生日
        if (contactsBean.birthday_g != null) {
            values.clear();
            values.put(Data.RAW_CONTACT_ID, rawContactId);
            values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE);
            values.put(ContactsContract.CommonDataKinds.Event.TYPE, ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY);
            values.put(ContactsContract.CommonDataKinds.Event.START_DATE, contactsBean.birthday_g);
            cr.insert(ContactsContract.Data.CONTENT_URI, values);
        }

        //插入备注
        if (contactsBean.remark != null) {
            values.clear();
            values.put(ContactsContract.Data.RAW_CONTACT_ID, rawContactId);
            values.put(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE);
            values.put(ContactsContract.CommonDataKinds.Note.NOTE, contactsBean.remark);
            cr.insert(ContactsContract.Data.CONTENT_URI, values);
        }
    }

    //插入所有通讯录信息
    public static void insertContact(Context context) {
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                addContact(context, list.get(i));
            }
            list.clear();
        }
    }
ContactsBean， Mode定义
public class ContactsBean implements Serializable {
    public String id;
    public String name;
    public Phone phone;
    public Address address;
    public Email email;

    public static class Phone implements Serializable {
        public String mobile1;
        public String mobile2;
        public String mobile3;
        public String home;
        public String work;
        public String faxhome;
        public String faxwork;
        public String main;
        public String other;
        public String custom;
        public String pager;
    }

    public static class Email implements Serializable {
        public String home;
        public String work;
        public String mobile;
        public String other;
    }

    public static class Address implements Serializable {
        public AddressInfo home;
        public AddressInfo work;
        public AddressInfo other;

        public static class AddressInfo implements Serializable{
            public String country;//国家
            public String province;//省
            public String city;//城市
            public String region;//区
            public String street;//街道
            public String postalCode;//邮编
            public String formatAddress;//完整地址
        }
    }

    public String birthday_g;//公历生日
    public String birthday_l;//农历生日
    public String remark;//备注
}
( 持续更新，目前含 200+ 工具类 ) DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。
afkT 的博客
09-24 5270
About DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。 该项目尽可能的便于开发人员，快捷、快速开发安全可靠的项目，以及内置部分常用的资源文件，如color.xml、(toast) layout.xml等 Gradle Step 1. Add the JitPack repository to your build fil...
Android 完整的通讯录项目源码
05-17
Android 完整的通讯录项目源码 Android 完整的通讯录项目源码 Android 完整的通讯录项目源码
安卓获取电话本数据并且获取同一个联系人下多个号码
liufatao的博客
06-13 775
ContactInfo 是自己封装的实体对象可以按自己的需求进行封装 思路：通过数据库查询所有联系人 获取到数据库唯一标识ID，获取到联系人名称 查询联系人号码是否为空如果不为空 查询当前ID号下面有多少电话号码 全部装入到list中 需要在做联系人号码类型的可以在这里进行判断我这边没有这个需求只需要知道这个联系人有多少个号码就行了，在两个循环结束后 添加联系人名称添加联系人多号码列表 /** * 获取联系人列表 * * @return 联系人列表 */ ...
android 获取通讯录中同一联系人的多个号码
qq_30083021的博客
08-31 2054
public static void fetchContact(Context context) { List&lt;ContactsBean&gt; list = new ArrayList&lt;&gt;(); ContentResolver cr = context.getContentResolver(); Cursor cur = cr.query(Conta...
手机sim 卡 联系人获取
xcw931924821的专栏
11-20 1708
问答 | 交流群 | 讲座 | 月刊 | iProcess | uml.org.cn | 网站地图
Android软件开发之获取通讯录联系人信息（二十九）
mmdev
08-30 482
Android软件开发之获取通讯录联系人信息 雨松MOMO原创文章如转载，请注明：转载自雨松MOMO的博客原文地址:http://blog.csdn.net/xys289187120/article/details/6730957 Android手机的通讯录联系人全部都存在系统的数据库中，如果须要获得通讯里联系人的信息就须要访问系统的数据库，才能将信息拿出来。 这一篇文章...
手机通讯录备份代码实现一
琦琦的博客
11-13 807
手机通讯录备份还原四___综合一 import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputS...
Android通讯录管理系统开发教程
1. 联系人信息的添加、编辑和删除：用户可以创建新的联系人条目，包括姓名、电话号码、电子邮箱、地址等信息。也可以编辑现有联系人信息或者删除不再需要的联系人。 2. 联系人的分类和管理：系统可能提供按姓名、...
tongxunlu.rar_通讯录
09-24
用户可以输入联系人的姓名、电话号码、电子邮箱、地址等信息，并对这些信息进行快速查看和修改。此外，程序可能还支持导入和导出联系人数据，方便在不同设备间进行同步。 2. 分类与标签：为了帮助用户更好地组织...
【毕业设计心得分享】：构建Android通讯录项目的心得体会
本文对一个Android通讯录项目进行了全面的分析与开发实践，涵盖了从项目概述到功能模块开发、数据持久化处理、测试与优化以及项目总结与反思的全过程。在理论基础与技术选型章节中，详细介绍了Android开发环境的搭建...
【毕业设计实践指南】：全面解读实用的Android通讯录设计之道
![【毕业设计实践指南】：全面解读...本文详细介绍了Android通讯录项目的规划、设计与实现过程，涵盖了从理论基础到高级功能的完整开发流程。首先，文章概述了项目背景及Android平台架构，并探讨了通讯录数据模型和安
Android源码通讯录的开发_完整代码.zip
最新发布
05-14
Android源码通讯录的开发_完整代码.zip
Android获取联系人（一人多号）
dongkui_的博客
09-19 369
/** * Created on 2019/3/20. * * @author dk * 联系人的实体类 */ public class ReadContactsUtils { private Uri phoneUri = ContactsContract.Contacts.CONTENT_URI; // 联系人提供者的uri private fin...
Android读取通讯录数据
panshi5188的博客
04-01 3259
第一步，配置权限 <uses-permission android:name="android.permission.READ_CONTACTS" /><!-- 读取联系人 --> <uses-permission android:name="android.permission.WRITE_CONTACTS" /> 如果需要存储，还需要存储权限 ...
安卓——读取到手机通讯录中的好友的备注信息
小雨的专栏
12-09 3846
奇葩需求 - 读取到手机通讯录中的好友的备注信息
android 手机号分段_android开发中想获取双卡手机号码，两个号码的怎样获取?
weixin_39978276的博客
12-20 1028
展开全部Android的官方文档是32313133353236313431303231363533e58685e5aeb931333337626230没有提供相应的Api的，因为标准的Andoird是没有双卡的，好像也只有国内才会搞双卡双待的神器吧。以下记录一下做这个功能所学习到的东西。直接上代码：import java.lang.reflect.InvocationTargetException...
Android 笔记：获取本机手机号(适用于双卡双待手机)
陈果的博客
11-30 1万+
获取当前手机号码 双卡双待
Android获取手机联系人的基本信息（如姓名、电话、邮箱、备注）
weixin_37587365的博客
10-24 1万+
在做项目的过程中，需要获取我们手机通讯录联系人的基本信息，如姓名、电话、邮箱、备注、昵称、公司、职位、家庭电话等等信息，下面就是我总结的一些具体方法。 1：首先读取联系人需要添加读取权限，6.0以上需要动态获取权限） 1.1AndroidManifest.xml 文件添加: <uses-permission android:name="android.permission.READ_E......
Android-->获取所有联系人以及所有的字段(联系人头像,邮箱,地址,公司等)
热门推荐
<angcyo>菜鸟视角
08-11 1万+
本文测试平台: Android 6.0 , API 23辅助阅读: Android官网有关联系人的开发指南: https://developer.android.com/guide/topics/providers/contacts-provider.html相关API: https://developer.android.com/reference/android/provider/Cont
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值