Android 调用系统的ContentProvider

客官°小女子只卖身不卖艺 2022-09-16 01:28 167阅读 0赞

1.调用系统的ContentProvider  
Android系统为我们提供了一些系统定义好的ContentProvider，我们可以根据这些ContentProvider的Uri得到相应的数据。比方说你想获得手机短信的信息，那么必定有和其对应的Uri，你想获得图库、联系人信息，也必定有相应的Uri与之对应。知道对应的Uri后，就可以过ContentResolver这个对象，根据Uri进行数据访问。

2.举例—手机短信数据的读写  
接下来我们就来看一个案例，这个案例的主要功能就是根据Uri获取手机短信的信息，并将其备份和恢复，它的效果图如下：  
![在这里插入图片描述][20211014153614766.gif]  
这个图片演示了这样一种功能，首先在DDMS中向模拟器中发几条短信，然后运行我们的程序，点击备份，提示备份成功后，将所有的短信删除，然后在我们的程序中点击恢复，打开短信界面发现刚才删除的短信已经恢复，这就是我们要实现的功能。  
首先来分析一下怎么实现上述效果，如果想备份短信，首先要做的就是获取短信的列表，这一步比较简单，因为谷歌已经将其封装好，我们所要做的就是用Uri去查询短信库，然后拿到数据后需要将数据以XML的形式保存到SD卡里面，当然用其它的方式也可以，只要能将其恢复就行。最后恢复的时候将指定路径的XML文件解析，根据Uri将解析的短信数据插入到系统的短信列表中。  
了解了大概思路后，另一个重要的任务就是看看短信的表结构，在模拟器中它的路径是data->data->com.android.providers.telephony->databases下，如下图：  
![在这里插入图片描述][20211014154958706.png]  
将其导出，然后用Sqlite数据打开可以看到数据的结构如下，这里只关心threads表和sms表就够了，threads代表所有会话信息，每个会话代表和一个联系人之间短信的群组；sms代表短信具体信息。在sms表中的thread\_id指向了threads表中的\_id，指定每条短信的会话id，以便对短信进行分组。  
threads表的结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70]  
\_id:会话id，用于区分不同的电话号码，系统会为不同的电话号码分配不同的\_id。  
date:收到信息的时间（如果收到来自同一个phone number多条信息，并且有对于一条信息未读，那么date表示收到的最后一条信息时的时间）  
message\_count:收到的信息的数目  
read: 0. 代表未读。 1.代表已读  
对于其它字段一般很少用到，这里就不多做介绍了。

sms表的结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 1]  
\_id:用于区分不同的短信  
date: 该条短信接收的时间  
read: 0表未读，1表已读  
body: 表示具体的短信内容

到这里，准备工作还差一步就可以进行代码的书写了，哪一步呢？就是访问这个数据库的Uri，对于访问手机短信的Uri，主要有以下这么几个  
content://sms/ 所有短信  
content://sms/inbox 收件箱  
content://sms/sent 已发送  
content://sms/draft 草稿  
content://sms/outbox 发件箱  
content://sms/failed 发送失败  
content://sms/queued 待发送列表  
在这个案例中我们用content://sms/，因为是备份肯定是备份所有的短信，好了，下面一起来看看代码吧。

