Android学习记录——7.内容提供器

桃扇骨 2023-05-30 14:57 168阅读 0赞

### 文章目录 ###

*  1.内容提供器简介
 *  2.运行时权限
 *   *  2.1 Android权限机制详解
     *  2.2 在程序运行时申请权限
 *  3.访问其他程序中的数据
 *   *  3.1 ContentResolver的基本用法
     *  3.2 读取系统联系人
 *  4.创建自己的内容提供器
 *   *  4.1 创建内容提供器的步骤
     *  4.2 实现跨程序数据共享

# 1.内容提供器简介 #

内容提供器(Content Provider)主要用于在不同的应用程序之间实现数据共享的功能，它提供了一套完整的机制，允许一个程序访问另一个程序中的数据，同时还能保证被访数据的安全性。 目前，使用内容提供器是Android实现跨程序共享数据的标准方式。  
不同于文件存储和SharedPreferences存储中的两种全局可读写操作模式，内容提供器可以选择只对哪一部分数据进行共享，从而保证我们程序中的隐私数据不会有泄漏的风险。  
不过在正式开始学习内容提供器之前，我们需要先掌握另外一个非常重要的知识——Android运行时权限，因为待会的内容提供器示例中会使用到运行时权限的功能。当然不光是内容提供器，以后我们的开发过程中也会经常使用到运行时权限，因此你必须能够牢牢掌握它才行。

# 2.运行时权限 #

Android的权限机制并不是什么新鲜事物，从系统的第一个版本开始就已经存在了。但其实 之前Android的权限机制在保护用户安全和隐私等方面起到的作用比较有限，尤其是一些大家都离不开的常用软件，非常容易“店大欺客”。为此，Android开发团队在Android 6.0系统中引用 了运行时权限这个功能，从而更好地保护了用户的安全和隐私，那么本节我们就来详细学习一下这个6.0系统中引入的新特性。

## 2.1 Android权限机制详解 ##

首先来回顾一下过去Android的权限机制是什么样的。我们在第五篇博客写项目的时候第一次接触了 Android权限相关的内容，当时为了要访问系统的网络状态以及监听开机广播, 于是在AndroidManifest.xml文件中添加了这样两句权限声明：

因为访问系统的网络状态以及监听开机广播涉及了用户设备的安全性，因此必须在 AndroidManifest.xml中加入权限声明，否则我们的程序就会崩溃。  
那么现在问题来了，加入了这两句权限声明后，对于用户来说到底有什么影响呢？为什么这样就可以保护用户设备的安全性了呢？  
其实用户主要在以下两个方面得到了保护，一方面，如果用户在低于6.0系统的设备上安装该程序，会在安装界面给出相应的提醒。这样用户就可以清楚地知晓该程序一共申请了 哪些权限，从而决定是否要安装这个程序。  
另一方面，用户可以随时在应用程序管理界面查看任意一个程序的权限申请情况，这样该程序申请的所有权限就尽收眼底，什么都瞒不过用户的眼睛，以此保证应用程序不会出现各种滥用权限的情况。  
这种权限机制的设计思路其实非常简单，就是用户如果认可你所申请的权限，那么就会安装你的程序，如果不认可你所申请的权限，那么拒绝安装就可以了。  
但是理想是美好的，现实却很残酷，因为很多我们所离不开的常用软件普遍存在着滥用权限的情况，不管到底用不用得到，反正先把权限申请了再说。  
Android开发团队当然也意识到了这个问题，于是在6.0系统中加入了运行时权限功能。也就是说，用户不需要在安装软件的时候一次性授权所有申请的权限，而是可以在软件的使用过程中再对某一项权限申请进行授权。比如说一款相机应用在运行时申请了地理位置定位权限，就算我拒绝了这个权限，但是我应该仍然可以使用这个应用的其他功能，而不是像之前那样直接无法安装它。  
当然，并不是所有权限都需要在运行时申请，对于用户来说，不停地授权也很烦琐。Android 现在将所有的权限归成了两类，一类是普通权限，一类是危险权限。普通权限指的是那些不会直接威胁到用户的安全和隐私的权限，对于这部分权限申请，系统会自动帮我们进行授权，而不需要用户再去手动操作了，比如在之前的项目中申请的两个权限就是普通权限。危险权限则表示那些可能会触及用户隐私，或者对设备安全性造成影响的权限，如获取设备联系人信息、定位设备的地理位置等，对于这部分权限申请，必须要由用户手动点击授权才可以，否则程序就无法使用相应的功能。  
但是Android中有一共有上百种权限，我们怎么从中区分哪些是普通权限，哪些是危险权限？其实并没有那么难，因为危险权限总共就那么几个，除了危险权限之外，剩余的就都是普通权限了。下表列出了 Android中所有的危险权限，一共是9组24个权限。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]  
这张表格你看起来可能并不会那么轻松，因为里面的权限全都是你没使用过的。不过没有关系，你并不需要了解表格中每个权限的作用，只要把它当成一个参照表来查看就行了。每当要使用一个权限时，可以先到这张表中来查一下，如果是属于这张表中的权限，那么就需要进行运行时权限处理，如果不在这张表中，那么只需要在AndroidManifest.xml文件中添加一下权限声明就可以了。  
另外注意一下，表格中每个危险权限都属于一个权限组，我们在进行运行时权限处理时使用 的是权限名，但是用户一旦同意授权了，那么该权限所对应的权限组中所有的其他权限也会同时被授权。访问http://developer.android.com/reference/android/Manifest.permission.html 可以查看 Android 系统中完整的权限列表。  
好了，关于Android权限机制的内容就讲这么多，理论知识你已经了解得非常充足了。接下来我们就学习一下到底如何在程序运行的时候申请权限。

## 2.2 在程序运行时申请权限 ##

首先新建一个项目，我们就在这个项目的基础上来学习运行时权限的使用方法。在开始动手之前还需要考虑一下到底要申请什么权限，其实刚才表中列出的所有权限都是可以申请的，这里简单起见我们就使用CALL\_PHONE这个权限来作为本小节中的示例吧。  
CALL\_PHONE这个权限是编写拨打电话功能的时候需要声明的，因为拨打电话会涉及用户手机的资费问题，因而被列为了危险权限。在Android 6.0系统出现之前，拨打电话功能的实现其实非常简单,修改activity\_main.xml布局文件，如下所示：

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <Button
            android:id="@+id/make_call"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="拨打电话"/>
    </LinearLayout>

