GVKun编程网logo

Android ContentProvider实现获取手机联系人功能（android获取联系人信息）

18

本文将带您了解关于AndroidContentProvider实现获取手机联系人功能的新内容，同时我们还将为您解释android获取联系人信息的相关知识，另外，我们还将为您提供关于(android)解

本文将带您了解关于Android ContentProvider实现获取手机联系人功能的新内容，同时我们还将为您解释android获取联系人信息的相关知识，另外，我们还将为您提供关于(android)解剖contentProvider获取通讯录列表-002、(android)解剖contentProvider获取通讯录列表-003、Android ContentProvider、android ContentProvider 使用实例的实用信息。

本文目录一览：

Android ContentProvider实现获取手机联系人功能（android获取联系人信息）

Android ContentProvider实现获取手机联系人功能（android获取联系人信息）

在之前项目中有用到关于获取手机联系人的部分，闲置就想和大家分享一下，话不多说，上代码:

java部分:

package com.example.content; 
 
import android.content.ContentResolver; 
import android.database.Cursor; 
import android.net.Uri; 
import android.support.v7.app.AppCompatActivity; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
 
public class MainActivity extends AppCompatActivity { 
 
 private ContentResolver cr; 
 
 @Override 
 protected void onCreate(Bundle savedInstanceState) { 
  super.onCreate(savedInstanceState); 
  setContentView(R.layout.activity_main); 
  //获取内容访问者 
  cr = getContentResolver(); 
 } 
 public void getContacts(View view){ 
  Uri uri=Uri.parse("content://com.android.contacts/raw_contacts"); 
  Cursor cursor=cr.query(uri,null,null); 
  while(cursor.movetoNext()){ 
   int _id=cursor.getInt(cursor.getColumnIndex("_id")); 
   String display_name=cursor.getString(cursor.getColumnIndex("display_name")); 
   Log.i("test",_id+" "+display_name); 
   Uri uriData=Uri.parse("content://com.android.contacts/raw_contacts/"+_id+"/data"); 
   Cursor cursorData=cr.query(uriData,null); 
   while(cursorData.movetoNext()){ 
    String mimetype=cursorData.getString(cursorData.getColumnIndex("mimetype")); 
    String data1=cursorData.getString(cursorData.getColumnIndex("data1")); 
    if("vnd.android.cursor.item/phone_v2".equals(mimetype)){ 
     Log.i("test","  "+mimetype+" "+data1); 
    } 
   } 
  } 
 } 
}

xml部分：

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout 
 xmlns:android="http://schemas.android.com/apk/res/android" 
 xmlns:app="http://schemas.android.com/apk/res-auto" 
 xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" 
 android:layout_height="match_parent" tools:context="com.example.content.MainActivity"> 
 
 <Button 
  android:layout_width="wrap_content" 
  android:layout_height="wrap_content" 
  android:text="获取手机联系人" 
  android:onClick="getContacts" 
  /> 
 
</LinearLayout>

在需要获取系统的东西的时候一定不要忘记给权限啊

AndroidManifest.xml部分：

<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.content"> 
 
 <!--获取手机的联系人--> 
 <uses-permission android:name="android.permission.READ_CONTACTS"></uses-permission> 
 
 <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" 
  android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round" 
  android:supportsRtl="true" android:theme="@style/AppTheme"> 
  <activity android:name=".MainActivity"> 
   <intent-filter> 
    <action android:name="android.intent.action.MAIN" /> 
 
    <category android:name="android.intent.category.LAUNCHER" /> 
   </intent-filter> 
  </activity> 
 </application> 
 
</manifest>

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持编程小技巧。

(android)解剖contentProvider获取通讯录列表-002

(android)解剖contentProvider获取通讯录列表-002

//基于上一次说的内容 ,我们来弄下获取联系人详细信息,直接上代码,在第三篇补上其他的操作

package org.mo.pmas.resolver;
//本文章归属于小黑_mo所有,转载请说明出来http://my.oschina.net/moziqi/
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.provider.ContactsContract;
import android.util.Log;
import org.mo.pmas.activity.R;
import org.mo.pmas.entity.Contact;
import org.mo.pmas.entity.Phone;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by moziqi on 2015/1/9 0009.
 */
public class ContactResolver implements BaseResolver<Contact> {
    private Context mContext;

    public ContactResolver(Context mContext) {
        this.mContext = mContext;
    }

    @Override
    public boolean save(Contact entity) {
        return false;
    }

    @Override
    public boolean update(Contact entity) {
        return false;
    }

    @Override
    public boolean delete(Contact entity) {
        return false;
    }

