精华内容
下载资源
问答
  • android手机通讯录备份还原代码

    热门讨论 2011-11-01 09:02:10
    最近想写段android程序玩玩。 开发环境 eclipse ,android2.2 ...1.把通讯录中的联系人,电话号码保存到txt文件中完成备份。 2.读取txt文件,导入到通讯录完成还原。 具体代码 1.添加 通讯录读写权限,存储卡写权限 ...
  • 手机通讯录备份代码实现一和二的思路是通过 备份: while循环找到contact_id然后根据id找对应联系人所有电话和邮箱. 还原: 获取联系人列表通过for循环,一个一个插入手机通讯录 这两种方式的弊端是 备份速度太慢,查询...

    前言

    手机通讯录备份代码实现一和二的思路是通过
    备份:
    while循环找到contact_id然后根据id找对应联系人所有电话和邮箱.
    还原:
    获取联系人列表通过for循环,一个一个插入手机通讯录

    这两种方式的弊端是
    备份速度太慢,查询数据库太多次.
    还原 没有进行批量插入,插入的速度也非常慢.

    下面的方法查询手机500条联系人数据,组成一个对象,只需要2s左右(测试手机华为mate 20),还原手机通讯录的时间也比之前缩短很多.

    思路:

    备份:

    1 查询所有联系人
    2查询所有联系人
    3 查询所有邮箱
    然后三者合并

    还原:

    用ContentProviderOperation对象批量处理

    代码实现
    List<ContactListBean> contactListBeanList =   getContactName(MainActivity.this);
    
            List<PhoneListBean> phoneList =  getContactPhone(MainActivity.this);
    
            List<EmailListBean> emailListBeans  = getContactEmail(MainActivity.this);
    
            calculate(contactListBeanList,phoneList,emailListBeans);
    
       private  List<ContactListBean>   getContactName(Activity context) {
            Cursor cur = context.getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, PROJECTION,
                    null, null, null);
    
            List<ContactListBean> contactListBeanList = new ArrayList<>();
            if (cur != null) {
    
                final int displayNameIndex = cur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
                final int hasPhoneNumberIndex = cur.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER);
                while (cur.moveToNext()) {
                    ContactListBean contactListBean = new ContactListBean();
                    String displayName = cur.getString(displayNameIndex);
                    int phoneCount = cur.getInt(hasPhoneNumberIndex);
                    contactListBean.setContactsName(displayName);
                    contactListBean.setHasPhoneNumber(phoneCount > 0);
                    contactListBean.setPhoneList(new ArrayList<PhoneListBean>());
                    contactListBean.setEmailList(new ArrayList<EmailListBean>());
                    contactListBeanList.add(contactListBean);
                }
                cur.close();
    //            calculate(contactListBeanList, null, null);
            }
            return contactListBeanList;
        }
    
        private  List<PhoneListBean>  getContactPhone(Activity context) {
            List<PhoneListBean> phoneList = new ArrayList<>();
            Cursor phonesCursor = context.getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
                    PROJECTIONPHONE, null,
                    null, null);
            if (phonesCursor != null) {
                final int numberIndex = phonesCursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER);
                final int numberTypeIndex = phonesCursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.TYPE);
                final int displayNameIndex = phonesCursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
                while (phonesCursor.moveToNext()) {
                    PhoneListBean phoneListBean = new PhoneListBean();
    
    
                    String phoneNumber = phonesCursor.getString(numberIndex);
                    int type = phonesCursor.getInt(numberTypeIndex);
                    String displayName = phonesCursor.getString(displayNameIndex);
    
                    phoneListBean.setType(type);
                    phoneListBean.setNumber(phoneNumber);
                    phoneListBean.contactsName=displayName;
                    phoneList.add(phoneListBean);
                }
                phonesCursor.close();
            }
            return phoneList;
    //        calculate(null, phoneList, null);
        }
    
        private  List<EmailListBean>  getContactEmail(Activity context) {
            //邮箱
            List<EmailListBean> emailListBeans = new ArrayList<>();
            Cursor emailCur = context.getContentResolver().query(ContactsContract.CommonDataKinds.Email.CONTENT_URI, PROJECTIONEMAIL,
                    null, null, null);
            if (emailCur != null) {
                if (emailCur.getCount() > 0) {
                    final int displayNameIndex = emailCur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);
                    final int emailIndex = emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA1);
                    final int emailTypeIndex = emailCur.getColumnIndex(ContactsContract.CommonDataKinds.Email.TYPE);
    
                    while (emailCur.moveToNext()) {
                        EmailListBean emailListBean = new EmailListBean();
    
                        String email = emailCur.getString(emailIndex);
                        int type = emailCur.getInt(emailTypeIndex);
                        String displayName = emailCur.getString(displayNameIndex);
    
                        emailListBean.setEmail(email);
                        emailListBean.setType(type);
                        emailListBean.contactsName= displayName;
                        emailListBeans.add(emailListBean);
                    }
                }
                emailCur.close();
            }
            return emailListBeans;
    //        calculate(null, null, emailListBeans);
        }
    
        List<ContactListBean> contactListBeanListTemp;
        List<PhoneListBean> phoneListTemp;
        List<EmailListBean> emailListBeansTemp;
        private boolean isEnableCalculate=true;
    
        private synchronized void calculate(List<ContactListBean> contactListBeanList,
                                            List<PhoneListBean> phoneList,
                                            List<EmailListBean> emailListBeans) {
            if (contactListBeanListTemp == null) {
                contactListBeanListTemp = contactListBeanList;
            }
            if (phoneListTemp == null) {
                phoneListTemp = phoneList;
            }
            if (emailListBeansTemp == null) {
                emailListBeansTemp = emailListBeans;
            }
    
            if (contactListBeanListTemp != null && phoneListTemp != null && emailListBeansTemp != null) {
                Log.e(TAG, "contactListBeanListTemp.size" + contactListBeanListTemp.size() + "---" + phoneListTemp.size()
                        + "---" + emailListBeansTemp.size());
                for (ContactListBean contactListBean : contactListBeanListTemp) {
                    for (PhoneListBean phoneListBean : phoneListTemp) {
                        if(contactListBean.getContactsName().equals(phoneListBean.contactsName)){
                            if(contactListBean.isHasPhoneNumber()){
                                phoneListBean.contactsName=null;
                                contactListBean.getPhoneList().add(phoneListBean);
                            }
                        }
    
                    }
    
                    for (EmailListBean emailListBean : emailListBeansTemp) {
                        if( contactListBean.getContactsName().equals(emailListBean.contactsName)){
                            emailListBean.contactsName=null;
                            contactListBean.getEmailList().add(emailListBean);
                        }
    
                    }
                }
                String json = new Gson().toJson(contactListBeanListTemp);
                String jsonStr =  new Gson().toJson(json);
                Log.e(TAG, "contactListBeanListTemp.size" + contactListBeanListTemp.size());
    
            }
    
        }
    
    还原代码实现

    如果还原的数据有联系人没有手机号,默认用更新update方法,这样通讯录不会还原的时候多数据

       Test  test = getAssetFile();
            List<ContactListBean> contactListBeanList =  test.getContactList();
            insertContact(contactListBeanList);
    
       public int insertContact(List<ContactListBean> contactListBeanList) {
            boolean isCloudExitPhone = false;
            if (contactListBeanList == null || contactListBeanList.size() == 0) {
                return 0;
            }
            ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
            int rawContactInsertIndex = 0;
            int resutl = 0;
            for (ContactListBean contactListBean : contactListBeanList) {
                rawContactInsertIndex = ops.size();
                isCloudExitPhone = isCloudExistPhone(contactListBean);
                if (isCloudExitPhone) {
                    ops.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
                            .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null)
                            .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null)
                            .withYieldAllowed(true)
                            .build());
                } else {
    //                //update会新增数据,例如本地存在一个没有手机号的联系人,会新增进入
                    ops.add(ContentProviderOperation.newUpdate(ContactsContract.RawContacts.CONTENT_URI)
                            .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null)
                            .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null)
                            .withYieldAllowed(true)
                            .build());
                }
                //写入姓名
                if (!TextUtils.isEmpty(contactListBean.getContactsName())) {
                    ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                            .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                            .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
                            .withValue(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, contactListBean.getContactsName())
                            .withYieldAllowed(true)
                            .build());
                }
                //写入电话
                List<PhoneListBean> phoneList = contactListBean.getPhoneList();
                if (phoneList != null && phoneList.size() > 0) {
                    for (PhoneListBean phoneListBean : phoneList) {
                        if(!TextUtils.isEmpty(phoneListBean.getNumber())){
                            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                                    .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE)
                                    .withValue(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE)
                                    .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, phoneListBean.getNumber())
                                    .withYieldAllowed(true)
                                    .build());
                        }
                    }
                }
                //写入邮箱
                List<EmailListBean> emailList = contactListBean.getEmailList();
                if (emailList != null && emailList.size() > 0) {
                    for (EmailListBean emailListBean : emailList) {
                        //插入Email
                        if(!TextUtils.isEmpty(emailListBean.getEmail())){
                            ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
                                    .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactInsertIndex)
                                    .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
                                    .withValue(ContactsContract.CommonDataKinds.Email.ADDRESS, emailListBean.getEmail())
                                    .withValue(ContactsContract.CommonDataKinds.Email.TYPE, ContactsContract.CommonDataKinds.Email.TYPE_WORK)
                                    .withYieldAllowed(true)
                                    .build());
                        }
                    }
    
                }
            }
    
            try {
                ContentProviderResult[] results = getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
    //            if (results != null && results.length > 0) {
    //                for (ContentProviderResult result : results) {
    //                    Log.e(TAG, "URI:" + result.uri + "count:" + result.count);
    //                }
    //                resutl++;
    //            }
                Log.e(TAG, "results.length==" + results.length);
            } catch (RemoteException | OperationApplicationException e) {
                Log.e(TAG, "e.toString()==" + e.toString());
                e.printStackTrace();
            }
    
    
            return resutl;
        }
    
        private static boolean isCloudExistPhone(ContactListBean contactListBean) {
            if (contactListBean.getPhoneList() == null ||
                    contactListBean.getPhoneList().size() == 0
    
            ) {
    
                return false;
            }
    
            if(TextUtils.isEmpty(contactListBean.getPhoneList().get(0).getNumber())){
                return false;
            }
    
            return true;
    
        }
    
    
    

    源代码源https://download.csdn.net/download/qq_26296197/11974840

    展开全文
  • android通讯录备份与还原

    热门讨论 2011-07-08 18:19:52
    实现简单android通讯录备份与还原,网上这方面的资料很少,贴出来分享给有需要的朋友,支持2.0以上版本
  • android通讯录备份恢复 新增和修改 目前用的是新增,云端判断返回的手机号是否为空 /** * 向手机中录入联系人信息 * * @param contactListBean 要录入的联系人信息 */ public void addContacts...

    android通讯录备份恢复
    新增和修改

    目前用的是新增,云端判断返回的手机号是否为空

       /**
         * 向手机中录入联系人信息
         *
         * @param contactListBean 要录入的联系人信息
         */
    
        public void addContacts(ContactListBean contactListBean) {
    
            try {
    
                ContentValues values = new ContentValues();
                //首先向RawContacts.CONTENT_URI执行一个空值插入,目的是获取系统返回的rawContactId
                Uri rawContactUri = getContentResolver().insert(ContactsContract.RawContacts.CONTENT_URI, values);
                long rawContactId = ContentUris.parseId(rawContactUri);
    
                //往data表入姓名数据
                values.clear();
                values.put(ContactsContract.RawContacts.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.RawContacts.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
                values.put(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, contactListBean.getContactsName());
                getContentResolver().insert(
                        android.provider.ContactsContract.Data.CONTENT_URI, values);
    
                values.clear();
                values.put(android.provider.ContactsContract.Contacts.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.RawContacts.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
    
                // 获取联系人电话信息
                List<PhoneListBean> phoneList = contactListBean.getPhoneList();
                /** 录入联系电话 */
                for (PhoneListBean phoneInfo : phoneList) {
                    if(TextUtils.isEmpty(phoneInfo.getNumber())){
                        continue;
                    }
                    // 设置录入联系人电话信息
                    values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, phoneInfo.getNumber());
    //            values.put(ContactsContract.CommonDataKinds.Phone.TYPE, phoneInfo.getType());
                    values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE);
                    // 往data表入电话数据
                    getContentResolver().insert(
                            android.provider.ContactsContract.Data.CONTENT_URI, values);
                }
    
    //        // 获取联系人邮箱信息
    //        List<ContactInfo.EmailInfo> emailList = info.getEmail();
    //
    //        /** 录入联系人邮箱信息 */
    //        for (ContactInfo.EmailInfo email : emailList) {
    //            values.clear();
    //            values.put(android.provider.ContactsContract.Contacts.Data.RAW_CONTACT_ID, rawContactId);
    //            values.put(ContactsContract.RawContacts.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE);
    //            // 设置录入的邮箱信息
    //            values.put(ContactsContract.CommonDataKinds.Email.DATA, email.email);
    //            values.put(ContactsContract.CommonDataKinds.Email.TYPE, email.type);
    //            // 往data表入Email数据
    //            context.getContentResolver().insert(
    //                    android.provider.ContactsContract.Data.CONTENT_URI, values);
    //        }
            } catch (Exception e) {
                EvtLog.e(TAG, "e.toString==" + e.toString());
            }
    
        }
    
    
        public void updateContacts(ContactListBean contactListBean,String rawContactIdStr) {
    
            try {
    
                ContentValues values = new ContentValues();
                long rawContactId =Long.parseLong(rawContactIdStr);
    
                values.clear();
                values.put(android.provider.ContactsContract.Contacts.Data.RAW_CONTACT_ID, rawContactId);
                values.put(ContactsContract.RawContacts.Data.MIMETYPE, ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
    
                // 获取联系人电话信息
                List<PhoneListBean> phoneList = contactListBean.getPhoneList();
                /** 录入联系电话 */
                for (PhoneListBean phoneInfo : phoneList) {
                    if(TextUtils.isEmpty(phoneInfo.getNumber())){
                        continue;
                    }
                    // 设置录入联系人电话信息
                    values.put(ContactsContract.CommonDataKinds.Phone.NUMBER, phoneInfo.getNumber());
    //            values.put(ContactsContract.CommonDataKinds.Phone.TYPE, phoneInfo.getType());
                    values.put(ContactsContract.CommonDataKinds.Phone.TYPE, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE);
                    // 往data表入电话数据
                    String where = ContactsContract.Data.RAW_CONTACT_ID + "=? AND "
                            + ContactsContract.Data.MIMETYPE + "=?";
                    String[] selectionArgs = new String[] { String.valueOf(rawContactId),
                            ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE };
                    getContentResolver().update(ContactsContract.Data.CONTENT_URI, values,
                            where, selectionArgs);
                    EvtLog.e(TAG,"phoneInfo.getNumber()=="+phoneInfo.getNumber());
                }
    
            } catch (Exception e) {
                EvtLog.e(TAG, "e.toString==" + e.toString());
            }
    
        }
    
    展开全文
  • . 手机通讯录可以说是我们手机中最重要的应用功能之一特别是我们在更换手机的时候首先要...最重要的是这个方法很慢所以下面我们就给大家介绍几个比较简单好用的通讯录备份方法 目前手机从系统上可以分为苹果的iOS系统和
  • android手机通讯录备份还原
  • 本设计要求完成一个基于C/S模式的通讯录备份软件,采用C/S架构,具有易用、美观的图形界面。 1.1 服务器端功能要求 能够验证客户身份,接收客户端的备份通讯录的请求,能够实时备份和更新客户的通讯录 加密...

    一 需求分析

    本设计要求完成一个基于C/S模式的通讯录备份软件,采用C/S架构,具有易用、美观的图形界面。

    1.1 服务器端功能要求

    能够验证客户身份,接收客户端的备份通讯录的请求,能够实时备份和更新客户的通讯录

    加密存储每个用户的通讯录

    1.2 客户端功能要求

    能登陆连接到服务器,回应:连接成功/失败

    能备份本机通讯录

    能实时更新本机通讯录

    能查询本机通讯录

    1.3 本程序可实现功能

    客户端

    能登陆连接到服务器,回应:连接成功/失败

    能将本机通讯录备份到数据库

    能实时从数据库获取最新内容更新本机通讯录

    能查询本机通讯录

    能增加、删除并且修改本机通讯录

    服务端

    能够验证客户身份,接收客户端的备份通讯录的请求,能够实时备份和更新客户的通讯录

    加、解密用户存储的通讯录

    二 程序实现

    2.1 总体结构

    客户端首先建立一个本地文件来存储本地的通讯录数据,通过本地文件对通讯录内容进行查询操作,在数据库中进行通讯录的增添、删除以及修改操作。同时备份功能可将本地文件中的通讯录内容上传至数据库中,更新功能则是将经过增添、删除或修改后的数据库中通讯录内容更新到本地文件中。

    服务器负责验证客户端的登录账号和密码,若一致则与MySQL进行连接并回应客户端登陆成功,否则回应登陆失败。若登录成功,则服务端可响应客户端的备份请求,将本地文件中的通讯录内容经过DES加密后备份至数据库;还可响应客户端的更新要求,将数据库中通讯录的内容经过DES解密后更新至本地文件中。

    2.2 模块关系

    参考文档和完整的文档和源码下载地址:

    https://www.write-bug.com/article/1406.html

    转载于:https://my.oschina.net/u/4188109/blog/3090580

    展开全文
  • 通讯录备份

    2011-12-07 20:10:41
    可用于通讯录或者是其他任何你想备份的东西,添加、删除、精确查找、模糊查找、修改,只要轻轻一按,方便快捷
  • 手机通讯录可以说是我们手机中最重要的应用功能之一特别是我们在更换手机的时候首先...最重要的是这个方法很慢所以下面我们就给大家介绍几个比较简单好用的通讯录备份方法 目前手机从系统上可以分为苹果的iOS系统和谷歌
  • 通讯录 备份还原.rar,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • 电信设备-一种通讯录备份的方法及装置.zip
  • 电信设备-一种通讯录备份、恢复方法及装置.zip
  • 手机通讯录可以说是我们手机中最重要的应用功能之一 特别是我们在更换手机的时候首先要做的...并且 最重要的是这个方法很慢 所以下面我们就给大家介绍几个比较简单好用的通讯录备份方法 目前手机从系统上可以分为苹果的
  • 通讯录备份还原二 package app.utils; import java.util.ArrayList; import java.util.List; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import ...

    手机通讯录备份代码实现二

    package app.utils;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import android.content.ContentResolver;
    import android.content.Context;
    import android.content.Intent;
    import android.database.Cursor;
    import android.net.Uri;
    import android.provider.ContactsContract;
    import android.telephony.SmsManager;
    import android.text.TextUtils;
    
    import com.google.common.collect.Lists;
    
    /**
     * 短信电话相关工具类<br/>
     * 目录: <br/>
     * 1.发送短信 sendSMS() <br/>
     * 2.拨打电话短信 callPhone() <br/>
     * 3.获取所有短信记录getAllSms() <br/>
     * 4.获取所有联系人getContactsList() <br/>
     * 5.获取所有联系人getContactList() : 与第4条所生成的数据结构不同 <br/>
        
     * <b>注</b>:使用时请添加相关权限
     *
     * @author 赵LW QQ:739043667
     */
    public class SMSHelper {
    
        /**
         * 发送短信 (需要权限SMS_Send)
         *
         * @param num  电话
         * @param text 短信内容
         */
        public static void sendSMS(String num, String text) {
            SmsManager.getDefault().sendTextMessage(num, null, text, null, null);
        }
    
        public static void callPhone(Context context, String num) {
            Intent intent = new Intent();
            intent.setAction(Intent.ACTION_CALL);
            intent.setData(Uri.parse("tel:" + num));
            // 开启系统拨号器
            context.startActivity(intent);
        }
    
        /**
         * 获取所有联系人 需要权限
         * <uses-permission android:name="android.permission.READ_CONTACTS" />
         * 数据结构:ContactBean(String displayName, String numList)
         *
         * @param
         * @return
         */
        public static List<ContactBean> getContactList(Context context) {
    
            Logger.d("SMSHelper", "-----------SMSHelper#getContactList()----------");
            Logger.d("SMSHelper", "开始查询 Data 表");
            List<ContactBean> list = new ArrayList<ContactBean>();
    
            ContactsContract.Data._ID
            ContentResolver resolver = context.getContentResolver();
            Cursor cursor = resolver.query(ContactsContract.Data.CONTENT_URI, null, null, null, null);
    
            if (cursor == null && cursor.getCount() <= 0) {
                return null;
            }
            Logger.d("SMSHelper", "cursor.getCount():" + cursor.getCount());
    
            while (cursor.moveToNext()) {
    
                String name = cursor.getString(cursor.getColumnIndex(ContactsContract.Data.DISPLAY_NAME));
                String number = cursor.getString(cursor.getColumnIndex(ContactsContract.Data.DATA1));
    
                //数据清洗
                if (TextUtils.isEmpty(number)) {
                    continue;
                }
                if (!TextUtils.isDigitsOnly(number = number.replace(" ", ""))) {
                    continue;
                }
    
                if (TextUtils.isEmpty(name)) {
                    name = number;
                }
                list.add(new ContactBean(name, number));
            }
            cursor.close();
            return list;
        }
    
        /**
         * 获取所有联系人
         * 数据结构:ContactsBean(String displayName, List<String> numList)
         * <p/>
         * 需要权限:
         * <uses-permission android:name="android.permission.READ_CONTACTS" />
         *
         * @param
         * @return List<ContactsBean>
         */
        public static List<ContactsBean> getContactsList(Context context) {
    
            Logger.d("SMSHelper", "-----------SMSHelper#getContactsList()----------");
            Logger.d("SMSHelper", "开始查询 Contacts 表");
            List<ContactsBean> list = new ArrayList<ContactsBean>();
            ContactsBean bean = null;
            ContentResolver resolver = context.getContentResolver();
            Cursor cursor = resolver.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
    
            if (cursor == null && cursor.getCount() <= 0) {
                return null;
            }
            Logger.d("SMSHelper", "cursor.getCount():" + cursor.getCount());
    
            while (cursor.moveToNext()) {
                bean = new ContactsBean();
    
                String name = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));//姓名
    
                wirteNumbers(resolver, name, bean);
                list.add(bean);
            }
            cursor.close();
            return list;
        }
    
        /**
         * 根据联系人姓名查询电话
         * 并写入
         */
        private static void wirteNumbers(final ContentResolver contentResolver, String name, final ContactsBean bean) {
            Logger.d("SMSHelper", "开始查询 Data 表 : 查询联系人:" + name);
    
            Cursor dataCursor = contentResolver.query(ContactsContract.Data.CONTENT_URI,
                    new String[]{ContactsContract.Data.DATA1},
                    ContactsContract.Data.DISPLAY_NAME + "= ? ",
                    new String[]{name}, null);
            if (dataCursor == null) {
                Logger.w("SMSHelper", "dataCursor == null ");
    
                return;
            }
            if (dataCursor.getCount() > 0) {
                bean.setName(name);
                Logger.w("SMSHelper", " 电话信息 -- size: " + dataCursor.getCount());
                while (dataCursor.moveToNext()) {
                    String number = dataCursor.getString(dataCursor.getColumnIndex(ContactsContract.Data.DATA1));
    
                    if (TextUtils.isEmpty(number) || !TextUtils.isDigitsOnly(number = number.replace(" ", ""))) {
                        Logger.w("SMSHelper", " 电话信息(异常) -- number: " + number);
                        continue;
                    }
                    bean.getNumList().add(number);
                    Logger.w("SMSHelper", " 电话信息 -- number: " + number);
                }
                dataCursor.close();
            } else {
                Logger.w("SMSHelper", " 无电话信息 -- name: " + name);
            }
            return;
        }
    
        /**
         * 获取短信记录 (需要bean: Smsinfo.java和 Read_SMS权限)
         * <p>
         * <uses-permission android:name="android.permission.READ_SMS" />
         *
         * @return List<Smsinfo>
         * @author zlw QQ:739043667
         */
        public static List<SmsInfo> getAllSms(Context context) {
            List<SmsInfo> smsinfos = new ArrayList<SmsInfo>();
    
            Uri uri = Uri.parse("content://sms/");
            ContentResolver resolver = context.getContentResolver();
            Cursor cursor = resolver.query(uri, new String[]{"address", "date", "type", "body"}, null, null, null);
    
            SmsInfo smsinfo = null;
            while (cursor.moveToNext()) {
                String address = cursor.getString(0);
                String date = cursor.getString(1);
                String type = cursor.getString(2);
                String body = cursor.getString(3);
                smsinfo = new SmsInfo(address, date, type, body);
                smsinfos.add(smsinfo);
            }
    
            cursor.close();
            return smsinfos;
        }
    
        /**
         * 短信信息Bean 类
         *
         * @param
         * @author zlw QQ:739043667
         * @return
         */
        public static class SmsInfo {
            String address;
            String date;
            String type;
            String body;
    
            public SmsInfo(String address, String date, String type, String body) {
                super();
                this.address = address;
                this.date = date;
                this.type = type;
                this.body = body;
            }
    
            public String getAddress() {
                return address;
            }
    
            public void setAddress(String address) {
                this.address = address;
            }
    
            public String getDate() {
                return date;
            }
    
            public void setDate(String date) {
                this.date = date;
            }
    
            public String getType() {
                return type;
            }
    
            public void setType(String type) {
                this.type = type;
            }
    
            public String getBody() {
                return body;
            }
    
            public void setBody(String body) {
                this.body = body;
            }
    
        }
    
        /**
         * 联系人集合Bean类
         */
        public static class ContactsBean {
    
            private String name;
            private List<String> numList;
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public List<String> getNumList() {
                return numList;
            }
    
            public void setNumList(List<String> numList) {
                this.numList = numList;
            }
    
            public ContactsBean() {
                numList = Lists.newArrayList();
            }
    
            public ContactsBean(String displayName, List<String> numList) {
                super();
                this.name = displayName;
                if (numList == null) {
                    this.numList = Lists.newArrayList();
                } else {
                    this.numList = numList;
                }
            }
    
            @Override
            public String toString() {
                return "ContactsBean [name=" + name + ", numList=" + numList + "]";
            }
        }
    
    
        /**
         * 联系人Bean类
         */
        public static class ContactBean {
    
            private String name;
            private String number;
    
            public ContactBean() {
            }
    
            public ContactBean(String name, String number) {
                this.name = name;
                this.number = number;
            }
    
            public String getName() {
                return name;
            }
    
            @Override
            public String toString() {
                return "ContactBean{" +
                        "name='" + name + '\'' +
                        ", number='" + number + '\'' +
                        '}';
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            public String getNumber() {
                return number;
            }
    
            public void setNumber(String number) {
                this.number = number;
            }
        }
    
    }
    

    源代 https://download.csdn.net/download/qq_26296197/11974840

    展开全文
  • 通讯录备份还原.rar
  • 手机通讯录可以说是我们手机中最重要的应用功能之一特别是我们在更换手机 的时候首先要做的就是把旧手机上面的联系人更新到新手机上面去以前碰 到这个问题我们可能用得最多的是通过复制到 SIM 卡再从 SIM 卡复制到新...
  • Android手机通讯录备份和恢复项目

    千次阅读 2020-01-16 12:26:52
    Android手机通讯录备份和恢复项目登录功能注册功能找回密码修改密码备份功能恢复功能恢复数据从服务器导出为Excel文件 登录功能 注册功能 找回密码 同注册功能 修改密码 同注册功能 备份功能 恢复功能 恢复数据...
  • 通讯录中的联系人,电话号码保存到txt文件中完成备份。2.读取txt文件,导入到通讯录完成还原。  具体代码1.添加 通讯录读写权限,存储卡写权限  <uses-permission android:name="android.permission.READ_...
  • iOS 通讯录备份、恢复

    千次阅读 热门讨论 2016-01-11 11:32:00
    和相册 备份一样,公司产品备份功能有通讯录备份 功能,自然也有通讯录恢复了。iOS通讯录相关操作,iOS对通讯录的操作离不开的框架: #import #import iOS提供给我们了通讯录的相关信息,也给我们提供了简单的...
  • Android备份短信和通讯录
  • 通讯录备份还原

    2013-02-20 09:39:05
    为android手机的通讯录提供的备份还原功能,源码可直接编译。
  • Android通讯录备份恢复

    2016-08-15 04:42:20
    Android通讯录备份恢复
  • 用安卓手机导出通讯录后,得到一个vcf文件。想在电脑查看,找了网上其他vcf解析工具,发现解析不了,所以自己写了一个,没啥技术含量。运行后直接选择要解析的vcf文件,会自动生成一个解析后的txt文本。
  • 现在手机已经成为用户必不可少的社交工具之一,而手机上的通讯录是非常重要的,最直接连接的途径,那么iPhone通讯录备份怎么导出来呢?如何才能导出来轻松传输到另一台手机上呢,下面就为大家带来一个通讯录导出的...
  • 通讯录备份大师

    2013-01-01 17:26:35
    通讯录大师java版,备份记录你的手机通讯录
  • 手机通讯录备份还原四___综合一 import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import ...
  • 需求分析 在2年前就学过安卓开发,那时候安卓开发还是很火,但是感觉现在不怎么热潮了,这学期刚好有门c++课,实现通讯录备份,网络通信使用socket通信,服务器端用...
  • 手机 通讯录 备份大师 JAVA版本 导出数据格式为DAT

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,376
精华内容 2,150
关键字:

通讯录备份