我们在布局文件中只是定义了一个按钮，当点击按钮时就去触发拨打电话的逻辑。接着修改 MainActivity中的代码，如下所示：

package com.mxt.runtimepermissiontest;
    
    import android.content.Intent;
    import android.net.Uri;
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity { 
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Button makeCall =  (Button)findViewById(R.id.make_call);
            makeCall.setOnClickListener(new View.OnClickListener() { 
                @Override
                public void onClick(View v) { 
                    try { 
                        Intent intent = new Intent(Intent.ACTION_DIAL);
                        intent.setData(Uri.parse("tel:10086"));
                        startActivity(intent);
                    }catch (SecurityException e){ 
                        e.printStackTrace();
                    }
                }
            });
        }
    }

可以看到，在按钮的点击事件中，我们构建了一个隐式Intent , Intent的action指定为 Intent. ACTI0N\_ CALL，这是一个系统内置的打电话的动作，然后在data部分指定了协议是tel, 号码是10086。其实这部分代码我们在之前就已经见过了，只不过当时指定的action是 Intent.ACTI0N\_DIAL，表示打开拨号界面，这个是不需要声明权限的，而Intent. ACTI0N\_ CALL则可以直接拨打电话，因此必须声明权限。另外为了防止程序崩溃，我们将所有操作都放在了异 常捕获代码块当中。  
那么接下来修改AndroidManifest.xml文件，在其中声明如下权限：

<?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.mxt.runtimepermissiontest">
        <uses-permission android:name="android.permission.CALL_PHONE"/>
        <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 6.0系统的手机上都是可以正常运行的，但是如果我们在6.0或者更高版本系统的手机上运行，点击Make Call按钮就没有任何效果，这时观察logcat中的打印日志，你会看到提示SecurityExcepion异常的错误信息。  
错误信息中提醒我们“PermissionDenial”，可以看出，是由于权限被禁止所导致的，因为6.0及以上系统在使用危险权限时都必须进行运行时权限处理。  
那么下面我们就来尝试修复这个问题，修改MainActivity中的代码，如下所示：

package com.mxt.runtimepermissiontest;
    
    import android.Manifest;
    import android.content.Intent;
    import android.content.pm.PackageManager;
    import android.net.Uri;
    import android.os.Bundle;
    import android.support.v4.app.ActivityCompat;
    import android.support.v4.content.ContextCompat;
    import android.support.v7.app.AppCompatActivity;
    import android.view.View;
    import android.widget.Button;
    import android.widget.Toast;
    
    public class MainActivity extends AppCompatActivity { 
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Button makeCall =  (Button)findViewById(R.id.make_call);
            makeCall.setOnClickListener(new View.OnClickListener() { 
                @Override
                public void onClick(View v) { 
                    if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) { 
                        ActivityCompat.requestPermissions(MainActivity.this, new String[]{ Manifest.permission.CALL_PHONE}, 1);
                    } else { 
                        call();
                    }
                }
            });
        }
        private void call(){ 
            try{ 
                Intent intent = new Intent(Intent.ACTION_CALL);
                intent.setData(Uri.parse("tel:10086"));
                startActivity(intent);
            }catch (SecurityException e){ 
                e.printStackTrace();
            }
        }
    
        @Override
        public void onRequestPermissionsResult(int requestCode,String[] permissions,int[] grantResults){ 
            switch (requestCode){ 
                case 1:
                    if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){ 
                        call();
                    }else{ 
                        Toast.makeText(this,"授权失败",Toast.LENGTH_SHORT).show();
                    }
                    break;
                default:
            }
        }
    }

上面的代码将运行时权限的完整流程都覆盖了，下面我们来具体解析一下。说白了，运行时权限的核心就是在程序运行过程中由用户授权我们去执行某些危险操作，程序是不可以擅自做主去执行这些危险操作的。因此，第一步就是要先判断用户是不是已经给过我们授权了，借助的是 ContextCompat. checkSelfPermission ()方法。checkSelfPermission()方法接收两个参数， 第一个参数是Context，这个没什么好说的，第二个参数是具体的权限名，比如打电话的权限名就是Manifest.permission.CALL PHONE，然后我们使用方法的返回值和PackageManager. PERMISSION\_GRANTED做比较，相等就说明用户已经授权，不等就表示用户没有授权。  
如果已经授权的话就简单了，直接去执行拨打电话的逻辑操作就可以了，这里我们把拨打电话的逻辑封装到了 call()方法当中。如果没有授权的话，则需要调用ActivityCompat.requestpermissions ()方法来向用户申请授权，requestpermissions ()方法接收3个参数， 第一个参数要求是Activity的实例，第二个参数是一个String数组，我们把要申请的权限名放在数组中即可，第三个参数是请求码，只要是唯一值就可以了，这里传入了 1。  
调用完了 requestpermissions()方法之后，系统会弹出一个权限申请的对话框，然后用户可以选择同意或拒绝我们的权限申请，不论是哪种结果，最终都会回调到onRequestPermissionsResult ()方法中，而授权的结果则会封装在grantResults参数当中。这里我们只需要判断一下最后的授权结果，如果用户同意的话就调用call()方法来拨打电话，如果用户拒绝的话我们只能放弃操作，并且弹出一条失败提示。  
现在重新运行一下程序，并点击Make Call按钮，效果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]  
由于用户还没有授权过我们拨打电话权限，因此第一次运行会弹出这样一个权限申请的对话 框，用户可以选择同意或者拒绝，比如说这里点击了 DENY,结果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]  
由于用户没有同意授权，我们只能弹出一个操作失败的提示。下面我们再次点击Make Call 按钮，仍然会弹出权限申请的对话框，这次点击ALLOW，结果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 3]  
可以看到，这次我们就成功进入到拨打电话界面了，并且由于用户已经完成了授权操作，之后再点击Make Call按钮就不会再弹出权限申请对话框了，而是可以直接拨打电话。那可能你会担心，万一以后我又后悔了怎么办？没有关系，用户随时都可以将授予程序的危险权限进行关闭， 进入 Settings Apps —> RuntimePermissionTest —> Permissions，即可关闭相应的危险权限。  
好了，关于运行时权限的内容就讲到这里，现在你已经有能力处理Android±各种关于权限 的问题了，下面我们就来进入本章的正题一一内容提供器。

