devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

6.5 共享数据

作者：凡人多烦事01 | 2024-03-07 11:37:41

赞

踩

6.5 共享数据

        本节介绍Android的四大组件之一ContentProvider的基本概念和常见用法：首先说明如何使用内容提供器封装内部数据的外部访问接口，然后阐述如何使用内容解析器通过外部接口操作内部数据，最后叙述如何利用内容解析器读写联系人信息，以及如何利用内容观察器监听收到的短信内容。

6.5.1  通过ContentProvider封装数据

        Android提供了四大组件，分别是活动Activity、广播Broadcast、服务Service和内容提供器ContentProvider。其中内容提供器涵盖与内部数据存取有关的一系列组件，完整的内容组件由内容提供器ContentProvider、内容解析器ContentResolver、内容观察器ContentObserver三部分组成。

        ContentProvider给App存取内部数据提供了统一的外部接口，让不同的应用之间得以互相共享数据。像上一章提到的SQLite可操作应用自身的内部数据库，上传和下载功能可操作后端服务器的文件，而ContentProvider可操作当前设备其他应用的内部数据，它是一种中间层次的数据存储形式。

        在实际编码中，ContentProvider只是服务端App存储数据的抽象类，开发者需要在其基础上实现一个完整的内容提供器，并重写下列数据库管理方法。

        ●  onCreate：创建数据库并获得数据库连接。

        ●  insert：插入数据。

        ●  delete：删除数据。

        ●  update：更新数据。

        ●  query：查询数据，并返回结果集的游标。

        ●  getType：获取内容提供器支持的数据类型。

        这些方法看起来是不是很像SQLite？没错，ContentProvider作为中间接口，本身并不直接保存数据，而是通过SQLiteOpenHelper与SQLiteDatabase间接操作底层的数据库。所以要想使用ContentProvider，首先得实现SQLite的数据库帮助器，然后由ContentProvider封装对外的接口。以封装用户信息为例，具体步骤主要分成以下3步。

        1.  编写用户信息表的数据库帮助器

        这个数据库帮助器就是常规的SQLite操作代码，实现过程参见本章的“6.2.3  数据库帮助器SQLiteOpenHelper”，完整代码如下：

  1. package com.example.roomdatabase.entity;
  2. //用户信息
  3. public class UserInfo {
  4.     public long rowid; // 行号
  5.     public int xuhao; // 序号
  6.     public String name; // 姓名
  7.     public int age; // 年龄
  8.     public long height; // 身高
  9.     public float weight; // 体重
  10.     public boolean married; // 婚否
  11.     public String update_time; // 更新时间
  12.     public String phone; // 手机号
  13.     public String password; // 密码
  14.  
  15.     public UserInfo() {
  16.         rowid = 0L;
  17.         xuhao = 0;
  18.         name = "";
  19.         age = 0;
  20.         height = 0L;
  21.         weight = 0.0f;
  22.         married = false;
  23.         update_time = "";
  24.         phone = "";
  25.         password = "";
  26.     }
  27. }
  1. package com.example.roomdatabase.database;
  2.  
  3. import android.content.ContentValues;
  4. import android.content.Context;
  5. import android.database.Cursor;
  6. import android.database.sqlite.SQLiteDatabase;
  7. import android.database.sqlite.SQLiteOpenHelper;
  8. import android.util.Log;
  9.  
  10. import com.example.roomdatabase.entity.UserInfo;
  11.  
  12. import java.util.ArrayList;
  13. import java.util.List;
  14.  
  15. public class UserDBHelper extends SQLiteOpenHelper {
  16.     private static final String TAG = "UserDBHelper";
  17.     private static final String DB_NAME = "user.db"; // 数据库的名称
  18.     private static final int DB_VERSION = 1; // 数据库的版本号
  19.     private static UserDBHelper mHelper = null; // 数据库帮助器的实例
  20.     private SQLiteDatabase mDB = null; // 数据库的实例
  21.     public static final String TABLE_NAME = "user_info"; // 表的名称
  22.  
  23.     private UserDBHelper(Context context) {
  24.         super(context, DB_NAME, null, DB_VERSION);
  25.     }
  26.  
  27.     private UserDBHelper(Context context, int version) {
  28.         super(context, DB_NAME, null, version);
  29.     }
  30.  
  31.     // 利用单例模式获取数据库帮助器的唯一实例
  32.     public static UserDBHelper getInstance(Context context, int version) {
  33.         if (version > 0 && mHelper == null) {
  34.             mHelper = new UserDBHelper(context, version);
  35.         } else if (mHelper == null) {
  36.             mHelper = new UserDBHelper(context);
  37.         }
  38.         return mHelper;
  39.     }
  40.  
  41.     // 打开数据库的读连接
  42.     public SQLiteDatabase openReadLink() {
  43.         if (mDB == null || !mDB.isOpen()) {
  44.             mDB = mHelper.getReadableDatabase();
  45.         }
  46.         return mDB;
  47.     }
  48.  
  49.     // 打开数据库的写连接
  50.     public SQLiteDatabase openWriteLink() {
  51.         if (mDB == null || !mDB.isOpen()) {
  52.             mDB = mHelper.getWritableDatabase();
  53.         }
  54.         return mDB;
  55.     }
  56.  
  57.     // 关闭数据库连接
  58.     public void closeLink() {
  59.         if (mDB != null && mDB.isOpen()) {
  60.             mDB.close();
  61.             mDB = null;
  62.         }
  63.     }
  64.  
  65.     // 创建数据库，执行建表语句
  66.     @Override
  67.     public void onCreate(SQLiteDatabase db) {
  68.         Log.d(TAG, "onCreate");
  69.         String drop_sql = "DROP TABLE IF EXISTS " + TABLE_NAME + ";";
  70.         Log.d(TAG, "drop_sql:" + drop_sql);
  71.         db.execSQL(drop_sql);
  72.         String create_sql = "CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " ("
  73.                 + "_id INTEGER PRIMARY KEY  AUTOINCREMENT NOT NULL,"
  74.                 + "name VARCHAR NOT NULL," + "age INTEGER NOT NULL,"
  75.                 + "height INTEGER NOT NULL," + "weight FLOAT NOT NULL,"
  76.                 + "married INTEGER NOT NULL," + "update_time VARCHAR NOT NULL"
  77.                 //演示数据库升级时要先把下面这行注释
  78.                 + ",phone VARCHAR" + ",password VARCHAR"
  79.                 + ");";
  80.         Log.d(TAG, "create_sql:" + create_sql);
  81.         db.execSQL(create_sql); // 执行完整的SQL语句
  82.     }
  83.  
  84.     // 升级数据库，执行表结构变更语句
  85.     @Override
  86.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
  87.         Log.d(TAG, "onUpgrade oldVersion=" + oldVersion + ", newVersion=" + newVersion);
  88.         if (newVersion > 1) {
  89.             //Android的ALTER命令不支持一次添加多列，只能分多次添加
  90.             String alter_sql = "ALTER TABLE " + TABLE_NAME + " ADD COLUMN " + "phone VARCHAR;";
  91.             Log.d(TAG, "alter_sql:" + alter_sql);
  92.             db.execSQL(alter_sql);
  93.             alter_sql = "ALTER TABLE " + TABLE_NAME + " ADD COLUMN " + "password VARCHAR;";
  94.             Log.d(TAG, "alter_sql:" + alter_sql);
  95.             db.execSQL(alter_sql); // 执行完整的SQL语句
  96.         }
  97.     }
  98.  
  99.     // 根据指定条件删除表记录
  100.     public int delete(String condition) {
  101.         // 执行删除记录动作，该语句返回删除记录的数目
  102.         return mDB.delete(TABLE_NAME, condition, null);
  103.     }
  104.  
  105.     // 删除该表的所有记录
  106.     public int deleteAll() {
  107.         // 执行删除记录动作，该语句返回删除记录的数目
  108.         return mDB.delete(TABLE_NAME, "1=1", null);
  109.     }
  110.  
  111.     // 往该表添加一条记录
  112.     public long insert(UserInfo info) {
  113.         List<UserInfo> infoList = new ArrayList<UserInfo>();
  114.         infoList.add(info);
  115.         return insert(infoList);
  116.     }
  117.  
  118.     // 往该表添加多条记录
  119.     public long insert(List<UserInfo> infoList) {
  120.         long result = -1;
  121.         for (int i = 0; i < infoList.size(); i++) {
  122.             UserInfo info = infoList.get(i);
  123.             List<UserInfo> tempList = new ArrayList<UserInfo>();
  124.             // 如果存在同名记录，则更新记录
  125.             // 注意条件语句的等号后面要用单引号括起来
  126.             if (info.name != null && info.name.length() > 0) {
  127.                 String condition = String.format("name='%s'", info.name);
  128.                 tempList = query(condition);
  129.                 if (tempList.size() > 0) {
  130.                     update(info, condition);
  131.                     result = tempList.get(0).rowid;
  132.                     continue;
  133.                 }
  134.             }
  135.             // 如果存在同样的手机号码，则更新记录
  136.             if (info.phone != null && info.phone.length() > 0) {
  137.                 String condition = String.format("phone='%s'", info.phone);
  138.                 tempList = query(condition);
  139.                 if (tempList.size() > 0) {
  140.                     update(info, condition);
  141.                     result = tempList.get(0).rowid;
  142.                     continue;
  143.                 }
  144.             }
  145.             // 不存在唯一性重复的记录，则插入新记录
  146.             ContentValues cv = new ContentValues();
  147.             cv.put("name", info.name);
  148.             cv.put("age", info.age);
  149.             cv.put("height", info.height);
  150.             cv.put("weight", info.weight);
  151.             cv.put("married", info.married);
  152.             cv.put("update_time", info.update_time);
  153.             cv.put("phone", info.phone);
  154.             cv.put("password", info.password);
  155.             // 执行插入记录动作，该语句返回插入记录的行号
  156.             result = mDB.insert(TABLE_NAME, "", cv);
  157.             if (result == -1) { // 添加成功则返回行号，添加失败则返回-1
  158.                 return result;
  159.             }
  160.         }
  161.         return result;
  162.     }
  163.  
  164.     // 根据条件更新指定的表记录
  165.     public int update(UserInfo info, String condition) {
  166.         ContentValues cv = new ContentValues();
  167.         cv.put("name", info.name);
  168.         cv.put("age", info.age);
  169.         cv.put("height", info.height);
  170.         cv.put("weight", info.weight);
  171.         cv.put("married", info.married);
  172.         cv.put("update_time", info.update_time);
  173.         cv.put("phone", info.phone);
  174.         cv.put("password", info.password);
  175.         // 执行更新记录动作，该语句返回更新的记录数量
  176.         return mDB.update(TABLE_NAME, cv, condition, null);
  177.     }
  178.  
  179.     public int update(UserInfo info) {
  180.         // 执行更新记录动作，该语句返回更新的记录数量
  181.         return update(info, "rowid=" + info.rowid);
  182.     }
  183.  
  184.     // 根据指定条件查询记录，并返回结果数据列表
  185.     public List<UserInfo> query(String condition) {
  186.         String sql = String.format("select rowid,_id,name,age,height," +
  187.                 "weight,married,update_time,phone,password " +
  188.                 "from %s where %s;", TABLE_NAME, condition);
  189.         Log.d(TAG, "query sql: " + sql);
  190.         List<UserInfo> infoList = new ArrayList<UserInfo>();
  191.         // 执行记录查询动作，该语句返回结果集的游标
  192.         Cursor cursor = mDB.rawQuery(sql, null);
  193.         // 循环取出游标指向的每条记录
  194.         while (cursor.moveToNext()) {
  195.             UserInfo info = new UserInfo();
  196.             info.rowid = cursor.getLong(0); // 取出长整型数
  197.             info.xuhao = cursor.getInt(1); // 取出整型数
  198.             info.name = cursor.getString(2); // 取出字符串
  199.             info.age = cursor.getInt(3); // 取出整型数
  200.             info.height = cursor.getLong(4); // 取出长整型数
  201.             info.weight = cursor.getFloat(5); // 取出浮点数
  202.             //SQLite没有布尔型，用0表示false，用1表示true
  203.             info.married = (cursor.getInt(6) == 0) ? false : true;
  204.             info.update_time = cursor.getString(7); // 取出字符串
  205.             info.phone = cursor.getString(8); // 取出字符串
  206.             info.password = cursor.getString(9); // 取出字符串
  207.             infoList.add(info);
  208.         }
  209.         cursor.close(); // 查询完毕，关闭数据库游标
  210.         return infoList;
  211.     }
  212.  
  213.     // 根据手机号码查询指定记录
  214.     public UserInfo queryByPhone(String phone) {
  215.         UserInfo info = null;
  216.         List<UserInfo> infoList = query(String.format("phone='%s'", phone));
  217.         if (infoList.size() > 0) { // 存在该号码的登录信息
  218.             info = infoList.get(0);
  219.         }
  220.         return info;
  221.     }
  222. }
        2.  编写内容提供器的基础字段类       

        该类需要实现接口BaseColumns，同时加入几个常量定义。详细代码示例如下：

  1. package com.example.roomdatabase.entity;
  2.  
  3. import android.net.Uri;
  4. import android.provider.BaseColumns;
  5.  
  6. import com.example.roomdatabase.database.UserDBHelper;
  7.  
  8. public class UserInfoContent implements BaseColumns {
  9.     // 这里的名称必须与AndroidManifest.xml里的android:authorities保持一致
  10.     public static final String AUTHORITIES = "com.example";
  11.     //  内容提供器的外部表名
  12.     public static final String TABLE_NAME = UserDBHelper.TABLE_NAME;
  13.     // 访问内容提供器的URI
  14.     public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITIES + "/user");
  15.     // 下面是该表的各个字段名称
  16.     public static final String USER_NAME = "name";
  17.     public static final String USER_AGE = "age";
  18.     public static final String USER_HEIGHT = "height";
  19.     public static final String USER_WEIGHT = "weight";
  20.     public static final String USER_MARRIED = "married";
  21.     // 默认的排序方法
  22.     public static final String DEFAULT_SORT_ORDER = "_id desc";
  23. }
        3.  通过右键菜单创建内容提供器

        右击App模块的包名目录，在弹出的右键菜单中依次选择New→Other→Content Provider,打开如图所示的组件创建对话框。

        在创建对话框的Class Name一栏填写内容提供器的名称，比如UserInfoProvider；在URI Authorities一栏填写URI的授权串，比如“com.example”，注意这个授权串要跟 UserInfoContent里的一样；然后单击对话框右下角的Finish按钮，完成提供器的创建操作。

       上述创建过程会自动修改App模块的两处地方，一处是往AndroidManifest.xml添加内容提供器的注册配置，配置信息示例如下：

  1.         <provider
  2.             android:name=".entity.UserInfoProvider"
  3.             android:authorities="com.example"
  4.             android:enabled="true"
  5.             android:exported="true" >
  6.         </provider>

        另一处是在包名目录下生成名为UserInfoProvider.java的代码文件，打开一看发现该类继承了ContentProvider，并且提示重写onCreate、insert、delete、query、update、getType等方法，以便对数据进行增删改查等操作。这个提供器代码显然只有一个框架，还需补充详细的实现代码，为此重写onCreate方法，在此获取用户信息表的数据库帮助器实例，其他insert、delete、query等方法也要加入对应的数据库操作代码，修改之后的内容提供器代码如下：

  1. package com.example.roomdatabase.entity;
  2.  
  3. import android.content.ContentProvider;
  4. import android.content.ContentUris;
  5. import android.content.ContentValues;
  6. import android.content.UriMatcher;
  7. import android.database.Cursor;
  8. import android.database.sqlite.SQLiteDatabase;
  9. import android.net.Uri;
  10.  
  11. import com.example.roomdatabase.database.UserDBHelper;
  12.  
  13. public class UserInfoProvider extends ContentProvider {
  14.     private final static String TAG = "UserInfoProvider";
  15.     private UserDBHelper userDB; // 声明一个用户数据库的帮助器对象
  16.     public static final int USER_INFO = 1; // Uri匹配时的代号
  17.     public static final UriMatcher uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
  18.     static { // 往Uri匹配器中添加指定的数据路径
  19.         uriMatcher.addURI(UserInfoContent.AUTHORITIES, "/user", USER_INFO);
  20.     }
  21.     public UserInfoProvider() {
  22.     }
  23.  
  24.     // 根据指定条件删除数据
  25.     @Override
  26.     public int delete(Uri uri, String selection, String[] selectionArgs) {
  27.         // Implement this to handle requests to delete one or more rows.
  28.         int count = 0;
  29.         if (uriMatcher.match(uri) == USER_INFO) { // 匹配到了用户信息表
  30.             // 获取SQLite数据库的写连接
  31.             SQLiteDatabase db = userDB.getWritableDatabase();
  32.             // 执行SQLite的删除操作，并返回删除记录的数目
  33.             count = db.delete(UserInfoContent.TABLE_NAME, selection, selectionArgs);
  34.             db.close(); // 关闭SQLite数据库连接
  35.         }
  36.         return count;
  37.     }
  38.  
  39.     // 获取Uri支持的数据类型，暂未实现
  40.     @Override
  41.     public String getType(Uri uri) {
  42.         // TODO: Implement this to handle requests for the MIME type of the data
  43.         // at the given URI.
  44.         throw new UnsupportedOperationException("Not yet implemented");
  45.     }
  46.  
  47.     // 插入数据
  48.     @Override
  49.     public Uri insert(Uri uri, ContentValues values) {
  50.         // TODO: Implement this to handle requests to insert a new row.
  51.         if (uriMatcher.match(uri) == USER_INFO) { // 匹配到了用户信息表
  52.             // 获取SQLite数据库的写连接
  53.             SQLiteDatabase db = userDB.getWritableDatabase();
  54.             // 向指定的表插入数据，返回记录的行号
  55.             long rowId = db.insert(UserInfoContent.TABLE_NAME, null, values);
  56.             if (rowId > 0) { // 判断插入是否执行成功
  57.                 // 如果添加成功，就利用新记录的行号生成新的地址
  58.                 Uri newUri = ContentUris.withAppendedId(UserInfoContent.CONTENT_URI, rowId);
  59.                 // 通知监听器，数据已经改变
  60.                 getContext().getContentResolver().notifyChange(newUri, null);
  61.             }
  62.             db.close(); // 关闭SQLite数据库连接
  63.         }
  64.         return uri;
  65.     }
  66.  
  67.     // 创建ContentProvider时调用，可在此获取具体的数据库帮助器实例
  68.     @Override
  69.     public boolean onCreate() {
  70.         // TODO: Implement this to initialize your content provider on startup.
  71.         userDB = UserDBHelper.getInstance(getContext(), 1);
  72.         return true;
  73.     }
  74.  
  75.     // 根据指定条件查询数据库
  76.     @Override
  77.     public Cursor query(Uri uri, String[] projection, String selection,
  78.                         String[] selectionArgs, String sortOrder) {
  79.         Cursor cursor = null;
  80.         if (uriMatcher.match(uri) == USER_INFO) { // 匹配到了用户信息表
  81.             // 获取SQLite数据库的读连接
  82.             SQLiteDatabase db = userDB.getReadableDatabase();
  83.             // 执行SQLite的查询操作
  84.             cursor = db.query(UserInfoContent.TABLE_NAME,
  85.                     projection, selection, selectionArgs, null, null, sortOrder);
  86.             // 设置内容解析器的监听
  87.             cursor.setNotificationUri(getContext().getContentResolver(), uri);
  88.         }
  89.         return cursor; // 返回查询结果集的游标
  90.     }
  91.  
  92.     // 更新数据，暂未实现
  93.     @Override
  94.     public int update(Uri uri, ContentValues values, String selection,
  95.                       String[] selectionArgs) {
  96.         // TODO: Implement this to handle requests to update one or more rows.
  97.         throw new UnsupportedOperationException("Not yet implemented");
  98.     }
  99. }

        经过以上3个步骤之后，便完成了服务端App的接口封装工作，接下来再由其他App去访问服务端App的数据。