    @Override
    public List<Contact> findAll() {
        List<Contact> contacts = new ArrayList<Contact>();
        ContentResolver contentResolver = mContext.getContentResolver();
        Cursor cursor = contentResolver.query(
                ContactsContract.Contacts.CONTENT_URI,
                null,
                null,
                null,
                ContactsContract.Contacts.DISPLAY_NAME
                        + " COLLATE LOCALIZED ASC");
        if (cursor.moveToFirst()) {
            do {
                Contact contact = new Contact();
                // 获得联系人的ID号
                int contactId = cursor.getInt(cursor.getColumnIndex(ContactsContract.Contacts._ID));
                // 获得联系人姓名
                String contactName = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));

                //获取联系人生日
                String[] projection = new String[]{ContactsContract.CommonDataKinds.Event.DATA1};
                String selection = ContactsContract.Data.MIMETYPE
                        + "=''"
                        + ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE
                        + "''"
                        + " and "
                        + ContactsContract.CommonDataKinds.Event.TYPE
                        + "=''"
                        + ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY
                        + "''"
                        + " and "
                        + ContactsContract.CommonDataKinds.Event.CONTACT_ID
                        + " = " + contactId;
                Cursor birthdayCursor = mContext.getContentResolver().query(
                        ContactsContract.Data.CONTENT_URI,
                        projection,
                        selection,
                        null,
                        null);
                String birthday = null;
                if (birthdayCursor.moveToFirst()) {
                    birthday = birthdayCursor.getString(birthdayCursor.getColumnIndex(ContactsContract.CommonDataKinds.Event.DATA));
                }
                birthdayCursor.close();

                //得到联系人头像Bitamp
                Bitmap contactPhoto = null;
                //得到联系人头像ID
                int photoid = cursor.getInt(cursor.getColumnIndex(ContactsContract.Contacts.PHOTO_ID));
                //photoid 大于0 表示联系人有头像 如果没有给此人设置头像则给他一个默认的
                if (photoid > 0) {
                    Uri uri = ContentUris.withAppendedId(ContactsContract.Contacts.CONTENT_URI, (long) contactId);
                    InputStream input = ContactsContract.Contacts.openContactPhotoInputStream(mContext.getContentResolver(), uri);
                    contactPhoto = BitmapFactory.decodeStream(input);
                    try {
                        input.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                } else {
                    contactPhoto = BitmapFactory.decodeResource(mContext.getResources(), R.drawable.h001);
                }

                // 获取该联系人邮箱
                //我这里只需要获取一个,没有遍历全部出来
                Cursor cursorEmail = mContext.getContentResolver().query(
                        ContactsContract.CommonDataKinds.Email.CONTENT_URI,
                        null,
                        ContactsContract.CommonDataKinds.Email.CONTACT_ID
                                + " = " + contactId, null, null);
                String email = null;
                if (cursorEmail.moveToFirst()) {
                    email = cursorEmail.getString(
                            cursorEmail.getColumnIndex(
                                    ContactsContract.CommonDataKinds.Email.DATA));
                }
                cursorEmail.close();

                // 获取该联系人地址
                //我这里只需要获取一个,没有遍历全部出来
                Cursor cursorAddress = mContext.getContentResolver().query(
                        ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_URI,
                        null,
                        ContactsContract.CommonDataKinds.StructuredPostal.CONTACT_ID
                                + " = " + contactId, null, null);
                String address = null;
                if (cursorAddress.moveToFirst()) {
                    //获取CITY
                    address = cursorAddress.getString(cursorAddress.getColumnIndex(ContactsContract.CommonDataKinds.StructuredPostal.CITY));
                }
                cursorAddress.close();

                contact.setId(contactId);
                contact.setName(contactName);
                contact.setContactPhoto(contactPhoto);
                contact.setEmail(email);
                contact.setAddress(address);
                contact.setBirthday(birthday);

                // 查看该联系人有多少个电话号码。如果没有这返回值为0
                int has_phone_number = cursor.getInt(cursor.getColumnIndex(ContactsContract.Contacts.HAS_PHONE_NUMBER));
                if (has_phone_number > 0) {
                    // 获得联系人的电话号码
                    Cursor cursorPhone = mContext.getContentResolver().query(
                            ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
                            null,
                            ContactsContract.CommonDataKinds.Phone.CONTACT_ID
                                    + " = " + contactId, null, null);
                    List<Phone> phones = new ArrayList<Phone>();
                    if (cursorPhone.moveToFirst()) {
                        do {
                            Phone phone = new Phone();
                            int phoneId = cursorPhone.getInt(
                                    cursorPhone.getColumnIndex(
                                            ContactsContract.CommonDataKinds.Phone._ID));
                            String phoneNumber = cursorPhone.getString(
                                    cursorPhone.getColumnIndex(
                                            ContactsContract.CommonDataKinds.Phone.NUMBER));
                            phone.setContact(contact);
                            phone.setId(phoneId);
                            phone.setPhoneNumber(phoneNumber);
                            //保存phone list集合
                            phones.add(phone);
                        } while (cursorPhone.moveToNext());
                    }
                    cursorPhone.close();
                    //如果有电话号码就把phones添加到contact上
                    contact.setPhones(phones);
                }

                contacts.add(contact);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return contacts;
    }
}

//另外2个bean类

public class Contact implements Serializable {

    private Integer id;//编号

    private String name;//名字

    private String birthday;//生日

    private String email;//邮箱地址

    private String address;//通讯地址

    private Bitmap contactPhoto;//联系人照片

    private String phoneNumber;//联系电话

    private String sortLetters;  //显示数据拼音的首字母

    private String contactGroup;//联系组名称

    private String objectId;

    private String createdAt;

    private ContactGroup mContactGroup;

    private MyUser myUser;

    private List<Phone> phones;
    
    //getset
 }

package org.mo.pmas.entity;

import android.os.Parcel;
import android.os.Parcelable;

import java.io.Serializable;

/**
 * Created by moziqi on 2015/1/9 0009.
 */
public class Phone implements Serializable {

    private Integer id;
    private String objectId;
    private String phoneNumber;
    private Contact contact;
    private MyUser myUser;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getObjectId() {
        return objectId;
    }

    public void setObjectId(String objectId) {
        this.objectId = objectId;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public Contact getContact() {
        return contact;
    }

    public void setContact(Contact contact) {
        this.contact = contact;
    }

    public MyUser getMyUser() {
        return myUser;
    }

    public void setMyUser(MyUser myUser) {
        this.myUser = myUser;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "phoneNumber=''" + phoneNumber + ''\'''' +
                ", objectId=''" + objectId + ''\'''' +
                ", id=" + id +
                ''}'';
    }
}

参考内容http://www.verydemo.com/demo_c131_i81641.html

http://www.eoeandroid.com/thread-24595-1-1.html


(android)解剖contentProvider获取通讯录列表-003

(android)解剖contentProvider获取通讯录列表-003

群组的增删改查, 群组跟联系人是多对多的关系,这个是我的理解

//代码多长,我就分开来写吧
public class ContactGroupResolver implements BaseResolver<ContactGroup> {

