小米便签项目代码分析----程序包Tool的分析

小米便签项目代码分析----程序包tool的分析

程序包tool包含文件：

• GTaskStringUtils：用于定义与 Google Tasks API 交互时使用的 JSON 字段名常量
• ResourceParser：用于定义便签的资源解析方法和常量
• BackupUtils： 用于备份和导出便签数据到文本文件
• DataUtils：用于封装便签数据的处理操作，如查找、移动、删除等

代码标注部分

• GTaskStringUtils

/*
 * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.micode.notes.tool;

/**
 * GtaskStringUtils 类用于定义一组常量
 * 这些常量主要用于与Google Tasks API 进行交互时使用的JSON字段名
 */

public class GTaskStringUtils {

    //定义 Google Tasks API 中 action_id 字段的常量，用于标识操作的唯一ID
    public final static String GTASK_JSON_ACTION_ID = "action_id";

    //定义 Google Tasks API 中 action_list 字段的常量，用于标识操作的列表
    public final static String GTASK_JSON_ACTION_LIST = "action_list";

    //定义 Google Tasks API 中 action_type 字段的常量，用于标识操作的类型，如创建、更新、移动等
    public final static String GTASK_JSON_ACTION_TYPE = "action_type";

    //定义 Google Tasks API 中 action_type_create 字段的常量，用于标识操作的创建类型
    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";

    //定义 Google Tasks API 中 action_type_delete 字段的常量，用于标识操作的删除类型
    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";

    //定义 Google Tasks API 中 action_type_move 字段的常量，用于标识操作的移动类型
    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";

    //定义 Google Tasks API 中 action_type_update 字段的常量，用于标识操作的更新类型
    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";

    //定义 Google Tasks API 中 CREATOR_ID 字段的常量，用于标识创建者的 ID
    public final static String GTASK_JSON_CREATOR_ID = "creator_id";

    //定义 Google Tasks API 中 child_entity 字段的常量，用于标识子实体
    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";

    //定义 Google Tasks API 中 CLIENT_VERSION 字段的常量，用于标识客户端版本
    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";

    //定义 Google Tasks API 中 COMPLETED 字段的常量，用于标识是否已完成
    public final static String GTASK_JSON_COMPLETED = "completed";

    //定义 Google Tasks API 中 CURRENT_LIST_ID 字段的常量，用于标识当前列表的 ID
    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";

    //定义 Google Tasks API 中 DEFAULT_LIST_ID 字段的常量，用于标识默认列表的 ID
    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";

    //定义 Google Tasks API 中 DELETED 字段的常量，用于标识是否已删除
    public final static String GTASK_JSON_DELETED = "deleted";

    //定义 Google Tasks API 中 DEST_LIST 字段的常量，用于标识目标列表
    public final static String GTASK_JSON_DEST_LIST = "dest_list";

    //定义 Google Tasks API 中 DEST_PARENT 字段的常量，用于标识目标父节点
    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";

    //定义 Google Tasks API 中 DEST_PARENT_TYPE 字段的常量，用于标识目标父节点的类型
    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";

    //定义 Google Tasks API 中 ENTITY_DELTA 字段的常量，用于标识实体的变化
    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";

    //定义 Google Tasks API 中 ENTITY_TYPE 字段的常量，用于标识实体的类型
    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";

    //定义 Google Tasks API 中 GET_DELETED 字段的常量，用于标识是否获取已删除的实体
    public final static String GTASK_JSON_GET_DELETED = "get_deleted";

    //定义 Google Tasks API 中 GTASK_JSON_ID 字段的常量，用于标识 Google Tasks 的 ID
    public final static String GTASK_JSON_ID = "id";

    //定义 Google Tasks API 中 INDEX 字段的常量，用于标识索引
    public final static String GTASK_JSON_INDEX = "index";

    //定义 Google Tasks API 中 LAST_MODIFIED 字段的常量，用于标识最后修改时间
    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";

    //定义 Google Tasks API 中 LAST_SYNC_POINT 字段的常量，用于标识最后同步时间
    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";

    //定义 Google Tasks API 中 LIST_ID 字段的常量，用于标识列表的 ID
    public final static String GTASK_JSON_LIST_ID = "list_id";

    //定义 Google Tasks API 中 LISTS 字段的常量，用于标识列表
    public final static String GTASK_JSON_LISTS = "lists";

    //定义 Google Tasks API 中 NAME 字段的常量，用于标识名称
    public final static String GTASK_JSON_NAME = "name";

    //定义 Google Tasks API 中 NEW_ID 字段的常量，用于标识新的 ID
    public final static String GTASK_JSON_NEW_ID = "new_id";

    //定义 Google Tasks API 中 NOTES 字段的常量，用于标识备注
    public final static String GTASK_JSON_NOTES = "notes";

    //定义 Google Tasks API 中 PARENT_ID 字段的常量，用于标识父节点的 ID
    public final static String GTASK_JSON_PARENT_ID = "parent_id";

    //定义 Google Tasks API 中 PRIOR_SIBLING_ID 字段的常量，用于标识前一个兄弟节点的 ID
    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";

    //定义 Google Tasks API 中 RESULT 字段的常量，用于标识结果
    public final static String GTASK_JSON_RESULTS = "results";

