111

tool--DataUtils.txt

@@ -0,0 +1,79 @@
+package net.micode.notes.tool;
+
+// 导入语句
+
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.OperationApplicationException;
+import android.os.RemoteException;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+/**
+ * 笔记数据操作的工具类。
+ */
+public class DataUtils {
+
+    // 日志标签
+    public static final String TAG = "DataUtils";
+
+    /**
+     * 批量直接删除多个笔记。
+     *
+     * @param resolver ContentResolver 实例
+     * @param ids      要删除的笔记 ID 的 HashSet
+     * @return 删除是否成功的布尔值
+     */
+    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
+        // 检查传入的 ID 集合是否为空
+        if (ids == null) {
+            Log.d(TAG, "ids 为空");
+            return true;
+        }
+        // 检查传入的 ID 集合是否为空集合
+        if (ids.size() == 0) {
+            Log.d(TAG, "hashset 中没有 ID");
+            return true;
+        }
+
+        // 准备要执行的操作列表
+        ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
+        // 遍历传入的 ID 集合，构建删除操作
+        for (long id : ids) {
+            // 如果是根文件夹，则跳过删除操作
+            if (id == Notes.ID_ROOT_FOLDER) {
+                Log.e(TAG, "不要删除系统文件夹的根目录");
+                continue;
+            }
+            // 构建要执行的删除操作并添加到操作列表中
+            ContentProviderOperation.Builder builder = ContentProviderOperation
+                    .newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
+            operationList.add(builder.build());
+        }
+        try {
+            // 应用批处理操作
+            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
+            // 检查批处理结果
+            if (results == null || results.length == 0 || results[0] == null) {
+                Log.d(TAG, "删除笔记失败，ids:" + ids.toString());
+                return false;
+            }
+            // 返回删除成功
+            return true;
+        } catch (RemoteException e) {
+            // 捕获远程异常并记录日志
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        } catch (OperationApplicationException e) {
+            // 捕获操作应用异常并记录日志
+            Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+        }
+        // 删除失败，返回 false
+        return false;
+    }
+
+    // 其他方法使用相似的注释风格...
+}

tool--GTaskStringUtils.txt

@@ -0,0 +1,146 @@
+package net.micode.notes.tool;
+
+// 这个类定义了一系列静态字符串，主要目的是为了提供 JSON 对象中对应字符串的键（key）。
+// 将这些定义集中写在一个类中，有利于查看和管理，是很好的编程规范。
+
+// 提供了一系列静态字符串，用于 JSON 对象中的键
+public class GTaskStringUtils { 
+
+    // 操作 ID
+    public final static String GTASK_JSON_ACTION_ID = "action_id";
+
+    // 操作列表
+    public final static String GTASK_JSON_ACTION_LIST = "action_list";
+
+    // 操作类型
+    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
+
+    // 创建操作类型
+    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
+
+    // 获取全部操作类型
+    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
+
+    // 移动操作类型
+    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
+
+    // 更新操作类型
+    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
+
+    // 创建者 ID
+    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
+
+    // 子实体
+    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
+
+    // 客户端版本
+    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
+
+    // 已完成
+    public final static String GTASK_JSON_COMPLETED = "completed";
+
+    // 当前列表 ID
+    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
+
+    // 默认列表 ID
+    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
+
+    // 已删除
+    public final static String GTASK_JSON_DELETED = "deleted";
+
+    // 目标列表
+    public final static String GTASK_JSON_DEST_LIST = "dest_list";
+
+    // 目标父级
+    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
+
+    // 目标父级类型
+    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
+
+    // 实体增量
+    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
+
+    // 实体类型
+    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
+
+    // 获取已删除
+    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
+
+    // ID
+    public final static String GTASK_JSON_ID = "id";
+
+    // 索引
+    public final static String GTASK_JSON_INDEX = "index";
+
+    // 最后修改时间
+    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
+
+    // 最新同步点
+    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
+
+    // 列表 ID
+    public final static String GTASK_JSON_LIST_ID = "list_id";
+
+    // 列表
+    public final static String GTASK_JSON_LISTS = "lists";
+
+    // 名称
+    public final static String GTASK_JSON_NAME = "name";
+
+    // 新 ID
+    public final static String GTASK_JSON_NEW_ID = "new_id";
+
+    // 笔记
+    public final static String GTASK_JSON_NOTES = "notes";
+
+    // 父级 ID
+    public final static String GTASK_JSON_PARENT_ID = "parent_id";
+
+    // 前一个兄弟 ID
+    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
+
+    // 结果
+    public final static String GTASK_JSON_RESULTS = "results";
+
+    // 源列表
+    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
+
+    // 任务
+    public final static String GTASK_JSON_TASKS = "tasks";
+
+    // 类型
+    public final static String GTASK_JSON_TYPE = "type";
+
+    // 类型 - 组
+    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
+
+    // 类型 - 任务
+    public final static String GTASK_JSON_TYPE_TASK = "TASK";
+
+    // 用户
+    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";
+
+    // 元信息头 - GTask 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] 不要更新和删除";
+}