    private Context mContext;

    public ContactGroupResolver(Context mContext) {
        this.mContext = mContext;
    }

    private ContentResolver resolver;

    public ContactGroupResolver(ContentResolver resolver) {
        this.resolver = resolver;
    }
    //这个你懂得
 }

里面的每一个方法

    /**
     * 获取所有的组
     *
     * @return
     */
    public List<HashMap<String, String>> getGroups() {
        List<HashMap<String, String>> groups = new ArrayList<HashMap<String, String>>();

        Cursor cursor = resolver.query(ContactsContract.Groups.CONTENT_URI, null, null, null, null);
        HashMap<String, String> group = new HashMap<String, String>();
        while (cursor.moveToNext()) {
            int id = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
            String title = cursor.getString(cursor.getColumnIndex(ContactsContract.Groups.TITLE));
            group.put("id", id + "");
            group.put("title", title);
            groups.add(group);
        }
        cursor.close();
        return groups;
    }
 /**
     * 创建组
     *
     * @return int
     */
    public long createGroup(String title) {
        if (TextUtils.isEmpty(title)) {
            return -1;
        }
        long gId = getGroupByTitle(title);
        if (gId == -1) {
            ContentValues values = new ContentValues();
            values.put(ContactsContract.Groups.TITLE, title);
            Uri uri = resolver.insert(ContactsContract.Groups.CONTENT_URI, values);
            gId = ContentUris.parseId(uri);
        }
        return gId;
    }
/**
     * 根据组的名称查询组
     *
     * @return int
     */
    public int getGroupByTitle(String title) {
        int id = -1;
        Cursor cursor = mContext.getContentResolver().query(
                ContactsContract.Groups.CONTENT_URI,
                new String[]{ContactsContract.Groups._ID},
                ContactsContract.Groups.TITLE + "=''" + title + "''",
                null, null);
        if (cursor.moveToNext()) {
            id = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
        }
        cursor.close();
        return id;
    }
   /**
     * 根据组的id删除组
     *
     * @return int
     */
    public int delGroupById(String selection, String[] ids) {
        Uri uri = Uri.parse(ContactsContract.Groups.CONTENT_URI + "?" + ContactsContract.CALLER_IS_SYNCADAPTER + "=true");
        int i = resolver.delete(
                uri,
                ContactsContract.Groups._ID + selection,
                ids);
        return i;
    }
    /**
     * 保存群组
     * @param entity
     * @return
     */
    @Override
    public boolean save(ContactGroup entity) {
        if (TextUtils.isEmpty(entity.getName())) {
            return false;
        }
        long gId = getGroupByTitle(entity.getName());
        if (gId == -1) {
            ContentValues values = new ContentValues();
            values.put(ContactsContract.Groups.TITLE, entity.getName());
            Uri uri = mContext.getContentResolver().insert(ContactsContract.Groups.CONTENT_URI, values);
            gId = ContentUris.parseId(uri);
            return true;
        } else {
            return false;
        }
    }
   /**
     * 更新群组
     * @param entity
     * @return
     */
    @Override
    public boolean update(ContactGroup entity) {
        long gId = getGroupByTitle(entity.getName());
        if (gId == -1) {
            Uri uri = ContentUris.withAppendedId(ContactsContract.Groups.CONTENT_URI, entity.getId());
            ContentValues values = new ContentValues();
            values.put(ContactsContract.Groups.TITLE, entity.getName());
            mContext.getContentResolver().update(uri, values, null, null);
            return true;
        } else {
            return false;
        }

    }
   /**
     * 删除群组
     * @param entity
     * @return
     */
    @Override
    public boolean delete(ContactGroup entity) {
        Uri uri = Uri.parse(ContactsContract.Groups.CONTENT_URI + "?" + ContactsContract.CALLER_IS_SYNCADAPTER + "=true");
        int i = mContext.getContentResolver().delete(
                uri,
                ContactsContract.Groups._ID + "=" + entity.getId(),
                null);
        if (i > 0) {
            return true;
        } else {
            return false;
        }
    }
 /**
     * 查找所有群组
     * @return
     */
    @Override
    public List<ContactGroup> findAll() {
        List<ContactGroup> groups = new ArrayList<ContactGroup>();
        Cursor cursor = mContext.getContentResolver().query(ContactsContract.Groups.CONTENT_URI,
                null,
                null,
                null,
                null);
        if (cursor.moveToFirst()) {
            do {
                ContactGroup contactGroup = new ContactGroup();
                int id = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
                String title = cursor.getString(cursor.getColumnIndex(ContactsContract.Groups.TITLE));
                contactGroup.setId(id);
                contactGroup.setName(title);
                groups.add(contactGroup);
            } while (cursor.moveToNext());
        }
        cursor.close();
        return groups;
    }
 /**
     * 通过id查找群组
     * @param id
     * @return
     */
    @Override
    public ContactGroup findOneById(Serializable id) {
        ContactGroup contactGroup = null;
        Cursor cursor = mContext.getContentResolver().query(ContactsContract.Groups.CONTENT_URI,
                null,
                ContactsContract.Groups._ID + "=?",
                new String[]{id + ""},
                null);
        if (cursor.moveToFirst()) {
            contactGroup = new ContactGroup();
            int cgid = cursor.getInt(cursor.getColumnIndex(ContactsContract.Groups._ID));
            String title = cursor.getString(cursor.getColumnIndex(ContactsContract.Groups.TITLE));
            contactGroup.setId(cgid);
            contactGroup.setName(title);
        }
        cursor.close();
        return contactGroup;
    }
  /**
     * 通过群组获取联系人列表
     * @param groupId
     * @return
     */
    public List<Contact> getAllContactsByGroupId(int groupId) {
        List<Contact> contacts = new ArrayList<Contact>();
        String[] RAW_PROJECTION = new String[]{ContactsContract.Data.RAW_CONTACT_ID,};
        String RAW_CONTACTS_WHERE = ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID
                + "=?"
                + " and "
                + ContactsContract.Data.MIMETYPE
                + "="
                + "''"
                + ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE
                + "''";

        // 通过分组的id 查询得到RAW_CONTACT_ID
        Cursor cursor = mContext.getContentResolver().query(
                ContactsContract.Data.CONTENT_URI, RAW_PROJECTION,
                RAW_CONTACTS_WHERE, new String[]{groupId + ""}, "data1 asc");
        while (cursor.moveToNext()) {
            // RAW_CONTACT_ID
            int col = cursor.getColumnIndex("raw_contact_id");
            int raw_contact_id = cursor.getInt(col);
            Contact ce = new Contact();
            ce.setId(raw_contact_id);
            Uri dataUri = Uri.parse("content://com.android.contacts/data");
            Cursor dataCursor = mContext.getContentResolver().query(dataUri,
                    null, "raw_contact_id=?",
                    new String[]{raw_contact_id + ""}, null);

            while (dataCursor.moveToNext()) {
                String data1 = dataCursor.getString(dataCursor
                        .getColumnIndex("data1"));
                String mime = dataCursor.getString(dataCursor
                        .getColumnIndex("mimetype"));
                if ("vnd.android.cursor.item/name".equals(mime)) {
                    ce.setName(data1);
                }
            }
            dataCursor.close();
            contacts.add(ce);
            ce = null;
        }
        cursor.close();
        return contacts;
    }
   /**
     * 通过联系人获取群组
     * @param conactId
     * @return
     */
    public ContactGroup getContactGroupByConactId(Integer conactId) {
        ContactGroup contactGroup = null;
        Cursor query = mContext.getContentResolver().query(
                ContactsContract.Data.CONTENT_URI,
                null,
                ContactsContract.CommonDataKinds.GroupMembership.RAW_CONTACT_ID + "=? and " + ContactsContract.CommonDataKinds.GroupMembership.MIMETYPE + "=?",
                new String[]{"" + conactId, ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE},
                null);
        if (query.moveToFirst()) {
            contactGroup = new ContactGroup();
            int id = query.getInt(query.getColumnIndex(ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID));
            contactGroup = findOneById(id);
        }
        query.close();
        return contactGroup;
    }
    /**
     * 保存关系
     * @param contactGroupId
     * @param contactId
     */
    public void saveRelationship(Integer contactGroupId, Integer contactId) {
        ContentValues values = new ContentValues();
        values.put(ContactsContract.CommonDataKinds.GroupMembership.RAW_CONTACT_ID, contactId);
        values.put(ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID, contactGroupId);
        values.put(ContactsContract.CommonDataKinds.GroupMembership.MIMETYPE, ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE);
        mContext.getContentResolver().insert(ContactsContract.Data.CONTENT_URI, values);
    }
给组移除成员(groupId,personId):   
getContentResolver().delete(ContactsContract.Data.CONTENT_URI,ContactsContract.CommonDataKinds.GroupMembership.RAW_CONTACT_ID + "=? and " +ContactsContract.CommonDataKinds.GroupMembership.GROUP_ROW_ID + "=? and " +ContactsContract.CommonDataKinds.GroupMembership.MIMETYPE + "=?",new String[]{"" + personId,"" + groupId,ContactsContract.CommonDataKinds.GroupMembership.CONTENT_ITEM_TYPE});


Android ContentProvider

Android ContentProvider

1. 适用场景

1) ContentProvider 为存储和读取数据提供了统一的接口

