Update BackupUtils.java

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

@@ -18,6 +18,7 @@ package net.micode.notes.tool;
 
 import android.content.Context;
 import android.database.Cursor;
+import android.os.Build;
 import android.os.Environment;
 import android.text.TextUtils;
 import android.text.format.DateFormat;
@@ -29,12 +30,14 @@ import net.micode.notes.data.Notes.DataColumns;
 import net.micode.notes.data.Notes.DataConstants;
 import net.micode.notes.data.Notes.NoteColumns;
 
+import java.io.BufferedWriter;
 import java.io.File;
-import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.PrintStream;
+import java.io.OutputStreamWriter;
-
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
 
 public class BackupUtils {
     private static final String TAG = "BackupUtils";
@@ -62,6 +65,8 @@ public class BackupUtils {
     public static final int STATE_SYSTEM_ERROR                 = 3;
     // Backup or restore success
     public static final int STATE_SUCCESS                      = 4;
+    // Permission denied
+    public static final int STATE_PERMISSION_DENIED            = 5;
 
     private TextExport mTextExport;
 
@@ -90,14 +95,15 @@ public class BackupUtils {
                 NoteColumns.ID,
                 NoteColumns.MODIFIED_DATE,
                 NoteColumns.SNIPPET,
-                NoteColumns.TYPE
+                NoteColumns.TYPE,
+                NoteColumns.PARENT_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 int NOTE_COLUMN_TYPE = 3;
+        private static final int NOTE_COLUMN_PARENT_ID = 4;
 
         private static final String[] DATA_PROJECTION = {
                 DataColumns.CONTENT,
@@ -109,11 +115,8 @@ public class BackupUtils {
         };
 
         private static final int DATA_COLUMN_CONTENT = 0;
-
         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;
@@ -124,12 +127,17 @@ public class BackupUtils {
         private Context mContext;
         private String mFileName;
         private String mFileDirectory;
+        private BufferedWriter mWriter;
+        private int mNotesCount;
+        private int mFoldersCount;
 
         public TextExport(Context context) {
             TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
             mContext = context;
             mFileName = "";
             mFileDirectory = "";
+            mNotesCount = 0;
+            mFoldersCount = 0;
         }
 
         private String getFormat(int id) {
@@ -137,175 +145,223 @@ public class BackupUtils {
         }
 
         /**
-         * Export the folder identified by folder id to text
+         * Export notes to text file
          */
-        private void exportFolderToText(String folderId, PrintStream ps) {
+        public int exportToText() {
-            // Query notes belong to this folder
+            if (!externalStorageAvailable()) {
-            Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                Log.d(TAG, "Media was not mounted");
-                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
+                return STATE_SD_CARD_UNMOUONTED;
-                        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
-                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
-                        exportNoteToText(noteId, ps);
-                    } while (notesCursor.moveToNext());
-                }
-                notesCursor.close();
             }
+
+            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 STATE_SYSTEM_ERROR;
             }
             
-        /**
+            mFileName = file.getName();
-         * Export note identified by id to a print stream
+            mFileDirectory = mContext.getString(R.string.file_path);
-         */
-        private void exportNoteToText(String noteId, PrintStream ps) {
-            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 {
-                        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)) {
+            // 使用try-with-resources确保资源释放
-                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
+            try (BufferedWriter writer = new BufferedWriter(
-                                        phoneNumber));
+                    new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8))) {
-                            }
+                mWriter = writer;
-                            // Print call date
+                
-                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
+                // 导出文件夹和笔记
-                                    .format(mContext.getString(R.string.format_datetime_mdhm),
+                exportFoldersAndNotes();
-                                            callDate)));
+                
-                            // Print call attachment location
+                // 写入导出统计信息
-                            if (!TextUtils.isEmpty(location)) {
+                writeExportSummary();
-                                ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
+                
-                                        location));
+                Log.d(TAG, "Export successful. Exported " + mFoldersCount + " folders and " + mNotesCount + " notes.");
-                            }
+                return STATE_SUCCESS;
-                        } 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[] {
-                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
-                });
             } catch (IOException e) {
-                Log.e(TAG, e.toString());
+                Log.e(TAG, "Error during export: " + e.getMessage(), e);
+                return STATE_SYSTEM_ERROR;
             }
         }
         
         /**
-         * Note will be exported as text which is user readable
+         * 写入导出摘要信息
          */
