phcublirf
/
gitProject
1
0
Fork 0
Code Issues Pull Requests 2 Projects Releases Wiki Activity

注释 tool.BackupUtils

Browse Source
pull/13/head
chenqy 2 years ago
parent 7698bec1d9
commit a2738e251a
2 changed files with 388 additions and 192 deletions
Show Stats Download Patch File Download Diff File

272
app/src/main/java/net/micode/notes/tool/BackupUtils.java
Unescape View File

@ -41,121 +41,160 @@ public class BackupUtils {
// Singleton stuff // Singleton stuff
private static BackupUtils sInstance; private static BackupUtils sInstance;
/**
* 返回 BackupUtils 类的单例实例，并确保线程安全。
* @param context 应用程序的上下文。
* @return BackupUtils 类的实例。
*/
public static synchronized BackupUtils getInstance(Context context) { public static synchronized BackupUtils getInstance(Context context) {
// 如果实例不存在，创建一个新的实例
if (sInstance == null) { if (sInstance == null) {
sInstance = new BackupUtils(context); sInstance = new BackupUtils(context);
} }
// 返回现有实例或新创建的实例
return sInstance; return sInstance;
} }
/** /**
* Following states are signs to represents backup or restore * Following states are signs to represents backup or restore
* status * status
*/ */
// Currently, the sdcard is not mounted // 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; private TextExport mTextExport; // 用于导出文本数据的 TextExport 实例
// 构造函数，用于创建 BackupUtils 类的实例
private BackupUtils(Context context) { private BackupUtils(Context context) {
mTextExport = new TextExport(context); mTextExport = new TextExport(context); // 创建 TextExport 实例并保存到成员变量中
} }
/**
* 检查外部存储是否可用。
* @return 如果外部存储可用，则返回 true；否则返回 false。
*/
private static boolean externalStorageAvailable() { private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()); return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
} }
/**
* 将数据导出到文本文件中。
* @return 导出操作的结果状态。
*/
public int exportToText() { public int exportToText() {
return mTextExport.exportToText(); return mTextExport.exportToText();
} }
/**
* 获取导出的文本文件名。
* @return 导出的文本文件名。
*/
public String getExportedTextFileName() { public String getExportedTextFileName() {
return mTextExport.mFileName; return mTextExport.mFileName;
} }
/**
* 获取导出的文本文件所在的目录。
* @return 导出的文本文件所在的目录。
*/
public String getExportedTextFileDir() { public String getExportedTextFileDir() {
return mTextExport.mFileDirectory; return mTextExport.mFileDirectory;
} }
private static class TextExport { private static class TextExport {
private static final String[] NOTE_PROJECTION = { private static final String[] NOTE_PROJECTION = {
NoteColumns.ID, NoteColumns.ID, // 笔记的标识符
NoteColumns.MODIFIED_DATE, NoteColumns.MODIFIED_DATE, // 笔记最近修改的日期
NoteColumns.SNIPPET, NoteColumns.SNIPPET, // 笔记内容的片段，用于快速预览笔记
NoteColumns.TYPE NoteColumns.TYPE // 笔记的类型
}; };
private static final int NOTE_COLUMN_ID = 0; private static final int NOTE_COLUMN_ID = 0; // 列 ID
private static final int NOTE_COLUMN_MODIFIED_DATE = 1; // 列 MODIFIED_DATE
private static final int NOTE_COLUMN_MODIFIED_DATE = 1; private static final int NOTE_COLUMN_SNIPPET = 2; // 列 SNIPPET
private static final int NOTE_COLUMN_SNIPPET = 2;
private static final String[] DATA_PROJECTION = { private static final String[] DATA_PROJECTION = {
DataColumns.CONTENT, DataColumns.CONTENT, // 数据的主体内容
DataColumns.MIME_TYPE, DataColumns.MIME_TYPE, // 数据的 MIME 类型
DataColumns.DATA1, DataColumns.DATA1, // 此列可能包含电话号码、电子邮件地址等。
DataColumns.DATA2, DataColumns.DATA2, // 此列可能包含电话类型（家庭、工作等）、电子邮件类型等。
DataColumns.DATA3, DataColumns.DATA3, // 通常情况下，此列的使用与 DATA2 相同。
DataColumns.DATA4, DataColumns.DATA4 // 保留供将来使用。
}; };
private static final int DATA_COLUMN_CONTENT = 0; private static final int DATA_COLUMN_CONTENT = 0; // 列 CONTENT
private static final int DATA_COLUMN_MIME_TYPE = 1; // 列 MIME_TYPE
private static final int DATA_COLUMN_CALL_DATE = 2; // 列 CALL_DATE
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; // 列 PHONE_NUMBER
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 final String [] TEXT_FORMAT; private Context mContext; // 应用程序上下文
private static final int FORMAT_FOLDER_NAME = 0; private String mFileName; // 导出文件的名称
private static final int FORMAT_NOTE_DATE = 1; private String mFileDirectory; // 导出文件所在的目录
private static final int FORMAT_NOTE_CONTENT = 2;
private Context mContext;
private String mFileName;
private String mFileDirectory;
/**
* 构造函数，用于创建 TextExport 类的实例。
*
* @param context 应用程序上下文。
*/
public TextExport(Context context) { public TextExport(Context context) {
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note); TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note); // 从资源中获取导出文本的格式
mContext = context; mContext = context; // 保存应用程序上下文
mFileName = ""; mFileName = ""; // 导出文件名称为空
mFileDirectory = ""; mFileDirectory = ""; // 导出文件所在目录为空
} }
/**
* 获取指定索引处的导出文本格式。
*
* @param id 索引值。
* @return 指定索引处的导出文本格式。
*/
private String getFormat(int id) { private String getFormat(int id) {
return TEXT_FORMAT[id]; return TEXT_FORMAT[id]; // 返回指定索引处的导出文本格式
} }
/** /**
* Export the folder identified by folder id to text * Export the folder identified by folder id to text
*/ */
/**
* 导出指定笔记本中的所有笔记到文本文件。
*
* @param folderId 笔记本的标识符。
* @param ps PrintStream 对象，用于写入导出的文本数据。
*/
private void exportFolderToText(String folderId, PrintStream ps) { private void exportFolderToText(String folderId, PrintStream ps) {
// Query notes belong to this folder // 查询属于该笔记本的笔记
Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI, Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] { NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[]{folderId}, null);
folderId
}, null);
if (notesCursor != null) { if (notesCursor != null) {
if (notesCursor.moveToFirst()) { if (notesCursor.moveToFirst()) {
do { do {
// Print note's last modified date // 打印笔记的最近修改日期
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format( ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm), mContext.getString(R.string.format_datetime_mdhm),
notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)))); notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// Query data belong to this note // 查询属于该笔记的数据
String noteId = notesCursor.getString(NOTE_COLUMN_ID); String noteId = notesCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps); exportNoteToText(noteId, ps); // 将笔记导出到文本文件
} while (notesCursor.moveToNext()); } while (notesCursor.moveToNext());
} }
notesCursor.close(); notesCursor.close();
@ -163,84 +202,103 @@ public class BackupUtils {
} }
/** /**
* Export note identified by id to a print stream * 将指定 ID 的笔记导出到打印流中。
*
* @param noteId 要导出的笔记 ID。
* @param ps 要写入笔记的打印流对象。
*/ */
private void exportNoteToText(String noteId, PrintStream ps) { private void exportNoteToText(String noteId, PrintStream ps) {
Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, // 查询与该笔记关联的数据项
DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] { Cursor dataCursor = mContext.getContentResolver().query(
noteId Notes.CONTENT_DATA_URI, // 查询的 URI
}, null); DATA_PROJECTION, // 要查询的列名
DataColumns.NOTE_ID + "=?", // WHERE 子句
new String[]{noteId}, // WHERE 子句中占位符的值
null // 排序方式
);
if (dataCursor != null) { if (dataCursor != null) {
if (dataCursor.moveToFirst()) { if (dataCursor.moveToFirst()) {
do { do {
// 获取当前数据项的 MIME 类型
String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE); String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
if (DataConstants.CALL_NOTE.equals(mimeType)) { if (DataConstants.CALL_NOTE.equals(mimeType)) {
// Print phone number // 处理通话记录类型的笔记
String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER); String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER); // 电话号码
long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE); long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE); // 通话日期
String location = dataCursor.getString(DATA_COLUMN_CONTENT); String location = dataCursor.getString(DATA_COLUMN_CONTENT); // 通话位置
if (!TextUtils.isEmpty(phoneNumber)) { if (!TextUtils.isEmpty(phoneNumber)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), // 如果电话号码不为空，就将其写入打印流中
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), ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
location)); 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)) { } else if (DataConstants.NOTE.equals(mimeType)) {
String content = dataCursor.getString(DATA_COLUMN_CONTENT); // 处理普通笔记类型
String content = dataCursor.getString(DATA_COLUMN_CONTENT); // 笔记内容
if (!TextUtils.isEmpty(content)) { if (!TextUtils.isEmpty(content)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), // 如果笔记内容不为空，就将其写入打印流中
content)); ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), content));
} }
} }
} while (dataCursor.moveToNext()); } while (dataCursor.moveToNext());
} }
// 关闭游标
dataCursor.close(); dataCursor.close();
} }
// print a line separator between note
// 在每个笔记之间输出一个分隔符
try { try {
ps.write(new byte[] { ps.write(new byte[]{Character.LINE_SEPARATOR, Character.LETTER_NUMBER});
Character.LINE_SEPARATOR, Character.LETTER_NUMBER
});
} catch (IOException e) { } catch (IOException e) {
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
} }
} }
/** /**
* Note will be exported as text which is user readable * 将笔记导出为纯文本文件。
*
* @return 导出的状态码。
*/ */
public int exportToText() { public int exportToText() {
// 检查外部存储是否可用
if (!externalStorageAvailable()) { if (!externalStorageAvailable()) {
Log.d(TAG, "Media was not mounted"); Log.d(TAG, "Media was not mounted");
return STATE_SD_CARD_UNMOUONTED; return STATE_SD_CARD_UNMOUONTED;
} }
// 获取打印流对象，准备写入数据
PrintStream ps = getExportToTextPrintStream(); PrintStream ps = getExportToTextPrintStream();
if (ps == null) { if (ps == null) {
Log.e(TAG, "get print stream error"); Log.e(TAG, "get print stream error");
return STATE_SYSTEM_ERROR; return STATE_SYSTEM_ERROR;
} }
// First export folder and its notes
// 先导出所有的文件夹及其笔记
Cursor folderCursor = mContext.getContentResolver().query( Cursor folderCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI, Notes.CONTENT_NOTE_URI, // 查询的 URI
NOTE_PROJECTION, NOTE_PROJECTION, // 要查询的列名
"(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+ NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null); + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, // WHERE 子句
null, // WHERE 子句中占位符的值
null // 排序方式
);
if (folderCursor != null) { if (folderCursor != null) {
if (folderCursor.moveToFirst()) { if (folderCursor.moveToFirst()) {
do { do {
// Print folder's name // 打印文件夹名称
String folderName = ""; 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); folderName = mContext.getString(R.string.call_record_folder_name);
@ -251,60 +309,81 @@ public class BackupUtils {
ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName)); ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
} }
String folderId = folderCursor.getString(NOTE_COLUMN_ID); String folderId = folderCursor.getString(NOTE_COLUMN_ID);
// 导出当前文件夹下的所有笔记
exportFolderToText(folderId, ps); exportFolderToText(folderId, ps);
} while (folderCursor.moveToNext()); } while (folderCursor.moveToNext());
} }
// 关闭游标
folderCursor.close(); folderCursor.close();
} }
// Export notes in root's folder // 导出根目录下的笔记
Cursor noteCursor = mContext.getContentResolver().query( Cursor noteCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI, Notes.CONTENT_NOTE_URI, // 查询的 URI
NOTE_PROJECTION, NOTE_PROJECTION, // 要查询的列名
NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID + "=0", // WHERE 子句
+ "=0", null, null); null, // WHERE 子句中占位符的值
null // 排序方式
);
if (noteCursor != null) { if (noteCursor != null) {
if (noteCursor.moveToFirst()) { if (noteCursor.moveToFirst()) {
do { do {
// 打印笔记的最后修改时间
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format( ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm), mContext.getString(R.string.format_datetime_mdhm),
noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)))); noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// Query data belong to this note // 导出当前笔记的内容
String noteId = noteCursor.getString(NOTE_COLUMN_ID); String noteId = noteCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps); exportNoteToText(noteId, ps);
} while (noteCursor.moveToNext()); } while (noteCursor.moveToNext());
} }
// 关闭游标
noteCursor.close(); noteCursor.close();
} }
ps.close();
// 关闭打印流
ps.close();
return STATE_SUCCESS; return STATE_SUCCESS;
} }
/** /**
* Get a print stream pointed to the file {@generateExportedTextFile} * Get a print stream pointed to the file {@generateExportedTextFile}
*/ */
/**
* 生成用于将数据输出到文本文件中的PrintStream对象。
*
* @return 用于将数据输出到文本文件中的PrintStream对象。
*/
private PrintStream getExportToTextPrintStream() { private PrintStream getExportToTextPrintStream() {
// 生成指定路径和名称的文本文件，保存在SD卡上。
File file = generateFileMountedOnSDcard(mContext, R.string.file_path, File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
R.string.file_name_txt_format); R.string.file_name_txt_format);
if (file == null) { if (file == null) {
// 如果创建文件失败，则记录错误日志并返回null。
Log.e(TAG, "create file to exported failed"); Log.e(TAG, "create file to exported failed");
return null; return null;
} }
// 将文件名保存在成员变量中。
mFileName = file.getName(); mFileName = file.getName();
// 将文件目录路径保存在成员变量中。
mFileDirectory = mContext.getString(R.string.file_path); mFileDirectory = mContext.getString(R.string.file_path);
PrintStream ps = null; PrintStream ps = null;
try { try {
// 创建一个新的FileOutputStream对象，并将其包装在PrintStream对象中。
FileOutputStream fos = new FileOutputStream(file); FileOutputStream fos = new FileOutputStream(file);
ps = new PrintStream(fos); ps = new PrintStream(fos);
} catch (FileNotFoundException e) { } catch (FileNotFoundException e) {
// 如果找不到文件，则打印堆栈跟踪并返回null。
e.printStackTrace(); e.printStackTrace();
return null; return null;
} catch (NullPointerException e) { } catch (NullPointerException e) {
// 如果发生空指针异常，则打印堆栈跟踪并返回null。
e.printStackTrace(); e.printStackTrace();
return null; return null;
} }
// 返回用于将数据输出到文本文件中的PrintStream对象。
return ps; return ps;
} }
} }
@ -312,33 +391,52 @@ public class BackupUtils {
/** /**
* Generate the text file to store imported data * 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) { private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
// 创建一个StringBuilder对象，用于拼接文件路径和名称。
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
// 将外部存储器目录添加到StringBuilder中。
sb.append(Environment.getExternalStorageDirectory()); sb.append(Environment.getExternalStorageDirectory());
// 将文件路径的字符串资源ID添加到StringBuilder中。
sb.append(context.getString(filePathResId)); sb.append(context.getString(filePathResId));
// 创建一个包含文件路径的File对象。
File filedir = new File(sb.toString()); File filedir = new File(sb.toString());
sb.append(context.getString( // 将文件名格式化并将其添加到StringBuilder末尾。
fileNameFormatResId, sb.append(context.getString(fileNameFormatResId,
DateFormat.format(context.getString(R.string.format_date_ymd), DateFormat.format(context.getString(R.string.format_date_ymd), System.currentTimeMillis())));
System.currentTimeMillis()))); // 创建一个包含完整文件路径的File对象。
File file = new File(sb.toString()); File file = new File(sb.toString());
try { try {
// 如果文件夹不存在，则创建它。
if (!filedir.exists()) { if (!filedir.exists()) {
filedir.mkdir(); filedir.mkdir();
} }
// 如果文件不存在，则创建它。
if (!file.exists()) { if (!file.exists()) {
file.createNewFile(); file.createNewFile();
} }
// 返回创建的文件对象。
return file; return file;
} catch (SecurityException e) { } catch (SecurityException e) {
// 捕获安全异常，并打印错误日志。
e.printStackTrace(); e.printStackTrace();
} catch (IOException e) { } catch (IOException e) {
// 捕获I/O异常，并打印错误日志。
e.printStackTrace(); e.printStackTrace();
} }
// 如果创建文件失败，则返回null。
return null; return null;
} }
} }

272
doc/tool/BackupUtils.java
Unescape View File

@ -41,121 +41,160 @@ public class BackupUtils {
// Singleton stuff // Singleton stuff
private static BackupUtils sInstance; private static BackupUtils sInstance;
/**
* 返回 BackupUtils 类的单例实例，并确保线程安全。
* @param context 应用程序的上下文。
* @return BackupUtils 类的实例。
*/
public static synchronized BackupUtils getInstance(Context context) { public static synchronized BackupUtils getInstance(Context context) {
// 如果实例不存在，创建一个新的实例
if (sInstance == null) { if (sInstance == null) {
sInstance = new BackupUtils(context); sInstance = new BackupUtils(context);
} }
// 返回现有实例或新创建的实例
return sInstance; return sInstance;
} }
/** /**
* Following states are signs to represents backup or restore * Following states are signs to represents backup or restore
* status * status
*/ */
// Currently, the sdcard is not mounted // 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; private TextExport mTextExport; // 用于导出文本数据的 TextExport 实例
// 构造函数，用于创建 BackupUtils 类的实例
private BackupUtils(Context context) { private BackupUtils(Context context) {
mTextExport = new TextExport(context); mTextExport = new TextExport(context); // 创建 TextExport 实例并保存到成员变量中
} }
/**
* 检查外部存储是否可用。
* @return 如果外部存储可用，则返回 true；否则返回 false。
*/
private static boolean externalStorageAvailable() { private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()); return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
} }
/**
* 将数据导出到文本文件中。
* @return 导出操作的结果状态。
*/
public int exportToText() { public int exportToText() {
return mTextExport.exportToText(); return mTextExport.exportToText();
} }
/**
* 获取导出的文本文件名。
* @return 导出的文本文件名。
*/
public String getExportedTextFileName() { public String getExportedTextFileName() {
return mTextExport.mFileName; return mTextExport.mFileName;
} }
/**
* 获取导出的文本文件所在的目录。
* @return 导出的文本文件所在的目录。
*/
public String getExportedTextFileDir() { public String getExportedTextFileDir() {
return mTextExport.mFileDirectory; return mTextExport.mFileDirectory;
} }
private static class TextExport { private static class TextExport {
private static final String[] NOTE_PROJECTION = { private static final String[] NOTE_PROJECTION = {
NoteColumns.ID, NoteColumns.ID, // 笔记的标识符
NoteColumns.MODIFIED_DATE, NoteColumns.MODIFIED_DATE, // 笔记最近修改的日期
NoteColumns.SNIPPET, NoteColumns.SNIPPET, // 笔记内容的片段，用于快速预览笔记
NoteColumns.TYPE NoteColumns.TYPE // 笔记的类型
}; };
private static final int NOTE_COLUMN_ID = 0; private static final int NOTE_COLUMN_ID = 0; // 列 ID
private static final int NOTE_COLUMN_MODIFIED_DATE = 1; // 列 MODIFIED_DATE
private static final int NOTE_COLUMN_MODIFIED_DATE = 1; private static final int NOTE_COLUMN_SNIPPET = 2; // 列 SNIPPET
private static final int NOTE_COLUMN_SNIPPET = 2;
private static final String[] DATA_PROJECTION = { private static final String[] DATA_PROJECTION = {
DataColumns.CONTENT, DataColumns.CONTENT, // 数据的主体内容
DataColumns.MIME_TYPE, DataColumns.MIME_TYPE, // 数据的 MIME 类型
DataColumns.DATA1, DataColumns.DATA1, // 此列可能包含电话号码、电子邮件地址等。
DataColumns.DATA2, DataColumns.DATA2, // 此列可能包含电话类型（家庭、工作等）、电子邮件类型等。
DataColumns.DATA3, DataColumns.DATA3, // 通常情况下，此列的使用与 DATA2 相同。
DataColumns.DATA4, DataColumns.DATA4 // 保留供将来使用。
}; };
private static final int DATA_COLUMN_CONTENT = 0; private static final int DATA_COLUMN_CONTENT = 0; // 列 CONTENT
private static final int DATA_COLUMN_MIME_TYPE = 1; // 列 MIME_TYPE
private static final int DATA_COLUMN_CALL_DATE = 2; // 列 CALL_DATE
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; // 列 PHONE_NUMBER
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 final String [] TEXT_FORMAT; private Context mContext; // 应用程序上下文
private static final int FORMAT_FOLDER_NAME = 0; private String mFileName; // 导出文件的名称
private static final int FORMAT_NOTE_DATE = 1; private String mFileDirectory; // 导出文件所在的目录
private static final int FORMAT_NOTE_CONTENT = 2;
private Context mContext;
private String mFileName;
private String mFileDirectory;
/**
* 构造函数，用于创建 TextExport 类的实例。
*
* @param context 应用程序上下文。
*/
public TextExport(Context context) { public TextExport(Context context) {
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note); TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note); // 从资源中获取导出文本的格式
mContext = context; mContext = context; // 保存应用程序上下文
mFileName = ""; mFileName = ""; // 导出文件名称为空
mFileDirectory = ""; mFileDirectory = ""; // 导出文件所在目录为空
} }
/**
* 获取指定索引处的导出文本格式。
*
* @param id 索引值。
* @return 指定索引处的导出文本格式。
*/
private String getFormat(int id) { private String getFormat(int id) {
return TEXT_FORMAT[id]; return TEXT_FORMAT[id]; // 返回指定索引处的导出文本格式
} }
/** /**
* Export the folder identified by folder id to text * Export the folder identified by folder id to text
*/ */
/**
* 导出指定笔记本中的所有笔记到文本文件。
*
* @param folderId 笔记本的标识符。
* @param ps PrintStream 对象，用于写入导出的文本数据。
*/
private void exportFolderToText(String folderId, PrintStream ps) { private void exportFolderToText(String folderId, PrintStream ps) {
// Query notes belong to this folder // 查询属于该笔记本的笔记
Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI, Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] { NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[]{folderId}, null);
folderId
}, null);
if (notesCursor != null) { if (notesCursor != null) {
if (notesCursor.moveToFirst()) { if (notesCursor.moveToFirst()) {
do { do {
// Print note's last modified date // 打印笔记的最近修改日期
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format( ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm), mContext.getString(R.string.format_datetime_mdhm),
notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)))); notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// Query data belong to this note // 查询属于该笔记的数据
String noteId = notesCursor.getString(NOTE_COLUMN_ID); String noteId = notesCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps); exportNoteToText(noteId, ps); // 将笔记导出到文本文件
} while (notesCursor.moveToNext()); } while (notesCursor.moveToNext());
} }
notesCursor.close(); notesCursor.close();
@ -163,84 +202,103 @@ public class BackupUtils {
} }
/** /**
* Export note identified by id to a print stream * 将指定 ID 的笔记导出到打印流中。
*
* @param noteId 要导出的笔记 ID。
* @param ps 要写入笔记的打印流对象。
*/ */
private void exportNoteToText(String noteId, PrintStream ps) { private void exportNoteToText(String noteId, PrintStream ps) {
Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, // 查询与该笔记关联的数据项
DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] { Cursor dataCursor = mContext.getContentResolver().query(
noteId Notes.CONTENT_DATA_URI, // 查询的 URI
}, null); DATA_PROJECTION, // 要查询的列名
DataColumns.NOTE_ID + "=?", // WHERE 子句
new String[]{noteId}, // WHERE 子句中占位符的值
null // 排序方式
);
if (dataCursor != null) { if (dataCursor != null) {
if (dataCursor.moveToFirst()) { if (dataCursor.moveToFirst()) {
do { do {
// 获取当前数据项的 MIME 类型
String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE); String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
if (DataConstants.CALL_NOTE.equals(mimeType)) { if (DataConstants.CALL_NOTE.equals(mimeType)) {
// Print phone number // 处理通话记录类型的笔记
String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER); String phoneNumber = dataCursor.getString(DATA_COLUMN_PHONE_NUMBER); // 电话号码
long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE); long callDate = dataCursor.getLong(DATA_COLUMN_CALL_DATE); // 通话日期
String location = dataCursor.getString(DATA_COLUMN_CONTENT); String location = dataCursor.getString(DATA_COLUMN_CONTENT); // 通话位置
if (!TextUtils.isEmpty(phoneNumber)) { if (!TextUtils.isEmpty(phoneNumber)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), // 如果电话号码不为空，就将其写入打印流中
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), ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
location)); 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)) { } else if (DataConstants.NOTE.equals(mimeType)) {
String content = dataCursor.getString(DATA_COLUMN_CONTENT); // 处理普通笔记类型
String content = dataCursor.getString(DATA_COLUMN_CONTENT); // 笔记内容
if (!TextUtils.isEmpty(content)) { if (!TextUtils.isEmpty(content)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), // 如果笔记内容不为空，就将其写入打印流中
content)); ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), content));
} }
} }
} while (dataCursor.moveToNext()); } while (dataCursor.moveToNext());
} }
// 关闭游标
dataCursor.close(); dataCursor.close();
} }
// print a line separator between note
// 在每个笔记之间输出一个分隔符
try { try {
ps.write(new byte[] { ps.write(new byte[]{Character.LINE_SEPARATOR, Character.LETTER_NUMBER});
Character.LINE_SEPARATOR, Character.LETTER_NUMBER
});
} catch (IOException e) { } catch (IOException e) {
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
} }
} }
/** /**
* Note will be exported as text which is user readable * 将笔记导出为纯文本文件。
*
* @return 导出的状态码。
*/ */
public int exportToText() { public int exportToText() {
// 检查外部存储是否可用
if (!externalStorageAvailable()) { if (!externalStorageAvailable()) {
Log.d(TAG, "Media was not mounted"); Log.d(TAG, "Media was not mounted");
return STATE_SD_CARD_UNMOUONTED; return STATE_SD_CARD_UNMOUONTED;
} }
// 获取打印流对象，准备写入数据
PrintStream ps = getExportToTextPrintStream(); PrintStream ps = getExportToTextPrintStream();
if (ps == null) { if (ps == null) {
Log.e(TAG, "get print stream error"); Log.e(TAG, "get print stream error");
return STATE_SYSTEM_ERROR; return STATE_SYSTEM_ERROR;
} }
// First export folder and its notes
// 先导出所有的文件夹及其笔记
Cursor folderCursor = mContext.getContentResolver().query( Cursor folderCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI, Notes.CONTENT_NOTE_URI, // 查询的 URI
NOTE_PROJECTION, NOTE_PROJECTION, // 要查询的列名
"(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
+ NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null); + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, // WHERE 子句
null, // WHERE 子句中占位符的值
null // 排序方式
);
if (folderCursor != null) { if (folderCursor != null) {
if (folderCursor.moveToFirst()) { if (folderCursor.moveToFirst()) {
do { do {
// Print folder's name // 打印文件夹名称
String folderName = ""; 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); folderName = mContext.getString(R.string.call_record_folder_name);
@ -251,60 +309,81 @@ public class BackupUtils {
ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName)); ps.println(String.format(getFormat(FORMAT_FOLDER_NAME), folderName));
} }
String folderId = folderCursor.getString(NOTE_COLUMN_ID); String folderId = folderCursor.getString(NOTE_COLUMN_ID);
// 导出当前文件夹下的所有笔记
exportFolderToText(folderId, ps); exportFolderToText(folderId, ps);
} while (folderCursor.moveToNext()); } while (folderCursor.moveToNext());
} }
// 关闭游标
folderCursor.close(); folderCursor.close();
} }
// Export notes in root's folder // 导出根目录下的笔记
Cursor noteCursor = mContext.getContentResolver().query( Cursor noteCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI, Notes.CONTENT_NOTE_URI, // 查询的 URI
NOTE_PROJECTION, NOTE_PROJECTION, // 要查询的列名
NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID NoteColumns.TYPE + "=" + +Notes.TYPE_NOTE + " AND " + NoteColumns.PARENT_ID + "=0", // WHERE 子句
+ "=0", null, null); null, // WHERE 子句中占位符的值
null // 排序方式
);
if (noteCursor != null) { if (noteCursor != null) {
if (noteCursor.moveToFirst()) { if (noteCursor.moveToFirst()) {
do { do {
// 打印笔记的最后修改时间
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format( ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm), mContext.getString(R.string.format_datetime_mdhm),
noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE)))); noteCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// Query data belong to this note // 导出当前笔记的内容
String noteId = noteCursor.getString(NOTE_COLUMN_ID); String noteId = noteCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps); exportNoteToText(noteId, ps);
} while (noteCursor.moveToNext()); } while (noteCursor.moveToNext());
} }
// 关闭游标
noteCursor.close(); noteCursor.close();
} }
ps.close();
// 关闭打印流
ps.close();
return STATE_SUCCESS; return STATE_SUCCESS;
} }
/** /**
* Get a print stream pointed to the file {@generateExportedTextFile} * Get a print stream pointed to the file {@generateExportedTextFile}
*/ */
/**
* 生成用于将数据输出到文本文件中的PrintStream对象。
*
* @return 用于将数据输出到文本文件中的PrintStream对象。
*/
private PrintStream getExportToTextPrintStream() { private PrintStream getExportToTextPrintStream() {
// 生成指定路径和名称的文本文件，保存在SD卡上。
File file = generateFileMountedOnSDcard(mContext, R.string.file_path, File file = generateFileMountedOnSDcard(mContext, R.string.file_path,
R.string.file_name_txt_format); R.string.file_name_txt_format);
if (file == null) { if (file == null) {
// 如果创建文件失败，则记录错误日志并返回null。
Log.e(TAG, "create file to exported failed"); Log.e(TAG, "create file to exported failed");
return null; return null;
} }
// 将文件名保存在成员变量中。
mFileName = file.getName(); mFileName = file.getName();
// 将文件目录路径保存在成员变量中。
mFileDirectory = mContext.getString(R.string.file_path); mFileDirectory = mContext.getString(R.string.file_path);
PrintStream ps = null; PrintStream ps = null;
try { try {
// 创建一个新的FileOutputStream对象，并将其包装在PrintStream对象中。
FileOutputStream fos = new FileOutputStream(file); FileOutputStream fos = new FileOutputStream(file);
ps = new PrintStream(fos); ps = new PrintStream(fos);
} catch (FileNotFoundException e) { } catch (FileNotFoundException e) {
// 如果找不到文件，则打印堆栈跟踪并返回null。
e.printStackTrace(); e.printStackTrace();
return null; return null;
} catch (NullPointerException e) { } catch (NullPointerException e) {
// 如果发生空指针异常，则打印堆栈跟踪并返回null。
e.printStackTrace(); e.printStackTrace();
return null; return null;
} }
// 返回用于将数据输出到文本文件中的PrintStream对象。
return ps; return ps;
} }
} }
@ -312,33 +391,52 @@ public class BackupUtils {
/** /**
* Generate the text file to store imported data * 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) { private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
// 创建一个StringBuilder对象，用于拼接文件路径和名称。
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
// 将外部存储器目录添加到StringBuilder中。
sb.append(Environment.getExternalStorageDirectory()); sb.append(Environment.getExternalStorageDirectory());
// 将文件路径的字符串资源ID添加到StringBuilder中。
sb.append(context.getString(filePathResId)); sb.append(context.getString(filePathResId));
// 创建一个包含文件路径的File对象。
File filedir = new File(sb.toString()); File filedir = new File(sb.toString());
sb.append(context.getString( // 将文件名格式化并将其添加到StringBuilder末尾。
fileNameFormatResId, sb.append(context.getString(fileNameFormatResId,
DateFormat.format(context.getString(R.string.format_date_ymd), DateFormat.format(context.getString(R.string.format_date_ymd), System.currentTimeMillis())));
System.currentTimeMillis()))); // 创建一个包含完整文件路径的File对象。
File file = new File(sb.toString()); File file = new File(sb.toString());
try { try {
// 如果文件夹不存在，则创建它。
if (!filedir.exists()) { if (!filedir.exists()) {
filedir.mkdir(); filedir.mkdir();
} }
// 如果文件不存在，则创建它。
if (!file.exists()) { if (!file.exists()) {
file.createNewFile(); file.createNewFile();
} }
// 返回创建的文件对象。
return file; return file;
} catch (SecurityException e) { } catch (SecurityException e) {
// 捕获安全异常，并打印错误日志。
e.printStackTrace(); e.printStackTrace();
} catch (IOException e) { } catch (IOException e) {
// 捕获I/O异常，并打印错误日志。
e.printStackTrace(); e.printStackTrace();
} }
// 如果创建文件失败，则返回null。
return null; return null;
} }
} }

Write Preview
Loading…
Cancel
Save