NoteWidgetProvider.java

NoteWidgetProvider_2x.java
NoteWidgetProvider_2x.java
NoteWidgetProvider_4x.java
BackupUtils.java
GTaskStringUtils.java

Signed-off-by: JUNNE_TOPIC1 <1763461387@qq.com>

src/tool/BackupUtils.java

@@ -35,13 +35,16 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.PrintStream;
 
-
+// 该类用于实现笔记的备份功能，将笔记数据导出为文本文件
 public class BackupUtils {
+    // 日志标签，用于在日志中标识该类的相关信息
     private static final String TAG = "BackupUtils";
-    // Singleton stuff
+    // 单例模式的实例对象
     private static BackupUtils sInstance;
 
+    // 获取 BackupUtils 的单例实例
     public static synchronized BackupUtils getInstance(Context context) {
+        // 如果实例还未创建，则创建一个新的实例
         if (sInstance == null) {
             sInstance = new BackupUtils(context);
         }
@@ -49,43 +52,55 @@ public class BackupUtils {
     }
 
     /**
-     * Following states are signs to represents backup or restore
+     * 以下状态用于表示备份或恢复操作的状态
-     * status
      */
-    // Currently, the sdcard is not mounted
+    // 当前 SD 卡未挂载
-    public static final int STATE_SD_CARD_UNMOUONTED           = 0;
+    public static final int STATE_SD_CARD_UNMOUONTED = 0;
-    // The backup file not exist
+    // 备份文件不存在
-    public static final int STATE_BACKUP_FILE_NOT_EXIST        = 1;
+    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;
+    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;
+    public static final int STATE_SYSTEM_ERROR = 3;
-    // Backup or restore success
+    // 备份或恢复成功
-    public static final int STATE_SUCCESS                      = 4;
+    public static final int STATE_SUCCESS = 4;
-
+
+    // 文本导出工具类的实例
     private TextExport mTextExport;
 
+    // 私有构造函数，确保只能通过 getInstance 方法获取实例
     private BackupUtils(Context context) {
+        // 初始化 TextExport 实例
         mTextExport = new TextExport(context);
     }
 
+    // 检查外部存储是否可用
     private static boolean externalStorageAvailable() {
+        // 检查外部存储的状态是否为已挂载
         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
     }
 
+    // 将笔记数据导出为文本文件
     public int exportToText() {
+        // 调用 TextExport 类的 exportToText 方法进行导出操作
         return mTextExport.exportToText();
     }
 
+    // 获取导出的文本文件的文件名
     public String getExportedTextFileName() {
+        // 返回 TextExport 类中保存的文件名
         return mTextExport.mFileName;
     }
 
+    // 获取导出的文本文件的目录
     public String getExportedTextFileDir() {
+        // 返回 TextExport 类中保存的文件目录
         return mTextExport.mFileDirectory;
     }
 
+    // 内部类，用于实现将笔记数据导出为文本文件的具体逻辑
     private static class TextExport {
+        // 查询笔记信息时使用的投影，指定要查询的列
         private static final String[] NOTE_PROJECTION = {
                 NoteColumns.ID,
                 NoteColumns.MODIFIED_DATE,
@@ -93,12 +108,14 @@ public class BackupUtils {
                 NoteColumns.TYPE
         };
 
+        // 笔记 ID 在投影数组中的索引
         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,
@@ -108,128 +125,169 @@ public class BackupUtils {
                 DataColumns.DATA4,
         };
 
+        // 笔记数据内容在投影数组中的索引
         private static final int DATA_COLUMN_CONTENT = 0;
-
+        // 笔记数据 MIME 类型在投影数组中的索引
         private static final int DATA_COLUMN_MIME_TYPE = 1;
-
+        // 通话记录日期在投影数组中的索引
         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 final String[] TEXT_FORMAT;
-        private static final int FORMAT_NOTE_DATE            = 1;
+        // 文件夹名称的格式索引
-        private static final int FORMAT_NOTE_CONTENT         = 2;
+        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 = "";
         }
 
+        // 根据索引获取文本格式字符串
         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
+            // 查询属于该文件夹的笔记信息
             Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
-                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
+                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[]{
-                        folderId
+                            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
                         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) {
+            // 查询属于该笔记的数据信息
             Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
-                    DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
+                    DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[]{
-                        noteId
+                            noteId
                     }, null);
 
             if (dataCursor != null) {
                 if (dataCursor.moveToFirst()) {
                     do {
+                        // 获取数据的 MIME 类型
                         String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
                         if (DataConstants.CALL_NOTE.equals(mimeType)) {
-                            // Print phone number
+                            // 如果是通话记录笔记
+                            // 获取电话号码
                             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();
             }
-            // print a line separator between note
+            // 在笔记之间打印一个换行符
             try {
-                ps.write(new byte[] {
+                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
+         * 将笔记数据导出为用户可读的文本文件
+         *
+         * @return 导出操作的状态码，可能的值为 STATE_SD_CARD_UNMOUONTED、STATE_SYSTEM_ERROR 或 STATE_SUCCESS
          */
         public int exportToText() {
+            // 检查外部存储是否可用
             if (!externalStorageAvailable()) {
+                // 记录日志信息
                 Log.d(TAG, "Media was not mounted");
+                // 返回 SD 卡未挂载的状态码
                 return STATE_SD_CARD_UNMOUONTED;
             }
 
+            // 获取用于导出文本的打印流
             PrintStream ps = getExportToTextPrintStream();
             if (ps == null) {
+                // 记录日志信息
                 Log.e(TAG, "get print stream error");
+                // 返回系统错误的状态码
                 return STATE_SYSTEM_ERROR;
             }
-            // First export folder and its notes
+            // 首先导出文件夹及其包含的笔记
             Cursor folderCursor = mContext.getContentResolver().query(
                     Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION,
@@ -240,105 +298,144 @@ public class BackupUtils {
             if (folderCursor != null) {
                 if (folderCursor.moveToFirst()) {
                     do {
-                        // Print folder's name
+                        // 获取文件夹名称
                         String folderName = "";
-                        if(folderCursor.getLong(NOTE_COLUMN_ID) == Notes.ID_CALL_RECORD_FOLDER) {
+                        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(folderId, ps);
                     } while (folderCursor.moveToNext());
                 }
+                // 关闭游标，释放资源
                 folderCursor.close();
             }
 
-            // Export notes in root's folder
+            // 导出根文件夹下的笔记
             Cursor noteCursor = mContext.getContentResolver().query(
                     Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION,
-                    NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID
+                    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))));
-                        // Query data belong to this note
+                        // 获取笔记的 ID
                         String noteId = noteCursor.getString(NOTE_COLUMN_ID);
+                        // 将该笔记导出为文本
                         exportNoteToText(noteId, ps);
                     } while (noteCursor.moveToNext());
                 }
+                // 关闭游标，释放资源
                 noteCursor.close();
             }
+            // 关闭打印流
             ps.close();
 
+            // 返回导出成功的状态码
             return STATE_SUCCESS;
         }
 
         /**
-         * Get a print stream pointed to the file {@generateExportedTextFile}
+         * 获取一个指向导出文本文件的打印流
+         *
+         * @return 打印流对象，如果创建文件或获取流失败，则返回 null
          */
         private PrintStream getExportToTextPrintStream() {
+            // 生成一个存储在 SD 卡上的文件
             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");
+                // 返回 null 表示创建文件失败
                 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) {
+                // 打印异常堆栈信息
                 e.printStackTrace();
+                // 返回 null 表示文件未找到
                 return null;
             } catch (NullPointerException e) {
+                // 打印异常堆栈信息
                 e.printStackTrace();
+                // 返回 null 表示空指针异常
                 return null;
             }
+            // 返回打印流对象
             return ps;
         }
     }
 
     /**
-     * Generate the text file to store imported data
+     * 生成一个存储在 SD 卡上的文本文件，用于存储导出的数据
+     *
+     * @param context          上下文对象，用于获取资源和执行相关操作
+     * @param filePathResId    文件路径的资源 ID
+     * @param fileNameFormatResId 文件名格式的资源 ID
+     * @return 生成的文件对象，如果创建文件失败，则返回 null
      */
     private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+        // 创建一个 StringBuilder 对象，用于构建文件路径
         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) {
+            // 打印输入输出异常信息
             e.printStackTrace();
         }
-
+        // 如果出现异常，返回 null
         return null;
     }
-}
+}
-
-