-        public int exportToText() {
+        private void writeExportSummary() throws IOException {
-            if (!externalStorageAvailable()) {
+            mWriter.write("\n");
-                Log.d(TAG, "Media was not mounted");
+            mWriter.write("==============================\n");
-                return STATE_SD_CARD_UNMOUONTED;
+            mWriter.write(mContext.getString(R.string.export_summary) + "\n");
+            mWriter.write(mContext.getString(R.string.export_date) + ": " 
+                    + DateFormat.format(mContext.getString(R.string.format_datetime_ymdhm), System.currentTimeMillis()) + "\n");
+            mWriter.write(mContext.getString(R.string.folder_count) + ": " + mFoldersCount + "\n");
+            mWriter.write(mContext.getString(R.string.note_count) + ": " + mNotesCount + "\n");
+            mWriter.write("==============================\n");
         }
         
-            PrintStream ps = getExportToTextPrintStream();
+        /**
-            if (ps == null) {
+         * 导出所有文件夹和笔记
-                Log.e(TAG, "get print stream error");
+         */
-                return STATE_SYSTEM_ERROR;
+        private void exportFoldersAndNotes() throws IOException {
+            // 首先导出文件夹和其中的笔记
+            exportFolders();
+            
+            // 导出根文件夹中的笔记
+            exportRootNotes();
         }
-            // First export folder and its notes
+        
-            Cursor folderCursor = mContext.getContentResolver().query(
+        /**
+         * 导出所有文件夹
+         */
+        private void exportFolders() throws IOException {
+            // 查询所有文件夹
+            String selection = "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+                    + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+                    + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER;
+            
+            try (Cursor folderCursor = mContext.getContentResolver().query(
                     Notes.CONTENT_NOTE_URI,
                     NOTE_PROJECTION,
-                    "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+                    selection, null, null)) {
-                            + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
-                            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
                 
-            if (folderCursor != null) {
+                if (folderCursor != null && folderCursor.moveToFirst()) {
-                if (folderCursor.moveToFirst()) {
                     do {
-                        // Print folder's name
+                        mFoldersCount++;
-                        String folderName = "";
+                        exportFolder(folderCursor);
+                    } while (folderCursor.moveToNext());
+                }
+            }
+        }
+        
+        /**
+         * 导出单个文件夹及其包含的笔记
+         */
+        private void exportFolder(Cursor folderCursor) throws IOException {
+            String folderId = folderCursor.getString(NOTE_COLUMN_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));
+                mWriter.write(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
+                mWriter.newLine();
+            }
+            
+            // 导出文件夹中的笔记
+            exportNotesInFolder(folderId);
+            
+            // 添加文件夹分隔线
+            mWriter.write("\n");
+        }
+        
+        /**
+         * 导出指定文件夹中的所有笔记
+         */
+        private void exportNotesInFolder(String folderId) throws IOException {
+            try (Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+                    NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] { folderId }, null)) {
+                
+                if (notesCursor != null && notesCursor.moveToFirst()) {
+                    do {
+                        mNotesCount++;
+                        exportNote(notesCursor);
+                    } while (notesCursor.moveToNext());
                 }
-                        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(
+         * 导出根文件夹中的笔记
+         */
+        private void exportRootNotes() throws IOException {
+            try (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", 
-                            + "=0", null, null);
+                    null, null)) {
                 
-            if (noteCursor != null) {
+                if (noteCursor != null && noteCursor.moveToFirst()) {
-                if (noteCursor.moveToFirst()) {
                     do {
-                        ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
+                        mNotesCount++;
-                                mContext.getString(R.string.format_datetime_mdhm),
+                        exportNote(noteCursor);
-                                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;
+        /**
+         * 导出单个笔记
+         */
+        private void exportNote(Cursor noteCursor) throws IOException {
+            // 打印笔记的最后修改日期
+            mWriter.write(String.format(getFormat(FORMAT_NOTE_DATE), 
+                    DateFormat.format(mContext.getString(R.string.format_datetime_mdhm),
+                            noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
+            mWriter.newLine();
+            
+            // 查询并导出笔记的数据
+            String noteId = noteCursor.getString(NOTE_COLUMN_ID);
+            exportNoteData(noteId);
+            
+            // 添加笔记分隔线
+            mWriter.write("\n");
         }
         
         /**
-         * Get a print stream pointed to the file {@generateExportedTextFile}
+         * 导出笔记的所有数据
          */
-        private PrintStream getExportToTextPrintStream() {
+        private void exportNoteData(String noteId) throws IOException {
-            File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
+            try (Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
-                    R.string.file_name_txt_format);
+                    DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] { noteId }, null)) {
-            if (file == null) {
+                
-                Log.e(TAG, "create file to exported failed");
+                if (dataCursor != null && dataCursor.moveToFirst()) {
-                return null;
+                    do {
+                        String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
+                        if (DataConstants.CALL_NOTE.equals(mimeType)) {
+                            exportCallNote(dataCursor);
+                        } else if (DataConstants.NOTE.equals(mimeType)) {
+                            exportTextNote(dataCursor);
                         }
-            mFileName = file.getName();
+                    } while (dataCursor.moveToNext());
-            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;
                 }
-            return ps;
+            }
+        }
+        
+        /**
+         * 导出通话记录笔记
+         */
+        private void exportCallNote(Cursor dataCursor) throws IOException {
+            // 打印电话号码
+            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)) {
+                mWriter.write(String.format(getFormat(FORMAT_NOTE_CONTENT), phoneNumber));
+                mWriter.newLine();
+            }
+            
+            // 打印通话日期
+            mWriter.write(String.format(getFormat(FORMAT_NOTE_CONTENT), 
+                    DateFormat.format(mContext.getString(R.string.format_datetime_mdhm), callDate)));
+            mWriter.newLine();
+            
+            // 打印通话附件位置
+            if (!TextUtils.isEmpty(location)) {
+                mWriter.write(String.format(getFormat(FORMAT_NOTE_CONTENT), location));
+                mWriter.newLine();
+            }
+        }
+        
+        /**
+         * 导出文本笔记
+         */
+        private void exportTextNote(Cursor dataCursor) throws IOException {
+            String content = dataCursor.getString(DATA_COLUMN_CONTENT);
+            if (!TextUtils.isEmpty(content)) {
+                mWriter.write(String.format(getFormat(FORMAT_NOTE_CONTENT), content));
+                mWriter.newLine();
             }
         }
 
@@ -314,9 +370,24 @@ public class BackupUtils {
          */
         private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
             StringBuilder sb = new StringBuilder();
+            
+            // 适配Android 10+的存储访问
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                sb.append(context.getExternalFilesDir(null));
+            } else {
                 sb.append(Environment.getExternalStorageDirectory());
+            }
+            
             sb.append(context.getString(filePathResId));
             File filedir = new File(sb.toString());
+            
+            // 确保目录存在
+            if (!filedir.exists() && !filedir.mkdirs()) {
+                Log.e(TAG, "Failed to create directory: " + filedir.getAbsolutePath());
+                return null;
+            }
+            
+            // 构建文件名
             sb.append(context.getString(
                     fileNameFormatResId,
                     DateFormat.format(context.getString(R.string.format_date_ymd),
@@ -324,21 +395,18 @@ public class BackupUtils {
             File file = new File(sb.toString());
 
             try {
-            if (!filedir.exists()) {
+                if (!file.exists() && !file.createNewFile()) {
-                filedir.mkdir();
+                    Log.e(TAG, "Failed to create file: " + file.getAbsolutePath());
-            }
+                    return null;
-            if (!file.exists()) {
-                file.createNewFile();
                 }
                 return file;
-        } catch (SecurityException e) {
+            } catch (SecurityException | IOException e) {
-            e.printStackTrace();
+                Log.e(TAG, "Error creating file: " + e.getMessage(), e);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-
                 return null;
             }
+        }
+    }
 }
 
 
+