# 3.访问其他程序中的数据 #

内容提供器的用法一般有两种，一种是使用现有的内容提供器来读取和操作相应程序中的数据，另一种是创建自己的内容提供器给我们程序的数据提供外部访问接口。那么接下来我们就一 个一个开始学习吧，首先从使用现有的内容提供器开始。  
如果一个应用程序通过内容提供器对其数据提供了外部访问接口，那么任何其他的应用程序就都可以对这部分数据进行访问。Android系统中自带的电话簿、短信、媒体库等程序都提供了类似的访问接口，这就使得第三方应用程序可以充分地利用这部分数据来实现更好的功能。下面我们就来看一看，内容提供器到底是如何使用的。

## 3.1 ContentResolver的基本用法 ##

对于每一个应用程序来说，如果想要访问内容提供器中共享的数据，就一定要借助ContentResolver 类，可以通过Context中的getContentResolver()方法获取到该类的实例。ContentResolver 中提供了一系列的方法用于对数据进行CRUD操作，其中insert()方法用于添加数据， update()方法用于更新数据，delete()方法用于删除数据，query()方法用于查询数据。有没有似曾相识的感觉？没错，SQLiteDatabase中也是使用这几个方法来进行CRUD操作的，只不过它们在方法参数上稍微有一些区别。  
不同于SQLiteDatabase,，ContentResolver中的增删改查方法都是不接收表名参数的，而是使用一个Uri参数代替，这个参数被称为内容URI。内容URI给内容提供器中的数据建立了唯一标识符，它主要由两部分组成：authority和path。authority是用于对不同的应用程序做区分的， 一般为了避免冲突，都会采用程序包名的方式来进行命名。比如某个程序的包名是com.example. app,那么该程序对应的authority就可以命名为com.example.app.provider。path则是用于对同一应用程序中不同的表做区分的，通常都会添加到authority的后面。比如某个程序的数据库里存在两张表：table 1和table2，这时就可以将path分别命名为/table1和/table2,然后把authority和path进行组合，内容 URI 就变成了 com.example.app.provider/table1 和 com.example.app.provider/table2。不过，目前还很难辨认出这两个字符串就是两个内容URI，我们还需要在字符串的头部加上协议 声明。因此，内容URI最标准的格式写法如下：

content://com.example.app.provider/table1
    content://com.example.app.provider/table2

有没有发现，内容URI可以非常清楚地表达出我们想要访问哪个程序中哪张表里的数据。也正是因此，ContentResolver中的增删改查方法才都接收对象作为参数，因为如果使用表名的话，系统将无法得知我们期望访问的是哪个应用程序里的表。  
在得到了内容URI字符串之后，我们还需要将它解析成Uri对象才可以作为参数传入。解析的方法也相当简单，代码如下所示：

Uri uri = Uri.parse("content://com.example.app.provider/table1")

只需要调用Uri.parse()方法，就可以将内容URI字符串解析成Uri对象了。  
现在我们就可以使用这个Uri对象来查询tablet表中的数据了，代码如下所示：

Cursor cursor = getContentResolver().query(
    uri,
    projection,
    selection,
    selectionArgs, 
    sortOrder);

这些参数和SQLiteDatabase中query ()方法里的参数很像，但总体来说要简单一些，毕竟这 是在访问其他程序中的数据，没必要构建过于复杂的查询语句。下表对使用到的这部分参数进行了详细的解释。  
![在这里插入图片描述][20191110220633551.png]  
查询完成后返回的仍然是一个Cursor对象，这时我们就可以将数据从Cursor对象中逐个读取出来了。读取的思路仍然是通过移动游标的位置来遍历Cursor的所有行，然后再取出每一行中相应列的数据，代码如下所示：

if (cursor != null) { 
    while (cursor.moveToNext()) (
    String columnl = cursor.getString(cursor.getColumnIndex("columnl")); int column2 = cursor.getInt(cursor.getColumnIndex("column?"));
    }
    cursor.close();
    }

掌握了最难的查询操作，剩下的增加、修改、删除操作就更不在话下了。我们先来看看如何向tablel表中添加一条数据，代码如下所示：

Contentvalues values = new Contentvalues();
    values.put("columnl", "text");
    values.put("column?", 1);
    getContentResolver().insert(uri, values);

现在如果我们想要更新这条新添加的数据，把column 1的值清空，可以借助ContentResolver的update()方法实现，代码如下所示：

Contentvalues values = new Contentvalues();
    values.put("columnl","");
    getContentResolver().update(uri, values, "column1 = ? and column2 = ?", new String!] { ''text", "1"});

注意上述代码使用了 selection和selectionArgs参数来对想要更新的数据进行约束，以防止所有的行都会受影响。  
最后，可以调用ContentResolver的delete。方法将这条数据删除掉，代码如下所示：

getContentResolver().delete(uri, "column2 = ?", new String[] {  "1" });

到这里为止，我们就把ContentResolver中的增删改查方法全部学完了。是不是感觉一看就懂？因为这些知识早在上一篇博客中学习SQLiteDatabase的时候你就已经掌握了，所需特别注意的就只有这个参数而已。那么接下来，我们就利用目前所学的知识，看一看如何读取系统电话簿 中的联系人信息。

## 3.2 读取系统联系人 ##

由于我们之前一直使用的都是模拟器，电话簿里面并没有联系人存在，所以现在需要自己手动添加几个，以便稍后进行读取。打开电话簿程序，添加以下两个联系人：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 5]

这样准备工作就做好了，现在新建一个项目，让我们开始动手吧。  
首先还是来编写一下布局文件，这里我们希望读取出来的联系人信息能够在ListView中显示，因此，修改activity main.xml中的代码，如下所示：

简单起见，LinearLayout里就只放置了一个ListView。这里使用ListView而不是RecyclerView，是因为我们要将关注的重点放在读取系统联系人上面，如果使用RecyclerView的话，代码偏多, 会容易让我们找不着重点。  
接着修改MainActivity中的代码，如下所示：