    //定义 Google Tasks API 中 SOURCE_LIST 字段的常量，用于标识源列表
    public final static String GTASK_JSON_SOURCE_LIST = "source_list";

    //定义 Google Tasks API 中 TASKS 字段的常量，用于标识任务
    public final static String GTASK_JSON_TASKS = "tasks";

    //定义 Google Tasks API 中 TYPE 字段的常量，用于标识类型
    public final static String GTASK_JSON_TYPE = "type";

    //定义 Google Tasks API 中 TYPE_GROUP 字段的常量，用于标识组类型
    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";

    //定义 Google Tasks API 中 TYPE_TASK 字段的常量，用于标识任务类型
    public final static String GTASK_JSON_TYPE_TASK = "TASK";

    //定义 Google Tasks API 中 USER 字段的常量，用于标识用户
    public final static String GTASK_JSON_USER = "user";

    //定义 NIUI 便签应用中的文件夹前缀
    public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";

    //定义默认文件夹的名称
    public final static String FOLDER_DEFAULT = "Default";

    //定义通话记录文件夹的名称
    public final static String FOLDER_CALL_NOTE = "Call_Note";

    //定义元数据文件夹的名称
    public final static String FOLDER_META = "METADATA";

    //定义 元数据头部的 GTASK_ID 字段
    public final static String META_HEAD_GTASK_ID = "meta_gid";

    //定义元数据头部中便签的内容的常量
    public final static String META_HEAD_NOTE = "meta_note";

    //定义元数据头部中数据的常量
    public final static String META_HEAD_DATA = "meta_data";

    //定义元数据便签名称的常量
    public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";

}

• ResourceParser：

/*
 * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.micode.notes.tool;

import android.content.Context;
import android.preference.PreferenceManager;

import net.micode.notes.R;
import net.micode.notes.ui.NotesPreferenceActivity;

/**
 * ResourceParser 类用于定义一组常量和资源解析方法，利用R.java类获取资源供程序调用
 */
public class ResourceParser {

    // 定义了五种颜色常量
    public static final int YELLOW           = 0;
    public static final int BLUE             = 1;
    public static final int WHITE            = 2;
    public static final int GREEN            = 3;
    public static final int RED              = 4;

    // 默认背景颜色为黄色
    public static final int BG_DEFAULT_COLOR = YELLOW;

    // 定义了四种字体大小常量
    public static final int TEXT_SMALL       = 0;
    public static final int TEXT_MEDIUM      = 1;
    public static final int TEXT_LARGE       = 2;
    public static final int TEXT_SUPER       = 3;

    // 默认字体大小为中等
    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;

    // NoteBgResources 内部类用于定义了便签背景资源
    public static class NoteBgResources {
        // 定义了便签编辑背景资源数组
        private final static int [] BG_EDIT_RESOURCES = new int [] {
            R.drawable.edit_yellow,
            R.drawable.edit_blue,
            R.drawable.edit_white,
            R.drawable.edit_green,
            R.drawable.edit_red
        };

        // 定义了便签标题背景资源数组
        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
            R.drawable.edit_title_yellow,
            R.drawable.edit_title_blue,
            R.drawable.edit_title_white,
            R.drawable.edit_title_green,
            R.drawable.edit_title_red
        };

        // 获取便签编辑背景资源
        public static int getNoteBgResource(int id) {
            return BG_EDIT_RESOURCES[id];
        }

