王希宁 2023317170
public class BackupUtils {
    private static final String TAG = "BackupUtils";
    // 单例模式相关
    private static BackupUtils sInstance;

    public static synchronized BackupUtils getInstance(Context context) {
        if (sInstance == null) {
            sInstance = new BackupUtils(context);
        }
        return sInstance;
    }

    /**
     * 以下状态用于表示备份或恢复的状态
     */
    // 当前，SD卡未挂载
    public static final int STATE_SD_CARD_UNMOUNTED = 0;
    // 备份文件不存在
    public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
    // 数据格式不正确，可能被其他程序更改
    public static final int STATE_DATA_DESTROYED = 2;
    // 由于运行时异常导致恢复或备份失败
    public static final int STATE_SYSTEM_ERROR = 3;
    // 备份或恢复成功
    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;
    }
}
``````java
private static class TextExport {
        private static final String[] NOTE_PROJECTION = {
                NoteColumns.ID,
                NoteColumns.MODIFIED_DATE,
                NoteColumns.SNIPPET,
                NoteColumns.TYPE
        };

        private static final int NOTE_COLUMN_ID = 0;

        private static final int NOTE_COLUMN_MODIFIED_DATE = 1;

        private static final int NOTE_COLUMN_SNIPPET = 2;

        private static final String[] DATA_PROJECTION = {
                DataColumns.CONTENT,
                DataColumns.MIME_TYPE,
                DataColumns.DATA1,
                DataColumns.DATA2,
                DataColumns.DATA3,
                DataColumns.DATA4,
        };

        private static final int DATA_COLUMN_CONTENT = 0;

        private static final int DATA_COLUMN_MIME_TYPE = 1;

        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];
        }

        /**
         * 将由文件夹ID标识的文件夹导出为文本
         */
        private void exportFolderToText(String folderId, PrintStream ps) {
            // 查询属于此文件夹的笔记
            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))));
                        // 查询属于此笔记的数据
                        String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                        exportNoteToText(noteId, ps);
                    } while (notesCursor.moveToNext());
                }
                notesCursor.close();
            }
        }
}
``````java
            }
            folderCursor.close();
        }
        // 关闭游标
        folderCursor.close();
    }

    return STATE_SUCCESS;
}

/**
 * 检查外部存储是否可用
 */
private boolean externalStorageAvailable() {
    String state = Environment.getExternalStorageState();
    return Environment.MEDIA_MOUNTED.equals(state);
}

/**
 * 获取导出到文本的打印流
 */
private PrintStream getExportToTextPrintStream() {
    try {
        File exportFile = new File(mFileDirectory, mFileName);
        FileOutputStream fileOutputStream = new FileOutputStream(exportFile);
        return new PrintStream(fileOutputStream);
    } catch (FileNotFoundException e) {
        Log.e(TAG, e.toString());
        return null;
    }
}

/**
 * 导出文件夹和其笔记到文本
 */
private void exportFolderToText(String folderId, PrintStream ps) {
    // 查询属于此文件夹的笔记
    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))));
                // 查询属于此笔记的数据
                String noteId = notesCursor.getString(NOTE_COLUMN_ID);
                exportNoteToText(noteId, ps);
            } while (notesCursor.moveToNext());
        }
        notesCursor.close();
    }
}

/**
 * 导出由id标识的笔记到打印流
 */
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)) {
                    // 打印电话号码
                    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));
                    }
                    // 打印通
```java
// 导出根文件夹中的笔记
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))));
            // 查询属于此笔记的数据
            String noteId = noteCursor.getString(NOTE_COLUMN_ID);
            exportNoteToText(noteId, ps);
        } while (noteCursor.moveToNext());
    }
    noteCursor.close();
}
ps.close();

return STATE_SUCCESS;
}

/**
 * 获取指向文件{@generateExportedTextFile}的打印流
 */
private PrintStream getExportToTextPrintStream() {
File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
        R.string.file_name_txt_format);
if (file == null) {
    Log.e(TAG, "创建要导出的文件失败");
    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;
}
return ps;
}
}

/**
 * 生成文本文件以存储导入的数据
 */
private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
StringBuilder sb = new StringBuilder();
sb.append(Environment.getExternalStorageDirectory());
sb.append(context.getString(filePathResId));
File filedir = new File(sb.toString());
sb.append(context.getString(
        fileNameFormatResId,
        DateFormat.format(context.getString(R.string.format_date_ymd),
                System.currentTimeMillis())));
File file = new File(sb.toString());

try {
    if (!filedir.exists()) {
        filedir.mkdir();
    }
    if (!file.exists()) {
        file.createNewFile();
    }
    return file;
} catch (SecurityException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

return null;
}
}
```