2) 使用 ContentProvider，应用程序可以实现数据共享

3) android 内置的许多数据都是使用 ContentProvider 形式，供开发者调用的 (如视频，音频，图片，通讯录等)

2. 相关概念介绍

1）ContentProvider 简介

       当应用继承 ContentProvider 类，并重写该类用于提供数据和存储数据的方法，就可以向其他应用共享其数据。虽然使用其他方法也可以对外共享 数据，但数据访问方式会因数据存储的方式而不同，如：采用文件方式对外共享数据，需要进行文件操作读写数据；采用 sharedpreferences 共享 数据，需要使用 sharedpreferences API 读写数据。而使用 ContentProvider 共享数据的好处是统一了数据访问方式。

2）Uri 类简介

      Uri uri = Uri.parse("content://com.changcheng.provider.contactprovider/contact")

      在 Content Provider 中使用的查询字符串有别于标准的 SQL 查询。很多诸如 select, add, delete, modify 等操作我们都使用一种特殊的 URI 来进行，这种 URI 由 3 个部分组成， “content://”, 代表数据的路径，和一个可选的标识数据的 ID。以下是一些示例 URI:

     content://media/internal/images  这个 URI 将返回设备上存储的所有图片

     content://contacts/people/  这个 URI 将返回设备上的所有联系人信息

     content://contacts/people/45 这个 URI 返回单个结果（联系人信息中 ID 为 45 的联系人记录）

　　尽管这种查询字符串格式很常见，但是它看起来还是有点令人迷惑。为此，Android 提供一系列的帮助类（在 android.provider 包下），里面包含了很多以类变量形式给出的查询字符串，这种方式更容易让我们理解一点，因此，如上面 content://contacts/people/45 这个 URI 就可以写成如下形式：

　　Uri person = ContentUris.withAppendedId(People.CONTENT_URI,  45);

然后执行数据查询:

Cursor cur = managedQuery(person, null, null, null);

这个查询返回一个包含所有数据字段的游标，我们可以通过迭代这个游标来获取所有的数据：

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package  com.wissen.testApp;
public  class  ContentProviderDemo  extends  Activity {
     @Override
     public  void  onCreate(Bundle savedInstanceState) {
         super .onCreate(savedInstanceState);
         setContentView(R.layout.main);
        displayRecords();
     }
 