package com.mxt.runtimepermissiontest;
    
    import android.Manifest;
    import android.content.pm.PackageManager;
    import android.database.Cursor;
    import android.os.Bundle;
    import android.provider.ContactsContract;
    import android.support.v4.app.ActivityCompat;
    import android.support.v4.content.ContextCompat;
    import android.support.v7.app.AppCompatActivity;
    import android.widget.ArrayAdapter;
    import android.widget.ListView;
    import android.widget.Toast;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class MainActivity extends AppCompatActivity { 
    
        ArrayAdapter<String> adapter;
        List<String> contactsList = new ArrayList<>();
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            ListView contactsView = (ListView) findViewById(R.id.contacts_view);
            adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,contactsList);
            contactsView.setAdapter(adapter);
            if(ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS) != PackageManager.PERMISSION_GRANTED){ 
                ActivityCompat.requestPermissions(this,new String[]{ Manifest.permission.READ_CONTACTS},1);
            }else{ 
                readContacts();
            }
        }
        private void readContacts(){ 
            Cursor cursor = null;
            try{ 
                cursor = getContentResolver().query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,null,null,null,null);
                if(cursor != null){ 
                    while (cursor.moveToNext()){ 
                        String displayName = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
                        String number = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER));
                        contactsList.add(displayName + "\n" + number);
                    }
                    adapter.notifyDataSetChanged();
                }
            }catch (Exception e){ 
                e.printStackTrace();
            }finally { 
                if (cursor != null){ 
                    cursor.close();
                }
            }
        }
        @Override
        public void onRequestPermissionsResult(int requestCode,String[] permissions,int[] grantResults){ 
            switch (requestCode){ 
                case 1:
                    if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){ 
                        readContacts();
                    }else { 
                        Toast.makeText(this,"授权失败",Toast.LENGTH_SHORT).show();
                    }
                    break;
                default:
            }
        }
    }

在onCreate()方法中，我们首先获取了 ListView控件的实例，并给它设置好了适配器，然 后开始调用运行时权限的处理逻辑，因为READ\_CONTACTS权限是属于危险权限的。关于运行 时权限的处理流程相信你已经熟练掌握了，这里我们在用户授权之后调用readContacts()方法 来读取系统联系人信息。  
下面重点看一下readContacts()方法，可以看到，这里使用了 ContentResolver的query() 方法来查询系统的联系人数据。不过传入的Uri参数怎么有些奇怪啊？为什么没有调用 Uri.parse()方法去解析一个内容UR\[字符串呢？这是因为ContactsContract .CommonData- Kinds.Phone类已经帮我们做好了封装，提供了一个CONTENT\_URI常量，而这个常量就是使用 Uri.parse()方法解析出来的结果。接着我们对Cursor对象进行遍历，将联系人姓名和手机号 这些数据逐个取出，联系人姓名这一列对应的常量是ContactsContract.CommonDataKinds. Phone . DISPLAY NAME,联系人手机号这一列对应的常量是 ContactsContract.CommonData- Kinds.Phone.NUMBERO两个数据都取出之后，将它们进行拼接，并且在中间加上换行符，然后 将拼接后的数据添加到ListView的数据源里，并通知刷新一下ListViewo最后千万不要忘记将 Cursor对象关闭掉。  
这样就结束了吗？还差一点点，读取系统联系人的权限千万不能忘记声明。修改 AndroidManifest.xml中的代码，如下所示：

<uses-permission android:name="android.permission.READ_CONTACTS"/>

加入了 android.permission.READ\_CONTACTS权限，这样我们的程序就可以访问到系统的联系人数据了。现在才算是大功告成了，让我们来运行一下程序吧，效果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 6]  
首先弹出了申请访问联系人权限的对话框，我们点击ALLOW,然后结果如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 7]

刚刚添加的两个联系人的数据都成功读取出来了！这说明跨程序访问数据的功能确实是实现了。

# 4.创建自己的内容提供器 #

在上一节当中，我们学习了如何在自己的程序中访问其他应用程序的数据。总体来说思路还是非常简单的，只需要获取到该应用程序的内容URI，然后借助ContentResolver进行CRUD操作就可以了。可是你有没有想过，那些提供外部访问接口的应用程序都是如何实现这种功能的呢？它们又是怎样保证数据的安全性，使得隐私数据不会泄漏出去？学习完本节的知识后，你的疑惑将会被——解开。

## 4.1 创建内容提供器的步骤 ##

前面已经提到过，如果想要实现跨程序共享数据的功能，官方推荐的方式就是使用内容提供器，可以通过新建一个类去继承Contentprovider的方式来创建一个自己的内容提供器。 Contentprovider类中有6个抽象方法，我们在使用子类继承它的时候，需要将这6个方法全 部重写。新建MyProvider继承自Contentprovider，代码如下所示：

package com.mxt.runtimepermissiontest;
    
    import android.content.ContentProvider;
    import android.content.ContentValues;
    import android.database.Cursor;
    import android.net.Uri;
    import android.support.annotation.NonNull;
    import android.support.annotation.Nullable;
    
    public class MyProvider extends ContentProvider { 
        @Override
        public boolean onCreate() { 
            return false;
        }
    
        @Nullable
        @Override
        public Cursor query(@NonNull Uri uri, @Nullable String[] strings, @Nullable String s, @Nullable String[] strings1, @Nullable String s1) { 
            return null;
        }
    
        @Nullable
        @Override
        public String getType(@NonNull Uri uri) { 
            return null;
        }
    
        @Nullable
        @Override
        public Uri insert(@NonNull Uri uri, @Nullable ContentValues contentValues) { 
            return null;
        }
    
        @Override
        public int delete(@NonNull Uri uri, @Nullable String s, @Nullable String[] strings) { 
            return 0;
        }
    
        @Override
        public int update(@NonNull Uri uri, @Nullable ContentValues contentValues, @Nullable String s, @Nullable String[] strings) { 
            return 0;
        }
    }

在这6个方法中，相信大多数你都已经非常熟悉了，我再来简单介绍一下吧。

1.  onCreate()  
    初始化内容提供器的时候调用。通常会在这里完成对数据库的创建和升级等操作，返回true 表示内容提供器初始化成功，返回false则表示失败。注意，只有当存在ContentResolver尝试 访问我们程序中的数据时，内容提供器才会被初始化。
2.  query()  
    从内容提供器中查询数据。使用uri参数来确定查询哪张表，projection参数用于确定查 询哪些列，selection和selectionArgs参数用于约束查询哪些行，sortOrder参数用于对结 果进行排序，查询的结果存放在Cursor对象中返回。
3.  insertf)  
    向内容提供器中添加一条数据。使用uri参数来确定要添加到的表，待添加的数据保存在 values参数中。添加完成后，返回一个用于表示这条新记录的URI。
