V1

src/BackupUtils.java

@@ -0,0 +1,356 @@
+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;
+
+// BackupUtils类用于实现笔记数据的备份相关功能，例如将笔记数据导出为文本格式等
+public class BackupUtils {
+    private static final String TAG = "BackupUtils";
+    // 单例模式相关，用于保存唯一的BackupUtils实例
+    private static BackupUtils sInstance;
+
+    // 获取BackupUtils的单例实例，若不存在则创建新实例
+    public static synchronized BackupUtils getInstance(Context context) {
+        if (sInstance == null) {
+            sInstance = new BackupUtils(context);
+        }
+        return sInstance;
+    }
+
+    /**
+     * 以下这些状态常量用于表示备份或恢复操作的不同状态
+     */
+    // 当前外部存储卡（SD卡）未挂载
+    public static final int STATE_SD_CARD_UNMOUONTED = 0;
+    // 备份文件不存在
+    public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
+    // 数据格式不正确，可能被其他程序修改过
+    public static final int STATE_DATA_DESTROIED = 2;
+    // 一些运行时异常导致备份或恢复操作失败
+    public static final int STATE_SYSTEM_ERROR = 3;
+    // 备份或恢复操作成功
+    public static final int STATE_SUCCESS = 4;
+
+    private TextExport mTextExport;
+
+    // 私有构造函数，初始化时创建TextExport对象，用于文本导出相关操作
+    private BackupUtils(Context context) {
+        mTextExport = new TextExport(context);
+    }
+
+    // 判断外部存储（通常指SD卡）是否可用，通过比较外部存储状态与已挂载状态常量来判断
+    private static boolean externalStorageAvailable() {
+        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
+    }
+
+    // 调用TextExport对象的exportToText方法进行文本导出，并返回相应的状态码
+    public int exportToText() {
+        return mTextExport.exportToText();
+    }
+
+    // 获取导出的文本文件名，实际是通过TextExport对象获取其内部保存的文件名
+    public String getExportedTextFileName() {
+        return mTextExport.mFileName;
+    }
+
+    // 获取导出的文本文件所在目录，同样是通过TextExport对象获取其内部保存的文件目录
+    public String getExportedTextFileDir() {
+        return mTextExport.mFileDirectory;
+    }
+
+    // TextExport内部类，主要负责具体的文本导出逻辑，将笔记数据格式化为文本并输出到文件
+    private static class TextExport {
+        // 用于查询笔记基本信息（如ID、修改日期、摘要、类型等）的投影数组，指定了从数据库查询时要返回的列
+        private static final String[] NOTE_PROJECTION = {
+                NoteColumns.ID,
+                NoteColumns.MODIFIED_DATE,
+                NoteColumns.SNIPPET,
+                NoteColumns.TYPE
+        };
+
+        // 对应NOTE_PROJECTION中笔记ID列的索引，方便后续从查询结果游标中获取该列数据
+        private static final int NOTE_COLUMN_ID = 0;
+
+        // 对应NOTE_PROJECTION中笔记修改日期列的索引，方便后续从查询结果游标中获取该列数据
+        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
+
+        // 对应NOTE_PROJECTION中笔记摘要列的索引，方便后续从查询结果游标中获取该列数据
+        private static final int NOTE_COLUMN_SNIPPET = 2;
+
+        // 用于查询笔记相关数据（如内容、MIME类型等）的投影数组，指定了从数据库查询时要返回的列
+        private static final String[] DATA_PROJECTION = {
+                DataColumns.CONTENT,
+                DataColumns.MIME_TYPE,
+                DataColumns.DATA1,
+                DataColumns.DATA2,
+                DataColumns.DATA3,
+                DataColumns.DATA4,
+        };
+
+        // 对应DATA_PROJECTION中内容列的索引，方便后续从查询结果游标中获取该列数据
+        private static final int DATA_COLUMN_CONTENT = 0;
+
+        // 对应DATA_PROJECTION中MIME类型列的索引，方便后续从查询结果游标中获取该列数据
+        private static final int DATA_COLUMN_MIME_TYPE = 1;
+
+        // 对应DATA_PROJECTION中通话日期列的索引（这里命名可能有点混淆，原代码如此，从变量名推测是和通话相关的日期），方便后续从查询结果游标中获取该列数据
+        private static final int DATA_COLUMN_CALL_DATE = 2;
+
+        // 对应DATA_PROJECTION中电话号码列的索引，方便后续从查询结果游标中获取该列数据
+        private static final int DATA_COLUMN_PHONE_NUMBER = 4;
+
+        // 用于格式化导出文本的字符串数组，不同索引对应不同的格式模板，比如文件夹名、笔记日期、笔记内容等的格式
+        private static 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;
+
+        // 构造函数，初始化TextExport对象，获取用于文本格式化的字符串数组，同时初始化上下文、文件名和文件目录相关变量
+        public TextExport(Context context) {
+            TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
+            mContext = context;
+            mFileName = "";
+            mFileDirectory = "";
+        }
+
+        // 根据给定的格式模板ID获取对应的格式字符串，用于后续格式化文本输出
+        private String getFormat(int id) {
+            return TEXT_FORMAT[id];
+        }
+
+        /**
+         * 将指定文件夹（通过folderId标识）下的所有笔记导出为文本格式，并输出到给定的PrintStream中
+         */
+        private void exportFolderToText(String folderId, PrintStream ps) {
+            // 通过内容解析器查询属于该文件夹的所有笔记，使用之前定义的NOTE_PROJECTION指定查询返回的列，根据父文件夹ID筛选
+            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 {
+                        // 使用指定格式打印笔记的最后修改日期，先格式化日期，再按照格式模板进行输出
+                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
+                                mContext.getString(R.string.format_datetime_mdhm),
+                                notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
+                        // 获取当前笔记的ID，用于后续查询该笔记相关的数据
+                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
+                        // 调用exportNoteToText方法导出当前笔记的数据为文本格式并输出到PrintStream中
+                        exportNoteToText(noteId, ps);
+                    } while (notesCursor.moveToNext());  // 循环遍历游标中的下一条笔记数据，直到全部遍历完
+                }
+                // 关闭游标，释放相关资源
+                notesCursor.close();
+            }
+        }
+
+        /**
+         * 将指定ID的笔记数据导出为文本格式，并输出到给定的PrintStream中
+         */
+        private void exportNoteToText(String noteId, PrintStream ps) {
+            // 通过内容解析器查询属于该笔记的所有相关数据，使用之前定义的DATA_PROJECTION指定查询返回的列，根据笔记ID筛选
+            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));
+                            }
+                            // 格式化并输出通话日期
+                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
+                                   .format(mContext.getString(R.string.format_datetime_mdhm),
+                                            callDate)));
+                            // 如果通话附件位置信息不为空，则按格式输出该位置信息
+                            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异常则记录日志
+            try {
+                ps.write(new byte[]{
+                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
+                });
+            } catch (IOException e) {
+                Log.e(TAG, e.toString());
+            }
+        }
+
+        /**
+         * 将笔记数据导出为用户可读的文本格式，整体执行备份导出的逻辑流程
+         */
+        public int exportToText() {
+            // 首先判断外部存储（SD卡）是否可用，如果不可用则记录日志并返回表示SD卡未挂载的状态码
+            if (!externalStorageAvailable()) {
+                Log.d(TAG, "Media was not mounted");
+                return STATE_SD_CARD_UNMOUONTED;
+            }
+
+            // 获取用于将数据输出到文本文件的PrintStream对象，如果获取失败则记录日志并返回表示系统错误的状态码
+            PrintStream ps = getExportToTextPrintStream();
+            if (ps == null) {
+                Log.e(TAG, "get print stream error");
+                return STATE_SYSTEM_ERROR;
+            }
+            // 先导出文件夹及其包含的笔记数据
+            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);
+
+            // 如果查询文件夹的游标不为空（即有查询到相关文件夹数据）
+            if (folderCursor!= null) {
+                // 将游标移动到第一条数据位置（开始遍历数据）
+                if (folderCursor.moveToFirst()) {
+                    do {
+                        // 获取文件夹名称，根据文件夹ID判断是否是通话记录文件夹，若是则使用对应的固定名称，否则使用摘要作为文件夹名
+                        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));
+                        }
+                        // 获取当前文件夹的ID，用于后续导出该文件夹下的笔记数据
+                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
+                        // 调用exportFolderToText方法导出该文件夹下的所有笔记数据
+                        exportFolderToText(folderId, ps);
+                    } while (folderCursor.moveToNext());  // 循环遍历游标中的下一个文件夹数据，直到全部遍历完
+                }
+                // 关闭游标，释放相关资源
+                folderCursor.close();
+            }
+
+            // 导出根文件夹下的笔记数据
+            Cursor noteCursor = mContext.getContentResolver().query(
+                    Notes.CONTENT_NOTE_URI,
+                    NOTE_PROJECTION,
+                    NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID
+                            + "=0", null, null);
+
+            // 如果查询根文件夹笔记的游标不为空（即有查询到相关笔记数据）
+            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))));
+                        // 获取当前笔记的ID，用于后续查询该笔记相关的数据
+                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
+                        // 调用exportNoteToText方法导出当前笔记的数据为文本格式并输出到PrintStream中
+                        exportNoteToText(noteId, ps);
+                    } while (noteCursor.moveToNext());  // 循环遍历游标中的下一条笔记数据，直到全部遍历完
+                }
+                // 关闭游标，释放相关资源
+                noteCursor.close();
+            }
+            // 关闭PrintStream，完成整个文本导出操作并释放相关资源，最后返回表示操作成功的状态码
+            ps.close();
+
+            return STATE_SUCCESS;
+        }
+
+        /**
+         * 获取一个指向要导出文本文件的PrintStream对象，如果创建文件或获取输出流失败则返回null
+         */
+        private PrintStream getExportToTextPrintStream() {
+            // 生成要保存导出数据的文本文件对象，通过调用generateFileMountedOnSDcard方法，传入相关资源ID用于构建文件路径和文件名格式
+            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
+                    R.string.file_name_txt_format);
+            if (file == null) {  // 如果文件创建失败（返回null），则记录日志并返回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);
+                // 通过文件输出流创建PrintStream对象，用于方便地向文件写入格式化的文本数据
+                ps = new PrintStream(fos);
+            } catch (FileNotFoundException e) {  // 如果文件未找到异常（比如文件路径不正确等原因），打印异常堆栈信息并返回null
+                e.printStackTrace();
+                return null;
+            } catch (NullPointerException e) {  // 如果出现空指针异常（比如传入的文件对象为null等原因），打印异常堆栈信息并返回null
+                e.printStackTrace();
+                return null;
+            }
+            return ps;
+        }
+    }
+
+    /**
+     * 在已挂载的SD卡上生成用于存储导入数据的文本文件，如果生成过程出现异常则返回null
+     */
+    private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+        StringBuilder sb = new StringBuilder();
+        // 先添加外部存储（SD卡）的根目录路径
+        sb.append(Environment.getExternalStorageDirectory());
+        // 再添加通过资源ID获取的文件路径部分，构建出完整的文件目录路径
+        sb.append(context.getString(filePathResId));
+        File filedir = new File(sb.toString());
+        // 在目录路径基础上，添加通过资源ID获取的文件名格式部分（文件名中可能包含日期等动态内容，通过格式化生成最终文件名），构建出完整的文件路径
+        sb.append(context.getString(
+                fileNameFormatResId,
+                DateFormat.format(context.getString(R.string.format_date_ymd),
+                        System.currentTimeMillis())));
+        File file = new File(sb.toString());