     private  void  displayRecords() {
         //该数组中包含了所有要返回的字段
      String columns[] =  new  String[] { People.NAME, People.NUMBER };
        Uri mContacts = People.CONTENT_URI;
        Cursor cur = managedQuery(
           mContacts,
           columns,   // 要返回的数据字段
        　　 null ,           // WHERE子句
        　　 null ,          // WHERE 子句的参数
       　　  null          // Order-by子句
      );
        if  (cur.moveToFirst()) {
            String name =  null ;
            String phoneNo =  null ;
            do  {
               // 获取字段的值
          　　 name = cur.getString(cur.getColumnIndex(People.NAME));
              phoneNo = cur.getString(cur.getColumnIndex(People.NUMBER));
              Toast.makeText( this , name + ” ” + phoneNo, Toast.LENGTH_LONG).show();
           }  while  (cur.moveToNext());
        }
     }
}

上例示范了一个如何依次读取联系人信息表中的指定数据列 name 和 number。

修改记录:

我们可以使用 ContentResolver.update () 方法来修改数据，我们来写一个修改数据的方法:

?

1
2
3
4
5
6
private  void  updateRecord( int  recNo, String name) {
     Uri uri = ContentUris.withAppendedId(People.CONTENT_URI, recNo);
     ContentValues values =  new  ContentValues();
     values.put(People.NAME, name);
     getContentResolver().update(uri, values,  null ,  null );
}

现在你可以调用上面的方法来更新指定记录：

updateRecord (10,”XYZ”);   // 更改第 10 条记录的 name 字段值为 “XYZ”

添加记录:

要增加记录，我们可以调用 ContentResolver.insert () 方法，该方法接受一个要增加的记录的目标 URI，以及一个包含了新记录值的 Map 对象，调用后的返回值是新记录的 URI，包含记录号。

上面的例子中我们都是基于联系人信息簿这个标准的 Content Provider，现在我们继续来创建一个 insertRecord () 方法以对联系人信息簿中进行数据的添加：

?

1
2
3
4
5
6
7
8
9
10
11
private  void  insertRecords(String name, String phoneNo) {
     ContentValues values =  new  ContentValues();
     values.put(People.NAME, name);
     Uri uri = getContentResolver().insert(People.CONTENT_URI, values);
     Log.d(”ANDROID”, uri.toString());
     Uri numberUri = Uri.withAppendedPath(uri, People.Phones.CONTENT_DIRECTORY);
     values.clear();
     values.put(Contacts.Phones.TYPE, People.Phones.TYPE_MOBILE);
     values.put(People.NUMBER, phoneNo);
     getContentResolver().insert(numberUri, values);
}

这样我们就可以调用 insertRecords (name, phoneNo) 的方式来向联系人信息簿中添加联系人姓名和电话号码。

删除记录:

Content Provider 中的 getContextResolver.delete () 方法可以用来删除记录，下面的记录用来删除设备上所有的联系人信息：

?

1
2
3
4
private  void  deleteRecords() {
     Uri uri = People.CONTENT_URI;
     getContentResolver().delete(uri,  null ,  null );
}

你也可以指定 WHERE 条件语句来删除特定的记录：

getContentResolver().delete(uri, “NAME=” + “‘XYZ XYZ’”, null);

这将会删除 name 为‘XYZ XYZ’的记录。

3. 创建 ContentProvider

要创建我们自己的 Content Provider 的话，我们需要遵循以下几步：

a. 创建一个继承了 ContentProvider 父类的类

b. 定义一个名为 CONTENT_URI，并且是 public static final 的 Uri 类型的类变量，你必须为其指定一个唯一的字符串值，最好的方案是以类的全名称， 如:

