Android本地通讯录

最新推荐文章于 2022-09-02 16:59:45 发布
最新推荐文章于 2022-09-02 16:59:45 发布
阅读量677 收藏
点赞数
分类专栏： andorid
文章转自http://my.oschina.net/xiahuawuyu/blog/87953


package com.cy.contact.dao;
 
import java.util.ArrayList;
import java.util.List;
 
import android.content.ContentProviderOperation;
import android.content.ContentProviderResult;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.OperationApplicationException;
import android.database.Cursor;
import android.net.Uri;
import android.os.RemoteException;
import android.provider.ContactsContract;
import android.provider.ContactsContract.Data;
import android.provider.ContactsContract.RawContacts;
import android.provider.ContactsContract.CommonDataKinds.Email;
import android.provider.ContactsContract.CommonDataKinds.Im;
import android.provider.ContactsContract.CommonDataKinds.Nickname;
import android.provider.ContactsContract.CommonDataKinds.Note;
import android.provider.ContactsContract.CommonDataKinds.Organization;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.CommonDataKinds.StructuredName;
import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
import android.provider.ContactsContract.CommonDataKinds.Website;
 
import com.cy.contact.activity.R;
import com.cy.contact.pojo.ContentIndex;
import com.cy.contact.pojo.Group;
import com.cy.contact.pojo.User;
import com.cy.contact.pojo.UserContent;
import com.cy.contact.pojo.UserIndex;
import com.cy.contact.usercontent.action.ActionCode;
import com.cy.contact.util.HypyUtil;
import com.cy.contact.util.Constant.AuthSystem;
import com.cy.contact.util.Constant.SourceCategory;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.dao.ForeignCollection;
 
/**
  * 本地通讯录增删改查类
  *
  * @author wangqiang
  *
  */
public class NativeContactImpl {
     private Context context;
 
     public NativeContactImpl(Context context) {
         this .context = context;
     }
     private UserDao udao;
     private Dao dao;
     DaoFactory daoFactory;
     
 
     /**
      * 添加数据到通讯录中
      */
     public void addContact(User user) {
         ContentValues values = new ContentValues();
         UserIndex index= null ;
         String source=SourceCategory.SourceSystem.value;
         
         ForeignCollection<UserIndex> listIndex=user.getListIndex();
         for (UserIndex i:listIndex){
             if (SourceCategory.SourceSystem.value.equals(i.getSourceCategory())){
                 index=i;
             }
         }
         
         long rawContactId = 0 ;
         
         if (index!= null ){
             rawContactId=Long.parseLong(index.getSourceUserId());
         } else {
             // 首先向RawContacts.CONTENT_URI执行一个空值插入，目的是获取系统返回的rawContactId
             Uri rawContactUri = context.getContentResolver().insert(
                     RawContacts.CONTENT_URI, values);
             rawContactId = ContentUris.parseId(rawContactUri);
             index= new UserIndex();    //设置来源索引信息
         }
         
         // 往data表入姓名数据
         values.clear();
         //姓名分开添加时候使用
         /*
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
         values.put(StructuredName.FAMILY_NAME, user.getXing());
         values.put(StructuredName.GIVEN_NAME, user.getMing());
         context.getContentResolver().insert(
                 android.provider.ContactsContract.Data.CONTENT_URI, values);
         */
         // 往data表入姓名数据
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, StructuredName.CONTENT_ITEM_TYPE);
         values.put(StructuredName.DISPLAY_NAME, user.getMemberName());
         context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         
         user.getUpdateIndex().add(index);     
         index.setSourceUserId(rawContactId+ "" );
         index.setSourceCategory(source);
         