6.5.2  通过ContentResolver访问数据

        上一小节提到了利用ContentProvider封装服务端App的数据，如果客户App想访问对方的内部数据，就要借助内容解析器ContentResolver。内容解析器是客户端App操作服务端数据的工具，与之对应的内容提供器则是服务端的数据接口。在活动代码中调用getContentResolver方法，即可获取内容解析器的实例。

        ContentResolver提供的方法与ContentProvider壹壹对应，比如insert、delete、query、update、getType等，甚至连方法的参数类型都雷同。以添加操作为例，针对前面UserInfoProvider提供的数据接口，下面由内容解析器调用insert方法，使之往内容提供器中插入一条用户信息，记录添加代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     android:orientation="vertical"
  8.     android:padding="5dp"
  9.     tools:context=".ContentWriteActivity">
  10.     <RelativeLayout
  11.         android:layout_width="match_parent"
  12.         android:layout_height="56dp" >
  13.  
  14.         <TextView
  15.             android:id="@+id/tv_name"
  16.             android:layout_width="wrap_content"
  17.             android:layout_height="match_parent"
  18.             android:gravity="center"
  19.             android:text="姓名："
  20.             android:textColor="@color/black"
  21.             android:textSize="17sp" />
  22.  
  23.         <EditText
  24.             android:id="@+id/et_name"
  25.             android:layout_width="match_parent"
  26.             android:layout_height="match_parent"
  27.             android:layout_marginBottom="3dp"
  28.             android:layout_marginTop="3dp"
  29.             android:layout_toRightOf="@+id/tv_name"
  30.             android:background="@drawable/editext_selector"
  31.             android:gravity="left|center"
  32.             android:hint="请输入姓名"
  33.             android:inputType="text"
  34.             android:maxLength="12"
  35.             android:textColor="@color/black"
  36.             android:textSize="17sp" />
  37.     </RelativeLayout>
  38.  
  39.     <RelativeLayout
  40.         android:layout_width="match_parent"
  41.         android:layout_height="56dp" >
  42.  
  43.         <TextView
  44.             android:id="@+id/tv_age"
  45.             android:layout_width="wrap_content"
  46.             android:layout_height="match_parent"
  47.             android:gravity="center"
  48.             android:text="年龄："
  49.             android:textColor="@color/black"
  50.             android:textSize="17sp" />
  51.  
  52.         <EditText
  53.             android:id="@+id/et_age"
  54.             android:layout_width="match_parent"
  55.             android:layout_height="match_parent"
  56.             android:layout_marginBottom="3dp"
  57.             android:layout_marginTop="3dp"
  58.             android:layout_toRightOf="@+id/tv_age"
  59.             android:background="@drawable/editext_selector"
  60.             android:gravity="left|center"
  61.             android:hint="请输入年龄"
  62.             android:inputType="number"
  63.             android:maxLength="2"
  64.             android:textColor="@color/black"
  65.             android:textSize="17sp" />
  66.     </RelativeLayout>
  67.  
  68.     <RelativeLayout
  69.         android:layout_width="match_parent"
  70.         android:layout_height="56dp" >
  71.  
  72.         <TextView
  73.             android:id="@+id/tv_height"
  74.             android:layout_width="wrap_content"
  75.             android:layout_height="match_parent"
  76.             android:gravity="center"
  77.             android:text="身高："
  78.             android:textColor="@color/black"
  79.             android:textSize="17sp" />
  80.  
  81.         <EditText
  82.             android:id="@+id/et_height"
  83.             android:layout_width="match_parent"
  84.             android:layout_height="match_parent"
  85.             android:layout_marginBottom="3dp"
  86.             android:layout_marginTop="3dp"
  87.             android:layout_toRightOf="@+id/tv_height"
  88.             android:background="@drawable/editext_selector"
  89.             android:gravity="left|center"
  90.             android:hint="请输入身高"
  91.             android:inputType="number"
  92.             android:maxLength="3"
  93.             android:textColor="@color/black"
  94.             android:textSize="17sp" />
  95.     </RelativeLayout>
  96.  
  97.     <RelativeLayout
  98.         android:layout_width="match_parent"
  99.         android:layout_height="56dp" >
  100.  
  101.         <TextView
  102.             android:id="@+id/tv_weight"
  103.             android:layout_width="wrap_content"
  104.             android:layout_height="match_parent"
  105.             android:gravity="center"
  106.             android:text="体重："
  107.             android:textColor="@color/black"
  108.             android:textSize="17sp" />
  109.  
  110.         <EditText
  111.             android:id="@+id/et_weight"
  112.             android:layout_width="match_parent"
  113.             android:layout_height="match_parent"
  114.             android:layout_marginBottom="3dp"
  115.             android:layout_marginTop="3dp"
  116.             android:layout_toRightOf="@+id/tv_weight"
  117.             android:background="@drawable/editext_selector"
  118.             android:gravity="left|center"
  119.             android:hint="请输入体重"
  120.             android:inputType="numberDecimal"
  121.             android:maxLength="5"
  122.             android:textColor="@color/black"
  123.             android:textSize="17sp" />
  124.     </RelativeLayout>
  125.  
  126.     <Button
  127.         android:id="@+id/btn_add_user"
  128.         android:layout_width="match_parent"
  129.         android:layout_height="wrap_content"
  130.         android:gravity="center"
  131.         android:text="添加用户信息"
  132.         android:textColor="@color/black"
  133.         android:textSize="17sp" />
  134.     <Button
  135.         android:id="@+id/btn_jump"
  136.         android:layout_width="match_parent"
  137.         android:layout_height="wrap_content"
  138.         android:gravity="center"
  139.         android:text="跳转到用户信息"
  140.         android:textColor="@color/black"
  141.         android:textSize="17sp" />
  142. </LinearLayout>
  1. package com.example.roomdatabase;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.content.ContentValues;
  6. import android.os.Bundle;
  7. import android.view.View;
  8. import android.widget.EditText;
  9. import android.widget.Toast;
  10.  
  11. import com.example.roomdatabase.entity.UserInfo;
  12. import com.example.roomdatabase.entity.UserInfoContent;
  13.  
  14. public class ContentWriteActivity extends AppCompatActivity implements View.OnClickListener {
  15.     private static final String TAG = "ContentWriteActivity";
  16.     private EditText et_name; // 声明一个编辑框对象
  17.     private EditText et_age; // 声明一个编辑框对象
  18.     private EditText et_height; // 声明一个编辑框对象
  19.     private EditText et_weight; // 声明一个编辑框对象
  20.  
  21.     @Override
  22.     protected void onCreate(Bundle savedInstanceState) {
  23.         super.onCreate(savedInstanceState);
  24.         setContentView(R.layout.activity_content_write);
  25.  
  26.         et_name = findViewById(R.id.et_name);
  27.         et_age = findViewById(R.id.et_age);
  28.         et_height = findViewById(R.id.et_height);
  29.         et_weight = findViewById(R.id.et_weight);
  30.         findViewById(R.id.btn_add_user).setOnClickListener(this);
  31.         findViewById(R.id.btn_jump).setOnClickListener(this);
  32.     }
  33.  
  34.     @Override
  35.     public void onClick(View v) {
  36.         if (v.getId() == R.id.btn_add_user) {
  37.             UserInfo user = new UserInfo();
  38.             user.name = et_name.getText().toString();
  39.             user.age = Integer.parseInt(et_age.getText().toString());
  40.             user.height = Integer.parseInt(et_height.getText().toString());
  41.             user.weight = Float.parseFloat(et_weight.getText().toString());
  42.             addUser(user); // 添加一条用户记录
  43.         }
  44.     }
  45.     // 添加一条用户记录
  46.     private void addUser(UserInfo user) {
  47.         ContentValues name = new ContentValues();
  48.         name.put("name", user.name);
  49.         name.put("age", user.age);
  50.         name.put("height", user.height);
  51.         name.put("weight", user.weight);
  52.         name.put("married", 0);
  53.         name.put("update_time", DateUtil.getNowDateTime(""));
  54.         // 通过内容解析器往指定Uri添加用户信息
  55.         getContentResolver().insert(UserInfoContent.CONTENT_URI, name);
  56.         Toast.makeText(this, "成功添加用户信息", Toast.LENGTH_SHORT).show();
  57.     }
  58. }

        至于删除操作就更简单了，只要下面一行代码就删除了所有记录：