首先要做的就是根据Uri获取短信的列表，这里新建一个SmsManage类，将备份和恢复的方法放到这个类中。  
获取短信列表的代码如下：  
/\*\*  
\* 获取短信列表  
\* @return  
*/  
public List< SmsData> getSmsList() \{  
//获取所有短信的 Uri  
Uri uri = Uri. parse( “content://sms/”);  
//获取ContentResolver对象  
ContentResolver contentResolver = mContext.getContentResolver();  
//根据Uri 查询短信数据  
Cursor cursor = contentResolver.query(uri, null, null, null, null);  
if ( null != cursor) \{  
Log. i( TAG, “cursor.getCount():” + cursor.getCount());  
//根据得到的Cursor一条一条的添加到smsList(短信列表)中  
while (cursor.moveToNext()) \{  
int \_id = cursor.getInt(cursor.getColumnIndex("\_id" ));  
int type = cursor.getInt(cursor.getColumnIndex(“type” ));  
String address = cursor.getString(cursor.getColumnIndex( “address”));  
String body = cursor.getString(cursor.getColumnIndex(“body” ));  
String date = cursor.getString(cursor.getColumnIndex(“date” ));  
SmsData smsData = new SmsData(\_id, type, address, body, date);  
smsList.add(smsData);  
\}  
cursor.close();  
\}  
return smsList;  
\}  
可以看到，上述代码就是根据 content://sms/这个Uri去查询手机中短信的数据库，得到一个Cursor，这个Cursor就包含了一条一条的短信。然后去遍历这个Cursor将我们需要的数据添加到smsList中。这样短信数据就拿到了，因为我们做的功能是短信备份，所以接下来需要将smsList这个集合中的数据保存到本地，以方便短信恢复的时候去读取保存的这个文件，那么问题来了，怎样将smsList这个集合以文件的形式保存到本地呢？当然方法有很多，这里我们采用的是使用XmlSerializer将其序列化，待我们需要恢复的时候使用XmlPullParser 将其反序列化，就可以拿到备份的数据，听起来感觉挺高大上的，其实很简单就是对xml的操作。  
下面来看看序列化的代码，即将上面得到的集合smsList中的数据生成一个xml文件，并保存到本地，代码如下：  
/*\*

*  将短信数据保存到 sd卡中  
    \*/  
    public void saveSmsToSdCard()\{  
    smsList=getSmsList();  
    //获得一个序列化对象  
    XmlSerializer xmlSerializer=Xml. newSerializer();  
    //将生成的xml文件保存到sd 卡中名字为"sms.xml"  
    File file= new File(Environment.getExternalStorageDirectory(), “sms.xml”);  
    FileOutputStream fos;
    
        try {
                 fos = new FileOutputStream(file);
                 xmlSerializer.setOutput(fos, "utf-8");
                 xmlSerializer.startDocument( "utf-8", true);
                 xmlSerializer.startTag( null, "smss");
                 
                 xmlSerializer.startTag( null, "count");
                 xmlSerializer.text( smsList.size()+ "");
                 xmlSerializer.endTag( null, "count");
        
          for(SmsData smsData: smsList){
               xmlSerializer.startTag( null, "sms");
                                  
               xmlSerializer.startTag( null, "_id");
               xmlSerializer.text(smsData.get_id()+ "");
               xmlSerializer.endTag( null, "_id");
                      
              xmlSerializer.startTag( null, "type");
             xmlSerializer.text(smsData.getType()+ "");
             xmlSerializer.endTag( null, "type");
                      
             xmlSerializer.startTag( null, "address");                     xmlSerializer.text(smsData.getAddress()+ "");
             xmlSerializer.endTag( null, "address");
                    
            xmlSerializer.startTag( null, "body");                             
            xmlSerializer.text(smsData.getBody()+ "");
            xmlSerializer.endTag( null, "body");
                      
            xmlSerializer.startTag( null, "date");
            xmlSerializer.text(smsData.getDate()+ "");
            xmlSerializer.endTag( null, "date");
                      
             xmlSerializer.endTag( null, "sms");
         }
         xmlSerializer.endTag( null, "smss");
         xmlSerializer.endDocument();
        
          fos.flush();
          fos.close();
          Toast. makeText( mContext, "备份完成", Toast.LENGTH_SHORT ).show();
            } catch (FileNotFoundException e) {
                 e.printStackTrace();
            } catch (IllegalArgumentException e) {
                 e.printStackTrace();
            } catch (IllegalStateException e) {
                 e.printStackTrace();
            } catch (IOException e) {
                 e.printStackTrace();
            }
    
    \}  
    通过调用以上方法就将短信以xml的形式保存到了本地。  
    运行这个方法后可以在sd卡中看到sms.xml文件，将其导出来可以看到它的格式如下:  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 2]  
    注：实际上xml文件中它是一行，这里为了让大家更清楚的看清结构，我手动将其改成上述格式了。  
    保存到本地后，工作就剩下最后一步了，那就是将这个xml文件反序列化，并将其中的数据一条一条插入到短信的数据库中，与其对应的代码如下：  
    /\*\*
    
     *  将指定路径的 xml文件中的数据插入到短信数据库中
     *  @param path  
        \*/  
        public void restoreSms(String path) \{  
        File file = new File(path);  
        //得到一个解析 xml的对象  
        XmlPullParser parser = Xml. newPullParser();  
        try \{  
        fis = new FileInputStream(file);  
        parser.setInput( fis, “utf-8”);  
        ContentValues values = null;  
        int type = parser.getEventType();  
        while (type != XmlPullParser. END\_DOCUMENT) \{  
        switch (type) \{  
        case XmlPullParser. START\_TAG:  
        if (“count”.equals(parser.getName())) \{
        
        \} else if (“sms”.equals(parser.getName())) \{  
        values = new ContentValues();  
        \} else if (“type” .equals(parser.getName())) \{  
        values.put( “type”, parser.nextText());  
        \} else if (“address” .equals(parser.getName())) \{  
        values.put( “address”, parser.nextText());  
        \} else if (“body” .equals(parser.getName())) \{  
        values.put( “body”, parser.nextText());  
        \} else if (“date” .equals(parser.getName())) \{  
        values.put( “date”, parser.nextText());  
        \}  
        break;  
        case XmlPullParser. END\_TAG:  
        if ( “sms”.equals(parser.getName())) \{  
        // 如果节点是 sms  
        Uri uri = Uri.parse( “content://sms/”);  
        ContentResolver resolver = mContext.getContentResolver();  
        resolver.insert(uri, values);//向数据库中插入数据  
        System. out.println( “插入成功” );  
        values = null;  
        \}  
        break;  
        \}  
        type=parser.next();  
        \}  
        \} catch (FileNotFoundException e) \{  
        e.printStackTrace();  
        \} catch (XmlPullParserException e) \{  
        e.printStackTrace();  
        \} catch (NumberFormatException e) \{  
        e.printStackTrace();  
        \} catch (IOException e) \{  
        e.printStackTrace();  
        \}  
        \}  
        可以看到，在上述方法中判断xml的END\_TAG是不是"sms"，如果是的话说明一条短信的"type"、“address”、“body”、"date"这些信息已经拿到，然后就根据Uri将这条数据插入到数据库中，就完成一条短信的恢复，待读到 END\_DOCUMENT说明xml文件已经读完，此时所备份的短信就全部恢复了。

3.举例—联系人的读写  
在Android中，联系人的操作都是通过一个统一的途径来读写数据的，我们打开  
/data/data/com.android.providers.contacts，可以看到联系人的数据源：  
![在这里插入图片描述][20211014181634749.png]  
可以导出这个文件，用专业的工具软件打开看一下表结构。  
对这个SQLite类型的数据源进行封装后，联系人就以ContentProvider的形式为其他应用进程提供联系人的读写服务，我们就可以顺利成章的操作自己的联系人信息了。  
为了方便测试，我们先添加两个联系人到数据源中，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 5]  
我们看到，每个联系人都有两个电话号码和两个邮箱账号，分别为家庭座机号码、移动手机号码、家庭邮箱账号和工作邮箱账号。当然在添加联系人时有很多其他信息，我们这里都没有填写，只选择了最常用的电话和邮箱，主要是方便演示这个过程。  
在演示代码之前，我们需要了解一下android.provider.ContactsContract这个类（注：在较早的版本中是android.provider.Contacts这个类，不过现在已被废弃，不建议使用），它定义了各种联系人相关的URI和每一种类型信息的属性信息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 6]  
下面我们通过一个项目，来演示一下联系人操作的具体过程。  
新建一个名为provider的项目，创建一个名为ContactsReadTest的测试用例，如下：  
public class ContactsReadTest extends AndroidTestCase \{  
//\[content://com.android.contacts/contacts\]  
private static final Uri CONTACTS\_URI = ContactsContract.Contacts.CONTENT\_URI;  
//\[content://com.android.contacts/data/phones\]  
private static final Uri PHONES\_URI = ContactsContract.CommonDataKinds.Phone.CONTENT\_URI;  
//\[content://com.android.contacts/data/emails\]  
private static final Uri EMAIL\_URI = ContactsContract.CommonDataKinds.Email.CONTENT\_URI;

private static final String \_ID = ContactsContract.Contacts.\_ID;  
private static final String DISPLAY\_NAME = ContactsContract.Contacts.DISPLAY\_NAME;  
private static final String HAS\_PHONE\_NUMBER = ContactsContract.Contacts.HAS\_PHONE\_NUMBER;  
private static final String CONTACT\_ID = ContactsContract.Data.CONTACT\_ID;  
private static final String PHONE\_NUMBER = ContactsContract.CommonDataKinds.Phone.NUMBER;  
private static final String PHONE\_TYPE = ContactsContract.CommonDataKinds.Phone.TYPE;  
private static final String EMAIL\_DATA = ContactsContract.CommonDataKinds.Email.DATA;  
private static final String EMAIL\_TYPE = ContactsContract.CommonDataKinds.Email.TYPE;

public void testReadContacts() \{  
ContentResolver resolver = getContext().getContentResolver();  
Cursor c = resolver.query(CONTACTS\_URI, null, null, null, null);  
while (c.moveToNext()) \{  
int \_id = c.getInt(c.getColumnIndex(\_ID));  
String displayName = c.getString(c.getColumnIndex(DISPLAY\_NAME))；

ArrayList< String> phones = new ArrayList< String>();  
ArrayList< String> emails = new ArrayList< String>();

String selection = CONTACT\_ID + “=” + \_id;

//获取手机号  
int hasPhoneNumber = c.getInt(c.getColumnIndex(HAS\_PHONE\_NUMBER));  
if (hasPhoneNumber > 0) \{  
Cursor phc = resolver.query(PHONES\_URI, null, selection, null, null);  
while (phc.moveToNext()) \{  
String phoneNumber = phc.getString(phc.getColumnIndex(PHONE\_NUMBER));  
int phoneType = phc.getInt(phc.getColumnIndex(PHONE\_TYPE)); phones.add(getPhoneTypeNameById(phoneType) + " : " + phoneNumber);  
\}  
phc.close();  
\}  
Log.i(TAG, "phones: " + phones);

//获取邮箱  
Cursor emc = resolver.query(EMAIL\_URI,null, selection, null, null);  
while (emc.moveToNext()) \{  
String emailData = emc.getString(emc.getColumnIndex(EMAIL\_DATA));  
int emailType = emc.getInt(emc.getColumnIndex(EMAIL\_TYPE)); emails.add(getEmailTypeNameById(emailType) + " : " + emailData);  
\}  
emc.close();

Log.i(TAG, "emails: " + emails);  
\}  
c.close();  
\}

private String getPhoneTypeNameById(int typeId) \{  
switch (typeId) \{  
case ContactsContract.CommonDataKinds.Phone.TYPE\_HOME:  
return “home”;  
case ContactsContract.CommonDataKinds.Phone.TYPE\_MOBILE:  
return “mobile”;  
case ContactsContract.CommonDataKinds.Phone.TYPE\_WORK:  
return “work”;  
default: return “none”;  
\}  
\}

private String getEmailTypeNameById(int typeId) \{  
switch (typeId) \{  
case ContactsContract.CommonDataKinds.Email.TYPE\_HOME:  
return “home”;  
case ContactsContract.CommonDataKinds.Email.TYPE\_WORK:  
return “work”;  
case ContactsContract.CommonDataKinds.Email.TYPE\_OTHER:  
return “other”;  
default: return “none”;  
\}  
\}  
\}  
为了使这个测试用例运行起来，我们需要在AndroidManifest.xml中配置一下测试设备的声明，它与< application>元素处于同一级别位置：