4.  update()  
    更新内容提供器中已有的数据。使用uri参数来确定更新哪一张表中的数据，新数据保存在 values参数中，selection和selectionArgs参数用于约束更新哪些行，受影响的行数将作 为返回值返回。
5.  delete()  
    从内容提供器中删除数据。使用uri参数来确定删除哪一张表中的数据，selection和 selectionArgs参数用于约束删除哪些行，被删除的行数将作为返回值返回。
6.  getType()  
    根据传入的内容URI来返回相应的MIME类型。  
    可以看到，几乎每一个方法都会带有Uri这个参数，这个参数也正是调用ContentResolver 的增删改查方法时传递过来的。而现在，我们需要对传入的Uri参数进行解析，从中分析出调用 方期望访问的表和数据。

回顾一下，一个标准的内容URI写法是这样的：

content://com.example.app.provider/tablel

这就表示调用方期望访问的是com.example.app这个应用的table 1表中的数据。除此之外， 我们还可以在这个内容URI的后面加上一个id,如下所示：

content://com.example.app.provider/table1/1

这就表示调用方期望访问的是com.example.app这个应用的table1表中id为1的数据。  
内容URI的格式主要就只有以上两种，以路径结尾就表示期望访问该表中所有的数据，以 id结尾就表示期望访问该表中拥有相应id的数据。我们可以使用通配符的方式来分别匹配这两种格式的内容URI,规则如下。

*  \*：表示匹配任意长度的任意字符。
 *  \#：表示匹配任意长度的数字。

所以，一个能够匹配任意表的内容URI格式就可以写成：

content://com.example.app.provider/*

而一个能够匹配tablel表中任意一行数据的内容URI格式就可以写成:

content://com.example.app.provider/tablel/#

接着，我们再借助UriMatcher这个类就可以轻松地实现匹配内容URI的功能。UriMatcher 中提供了一个addURI()方法，这个方法接收3个参数，可以分别把authority, path和一个自定义代码传进去。这样，当调用UriMatcher的match()方法时，就可以将一个Uri对象传入， 返回值是某个能够匹配这个Uri对象所对应的自定义代码，利用这个代码，我们就可以判断出调用方期望访问的是哪张表中的数据了。修改MyProvider中的代码，如下所示：

package com.mxt.runtimepermissiontest;
    
    import android.content.ContentProvider;
    import android.content.ContentValues;
    import android.content.UriMatcher;
    import android.database.Cursor;
    import android.net.Uri;
    import android.support.annotation.NonNull;
    import android.support.annotation.Nullable;
    
    public class MyProvider extends ContentProvider { 
    
        public static final int TABLE1_DIR = 0;
        public static final int TABLE1_ITEM = 1;
        public static final int TABLE2_DIR = 2;
        public static final int TABLE2_ITEM = 3;
        private static UriMatcher uriMatcher;
        static { 
            uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
            uriMatcher.addURI("com.example.app.provider","table1",TABLE1_DIR);
            uriMatcher.addURI("com.example.app.provider ","table1/#",TABLE1_ITEM);
            uriMatcher.addURI("com.example.app.provider ","table2",TABLE2_DIR);
            uriMatcher.addURI("com.example.app.provider ","table2/#",TABLE2_ITEM);
        }
    
        @Override
        public boolean onCreate() { 
            return false;
        }
    
        @Nullable
        @Override
        public Cursor query(@NonNull Uri uri, @Nullable String[] strings, @Nullable String s, @Nullable String[] strings1, @Nullable String s1) { 
            switch (uriMatcher.match(uri)){ 
                case TABLE1_DIR:
                    break;
                case TABLE1_ITEM:
                    break;
                case TABLE2_DIR:
                    break;
                case TABLE2_ITEM:
                    break;
                default:
                    break;
            }
            return null;
        }
    
        @Nullable
        @Override
        public String getType(@NonNull Uri uri) { 
            return null;
        }
    
        @Nullable
        @Override
        public Uri insert(@NonNull Uri uri, @Nullable ContentValues contentValues) { 
            return null;
        }
    
        @Override
        public int delete(@NonNull Uri uri, @Nullable String s, @Nullable String[] strings) { 
            return 0;
        }
    
        @Override
        public int update(@NonNull Uri uri, @Nullable ContentValues contentValues, @Nullable String s, @Nullable String[] strings) { 
            return 0;
        }
    }

可以看到，MyProvider中新增了4个整型常量，其中TABLE1\_DIR表示访问table1表中的所有数据，TABLE1\_ITEM表示访问table1表中的单条数据，TABLE2\_DIR表示访问table2表中的所有数据，TABLE2\_ITEM表示访问table2表中的单条数据。接着在静态代码块里我们创建了 UriMatcher的实例，并调用addURI()方法，将期望匹配的内容URI格式传递进去，注意这里传入的路径参数是可以使用通配符的。然后当query()方法被调用的时候，就会通过UriMatcher 的match()方法对传入的Uri对象进行匹配，如果发现UriMatcher中某个内容URI格式成功匹配了该URI对象，则会返回相应的自定义代码，然后我们就可以判断出调用方期望访问的到底是 什么数据了。  
上述代码只是以query()方法为例做了个示范，其实insert()、update()、delete()这 几个方法的实现也是差不多的，它们都会携带Uri这个参数,然后同样利用UriMatcher的match() 方法判断出调用方期望访问的是哪张表，再对该表中的数据进行相应的操作就可以了。  
除此之外，还有一个方法你会比较陌生，即getType()方法。它是所有的内容提供器都必须提供的一个方法，用于获取Uri对象所对应的MIME类型。一个内容URI所对应的MIME字符串主要由3部分组成，Android对这3个部分做了如下格式规定。

*  必须以vnd开头。
 *  如果内容URI以路径结尾，则后接android.cursor.dir/,如果内容URI以id结尾， 则后接 android. cursor.item/。
 *  最后接上 `vnd.<authority>.<path>`。

所以，对于 content://com.example.app.provider/table1 这个内容 URI,它所对应的 MIME类型 就可以写成：

vnd.android.cursor.dir/vnd.com.example.app.provider.table1

对于 content://com.example.app.provider/tablel/1 这个内容 URI，它所对应的 MIME类型就可以写成：

vnd.android.cursor.item/vnd.com.example.app.provider.table1