        // 获取便签标题背景资源
        public static int getNoteTitleBgResource(int id) {
            return BG_EDIT_TITLE_RESOURCES[id];
        }
    }

    /**
     * 获取默认背景颜色ID
     * @param context 上下文
     * @return 默认背景颜色
     */
    public static int getDefaultBgId(Context context) {
        // 如果用户设置了背景颜色偏好（即 getBoolean 返回 true），则会随机返回一个背景资源 ID。
        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
        } else {
            return BG_DEFAULT_COLOR; // 未设置偏好：返回默认背景颜色常量 BG_DEFAULT_COLOR黄色。
        }
    }

    /**
     * NoteItemBgResources 类用于定义便签项背景资源
     */
    public static class NoteItemBgResources {
        // 定义了便签项第一个位置的背景资源数组
        private final static int [] BG_FIRST_RESOURCES = new int [] {
            R.drawable.list_yellow_up,
            R.drawable.list_blue_up,
            R.drawable.list_white_up,
            R.drawable.list_green_up,
            R.drawable.list_red_up
        };

        // 定义了便签项中间位置的背景资源数组
        private final static int [] BG_NORMAL_RESOURCES = new int [] {
            R.drawable.list_yellow_middle,
            R.drawable.list_blue_middle,
            R.drawable.list_white_middle,
            R.drawable.list_green_middle,
            R.drawable.list_red_middle
        };

        // 定义了便签项最后一个位置的背景资源数组
        private final static int [] BG_LAST_RESOURCES = new int [] {
            R.drawable.list_yellow_down,
            R.drawable.list_blue_down,
            R.drawable.list_white_down,
            R.drawable.list_green_down,
            R.drawable.list_red_down,
        };

        // 定义了便签项单独位置的背景资源数组
        private final static int [] BG_SINGLE_RESOURCES = new int [] {
            R.drawable.list_yellow_single,
            R.drawable.list_blue_single,
            R.drawable.list_white_single,
            R.drawable.list_green_single,
            R.drawable.list_red_single
        };

        // 获取便签项第一个位置的背景资源
        public static int getNoteBgFirstRes(int id) {
            return BG_FIRST_RESOURCES[id];
        }

        // 获取便签项最后一个位置的背景资源
        public static int getNoteBgLastRes(int id) {
            return BG_LAST_RESOURCES[id];
        }

        // 获取便签项单独位置的背景资源
        public static int getNoteBgSingleRes(int id) {
            return BG_SINGLE_RESOURCES[id];
        }

        // 获取便签项中间位置的背景资源
        public static int getNoteBgNormalRes(int id) {
            return BG_NORMAL_RESOURCES[id];
        }

        // 获取文件夹背景资源
        public static int getFolderBgRes() {
            return R.drawable.list_folder;
        }
    }

    // WidgetBgResources 内部类用于定义了便签小部件背景资源
    public static class WidgetBgResources {

        // 定义了便签小部件2x背景资源数组
        private final static int [] BG_2X_RESOURCES = new int [] {
            R.drawable.widget_2x_yellow,
            R.drawable.widget_2x_blue,
            R.drawable.widget_2x_white,
            R.drawable.widget_2x_green,
            R.drawable.widget_2x_red,
        };

        // 获取便签小部件2x背景资源
        public static int getWidget2xBgResource(int id) {
            return BG_2X_RESOURCES[id];
        }

        // 定义了便签小部件4x背景资源数组
        private final static int [] BG_4X_RESOURCES = new int [] {
            R.drawable.widget_4x_yellow,
            R.drawable.widget_4x_blue,
            R.drawable.widget_4x_white,
            R.drawable.widget_4x_green,
            R.drawable.widget_4x_red
        };

        // 获取便签小部件4x
        public static int getWidget4xBgResource(int id) {
            return BG_4X_RESOURCES[id];
        }
    }

    // TextAppearanceResources 内部类用于定义了便签文本字体大小资源
    public static class TextAppearanceResources {

        // 定义了便签文本字体大小资源数组
        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
            R.style.TextAppearanceNormal,
            R.style.TextAppearanceMedium,
            R.style.TextAppearanceLarge,
            R.style.TextAppearanceSuper
        };

        // 获取文本字体大小资源
        public static int getTexAppearanceResource(int id) {
            /**
             * HACKME: Fix bug of store the resource id in shared preference.
             * The id may larger than the length of resources, in this case,
             * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
             * 修复存储资源 ID 的共享偏好的错误。
             * 如果ID大于资源的长度，则返回 BG_DEFAULT_FONT_SIZE。
             */
            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
                return BG_DEFAULT_FONT_SIZE;
            }
            return TEXTAPPEARANCE_RESOURCES[id];
        }

        // 获取文本字体大小资源数量
        public static int getResourcesSize() {
            return TEXTAPPEARANCE_RESOURCES.length;
        }
    }
}

• BackupUtils

/*
 * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.micode.notes.tool;

import android.content.Context;
import android.database.Cursor;
import android.os.Environment;
import android.text.TextUtils;
import android.text.format.DateFormat;
import android.util.Log;

import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

/**
 * 备份工具类，用于导出笔记数据到文本文件
 */