< instrumentation android:name="android.test.InstrumentationTestRunner"					 android:targetPackage="com.scott.provider"/>

然后再配置使用测试类库声明，它与< activity>元素处于同一级别位置：

< uses-library android:name="android.test.runner"/>

最后，还有一个重要的声明需要配置，就是读取联系人权限，声明如下：  
  
< uses-permission android:name=“android.permission.READ\_CONTACTS”/>  
经过以上准备工作，这个测试用例就可以运转起来了，我们运行一下testReadContacts()方法，打印结果如下：  
![在这里插入图片描述][20211014185658493.png]  
联系人里的信息都被我们准确无误的读取出来了。  
如果我们在一个Activity里运行读取联系人的代码，不仅可以使用ContentResolver直接进行读取操作（即查询），还可以使用Activity提供的managedQuery方法方便的实现同样的效果，我们来看一下这个方法的具体代码：  
public final Cursor managedQuery(Uri uri,  
String\[\] projection,  
String selection,  
String\[\] selectionArgs,  
String sortOrder) \{  
Cursor c = getContentResolver().query(uri, projection, selection, selectionArgs, sortOrder);  
if (c != null) \{  
startManagingCursor©;  
\}  
return c;  
\}  
我们发现，其实它还是使用了ContentResolver进行查询操作，但是多了一步startManagingCursor的操作，它会根据Activity的生命周期对Cursor对象进行管理，避免了一些因Cursor是否释放引起的问题，所以非常方便，大大简化了我们的工作量。