现在我们可以继续完善MyProvider中的内容了，这次来实现getType()方法中的逻辑代码如下所示：

package com.mxt.runtimepermissiontest;
    
    import android.content.ContentProvider;
    import android.content.ContentValues;
    import android.content.UriMatcher;
    import android.database.Cursor;
    import android.net.Uri;
    import android.support.annotation.NonNull;
    import android.support.annotation.Nullable;
    
    public class MyProvider extends ContentProvider { 
    
        public static final int TABLE1_DIR = 0;
        public static final int TABLE1_ITEM = 1;
        public static final int TABLE2_DIR = 2;
        public static final int TABLE2_ITEM = 3;
        private static UriMatcher uriMatcher;
        static { 
            uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
            uriMatcher.addURI("com.example.app.provider","table1",TABLE1_DIR);
            uriMatcher.addURI("com.example.app.provider ","table1/#",TABLE1_ITEM);
            uriMatcher.addURI("com.example.app.provider ","table2",TABLE2_DIR);
            uriMatcher.addURI("com.example.app.provider ","table2/#",TABLE2_ITEM);
        }
    
        @Override
        public boolean onCreate() { 
            return false;
        }
    
        @Nullable
        @Override
        public Cursor query(@NonNull Uri uri, @Nullable String[] strings, @Nullable String s, @Nullable String[] strings1, @Nullable String s1) { 
            switch (uriMatcher.match(uri)){ 
                case TABLE1_DIR:
                    break;
                case TABLE1_ITEM:
                    break;
                case TABLE2_DIR:
                    break;
                case TABLE2_ITEM:
                    break;
                default:
                    break;
            }
            return null;
        }
    
        @Nullable
        @Override
        public String getType(@NonNull Uri uri) { 
            switch (uriMatcher.match(uri)){ 
                case TABLE1_DIR:
                    return "vnd.android.cursor.dir/vnd.com.example.app.provider.table1";
                case TABLE1_ITEM:
                    return "vnd.android.cursor.item/vnd.com.example.app.provider.table1";
                case TABLE2_DIR:
                    return "vnd.android.cursor.dir/vnd.com.example.app.provider.table2";
                case TABLE2_ITEM:
                    return "vnd.android.cursor.item/vnd.com.example.app.provider.table2";
                default:
                    break;
            }
            return null;
        }
    
        @Nullable
        @Override
        public Uri insert(@NonNull Uri uri, @Nullable ContentValues contentValues) { 
            return null;
        }
    
        @Override
        public int delete(@NonNull Uri uri, @Nullable String s, @Nullable String[] strings) { 
            return 0;
        }
    
        @Override
        public int update(@NonNull Uri uri, @Nullable ContentValues contentValues, @Nullable String s, @Nullable String[] strings) { 
            return 0;
        }
    }

到这里，一个完整的内容提供器就创建完成了，现在任何一个应用程序都可以使用ContentResolver来访问我们程序中的数据。那么前面所提到的，如何才能保证隐私数据不会泄漏出去呢？其实多亏了内容提供器的良好机制，这个问题在不知不觉中已经被解决了。因为所有的CRUD操作都一定要匹配到相应的内容URI格式才能进行的，而我们当然不可能向UriMatcher中添加隐私数据的URI，所以这部分数据根本无法被外部程序访问到，安全问题也就不存在了。  
好了，创建内容提供器的步骤你也已经清楚了，下面就来实战一下，真正体验一回跨程序数据共享的功能。

## 4.2 实现跨程序数据共享 ##

简单起见，我们还是在上一章项目的基础上继续开发，通过内容提供器来给它加入外部访问接口。打开项目，然后创建一个内容提供 器，右击《你的项目名》——>New——>Other——>Content Provider,会弹出如图所示的窗口：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 8]  
可以看到，这里我们将内容提供器命名为DatabaseProviderauthority指定为com.example, databasetest .provider，Exported属性表示是否允许外部程序访问我们的内容提供器， Enabled属性表示是否启用这个内容提供器。将两个属性都勾中，点击Finish完成创建。  
接着我们修改DatabaseProvider中的代码，如下所示：