src/tool/GTaskStringUtils.java

@@ -16,98 +16,147 @@
 
 package net.micode.notes.tool;
 
+/**
+ * 该类包含了与 Google 任务（GTask）相关的 JSON 字符串常量，
+ * 用于在处理 GTask 数据交互时作为键名使用，同时也定义了一些特定文件夹名称和元数据相关的常量。
+ */
 public class GTaskStringUtils {
 
+    // 表示动作 ID 的 JSON 键名
     public final static String GTASK_JSON_ACTION_ID = "action_id";
 
+    // 表示动作列表的 JSON 键名
     public final static String GTASK_JSON_ACTION_LIST = "action_list";
 
+    // 表示动作类型的 JSON 键名
     public final static String GTASK_JSON_ACTION_TYPE = "action_type";
 
+    // 表示创建动作类型的 JSON 值
     public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
 
+    // 表示获取所有数据动作类型的 JSON 值
     public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
 
+    // 表示移动动作类型的 JSON 值
     public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
 
+    // 表示更新动作类型的 JSON 值
     public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
 
+    // 表示创建者 ID 的 JSON 键名
     public final static String GTASK_JSON_CREATOR_ID = "creator_id";
 
+    // 表示子实体的 JSON 键名
     public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
 
+    // 表示客户端版本的 JSON 键名
     public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
 
+    // 表示任务是否完成的 JSON 键名
     public final static String GTASK_JSON_COMPLETED = "completed";
 
+    // 表示当前列表 ID 的 JSON 键名
     public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
 
+    // 表示默认列表 ID 的 JSON 键名
     public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
 
+    // 表示是否删除的 JSON 键名
     public final static String GTASK_JSON_DELETED = "deleted";
 
+    // 表示目标列表的 JSON 键名
     public final static String GTASK_JSON_DEST_LIST = "dest_list";
 
+    // 表示目标父实体的 JSON 键名
     public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
 
+    // 表示目标父实体类型的 JSON 键名
     public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
 
+    // 表示实体增量的 JSON 键名
     public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
 
+    // 表示实体类型的 JSON 键名
     public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
 
+    // 表示获取已删除数据的 JSON 键名
     public final static String GTASK_JSON_GET_DELETED = "get_deleted";
 
+    // 表示 ID 的 JSON 键名
     public final static String GTASK_JSON_ID = "id";
 
+    // 表示索引的 JSON 键名
     public final static String GTASK_JSON_INDEX = "index";
 
+    // 表示最后修改时间的 JSON 键名
     public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
 
+    // 表示最新同步点的 JSON 键名
     public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
 
+    // 表示列表 ID 的 JSON 键名
     public final static String GTASK_JSON_LIST_ID = "list_id";
 
+    // 表示列表集合的 JSON 键名
     public final static String GTASK_JSON_LISTS = "lists";
 
+    // 表示名称的 JSON 键名
     public final static String GTASK_JSON_NAME = "name";
 
+    // 表示新 ID 的 JSON 键名
     public final static String GTASK_JSON_NEW_ID = "new_id";
 
+    // 表示备注的 JSON 键名
     public final static String GTASK_JSON_NOTES = "notes";
 
+    // 表示父实体 ID 的 JSON 键名
     public final static String GTASK_JSON_PARENT_ID = "parent_id";
 
+    // 表示前一个兄弟实体 ID 的 JSON 键名
     public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
 
+    // 表示结果的 JSON 键名
     public final static String GTASK_JSON_RESULTS = "results";
 
+    // 表示源列表的 JSON 键名
     public final static String GTASK_JSON_SOURCE_LIST = "source_list";
 
+    // 表示任务集合的 JSON 键名
     public final static String GTASK_JSON_TASKS = "tasks";
 
+    // 表示类型的 JSON 键名
     public final static String GTASK_JSON_TYPE = "type";
 
+    // 表示组类型的 JSON 值
     public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
 
+    // 表示任务类型的 JSON 值
     public final static String GTASK_JSON_TYPE_TASK = "TASK";
 
+    // 表示用户的 JSON 键名
     public final static String GTASK_JSON_USER = "user";
 
+    // MIUI 笔记文件夹前缀
     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";
 
+    // 元数据头部 Google 任务 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";
-
+}
-}