public static final Uri CONTENT_URI = Uri.parse( “content://com.google.android.MyContentProvider”);

c. 定义你要返回给客户端的数据列名。如果你正在使用 Android 数据库，必须为其定义一个叫_id 的列，它用来表示每条记录的唯一性。

d. 创建你的数据存储系统。大多数 Content Provider 使用 Android 文件系统或 SQLite 数据库来保持数据，但是你也可以以任何你想要的方式来存储。

e. 如果你要存储字节型数据，比如位图文件等，数据列其实是一个表示实际保存文件的 URI 字符串，通过它来读取对应的文件数据。处理这种数据类型的 Content Provider 需要实现一个名为_data 的字段，_data 字段列出了该文件在 Android 文件系统上的精确路径。这个字段不仅是供客户端使用，而 且也可以供 ContentResolver 使用。客户端可以调用 ContentResolver.openOutputStream () 方法来处理该 URI 指向的文件资源；如果是 ContentResolver 本身的话，由于其持有的权限比客户端要高，所以它能直接访问该数据文件。

f. 声明 public static String 型的变量，用于指定要从游标处返回的数据列。

g. 查询返回一个 Cursor 类型的对象。所有执行写操作的方法如 insert (), update () 以及 delete () 都将被监听。我们可以通过使用 ContentResover ().notifyChange () 方法来通知监听器关于数据更新的信息。

h. 在 AndroidMenifest.xml 中使用 <provider> 标签来设置 Content Provider。

i. 如果你要处理的数据类型是一种比较新的类型，你就必须先定义一个新的 MIME 类型，以供 ContentProvider.geType (url) 来返回。MIME 类型有两种形式：一种是为指定的单个记录的，还有一种是为多条记录的。这里给出一种常用的格式：

　　vnd.android.cursor.item/vnd.yourcompanyname.contenttype （单个记录的 MIME 类型）

　　比如，一个请求列车信息的 URI 如 content://com.example.transportationprovider/trains/122 可能就会返回 typevnd.android.cursor.item/vnd.example.rail 这样一个 MIME 类型。

　　vnd.android.cursor.dir/vnd.yourcompanyname.contenttype （多个记录的 MIME 类型）

　　比如，一个请求所有列车信息的 URI 如 content://com.example.transportationprovider/trains 可能就会返回 vnd.android.cursor.dir/vnd.example.rail 这样一个 MIME 类型。

下列代码将创建一个 Content Provider，它仅仅是存储用户名称并显示所有的用户名称（使用 SQLLite 数据库存储这些数据）：

?

1
2
3
4
5
6
7
8
9
10
public  class  MyUsers {
     public  static  final  String AUTHORITY  = “com.wissen.MyContentProvider”;
 
     // BaseColumn类中已经包含了 _id字段
    public  static  final  class  User  implements  BaseColumns {
         public  static  final  Uri CONTENT_URI  = Uri.parse(”content: //com.wissen.MyContentProvider”);
         // 表数据列
         public  static  final  String  USER_NAME  = “USER_NAME”;
     }
}

上面的类中定义了 Content Provider 的 CONTENT_URI，以及数据列。下面我们将定义基于上面的类来定义实际的 Content Provider 类：

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public  class  MyContentProvider  extends  ContentProvider {
     private  SQLiteDatabase     sqlDB;
     private  DatabaseHelper    dbHelper;
     private  static  final  String  DATABASE_NAME = “Users.db”;
     private  static  final  int   DATABASE_VERSION=  1 ;
     private  static  final  String TABLE_NAME= “User”;
     private  static  final  String TAG = “MyContentProvider”;
 
     private  static  class  DatabaseHelper  extends  SQLiteOpenHelper {
         DatabaseHelper(Context context) {
             super (context, DATABASE_NAME,  null , DATABASE_VERSION);
         }
 
         @Override
         public  void  onCreate(SQLiteDatabase db) {
             //创建用于存储数据的表
         db.execSQL(”Create table ” + TABLE_NAME + “( _id INTEGER PRIMARY KEY AUTOINCREMENT, USER_NAME TEXT);”);
         }
 
         @Override
         public  void  onUpgrade(SQLiteDatabase db,  int  oldVersion,  int  newVersion) {
             db.execSQL(”DROP TABLE IF EXISTS ” + TABLE_NAME);
             onCreate(db);
         }
     }
 
     @Override
     public  int  delete(Uri uri, String s, String[] as) {
         return  0 ;
     }
 
     @Override
     public  String getType(Uri uri) {
         return  null ;
     }
 
     @Override
     public  Uri insert(Uri uri, ContentValues contentvalues) {
         sqlDB = dbHelper.getWritableDatabase();
         long  rowId = sqlDB.insert(TABLE_NAME, “”, contentvalues);
         if  (rowId >  0 ) {
             Uri rowUri = ContentUris.appendId(MyUsers.User.CONTENT_URI.buildUpon(), rowId).build();
             getContext().getContentResolver().notifyChange(rowUri,  null );
             return  rowUri;
         }
         throw  new  SQLException(”Failed to insert row into ” + uri);
     }
 
     @Override
     public  boolean  onCreate() {
         dbHelper =  new  DatabaseHelper(getContext());
         return  (dbHelper ==  null ) ?  false  :  true ;
     }
 
     @Override
     public  Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
         SQLiteQueryBuilder qb =  new  SQLiteQueryBuilder();
         SQLiteDatabase db = dbHelper.getReadableDatabase();
         qb.setTables(TABLE_NAME);
         Cursor c = qb.query(db, projection, selection,  null ,  null ,  null , sortOrder);
         c.setNotificationUri(getContext().getContentResolver(), uri);
         return  c;
     }
 
     @Override
     public  int  update(Uri uri, ContentValues contentvalues, String s, String[] as) {
         return  0 ;
     }
}

一个名为 MyContentProvider 的 Content Provider 创建完成了，它用于从 Sqlite 数据库中添加和读取记录。

Content Provider 的入口需要在 AndroidManifest.xml 中配置:

?

1
<provider android:name=”MyContentProvider” android:authorities=”com.wissen.MyContentProvider” />

之后，让我们来使用这个定义好的 Content Provider:

1）为应用程序添加 ContentProvider 的访问权限。

2）通过 getContentResolver () 方法得到 ContentResolver 对象。

3）调用 ContentResolver 类的 query () 方法查询数据，该方法会返回一个 Cursor 对象。

4）对得到的 Cursor 对象进行分析，得到需要的数据。

5）调用 Cursor 类的 close () 方法将 Cursor 对象关闭。

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public  class  MyContentDemo  extends  Activity {
     @Override
     protected  void  onCreate(Bundle savedInstanceState) {
         super .onCreate(savedInstanceState);
         insertRecord(”MyUser”);
         displayRecords();
     }
    
     private  void  insertRecord(String userName) {
         ContentValues values =  new  ContentValues();
         values.put(MyUsers.User.USER_NAME, userName);
         getContentResolver().insert(MyUsers.User.CONTENT_URI, values);
     }
 
     private  void  displayRecords() {
         String columns[] =  new  String[] { MyUsers.User._ID, MyUsers.User.USER_NAME };
         Uri myUri = MyUsers.User.CONTENT_URI;
         Cursor cur = managedQuery(myUri, columns, null ,  null ,  null  );
         if  (cur.moveToFirst()) {
             String id =  null ;
             String userName =  null ;
             do  {
                 id = cur.getString(cur.getColumnIndex(MyUsers.User._ID));
                 userName = cur.getString(cur.getColumnIndex(MyUsers.User.USER_NAME));
                 Toast.makeText( this , id + ” ” + userName, Toast.LENGTH_LONG).show();
            }  while  (cur.moveToNext());
        }
     }
}


android ContentProvider 使用实例

android ContentProvider 使用实例

创建 PeopleProvider.java:

package com.example.ch9;

import com.example.db.DbHelper;

import android.content.ContentProvider;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.text.TextUtils;

public class PeopleProvider extends ContentProvider {
	
	private static final int ITEMS = 1;
	private static final int ITEM_ID = 2;
	public static final String DbName = "Db_People";
	public static final String TableName = "tb_people";
	DbHelper dbhelper ;
	SQLiteDatabase db;
	public static final String CONTENT_ITEMS_TYPE = "vnd.android.cursor.items/com.example.ch94.Db_People";
	public static final String CONTENT_ITEMID_TYPE = "vnd.android.cursor.itemid/com.example.ch94.Db_People";
	public static final Uri CONTENT_URI = Uri.parse("content://com.example.ch94.Db_People/tb_people");
	
	private static final UriMatcher sMatcher;
	static{
		sMatcher = new UriMatcher(UriMatcher.NO_MATCH);
		sMatcher.addURI("com.example.ch94.Db_People", TableName, ITEMS);
		sMatcher.addURI("com.example.ch94.Db_People", TableName+"/#", ITEM_ID);
	}

	@Override
	public int delete(Uri uri, String selection, String[] selectionArgs) {
		db = dbhelper.getWritableDatabase();
		int count = 0;
		switch(sMatcher.match(uri)){
		case ITEMS:
			count = db.delete("tb_people", selection, selectionArgs);
			break;
		case ITEM_ID:
			String id = uri.getPathSegments().get(1);
			count = db.delete("tb_people", "_ID="+id+(!TextUtils.isEmpty("_ID=?")?"AND("+selection+'')'':""), selectionArgs);
			break;
		default:
			throw new IllegalArgumentException("Unknown URI"+uri);
		}
		getContext().getContentResolver().notifyChange(uri, null);
		return count;
	}

	@Override
	public String getType(Uri uri) {
		switch(sMatcher.match(uri)){
		case ITEMS:
			return CONTENT_ITEMS_TYPE;
		case ITEM_ID:
			return CONTENT_ITEMID_TYPE;
		default:
			throw new IllegalArgumentException("Unknown URI"+uri);
			
		}
	}

	@Override
	public Uri insert(Uri uri, ContentValues values) {
		db = dbhelper.getWritableDatabase();
		long rowId ;
		if(sMatcher.match(uri)!=ITEMS){
			throw new IllegalArgumentException("Unknown URI"+uri);
		}
		rowId = db.insert("tb_people", "_ID", values);
		if(rowId>0){
			Uri noteUri = ContentUris.withAppendedId(CONTENT_URI, rowId);
			getContext().getContentResolver().notifyChange(noteUri, null);
			return noteUri;
		}
		throw new IllegalArgumentException("Unknown URI"+uri);
	}

	@Override
	public boolean onCreate() {
		dbhelper = new DbHelper(this.getContext(),"Db_People",null,1);
		return true;
	}

	@Override
	public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
			String sortOrder) {
		db = dbhelper.getReadableDatabase();
		Cursor c;
		switch(sMatcher.match(uri)){
		case ITEMS:
			c = db.query("tb_people", projection, selection, selectionArgs, null, null, null);
			break;
		case ITEM_ID:
			String id = uri.getPathSegments().get(1);
			c = db.query("tb_people", projection, "_ID="+id+(!TextUtils.isEmpty(selection)?"AND("+selection+'')'':""), selectionArgs, null, null, sortOrder);
			break;
		default:
			throw new IllegalArgumentException("Unknown URI"+uri);
		}
		c.setNotificationUri(getContext().getContentResolver(), uri);
		return c;
	}

	@Override
	public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
		db = dbhelper.getWritableDatabase();
		int count = 0;
		switch(sMatcher.match(uri)){
		case ITEMS:
			count = db.update("tb_people", values, selection, selectionArgs);
			break;
		case ITEM_ID:
			String id = uri.getPathSegments().get(1);
			count = db.update("tb_people", values, "_ID="+id+(!TextUtils.isEmpty(selection)?"AND("+selection+'')'':""), selectionArgs);
			break;
		default:
			throw new IllegalArgumentException("Unknown URI"+uri);
		}
		getContext().getContentResolver().notifyChange(uri, null);
		return count;
	}

}