package com.example.administrator.databasetest;
    
    import android.content.ContentProvider;
    import android.content.ContentValues;
    import android.content.UriMatcher;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.net.Uri;
    
    public class DatabaseProvider extends ContentProvider { 
        public static final int BOOK_DIR = 0;
        public static final int BOOK_ITEM = 1;
        public static final int CATEGORY_DIR = 2;
        public static final int CATEGORY_ITEM = 3;
        public static final String AUTHORITY = "com.example.databasetest.provider";
        private static UriMatcher uriMatcher;
        private MyDatabaseHelper dbHelper;
        static { 
            uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
            uriMatcher.addURI(AUTHORITY,"book",BOOK_DIR);
            uriMatcher.addURI(AUTHORITY,"book/#",BOOK_ITEM);
            uriMatcher.addURI(AUTHORITY,"category",CATEGORY_DIR);
            uriMatcher.addURI(AUTHORITY,"category/#",CATEGORY_ITEM);
        }
        public DatabaseProvider() { 
        }
    
        @Override
        public int delete(Uri uri, String selection, String[] selectionArgs) { 
            SQLiteDatabase db = dbHelper.getWritableDatabase();
            int deletedRows = 0;
            switch (uriMatcher.match(uri)){ 
                case BOOK_DIR:
                    deletedRows = db.delete("Book",selection,selectionArgs);
                    break;
                case BOOK_ITEM:
                    String bookId = uri.getPathSegments().get(1);
                    deletedRows = db.delete("Book","id = ?",new String[] { bookId});
                    break;
                case CATEGORY_DIR:
                    deletedRows = db.delete("Category",selection,selectionArgs);
                    break;
                case CATEGORY_ITEM:
                    String categoryId = uri.getPathSegments().get(1);
                    deletedRows = db.delete("Category","id = ?",new String[]{ categoryId});
                    break;
                default:
                    break;
            }
            return deletedRows;
        }
    
        @Override
        public String getType(Uri uri) { 
            switch (uriMatcher.match(uri)){ 
                case BOOK_DIR:
                    return "vnd.android.cursor.dir/vnd.com.example.databasetest.provider.book";
                case BOOK_ITEM:
                    return "vnd.android.cursor.item/vnd.com.example.databasetest.provider.book";
                case CATEGORY_DIR:
                    return "vnd.android.cursor.dir/vnd.com.example.databasetest.provider.category";
                case CATEGORY_ITEM:
                    return "vnd.android.cursor.item/vnd.com.example.databasetest.provider.category";
            }
            return null;
        }
    
        @Override
        public Uri insert(Uri uri, ContentValues values) { 
            SQLiteDatabase db = dbHelper.getWritableDatabase();
            Uri uriReturn = null;
            switch (uriMatcher.match(uri)){ 
                case BOOK_DIR:
                case BOOK_ITEM:
                    long newBookId = db.insert("Book",null,values);
                    uriReturn = Uri.parse("content://" + AUTHORITY + "/book/" + newBookId);
                    break;
                case CATEGORY_DIR:
                case CATEGORY_ITEM:
                    long newCategoryId = db.insert("Category",null,values);
                    uriReturn = Uri.parse("content://" + AUTHORITY + "/category/" + newCategoryId);
                    break;
                default:
                    break;
            }
            return uriReturn;
        }
    
        @Override
        public boolean onCreate() { 
            dbHelper = new MyDatabaseHelper(getContext(),"BookStore.db",null,2);
            return true;
        }
    
        @Override
        public Cursor query(Uri uri, String[] projection, String selection,
                            String[] selectionArgs, String sortOrder) { 
            SQLiteDatabase db = dbHelper.getReadableDatabase();
            Cursor cursor = null;
            switch (uriMatcher.match(uri)){ 
                case BOOK_DIR:
                    cursor = db.query("Book",projection,selection,selectionArgs,null,null,sortOrder);
                    break;
                case BOOK_ITEM:
                    String bookId = uri.getPathSegments().get(1);
                    cursor = db.query("Book",projection,"id = ?",new String[]{  bookId },null,null,sortOrder);
                    break;
                case CATEGORY_DIR:
                    cursor = db.query("Category",projection,selection,selectionArgs,null,null,sortOrder);
                    break;
                case CATEGORY_ITEM:
                    String categoryId = uri.getPathSegments().get(1);
                    cursor = db.query("Category",projection,"id = ?",new String[]{  categoryId },null,null,sortOrder);
                    break;
            }
            return cursor;
        }
    
        @Override
        public int update(Uri uri, ContentValues values, String selection,
                          String[] selectionArgs) { 
            SQLiteDatabase db = dbHelper.getWritableDatabase();
            int updateRows = 0;
            switch (uriMatcher.match(uri)){ 
                case BOOK_DIR:
                    updateRows = db.update("Book",values,selection,selectionArgs);
                    break;
                case BOOK_ITEM:
                    String bookId = uri.getPathSegments().get(1);
                    updateRows = db.update("Book",values,"id = ?",new String[] { bookId});
                    break;
                case CATEGORY_DIR:
                    updateRows = db.update("Category",values,selection,selectionArgs);
                    break;
                case CATEGORY_ITEM:
                    String categoryId = uri.getPathSegments().get(1);
                    updateRows = db.update("Category",values,"id = ?",new String[] { categoryId});
                    break;
                default:
                    break;
            }
            return updateRows;
        }
    }

代码虽然很长，不过不用担心，这些内容都非常容易理解，因为使用到的全部都是上一小节中我们学到的知识。首先在类的一开始，同样是定义了 4个常量，分别用于表示访问Book表中的所有数据、访问Book表中的单条数据、访问Category表中的所有数据和访问Category表中的单条数据。然后在静态代码块里对UriMatcher进行了初始化操作，将期望匹配的几种URI格式添加了进去。  
接下来就是每个抽象方法的具体实现了，先来看下onCreate()方法，这个方法的代码很短，就是创建了一个MyDatabaseHelper的实例，然后返回true表示内容提供器初始化成功，这时数据库就已经完成了创建或升级操作。  
接着看一下query()方法，在这个方法中先获取到了 SQLiteDatabase的实例，然后根据传入 的Uri参数判断出用户想要访问哪张表，再调用SQLiteDatabase的query()进行查询，并将 Cursor对象返回就好了。注意当访问单条数据的时候有一个细节，这里调用了 Uri对象的 getPathSegments()方法，它会将内容URI权限之后的部分以/符号进行分割，并把分割后的结果放入到一个字符串列表中，那这个列表的第0个位置存放的就是路径，第1个位置存放的就是id 了。得到了id之后，再通过selection和selectionArgs参数进行约束，就实现了查询单条数据的功能。  
再往后就是insert()方法，同样它也是先获取到了 SQLiteDatabase的实例，然后根据传入的Uri参数判断出用户想要往哪张表里添加数据，再调用SQLiteDatabase的insert()方法进行添加就可以了。注意insert()方法要求返回一个能够表示这条新增数据的URI，所以我们还需要调用Uri.parse()方法来将一个内容URI解析成Uri对象，当然这个内容URI是以新增数据的id结尾的。  
接下来就是update()方法了，相信这个方法中的代码已经完全难不倒你了。也是先获取 SQLiteDatabase的实例，然后根据传入的Uri参数判断出用户想要更新哪张表里的数据，再调用 SQLiteDatabase的update。方法进行更新就好了，受影响的行数将作为返回值返回。  
下面是delete()方法，是不是感觉越到后面越轻松了？因为你已经渐入佳境，真正地找到窍门了。这里仍然是先获取到SQLiteDatabase的实例，然后根据传入的Uri参数判断出用户想要删除哪张表里的数据，再调用SQLiteDatabase的delete。方法进行删除就好了，被删除的行数 将作为返回值返回。  
最后是getType()方法，这个方法中的代码完全是按照上一节中介绍的格式规则编写的，相信已经没有什么解释的必要了。这样我们就将内容提供器中的代码全部编写完了。  
另外还有一点需要注意，内容提供器一定要在AndroidManifest.xml文件中注册才可以使用。 不过幸运的是，由于我们是使用Android Studio的快捷方式创建的内容提供器，因此注册这一步已经被自动完成了。打开AndroidManifest.xml文件瞧一瞧，代码如下所示：