public class BackupUtils {
    private static final String TAG = "BackupUtils";//常量----日志标签
    private static BackupUtils sInstance;//备份工具类实例
    // getInstance()方法，用于获取备份工具类实例，其保证了允许其他类访问该方法，允许在没有实例的情况下调用该方法，且保证线程安全。
    public static synchronized BackupUtils getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new BackupUtils(context);
        }
        return sInstance;
    }

    /**
     * Following states are signs to represents backup or restore
     * status
     * 备份和恢复状态常量。
     */
    // Currently, the sdcard is not mounted
    public static final int STATE_SD_CARD_UNMOUONTED           = 0; //SD卡未挂载
    // The backup file not exist
    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1; //备份文件不存在
    // The data is not well formated, may be changed by other programs
    public static final int STATE_DATA_DESTROIED               = 2; //数据已被破坏
    // Some run-time exception which causes restore or backup fails
    public static final int STATE_SYSTEM_ERROR                 = 3;//系统错误
    // Backup or restore success
    public static final int STATE_SUCCESS                      = 4;//成功

    private TextExport mTextExport;  //文本导出内部类的实例

    /**
     * 构造方法，初始化TextExport对象
     * @param context 上下文对象
     */
    private BackupUtils(Context context) {
        mTextExport = new TextExport(context);
    } //类的构造方法

    /**
     * 检查外部存储是否已挂载且可用
     * 该函数通过判断外部存储的状态getExternalStorageState是否为MEDIA_MOUNTED（常量）来判断外部存储是否已挂载且可用
     * @return 外部存储是否可用
     */
    private static boolean externalStorageAvailable() {
        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
    }

    /**
     * 导出笔记数据到文本文件
     * 该函数通过调用TextExport 内部类的 exportToText 方法执行导出操作
     * 该函数返回导出上面定义的状态常量0-4：代表 SD卡未挂载，备份文件不存在，数据已被破坏，系统错误，成功
     * @return 导出状态
     */
    public int exportToText() {
        return mTextExport.exportToText();
    }

    /**
     * 获取导出的文本文件名
     * @return 文件名
     */
    public String getExportedTextFileName() {
        return mTextExport.mFileName;
    }

    /**
     * 获取导出的文本文件目录
     * @return 文件目录
     */
    public String getExportedTextFileDir() {
        return mTextExport.mFileDirectory;
    }

    /**
     * 内部类TextExport，用于导出笔记数据到文本文件
     */
    private static class TextExport {

        // 笔记查询投影，定义了数据库查询时需要返回的列
        private static final String[] NOTE_PROJECTION = {
                NoteColumns.ID,                     //笔记的唯一标识符
                NoteColumns.MODIFIED_DATE,          //笔记的最后修改日期
                NoteColumns.SNIPPET,                //笔记的摘要
                NoteColumns.TYPE                    //笔记的类型
        };

        private static final int NOTE_COLUMN_ID = 0;           //笔记的唯一标识符

        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;         //笔记的最后修改日期

        private static final int NOTE_COLUMN_SNIPPET = 2;     //笔记的摘要

        // 数据查询投影，定义了数据库查询时需要返回的列
        private static final String[] DATA_PROJECTION = {
                DataColumns.CONTENT,                //数据的内容
                DataColumns.MIME_TYPE,              //数据的MIME类型
                DataColumns.DATA1,                  //数据的附加信息
                DataColumns.DATA2,
                DataColumns.DATA3,
                DataColumns.DATA4,
        };

        private static final int DATA_COLUMN_CONTENT = 0;   //数据的内容

        private static final int DATA_COLUMN_MIME_TYPE = 1;     //数据的MIME类型

        private static final int DATA_COLUMN_CALL_DATE = 2;     //数据的附加信息

        private static final int DATA_COLUMN_PHONE_NUMBER = 4;  //数据的附加信息

        private final String [] TEXT_FORMAT;            //文本格式
        private static final int FORMAT_FOLDER_NAME          = 0;       //文件夹名称
        private static final int FORMAT_NOTE_DATE            = 1;       //笔记日期
        private static final int FORMAT_NOTE_CONTENT         = 2;       //笔记内容

        private Context mContext;           //上下文对象
        private String mFileName;           //文件名
        private String mFileDirectory;      //文件目录

        /**
         * 构造方法，初始化上下文和文本格式
         * @param context 上下文对象，是应用程序或活动的上下文，用于访问应用程序的资源和其他应用级操作。
         */
        public TextExport(Context context) {
            TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
            //从资源文件中获取一个字符串数组，并将其赋值给 TEXT_FORMAT 变量，作为文本格式数组，
            // R.array.format_for_exported_note 是资源文件中的一个字符串数组的标识符。
            // 该数组中包含了导出笔记数据到文本文件时的格式信息。
            mContext = context;             //传入的 context 参数赋值给 mContext 变量，以便在类的其他方法中使用这个上下文对象
            mFileName = "";                 //初始化导出文件名为空
            mFileDirectory = "";            //初始化导出文件目录为空
        }

        /**
            * 获取指定格式的文本格式
         */
        private String getFormat(int id) {
            return TEXT_FORMAT[id];
        }

        /**
         * Export the folder identified by folder id to text
         * 查询指定文件夹中的所有笔记，并将每条笔记的最后修改日期和详细数据导出到文本文件中。
         * @param folderId 文件夹ID
         * @param ps 打印流
         */
        private void exportFolderToText(String folderId, PrintStream ps) {
            /**
             * Query notes belong to this folder
             * 使用ContentResolver查询属于此文件夹(folderId)的笔记
             * 查询的 URI 是 Notes.CONTENT_NOTE_URI，其用于表示资源的字符
             * 查询的列是 NOTE_PROJECTION
             * 查询的条件是 NoteColumns.PARENT_ID + "=?", new String[] {folderId}
             * 查询的排序是 null
             * 返回类型Cursor 是一个接口，表示从数据库查询中返回的结果集
            */
            Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
                        folderId
                    }, null);

            if (notesCursor != null) {      //如果查询结果不为空
                if (notesCursor.moveToFirst()) {        //将查询结果的游标移动到第一行
                    do {                    //循环遍历查询结果
                        // Print note's last modified date
                        // 打印笔记的最后修改日期
                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                mContext.getString(R.string.format_datetime_mdhm),
                                notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
                        // Query data belong to this note
                        // 查询属于此笔记的数据
                        //获取当前笔记的 ID (noteId)，并调用 exportNoteToText(noteId, ps) 方法导出该笔记的详细数据。
                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (notesCursor.moveToNext());//将查询结果的游标移动到下一行
                }
                notesCursor.close();//关闭查询结果的游标
            }
        }

        /**
         * Export note identified by id to a print stream
         * 导出指定ID的笔记到打印流
         * @param noteId 笔记ID
         * @param ps 打印流
         */
        private void exportNoteToText(String noteId, PrintStream ps) {
            /**
             * 查询笔记数据:
             * 使用 ContentResolver 查询属于指定 noteId 的数据
             * 查询的 URI 是 Notes.CONTENT_DATA_URI，表示数据表。
             * 查询的列是 DATA_PROJECTION，定义了需要返回的列。
             * 查询条件是 DataColumns.NOTE_ID + "=?"，参数是 noteId。
             */
            Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
                    DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
                        noteId
                    }, null);
            /**
             * 遍历查询结果，将每条数据的内容导出到文本文件中
             */
            if (dataCursor != null) {
                if (dataCursor.moveToFirst()) {
                    do {
                        //根据数据的 MIME 类型，判断数据的类型，如果是通话记录，则导出通话记录的内容，如果是笔记，则导出笔记的内容。
                        String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
                        if (DataConstants.CALL_NOTE.equals(mimeType)) {
                            //处理通话记录
                            String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER);//获取通话记录的电话号码
                            long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE);      //获取通话记录的通话日期
                            String location = dataCursor.getString(DATA_COLUMN_CONTENT);    //获取通话记录的位置

                            if (!TextUtils.isEmpty(phoneNumber)) {      //如果电话号码不为空，打印电话号码
                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                        phoneNumber));
                            }
                            // Print call date
                            //打印通话日期
                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
                                    .format(mContext.getString(R.string.format_datetime_mdhm),
                                            callDate)));
                            // Print call attachment location
                            //打印通话记录的位置
                            if (!TextUtils.isEmpty(location)) {
                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                        location));
                            }
                        } else if (DataConstants.NOTE.equals(mimeType)) {
                            //处理普通笔记
                            String content = dataCursor.getString(DATA_COLUMN_CONTENT);//获取笔记的内容
                            if (!TextUtils.isEmpty(content)) {//如果笔记内容不为空，打印笔记内容
                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
                                        content));
                            }
                        }
                    } while (dataCursor.moveToNext());
                }
                dataCursor.close();
            }
            //打印一行分隔符，捕获并记录可能得IO异常
            // print a line separator between note
            try {
                ps.write(new byte[] {
                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
                });
            } catch (IOException e) {
                Log.e(TAG, e.toString());
            }
        }

        /**
         * Note will be exported as text which is user readable
         * 笔记将被导出为用户可读的文本。
         */
        public int exportToText() {
            /**
             * 通过调用 externalStorageAvailable 方法检查外部存储是否已挂载且可用。
             * 如果不可用，记录日志并返回 STATE_SD_CARD_UNMOUONTED 状态。
             */
            if (!externalStorageAvailable()) {
                Log.d(TAG, "Media was not mounted");
                return STATE_SD_CARD_UNMOUONTED;
            }
            /**
             * 调用 getExportToTextPrintStream 方法获取指向导出文本文件的打印流。
             * 如果获取失败，记录日志并返回 STATE_SYSTEM_ERROR 状态。
             */
            PrintStream ps = getExportToTextPrintStream();
            if (ps == null) {
                Log.e(TAG, "get print stream error");
                return STATE_SYSTEM_ERROR;
            }
            // First export folder and its notes
            /**
             * 查询所有文件夹及其笔记
             * 使用 ContentResolver 查询所有文件夹及其笔记。
             * 查询条件是文件夹类型且不在回收站，或是通话记录文件夹。
             */
            Cursor folderCursor = mContext.getContentResolver().query(
                    Notes.CONTENT_NOTE_URI,
                    NOTE_PROJECTION,
                    "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
                            + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
                            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
            /**
             * 遍历查询结果，将每个文件夹的名称和笔记导出到文本文件中。
             * 其通过调用exportFolderToText(folderId, ps)方法导出文件夹及其笔记。
             */
            if (folderCursor != null) {
                if (folderCursor.moveToFirst()) {//将查询结果的游标移动到第一行
                    do {
                        // Print folder's name
                        String folderName = "";
                        if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {//如果是通话记录文件夹
                            folderName = mContext.getString(R.string.call_record_folder_name);//获取通话记录文件夹的名称
                        } else {//如果是普通文件夹
                            folderName = folderCursor.getString(NOTE_COLUMN_SNIPPET);//获取文件夹的摘要
                        }
                        if (!TextUtils.isEmpty(folderName)) {//如果文件夹名称不为空，打印文件夹名称
                            ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));//打印文件夹名称
                        }
                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);//获取文件夹的 ID
                        exportFolderToText(folderId, ps);//导出文件夹及其笔记
                    } while (folderCursor.moveToNext());//将查询结果的游标移动到下一行
                }
                folderCursor.close();//关闭查询结果的游标
            }

            // Export notes in root's folder

            //查询根文件夹中的所有笔记
            Cursor noteCursor = mContext.getContentResolver().query(//使用 ContentResolver 查询根文件夹中的所有笔记
                    Notes.CONTENT_NOTE_URI,//查询的 URI 是 Notes.CONTENT_NOTE_URI，表示资源的字符
                    NOTE_PROJECTION,//查询的列是 NOTE_PROJECTION，定义了需要返回的列
                    NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID//查询条件是笔记类型且不在回收站
                            + "=0", null, null);//返回类型Cursor 是一个接口，表示从数据库查询中返回的结果集

            if (noteCursor != null) {//如果查询结果不为空
                if (noteCursor.moveToFirst()) {//将查询结果的游标移动到第一行
                    do {
                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
                                mContext.getString(R.string.format_datetime_mdhm),
                                noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));//打印笔记的最后修改日期
                        // Query data belong to this note
                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);//获取当前笔记的 ID
                        exportNoteToText(noteId, ps);//导出笔记的详细数据
                    } while (noteCursor.moveToNext());//将查询结果的游标移动到下一行
                }
                noteCursor.close();
            }
            ps.close();

            return STATE_SUCCESS;
        }

        /**
         * Get a print stream pointed to the file {@generateExportedTextFile}
         * 获取指向导出文本文件的打印流。
         * @return 打印流
         */
        private PrintStream getExportToTextPrintStream() {
            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
                    R.string.file_name_txt_format);//生成用于存储导出数据的文本文件
            if (file == null) {//如果文件为空
                Log.e(TAG, "create file to exported failed");
                return null;
            }
            mFileName = file.getName();//获取文件名
            mFileDirectory = mContext.getString(R.string.file_path);//获取文件目录
            PrintStream ps = null;
            try {
                FileOutputStream fos = new FileOutputStream(file);//创建一个文件输出流
                ps = new PrintStream(fos);//创建一个打印流
            } catch (FileNotFoundException e) {//捕获并记录可能得IO异常
                e.printStackTrace();//打印异常信息
                return null;
            } catch (NullPointerException e) {//捕获并记录可能得空指针异常
                e.printStackTrace();//打印异常信息
                return null;
            }
            return ps;
        }
    }

    /**
     * Generate the text file to store imported data
     * 生成用于存储导出数据的文本文件
     * @param context 上下文对象
     * @param filePathResId 文件路径资源ID
     * @param fileNameFormatResId 文件名格式资源ID
     * @return 文件对象
     */
    private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
        StringBuilder sb = new StringBuilder(); //创建一个字符串生成器
        sb.append(Environment.getExternalStorageDirectory());//获取外部存储目录
        sb.append(context.getString(filePathResId));//获取文件路径
        File filedir = new File(sb.toString());//创建一个文件目录对象
        sb.append(context.getString(
                fileNameFormatResId,
                DateFormat.format(context.getString(R.string.format_date_ymd),
                        System.currentTimeMillis())));//获取文件名
        File file = new File(sb.toString());//创建一个文件对象

        try {
            if (!filedir.exists()) {//如果文件目录不存在
                filedir.mkdir();
            }
            if (!file.exists()) {//如果文件不存在
                file.createNewFile();
            }
            return file;
        } catch (SecurityException e) {//捕获并记录可能得安全异常
            e.printStackTrace();
        } catch (IOException e) {//捕获并记录可能得IO异常
            e.printStackTrace();
        }

        return null;
    }
}

