《第一行代码》第七章跨程序共享数据——探究内容提供器

喜欢ヅ旅行 2021-09-26 14:30 438阅读 0赞

### 7.1 内容提供器简介 ###

内容提供器：用于在不同的应用程序之间实现数据共享功能，是Android实现跨程序共享数据的标准方式。能够保证被访数据的安全性。

可以选择只对某部分数据进行共享。

### 7.2 运行时权限 ###

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

####  ####

1、在学习通知广播那章曾经用过，我们在AndroidManifest.xml中添加权限声明。

2、6.0系统中加入了运行时权限功能，也就是说，用户不需要在安装软件时一次性授权所有的申请的权限，而是可以在使用的过程中对某一项权限申请授权。

3、Android将所有的权限分成了两类：

（1）普通权限：不会直接威胁到用户安全和隐私的权限。对这部分权限的申请，系统会自动帮我们进行授权，无需用户手动操作，例如：网络状态、监听开机广播。

（2）危险权限：可能触及用户隐私、或者对设备安全性造成影响的权限。对于这部分权限的申请，必须由用户手动授权，例如：获取设备联系人信息、定位设备的地理位置的。

4、权限那么多很难记？？其实危险权限只有9组24个（见下表），其余都是普通权限。

![20180402160106338][]

5、使用：先看一下是不是危险权限，如果不是，只要在AndroidManifest.xml中添加权限声明。表格中的每个危险权限都属于一个权限组，在运行时权限处理使用的是**权限名**，但一旦用户同意授权了，那么该权限所对应的权限组中的**所有其他权限也会同时被授权。**

7.2.2 在程序运行时申请权限

**1、范例1：在程序运行时申请权限**

（1）RuntimePermissionTest项目

（2）activity\_main.xml

（3）MainActivity.java

（4）AndroidManifest.xml

（5）运行结果

在6.0以下的系统中运行时能成功的，但是6.0及以上系统运行不正常，日志表示：permission denial.

![70][]

**2、范例2：6.0以上的系统中，要进行运行时权限处理。**

（1）MainActivity.java

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){
                       //如果没有授权，就调用以下方法来向用户申请授权。参数分别是：Activity实例、权限名、请求码
                       //调用这个方法时，系统会出现申请权限的对话框。不论用户选择什么，下一步程序进入onRequestPermissionsResult
                       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);//使用了一个隐式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, "You denied the permission",Toast.LENGTH_SHORT).show();
                    }
                    break;
                default:
            }
        }
    }

（2）运行结果

\--第一次运行，会出现选择对话框

![70 1][]

如果选择denied，出现toast提示。选择allow，则进入拨号界面。

![70 2][]

如果想更改权限的选择，则需要到设置中更改了。

### 7.3 访问其他程序中的数据 ###

内容提供其的用法一般分为两种：1-使用**现有的内容提供器**来读取和操作相应程序中的数据；2-创建**自己的内容提供器**给我们程序的数据提供外部访问接口。

若一个应用程序通过内容提供器对其数据提供了外部访问接口，那么任何其他应用程序都可以对这部分数据进行访问。例如：android系统中自带的电话簿、短信、媒体库。

#### 7.3.1 ContentResolver 的基本用法 ####

1、ContentResolver是一个类，每个应用程序，若想访问内容提供器中的数据，就一定得借助这个类。

通过Context.getContentResolver() 获得该类的实例，ContentResolver中提供了一系列方法对数据进行CRUD操作。

2、这些CRUD操作的方法不接受表名（因为共享的数据很多，哪儿知道是哪个程序的哪张表），接收的是**内容Uri。**

**    内容Uri：为内容提供器中的数据提供了唯一的标识符。**

组成：authority+path两部分

-authority：为了区分不同的程序，一般采用程序包名来命名；

-path：为了区分同一程序不同的表，通常会添加在authority后面。

Uri的标准格式：content://com.example.app.provider/table1

解析成对象：Uri uri = Uri.parse("content://com.example.app.provider/table1")

3、查询功能实现

（1）语法：Cursor cursor = getContentResolver().query(uri, projection, selection, selectionArgs, sortOder);

uri-指定查询谋和应用程序下的某张表

projection-指定查询的列名

selection-where的查询条件

selectionArgs-为where中的占位符提供具体的值

sortOder-查询结果的排序方式

（2）把数据从cursor中读取出来

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

4、增加数据

ContentValues values=new ContentValues();
        values.put("clumn1","text");
        values.put("clumn2","1");
        getContentResolver().insert(uri, values);

5、更新数据

ContentValues values=new ContentValues();
        values.put("clumn1","");
        getContentResolver().update(uri, values, "clumn1=? and clumn2=?",new String[]{"text",1});

6、删除数据

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

### 7.3.2 读取系统联系人 ###

1、范例1：读取系统联系人

（1）新建项目：ContactsTest

（2）在模拟器里新建两个联系人信息

（3）layout\_main.xml：放入一个listView

（4）MainActivity.java

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,"you denied the permission", Toast.LENGTH_SHORT).show();
                    }
                    break;
                default:
            }
        }
    }

（5）AndroidManifest.xml：修改权限

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

（6）运行结果

![70 3][]

### 7.4 创建自己的内容提供器 ###

#### 7.4.1 创建内容提供器步骤 ####

1、通过新建一个类去继承ContentProvider的方式，创建自己的内容提供器。ContentProvider有6个抽象方法，必须重写。

2、范例1：新建MyProvider类继承自ContentProvider（Ctrl+o重写快捷键！）