创建主活动类 SqlMainActivity.java: 

package com.example.ch94;

import com.example.baseexample.R;
import com.example.db.DbHelper;

import android.app.Activity;
import android.content.ContentResolver;
import android.content.Intent;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.os.Bundle;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.AdapterView.AdapterContextMenuInfo;
import android.widget.ListView;
import android.widget.SimpleCursorAdapter;
import android.widget.TextView;

public class SqlMainActivity extends Activity {
	private ListView list_people;
	private ContentResolver contentResolver;
	private Uri CONTENT_URI = Uri.parse("content://com.example.ch94.Db_People/tb_people");
//	private DbHelper dbhelper;
//	private SQLiteDatabase db;
	
	public void onCreate(Bundle savedInstanceState){
		super.onCreate(savedInstanceState);
		setContentView(R.layout.ch9_sqlmain);
		
		contentResolver = this.getContentResolver();
		
		list_people = (ListView)findViewById(R.id.list_people);
		
//		dbhelper = new DbHelper(this, "Db_People", null, 1);
//		db = dbhelper.getReadableDatabase();
		Cursor c = contentResolver.query(CONTENT_URI, new String[]{"_id","name","phone","mobile","email"}, null, null, null);
		SimpleCursorAdapter adapter = new SimpleCursorAdapter(this, R.layout.ch9_peoplelist, c, new String[]{"_id","name","phone","mobile","email"}, new int[]{R.id.id,R.id.name,R.id.phone,R.id.mobile,R.id.email});
		
		this.list_people.setAdapter(adapter);
		this.registerForContextMenu(list_people);
	}
	