• DataUtils

/*
 * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.micode.notes.tool;

import android.content.ContentProviderOperation;
import android.content.ContentProviderResult;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.OperationApplicationException;
import android.database.Cursor;
import android.os.RemoteException;
import android.util.Log;

import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.CallNote;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;

import java.util.ArrayList;
import java.util.HashSet;


/**
 * 便签数据处理工具类，封装如查找、移动、删除数据等操作
 */

public class DataUtils {
    public static final String TAG = "DataUtils";//标签
    private static final String QUERY_CONDITION = "=? AND ";

    private  static final String CONTANT_QUOTE="%s: %s";

    /**
     * 根据便签ID批量删除便签
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @param ids 要删除的便签ID集合
     * @return  如果删除成功，返回true；否则返回false
     */
    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {//批量删除便签
        if (ids == null) {//如果便签ID集合为空
            Log.d(TAG, "the ids is null");//Log日志输出调试信息，便于后期调试
            return true;
        }
        if (ids.size() == 0) {//如果便签ID集合的大小为0
            Log.d(TAG, "no id is in the hashset");//Log日志输出调试信息，便于后期调试
            return true;
        }

        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();  //用于存储批量数据库操作操作的列表，确保数据的一致性和效率
        for (long id : ids) {   //遍历便签ID集合
            if(id == Notes.ID_ROOT_FOLDER) {//如果便签ID为根文件夹
                Log.e(TAG, "Don't delete system folder root");//Log日志输出错误信息，便于后期调试
                continue;
            }
            ContentProviderOperation.Builder builder = ContentProviderOperation
                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));//将基础 URI 和具体记录的 ID 组合成一个新的 URI，用于指定便签ID的删除操作
            operationList.add(builder.build());//将删除操作添加到操作列表
        }
        try {
            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);//将操作列表应用到ContentProvider，返回操作结果
            if (results == null || results.length == 0 || results[0] == null) {//如果操作结果为空
                Log.d(TAG, "delete notes failed, ids:" + ids.toString());//删除便签失败，Log日志输出调试信息，便于后期调试
                return false;
            }
            return true;
        } catch (RemoteException e) {//捕获远程异常
            Log.e(TAG, String.format(CONTANT_QUOTE, e.toString(), e.getMessage()));
        } catch (OperationApplicationException e) {//捕获操作应用异常
            Log.e(TAG, String.format(CONTANT_QUOTE, e.toString(), e.getMessage()));
        }
        return false;
    }

    /**
     * 根据便签ID移动便签到指定文件夹
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @param id 便签ID
     * @param srcFolderId 源文件夹ID
     * @param desFolderId 目标文件夹ID
     */
    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
        ContentValues values = new ContentValues(); //用于存储键值对的数据结构，传递给数据库以执行对应的数据库操作
        values.put(NoteColumns.PARENT_ID, desFolderId); //将目标文件夹ID存入键值对
        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId); //将源文件夹ID存入键值对
        values.put(NoteColumns.LOCAL_MODIFIED, 1); //将本地修改标志存入键值对
        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null); //更新便签数据
    }

    /**
     * 根据便签ID批量移动便签到指定文件夹
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @param ids 便签ID集合
     * @param folderId 目标文件夹ID
     * @return 如果移动成功，返回true；否则返回false
     */
    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
            long folderId) {
        if (ids == null) { //如果便签ID集合为空
            Log.d(TAG, "the ids is null"); //Log日志输出调试信息，便于后期调试
            return true;
        }

        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>(); //用于存储批量数据库操作操作的列表，确保数据的一致性和效率
        for (long id : ids) { //遍历便签ID集合
            ContentProviderOperation.Builder builder = ContentProviderOperation
                    .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); //将基础 URI 和具体记录的 ID 组合成一个新的 URI，用于指定便签ID的更新操作
            builder.withValue(NoteColumns.PARENT_ID, folderId); //将目标文件夹ID存入键值对
            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1); //将本地修改标志存入键值对
            operationList.add(builder.build()); //将更新操作添加到操作列表
        }

        try {
            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList); //将操作列表应用到ContentProvider，返回操作结果
            if (results == null || results.length == 0 || results[0] == null) { //如果操作结果为空
                Log.d(TAG, "delete notes failed, ids:" + ids.toString()); //删除便签失败，Log日志输出调试信息，便于后期调试
                return false; //返回false
            }
            return true;
        } catch (RemoteException e) { //捕获远程异常
            Log.e(TAG, String.format(CONTANT_QUOTE, e.toString(), e.getMessage())); //Log日志输出错误信息，便于后期调试
        } catch (OperationApplicationException e) { //捕获操作应用异常
            Log.e(TAG, String.format(CONTANT_QUOTE, e.toString(), e.getMessage()));
        }
        return false;
    }

    /**
     * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
     * 获取除系统文件夹外的所有文件夹计数
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @return 返回文件夹计数
     */
    public static int getUserFolderCount(ContentResolver resolver) {
        Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI, //查询的URI，指定要查询的数据库表
                new String[] { "COUNT(*)" }, //查询的字段，这里是计数所有符合条件的记录数
                //查询条件
                // 表示 NoteColumns.TYPE 字段的值必须等于第一个参数  文件夹类型
                // 并且 NoteColumns.PARENT_ID 字段的值必须不等于第二个参数  垃圾文件夹
                NoteColumns.TYPE + QUERY_CONDITION+ NoteColumns.PARENT_ID + "<>?",
                new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},//查询条件的参数
                null);

        int count = 0;
        if(cursor != null) { //如果游标不为空
            if(cursor.moveToFirst()) { //如果游标移动到第一行
                try {
                    count = cursor.getInt(0); //获取第一列的值
                } catch (IndexOutOfBoundsException e) { //捕获索引越界异常
                    Log.e(TAG, "get folder count failed:" + e.toString());
                } finally {
                    cursor.close();
                }
            }
        }
        return count; //返回文件夹计数
    }

    /**
     * 检查指定类型的便签是否在数据库中可见。
     * @param resolver 用于访问数据库的ContentResolver。
     * @param noteId 要检查的便签ID。
     * @param type 便签的类型。
     * @return 如果便签可见返回true，否则返回false。
     */
    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), //查询的URI，指定要查询的数据库表
                null, //查询的字段，这里是所有字段
                NoteColumns.TYPE +QUERY_CONDITION + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, //查询条件 便签类型和父ID不等于垃圾文件夹
                new String [] {String.valueOf(type)}, //查询条件的参数
                null);

        boolean exist = false; //是否存在标志
        if (cursor != null) { //如果游标不为空
            if (cursor.getCount() > 0) { //如果游标的记录数大于0
                exist = true;
            }
            cursor.close();
        }
        return exist; //返回是否存在标志
    }

    /**
     * 检查便签是否在数据库中可见。
     * @param resolver 用于访问数据库的ContentResolver。
     * @param noteId 要检查的便签ID。
     * @return 如果便签可见返回true，否则返回false。
     */
    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), //查询的URI，指定要查询的数据库表
                null, null, null, null); //查询条件为空

        boolean exist = false; //是否存在标志
        if (cursor != null) {
            if (cursor.getCount() > 0) {
                exist = true; //如果游标的记录数大于0，返回True
            }
            cursor.close();
        }
        return exist; //返回是否存在标志
    }

    /**
     * 检查数据是否在数据库中可见。
     * @param resolver 用于访问数据库的ContentResolver。
     * @param dataId   要检查的数据ID。
     * @return 如果数据可见返回true，否则返回false。
     */
    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), //查询的URI，指定要查询的数据库表
                null, null, null, null); //查询条件为空

        boolean exist = false; //是否存在标志
        if (cursor != null) {
            if (cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist; //返回是否存在标志
    }

    /**
     * 检查文件夹名称是否可见。
     * @param resolver 用于访问数据库的ContentResolver。
     * @param name    要检查的文件夹名称。
     * @return 如果文件夹名称可见返回true，否则返回false。
     */
    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,  //查询的URI，指定要查询的数据库表
                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
                " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
                " AND " + NoteColumns.SNIPPET + "=?", //查询条件 文件夹类型、父ID不等于垃圾文件夹、文件夹名称
                new String[] { name }, null); //查询条件的参数
        boolean exist = false;  //是否存在标志
        if(cursor != null) {
            if(cursor.getCount() > 0) {
                exist = true;
            }
            cursor.close();
        }
        return exist;
    }

    /**
     * 获取指定文件夹的便签小部件
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @param folderId 文件夹ID
     * @return 包含便签小部件属性的集合
     */
    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
        //查询文件夹中的便签小部件
        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, //查询的URI，指定要查询的数据库表
                new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, //查询的字段，这里是widgetID和widgetType
                NoteColumns.PARENT_ID + "=?", //查询条件 父ID等于文件夹ID
                new String[] { String.valueOf(folderId) }, //查询条件的参数
                null);

        HashSet<AppWidgetAttribute> set = null; //便签ID集合
        if (c != null) {  //如果游标不为空
            if (c.moveToFirst()) { //如果游标移动到第一行
                set = new HashSet<AppWidgetAttribute>(); //创建便签ID集合
                do {
                    try {
                        AppWidgetAttribute widget = new AppWidgetAttribute(); //创建便签小部件属性
                        widget.widgetId = c.getInt(0); //获取widgetID
                        widget.widgetType = c.getInt(1); //获取widgetType
                        set.add(widget); //添加到便签ID集合
                    } catch (IndexOutOfBoundsException e) { //捕获索引越界异常
                        Log.e(TAG, e.toString());
                    }
                } while (c.moveToNext()); //移动到下一行
            }
            c.close();
        }
        return set; //
    }

    /**
     * 通过便签ID获取电话号码
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @param noteId 便签ID
     * @return 电话号码字符串
     */
    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, //查询的URI，指定要查询的数据库表
                new String [] { CallNote.PHONE_NUMBER }, //查询的字段，这里是电话号码
                Notes.DataColumns.NOTE_ID + QUERY_CONDITION + Notes.DataColumns.MIME_TYPE + "=?", //查询条件 便签ID和MIME类型
                new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },  //查询条件的参数 便签ID和MIME类型
                null);

        if (cursor != null && cursor.moveToFirst()) { //如果游标不为空且移动到第一行
            try {
                return cursor.getString(0); //获取电话号码
            } catch (IndexOutOfBoundsException e) { //捕获索引越界异常
                Log.e(TAG, "Get call number fails " + e.toString());
            } finally {
                cursor.close();
            }
        }
        return ""; //返回空字符串
    }

    /**
     * 通过电话号码和通话日期获取便签ID
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @param phoneNumber 电话号码
     * @param callDate 通话日期
     * @return 便签ID
     */
    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, //查询的URI，指定要查询的数据库表
                new String [] { Notes.DataColumns.NOTE_ID }, //查询的字段，这里是便签ID
                CallNote.CALL_DATE + QUERY_CONDITION+ Notes.DataColumns.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
                + CallNote.PHONE_NUMBER + ",?)", //查询条件 通话日期、MIME类型和电话号码
                new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, //查询条件的参数 通话日期、MIME类型和电话号码
                null);

        if (cursor != null) {
            if (cursor.moveToFirst()) { //游标移动到第一行
                try {
                    return cursor.getLong(0);
                } catch (IndexOutOfBoundsException e) { //捕获索引越界异常
                    Log.e(TAG, "Get call note id fails " + e.toString());
                }
            }
            cursor.close();
        }
        return 0;
    }

    /**
     * 通过便签ID获取便签內容/片段
     * @param resolver 访问 ContentProvider 提供的数据，通过URI解析，对指定数据库表的数据进行增删改查功能
     * @param noteId   便签ID
     * @return 便签片段
     */
    public static String getSnippetById(ContentResolver resolver, long noteId) {
        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, //查询的URI，指定要查询的数据库表
                new String [] { NoteColumns.SNIPPET }, //查询的字段，这里是便签片段
                NoteColumns.ID + "=?", //查询条件 便签ID
                new String [] { String.valueOf(noteId)}, //查询条件的参数 便签ID
                null);

        if (cursor != null) {
            String snippet = ""; //便签的文本内容
            if (cursor.moveToFirst()) {
                snippet = cursor.getString(0);
            }
            cursor.close();
            return snippet; //返回便签内容
        }
        throw new IllegalArgumentException("Note is not found with id: " + noteId);
    }

    /**
     * 格式化便签文本，去除空格和换行符
     * @param snippet 便签内容
     * @return 格式化后的便签内容
     */
    public static String getFormattedSnippet(String snippet) {
        if (snippet != null) { //如果便签内容不为空
            snippet = snippet.trim(); //去除空格
            int index = snippet.indexOf('\n'); //查找换行符
            if (index != -1) { //如果找到换行符
                snippet = snippet.substring(0, index); //截取换行符前的内容
            }
        }
        return snippet; //返回格式化后的便签内容
    }
}