接下来我们将要尝试将一个联系人信息添加到系统联系人的数据源中，实现对联系人的写入操作。  
我们新建一个名为ContactsWriteTest的测试用例，如下：  
public class ContactsWriteTest extends AndroidTestCase \{  
//\[content://com.android.contacts/raw\_contacts\]  
private static final Uri RAW\_CONTACTS\_URI = ContactsContract.RawContacts.CONTENT\_URI;  
//\[content://com.android.contacts/data\]  
private static final Uri DATA\_URI = ContactsContract.Data.CONTENT\_URI;

private static final String ACCOUNT\_TYPE = ContactsContract.RawContacts.ACCOUNT\_TYPE;  
private static final String ACCOUNT\_NAME = ContactsContract.RawContacts.ACCOUNT\_NAME;  
private static final String RAW\_CONTACT\_ID = ContactsContract.Data.RAW\_CONTACT\_ID;  
private static final String MIMETYPE = ContactsContract.Data.MIMETYPE;  
private static final String NAME\_ITEM\_TYPE = ContactsContract.CommonDataKinds.StructuredName.CONTENT\_ITEM\_TYPE;  
private static final String DISPLAY\_NAME = ContactsContract.CommonDataKinds.StructuredName.DISPLAY\_NAME;  
private static final String PHONE\_ITEM\_TYPE = ContactsContract.CommonDataKinds.Phone.CONTENT\_ITEM\_TYPE;  
private static final String PHONE\_NUMBER = ContactsContract.CommonDataKinds.Phone.NUMBER;  
private static final String PHONE\_TYPE = ContactsContract.CommonDataKinds.Phone.TYPE;  
private static final int PHONE\_TYPE\_HOME = ContactsContract.CommonDataKinds.Phone.TYPE\_HOME;  
private static final int PHONE\_TYPE\_MOBILE = ContactsContract.CommonDataKinds.Phone.TYPE\_MOBILE;  
private static final String EMAIL\_ITEM\_TYPE = ContactsContract.CommonDataKinds.Email.CONTENT\_ITEM\_TYPE;  
private static final String EMAIL\_DATA = ContactsContract.CommonDataKinds.Email.DATA;  
private static final String EMAIL\_TYPE = ContactsContract.CommonDataKinds.Email.TYPE;  
private static final int EMAIL\_TYPE\_HOME = ContactsContract.CommonDataKinds.Email.TYPE\_HOME;  
private static final int EMAIL\_TYPE\_WORK = ContactsContract.CommonDataKinds.Email.TYPE\_WORK;  
private static final String AUTHORITY = ContactsContract.AUTHORITY;

public void testWriteContacts() throws Exception \{  
ArrayList< ContentProviderOperation> operations = new ArrayList< ContentProviderOperation>();

ContentProviderOperation operation = ContentProviderOperation.newInsert(RAW\_CONTACTS\_URI).withValue(ACCOUNT\_TYPE, null)  
.withValue(ACCOUNT\_NAME, null)  
.build();  
operations.add(operation);

//添加联系人名称操作  
operation = ContentProviderOperation.newInsert(DATA\_URI) .withValueBackReference(RAW\_CONTACT\_ID, 0)  
.withValue(MIMETYPE, NAME\_ITEM\_TYPE)  
.withValue(DISPLAY\_NAME, “Scott Liu”)  
.build();  
operations.add(operation);

//添加家庭座机号码  
operation = ContentProviderOperation.newInsert(DATA\_URI) .withValueBackReference(RAW\_CONTACT\_ID, 0)  
.withValue(MIMETYPE, PHONE\_ITEM\_TYPE)  
.withValue(PHONE\_TYPE, PHONE\_TYPE\_HOME) .withValue(PHONE\_NUMBER, “01034567890”)  
.build();  
operations.add(operation);

//添加移动手机号码  
operation = ContentProviderOperation.newInsert(DATA\_URI) .withValueBackReference(RAW\_CONTACT\_ID, 0)  
.withValue(MIMETYPE, PHONE\_ITEM\_TYPE)  
.withValue(PHONE\_TYPE,PHONE\_TYPE\_MOBILE) .withValue(PHONE\_NUMBER, “13034567890”)  
.build();  
operations.add(operation);

//添加家庭邮箱  
operation = ContentProviderOperation.newInsert(DATA\_URI) .withValueBackReference(RAW\_CONTACT\_ID, 0)  
.withValue(MIMETYPE, EMAIL\_ITEM\_TYPE)  
.withValue(EMAIL\_TYPE, EMAIL\_TYPE\_HOME)  
.withValue(EMAIL\_DATA, “scott@android.com”)  
.build();  
operations.add(operation);

//添加工作邮箱  
operation = ContentProviderOperation.newInsert(DATA\_URI) .withValueBackReference(RAW\_CONTACT\_ID, 0)  
.withValue(MIMETYPE, EMAIL\_ITEM\_TYPE)  
.withValue(EMAIL\_TYPE, EMAIL\_TYPE\_WORK)  
.withValue(EMAIL\_DATA, “scott@msapple.com”)  
.build();  
operations.add(operation);

ContentResolver resolver = getContext().getContentResolver();  
//批量执行,返回执行结果集  
ContentProviderResult\[\] results = resolver.applyBatch(AUTHORITY, operations);  
for (ContentProviderResult result : results) \{  
Log.i(TAG, result.uri.toString());  
\}  
\}  
\}  
在上面的代码中，我们把整个操作分为几个ContentProviderOperation操作，并将他们做批处理操作，我们也许注意到，从第二个操作开始，每一项都有一个withValueBackReference(RAW\_CONTACT\_ID, 0)步骤，它参照了第一项操作新添加的联系人的id，因为是批处理，我们插入数据前并不知道id的值，不过这个不用担心，在进行批处理插入数据时，它会重新引用新的id值，不会影响最终的结果。  
当然，这个也不能忘了配置写入联系人的权限声明：  
  
