《第一行代码：Android篇》学习笔记（七）
本文和接下来的几篇文章为阅读郭霖先生所著《第一行代码：Android（篇第2版）》的学习笔记，按照书中的内容顺序进行记录，书中的Demo本人全部都做过了。每一章节本人都做了详细的记录，以下是我学习记录（包含大量书中内容的整理和自己在学习中遇到的各种bug及解决方案），方便以后阅读和查阅。最后，感激感激郭霖先生提供这么好的书籍。
第7章 跨程序共享数据——探究内容提供器
在上一章中我们学了Android数据持久化的技术，包括文件存储、SharedPreferences存储以及数据库存储。使用这些持久化技术所保存的数据都只能在当前应用程序中访问。
虽然文件和SharedPreferences存储中提供了MODE_WORLD_READABLE和MODE_WORLD_WRITEABLE这两种操作模式，用于供给其他的应用程序访问当前应用的数据，但这两种模式在Android 4.2版本中都已被废弃了。为什么呢？因为Android官方已经不再推荐使用这种方式来实现跨程序数据共享的功能，而是应该使用更加安全可靠的内容提供器技术。
为什么要将我们程序中的数据共享给其他程序呢？
当然，这个是要视情况而定的，比如说账号和密码这样的隐私数据显然是不能共享给其他程序的，不过一些可以让其他程序进行二次开发的基础性数据，我们还是可以选择将其共享的。例如系统的电话簿程序，它的数据库中保存了很多的联系人信息，如果这些数据都不允许第三方的程序进行访问的话，恐怕很多应用的功能都要大打折扣了。除了电话簿之外，还有短信、媒体库等程序都实现了跨程序数据共享的功能，而使用的技术当然就是内容提供器了，下面我们就来对这一技术进行深入的探讨。
7.1 内容提供器简介
内容提供器（Content Provider）主要用于在不同的应用程序之间实现数据共享的功能，它提供了一套完整的机制，允许一个程序访问另一个程序中的数据，同时还能保证被访数据的安全性。
目前，使用内容提供器是Android实现跨程序共享数据的标准方式。不同于文件存储和SharedPreferences存储中的两种全局可读写操作模式，内容提供器可以选择只对哪一部分数据进行共享，从而保证我们程序中的隐私数据不会有泄漏的风险。
不过在正式开始学习内容提供器之前，我们需要先掌握另外一个非常重要的知识——Android运行时权限，因为待会的内容提供器示例中会使用到运行时权限的功能。当然不光是内容提供器，以后我们的开发过程中也会经常使用到运行时权限，因此你必须能够牢牢掌握它才行。
7.2 运行时权限
Android的权限机制，从系统的第一个版本开始就已经存在了。但其实之前Android的权限机制在保护用户安全和隐私等方面起到的作用比较有限，尤其是一些大家都离不开的常用软件，非常容易“店大欺客”。为此，Android开发团队在Android 6.0系统中引用了运行时权限这个功能，从而更好地保护了用户的安全和隐私，那么本节我们就来详细学习一下这个6.0系统中引入的新特性。
7.2.1 Android权限机制详解
首先来回顾一下过去Android的权限机制是什么样的。在第5章写BroadcastTest项目的时候第一次接触了Android权限相关的内容，当时为了要访问系统的网络状态以及监听开机广播，于是在AndroidManifest.xml文件中添加了这样两句权限声明：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.zhouzhou.broadcasttest">
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
...
</manifest>
因为访问系统的网络状态以及监听开机广播涉及了用户设备的安全性，因此必须在AndroidManifest.xml中加入权限声明，否则我们的程序就会崩溃。
加入了这两句权限声明后，对于用户来说到底有什么影响呢？为什么这样就可以保护用户设备的安全性了呢？
其实用户主要在以下两个方面得到了保护，一方面，如果用户在低于6.0系统的设备上安装该程序，会在安装界面给出下图所示的提醒。这样用户就可以清楚地知晓该程序一共申请了哪些权限，从而决定是否要安装这个程序。
另一方面，用户可以随时在应用程序管理界面查看任意一个程序的权限申请情况，以此保证应用程序不会出现各种滥用权限的情况。
这种权限机制的设计思路其实非常简单，就是用户如果认可你所申请的权限，那么就会安装你的程序，如果不认可你所申请的权限，那么拒绝安装就可以了。
但是理想是美好的，现实却很残酷，因为很多我们所离不开的常用软件普遍存在着滥用权限的情况，不管到底用不用得到，反正先把权限申请了再说。比如说微信所申请的权限列表如图所示：
这只是微信所申请的一半左右的权限，因为权限太多一屏截不下来。其中有一些权限我并不认可，比如微信为什么要读取我手机的短信和彩信？但是我不认可又能怎样，难道我拒绝安装微信？
Android开发团队当然也意识到了这个问题，于是在6.0系统中加入了运行时权限功能。也就是说，用户不需要在安装软件的时候一次性授权所有申请的权限，而是可以在软件的使用过程中再对某一项权限申请进行授权。比如说一款相机应用在运行时申请了地理位置定位权限，就算我拒绝了这个权限，但是我应该仍然可以使用这个应用的其他功能，而不是像之前那样直接无法安装它。
当然，并不是所有权限都需要在运行时申请，对于用户来说，不停地授权也很烦琐。
Android现在将所有的权限归成了两类，一类是普通权限，一类是危险权限。准确地讲，其实还有第三类特殊权限，不过这种权限使用得很少，因此不在本书的讨论范围之内。
[*]普通权限：指的是那些不会直接威胁到用户的安全和隐私的权限，对于这部分权限申请，系统会自动帮我们进行授权，而不需要用户再去手动操作了，比如在BroadcastTest项目中申请的两个权限就是普通权限。
[*]危险权限：则表示那些可能会触及用户隐私或者对设备安全性造成影响的权限，如获取设备联系人信息、定位设备的地理位置等，对于这部分权限申请，必须要由用户手动点击授权才可以，否则程序就无法使用相应的功能。
但是，Android中有一共有上百种权限，我们怎么从中区分哪些是普通权限，哪些是危险权限呢？其实并没有那么难，因为危险权限总共就那么几个，除了危险权限之外，剩余的就都是普通权限了。下表列出了Android中所有的危险权限，一共是9组24个权限。
你并不需要了解表格中每个权限的作用，只要把它当成一个参照表来查看就行了。每当要使用一个权限时，可以先到这张表中来查一下，如果是属于这张表中的权限，那么就需要进行运行时权限处理，如果不在这张表中，那么只需要在AndroidManifest.xml文件中添加一下权限声明就可以了。
另外注意一下，表格中每个危险权限都属于一个权限组，我们在进行运行时权限处理时使用的是权限名，但是用户一旦同意授权了，那么该权限所对应的权限组中所有的其他权限也会同时被授权。访问：http://developer.android.google.cn/reference/android/Manifest.permission.html可以查看Android系统中完整的权限列表。
7.2.2 在程序运行时申请权限
新建一个RuntimePermissionTest项目，在这个项目的基础上来学习运行时权限的使用方法。
简单起见就使用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="Make Call"/>
</LinearLayout>
在布局文件中只是定义了一个按钮，当点击按钮时就去触发拨打电话的逻辑。接着修改MainActivity中的代码，如下所示：
package com.zhouzhou.runtimepermissiontest;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
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 view) {
try {
Intent intent = new Intent(Intent.ACTION_CALL);
intent.setData(Uri.parse("tel:10086"));
startActivity(intent);
} catch (SecurityException e) {
e.printStackTrace();
}
}
});
}
}
在按钮的点击事件中，构建了一个隐式Intent , Intent的action指定为Intent.ACTION_ CALL，这是一个系统内置的打电话的动作，然后在data部分指定了协议是tel，号码是10086。
（在2.3.3小节中就已经见过了，当时指定的action是Intent.ACTION_DIAL，表示打开拨号界面，这个是不需要声明权限的，而Intent.ACTION_ CALL则可以直接拨打电话，因此必须声明权限。）
另外为了防止程序崩溃，我们将所有操作都放在了异常捕获代码块当中。那么接下来修改AndroidManifest.xml文件，在其中声明如下权限：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.zhouzhou.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/Theme.RuntimePermissionTest">
...
</manifest>
这样我们就将拨打电话的功能成功实现了，并且在低于Android 6.0系统的手机上都是可以正常运行的，但是如果我们在6.0或者更高版本系统的手机上运行，点击Make Call按钮就没有任何效果，这时观察logcat中的打印日志，你会看到如图：
错误信息中提醒我们“Permission Denial”，可以看出，是由于权限被禁止所导致的，因为6.0及以上系统在使用危险权限时都必须进行运行时权限处理。那么下面我们就来尝试修复这个问题，修改MainActivity中的代码，如下所示：
package com.zhouzhou.runtimepermissiontest;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import android.Manifest;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
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 view) {
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, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode) {
case 1:
if (grantResults.length > 0 && grantResults == PackageManager.PERMISSION_GRANTED) {
call();
} else {
Toast.makeText(this,"You denied the permission",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按钮，效果如图：
由于用户还没有授权过我们拨打电话权限，因此第一次运行会弹出这样一个权限申请的对话框，用户可以选择同意或者拒绝，比如说这里点击了DENY，结果如图：
由于用户没有同意授权，我们只能弹出一个操作失败的提示。下面我们再次点击Make Call按钮，仍然会弹出权限申请的对话框，这次点击ALLOW，结果如图：
可以看到，这次我们就成功进入到拨打电话界面了，并且由于用户已经完成了授权操作，之后再点击Make Call按钮就不会再弹出权限申请对话框了，而是可以直接拨打电话。
用户随时都可以将授予程序的危险权限进行关闭，进入Settings → Apps→ RuntimePermissionTest → Permissions，在这里我们就可以对任何授予过的危险权限进行关闭了，界面如图：
7.3 访问其他程序中的数据
内容提供器的用法一般有两种：
[*]一种是使用现有的内容提供器来读取和操作相应程序中的数据。
[*]一种是创建自己的内容提供器给我们程序的数据提供外部访问接口。
使用现有的内容提供器：如果一个应用程序通过内容提供器对其数据提供了外部访问接口，那么任何其他的应用程序就都可以对这部分数据进行访问。
Android系统中自带的电话簿、短信、媒体库等程序都提供了类似的访问接口，这就使得第三方应用程序可以充分地利用这部分数据来实现更好的功能。下面我们就来看一看，内容提供器到底是如何使用的。
7.3.1 ContentResolver的基本用法
对于每一个应用程序来说，如果想要访问内容提供器中共享的数据，就一定要借助ContentResolver类，可以通过Context中的getContentResolver()方法获取到该类的实例。
ContentResolver中提供了一系列的方法用于对数据进行CRUD操作，其中insert()方法用于添加数据，update()方法用于更新数据，delete()方法用于删除数据，query()方法用于查询数据。
不同于SQLiteDatabase, ContentResolver中的增删改查方法都是不接收表名参数的，而是使用一个Uri参数代替，这个参数被称为内容URI。
内容URI给内容提供器中的数据建立了唯一标识符，它主要由两部分组成：authority和path。
[*]authority是用于对不同的应用程序做区分的，一般为了避免冲突，都会采用程序包名的方式来进行命名。比如某个程序的包名是com.example.app，那么该程序对应的authority就可以命名为com.example.app.provider。
[*]path则是用于对同一应用程序中不同的表做区分的，通常都会添加到authority的后面。比如某个程序的数据库里存在两张表：table1和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 = Uri.parse("content://com.example.app.provider/table1")
只需要调用Uri.parse()方法，就可以将内容URI字符串解析成Uri对象了。现在我们就可以使用这个Uri对象来查询table1表中的数据了，代码如下所示：
Cursor cursor = getContentResolver().query(
uri,
projection,
selection,
selectionArgs,
sortOrder);
这些参数和SQLiteDatabase中query()方法里的参数很像，但总体来说要简单一些，毕竟这是在访问其他程序中的数据，没必要构建过于复杂的查询语句。下表对使用到的这部分参数进行了详细的解释。
查询完成后返回的仍然是一个Cursor对象，这时就可以将数据从Cursor对象中逐个读取出来了。读取的思路仍然是通过移动游标的位置来遍历Cursor的所有行，然后再取出每一行中相应列的数据，代码如下所示：
if (cursor != null) {
while (cursor.moveToNext()) {
String column1 = cursor.getString(cursor.getColumnIndex("column1"));
int column2 = cursor.getInt(cursor.getColumnIndex("column2"));
}
cursor.close();
}
掌握了最难的查询操作，剩下的增加、修改、删除操作就更不在话下了。我们先来看看如何向table1表中添加一条数据，代码如下所示：
ContentValues values = new ContentValues();
values.put("column1","text");
values.put("column2",1);
getContentResolver().insert(uri,values);
可以看到，仍然是将待添加的数据组装到ContentValues中，然后调用ContentResolver的insert()方法，将Uri和ContentValues作为参数传入即可。现在如果我们想要更新这条新添加的数据，把column1的值清空，可以借助ContentResolver的update()方法实现，代码如下所示：
ContentValues values = new ContentValues();
values.put("column1","");
getContentResolver().update(uri,values,"column1 = ? and column2 = ? ",new String[] {"text","1"});
注意上述代码使用了selection和selectionArgs参数来对想要更新的数据进行约束，以防止所有的行都会受影响。最后，可以调用ContentResolver的delete()方法将这条数据删除掉，代码如下所示：
getContentResolver().delete(uri,"column2 = ? ",new String[] {"1"});
到这里为止，我们就把ContentResolver中的增删改查方法全部学完了。那么接下来，就利用目前所学，看一看如何读取系统电话簿中的联系人信息。
7.3.2 读取系统联系人
由于我们之前一直使用的都是模拟器，电话簿里面并没有联系人存在，所以现在需要自己手动添加几个，以便稍后进行读取。打开电话簿程序，界面如图：
目前电话簿里是没有任何联系人的，我们可以通过点击ADD ACONTACT按钮来对联系人进行创建。这里就先创建两个联系人吧，分别填入他们的姓名和手机号：
这样准备工作就做好了，现在新建一个ContactsTest项目。首先还是来编写一下布局文件，这里我们希望读取出来的联系人信息能够在ListView中显示，因此，修改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">
<ListView
android:id="@+id/contacts_view"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
</LinearLayout>
LinearLayout里就只放置了一个ListView。这里使用ListView而不是RecyclerView，是因为我们要将关注的重点放在读取系统联系人上面，如果使用RecyclerView的话，代码偏多，会容易让我们找不着重点。接着修改MainActivity中的代码，如下所示：
package com.zhouzhou.contactstest;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import android.Manifest;
import android.annotation.SuppressLint;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.os.Bundle;
import android.provider.ContactsContract;
import android.widget.ArrayAdapter;
import android.widget.Button;
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()) {
//获取联系人姓名
@SuppressLint("Range") String displayName = cursor.getString(cursor.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
//获取联系人手机号
@SuppressLint("Range") 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, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
switch (requestCode) {
case 1:
if (grantResults.length > 0 && grantResults == PackageManager.PERMISSION_GRANTED) {
readContacts();
} else {
Toast.makeText(this,"You denied the permission",Toast.LENGTH_SHORT).show();
}
break;
default:
}
}
}
在onCreate()方法中，我们首先获取了ListView控件的实例，并给它设置好了适配器，然后开始调用运行时权限的处理逻辑，因为READ_CONTACTS权限是属于危险权限的。这里在用户授权之后调用readContacts()方法来读取系统联系人信息。
下面重点看一下readContacts()方法，这里使用了ContentResolver的query()方法来查询系统的联系人数据。
不过，传入的Uri参数为什么没有调用Uri.parse()方法去解析一个内容URI字符串呢？
这是因为ContactsContract.CommonDataKinds.Phone类已经帮我们做好了封装，提供了一个CONTENT_URI常量，而这个常量就是使用Uri.parse()方法解析出来的结果。接着我们对Cursor对象进行遍历，将联系人姓名和手机号这些数据逐个取出，联系人姓名这一列对应的常量是ContactsContract.CommonDataKinds. Phone.DISPLAY_NAME，联系人手机号这一列对应的常量是ContactsContract.CommonData-Kinds.Phone.NUMBER。两个数据都取出之后，将它们进行拼接，并且在中间加上换行符，然后将拼接后的数据添加到ListView的数据源里，并通知刷新一下ListView。最后千万不要忘记将Cursor对象关闭掉。
读取系统联系人的权限千万不能忘记声明。修改AndroidManifest.xml中的代码，如下所示：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.zhouzhou.contactstest">
<uses-permission android:name="android.permission.READ_CONTACTS"/>
...
</manifest>
加入了android.permission.READ_CONTACTS权限，这样我们的程序就可以访问到系统的联系人数据了。来运行一下程序吧，效果如图：
首先弹出了申请访问联系人权限的对话框，我们点击DENY，然后结果如图：
点击ALLOW，刚刚添加的两个联系人的数据都成功读取出来了！这说明跨程序访问数据的功能确实是实现了。结果如图：
7.4 创建自己的内容提供器
上一节当中，思路还是非常简单的，只需要获取到该应用程序的内容URI，然后借助ContentResolver进行CRUD操作就可以了。
那些提供外部访问接口的应用程序都是如何实现这种功能的呢？它们又是怎样保证数据的安全性，使得隐私数据不会泄漏出去？学习完本节的知识后，疑惑将会被一一解开。
7.4.1 创建内容提供器的步骤
前面已经提到过，如果想要实现跨程序共享数据的功能，官方推荐的方式就是使用内容提供器，可以通过新建一个类去继承ContentProvider的方式来创建一个自己的内容提供器。ContentProvider类中有6个抽象方法，我们在使用子类继承它的时候，需要将这6个方法全部重写。新建MyProvider继承自ContentProvider，代码如下所示：
package com.zhouzhou.contactstest;
import android.content.ContentProvider;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import androidx.annotation.NonNull;
import androidx.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;
}
}
[*]onCreate()
初始化内容提供器的时候调用。通常会在这里完成对数据库的创建和升级等操作，返回true表示内容提供器初始化成功，返回false则表示失败。
[*]query()
从内容提供器中查询数据。使用uri参数来确定查询哪张表，projection参数用于确定查询哪些列，selection和selectionArgs参数用于约束查询哪些行，sortOrder参数用于对结果进行排序，查询的结果存放在Cursor对象中返回。
[*]insert()
向内容提供器中添加一条数据。使用uri参数来确定要添加到的表，待添加的数据保存在values参数中。添加完成后，返回一个用于表示这条新记录的URI。
[*]update()
更新内容提供器中已有的数据。使用uri参数来确定更新哪一张表中的数据，新数据保存在values参数中，selection和selectionArgs参数用于约束更新哪些行，受影响的行数将作为返回值返回。
[*]delete()
从内容提供器中删除数据。使用uri参数来确定删除哪一张表中的数据，selection和selectionArgs参数用于约束删除哪些行，被删除的行数将作为返回值返回。
[*]getType()
根据传入的内容URI来返回相应的MIME类型。
可以看到，几乎每一个方法都会带有Uri这个参数，这个参数也正是调用ContentResolver的增删改查方法时传递过来的。
而现在，我们需要对传入的Uri参数进行解析，从中分析出调用方期望访问的表和数据。回顾一下，一个标准的内容URI写法是这样的：
content://com.example.app.provider/table1
这就表示调用方期望访问的是com.example.app这个应用的table1表中的数据。除此之外，我们还可以在这个内容URI的后面加上一个id，如下所示：
content://com.example.app.provider/table1/1
内容URI的格式主要就只有以上两种，以路径结尾就表示期望访问该表中所有的数据，以id结尾就表示期望访问该表中拥有相应id的数据。我们可以使用通配符的方式来分别匹配这两种格式的内容URI，规则如下。
[*]星号（*） 表示匹配任意长度的任意字符。
[*]井号（#） 表示匹配任意长度的数字。
所以，一个能够匹配任意表的内容URI格式就可以写成：
content://com.example.app.provider/*
而一个能够匹配table1表中任意一行数据的内容URI格式就可以写成：
content://com.example.app.provider/table1/#
接着，再借助UriMatcher这个类就可以轻松地实现匹配内容URI的功能。UriMatcher中提供了一个addURI()方法，这个方法接收3个参数，可以分别把authority、path和一个自定义代码传进去。这样，当调用UriMatcher的match()方法时，就可以将一个Uri对象传入，返回值是某个能够匹配这个Uri对象所对应的自定义代码，利用这个代码，我们就可以判断出调用方期望访问的是哪张表中的数据了。修改MyProvider中的代码，如下所示：
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.zhouzhou.app.provider","table1",TABLE1_DIR);
uriMatcher.addURI("com.zhouzhou.app.provider","table1/#",TABLE1_ITEM);
uriMatcher.addURI("com.zhouzhou.app.provider","table2",TABLE2_DIR);
uriMatcher.addURI("com.zhouzhou.app.provider","table2/#",TABLE2_ITEM);
}
...
@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:
//查询table1表中的所有数据
break;
case TABLE1_ITEM:
//查询table1表中的单条数据
break;
case TABLE2_DIR:
//查询table2表中的所有数据
break;
case TABLE2_ITEM:
//查询table2表中的单条数据
break;
default:
break;
}
...
}
...
}
可以看到，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..。
所以，对于content://com.example.app.provider/table1这个内容URI，它所对应的MIME类型就可以写成：
vnd.android.cursor.dir/vnd.com.example.app.provider.table1
对于content://com.example.app.provider/table1/1这个内容URI，它所对应的MIME类型就可以写成：
vnd.android.cursor.item/vnd.com.example.app.provider.table1
可以继续完善MyProvider中的内容了，这次来实现getType()方法中的逻辑，代码如下所示：
...
public class MyProvider extends ContentProvider {
...
@Nullable
@Override
public String getType(@NonNull Uri uri) {
switch (uriMatcher.match(uri)) {
case TABLE1_DIR:
return "vnd.android.cursor.dir/vnd.com.zhouzhou.app.provider.table1";
case TABLE1_ITEM:
return "vnd.android.cursor.item/vnd.com.zhouzhou.app.provider.table1";
case TABLE2_DIR:
return "vnd.android.cursor.dir/vnd.com.zhouzhou.app.provider.table2";
case TABLE2_ITEM:
return "vnd.android.cursor.item/vnd.com.zhouzhou.app.provider.table2";
default:
break;
}
return null;
}
}
到这里，一个完整的内容提供器就创建完成了，现在任何一个应用程序都可以使用ContentResolver来访问我们程序中的数据。
那么,如何才能保证隐私数据不会泄漏出去呢？
内容提供器的良好机制使得这个问题在不知不觉中已经被解决了。因为所有的CRUD操作都一定要匹配到相应的内容URI格式才能进行的，而我们不可能向UriMatcher中添加隐私数据的URI，所以这部分数据根本无法被外部程序访问到，安全问题也就不存在了。实战一下，真正体验一回跨程序数据共享的功能。
7.4.2 实现跨程序数据共享
[*]在上一章中DatabaseTest项目的基础上继续开发，通过内容提供器来给它加入外部访问接口。
[*]打开DatabaseTest项目，首先将MyDatabaseHelper中使用Toast弹出创建数据库成功的提示去除掉，因为跨程序访问时我们不能直接使用Toast。
[*]然后，创建一个内容提供器，右击com.zhouzhou.databasetest包→New→Other→Content Provider。
会弹出如图所示的窗口：
[*]将内容提供器命名为DatabaseProvider。
[*]authority指定为com.zhouzhou. databasetest.provider。
[*]Exported属性表示是否允许外部程序访问我们的内容提供器。
[*]Enabled属性表示是否启用这个内容提供器。将两个属性都勾中，点击Finish完成创建。
接着我们修改DatabaseProvider中的代码，如下所示：
package com.zhouzhou.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.zhouzhou.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) {
// Implement this to handle requests to delete one or more rows.
//throw new UnsupportedOperationException("Not yet implemented");
//删除数据
SQLiteDatabase db = dbHelper.getWritableDatabase();
int deleteRows = 0;
switch (uriMatcher.match(uri)) {
case BOOK_DIR:
deleteRows = db.delete("Book",selection,selectionArgs);
break;
case BOOK_ITEM:
String bookId = uri.getPathSegments().get(1);
deleteRows = db.delete("Book","id = ?",new String[] { bookId });
break;
case CATEGORY_DIR:
deleteRows = db.delete("Category",selection,selectionArgs);
break;
case CATEGORY_ITEM:
String categoryId = uri.getPathSegments().get(1);
deleteRows = db.delete("Category","id = ?",new String[] { categoryId });
break;
default:
break;
}
returndeleteRows;
}
@Override
public String getType(Uri uri) {
// TODO: Implement this to handle requests for the MIME type of the data
// at the given URI.
//throw new UnsupportedOperationException("Not yet implemented");
switch (uriMatcher.match(uri)) {
case BOOK_DIR:
return "vnd.android.cursor.dir/vnd.com.zhouzhou.databasetest.provider.book";
case BOOK_ITEM:
return "vnd.android.cursor.item/vnd.com.zhouzhou.database.provider.book";
case CATEGORY_DIR:
return "vnd.android.cursor.dir/vnd.com.zhouzhou.databasetest.provider.category";
case CATEGORY_ITEM:
return "vnd.android.cursor.item/vnd.com.zhouzhou.databasetest.provider.category";
}
return null;
}
@Override
public Uri insert(Uri uri, ContentValues values) {
// TODO: Implement this to handle requests to insert a new row.
//throw new UnsupportedOperationException("Not yet implemented");
//添加数据
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() {
// TODO: Implement this to initialize your content provider on startup.
dbHelper = new MyDatabaseHelper(getContext(),"BookStore.db",null,2);
return true;
}
@Override
public Cursor query(Uri uri, String[] projection, String selection,
String[] selectionArgs, String sortOrder) {
// TODO: Implement this to handle query requests from clients.
//throw new UnsupportedOperationException("Not yet implemented");
//查询数据
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;
default:
break;
}
return cursor;
}
@Override
public int update(Uri uri, ContentValues values, String selection,
String[] selectionArgs) {
// TODO: Implement this to handle requests to update one or more rows.
//throw new UnsupportedOperationException("Not yet implemented");
//更新数据
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文件瞧一瞧，代码如下所示：
<provider
android:name=".DatabaseProvider"
android:authorities="com.zhouzhou.databasetest.provider"
android:enabled="true"
android:exported="true"></provider>
可以看到，<application>标签内出现了一个新的标签<provider>，使用它来对DatabaseProvider这个内容提供器进行注册。android:name属性指定了DatabaseProvider的类名，android:authorities属性指定了DatabaseProvider的authority，而enabled和exported属性则是根据刚才勾选的状态自动生成的，这里表示允许DatabaseProvider被其他应用程序进行访问。
现在DatabaseTest这个项目就已经拥有了跨程序共享数据的功能了。
[*]首先，需要将DatabaseTest程序从模拟器中删除掉，以防止上一章中产生的遗留数据对我们造成干扰。
[*]然后，运行一下项目，将DatabaseTest程序重新安装在模拟器上了。
[*]接着，关闭掉DatabaseTest这个项目，并创建一个新项目ProviderTest，我们就将通过这个程序去访问DatabaseTest中的数据。
还是先来编写一下布局文件吧，修改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:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/add_data"
android:text="Add To Book"/>
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/query_data"
android:text="Query From Book"/>
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/update_data"
android:text="Update Book"/>
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/delete_data"
android:text="Delete From Book"/>
</LinearLayout>
布局文件很简单，里面放置了4个按钮，分别用于添加、查询、修改和删除数据。然后修改MainActivity中的代码，如下所示：
package com.zhouzhou.providertest;
import androidx.appcompat.app.AppCompatActivity;
import android.annotation.SuppressLint;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
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 view) {
//添加数据
Uri uri = Uri.parse("content://com.zhouzhou.databasetest.provider/book");
ContentValues values = new ContentValues();
values.put("name","A Clash of Kings");
values.put("author","George Martin");
values.put("pages","1024");
values.put("price","22.85");
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 view) {
//查询数据
Uri uri = Uri.parse("content://com.zhouzhou.databasetest.provider/book");
Cursor cursor = getContentResolver().query(uri,null,null,null,null);
if (cursor != null) {
while (cursor.moveToNext()) {
@SuppressLint("Range") String name = cursor.getString(cursor.getColumnIndex("name"));
@SuppressLint("Range") String author = cursor.getString(cursor.getColumnIndex("author"));
@SuppressLint("Range") int pages = cursor.getInt(cursor.getColumnIndex("pages"));
@SuppressLint("Range") double price = cursor.getDouble(cursor.getColumnIndex("price"));
Log.d("MainActivity","book name is " + name);
Log.d("MainActivity","book author is " + author);
Log.d("MainActivity","book pages is " + pages);
Log.d("MainActivity","book price is " + price);
}
cursor.close();
}
}
});
Button updateData = (Button) findViewById(R.id.update_data);
updateData.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//更新数据
Uri uri = Uri.parse("content://com.zhouzhou.databasetest.provider./book" + newId);
ContentValues values = new ContentValues();
values.put("name","A Storm of Swords");
values.put("pages",1216);
values.put("price","77.77");
getContentResolver().update(uri,values,null,null);
}
});
Button deleteData = (Button) findViewById(R.id.delete_data);
deleteData.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//删除数据
Uri uri = Uri.parse("content://com.zhouzhou.databasetest.book" + newId);
getContentResolver().delete(uri,null,null);
}
});
}
}
分别在这4个按钮的点击事件里面处理了增删改查的逻辑。
添加数据的时候，首先调用了Uri.parse()方法将一个内容URI解析成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表中的其他数据都不会受影响。
现在，运行一下ProviderTest项目，出现几大问题：
[*]日志报错：Failed to find provider info for com.zhouzhou.databasetest.provider，Unknown URL content:...
原因是：因为测试用的模拟器的SDK是API 30的，该版本（Android 11）的更新中，改变了当前应用于本机其他应用进行交互的方式，由此若按照一些教程的例程去学习，会出现以上的一些访问权限问题。
[*]启动两个App后，出现屏幕闪烁/黑屏
解决：参考博客：https://blog.csdn.net/qq_34727886/article/details/110951082。
删除所有 device 模拟器，关闭AS再重新来过（解决闪烁/黑屏/屏幕有点呆/无法卸载应用的问题）），并且分别在DatabaseTest项目的AndroidManifest.xml文件的manifest中加入如下代码：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.zhouzhou.databasetest">
<uses-permission android:name="android.permission.INTERNET" />
<permission
android:name="DatabaseProvider._READ_PERMISSION"
android:protectionLevel="normal" />
<permission
android:name="DatabaseProvider._WRITE_PERMISSION"
android:protectionLevel="normal" />
<application
...
</application>
</manifest>
在ProviderTest项目的AndroidManifest.xml文件中的manifest中加入如下代码：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.zhouzhou.providertest">
<uses-permission android:name="DatabaseProvider._READ_PERMISSION" />
<uses-permission android:name="DatabaseProvider._WRITE_PERMISSION" />
<queries>
<package android:name="com.zhouzhou.databasetest" />
<!-- 也可以单独指定provider -->
<!--<provider android:authorities="com.zhouzhou.databasetest.provider" />-->
</queries>
<application
...
</application>
</manifest>
修改之后再次运行，完全OK，点击一下Add To Book按钮，此时数据就应该已经添加到DatabaseTest程序的数据库中了，我们可以通过点击Query From Book按钮来检查一下，打印日志如图：
然后，点击一下Update Book按钮来更新数据，再点击一下Query From Book按钮进行检查，结果如图：
最后，点击Delete From Book按钮删除数据，测试Ok。
由此可以看出，我们的跨程序共享数据功能已经成功实现了！经过测试，单开ProviderTest程序取数据完全OK。 现在不仅是ProviderTest程序，任何一个程序都可以轻松访问DatabaseTest中的数据，而且还丝毫不用担心隐私数据泄漏的问题。
7.5 Git时间——版本控制工具进阶
在上一次学习了关于Git最基本的用法，包括安装Git、创建代码仓库，以及提交本地代码。
本节中将要学习更多的使用技巧，准备工作，给一个项目创建代码仓库，这里就选择在ProviderTest项目中创建吧，打开Git Bash，进入到这个项目的根目录下面，然后执行git init命令，如图：
这样准备工作就已经完成了，让我们继续开始Git之旅吧。
7.5.1 忽略文件
代码仓库现在已经创建好了，接下来应该去提交ProviderTest项目中的代码。在提交之前你也许应该思考一下，是不是所有的文件都需要加入到版本控制当中呢？
在第1章介绍Android项目结构的时候有提到过，build目录下的文件都是编译项目时自动生成的，我们不应该将这部分文件添加到版本控制当中，那么如何才能实现这样的效果呢？
Git提供了一种可配性很强的机制来允许用户将指定的文件或目录排除在版本控制之外，它会检查代码仓库的目录下是否存在一个名为.gitignore的文件，如果存在的话，就去一行行读取这个文件中的内容，并把每一行指定的文件或目录排除在版本控制之外。注意.gitignore中指定的文件或目录是可以使用“*”通配符的。
我们并不需要自己去创建.gitignore文件，Android Studio在创建项目的时候会自动帮我们创建出两个.gitignore文件，一个在根目录下面，一个在app模块下面。首先看一下根目录下面的.gitignore文件，如图：
这是Android Studio自动生成的一些默认配置，通常情况下，这部分内容都是不用添加到版本控制当中的。除了*.iml表示指定任意以.iml结尾的文件，其他都是指定的具体的文件名或者目录名，上面配置中的所有内容都不会被添加到版本控制当中，因为基本都是一些由IDE自动生成的配置。
再来看一下app模块下面的.gitignore文件，这个就简单多了，如图：
由于app模块下面基本都是我们编写的代码，因此默认情况下只有其中的build目录不会被添加到版本控制当中。当然，我们完全可以对以上两个文件进行任意地修改，来满足特定的需求。比如说，app模块下面的所有测试文件都只是给我自己使用的，我并不想把它们添加到版本控制中，那么就可以这样修改app/.gitignore文件中的内容：
/build
/src/test
/src/androidTest
只需添加这样两行配置，因为所有的测试文件都是放在这两个目录下的。现在我们可以提交代码了，先使用add命令将所有的文件进行添加，如下所示：
git add .
然后执行commit命令完成提交，如下所示：
git commit -m "First commit."
7.5.2 查看修改内容
在进行了第一次代码提交之后，我们后面还可能会对项目不断地进行维护或添加新功能等。比较理想的情况是每当完成了一小块功能，就执行一次提交。
但是如果某个功能牵扯到的代码比较多，有可能写到后面的时候我们就已经忘记前面修改了什么东西了。遇到这种情况时不用担心，Git全都帮你记着呢！如何使用Git来查看自上次提交后文件修改的内容，只需要使用status命令就可以了，在项目的根目录下输入如下命令：
git status
然后，Git会提示目前项目中没有任何可提交的文件，因为我们刚刚才提交过嘛。现在对ProviderTest项目中的代码稍做一下改动，修改MainActivity中的代码，如下所示：
public class MainActivity extends AppCompatActivity {
...
@Override
protected void onCreate(Bundle savedInstanceState) {
...
addData.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
//添加数据
...
values.put("price","11.11");
...
}
});
...
}
}
这里仅仅是在添加数据的时候，将书的价格由22.85改成了11.11。然后重新输入git status命令，这次结果如图：
可以看到，Git提醒我们MainActivity.java这个文件已经发生了更改，那么如何才能看到更改的内容呢？这就需要借助diff命令了，用法如下所示：
git diff
这样可以查看到所有文件的更改内容，如果你只想查看MainActivity.java这个文件的更改内容，可以使用如下命令：
git diff app/src/main/java/com/zhouzhou/providertest/MainActivity.java
图片和上图一样，因为刚刚测试，只改了MainActivity.java这个文件的内容。
其中，减号代表删除的部分，加号代表添加的部分。从图中我们就可以明显地看出，书的价格由22.85被修改成了11.11。
7.5.3 撤销未提交的修改
有时候我们的代码可能会写得过于草率，以至于原本正常的功能，结果反倒被我们改出了问题。遇到这种情况时也不用着急，因为只要代码还未提交，所有修改的内容都是可以撤销的。
比如，在上一小节中我们修改了MainActivity里一本书的价格，现在如果想要撤销这个修改就可以使用checkout命令，用法如下所示：
git checkout app/src/main/java/com/zhouzhou/providertest/MainActivity.java
执行了这个命令之后，我们对MainActivity.java这个文件所做的一切修改就应该都被撤销了。
这种撤销方式只适用于那些还没有执行过add命令的文件，如果某个文件已经被添加过了，这种方式就无法撤销其更改的内容，我们来做个试验瞧一瞧。首先，仍然是将MainActivity中那本书的价格改成11.11，然后输入如下命令：
git add .
这样就把所有修改的文件都进行了添加，可以输入git status来检查一下，结果如图：
现在我们再执行一遍checkout命令，你会发现MainActivity仍然是处于已添加状态，所修改的内容无法撤销掉。
这种情况应该怎么办？难道我们还没法后悔了？当然不是，只不过对于已添加的文件我们应该先对其取消添加，然后才可以撤回提交。取消添加使用的是reset命令，用法如下所示：
git reset HEAD app/src/main/java/com/zhouzhou/providertest/MainActivity.java
然后再运行一遍git status命令，你就会发现MainActivity.java这个文件重新变回了未添加状态，此时就可以使用checkout命令来将修改的内容进行撤销了。
7.5.4 查看提交记录
当ProviderTest这个项目开发了几个月之后，可能已经执行过上百次的提交操作了，这个时候估计你早就已经忘记每次提交都修改了哪些内容。忠实的Git一直都帮我们清清楚楚地记录着。可以使用log命令查看历史提交信息，用法如下所示：
git log
由于目前我们只执行过一次提交，所以能看到的信息很少，如图：
可以看到，每次提交记录都会包含提交id、提交人、提交日期以及提交描述这4个信息。那么，我们再次将书价修改成11.11，然后执行一次提交操作，如下所示：
git add .
git commit -m "Change price"
现在，重新执行git log命令，结果如图：
当提交记录非常多的时候，如果我们只想查看其中一条记录，可以在命令中指定该记录的id，并加上-1参数表示只想看到一行记录，如下所示：
git log ca9f912bXXXXXXXXXXXXXXXXXXXXXXXXXXe20a77f -1
而如果想要查看这条提交记录具体修改了什么内容，可以在命令中加入-p参数，命令如下：
git log ca9f912bXXXXXXXXXXXXXXXXXXXXXXXXXXe20a77f -1 -p
查询出的结果如下图所示，其中减号代表删除的部分，加号代表添加的部分。
在本章中，先了解了Android的权限机制，并且学会了如何在6.0以上的系统中使用运行时权限，然后又重点学习了内容提供器的相关内容，以实现跨程序数据共享的功能，还学习了怎样创建自己的内容提供器来共享数据。
不过，只有真正需要将数据共享出去的时候我们才应该创建内容提供器，仅仅是用于程序内部访问的数据就没有必要这么做，所以千万别对它进行滥用。
个人学习笔记，针对本人在自学中遇到的问题。
https://www.cnblogs.com/1693977889zz/p/16256360.html
页:
[1]