tool--ResourceParser.txt

@@ -0,0 +1,205 @@
+package net.micode.notes.tool;
+
+/* 简介：资源解析器，用于获取并在程序中使用资源，例如颜色、图片等。
+ * 实现方法：主要依赖于 R.java 类，其中包括：
+ * R.id        组件资源引用
+ * R.drawable  图片资源（被使用）
+ * R.layout    布局资源
+ * R.menu      菜单资源
+ * R.String    文字资源
+ * R.style     主题资源（被使用）
+ * 在按顺序设置好相应的 id 后，就可以编写简单的 getXXX 函数获取需要的资源。
+ * 
+ * 特殊的变量：
+ * @BG_DEFAULT_COLOR 默认背景颜色（黄色）
+ * BG_DEFAULT_FONT_SIZE 默认字体大小（中等）
+ */
+
+public class ResourceParser {
+ 
+    // 常量定义不同颜色的标识
+    public static final int YELLOW = 0;
+    public static final int BLUE = 1;
+    public static final int WHITE = 2;
+    public static final int GREEN = 3;
+    public static final int RED = 4;
+ 
+    // 默认背景颜色为黄色
+    public static final int BG_DEFAULT_COLOR = YELLOW;
+ 
+    // 常量定义不同文本大小的标识
+    public static final int TEXT_SMALL = 0;
+    public static final int TEXT_MEDIUM = 1;
+    public static final int TEXT_LARGE = 2;
+    public static final int TEXT_SUPER = 3;
+ 
+    // 默认字体大小为中等
+    public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
+ 
+    // 内部类，定义了笔记背景资源
+    public static class NoteBgResources {
+        // 编辑状态下的背景资源数组
+        private final static int [] BG_EDIT_RESOURCES = new int [] {
+            R.drawable.edit_yellow,
+            R.drawable.edit_blue,
+            R.drawable.edit_white,
+            R.drawable.edit_green,
+            R.drawable.edit_red
+        };
+ 
+        // 编辑标题状态下的背景资源数组
+        private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
+            R.drawable.edit_title_yellow,
+            R.drawable.edit_title_blue,
+            R.drawable.edit_title_white,
+            R.drawable.edit_title_green,
+            R.drawable.edit_title_red
+        };
+ 
+        // 获取笔记背景资源
+        public static int getNoteBgResource(int id) {
+            return BG_EDIT_RESOURCES[id];
+        }
+ 
+        // 获取笔记标题背景资源
+        public static int getNoteTitleBgResource(int id) {
+            return BG_EDIT_TITLE_RESOURCES[id];
+        }
+    }
+    
+    // 获取默认背景 ID
+    // 若 PREFERENCE_SET_BG_COLOR_KEY 为真，返回随机背景资源 ID，否则返回默认背景颜色
+    public static int getDefaultBgId(Context context) { 
+        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
+                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
+            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
+        } else {
+            return BG_DEFAULT_COLOR;
+        }
+    }
+ 
+    // 内部类，定义了笔记项背景资源
+    public static class NoteItemBgResources {
+        // 第一个笔记项背景资源数组
+        private final static int [] BG_FIRST_RESOURCES = new int [] {
+            R.drawable.list_yellow_up,
+            R.drawable.list_blue_up,
+            R.drawable.list_white_up,
+            R.drawable.list_green_up,
+            R.drawable.list_red_up
+        };
+ 
+        // 中间笔记项背景资源数组
+        private final static int [] BG_NORMAL_RESOURCES = new int [] {
+            R.drawable.list_yellow_middle,
+            R.drawable.list_blue_middle,
+            R.drawable.list_white_middle,
+            R.drawable.list_green_middle,
+            R.drawable.list_red_middle
+        };
+ 
+        // 最后一个笔记项背景资源数组
+        private final static int [] BG_LAST_RESOURCES = new int [] {
+            R.drawable.list_yellow_down,
+            R.drawable.list_blue_down,
+            R.drawable.list_white_down,
+            R.drawable.list_green_down,
+            R.drawable.list_red_down,
+        };
+ 
+        // 单独笔记项背景资源数组
+        private final static int [] BG_SINGLE_RESOURCES = new int [] {
+            R.drawable.list_yellow_single,
+            R.drawable.list_blue_single,
+            R.drawable.list_white_single,
+            R.drawable.list_green_single,
+            R.drawable.list_red_single
+        };
+ 
+        // 获取第一个笔记项背景资源
+        public static int getNoteBgFirstRes(int id) {
+            return BG_FIRST_RESOURCES[id];
+        }
+ 
+        // 获取最后一个笔记项背景资源
+        public static int getNoteBgLastRes(int id) {
+            return BG_LAST_RESOURCES[id];
+        }
+ 
+        // 获取单独笔记项背景资源
+        public static int getNoteBgSingleRes(int id) {
+            return BG_SINGLE_RESOURCES[id];
+        }
+ 
+        // 获取中间笔记项背景资源
+        public static int getNoteBgNormalRes(int id) {
+            return BG_NORMAL_RESOURCES[id];
+        }
+ 
+        // 获取文件夹背景资源
+        public static int getFolderBgRes() {
+            return R.drawable.list_folder;
+        }
+    }
+ 
+    // 内部类，定义了小部件背景资源
+    public static class WidgetBgResources {
+        // 2x 小部件背景资源数组
+        private final static int [] BG_2X_RESOURCES = new int [] {
+            R.drawable.widget_2x_yellow,
+            R.drawable.widget_2x_blue,
+            R.drawable.widget_2x_white,
+            R.drawable.widget_2x_green,
+            R.drawable.widget_2x_red,
+        };
+ 
+        // 获取 2x 小部件背景资源
+        public static int getWidget2xBgResource(int id) {
+            return BG_2X_RESOURCES[id];
+        }
+ 
+        // 4x 小部件背景资源数组
+        private final static int [] BG_4X_RESOURCES = new int [] {
+            R.drawable.widget_4x_yellow,
+            R.drawable.widget_4x_blue,
+            R.drawable.widget_4x_white,
+            R.drawable.widget_4x_green,
+            R.drawable.widget_4x_red
+        };
+ 
+        // 获取 4x 小部件背景资源
+        public static int getWidget4xBgResource(int id) {
+            return BG_4X_RESOURCES[id];
+        }
+    }
+ 
+    // 内部类，定义了文本外观资源
+    public static class TextAppearanceResources {
+        // 文本外观资源数组
+        private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
+            R.style.TextAppearanceNormal,
+            R.style.TextAppearanceMedium,
+            R.style.TextAppearanceLarge,
+            R.style.TextAppearanceSuper
+        };
+        
+        // 获取文本外观资源
+        // 若 id 超出资源总数，则返回默认字体大小设置结果
+        public static int getTexAppearanceResource(int id) {
+            /**
+             * HACKME: Fix bug of store the resource id in shared preference.
+             * The id may larger than the length of resources, in this case,
+             * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
+             */
+            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
+                return BG_DEFAULT_FONT_SIZE;
+            }
+            return TEXTAPPEARANCE_RESOURCES[id];
+        }
+ 
+        // 获取资源数组大小
+        public static int getResourcesSize() {
+            return TEXTAPPEARANCE_RESOURCES.length;
+        }
+    }
+}