src/DataUtils.java

@@ -0,0 +1,327 @@
+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;
+
+// DataUtils类提供了一系列用于操作笔记数据的实用方法，例如批量删除笔记、移动笔记到文件夹、查询各种数据相关的存在性等功能
+public class DataUtils {
+    public static final String TAG = "DataUtils";
+
+    // 批量删除指定ID集合对应的笔记
+    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        // 如果传入的要删除的笔记ID集合为null，记录日志并返回true（表示无需进行删除操作，直接认为成功）
+        if (ids == null) {
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+        // 如果传入的要删除的笔记ID集合大小为0，即没有要删除的笔记，记录日志并返回true（表示无需进行删除操作，直接认为成功）
+        if (ids.size() == 0) {
+            Log.d(TAG, "no id is in the hashset");
+            return true;
+        }
+
+        // 创建一个用于存储内容提供器操作的列表，后续会将批量删除操作添加到这个列表中
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        // 遍历要删除的笔记ID集合
+        for (long id : ids) {
+            // 如果当前笔记的ID是系统根文件夹的ID（通常系统根文件夹不允许删除），记录错误日志并跳过本次循环，不添加到删除操作列表中
+            if (id == Notes.ID_ROOT_FOLDER) {
+                Log.e(TAG, "Don't delete system folder root");
+                continue;
+            }
+            // 创建一个用于删除指定笔记的内容提供器操作构建器，指定要删除的笔记的URI（通过将笔记ID附加到基础的笔记内容URI上）
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                  .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            // 将构建好的删除操作添加到操作列表中
+            operationList.add(builder.build());
+        }
+        try {
+            // 执行批量的内容提供器操作，传入对应的权限和操作列表，获取操作结果数组
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 如果操作结果数组为null，或者长度为0，或者第一个结果为null（表示操作可能没有正确执行），记录日志并返回false（表示删除笔记失败）
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            // 如果操作执行成功，返回true
+            return true;
+        } catch (RemoteException e) {
+            // 如果发生远程异常（比如与内容提供器通信出现问题等），记录详细的异常信息到日志中
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            // 如果发生操作应用异常（比如批量操作执行过程中出现错误等），记录详细的异常信息到日志中
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        // 如果发生异常导致操作未能成功完成，返回false
+        return false;
+    }
+
+    // 将指定ID的笔记移动到目标文件夹，同时记录笔记的原始文件夹ID，并标记本地已修改
+    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+        // 创建一个用于存储要更新的列和对应值的ContentValues对象
+        ContentValues values = new ContentValues();
+        // 设置笔记的新父文件夹ID（即目标文件夹ID）
+        values.put(NoteColumns.PARENT_ID, desFolderId);
+        // 设置笔记的原始父文件夹ID（即来源文件夹ID）
+        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
+        // 设置本地已修改的标记为1，表示该笔记有本地修改操作
+        values.put(NoteColumns.LOCAL_MODIFIED, 1);
+        // 通过内容解析器更新指定ID的笔记，使用上面设置好的ContentValues对象来更新相应列的值，后面两个参数为null表示不使用条件筛选和不传入额外的参数
+        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
+    }
+
+    // 批量将指定ID集合的笔记移动到指定文件夹
+    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
+                                            long folderId) {
+        // 如果传入的要移动的笔记ID集合为null，记录日志并返回true（表示无需进行移动操作，直接认为成功）
+        if (ids == null) {
+            Log.d(TAG, "the ids is null");
+            return true;
+        }
+
+        // 创建一个用于存储内容提供器操作的列表，后续会将批量移动操作添加到这个列表中
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        // 遍历要移动的笔记ID集合
+        for (long id : ids) {
+            // 创建一个用于更新指定笔记的内容提供器操作构建器，指定要更新的笔记的URI（通过将笔记ID附加到基础的笔记内容URI上）
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                  .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            // 设置笔记的新父文件夹ID（即目标文件夹ID）
+            builder.withValue(NoteColumns.PARENT_ID, folderId);
+            // 设置本地已修改的标记为1，表示该笔记有本地修改操作
+            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
+            // 将构建好的更新操作添加到操作列表中
+            operationList.add(builder.build());
+        }
+
+        try {
+            // 执行批量的内容提供器操作，传入对应的权限和操作列表，获取操作结果数组
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 如果操作结果数组为null，或者长度为0，或者第一个结果为null（表示操作可能没有正确执行），记录日志并返回false（表示移动笔记失败）
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "delete notes failed, ids:" + ids.toString());
+                return false;
+            }
+            // 如果操作执行成功，返回true
+            return true;
+        } catch (RemoteException e) {
+            // 如果发生远程异常（比如与内容提供器通信出现问题等），记录详细的异常信息到日志中
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            // 如果发生操作应用异常（比如批量操作执行过程中出现错误等），记录详细的异常信息到日志中
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        // 如果发生异常导致操作未能成功完成，返回false
+        return false;
+    }
+
+    /**
+     * 获取除系统文件夹（{@link Notes#TYPE_SYSTEM} 标记的文件夹）之外的所有用户文件夹的数量
+     */
+    public static int getUserFolderCount(ContentResolver resolver) {
+        // 通过内容解析器查询满足条件的文件夹数量，查询条件是类型为文件夹且父文件夹ID不是回收站文件夹ID，只查询记录数量（通过 COUNT(*) 聚合函数）
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[]{"COUNT(*)"},
+                NoteColumns.TYPE + "=? AND " + 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变量
+                    count = cursor.getInt(0);
+                } catch (IndexOutOfBoundsException e) {
+                    // 如果发生越界异常（比如查询结果格式不符合预期等情况），记录详细的异常信息到日志中
+                    Log.e(TAG, "get folder count failed:" + e.toString());
+                } finally {
+                    // 无论是否发生异常，都关闭游标，释放相关资源
+                    cursor.close();
+                }
+            }
+        }
+        return count;
+    }
+
+    // 判断指定ID的笔记是否在笔记数据库中可见（即不在回收站且类型符合要求）
+    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
+        // 通过内容解析器查询指定笔记是否存在且满足可见条件（类型符合要求且父文件夹ID不是回收站文件夹ID）
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null,
+                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
+                new String[]{String.valueOf(type)},
+                null);
+
+        boolean exist = false;
+        // 如果查询结果游标不为空
+        if (cursor!= null) {
+            // 如果游标中的记录数量大于0，表示笔记存在且满足可见条件，将exist设置为true
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            // 关闭游标，释放相关资源
+            cursor.close();
+        }
+        return exist;
+    }
+
+    // 判断指定ID的笔记是否存在于笔记数据库中（简单查询是否存在该记录）
+    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
+        // 通过内容解析器查询指定笔记是否存在，不添加额外的查询条件
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+                null, null, null, null);
+
+        boolean exist = false;
+        // 如果查询结果游标不为空
+        if (cursor!= null) {
+            // 如果游标中的记录数量大于0，表示笔记存在，将exist设置为true
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            // 关闭游标，释放相关资源
+            cursor.close();
+        }
+        return exist;
+    }
+
+    // 判断指定ID的数据记录是否存在于数据数据库中（简单查询是否存在该记录）
+    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
+        // 通过内容解析器查询指定数据记录是否存在，不添加额外的查询条件
+        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
+                null, null, null, null);
+
+        boolean exist = false;
+        // 如果查询结果游标不为空
+        if (cursor!= null) {
+            // 如果游标中的记录数量大于0，表示数据记录存在，将exist设置为true
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            // 关闭游标，释放相关资源
+            cursor.close();
+        }
+        return exist;
+    }
+
+    // 检查指定名称的文件夹是否在笔记数据库中可见（即不在回收站且类型为文件夹、名称匹配）
+    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
+        // 通过内容解析器查询满足条件的文件夹是否存在，条件是类型为文件夹、父文件夹ID不是回收站文件夹ID且摘要（名称）匹配传入的名称
+        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
+                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
+                        " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
+                        " AND " + NoteColumns.SNIPPET + "=?",
+                new String[]{name}, null);
+        boolean exist = false;
+        // 如果查询结果游标不为空
+        if (cursor!= null) {
+            // 如果游标中的记录数量大于0，表示文件夹存在且满足可见条件，将exist设置为true
+            if (cursor.getCount() > 0) {
+                exist = true;
+            }
+            // 关闭游标，释放相关资源
+            cursor.close();
+        }
+        return exist;
+    }
+
+    // 获取指定文件夹下所有笔记对应的小部件相关属性集合（包括小部件ID和小部件类型）
+    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
+        // 通过内容解析器查询指定文件夹下所有笔记的小部件ID和小部件类型信息
+        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
+                new String[]{NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE},
+                NoteColumns.PARENT_ID + "=?",
+                new String[]{String.valueOf(folderId)},
+                null);
+
+        HashSet<AppWidgetAttribute> set = null;
+        // 如果查询结果游标不为空
+        if (c!= null) {
+            // 将游标移动到第一条数据位置（开始遍历数据）
+            if (c.moveToFirst()) {
+                // 创建一个用于存储小部件相关属性的HashSet集合
+                set = new HashSet<AppWidgetAttribute>();
+                do {
+                    try {
+                        // 创建一个AppWidgetAttribute对象，用于存储单个小部件的属性
+                        AppWidgetAttribute widget = new AppWidgetAttribute();
+                        // 从游标中获取小部件ID并赋值给AppWidgetAttribute对象的对应属性
+                        widget.widgetId = c.getInt(0);
+                        // 从游标中获取小部件类型并赋值给AppWidgetAttribute对象的对应属性
+                        widget.widgetType = c.getInt(1);
+                        // 将小部件属性对象添加到HashSet集合中
+                        set.add(widget);
+                    } catch (IndexOutOfBoundsException e) {
+                        // 如果发生越界异常（比如查询结果格式不符合预期等情况），记录详细的异常信息到日志中
+                        Log.e(TAG, e.toString());
+                    }
+                } while (c.moveToNext());  // 循环遍历游标中的下一条数据，直到全部遍历完
+            }
+            // 关闭游标，释放相关资源
+            c.close();
+        }
+        return set;
+    }
+
+    // 根据笔记ID获取对应的通话号码（前提是该笔记是通话相关笔记）
+    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+        // 通过内容解析器查询指定笔记对应的通话号码，查询条件是笔记ID匹配且MIME类型为通话笔记的类型
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String[]{CallNote.PHONE_NUMBER},
+                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
+                new String[]{String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE},
+                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（前提是存在关联的通话笔记）
+    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+        // 通过内容解析器查询满足条件的笔记ID，条件是通话日期匹配、MIME类型为通话笔记的类型且电话号码匹配（通过自定义函数PHONE_NUMBERS_EQUAL判断）
+        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
+                new String[]{CallNote.NOTE_ID},
+                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
+                        + CallNote.PHONE_NUMBER + ",?)",
+                new String[]{String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber},
+                null);
+
+        if (cursor!= null) {
+            if (cursor.moveToFirst()) {
+                try {
+                    // 如果查询到数据且游标移动到第一条数据位置，尝试从游标中获取笔记ID并返回
+                    return cursor.getLong(0);
+                } catch (IndexOutOfBoundsException e) {
+                    // 如果发生越界异常（比如查询结果格式不符合预期等情况），记录详细的异常信息到日志中
+                    Log.e(TAG, "Get call note id fails " + e.toString());
+                }
+            }
+            // 关闭游标，释放相关资源

src/GTaskStringUtils.java

@@ -0,0 +1,142 @@
+/*
+ * 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.
+ */
+// 版权声明部分，表明该代码遵循Apache License 2.0开源协议，包含版权归属、授权相关等信息，说明了代码的使用规则和限制等情况。
+
+package net.micode.notes.tool;
+// 声明该类所在的包名，用于对代码进行组织和模块化管理，方便在项目中引用和区分不同功能模块的类，使代码结构更清晰。
+
+public class GTaskStringUtils {
+    // 定义一个名为GTaskStringUtils的公共类，从类名推测可能是用于处理与GTask相关的字符串操作的工具类，通常会包含一些静态的常量字符串成员，方便在代码中统一使用和引用。
+
+    public final static String GTASK_JSON_ACTION_ID = "action_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，动作（action）的唯一标识符对应的键（Key）名称，方便在解析或构建JSON数据时通过这个键来获取或设置相应的值。
+
+    public final static String GTASK_JSON_ACTION_LIST = "action_list";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，动作列表（action_list）对应的键（Key）名称，可能用于存放多个动作相关信息的集合，在处理JSON数据交互时可依据此键来操作对应的数据内容。
+
+    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，动作类型（action_type）对应的键（Key）名称，通过这个键对应的值可以判断具体执行的是哪种类型的动作，比如创建、更新等操作，便于在代码中根据不同动作类型进行相应的逻辑处理。
+
+    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，创建（create）类型动作对应的具体值，当通过GTASK_JSON_ACTION_TYPE这个键获取到的值为此常量时，可确定当前动作是创建操作，便于在业务逻辑中识别和处理创建相关的任务或数据。
+
+    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，获取全部（get_all）类型动作对应的具体值，用于在解析JSON数据时判断是否是获取所有相关数据的操作请求，以便执行相应的获取全部数据的逻辑处理。
+
+    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，移动（move）类型动作对应的具体值，当在JSON数据中识别到此值作为动作类型时，可知道要执行的是移动相关的数据操作，比如移动任务到其他位置等情况。
+
+    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，更新（update）类型动作对应的具体值，用于判断JSON数据中对应的动作是更新操作，进而执行相应的更新任务、数据等业务逻辑。
+
+    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，创建者（creator）的唯一标识符对应的键（Key）名称，可通过这个键获取到创建对应数据（如任务、列表等）的用户的标识信息，用于权限管理、记录创建源头等用途。
+
+    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，子实体（child_entity）对应的键（Key）名称，可能在表示具有层级关系的数据结构中，用于标识某个实体的子级相关的内容，便于在处理JSON数据时操作和获取对应的子实体信息。
+
+    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，客户端版本（client_version）对应的键（Key）名称，可通过这个键获取到客户端使用的软件版本信息，用于版本兼容性判断、数据格式适配等相关逻辑处理。
+
+    public final static String GTASK_JSON_COMPLETED = "completed";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，完成状态（completed）对应的键（Key）名称，其对应的值可能用于表示某个任务、操作等是否已经完成，方便在业务逻辑中根据完成情况进行后续处理，比如展示已完成任务列表等。
+
+    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，当前列表（current_list）的唯一标识符对应的键（Key）名称，用于获取当前正在操作或显示的列表的标识信息，比如在任务列表切换等场景下确定当前所处的列表。
+
+    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，默认列表（default_list）的唯一标识符对应的键（Key）名称，可通过这个键获取到默认的列表标识，常用于在一些初始化、默认显示等场景下确定要展示的默认列表内容。
+
+    public final static String GTASK_JSON_DELETED = "deleted";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，删除状态（deleted）对应的键（Key）名称，其对应的值可用于判断某个数据（如任务、列表等）是否已经被删除，便于在数据处理和展示中过滤掉已删除的内容。
+
+    public final static String GTASK_JSON_DEST_LIST = "dest_list";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，目标列表（dest_list）对应的键（Key）名称，在涉及移动、复制等操作时，用于标识操作的目标列表位置，方便在业务逻辑中确定数据要移动或复制到的目标位置。
+
+    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，目标父级（dest_parent）对应的键（Key）名称，当处理具有层级关系的数据移动、关联等操作时，用于指定目标位置的父级相关信息，辅助确定准确的目标位置。
+
+    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，目标父级类型（dest_parent_type）对应的键（Key）名称，可通过这个键获取到目标父级的类型信息，比如是哪种类型的分组、列表等，有助于在复杂的数据结构操作中进行类型判断和相应的逻辑处理。
+
+    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，实体增量（entity_delta）对应的键（Key）名称，可能用于记录某个实体相对于之前状态的变化量、差异信息等，在数据更新、同步等场景下可依据此键来处理实体的变化情况。
+
+    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，实体类型（entity_type）对应的键（Key）名称，通过这个键获取到的值可以判断实体是任务、列表还是其他类型的数据，便于在代码中针对不同类型的实体执行相应的处理逻辑。
+
+    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，获取已删除数据（get_deleted）对应的键（Key）名称，可能用于在某些查询操作中明确要获取的是已经被删除的数据相关信息，便于数据恢复、历史记录查看等功能的实现。
+
+    public final static String GTASK_JSON_ID = "id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，通用的唯一标识符（id）对应的键（Key）名称，几乎所有的实体（如任务、列表、用户等）都可能有对应的唯一标识，通过这个键可以方便地获取和操作它们的标识信息，用于数据关联、查找等操作。
+
+    public final static String GTASK_JSON_INDEX = "index";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，索引（index）对应的键（Key）名称，可用于表示某个元素在列表、数组等结构中的位置顺序信息，在排序、查找特定位置元素等操作中会用到这个键对应的索引值。
+
+    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，最后修改时间（last_modified）对应的键（Key）名称，通过这个键获取到的值可以知道对应的数据（如任务、列表等）最后一次被修改的时间，常用于数据同步、版本控制等场景下判断数据的新旧程度。
+
+    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，最新同步点（latest_sync_point）对应的键（Key）名称，可能用于记录与服务器或者其他数据源进行数据同步时的最新时间点、版本等关键信息，便于后续进行增量同步等操作判断同步的起始位置。
+
+    public final static String GTASK_JSON_LIST_ID = "list_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，列表（list）的唯一标识符对应的键（Key）名称，用于获取和操作特定列表的标识信息，比如在任务与列表关联、切换列表显示等场景下使用这个键来确定相关的列表。
+
+    public final static String GTASK_JSON_LISTS = "lists";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，列表（lists，复数形式，可能表示多个列表的集合）对应的键（Key）名称，可通过这个键获取到包含多个列表信息的数据内容，常用于获取所有列表、展示列表集合等操作场景。
+
+    public final static String GTASK_JSON_NAME = "name";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，名称（name）对应的键（Key）名称，可用于获取各种实体（如任务、列表、用户等）的名称信息，方便在界面展示、数据筛选等操作中使用。
+
+    public final static String GTASK_JSON_NEW_ID = "new_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，新的唯一标识符（new_id）对应的键（Key）名称，可能在创建新的实体、复制实体等操作后，用于获取新生成的标识信息，便于后续对新实体进行关联、操作等处理。
+
+    public final static String GTASK_JSON_NOTES = "notes";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，备注（notes，复数形式，可能表示多条备注信息）对应的键（Key）名称，可通过这个键获取到与某个实体相关的备注内容，常用于添加、查看任务等相关的详细说明信息场景。
+
+    public final static String GTASK_JSON_PARENT_ID = "parent_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，父级（parent）的唯一标识符对应的键（Key）名称，用于获取某个实体所属的父级的标识信息，在处理层级结构的数据关系时，通过这个键可以明确父子层级关联，便于进行数据的查找、移动等操作。
+
+    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，前一个兄弟节点（prior_sibling）的唯一标识符对应的键（Key）名称，在处理具有顺序关系的同层级元素（如任务列表中的任务顺序）时，通过这个键可以获取到当前元素前一个兄弟元素的标识信息，有助于进行排序、插入等操作。
+
+    public final static String GTASK_JSON_RESULTS = "results";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，结果（results）对应的键（Key）名称，可能用于存放某个操作（如查询、执行任务等）完成后返回的结果数据集合，方便在业务逻辑中获取和处理操作得到的最终结果内容。
+
+    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
+    // 定义一个公共的、 static的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，源列表（source_list）对应的键（Key）名称，在涉及移动、复制等操作时，用于标识操作的起始列表位置，与dest_list相对应，明确数据的来源和去向。
+
+    public final static String GTASK_JSON_TASKS = "tasks";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，任务（tasks，复数形式，可能表示多个任务的集合）对应的键（Key）名称，可通过这个键获取到包含多个任务信息的数据内容，常用于展示任务列表、处理任务集合等操作场景。
+
+    public final static String GTASK_JSON_TYPE = "type";
+    // 定义一个公共的、静态的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，类型（type）对应的键（Key）名称，通过这个键获取到的值可以判断数据是何种类型，比如是任务类型还是列表类型等，便于在代码中针对不同类型的数据进行分类处理。
+
+    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
+    // 定义一个公共的、 static的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，组（GROUP）类型对应的具体值，当通过GTASK_JSON_TYPE这个键获取到的值为此常量时，可确定当前数据是组类型，方便在业务逻辑中对组相关的数据进行特定的处理操作。
+
+    public final static String GTASK_JSON_TYPE_TASK = "TASK";
+    // 定义一个公共的、 static的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，任务（TASK）类型对应的具体值，用于判断JSON数据中对应的实体是任务类型，进而执行相应的任务相关业务逻辑。
+
+    public final static String GTASK_JSON_USER = "user";
+    // 定义一个公共的、 static的、不可变（final）的字符串常量，用于表示在与GTask相关的JSON数据结构中，用户（user）对应的键（Key）名称，可通过这个键获取到与用户相关的信息，比如用户名、用户标识等，用于用户权限管理、关联用户操作等场景。
+
+    public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
+    // 定义一个公共的、 static的、不可变（final）的字符串常量，看起来是与MIUI系统下的笔记应用相关的文件夹前缀，可能用于标识特定的笔记文件夹，方便在文件系统或者数据存储中区分出属于该应用的相关文件夹内容。
+
+    public final static String FOLDER_DEFAULT = "Default";
+// 定义一个公共的、 static

src/ResourceParser.java

@@ -0,0 +1,226 @@
+/*
+ * 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.
+ */
+// 版权声明部分，表明该代码遵循Apache License 2.0开源协议，包含版权归属、授权相关等信息，说明了代码的使用规则和限制等情况。
+
+package net.micode.notes.tool;
+// 声明该类所在的包名，用于对代码进行组织和模块化管理，方便在项目中引用和区分不同功能模块的类，使代码结构更清晰。
+
+import android.content.Context;
+import android.preference.PreferenceManager;
+// 导入必要的Android系统类：
+// - Context用于获取应用程序的上下文环境，以便访问系统资源、服务等。
+// - PreferenceManager用于方便地管理应用程序的偏好设置（Shared Preferences），例如获取默认的偏好设置对象等操作。
+
+import net.micode.notes.R;
+import net.micode.notes.ui.NotesPreferenceActivity;
+// 导入应用内自定义的资源类R（用于访问项目中的各种资源，如图标、布局、样式等）以及与笔记偏好设置相关的Activity类，可能在获取特定偏好设置项等操作中会用到。
+
+public class ResourceParser {
+    // 定义一个名为ResourceParser的公共类，从类名推测它可能是用于解析各种资源相关信息的工具类，比如根据不同条件获取对应的资源ID等操作。
+
+    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;
+    // 定义一系列公共的、静态的、不可变（final）的整型常量，用于表示不同的颜色选项，通过整数索引的方式来区分不同颜色，方便在代码中统一引用和进行逻辑判断，这里以数字顺序分别对应不同颜色，具体含义可能与笔记应用中的背景颜色等相关设置有关。
+
+    public static final int BG_DEFAULT_COLOR = YELLOW;
+    // 定义一个公共的、静态的、不可变（final）的整型常量，用于表示默认的背景颜色，其值被设置为之前定义的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;
+    // 定义一系列公共的、静态的、不可变（final）的整型常量，用于表示不同的文本字号大小选项，同样以整数索引形式来区分不同字号，便于在代码中进行相关文本字号设置等逻辑处理。
+
+    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
+    // 定义一个公共的、静态的、不可变（final）的整型常量，用于表示默认的字体大小，其值被设置为之前定义的TEXT_MEDIUM，即默认情况下文本字号可能采用中等大小，在没有其他针对字体大小的特殊设置时以此为默认值。
+
+    public static class NoteBgResources {
+        // 定义一个内部静态类NoteBgResources，从类名可以推测它主要用于处理笔记相关的背景资源相关操作，比如获取不同情况下的背景图片资源ID等。
+
+        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
+        };
+        // 定义一个私有静态的整型数组，用于存储笔记编辑界面背景相关的资源ID，数组中的每个元素对应一种颜色（与前面定义的颜色常量顺序相关）的编辑界面背景图片资源，通过索引可以获取到相应颜色的背景图片资源ID，方便后续在需要设置编辑界面背景时使用。
+
+        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
+        };
+        // 定义一个私有静态的整型数组，用于存储笔记编辑界面标题背景相关的资源ID，同样按照颜色顺序排列，每个元素对应一种颜色的编辑界面标题背景图片资源，便于在设置标题背景时通过索引获取相应资源ID。
+
+        public static int getNoteBgResource(int id) {
+            return BG_EDIT_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引（对应前面定义的颜色索引）获取笔记编辑界面背景图片资源ID，通过直接返回BG_EDIT_RESOURCES数组中对应索引位置的元素来实现，方便外部代码获取指定颜色的编辑界面背景资源。
+
+        public static int getNoteTitleBgResource(int id) {
+            return BG_EDIT_TITLE_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引获取笔记编辑界面标题背景图片资源ID，原理与getNoteBgResource方法类似，只是从BG_EDIT_TITLE_RESOURCES数组中获取相应元素，用于获取指定颜色的编辑界面标题背景资源。
+    }
+
+    public static int getDefaultBgId(Context context) {
+        // 定义一个公共静态方法，用于获取默认的背景图片资源ID，该方法接收一个Context对象作为参数，以便访问应用的偏好设置等信息来确定默认背景。
+        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
+                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
+            // 通过PreferenceManager获取默认的偏好设置对象，并根据一个名为NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY的键（应该在NotesPreferenceActivity类中定义，用于标识是否设置了自定义背景颜色的偏好设置项）获取对应的布尔值。
+            // 如果该布尔值为true，表示用户已经设置了自定义的背景颜色，执行以下逻辑：
+            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
+            // 通过生成一个随机数（范围是0到NoteBgResources.BG_EDIT_RESOURCES数组长度减1之间）作为索引，从NoteBgResources.BG_EDIT_RESOURCES数组中随机获取一个背景图片资源ID，实现随机选择一种颜色的背景图片作为默认背景（在用户已设置自定义背景颜色的情况下）。
+        } else {
+            // 如果获取到的布尔值为false，表示用户没有设置自定义背景颜色，执行以下逻辑：
+            return BG_DEFAULT_COLOR;
+            // 直接返回之前定义的默认背景颜色常量BG_DEFAULT_COLOR（即黄色对应的索引值），表示采用默认的背景颜色设置。
+        }
+    }
+
+    public static class NoteItemBgResources {
+        // 定义一个内部静态类NoteItemBgResources，推测它主要用于处理笔记列表项相关的背景资源操作，比如获取不同位置、不同状态下笔记列表项的背景图片资源ID等。
+
+        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
+        };
+        // 定义一个私有静态的整型数组，用于存储笔记列表项处于首位时不同颜色对应的背景图片资源ID，每个元素对应一种颜色的首位列表项背景图片资源，方便在列表项首位显示时获取相应的背景资源。
+
+        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
+        };
+        // 定义一个私有静态的整型数组，用于存储笔记列表项处于中间位置时不同颜色对应的背景图片资源ID，每个元素对应一种颜色的中间位置列表项背景图片资源，用于列表项非首位和末位时的背景显示资源获取。
+
+        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,
+        };
+        // 定义一个私有静态的整型数组，用于存储笔记列表项处于末位时不同颜色对应的背景图片资源ID，每个元素对应一种颜色的末位列表项背景图片资源，便于在列表项末尾显示时获取相应的背景资源。
+
+        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
+        };
+        // 定义一个私有静态的整型数组，用于存储当笔记列表项单独显示（可能没有前后相邻项的情况）时不同颜色对应的背景图片资源ID，每个元素对应一种颜色的单独显示列表项背景图片资源，用于特殊显示场景下的背景资源获取。
+
+        public static int getNoteBgFirstRes(int id) {
+            return BG_FIRST_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引（对应颜色索引）获取笔记列表项处于首位时的背景图片资源ID，通过返回BG_FIRST_RESOURCES数组中对应索引位置的元素来实现，方便外部代码在需要设置首位列表项背景时使用。
+
+        public static int getNoteBgLastRes(int id) {
+            return BG_LAST_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引获取笔记列表项处于末位时的背景图片资源ID，原理与获取首位背景资源ID类似，从BG_LAST_RESOURCES数组中获取对应元素，用于设置末位列表项背景。
+
+        public static int getNoteBgSingleRes(int id) {
+            return BG_SINGLE_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引获取笔记列表项单独显示时的背景图片资源ID，从BG_SINGLE_RESOURCES数组中获取对应元素，用于单独显示列表项的背景设置。
+
+        public static int getNoteBgNormalRes(int id) {
+            return BG_NORMAL_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引获取笔记列表项处于中间位置时的背景图片资源ID，从BG_NORMAL_RESOURCES数组中获取对应元素，用于设置中间位置列表项的背景。
+
+        public static int getFolderBgRes() {
+            return R.drawable.list_folder;
+        }
+        // 定义一个公共静态方法，用于获取文件夹相关的背景图片资源ID，直接返回固定的R.drawable.list_folder这个资源ID，用于在显示文件夹相关界面时设置背景图片资源。
+    }
+
+    public static class WidgetBgResources {
+        // 定义一个内部静态类WidgetBgResources，推测它主要用于处理与应用小部件（Widget）相关的背景资源操作，比如获取不同尺寸小部件的背景图片资源ID等。
+
+        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,
+        };
+        // 定义一个私有静态的整型数组，用于存储2倍尺寸小部件不同颜色对应的背景图片资源ID，每个元素对应一种颜色的2倍尺寸小部件背景图片资源，方便在创建或显示2倍尺寸小部件时获取相应的背景资源。
+
+        public static int getWidget2xBgResource(int id) {
+            return BG_2X_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引（对应颜色索引）获取2倍尺寸小部件的背景图片资源ID，通过返回BG_2X_RESOURCES数组中对应索引位置的元素来实现，便于外部代码设置2倍尺寸小部件的背景。
+
+        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
+        };
+        // 定义一个私有静态的整型数组，用于存储4倍尺寸小部件不同颜色对应的背景图片资源ID，每个元素对应一种颜色的4倍尺寸小部件背景图片资源，用于4倍尺寸小部件的背景资源获取。
+
+        public static int getWidget4xBgResource(int id) {
+            return BG_4X_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引获取4倍尺寸小部件的背景图片资源ID，从BG_4X_RESOURCES数组中获取对应元素，用于设置4倍尺寸小部件的背景。
+    }
+
+    public static class TextAppearanceResources {
+        // 定义一个内部静态类TextAppearanceResources，推测它主要用于处理文本外观相关的资源操作，比如获取不同字号对应的文本样式资源ID等。
+
+        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
+                R.style.TextAppearanceNormal,
+                R.style.TextAppearanceMedium,
+                R.style.TextAppearanceLarge,
+                R.style.TextAppearanceSuper
+        };
+        // 定义一个私有静态的整型数组，用于存储不同字号对应的文本外观样式资源ID，每个元素对应一种字号大小的文本样式资源，方便在设置文本外观时通过索引获取相应的样式资源ID。
+
+        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}
+             */
+            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
+                return BG_DEFAULT_FONT_SIZE;
+            }
+            return TEXTAPPEARANCE_RESOURCES[id];
+        }
+        // 定义一个公共静态方法，用于根据传入的整数索引获取文本外观样式资源ID，首先会判断传入的索引是否大于TEXTAPPEARANCE_RESOURCES数组的长度（可能是为了防止因存储的资源ID有误或者超出范围等情况导致的问题），如果超出范围，则返回之前定义的默认字体大小对应的资源ID（BG_DEFAULT_FONT_SIZE），否则返回TEXTAPPEARANCE_RESOURCES数组中对应索引位置的元素，即正常获取相应字号对应的文本样式资源ID。
+
+        public static int getResourcesSize() {
+            return TEXTAPPEARANCE_RESOURCES.length;
+        }
+        // 定义一个公共静态方法，用于获取TEXTAPPEARANCE_RESOURCES数组的长度，也就是文本外观样式资源的数量，方便外部代码了解有多少种可用的文本外观样式资源。
+    }
+}