可以看到，`<application>`标签内出现了一个新的标签`<provider>`，我们使用它来对 DatabaseProvider这个内容提供器进行注册。android: name属性指定了 DatabaseProvider的类名，android:authorities 属性指定了 DatabaseProvider 的 authority,而 enabled 和 exported 属性则是根据我们刚才勾选的状态自动生成的，这里表示允许DatabaseProvider被其他应用程序进行 访问。  
现在这个项目就已经拥有了跨程序共享数据的功能了，我们赶快来尝试一下。 首先需要将该程序从模拟器中删除掉，以防止之前产生的遗留数据对我们造成干扰。然后运行一下项目，将程序重新安装在模拟器上。接着关闭掉这个项目，并创建一个新项目，我们就将通过这个程序去访问之前项目t中的数据。  
还是先来编写一下布局文件吧，修改activity main.xml中的代码，如下所示：

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    
        <Button
            android:id="@+id/add_data"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="在Book表中添加数据"/>
        <Button
            android:id="@+id/query_data"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="在Book表中查询数据"/>
        <Button
            android:id="@+id/updata_data"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="在Book表中更新数据"/>
        <Button
            android:id="@+id/delete_data"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="在Book表中删除数据"/>
    </LinearLayout>

布局文件很简单，里面放置了 4个按钮，分别用于添加、查询、修改和删除数据。然后修改 MainActivity中的代码，如下所示：

package com.example.administrator.providertest;
    
    import android.content.ContentValues;
    import android.database.Cursor;
    import android.net.Uri;
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    import android.widget.Button;
    
    public class MainActivity extends AppCompatActivity { 
        private String newId;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Button addData = (Button)findViewById(R.id.add_data);
            addData.setOnClickListener(new View.OnClickListener() { 
                @Override
                public void onClick(View v) { 
                    Uri uri = Uri.parse("content://com.example.databasetest.provider/book");
                    ContentValues values = new ContentValues();
                    values.put("name","A Clash of Kings");
                    values.put("author","George Martin");
                    values.put("pages",1040);
                    values.put("price",55.55);
                    Uri newUri = getContentResolver().insert(uri,values);
                    newId = newUri.getPathSegments().get(1);
                }
            });
            Button queryData = (Button)findViewById(R.id.query_data);
            queryData.setOnClickListener(new View.OnClickListener() { 
                @Override
                public void onClick(View v) { 
                    Uri uri = Uri.parse("content://com.example.databasetest.provider/book");
                    Cursor cursor = getContentResolver().query(uri,null,null,null,null);
                    if(cursor != null){ 
                        while (cursor.moveToNext()){ 
                            String name = cursor.getString(cursor.getColumnIndex("name"));
                            String author = cursor.getString(cursor.getColumnIndex("author"));
                            int pages = cursor.getInt(cursor.getColumnIndex("pages"));
                            double price = cursor.getDouble(cursor.getColumnIndex("price"));
                            Log.d("MainActivity","书的名字是" + name);
                            Log.d("MainActivity","书的作者是" + author);
                            Log.d("MainActivity","书的页数是" + pages);
                            Log.d("MainActivity","书的价格是" + price);
                        }
                        cursor.close();
                    }
                }
            });
            Button updateData = (Button)findViewById(R.id.updata_data);
            updateData.setOnClickListener(new View.OnClickListener() { 
                @Override
                public void onClick(View v) { 
                    Uri uri = Uri.parse("content://com.example.databasetest.provider/book/" + newId);
                    ContentValues values = new ContentValues();
                    values.put("name","A Strom of Swords");
                    values.put("pages",1216);
                    values.put("price",24.05);
                    getContentResolver().update(uri,values,null,null);
                }
            });
            Button deleteData = (Button)findViewById(R.id.delete_data);
            deleteData.setOnClickListener(new View.OnClickListener() { 
                @Override
                public void onClick(View v) { 
                    Uri uri = Uri.parse("content://com.example.databasetest.provider/book/" + newId);
                    getContentResolver().delete(uri,null,null);
                }
            });
        }
    }

可以看到，我们分别在这4个按钮的点击事件里面处理了增删改查的逻辑。添加数据的时候, 首先调用了 Uri.parse()方法将一个内容URI解析成对象，然后把要添加的数据都存放到 Contentvalues对象中，接着调用ContentResolver的insert()方法执行添加操作就可以了。 注意insert()方法会返回一个Uri对象，这个对象中包含了新增数据的id,我们通过getPathSegments()方法将这个id取出，稍后会用到它。  
查询数据的时候，同样是调用了 Uri.parse()方法将一个内容URI解析成Uri对象，然后调用ContentResolver的query()方法去查询数据，查询的结果当然还是存放在Cursor对 中的。之后对Cursor进行遍历，从中取出查询结果，并一一打印出来。  
更新数据的时候，也是先将内容URI解析成Uri对象，然后把想要更新的数据存放到 Contentvalues对象中，再调用ContentResolver的update()方法执行更新操作就可以了。 注意这里我们为了不想让Book表中的其他行受到影响，在调用Uri.parse()方法时，给内容URI的尾部增加了一个id，而这个id正是添加数据时所返回的。这就表示我们只希望更新刚刚添加的那条数据，Book表中的其他行都不会受影响。  
删除数据的时候，也是使用同样的方法解析了一个以id结尾的内容URI,然后调用 ContentResolver的delete()方法执行删除操作就可以了。由于我们在内容URI里指定了一个 id，因此只会删掉拥有相应id的那行数据，Book表中的其他数据都不会受影响。  
现在运行一下新项目，会显示如图所示的界面：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 9]  
点击一下第一个按钮，此时数据就应该已经添加到另一个程序的数据库中了, 我们可以通过点击第二个按钮来检查一下，打印日志如图所示：  
![在这里插入图片描述][20191110221641697.png]  
然后点击一下第三个按钮来更新数据，再点击一下第二个按钮进行检查, 结果如图所示：  
![在这里插入图片描述][20191110221649877.png]  
最后点击第四个按钮删除数据，此时再点击第三个按钮就查询不到数据了。由此可以看出，我们的跨程序共享数据功能已经成功实现了！现在不仅是新程 序，任何一个程序都可以轻松访问原程序中的数据，而且我们还丝毫不用担心隐私数据泄漏的问题。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191110220226226.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2019111022035433.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191110220420502.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191110220435284.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[20191110220633551.png]: https://img-blog.csdnimg.cn/20191110220633551.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191110220912173.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191110220925355.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191110221013280.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191110221028434.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20191110221608672.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20191110221631770.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5,size_16,color_FFFFFF,t_70
[20191110221641697.png]: https://img-blog.csdnimg.cn/20191110221641697.png
[20191110221649877.png]: https://img-blog.csdnimg.cn/20191110221649877.png