	public boolean onCreateOptionsMenu(Menu menu){
		menu.add(Menu.NONE,Menu.FIRST+1,1,"添加").setIcon(android.R.drawable.ic_menu_add);
		menu.add(Menu.NONE,Menu.FIRST+1,2,"退出").setIcon(android.R.drawable.ic_menu_delete);
		return true;
	}
	
	public boolean onOptionsItemSelected(MenuItem item){
		switch(item.getItemId()){
		case Menu.FIRST+1:
			Intent intent = new Intent();
			intent.setClass(SqlMainActivity.this, AddPeopleActivity.class);
			startActivity(intent);
			break;
		case Menu.FIRST+2:finish();
			break;
		}
		return super.onOptionsItemSelected(item);
	}
	
	public void onCreateContextMenu(ContextMenu menu,View v,ContextMenuInfo menuInfo){
		menu.setHeaderIcon(R.drawable.ic_launcher);
		menu.add(0,3,0,"修改");
		menu.add(0, 4, 0, "删除");
	}
	
	public boolean onContextItemSelected(MenuItem item){
		AdapterContextMenuInfo menuInfo = (AdapterContextMenuInfo)item.getMenuInfo();
		switch(item.getItemId()){
		case 3:
			String name=((TextView)menuInfo.targetView.findViewById(R.id.name)).getText().toString();
			String phone=((TextView)menuInfo.targetView.findViewById(R.id.phone)).getText().toString();
			String mobile=((TextView)menuInfo.targetView.findViewById(R.id.mobile)).getText().toString();
			String email=((TextView)menuInfo.targetView.findViewById(R.id.email)).getText().toString();
			Intent intent = new Intent();
			intent.setClass(SqlMainActivity.this, AddPeopleActivity.class);
			Bundle bundle = new Bundle();
			bundle.putLong("id", menuInfo.id);
			bundle.putString("name", name);
			bundle.putString("phone", phone);
			bundle.putString("mobile", mobile);
			bundle.putString("email", email);
			intent.putExtras(bundle);
			startActivity(intent);
			break;
		case 4:
			contentResolver.delete(CONTENT_URI, "_ID=?", new String[]{menuInfo.id+""});
//			dbhelper = new DbHelper(this,"Db_People",null,1);
//			db = dbhelper.getWritableDatabase();
//			db.delete("tb_people", "_id=?", new String[]{menuInfo.id+""});
			break;
		}
		
		return true;
	}
	
}

创建添加数据的活动类 AddPeopleActivity.java： 

package com.example.ch94;

import com.example.baseexample.R;
import com.example.db.DbHelper;

import android.app.Activity;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class AddPeopleActivity extends Activity {
	private EditText edt_name;
	private EditText edt_phone;
	private EditText edt_mobile;
	private EditText edt_email;
	private Button bt_save;
	private ContentResolver contentResolver;
	private Uri CONTENT_URI = Uri.parse("content://com.example.ch94.Db_People/tb_people");
	String name,phone,mobile,email;
//	DbHelper dbhelper;
//	SQLiteDatabase db;
	Bundle bundle;
	protected void onCreate(Bundle savedInstanceState){
		super.onCreate(savedInstanceState);
		setContentView(R.layout.ch9_addpeople);
		contentResolver = this.getContentResolver();
		
		edt_name=(EditText)findViewById(R.id.edt_name);
		edt_phone=(EditText)findViewById(R.id.edt_phone);
		edt_mobile=(EditText)findViewById(R.id.edt_mobile);
		edt_email=(EditText)findViewById(R.id.edt_email);
		bt_save = (Button)findViewById(R.id.bt_save);
		
		bundle = this.getIntent().getExtras();
		if(bundle!=null){
			edt_name.setText(bundle.getString("name"));
			edt_phone.setText(bundle.getString("phone"));
			edt_mobile.setText(bundle.getString("mobile"));
			edt_email.setText(bundle.getString("email"));
		}
		
		bt_save.setOnClickListener(new Button.OnClickListener(){

			@Override
			public void onClick(View v) {
				name = edt_name.getText().toString();
				phone = edt_phone.getText().toString();
				mobile = edt_mobile.getText().toString();
				email = edt_email.getText().toString();
				
				ContentValues value = new ContentValues();
				value.put("name", name);
				value.put("phone", phone);
				value.put("mobile", mobile);
				value.put("email", email);
				
//				DbHelper dbhelper = new DbHelper(AddPeopleActivity.this,"Db_People",null,1);
//				SQLiteDatabase db = dbhelper.getWritableDatabase();
				long status;
				if(bundle!=null){
					status = contentResolver.update(CONTENT_URI, value, "_ID=?", new String[]{bundle.getLong("id")+""});
				}else{
					Uri uri2 = contentResolver.insert(CONTENT_URI, value);
					if(uri2!=null){
						status =1;
					}else{
						status = -1;
					}
//					status = db.insert("tb_people", null, value);
				}
				if(status!=-1){
					Toast.makeText(AddPeopleActivity.this, "保存成功", Toast.LENGTH_LONG).show();
				}else{
					Toast.makeText(AddPeopleActivity.this, "保存失败", Toast.LENGTH_LONG).show();
				}
			}
			
		});
	}
}

最后，在 AndroidManifest.xml 增加：

<provider android:name="com.example.ch9.PeopleProvider" android:authorities="com.example.ch94.Db_People"/>




关于Android ContentProvider实现获取手机联系人功能和android获取联系人信息的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于(android)解剖contentProvider获取通讯录列表-002、(android)解剖contentProvider获取通讯录列表-003、Android ContentProvider、android ContentProvider 使用实例的相关知识，请在本站寻找。

本文标签：

上一篇解决Eclipse启动出错：Failed to create the Java Virtual Machine（eclipse failed to create the java virtual machine）

下一篇Android 消息分发使用EventBus的实例详解（消息分发系统）

相关文章