         List<UserContent> list = user.getListContent();
         for ( int i = 0 ; i <list.size(); i++){
             UserContent content=list.get(i);
             System.out.println( "mark:" +content.getContentMark()+ "   text:" +content.getContentText());
             String authSystemFlag=content.getSystemSynch();
             //修改或者删除原来授权的信息
             ContentIndex contentIndex= null ;
             List<ContentIndex> listcIndex=(List<ContentIndex>) content.getListIndex();
             if (listcIndex!= null ){
                 
                 for (ContentIndex ci:listcIndex){
                     if (SourceCategory.SourceSystem.value.equals(ci.getSourceCategory())){
                         contentIndex=ci;
                     }
                 }
             }
             System.out.println( "contentIndex:" +contentIndex);
             if (AuthSystem.Forbidden.value.equals(authSystemFlag)){  //没有授权,或者取消授权，跳出本次循环
                 
                 if (contentIndex!= null ){     //执行修改或者删除工作
                     String sourceDataId=contentIndex.getSourceId();
                     System.out.println( "sourceDataId:" +sourceDataId);
                     //删除操作
                     if (sourceDataId!= null ){
                         System.out.println( "删除联系人属性" );
                         deleteProperty(sourceDataId);
                     }
                     continue ;
                 }
                 continue ;
             }
             
             if (contentIndex!= null ){     //执行修改
                 String contactId=index.getSourceUserId();
                 String sourceDataId=contentIndex.getSourceId();
                 
                 //修改操作
                 System.out.println( "修改" );
                 continue ;
             }
             
             
             
             String cateFlag = content.getContentCategory();
             //添加电话号码
             if (cateFlag == ActionCode.PHONE_ACTION){
                 Uri uri=addPhone(rawContactId,content.getContentText());
                 //和警务通讯录db的   索引关系
                 setUserContentIndex(content,uri,source);
             }
             
             //添加email数据
             if (cateFlag == ActionCode.EMAIL_ACTION){
                 Uri uri=addEmail(rawContactId,content.getContentText());
                 setUserContentIndex(content,uri,source);
             }
             //添加 地址
             if (cateFlag == ActionCode.ADDRESS_ACTION){
                 Uri uri=addAddress(rawContactId,content.getContentText());
                 setUserContentIndex(content,uri,source);
             }
             
             //添加组织包括公司等信息
             if (cateFlag == ActionCode.ORIGNIZE_ACTION){
                 Uri uri=addOrganization(rawContactId,content.getContentText());
                 setUserContentIndex(content,uri,source);
             }
             //添加IM
             if (cateFlag == ActionCode.IM_ACTION){
                 Uri uri=addIM(rawContactId,content.getContentText());
                 setUserContentIndex(content,uri,source);
             }
             //添加备注
             if (cateFlag == ActionCode.REMARK_ACTION){
                 Uri uri=addRemark(rawContactId,content.getContentText());
                 setUserContentIndex(content,uri,source);
             }
             //添加昵称
             if (cateFlag == ActionCode.NICK_ACTION){
                 Uri uri=addNickName(rawContactId, content.getContentText());
                 setUserContentIndex(content,uri,source);
             }
             //添加网站
             if (cateFlag == ActionCode.HYPERLINK_ACTION){
                 Uri uri=addWebSite(rawContactId,content.getContentText());
                 setUserContentIndex(content,uri,source);
             }
             /*
             //添加互联网通话
             if(cateFlag == ActionCode.WEB_PHONE){
                 values.clear();
                 values.put(Data.RAW_CONTACT_ID, rawContactId);
                 values.put(Data.MIMETYPE, Intents.)
                 values.put(key, value)
                 values.put(key, value);
             }
             */
             
             
         }
         
         
         
     }
     
     /**
      * 添加电话号码
      * @param rawContactId  联系人ID
      * @param content       电话号码
      * @return
      */
     public Uri addPhone( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(
                 android.provider.ContactsContract.Contacts.Data.RAW_CONTACT_ID,
                 rawContactId);
         values.put(Data.MIMETYPE, Phone.CONTENT_ITEM_TYPE);
         values.put(Phone.NUMBER, content);
         values.put(Phone.TYPE, Phone.TYPE_MOBILE);
         Uri uri=context.getContentResolver().insert(
                 android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     
     /**
      * 添加email
      * @param rawContactId
      * @param content
      * @return
      */
     public Uri addEmail( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, Email.CONTENT_ITEM_TYPE);
         values.put(Email.DATA, content);
         values.put(Email.TYPE, Email.TYPE_WORK);
         Uri uri=context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     /**
      * 添加通讯地址
      * @param rawContactId
      * @param content
      * @return
      */
     public Uri addAddress( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE,StructuredPostal.CONTENT_ITEM_TYPE );
         values.put(StructuredPostal.DATA, content);
         values.put(StructuredPostal.TYPE, StructuredPostal.TYPE_WORK);
         Uri uri=context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     /**
      * 添加组织
      * @param rawContactId
      * @param content
      * @return
      */
     public Uri addOrganization( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, Organization.CONTENT_ITEM_TYPE);
         values.put(Organization.DATA, content);
         values.put(Organization.TYPE, Organization.TYPE_WORK);
 
         Uri uri=context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     /**
      * 添加即时通讯号码  qq等
      * @param rawContactId
      * @param content
      * @return
      */
     public Uri  addIM( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, Im.CONTENT_ITEM_TYPE);
         values.put(Im.DATA,content);
         values.put(Im.TYPE, Im.TYPE_WORK);
         Uri uri=context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     /**
      * 添加备注
      * @param rawContactId
      * @param content
      * @return
      */
     public Uri addRemark( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, Note.CONTENT_ITEM_TYPE);
         values.put(Note.DATA1,content);
         Uri uri=context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     /**
      * 添加昵称
      * @param rawContactId
      * @param content
      * @return
      */
     public Uri addNickName( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, Nickname.CONTENT_ITEM_TYPE);
         values.put(Nickname.DATA, content);
         values.put(Nickname.TYPE, Nickname.TYPE_CUSTOM);
         Uri uri=context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     /**
      * 添加网址
      * @param rawContactId
      * @param content
      * @return
      */
     public Uri addWebSite( long rawContactId,String content){
         ContentValues values= new ContentValues();
         values.put(Data.RAW_CONTACT_ID, rawContactId);
         values.put(Data.MIMETYPE, Website.CONTENT_ITEM_TYPE);
         values.put(Website.DATA, content);
         values.put(Website.TYPE, Website.TYPE_WORK);
         Uri uri=context.getContentResolver().insert(android.provider.ContactsContract.Data.CONTENT_URI, values);
         return uri;
     }
     
     /**
      * 查询系统分组
      *
      * @return
      */
     public List<Group> getGroups() {
         List<Group> listGroup = new ArrayList<Group>();
         Cursor groupCursor = context.getContentResolver().query(
                 ContactsContract.Groups.CONTENT_URI,
                 new String[] { ContactsContract.Groups._ID,
                         ContactsContract.Groups.TITLE }, null , null , null );
         while (groupCursor.moveToNext()) {
             String groupId = groupCursor.getString( 0 );
             String groupTitle = groupCursor.getString( 1 );
             Group group = new Group();
             group.setSystemGroupId(groupId);
             group.setGroupName(groupTitle);
             listGroup.add(group);
             
         }
         return listGroup;
     }
 
     
     /**
      * 获取联系人
      *
      * @return
      */
     public List<User>  getUsers(){
         List<User> listUser = new ArrayList<User>();
         
         String source=SourceCategory.SourceSystem.value;
         ContentResolver resolver = context.getContentResolver();
         // 获得所有的联系人 
         Cursor cur = resolver.query( 
                 ContactsContract.Contacts.CONTENT_URI, 
                 null , 
                 null , 
                 null , 
                 ContactsContract.Contacts.DISPLAY_NAME 
                         + " COLLATE LOCALIZED ASC" ); 
         // 循环遍历 
         if (cur.moveToFirst()) { 
             int idColumn = cur.getColumnIndex(ContactsContract.Contacts._ID); 
    
             int displayNameColumn = cur 
                     .getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME); 
             
             do { 
                 List<UserContent>  listContents= new ArrayList<UserContent>();
                 User user= new User();   
                 UserIndex index= new UserIndex();
                 user.getUpdateIndex().add(index);         //设置来源索引信息
                 // 获得联系人的ID号 
                 String contactId = cur.getString(idColumn); 
                 
                 index.setSourceUserId(contactId);
                 index.setSourceCategory(source);
                // index.setUser(user);
                 
                 // 获得联系人姓名 
                 String disPlayName = cur.getString(displayNameColumn); 
                 user.setMemberName(disPlayName);
                 user.setFirstLetter(HypyUtil.cn2py(disPlayName));
                 
                 // 查看该联系人有多少个电话号码。如果没有这返回值为0 
                 int phoneCount = cur 
                         .getInt(cur 
                                 .getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER)); 
                 if (phoneCount > 0 ) { 
                     // 获得联系人的电话号码 
                     Cursor phones = resolver.query( 
                             ContactsContract.CommonDataKinds.Phone.CONTENT_URI, 
                             null , 
                             ContactsContract.CommonDataKinds.Phone.CONTACT_ID 
                                     + " = " + contactId, null , null ); 
                     if (phones.moveToFirst()) { 
                         do { 
                             
                             // 遍历所有的电话号码 
                             int id = phones.getInt(phones.getColumnIndex(ContactsContract.CommonDataKinds.Phone._ID));
                             String phoneNumber = phones 
                                     .getString(phones 
                                             .getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER)); 
                             int phoneType = phones 
                                     .getInt(phones 
                                             .getColumnIndex(ContactsContract.CommonDataKinds.Phone.TYPE));
                             String label=context.getString(Phone.getTypeLabelResource(phoneType));
                            
                             
                             UserContent content= new UserContent();
                             content.setContentMark(label);
                             content.setContentText(phoneNumber);
                             content.setContentCategory(ActionCode.PHONE_ACTION);
                             
                             setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                             listContents.add(content);
                         } while (phones.moveToNext()); 
                     } 
                 } 
   
                 // 获取该联系人邮箱 
                 Cursor emails = resolver.query( 
                         ContactsContract.CommonDataKinds.Email.CONTENT_URI, 
                         null , 
                         ContactsContract.CommonDataKinds.Phone.CONTACT_ID 
                                 + " = " + contactId, null , null ); 
                 if (emails.moveToFirst()) { 
                     do { 
                          
                         // 遍历所有的邮箱 
                         int id = emails.getInt(emails.getColumnIndex(ContactsContract.CommonDataKinds.Email._ID));
                         int emailType = emails 
                                 .getInt(emails 
                                         .getColumnIndex(ContactsContract.CommonDataKinds.Email.TYPE)); 
                         String emailValue = emails 
                                 .getString(emails 
                                         .getColumnIndex(ContactsContract.CommonDataKinds.Email.DATA)); 
                         String label=context.getString(Email.getTypeLabelResource(emailType));
 
                         
                         UserContent content= new UserContent();
                         content.setContentMark(label);
                         content.setContentText(emailValue);
                         content.setContentCategory(ActionCode.EMAIL_ACTION);
                         
                         setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                         listContents.add(content);
                         
                     } while (emails.moveToNext()); 
                 } 
   
                 // 获取该联系人IM 
                 Cursor IMs = resolver.query( 
                         Data.CONTENT_URI, 
                         new String[] { Im._ID, Im.PROTOCOL, Im.DATA ,Im.TYPE}, 
                         Data.CONTACT_ID + "=?" + " AND " + Data.MIMETYPE + "='" 
                                 + Im.CONTENT_ITEM_TYPE + "'" , 
                         new String[] { contactId }, null ); 
                 if (IMs.moveToFirst()) { 
                     do { 
                         
                         int id = IMs.getInt(IMs.getColumnIndex(ContactsContract.CommonDataKinds.Im._ID));
                         int type=IMs.getInt(IMs.getColumnIndex(Im.TYPE));
                         String protocol = IMs.getString(IMs 
                                 .getColumnIndex(Im.PROTOCOL)); 
                         String data = IMs 
                                 .getString(IMs.getColumnIndex(Im.DATA)); 
                         String label=context.getString(Im.getTypeLabelResource(type));
                         
                         
                         UserContent content= new UserContent();
                         content.setContentMark(label);
                         content.setContentText(data);
                         content.setContentCategory(ActionCode.NORMAL_ACTION);
                         
                         setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                         listContents.add(content);
                     } while (IMs.moveToNext()); 
                 } 
   
                 // 获取该联系人地址 
                 Cursor address =resolver 
                         .query( 
                                 ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_URI, 
                                 null , 
                                 ContactsContract.CommonDataKinds.Phone.CONTACT_ID 
                                         + " = " + contactId, null , null ); 
                 if (address.moveToFirst()) { 
                     do { 
                         
                         int id = address.getInt(address.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal._ID));
                         int type=address.getInt(address.getColumnIndex(StructuredPostal.TYPE));
                         // 遍历所有的地址 
                         String street = address 
                                 .getString(address 
                                         .getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.STREET)); 
                         String city = address 
                                 .getString(address 
                                         .getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.CITY)); 
                         String region = address 
                                 .getString(address 
                                         .getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.REGION)); 
                         String postCode = address 
                                 .getString(address 
                                         .getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE)); 
                         String formatAddress = address 
                                 .getString(address 
                                         .getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.FORMATTED_ADDRESS)); 
                     
                     
                     String label=context.getString(StructuredPostal.getTypeLabelResource(type));
                     
                     UserContent content= new UserContent();
                     content.setContentMark(label);
                     content.setContentText(formatAddress);
                     content.setContentCategory(ActionCode.NORMAL_ACTION);
                     
                     setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                     listContents.add(content);
                     } while (address.moveToNext()); 
                 } 
   
                 // 获取该联系人公司
                 Cursor organizations = resolver.query( 
                         Data.CONTENT_URI, 
                         new String[] { Organization._ID, Organization.TYPE,Organization.COMPANY, 
                                 Organization.TITLE }, 
                         Data.CONTACT_ID + "=?" + " AND " + Data.MIMETYPE + "='" 
                                 + Organization.CONTENT_ITEM_TYPE + "'" , 
                         new String[] { contactId }, null ); 
                 if (organizations.moveToFirst()) { 
                     do { 
                         int id = organizations.getInt(organizations.getColumnIndex(ContactsContract.CommonDataKinds.Organization._ID));
                         int type=organizations.getInt(organizations.getColumnIndex(Organization.TYPE));
                         String company = organizations.getString(organizations 
                                 .getColumnIndex(Organization.COMPANY)); 
                         String title = organizations.getString(organizations 
                                 .getColumnIndex(Organization.TITLE)); 
                         
                         UserContent content= new UserContent();
                         content.setContentMark(context.getString(Organization.getTypeLabelResource(type)));
                         content.setContentText(company+ ":" +title);
                         content.setContentCategory(ActionCode.NORMAL_ACTION);
                         
                         
                         setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                         listContents.add(content);
                         
                     } while (organizations.moveToNext()); 
                 } 
   
                 // 获取备注信息 
                 Cursor notes = resolver.query( 
                         Data.CONTENT_URI, 
                         new String[] { Note._ID,Note.NOTE}, 
                         Data.CONTACT_ID + "=?" + " AND " + Data.MIMETYPE + "='" 
                                 + Note.CONTENT_ITEM_TYPE + "'" , 
                         new String[] { contactId }, null ); 
                 if (notes.moveToFirst()) { 
                     do { 
                         int id = notes.getInt(notes.getColumnIndex(ContactsContract.CommonDataKinds.Note._ID));
                         String noteinfo = notes.getString(notes 
                                 .getColumnIndex(Note.NOTE)); 
                         
                         
                         if (noteinfo== null ||noteinfo.equals( "" )){
                             break ;
                         }
                         
                         UserContent content= new UserContent();
                         content.setContentMark(context.getString(R.string.note_name));
                         content.setContentText(noteinfo);
                         content.setContentCategory(ActionCode.NORMAL_ACTION);
                        
                         setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                         listContents.add(content);
                         
                     } while (notes.moveToNext()); 
                 } 
                 
                 // 获取网址 
                 Cursor webSiteCr = resolver.query( 
                         Data.CONTENT_URI, 
                         new String[] { Website._ID,  Website.DATA ,Website.TYPE}, 
                         Data.CONTACT_ID + "=?" + " AND " + Website.MIMETYPE + "='" 
                                 + Website.CONTENT_ITEM_TYPE + "'" , 
                         new String[] { contactId }, null ); 
                 if (webSiteCr.moveToFirst()) { 
                     do { 
                         int id = webSiteCr.getInt(webSiteCr.getColumnIndex(ContactsContract.CommonDataKinds.Website._ID));
                         int type=webSiteCr.getInt(webSiteCr.getColumnIndex(Website.TYPE));
                         String protocol = webSiteCr.getString(webSiteCr 
                                 .getColumnIndex(Website.URL)); 
                         String data = webSiteCr 
                                 .getString(webSiteCr.getColumnIndex(Website.DATA)); 
                         
                         
                         UserContent content= new UserContent();
                         content.setContentMark(context.getString(R.string.website_name));
                         content.setContentText(data);
                         content.setContentCategory(ActionCode.HYPERLINK_ACTION);
                         
                         setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                         listContents.add(content);
                     } while (IMs.moveToNext()); 
                 } 
   
   
                 // 获取昵称
                 Cursor nicknames = resolver.query( 
                         Data.CONTENT_URI, 
                         new String[] { Nickname._ID, Nickname.NAME }, 
                         Data.CONTACT_ID + "=?" + " AND " + Data.MIMETYPE + "='" 
                                 + Nickname.CONTENT_ITEM_TYPE + "'" , 
                         new String[] { contactId }, null ); 
                 if (nicknames.moveToFirst()) { 
                     do { 
                         int id = nicknames.getInt(nicknames.getColumnIndex(ContactsContract.CommonDataKinds.Nickname._ID));
                         String nickname = nicknames.getString(nicknames 
                                 .getColumnIndex(Nickname.NAME)); 
                        
                         
                         if (nickname== null ){
                             break ;
                         }
                         
                         UserContent content= new UserContent();
                         content.setContentMark(context.getString(R.string.nick_name));
                         content.setContentText(nickname);
                         content.setContentCategory(ActionCode.NORMAL_ACTION);
                         
                         setUserContentIndex(content,id+ "" ,SourceCategory.SourceSystem.value);
                         listContents.add(content);
                     } while (nicknames.moveToNext()); 
                 }
                 user.setListContent(listContents);
                 listUser.add(user);
             } while (cur.moveToNext()); 
         } 
         return listUser;
     }
     
     /**
      * 修改和删除联系人
      * @param user
      * @param f
      *
      *
      */
 
     @SuppressWarnings ( "unchecked" )
     public void updateDelContent(User user, Boolean f) {
         
         UserIndex index= null ;
         
         ForeignCollection<UserIndex> listIndex=user.getListIndex();
         for (UserIndex i:listIndex){
             if (SourceCategory.SourceSystem.value.equals(i.getSourceCategory())){
                 index=i;
             }
         }
         if (index== null ){
             return ;
         }
         String sourceId=index.getSourceUserId();
         if (f == true ){
             ArrayList ops = new ArrayList();
             
              // 更新family_name和given_name
             /*
             ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                        .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
                          + ContactsContract.Data.MIMETYPE + "=?",
                           new String[]{user.getIndex().getSourceUserId(),ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE})
                           .withValue(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME, user.getXing())
                            .withValue(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, user.getMing())
                             .build());
                   */
             
             
             ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                        .withSelection(ContactsContract.Data.CONTACT_ID + "=?" + " AND "
                          + ContactsContract.Data.MIMETYPE + "=?" ,
                           new String[]{sourceId,ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE})
                           .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, user.getMemberName())
                          
                             .build());
                 
             
             List<UserContent> list = user.getListContent();
             String category ;
             for ( int i = 0 ; i< list.size(); i++){
                 category = list.get(i).getContentCategory();
                 System.out.println( "category---" +category);
                 if (category == ActionCode.PHONE_ACTION){
                 //更新typeMobile
                        ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =?  " + "  AND  "
                             +ContactsContract.Data.MIMETYPE + "=?" + " AND " +ContactsContract.CommonDataKinds.Organization.TYPE + "=?" ,
                             new String[]{sourceId,ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE,
                             String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE)})
                             .withValue(ContactsContract.CommonDataKinds.Phone.NUMBER, list.get(i).getContentText())
                             .build());
                         
                     }
                 if (category == ActionCode.EMAIL_ACTION){
                     //更新email
                     ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =?  " + "  AND  "
                                     +ContactsContract.Data.MIMETYPE + "=?" + " AND " +ContactsContract.CommonDataKinds.Email.TYPE + " =? " ,
                                     new String[]{sourceId,ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE,
                                     String.valueOf(ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE)})
                                     .withValue(ContactsContract.CommonDataKinds.Email.DATA, list.get(i).getContentText())
                                     .build());
                     
                 }
                 if (category == ActionCode.ADDRESS_ACTION){
                     //更新地址信息
                     ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =?  " +  " AND  "
                               +ContactsContract.Data.MIMETYPE + "  =? " + " =? " + ContactsContract.CommonDataKinds.StructuredPostal.TYPE + " =? " ,
                               new String[]{sourceId, ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE,
                                     String.valueOf(ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK)})
                                     .withValue(ContactsContract.CommonDataKinds.StructuredPostal.DATA, list.get(i).getContentText())
                                     .build());
                 }
                     
                 if (category == ActionCode.ORIGNIZE_ACTION){
                     //更行组织信息
                     ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =? " + " AND "
                              +ContactsContract.Data.MIMETYPE + " =? " + " AND " + ContactsContract.CommonDataKinds.Organization.TYPE + " =? " ,
                              new String[]{ sourceId, ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE,
                                     String.valueOf(ContactsContract.CommonDataKinds.Organization.TYPE_WORK)})
                                     .withValue(ContactsContract.CommonDataKinds.Organization.DATA, list.get(i).getContentText())
                                     .build());
                 }
                 
                 if (category == ActionCode.IM_ACTION){
                     //更新IM信息
                     ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =? " + " AND "
                              +ContactsContract.Data.MIMETYPE + " =? " + " AND " + ContactsContract.CommonDataKinds.Im.TYPE+ " =? " ,
                              new String[]{ sourceId, ContactsContract.CommonDataKinds.Im.CONTENT_ITEM_TYPE,
                                     String.valueOf(ContactsContract.CommonDataKinds.Im.TYPE_WORK)})
                                     .withValue(ContactsContract.CommonDataKinds.Organization.DATA, list.get(i).getContentText())
                                     .build());
                 }
                 
                 if (category == ActionCode.REMARK_ACTION){
                     //更新备注信息
                     ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =? " + " AND "
                              +ContactsContract.Data.MIMETYPE + " =? " ,
                              new String[]{ sourceId, ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE,})
                                     .withValue(ContactsContract.CommonDataKinds.Note.DATA1, list.get(i).getContentText())
                                     .build());
                 }
                 
                 if (category == ActionCode.NICK_ACTION){
                     //更新昵称
                     ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =? " + " AND "
                              +ContactsContract.Data.MIMETYPE + " =? " + " AND " + ContactsContract.CommonDataKinds.Nickname.TYPE+ " =? " ,
                              new String[]{ sourceId, ContactsContract.CommonDataKinds.Nickname.CONTENT_ITEM_TYPE,
                                     String.valueOf(ContactsContract.CommonDataKinds.Nickname.TYPE_CUSTOM)})
                                     .withValue(ContactsContract.CommonDataKinds.Nickname.DATA, list.get(i).getContentText())
                                     .build());
                 }
                 
                 if (category == ActionCode.HYPERLINK_ACTION){
                     //更新网址
                     ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                             .withSelection(ContactsContract.Data.CONTACT_ID + " =? " + " AND "
                              +ContactsContract.Data.MIMETYPE + " =? " + " AND " + ContactsContract.CommonDataKinds.Website.TYPE+ " =? " ,
                              new String[]{ sourceId, ContactsContract.CommonDataKinds.Website.CONTENT_ITEM_TYPE,
                                     String.valueOf(ContactsContract.CommonDataKinds.Website.TYPE_WORK)})
                                     .withValue(ContactsContract.CommonDataKinds.Website.DATA, list.get(i).getContentText())
                                     .build());
                 }
                 
                 
                 /*
             //更新company
             ops.add(ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
                     .withSelection(ContactsContract.Data.CONTACT_ID + "=?"+"  AND  "
                     +ContactsContract.Data.MIMETYPE+"=?"+"  AND  "     
                     +ContactsContract.CommonDataKinds.Organization.TYPE_WORK, new String[]{
                     ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE,
                     String.valueOf(ContactsContract.CommonDataKinds.Organization.TYPE_WORK)})
                     //.withValue(ContactsContract.CommonDataKinds.Organization.COMPANY, user.get)
                     );
             */
             
             }
              try {
                   ContentProviderResult[] res = context.getContentResolver().applyBatch(ContactsContract.AUTHORITY, ops);
                       //  Log.i("contact", "android_id="+android_id+",firstName="+firstName+",lastName="+lastName);
                    //  appState.db.insertContactToTag(tagId,String.valueOf(contactId));
                      }
                   catch (RemoteException e){
                       e.printStackTrace();
                   } catch (OperationApplicationException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
             }
         } else {
             ContentResolver cr = context.getContentResolver();
             String where = ContactsContract.Data._ID + " = ?  " ;
             String[] param = new String[]{ sourceId };
             
             ArrayList ops = new ArrayList();
             ops.add(ContentProviderOperation.newDelete(ContactsContract.RawContacts.CONTENT_URI)
                     .withSelection(where, param)
                     .build());
             try {
                 cr.applyBatch(ContactsContract.AUTHORITY, ops);
             } catch (RemoteException e) {
                 e.printStackTrace();
             } catch (OperationApplicationException e) {
                 e.printStackTrace();
             }  
            }
         }
     
     /**
      * 删除联系人属性
      * @param dataId
      */
     public void deleteProperty(String dataId){
         ContentResolver cr = context.getContentResolver();
         String where = ContactsContract.Data._ID + " = ?  " ;
         String[] param = new String[]{ dataId };
         cr.delete(ContactsContract.Data.CONTENT_URI, where, param);
     }
     
     
     public void updateInfo(){
         String dataId = "5" ;
         ContentResolver cr = context.getContentResolver();
         String where = ContactsContract.Data._ID + " = ?  " ;
         String[] param = new String[]{ dataId };
         ContentValues values = new ContentValues();
         values.put(StructuredName.DISPLAY_NAME, "wang" );
         cr.update(ContactsContract.Data.CONTENT_URI, values, where, param);
         
     }
     
     /**
      * 建立连个数据库联系人的索引关系
      * @param content
      * @param uri
      */
     public void  setUserContentIndex(UserContent content,Uri uri,String source){
         long id = ContentUris.parseId(uri);
         setUserContentIndex(content,id+ "" ,source);
     }
     
     
     public void setUserContentIndex(UserContent content,String id,String source){
         ContentIndex cindex= new ContentIndex();
         cindex.setSourceId(id);
         cindex.setPolyId( "1" );
         cindex.setSourceCategory(source);
         content.getUpdateIndex().add(cindex);
     }
}
海12345
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
安卓读取本地通讯录
04-06
读取手机内通讯录
获取android联系人信息
Fanfq's World
10-09 172
import android.app.Activity; import android.database.Cursor; import android.os.Bundle; import android.provider.ContactsContract; import android.provider.ContactsContract.Data; import android.p...
android 本地通讯录,android 加载本地联系人实现方法
weixin_39724382的博客
05-28 577
首先先建布局文件，界面很简单，就是一个搜索框和下面的联系人列表：android:layout_width="fill_parent"android:layout_height="fill_parent"android:background="#FFD3D7DF"android:orientation="vertical"android:padding="0dip" >android:lay...
android 读取本地通讯录外加搜索功能
LIAN_1988的专栏
05-10 952
一 添加权限     二 读取联系人关键代码  private static final String[] PHONES_PROJECTION = new String[] {         Phone.DISPLAY_NAME, Phone.NUMBER, Photo.PHOTO_ID,Phone.CONTACT_ID }; private C
android 本地通讯录列表滑动+侧边字母导航栏
06-27
在Android开发中，实现“本地通讯录列表滑动+侧边字母导航栏”是一项常见的功能，主要用于提升用户在大量联系人列表中查找特定联系人的体验。这个功能涉及到多个技术点，包括数据获取、数据处理、UI设计以及触摸事件...
使用jquery-mobile+html5实现android本地通讯录
08-08
本教程将聚焦于如何利用jQuery Mobile和HTML5来访问并操作Android设备上的本地通讯录。 首先，jQuery Mobile是一个基于HTML和CSS的框架，它提供了丰富的UI组件和交互效果，使得开发者可以创建具有触摸友好的用户...
Android Studio绿豆通讯录
05-28
【Android Studio绿豆通讯录】项目是一个使用Android Studio开发的简单应用，主要目的是教授如何在Android平台上构建一个基础的通讯录功能。在这个项目中，开发者将学习到如何利用Android Studio的集成开发环境（IDE...
基于Android 的通讯录设计
06-15
1. **SQLite数据库**：SQLite是Android系统内置的关系型数据库，用于本地数据存储。在这个项目中，SQLite用于持久化保存联系人的信息，包括姓名、电话号码、头像和备注。开发者需要创建数据库表结构，定义字段，以及...
android实现通讯录源码
03-26
【Android 实现通讯录源码】是一个基于Java编程语言，使用Eclipse集成开发环境（IDE）编写的项目，适用于Android平台。此项目的核心是利用SQLite数据库来存储和管理联系人信息，这涉及到Android应用程序开发中的多个...
Android 完整的通讯录项目源码
12-08
Android 完整的通讯录项目源码，开源源码，比较适合安卓初学者学习，界面看着还可以，系统能在手机上正常运行！
Android批量导入联系人到手机通讯录
04-27
将TXT文件内的联系人以及联系方式导入安卓手机通讯录！采用线程池模式。5000人也不会出现OOM错误。没有内存溢出。
Android 调用本地通讯录，广播接收
master-dragon的专栏
06-08 807
在AndroidManifest.xml里面注册好相应的通讯录相关权限 <!-- 读取联系人权限 --> <uses-permissionandroid:name="android.permission.READ_CONTACTS"/> <!-- 拨打电话权限 --> <uses-permissionandroid:name="android.permission.CALL_PHONE"/>这个稍微
如何有效的获取通讯录中的工作 公司等信息
myrssq的博客
07-07 1151
在获取本地通讯录信息的时候，由于很多字段的第二键值相同，所以在获取公司职位等信息的时候，不可与前面的姓名号码等同时获取，而是先存储id，姓名等信息，然后通过数据库筛选出只包含公司职位的字段值，然后再存储到本地。流程如下：   (1)首先获取id姓名等信息     Uri uri =ContactsContract.CommonDataKinds.Phone.CONTENT_URI;    
android的本地通讯录获取以及RecyclerView展示
镇元子的博客
09-02 1227
获取本地通讯录以及RecyclerView的运用
Android向通讯录添加联系人的一般方法
热门推荐
Zhang Phil
02-04 1万+
 Android向通讯录添加联系人的一般方法 以一个简单的例子加以说明，记得需要相应的权限： 测试代码，关键的内容就在add函数里面。 package zhangphil.demo; import android.app.Activity; import android.content.ContentUris; import android.content.
Android备份本地联系人和插入本地联系人
竹林小屋的博客
12-22 2754
Android备份本地联系人到sd卡的xml文件中 一.需要的权限： 二.获取本地联系人数据： public void getContacts(View v){ //获取ContentResolver对象 ContentResolver contentResolver=getContentResolver()
获取手机通讯录加好友
小白james
05-14 3587
获取手机通讯录加好友 工作用到的在app访问通讯录，获取好友信息，发邀请给好友，请求加好友， 类似微信的通讯录加好友效果，简单贴一些代码。 xml布局： <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent"
Android 绿豆通讯录
最新发布
04-26
Android 绿豆通讯录是一款基于Android系统的通讯录管理应用。它提供了方便快捷的联系人管理功能，可以帮助用户轻松地管理和查找联系人信息。 绿豆通讯录的主要特点和功能包括： 1. 联系人管理：用户可以添加、编辑...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值