BackupUtils注释

java/net/micode/notes/tool/BackupUtils.java

@@ -35,12 +35,13 @@ 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;
 
+    // 获取单例实例的方法
     public static synchronized BackupUtils getInstance(Context context) {
         if (sInstance == null) {
             sInstance = new BackupUtils(context);
@@ -48,44 +49,44 @@ public class BackupUtils {
         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;
-    // 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;
 
+    // 构造函数
     private BackupUtils(Context context) {
         mTextExport = new TextExport(context);
     }
 
+    // 检查外部存储是否可用的方法
     private static boolean externalStorageAvailable() {
         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
     }
 
+    // 导出笔记数据为文本的方法
     public int exportToText() {
         return mTextExport.exportToText();
     }
 
+    // 获取导出的文本文件名的方法
     public String getExportedTextFileName() {
         return mTextExport.mFileName;
     }
 
+    // 获取导出的文本文件目录的方法
     public String getExportedTextFileDir() {
         return mTextExport.mFileDirectory;
     }
 
+    // 内部类，用于实现文本导出功能
     private static class TextExport {
+        // 笔记查询的投影列
         private static final String[] NOTE_PROJECTION = {
                 NoteColumns.ID,
                 NoteColumns.MODIFIED_DATE,
@@ -93,12 +94,16 @@ 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,39 +113,51 @@ 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 static final int FORMAT_NOTE_DATE            = 1;
+        // 笔记内容格式的索引
         private static final int FORMAT_NOTE_CONTENT         = 2;
 
+        // 上下文对象
         private Context mContext;
+        // 导出的文件名
         private String mFileName;
+        // 导出的文件目录
         private String mFileDirectory;
 
+        // 构造函数
         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
-         */
         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[] {
                         folderId
@@ -149,23 +166,23 @@ public class BackupUtils {
             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
+                        // 查询属于该笔记的数据
                         String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                         exportNoteToText(noteId, ps);
                     } while (notesCursor.moveToNext());
                 }
+                // 关闭游标
                 notesCursor.close();
             }
         }
 
-        /**
+        // 将指定笔记导出为文本的方法
-         * Export note identified by id to a print stream
-         */
         private void exportNoteToText(String noteId, PrintStream ps) {
+            // 查询属于该笔记的数据
             Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
                     DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
                         noteId
@@ -174,9 +191,10 @@ public class BackupUtils {
             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);
@@ -185,16 +203,17 @@ public class BackupUtils {
                                 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),
@@ -203,33 +222,35 @@ public class BackupUtils {
                         }
                     } while (dataCursor.moveToNext());
                 }
+                // 关闭游标
                 dataCursor.close();
             }
-            // print a line separator between note
+            // 打印笔记之间的分隔线
             try {
                 ps.write(new byte[] {
                         Character.LINE_SEPARATOR, Character.LETTER_NUMBER
                 });
             } catch (IOException e) {
+                // 处理 IO 异常
                 Log.e(TAG, e.toString());
             }
         }
 
-        /**
+        // 导出所有笔记数据为文本的方法
-         * Note will be exported as text which is user readable
-         */
         public int exportToText() {
+            // 检查外部存储是否可用
             if (!externalStorageAvailable()) {
                 Log.d(TAG, "Media was not mounted");
                 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,7 +261,7 @@ 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) {
                             folderName = mContext.getString(R.string.call_record_folder_name);
@@ -250,14 +271,17 @@ public class BackupUtils {
                         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,
@@ -267,41 +291,50 @@ public class BackupUtils {
             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);
+                        // 导出笔记数据
                         exportNoteToText(noteId, ps);
                     } while (noteCursor.moveToNext());
                 }
+                // 关闭游标
                 noteCursor.close();
             }
+            // 关闭打印流
             ps.close();
 
             return STATE_SUCCESS;
         }
 
-        /**
+        // 获取导出文本的打印流的方法
-         * Get a print stream pointed to the file {@generateExportedTextFile}
-         */
         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) {
+                // 处理文件未找到异常
                 e.printStackTrace();
                 return null;
             } catch (NullPointerException e) {
+                // 处理空指针异常
                 e.printStackTrace();
                 return null;
             }
@@ -309,10 +342,9 @@ public class BackupUtils {
         }
     }
 
-    /**
+    // 生成存储导入数据的文本文件的方法
-     * Generate the text file to store imported data
-     */
     private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+        // 构建文件路径
         StringBuilder sb = new StringBuilder();
         sb.append(Environment.getExternalStorageDirectory());
         sb.append(context.getString(filePathResId));
@@ -324,21 +356,23 @@ public class BackupUtils {
         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;
     }
-}
+}
-
-