getContentResolver().delete(UserInfoContent.CONTENT_URI,"1=1",null);

        查询操作稍微复杂一些，调用query方法会返回游标对象，这个游标正是SQLite的游标Cursor，详细用法参见本章的“6.2.3  数据库帮助器SQLiteOpenHelper”。query方法的参数有好几个，具体说明如下（依参数顺序排列）：

        ●  uri：Uri类型，指定本次操作的数据表路径。

        ●  projection：字符串数组类型，指定将要查询的字段名称列表。

        ●  selection：字符串类型，指定查询条件。

        ●  selectionArgs：字符串数组类型，指定查询条件中的参数取值列表。

        ●  sortOrder：字符串类型，指定排序条件。

        下面是调用query方法从内容提供器查询所有用户信息的代码例子：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     android:orientation="vertical"
  8.     tools:context=".ContentReadActivity">
  9.     <Button
  10.         android:id="@+id/btn_delete"
  11.         android:layout_width="match_parent"
  12.         android:layout_height="wrap_content"
  13.         android:text="删除所有记录"
  14.         android:textColor="@color/black"
  15.         android:textSize="17sp" />
  16.  
  17.     <TextView
  18.         android:id="@+id/tv_desc"
  19.         android:layout_width="match_parent"
  20.         android:layout_height="wrap_content"
  21.         android:paddingLeft="5dp"
  22.         android:textColor="@color/black"
  23.         android:textSize="17sp" />
  24.  
  25.     <ScrollView
  26.         android:layout_width="match_parent"
  27.         android:layout_height="wrap_content">
  28.  
  29.         <LinearLayout
  30.             android:id="@+id/ll_list"
  31.             android:layout_width="match_parent"
  32.             android:layout_height="wrap_content"
  33.             android:orientation="vertical" />
  34.  
  35.     </ScrollView>
  36. </LinearLayout>
  1. package com.example.roomdatabase;
  2.  
  3. import androidx.appcompat.app.AppCompatActivity;
  4.  
  5. import android.annotation.SuppressLint;
  6. import android.database.Cursor;
  7. import android.graphics.Color;
  8. import android.os.Bundle;
  9. import android.view.View;
  10. import android.widget.LinearLayout;
  11. import android.widget.TextView;
  12. import android.widget.Toast;
  13.  
  14. import com.example.roomdatabase.entity.UserInfo;
  15. import com.example.roomdatabase.entity.UserInfoContent;
  16.  
  17. import java.util.ArrayList;
  18. import java.util.List;
  19. @SuppressLint("Range")
  20. public class ContentReadActivity extends AppCompatActivity implements View.OnClickListener {
  21.     private static final String TAG = "ContentReadActivity";
  22.     private TextView tv_desc; // 声明一个文本视图对象
  23.     private LinearLayout ll_list; // 用户信息列表的线性布局
  24.     @Override
  25.     protected void onCreate(Bundle savedInstanceState) {
  26.         super.onCreate(savedInstanceState);
  27.         setContentView(R.layout.activity_content_read);
  28.  
  29.         findViewById(R.id.btn_delete).setOnClickListener(this);
  30.         tv_desc = findViewById(R.id.tv_desc);
  31.         ll_list = findViewById(R.id.ll_list);
  32.         showAllUser(); // 显示所有的用户记录
  33.     }
  34.  
  35.     // 显示所有的用户记录
  36.     private void showAllUser() {
  37.         List<UserInfo> userList = new ArrayList<UserInfo>();
  38.         // 通过内容解析器从指定Uri中获取用户记录的游标
  39.         Cursor cursor = getContentResolver().query(UserInfoContent.CONTENT_URI, null, null, null, null);
  40.         // 循环取出游标指向的每条用户记录
  41.         while (cursor.moveToNext()) {
  42.             UserInfo user = new UserInfo();
  43.             user.name = cursor.getString(cursor.getColumnIndex(UserInfoContent.USER_NAME));
  44.             user.age = cursor.getInt(cursor.getColumnIndex(UserInfoContent.USER_AGE));
  45.             user.height = cursor.getInt(cursor.getColumnIndex(UserInfoContent.USER_HEIGHT));
  46.             user.weight = cursor.getFloat(cursor.getColumnIndex(UserInfoContent.USER_WEIGHT));
  47.             userList.add(user); // 添加到用户信息列表
  48.         }
  49.         cursor.close(); // 关闭数据库游标
  50.         String contactCount = String.format("当前共找到%d个用户", userList.size());
  51.         tv_desc.setText(contactCount);
  52.         ll_list.removeAllViews(); // 移除线性布局下面的所有下级视图
  53.         for (UserInfo user : userList) { // 遍历用户信息列表
  54.             String contactDesc = String.format("姓名为%s，年龄为%d，身高为%d，体重为%f\n",
  55.                     user.name, user.age, user.height, user.weight);
  56.             TextView tv_contact = new TextView(this); // 创建一个文本视图
  57.             tv_contact.setText(contactDesc);
  58.             tv_contact.setTextColor(Color.BLACK);
  59.             tv_contact.setTextSize(17);
  60.             int pad = Utils.dip2px(this, 5);
  61.             tv_contact.setPadding(pad, pad, pad, pad); // 设置文本视图的内部间距
  62.             ll_list.addView(tv_contact); // 把文本视图添加至线性布局
  63.         }
  64.     }
  65.  
  66.     @Override
  67.     public void onClick(View v) {
  68.         if (v.getId() == R.id.btn_delete) {
  69.             getContentResolver().delete(UserInfoContent.CONTENT_URI, "1=1", null);
  70.             showAllUser();
  71.             Toast.makeText(this, "已删除所有记录", Toast.LENGTH_SHORT).show();
  72.         }
  73.     }
  74. }
  1. package com.example.roomdatabase;
  2.  
  3. import android.content.Context;
  4.  
  5. public class Utils {
  6.     // 根据手机的分辨率从 dp 的单位 转成为 px(像素)
  7.     public static int dip2px(Context context, float dpValue) {
  8.         // 获取当前手机的像素密度（1个dp对应几个px）
  9.         float scale = context.getResources().getDisplayMetrics().density;
  10.         return (int) (dpValue * scale + 0.5f); // 四舍五入取整
  11.     }
  12.  
  13.     // 根据手机的分辨率从 px(像素) 的单位 转成为 dp
  14.     public static int px2dip(Context context, float pxValue) {
  15.         // 获取当前手机的像素密度（1个dp对应几个px）
  16.         float scale = context.getResources().getDisplayMetrics().density;
  17.         return (int) (pxValue / scale + 0.5f); // 四舍五入取整
  18.     }
  19.  
  20.     // 获得屏幕的宽度
  21.     public static int getScreenWidth(Context ctx) {
  22.         return ctx.getResources().getDisplayMetrics().widthPixels;
  23.     }
  24.  
  25.     // 获得屏幕的高度
  26.     public static int getScreenHeight(Context ctx) {
  27.         return ctx.getResources().getDisplayMetrics().heightPixels;
  28.     }
  29. }

        接下来分别演示通过内容解析器添加和查询用户信息的过程，其中记录添加页面为ContentWriteActivity.java，记录查询页面为ContentReadActivity.java。运行测试App，先打开记录添加页面，输入用户信息后点击“添加用户信息”按钮，由内容解析器执行插入操作，此时添加界面如图所示。

接着打开记录查询页面，内容解析器自动执行查询操作，并将查到的用户信息一一显示出来，此时查询界面如图所示。

        对比添加页面和查询页面的用户信息，可知成功查到了新增的用户记录。

6.5.3  利用ContentResolver读写联系人

        在实际开发中，普通App很少会开放数据接口给其他应用访问，作为服务端接口的ContentProvider基本用不到。内容组件能够派上用场的情况，往往是App想要访问系统应用的通讯数据，比如查看联系人、短信、通话记录，以及对这些通讯数据进行增删改查。

        在访问系统的通讯数据之前，得先在AndroidManifest.xml中添加相应的权限配置，常见的通讯权限配置主要有下面几个：

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/205381
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号