public class MyProvider extends ContentProvider {
    
        @Override
        public boolean onCreate() {
            //初始化内容提供器时调用，通常在这里：创建、升级数据库。
            //返回true: 内容提供器初始化成功。
            //只有当ContentResolver尝试访问程序中的数据时，内容提供器才会初始化
            return false;
        }
    
        @Nullable//表示标注方法能传入null值
        @Override
        public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
            return null;
        }
    
        @Nullable
        @Override
        public Uri insert(Uri uri, ContentValues values) {
            return null;//返回用来表示这条新纪录的URI
        }
    
        @Override
        public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
            return 0;
        }
    
        @Override
        public int delete(Uri uri, String selection, String[] selectionArgs) {
            return 0;
        }
    
        @Nullable
        @Override
        public String getType(Uri uri) {
            return null;
        }
    }

3、（1）Uri的标准格式：content://com.example.app.provider/table1

（2）其他格式：content://com.example.app.provider/table1/1   （表示table1中id为1的数据）

（3）可以使用通配符来分别匹配这两种格式的Uri：

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

例如，一个能够匹配任意表的内容的Uri格式可以写成：content://com.example.app.provider/\*

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

例如，一个能匹配table中任意一行数据的内容的Uri格式可以写成：content://com.example.app.provider/table1/\#

（4）范例2：query()使用示范

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//表示标注方法能传入null值
        @Override
        public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
            switch (uriMatcher.match(uri)){
                case TABLE1_DIR:
                    //查询表1中的所有数据
                    break;
                case TABLE1_ITEM:
                    //查询表1中的单条数据
                    break;
                case TABLE2_DIR:
                    //查询表2中的所有数据
                    break;
                case TABLE2_ITEM:
                    //查询表2中的单条数据
                    break;
            }
            
            return null;
        }

（4）getType()使用示范

作用：能够获得对象所对应的MIME类型

MIME类型：即多用途Internet邮件扩展类型，是一种标准化的方式来表示文档的性质和格式

规范-三部分组成：

1-必须是vnd开头；

2-若Uri以路径结尾，则vnd后接：android.cursor.dir/，若以id结尾，则跟android.cursor.item/

3-最后接上：vnd.<authority>.<path>

public String getType(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;
        }

（其实有点点不理解，先记着吧！）

7.4.2 实现跨程序数据共享

范例3：改装之前那个DatabaseTest项目，然后重新建一个项目ProviderTest项目，数据库存储在DatabaseTest目录下，但是却能够通过ProviderTest程序来操作。

1、将模拟器中原有的DatabaseTest卸载。

2、改写DatabaseTest

（1）com.example.zxx.databasetest包——New——Other——Content Provider

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.zxx.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 deletRows=0;
            switch (uriMatcher.match(uri)){
                case BOOK_DIR:
                    deletRows=db.delete("Book",selection,selectionArgs);
                    break;
                case BOOK_ITEM:
                    String bookId=uri.getPathSegments().get(1);
                    deletRows=db.delete("Book","id=?", new String[]{bookId});
                    break;
                case CATEGORY_DIR:
                    deletRows=db.delete("Book",selection,selectionArgs);
                    break;
                case CATEGORY_ITEM:
                    String categoryId =uri.getPathSegments().get(1);
                    deletRows=db.delete("Book","id=?",new String[]{categoryId});
                    break;
                    default:
                        break;
            }
            return deletRows;
        }
    
        @Override
        public String getType(Uri uri) {
           switch (uriMatcher.match(uri)){
               case BOOK_DIR:
                   return "vnd.android.cursor.dir/vnd.com.example.zxx.databasetest.provider.book";
               case BOOK_ITEM:
                   return "vnd.android.cursor.item/vnd.com.example.zxx.databasetest.provider.book";
               case CATEGORY_DIR:
                   return "vnd.android.cursor.dir/vnd.com.example.zxx.databasetest.provider.category";
               case CATEGORY_ITEM:
                   return "vnd.android.cursor.item/vnd.com.example.zxx.databasetest.provider.category";
                   default:
                       break;
           }
            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);//索引0处存储的是路径，1处存储的是id
                    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) {
            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;
        }
    }

然后把这个程序重新安装在模拟器上去。

3、新建ProviderTest项目

（1）layout\_main.xml

（2）MainActivity.java

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.zxx.databasetest.provider/book");
                    ContentValues values=new ContentValues();
                    values.put("name","A BIG BIG MOUSE");
                    values.put("author","WHO");
                    values.put("pages",1020);
                    values.put("price",100);
                    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.zxx.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","book name is "+name);
                            Log.d("MainActivity","book author is "+author);
                            Log.d("MainActivity","book pages are "+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 v) {
                    Uri uri = Uri.parse("content://com.example.zxx.databasetest.provider/book/"+newId);
                    ContentValues values=new ContentValues();
                    values.put("name","A SMALL CAT");
                    values.put("pages",2000);
                    values.put("price",13.14);
                    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.zxx.databasetest.provider/book/"+newId);
                    getContentResolver().delete(uri,null,null);
                }
            });
        }
    }

[20180402160106338]: /images/20210923/8fadd2d2d2be4b68b23952e1dcf6f5f7.png
[70]: /images/20210923/fa7d389b2047411ba83d8238f3014eae.png
[70 1]: /images/20210923/7bcf7e5a91d647718c9a4f294cc1505c.png
[70 2]: /images/20210923/adf0434cf9fb43ff8b8849349f7be210.png
[70 3]: /images/20210923/622dd3ce20ea45f4be77cbbe204a85ed.png