tools--BackupUtils.txt

@@ -0,0 +1,251 @@
+package net.micode.notes.tool;
+
+// 导入必要的类
+import android.content.Context;
+import android.database.Cursor;
+import android.os.Environment;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+
+// 备份工具类
+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;
+    }
+
+    // 数据导出类
+    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,
+                NoteColumns.SNIPPET,
+                NoteColumns.TYPE
+        };
+
+        private static final String[] DATA_PROJECTION = {
+                DataColumns.CONTENT,
+                DataColumns.MIME_TYPE,
+                DataColumns.DATA1,
+                DataColumns.DATA2,
+                DataColumns.DATA3,
+                DataColumns.DATA4,
+        };
+
+        // 笔记和数据表的列索引
+        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 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];
+        }
+
+        // 导出文件夹到文本
+        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();
+            }
+        }
+
+        // 导出笔记到文本
+        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)) {
+                            // 导出电话笔记内容
+                            // ...
+                        } else if (DataConstants.NOTE.equals(mimeType)) {
+                            // 导出普通笔记内容
+                            // ...
+                        }
+                    } while (dataCursor.moveToNext());
+                }
+                dataCursor.close();
+            }
+        }
+
+        // 导出到文本文件的主方法
+        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;
+            }
+
+            // 导出文件夹和笔记到文本文件
+            // ...
+
+            return STATE_SUCCESS;
+        }
+
+        // 获取导出到文本文件的打印流
+        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;
+            }
+            return ps;
+        }
+    }
+
+    // 导出状态常量
+    public static final int STATE_SD_CARD_UNMOUONTED = 0;
+    public static final int STATE_SUCCESS = 4;
+    public static final int STATE_SYSTEM_ERROR = 3;
+
+    // 构造导出工具
+    public BackupUtils(Context context) {
+        mTextExport = new TextExport(context);
+    }
+
+    // 外部存储是否可用
+    private static boolean externalStorageAvailable
+    // 外部存储是否可用
+    private static boolean externalStorageAvailable() {
+        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
+    }
+
+    // 生成文件存储在SD卡上
+    private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+        StringBuilder sb = new StringBuilder();
+        sb.append(Environment.getExternalStorageDirectory()); // 获取SD卡路径
+        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;
+    }
+}