< uses-permission android:name=“android.permission.WRITE\_CONTACTS” />  
经过以上步骤之后，我们运行一下testWriteContacts()方法，看看联系人是否添加进去了：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 8]

[20211014153614766.gif]: /images/20220828/930afe4c2fbf4f5ca4ecbf98e7fd1c83.png
[20211014154958706.png]: /images/20220828/e69d1c93010140e0af0e92412865451d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70]: /images/20220828/2c1c556b2f3245f4bc211b70d905c588.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 1]: /images/20220828/393c4a277ccc452998d38b519f801fee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 2]: /images/20220828/4dd0d48108d14d1d9a15f263dce8eaa3.png
[20211014181634749.png]: /images/20220828/fd9e2c0c68e24ff482498183571d6a7a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 3]: /images/20220828/fe666bf83c6643338621a2903e7c3435.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 4]: /images/20220828/b7b6d55900d1400abba1016e464f014e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 5]: /images/20220828/740876a3401e459ba1ff06bedf44f57b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 6]: /images/20220828/dee81bf8ec564b2c9e69bb5fc3b0c515.png
[20211014185658493.png]: /images/20220828/3d99917825d04dde9ce1dfa7465f7c93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 7]: /images/20220828/d5e4d72887b740359dd8a3e342467d09.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3plbm1lbGEyMDEx_size_16_color_FFFFFF_t_70 8]: /images/20220828/1e5f9f91252f4e40b35a5c88619aa275.png