xiaominote

src/data/Contact.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ package net.micode.notes.data;
+
+ import android.content.Context;
+ import android.database.Cursor;
+ import android.provider.ContactsContract.CommonDataKinds.Phone;
+ import android.provider.ContactsContract.Data;
+ import android.telephony.PhoneNumberUtils;
+ import android.util.Log;
+ 
+ import java.util.HashMap;
+ 
+ public class Contact {
+     // 联系人缓存，用于存储电话号码到联系人姓名的映射，避免重复查询
+     private static HashMap<String, String> sContactCache;
+     // 日志标签
+     private static final String TAG = "Contact";
+ 
+     // 查询联系人数据库的SQL选择语句
+     // 用于查找电话号码匹配且具有正确MIME类型的联系人
+     private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+     + ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+     + " AND " + Data.RAW_CONTACT_ID + " IN "
+             + "(SELECT raw_contact_id "
+             + " FROM phone_lookup"
+             + " WHERE min_match = '+')";
+ 
+     /**
+      * 根据电话号码获取联系人姓名
+      * @param context 应用上下文
+      * @param phoneNumber 要查询的电话号码
+      * @return 联系人姓名，如果未找到则返回null
+      */
+     public static String getContact(Context context, String phoneNumber) {
+         // 如果缓存未初始化，则初始化
+         if(sContactCache == null) {
+             sContactCache = new HashMap<String, String>();
+         }
+ 
+         // 如果缓存中已有该号码，直接返回缓存结果
+         if(sContactCache.containsKey(phoneNumber)) {
+             return sContactCache.get(phoneNumber);
+         }
+ 
+         // 准备查询条件：替换最小匹配长度参数
+         String selection = CALLER_ID_SELECTION.replace("+",
+                 PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+         
+         // 查询联系人数据库
+         Cursor cursor = context.getContentResolver().query(
+                 Data.CONTENT_URI,               // 查询的URI
+                 new String [] { Phone.DISPLAY_NAME }, // 要返回的列（联系人姓名）
+                 selection,                      // 查询条件
+                 new String[] { phoneNumber },   // 查询参数
+                 null);                          // 排序方式
+ 
+         // 处理查询结果
+         if (cursor != null && cursor.moveToFirst()) {
+             try {
+                 // 获取第一条结果的联系人姓名
+                 String name = cursor.getString(0);
+                 // 将结果存入缓存
+                 sContactCache.put(phoneNumber, name);
+                 return name;
+             } catch (IndexOutOfBoundsException e) {
+                 // 处理异常情况
+                 Log.e(TAG, "获取游标字符串错误 " + e.toString());
+                 return null;
+             } finally {
+                 // 确保关闭游标
+                 cursor.close();
+             }
+         } else {
+             // 没有找到匹配的联系人
+             Log.d(TAG, "未找到与号码匹配的联系人:" + phoneNumber);
+             return null;
+         }
+     }
+ }

src/data/Notes.java

@@ -0,0 +1,332 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ package net.micode.notes.data;
+
+ import android.net.Uri;
+ 
+ // 定义 Notes 类，包含笔记和文件夹的常量及相关信息
+ public class Notes {
+     // 内容提供者的授权字符串
+     public static final String AUTHORITY = "micode_notes";
+     // 日志标签
+     public static final String TAG = "Notes";
+     // 笔记类型
+     public static final int TYPE_NOTE     = 0;
+     // 文件夹类型
+     public static final int TYPE_FOLDER   = 1;
+     // 系统类型
+     public static final int TYPE_SYSTEM   = 2;
+ 
+     /**
+      * 以下 ID 是系统文件夹的标识符
+      * {@link Notes#ID_ROOT_FOLDER } 是默认文件夹
+      * {@link Notes#ID_TEMPARAY_FOLDER } 用于存放不属于任何文件夹的笔记
+      * {@link Notes#ID_CALL_RECORD_FOLDER} 用于存储通话记录
+      */
+     // 根文件夹的 ID
+     public static final int ID_ROOT_FOLDER = 0;
+     // 临时文件夹的 ID
+     public static final int ID_TEMPARAY_FOLDER = -1;
+     // 通话记录文件夹的 ID
+     public static final int ID_CALL_RECORD_FOLDER = -2;
+     // 回收站文件夹的 ID
+     public static final int ID_TRASH_FOLER = -3;
+ 
+     // 用于传递提醒日期的意图额外数据键
+     public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
+     // 用于传递背景颜色 ID 的意图额外数据键
+     public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
+     // 用于传递小部件 ID 的意图额外数据键
+     public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
+     // 用于传递小部件类型的意图额外数据键
+     public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
+     // 用于传递文件夹 ID 的意图额外数据键
+     public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
+     // 用于传递通话日期的意图额外数据键
+     public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
+ 
+     // 无效小部件类型
+     public static final int TYPE_WIDGET_INVALIDE      = -1;
+     // 2x 大小的小部件类型
+     public static final int TYPE_WIDGET_2X            = 0;
+     // 4x 大小的小部件类型
+     public static final int TYPE_WIDGET_4X            = 1;
+ 
+     // 定义数据常量的静态内部类
+     public static class DataConstants {
+         // 文本笔记的内容项类型
+         public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
+         // 通话笔记的内容项类型
+         public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+     }
+ 
+     /**
+      * 用于查询所有笔记和文件夹的 Uri
+      */
+     // 查询所有笔记和文件夹的 Uri
+     public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
+ 
+     /**
+      * 用于查询数据的 Uri
+      */
+     // 查询数据的 Uri
+     public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+ 
+     // 笔记列的接口，定义了笔记表的列名
+     public interface NoteColumns {
+         /**
+          * 行的唯一 ID
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 行的唯一 ID
+         public static final String ID = "_id";
+ 
+         /**
+          * 笔记或文件夹的父 ID
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 父 ID
+         public static final String PARENT_ID = "parent_id";
+ 
+         /**
+          * 笔记或文件夹的创建日期
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 创建日期
+         public static final String CREATED_DATE = "created_date";
+ 
+         /**
+          * 最新修改日期
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 最新修改日期
+         public static final String MODIFIED_DATE = "modified_date";
+ 
+         /**
+          * 提醒日期
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 提醒日期
+         public static final String ALERTED_DATE = "alert_date";
+ 
+         /**
+          * 文件夹名称或笔记的文本内容
+          * <P> 类型: TEXT </P>
+          */
+         // 摘要
+         public static final String SNIPPET = "snippet";
+ 
+         /**
+          * 笔记的小部件 ID
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 小部件 ID
+         public static final String WIDGET_ID = "widget_id";
+ 
+         /**
+          * 笔记的小部件类型
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 小部件类型
+         public static final String WIDGET_TYPE = "widget_type";
+ 
+         /**
+          * 笔记的背景颜色 ID
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 背景颜色 ID
+         public static final String BG_COLOR_ID = "bg_color_id";
+ 
+         /**
+          * 对于文本笔记，没有附件；对于多媒体笔记，至少有一个附件
+          * <P> 类型: INTEGER </P>
+          */
+         // 是否有附件
+         public static final String HAS_ATTACHMENT = "has_attachment";
+ 
+         /**
+          * 文件夹中的笔记数量
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 笔记数量
+         public static final String NOTES_COUNT = "notes_count";
+ 
+         /**
+          * 文件类型：文件夹或笔记
+          * <P> 类型: INTEGER </P>
+          */
+         // 类型
+         public static final String TYPE = "type";
+ 
+         /**
+          * 最后同步 ID
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 同步 ID
+         public static final String SYNC_ID = "sync_id";
+ 
+         /**
+          * 标记本地是否修改
+          * <P> 类型: INTEGER </P>
+          */
+         // 本地修改标记
+         public static final String LOCAL_MODIFIED = "local_modified";
+ 
+         /**
+          * 移动到临时文件夹之前的原始父 ID
+          * <P> 类型 : INTEGER </P>
+          */
+         // 原始父 ID
+         public static final String ORIGIN_PARENT_ID = "origin_parent_id";
+ 
+         /**
+          * Google 任务 ID
+          * <P> 类型 : TEXT </P>
+          */
+         // Google 任务 ID
+         public static final String GTASK_ID = "gtask_id";
+ 
+         /**
+          * 版本代码
+          * <P> 类型 : INTEGER (long) </P>
+          */
+         // 版本代码
+         public static final String VERSION = "version";
+     }
+ 
+     // 数据列的接口，定义了数据表的列名
+     public interface DataColumns {
+         /**
+          * 行的唯一 ID
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 行的唯一 ID
+         public static final String ID = "_id";
+ 
+         /**
+          * 该行所代表项的 MIME 类型
+          * <P> 类型: Text </P>
+          */
+         // MIME 类型
+         public static final String MIME_TYPE = "mime_type";
+ 
+         /**
+          * 此数据所属笔记的引用 ID
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 笔记 ID
+         public static final String NOTE_ID = "note_id";
+ 
+         /**
+          * 笔记或文件夹的创建日期
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 创建日期
+         public static final String CREATED_DATE = "created_date";
+ 
+         /**
+          * 最新修改日期
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 最新修改日期
+         public static final String MODIFIED_DATE = "modified_date";
+ 
+         /**
+          * 数据的内容
+          * <P> 类型: TEXT </P>
+          */
+         // 内容
+         public static final String CONTENT = "content";
+ 
+         /**
+          * 通用数据列，含义由 {@link #MIMETYPE} 特定，用于整数数据类型
+          * <P> 类型: INTEGER </P>
+          */
+         // 通用数据列 1
+         public static final String DATA1 = "data1";
+ 
+         /**
+          * 通用数据列，含义由 {@link #MIMETYPE} 特定，用于整数数据类型
+          * <P> 类型: INTEGER </P>
+          */
+         // 通用数据列 2
+         public static final String DATA2 = "data2";
+ 
+         /**
+          * 通用数据列，含义由 {@link #MIMETYPE} 特定，用于 TEXT 数据类型
+          * <P> 类型: TEXT </P>
+          */
+         // 通用数据列 3
+         public static final String DATA3 = "data3";
+ 
+         /**
+          * 通用数据列，含义由 {@link #MIMETYPE} 特定，用于 TEXT 数据类型
+          * <P> 类型: TEXT </P>
+          */
+         // 通用数据列 4
+         public static final String DATA4 = "data4";
+ 
+         /**
+          * 通用数据列，含义由 {@link #MIMETYPE} 特定，用于 TEXT 数据类型
+          * <P> 类型: TEXT </P>
+          */
+         // 通用数据列 5
+         public static final String DATA5 = "data5";
+     }
+ 
+     // 文本笔记的静态内部类，实现了 DataColumns 接口
+     public static final class TextNote implements DataColumns {
+         /**
+          * 模式，用于指示文本是否处于复选列表模式
+          * <P> 类型: Integer 1:复选列表模式 0: 正常模式 </P>
+          */
+         // 模式
+         public static final String MODE = DATA1;
+         // 复选列表模式
+         public static final int MODE_CHECK_LIST = 1;
+         // 文本笔记的内容类型
+         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
+         // 文本笔记的内容项类型
+         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+         // 文本笔记的 Uri
+         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
+     }
+ 
+     // 通话笔记的静态内部类，实现了 DataColumns 接口
+     public static final class CallNote implements DataColumns {
+         /**
+          * 此记录的通话日期
+          * <P> 类型: INTEGER (long) </P>
+          */
+         // 通话日期
+         public static final String CALL_DATE = DATA1;
+ 
+         /**
+          * 此记录的电话号码
+          * <P> 类型: TEXT </P>
+          */
+         // 电话号码
+         public static final String PHONE_NUMBER = DATA3;
+         // 通话笔记的内容类型
+         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
+         // 通话笔记的内容项类型
+         public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
+         // 通话笔记的 Uri
+         public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
+     }
+ }
+ 

src/data/NotesDatabaseHelper.java

@@ -0,0 +1,460 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+ package net.micode.notes.data;
+
+ import android.content.ContentValues;
+ import android.content.Context;
+ import android.database.sqlite.SQLiteDatabase;
+ import android.database.sqlite.SQLiteOpenHelper;
+ import android.util.Log;
+ 
+ import net.micode.notes.data.Notes.DataColumns;
+ import net.micode.notes.data.Notes.DataConstants;
+ import net.micode.notes.data.Notes.NoteColumns;
+ 
+ // 笔记数据库辅助类，继承自SQLiteOpenHelper，用于管理数据库的创建、升级和相关操作
+ public class NotesDatabaseHelper extends SQLiteOpenHelper {
+     // 数据库名称
+     private static final String DB_NAME = "note.db";
+     // 数据库版本号
+     private static final int DB_VERSION = 4;
+ 
+     // 定义数据库表名的接口
+     public interface TABLE {
+         // 笔记表的名称
+         public static final String NOTE = "note";
+         // 数据表的名称
+         public static final String DATA = "data";
+     }
+ 
+     // 日志标签，用于在日志输出中标识该类相关信息
+     private static final String TAG = "NotesDatabaseHelper";
+ 
+     // 单例实例，用于确保整个应用中只有一个数据库辅助类实例
+     private static NotesDatabaseHelper mInstance;
+ 
+     // 创建笔记表的SQL语句
+     private static final String CREATE_NOTE_TABLE_SQL =
+         "CREATE TABLE " + TABLE.NOTE + "(" +
+             // 笔记的唯一标识ID，整数类型，作为主键
+             NoteColumns.ID + " INTEGER PRIMARY KEY," +
+             // 父笔记或文件夹的ID，整数类型，不能为空，默认值为0
+             NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+             // 提醒日期，整数类型，不能为空，默认值为0
+             NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
+             // 背景颜色ID，整数类型，不能为空，默认值为0
+             NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
+             // 创建日期，整数类型，不能为空，默认值为当前时间的时间戳（秒转换为毫秒）
+             NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+             // 是否有附件，整数类型，不能为空，默认值为0
+             NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
+             // 最后修改日期，整数类型，不能为空，默认值为当前时间的时间戳（秒转换为毫秒）
+             NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+             // 文件夹中的笔记数量，整数类型，不能为空，默认值为0
+             NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
+             // 摘要（对于文件夹是名称，对于笔记是文本内容），文本类型，不能为空，默认值为空字符串
+             NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
+             // 类型（0代表笔记，1代表文件夹等），整数类型，不能为空，默认值为0
+             NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
+             // 小部件ID，整数类型，不能为空，默认值为0
+             NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
+             // 小部件类型，整数类型，不能为空，默认值为-1
+             NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
+             // 同步ID，整数类型，不能为空，默认值为0
+             NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
+             // 本地是否修改的标记，整数类型，不能为空，默认值为0
+             NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
+             // 移动到临时文件夹前的原始父ID，整数类型，不能为空，默认值为0
+             NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
+             // Google任务ID，文本类型，不能为空，默认值为空字符串
+             NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
+             // 版本号，整数类型，不能为空，默认值为0
+             NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+         ")";
+ 
+     // 创建数据表的SQL语句
+     private static final String CREATE_DATA_TABLE_SQL =
+         "CREATE TABLE " + TABLE.DATA + "(" +
+             // 数据的唯一标识ID，整数类型，作为主键
+             DataColumns.ID + " INTEGER PRIMARY KEY," +
+             // MIME类型，文本类型，不能为空
+             DataColumns.MIME_TYPE + " TEXT NOT NULL," +
+             // 所属笔记的ID，整数类型，不能为空，默认值为0
+             DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
+             // 创建日期，整数类型，不能为空，默认值为当前时间的时间戳（秒转换为毫秒）
+             NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+             // 最后修改日期，整数类型，不能为空，默认值为当前时间的时间戳（秒转换为毫秒）
+             NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
+             // 数据内容，文本类型，不能为空，默认值为空字符串
+             DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
+             // 通用数据列1，整数类型
+             DataColumns.DATA1 + " INTEGER," +
+             // 通用数据列2，整数类型
+             DataColumns.DATA2 + " INTEGER," +
+             // 通用数据列3，文本类型，不能为空，默认值为空字符串
+             DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
+             // 通用数据列4，文本类型，不能为空，默认值为空字符串
+             DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
+             // 通用数据列5，文本类型，不能为空，默认值为空字符串
+             DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
+         ")";
+ 
+     // 创建数据的笔记ID索引的SQL语句（如果不存在则创建）
+     private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
+         "CREATE INDEX IF NOT EXISTS note_id_index ON " +
+         TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
+ 
+     /**
+      * 当将笔记移动到文件夹时，增加目标文件夹的笔记数量
+      */
+     // 当笔记表的父ID更新时，触发增加目标文件夹笔记数量的触发器SQL语句
+     private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+         "CREATE TRIGGER increase_folder_count_on_update "+
+         " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
+         " BEGIN " +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+         "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+         " END";
+ 
+     /**
+      * 当将笔记从文件夹中移出时，减少原文件夹的笔记数量
+      */
+     // 当笔记表的父ID更新时，触发减少原文件夹笔记数量的触发器SQL语句
+     private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
+         "CREATE TRIGGER decrease_folder_count_on_update " +
+         " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
+         " BEGIN " +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+         "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+         "  AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
+         " END";
+ 
+     /**
+      * 当向文件夹中插入新笔记时，增加目标文件夹的笔记数量
+      */
+     // 当在笔记表中插入新记录时，触发增加目标文件夹笔记数量的触发器SQL语句
+     private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
+         "CREATE TRIGGER increase_folder_count_on_insert " +
+         " AFTER INSERT ON " + TABLE.NOTE +
+         " BEGIN " +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + " + 1" +
+         "  WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
+         " END";
+ 
+     /**
+      * 当从文件夹中删除笔记时，减少原文件夹的笔记数量
+      */
+     // 当在笔记表中删除记录时，触发减少原文件夹笔记数量的触发器SQL语句
+     private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
+         "CREATE TRIGGER decrease_folder_count_on_delete " +
+         " AFTER DELETE ON " + TABLE.NOTE +
+         " BEGIN " +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.NOTES_COUNT + "=" + NoteColumns.NOTES_COUNT + "-1" +
+         "  WHERE " + NoteColumns.ID + "=old." + NoteColumns.PARENT_ID +
+         "  AND " + NoteColumns.NOTES_COUNT + ">0;" +
+         " END";
+ 
+     /**
+      * 当插入数据类型为文本笔记（{@link DataConstants#NOTE}）时，更新对应笔记的内容
+      */
+     // 当在数据表中插入数据且MIME类型为文本笔记时，触发更新对应笔记内容的触发器SQL语句
+     private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
+         "CREATE TRIGGER update_note_content_on_insert " +
+         " AFTER INSERT ON " + TABLE.DATA +
+         " WHEN new." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+         " BEGIN" +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+         "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+         " END";
+ 
+     /**
+      * 当数据类型为文本笔记（{@link DataConstants#NOTE}）的内容发生更新时，更新对应笔记的内容
+      */
+     // 当在数据表中更新数据且原MIME类型为文本笔记时，触发更新对应笔记内容的触发器SQL语句
+     private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
+         "CREATE TRIGGER update_note_content_on_update " +
+         " AFTER UPDATE ON " + TABLE.DATA +
+         " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+         " BEGIN" +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.SNIPPET + "=new." + DataColumns.CONTENT +
+         "  WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
+         " END";
+ 
+     /**
+      * 当数据类型为文本笔记（{@link DataConstants#NOTE}）的内容被删除时，清空对应笔记的内容
+      */
+     // 当在数据表中删除数据且原MIME类型为文本笔记时，触发清空对应笔记内容的触发器SQL语句
+     private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
+         "CREATE TRIGGER update_note_content_on_delete " +
+         " AFTER delete ON " + TABLE.DATA +
+         " WHEN old." + DataColumns.MIME_TYPE + "='" + DataConstants.NOTE + "'" +
+         " BEGIN" +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.SNIPPET + "=''" +
+         "  WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
+         " END";
+ 
+     /**
+      * 删除属于已被删除笔记的数据
+      */
+     // 当在笔记表中删除记录时，触发删除对应数据表中相关数据的触发器SQL语句
+     private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
+         "CREATE TRIGGER delete_data_on_delete " +
+         " AFTER DELETE ON " + TABLE.NOTE +
+         " BEGIN" +
+         "  DELETE FROM " + TABLE.DATA +
+         "   WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
+         " END";
+ 
+     /**
+      * 删除属于已被删除文件夹的笔记
+      */
+     // 当在笔记表中删除文件夹记录时，触发删除该文件夹下所有笔记记录的触发器SQL语句
+     private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
+         "CREATE TRIGGER folder_delete_notes_on_delete " +
+         " AFTER DELETE ON " + TABLE.NOTE +
+         " BEGIN" +
+         "  DELETE FROM " + TABLE.NOTE +
+         "   WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+         " END";
+ 
+     /**
+      * 将属于已被移动到回收站文件夹的文件夹中的笔记也移动到回收站文件夹
+      */
+     // 当笔记表中文件夹的父ID更新为回收站文件夹ID时，触发移动该文件夹下所有笔记到回收站的触发器SQL语句
+     private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
+         "CREATE TRIGGER folder_move_notes_on_trash " +
+         " AFTER UPDATE ON " + TABLE.NOTE +
+         " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+         " BEGIN" +
+         "  UPDATE " + TABLE.NOTE +
+         "   SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+         "  WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
+         " END";
+ 
+     // 构造函数，调用父类构造函数初始化数据库辅助类，传入上下文、数据库名、游标工厂（这里为null）和版本号
+     public NotesDatabaseHelper(Context context) {
+         super(context, DB_NAME, null, DB_VERSION);
+     }
+ 
+     // 创建笔记表的方法，执行创建笔记表的SQL语句，重新创建相关触发器，并创建系统文件夹
+     public void createNoteTable(SQLiteDatabase db) {
+         db.execSQL(CREATE_NOTE_TABLE_SQL);
+         reCreateNoteTableTriggers(db);
+         createSystemFolder(db);
+         Log.d(TAG, "note table has been created");
+     }
+ 
+     // 重新创建笔记表相关触发器的方法，先删除旧的触发器，再创建新的触发器
+     private void reCreateNoteTableTriggers(SQLiteDatabase db) {
+         db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
+         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
+         db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
+         db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete");
+         db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert");
+         db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
+         db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
+ 
+         db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+         db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
+         db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
+         db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER);
+         db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER);
+         db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
+         db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
+     }
+ 
+     // 创建系统文件夹的方法，通过ContentValues设置文件夹相关信息并插入到笔记表中
+     private void createSystemFolder(SQLiteDatabase db) {
+         ContentValues values = new ContentValues();
+ 
+         /**
+          * 用于存储通话记录笔记的通话记录文件夹
+          */
+         values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
+         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+         db.insert(TABLE.NOTE, null, values);
+ 
+         /**
+          * 作为默认文件夹的根文件夹
+          */
+         values.clear();
+         values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
+         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+         db.insert(TABLE.NOTE, null, values);
+ 
+         /**
+          * 用于移动笔记的临时文件夹
+          */
+         values.clear();
+         values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+         db.insert(TABLE.NOTE, null, values);
+ 
+         /**
+          * 创建回收站文件夹
+          */
+         values.clear();
+         values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+         values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+         db.insert(TABLE.NOTE, null, values);
+     }
+ 
+     // 创建数据表的方法，执行创建数据表的SQL语句，重新创建相关触发器，并创建数据的笔记ID索引
+     public void createDataTable(SQLiteDatabase db) {
+         db.execSQL(CREATE_DATA_TABLE_SQL);
+         reCreateDataTableTriggers(db);
+        db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
+        Log.d(TAG, "data table has been created");
+    }
+
+        // 重新创建数据表相关触发器的方法
+        private void reCreateDataTableTriggers(SQLiteDatabase db) {
+            // 如果存在名为update_note_content_on_insert的触发器，则删除它
+            db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
+            // 如果存在名为update_note_content_on_update的触发器，则删除它
+            db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
+            // 如果存在名为update_note_content_on_delete的触发器，则删除它
+            db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
+    
+            // 执行创建插入数据时更新笔记内容的触发器的SQL语句
+            db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
+            // 执行创建更新数据时更新笔记内容的触发器的SQL语句
+            db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
+            // 执行创建删除数据时更新笔记内容的触发器的SQL语句
+            db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
+        }
+    
+        // 获取数据库辅助类单例实例的静态方法，使用同步锁确保线程安全
+        static synchronized NotesDatabaseHelper getInstance(Context context) {
+            // 如果单例实例尚未创建
+            if (mInstance == null) {
+                // 创建一个新的数据库辅助类实例
+                mInstance = new NotesDatabaseHelper(context);
+            }
+            // 返回单例实例
+            return mInstance;
+        }
+    
+        // 当数据库第一次创建时调用的方法
+        @Override
+        public void onCreate(SQLiteDatabase db) {
+            // 创建笔记表
+            createNoteTable(db);
+            // 创建数据表
+            createDataTable(db);
+        }
+    
+        // 当数据库版本需要升级时调用的方法
+        @Override
+        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+            // 标记是否需要重新创建触发器
+            boolean reCreateTriggers = false;
+            // 标记是否跳过版本2的升级逻辑
+            boolean skipV2 = false;
+    
+            // 如果旧版本是1
+            if (oldVersion == 1) {
+                // 升级到版本2
+                upgradeToV2(db);
+                // 设置跳过版本2的升级逻辑
+                skipV2 = true; // 这次升级包含了从版本2到版本3的升级逻辑
+                // 旧版本号加1
+                oldVersion++;
+            }
+    
+            // 如果旧版本是2且没有跳过版本2的升级逻辑
+            if (oldVersion == 2 && !skipV2) {
+                // 升级到版本3
+                upgradeToV3(db);
+                // 设置需要重新创建触发器
+                reCreateTriggers = true;
+                // 旧版本号加1
+                oldVersion++;
+            }
+    
+            // 如果旧版本是3
+            if (oldVersion == 3) {
+                // 升级到版本4
+                upgradeToV4(db);
+                // 旧版本号加1
+                oldVersion++;
+            }
+    
+            // 如果需要重新创建触发器
+            if (reCreateTriggers) {
+                // 重新创建笔记表相关的触发器
+                reCreateNoteTableTriggers(db);
+                // 重新创建数据表相关的触发器
+                reCreateDataTableTriggers(db);
+            }
+    
+            // 如果旧版本号和新版本号不相等，说明升级失败
+            if (oldVersion != newVersion) {
+                // 抛出异常，提示数据库升级到指定版本失败
+                throw new IllegalStateException("Upgrade notes database to version " + newVersion
+                        + "fails");
+            }
+        }
+    
+        // 将数据库升级到版本2的私有方法
+        private void upgradeToV2(SQLiteDatabase db) {
+            // 如果存在笔记表，则删除它
+            db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
+            // 如果存在数据表，则删除它
+            db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+            // 创建笔记表
+            createNoteTable(db);
+            // 创建数据表
+            createDataTable(db);
+        }
+    
+        // 将数据库升级到版本3的私有方法
+        private void upgradeToV3(SQLiteDatabase db) {
+            // 删除不再使用的触发器：插入笔记时更新修改日期的触发器
+            db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
+            // 删除不再使用的触发器：删除笔记时更新修改日期的触发器
+            db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
+            // 删除不再使用的触发器：更新笔记时更新修改日期的触发器
+            db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
+            // 向笔记表中添加一个用于存储Google任务ID的列
+            db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+                    + " TEXT NOT NULL DEFAULT ''");
+            // 添加一个回收站系统文件夹
+            ContentValues values = new ContentValues();
+            // 设置文件夹的ID为回收站文件夹的ID
+            values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+            // 设置文件夹的类型为系统类型
+            values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+            // 将回收站文件夹的信息插入到笔记表中
+            db.insert(TABLE.NOTE, null, values);
+        }
+    
+        // 将数据库升级到版本4的私有方法
+        private void upgradeToV4(SQLiteDatabase db) {
+            // 向笔记表中添加一个用于存储版本号的列
+            db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+                    + " INTEGER NOT NULL DEFAULT 0");
+        }
+    }
+    

src/data/NotesProvider.java

@@ -0,0 +1,411 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.micode.notes.data;
+
+
+import android.app.SearchManager;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+
+
+public class NotesProvider extends ContentProvider {
+    // 用于匹配Uri的UriMatcher对象
+    private static final UriMatcher mMatcher;
+    // 数据库辅助类实例，用于操作数据库
+    private NotesDatabaseHelper mHelper;
+    // 日志标签
+    private static final String TAG = "NotesProvider";
+
+    // 用于匹配不同Uri的请求码
+    private static final int URI_NOTE = 1;
+    // 匹配单个笔记的Uri的请求码
+    private static final int URI_NOTE_ITEM = 2;
+    // 匹配数据的Uri的请求码
+    private static final int URI_DATA = 3;
+    // 匹配单个数据项的Uri的请求码
+    private static final int URI_DATA_ITEM = 4;
+    // 匹配搜索的Uri的请求码
+    private static final int URI_SEARCH = 5;
+    // 匹配搜索建议的Uri的请求码
+    private static final int URI_SEARCH_SUGGEST = 6;
+
+    static {
+        // 初始化UriMatcher，设置默认匹配为不匹配
+        mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+        // 添加匹配笔记列表Uri的规则
+        mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
+        // 添加匹配单个笔记Uri的规则，其中#表示匹配任意数字
+        mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
+        // 添加匹配数据列表Uri的规则
+        mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
+        // 添加匹配单个数据项Uri的规则，其中#表示匹配任意数字
+        mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
+        // 添加匹配搜索Uri的规则
+        mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
+        // 添加匹配搜索建议Uri的规则，用于处理查询
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
+        // 添加匹配搜索建议Uri的规则，用于处理带参数的查询
+        mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
+    }
+
+    /**
+     * x'0A'在sqlite中表示'\n'字符。对于搜索结果中的标题和内容，
+     * 我们将修剪'\n'和空白字符，以便显示更多信息。
+     */
+    // 用于搜索的投影，定义了搜索结果中包含的列及其处理方式
+    private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+            + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+            + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
+            + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
+            + R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+            + "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+            + "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
+
+    // 用于搜索笔记摘要的查询语句
+    private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+            + " FROM " + TABLE.NOTE
+            + " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
+            + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+            + " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
+
+    // 初始化ContentProvider时调用的方法
+    @Override
+    public boolean onCreate() {
+        // 获取数据库辅助类的单例实例
+        mHelper = NotesDatabaseHelper.getInstance(getContext());
+        // 返回true表示初始化成功
+        return true;
+    }
+
+    // 处理查询请求的方法
+    @Override
+    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+                        String sortOrder) {
+        // 用于存储查询结果的游标
+        Cursor c = null;
+        // 获取可读的数据库实例
+        SQLiteDatabase db = mHelper.getReadableDatabase();
+        // 用于存储Uri路径中的ID
+        String id = null;
+        // 根据Uri匹配结果进行不同的查询操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 查询笔记表，返回所有符合条件的记录
+                c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
+                        sortOrder);
+                break;
+            case URI_NOTE_ITEM:
+                // 获取Uri路径中的ID
+                id = uri.getPathSegments().get(1);
+                // 查询笔记表，返回指定ID的记录
+                c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                break;
+            case URI_DATA:
+                // 查询数据表，返回所有符合条件的记录
+                c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
+                        sortOrder);
+                break;
+            case URI_DATA_ITEM:
+                // 获取Uri路径中的ID
+                id = uri.getPathSegments().get(1);
+                // 查询数据表，返回指定ID的记录
+                c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs, null, null, sortOrder);
+                break;
+            case URI_SEARCH:
+            case URI_SEARCH_SUGGEST:
+                // 检查是否指定了排序或投影，如果是则抛出异常
+                if (sortOrder != null || projection != null) {
+                    throw new IllegalArgumentException(
+                            "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
+                }
+
+                // 用于存储搜索字符串
+                String searchString = null;
+                // 如果是搜索建议的Uri
+                if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+                    // 如果Uri路径段数量大于1，则获取搜索字符串
+                    if (uri.getPathSegments().size() > 1) {
+                        searchString = uri.getPathSegments().get(1);
+                    }
+                } else {
+                    // 否则从Uri参数中获取搜索字符串
+                    searchString = uri.getQueryParameter("pattern");
+                }
+
+                // 如果搜索字符串为空，则返回null
+                if (TextUtils.isEmpty(searchString)) {
+                    return null;
+                }
+
+                try {
+                    // 格式化搜索字符串，添加通配符
+                    searchString = String.format("%%%s%%", searchString);
+                    // 执行原始查询，获取搜索结果
+                    c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
+                            new String[]{searchString});
+                } catch (IllegalStateException ex) {
+                    // 捕获异常并记录日志
+                    Log.e(TAG, "got exception: " + ex.toString());
+                }
+                break;
+            default:
+                // 如果Uri不匹配，则抛出异常
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        // 如果游标不为空，设置通知Uri
+        if (c != null) {
+            c.setNotificationUri(getContext().getContentResolver(), uri);
+        }
+        // 返回查询结果游标
+        return c;
+    }
+
+    // 处理插入请求的方法
+    @Override
+    public Uri insert(Uri uri, ContentValues values) {
+        // 获取可写的数据库实例
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 用于存储插入的ID
+        long dataId = 0, noteId = 0, insertedId = 0;
+        // 根据Uri匹配结果进行不同的插入操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 插入笔记表，获取插入的笔记ID
+                insertedId = noteId = db.insert(TABLE.NOTE, null, values);
+                break;
+            case URI_DATA:
+                // 如果插入的数据包含笔记ID
+                if (values.containsKey(DataColumns.NOTE_ID)) {
+                    // 获取笔记ID
+                    noteId = values.getAsLong(DataColumns.NOTE_ID);
+                } else {
+                    // 否则记录错误日志
+                    Log.d(TAG, "Wrong data format without note id:" + values.toString());
+                }
+                // 插入数据表，获取插入的数据ID
+                insertedId = dataId = db.insert(TABLE.DATA, null, values);
+                break;
+            default:
+                // 如果Uri不匹配，则抛出异常
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        // 如果插入的笔记ID大于0，通知内容解析器笔记Uri发生变化
+        if (noteId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
+        }
+
+        // 如果插入的数据ID大于0，通知内容解析器数据Uri发生变化
+        if (dataId > 0) {
+            getContext().getContentResolver().notifyChange(
+                    ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
+        }
+
+        // 返回插入后的Uri
+        return ContentUris.withAppendedId(uri, insertedId);
+    }
+
+    // 处理删除请求的方法
+    @Override
+    public int delete(Uri uri, String selection, String[] selectionArgs) {
+        // 用于记录删除的行数
+        int count = 0;
+        // 用于存储Uri路径中的ID
+        String id = null;
+        // 获取可写的数据库实例
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 标记是否删除数据
+        boolean deleteData = false;
+        // 根据Uri匹配结果进行不同的删除操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 构建删除条件，排除系统文件夹
+                selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
+                // 删除笔记表中符合条件的记录，获取删除的行数
+                count = db.delete(TABLE.NOTE, selection, selectionArgs);
+                break;
+            case URI_NOTE_ITEM:
+                // 获取Uri路径中的ID
+                id = uri.getPathSegments().get(1);
+                /**
+                 * ID小于等于0的是系统文件夹，不允许删除
+                 */
+                long noteId = Long.valueOf(id);
+                // 如果是系统文件夹，则不进行删除操作
+                if (noteId <= 0) {
+                    break;
+                }
+                // 删除笔记表中指定ID的记录，获取删除的行数
+                count = db.delete(TABLE.NOTE,
+                        NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                break;
+            case URI_DATA:
+                // 删除数据表中符合条件的记录，获取删除的行数
+                count = db.delete(TABLE.DATA, selection, selectionArgs);
+                // 标记删除了数据
+                deleteData = true;
+                break;
+            case URI_DATA_ITEM:
+                // 获取Uri路径中的ID
+                id = uri.getPathSegments().get(1);
+                // 删除数据表中指定ID的记录，获取删除的行数
+                count = db.delete(TABLE.DATA,
+                        DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+                // 标记删除了数据
+                deleteData = true;
+                break;
+            default:
+                // 如果Uri不匹配，则抛出异常
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+        // 如果删除的行数大于0
+        if (count > 0) {
+            // 如果删除了数据，通知内容解析器笔记Uri发生变化
+            if (deleteData) {
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+            }
+            // 通知内容解析器当前Uri发生变化
+            getContext().getContentResolver().notifyChange(uri, null);
+        }
+        // 返回删除的行数
+        return count;
+    }
+
+    // 处理更新请求的方法
+    @Override
+    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+        // 用于记录更新的行数
+        int count = 0;
+        // 用于存储Uri路径中的ID
+        String id = null;
+        // 获取可写的数据库实例
+        SQLiteDatabase db = mHelper.getWritableDatabase();
+        // 标记是否更新了数据
+        boolean updateData = false;
+        // 根据Uri匹配结果进行不同的更新操作
+        switch (mMatcher.match(uri)) {
+            case URI_NOTE:
+                // 增加笔记版本号
+                increaseNoteVersion(-1, selection, selectionArgs);
+                // 更新笔记表中符合条件的记录，获取更新的行数
+                count = db.update(TABLE.NOTE, values, selection, selectionArgs);
+                break;
+            case URI_NOTE_ITEM:
+                // 获取Uri路径中的ID
+                id = uri.getPathSegments().get(1);
+                // 增加指定笔记的版本号
+                increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
+                // 更新笔记表中指定ID的记录，获取更新的行数
+                count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);
+                break;
+            case URI_DATA:
+                // 更新数据表中符合条件的记录，获取更新的行数
+                count = db.update(TABLE.DATA, values, selection, selectionArgs);
+                // 标记更新了数据
+                updateData = true;
+                break;
+            case URI_DATA_ITEM:
+                // 获取Uri路径中的ID
+                id = uri.getPathSegments().get(1);
+                // 更新数据表中指定ID的记录，获取更新的行数
+                count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+                        + parseSelection(selection), selectionArgs);
+                // 标记更新了数据
+                updateData = true;
+                break;
+            default:
+                // 如果Uri不匹配，则抛出异常
+                throw new IllegalArgumentException("Unknown URI " + uri);
+        }
+
+        // 如果更新的行数大于0
+        if (count > 0) {
+            // 如果更新了数据，通知内容解析器笔记Uri发生变化
+            if (updateData) {
+                getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
+            }
+            // 通知内容解析器当前Uri发生变化
+            getContext().getContentResolver().notifyChange(uri, null);
+        }
+        // 返回更新的行数
+        return count;
+    }
+
+    // 解析选择条件的方法，添加额外的条件括号
+    private String parseSelection(String selection) {
+        return (!TextUtils.isEmpty(selection)? " AND (" + selection + ')' : "");
+    }
+
+    // 增加笔记版本号的方法
+    private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+        // 用于构建SQL语句的StringBuilder
+        StringBuilder sql = new StringBuilder(120);
+        // 添加更新语句的开头
+        sql.append("UPDATE ");
+        // 添加要更新的表名
+        sql.append(TABLE.NOTE);
+        // 添加设置版本号的语句
+        sql.append(" SET ");
+        sql.append(NoteColumns.VERSION);
+        sql.append("=" + NoteColumns.VERSION + "+1 ");
+
+        // 如果ID大于0或选择条件不为空，则添加WHERE子句
+        if (id > 0 ||!TextUtils.isEmpty(selection)) {
+            sql.append(" WHERE ");
+        }
+        // 如果ID大于0，则添加ID条件
+        if (id > 0) {
+            sql.append(NoteColumns.ID + "=" + String.valueOf(id));
+        }
+        // 如果选择条件不为空，则添加选择条件
+        if (!TextUtils.isEmpty(selection)) {
+            String selectString = id > 0? parseSelection(selection) : selection;
+            // 替换选择条件中的占位符
+            for (String args : selectionArgs) {
+                selectString = selectString.replaceFirst("\\?", args);
+            }
+            sql.append(selectString);
+        }
+
+        // 执行SQL语句，更新笔记版本号
+        mHelper.getWritableDatabase().execSQL(sql.toString());
+    }
+
+    // 获取Uri对应的MIME类型的方法，目前未实现
+    @Override
+    public String getType(Uri uri) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+}

src/tool/BackupUtils.java

@@ -1,420 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-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 net.micode.notes.R;
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.DataColumns;
-import net.micode.notes.data.Notes.DataConstants;
-import net.micode.notes.data.Notes.NoteColumns;
-
-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"; // 日志标签，用于在日志输出中标识该类的相关信息
-    // Singleton stuff
-    private static BackupUtils sInstance; // 单例模式下的唯一实例，确保整个应用中只有一个BackupUtils实例
-
-    public static synchronized BackupUtils getInstance(Context context) {
-        // 如果实例还未创建，则创建一个新的实例
-        if (sInstance == null) {
-            sInstance = new BackupUtils(context);
-        }
-        return sInstance;
-    }
-
-    /**
-     * 以下状态码用于表示备份或恢复操作的不同状态
-     */
-    // 当前SD卡未挂载，无法进行备份或恢复操作
-    public static final int STATE_SD_CARD_UNMOUONTED = 0;
-    // 备份文件不存在，无法进行恢复操作
-    public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
-    // 备份数据格式被破坏，可能被其他程序修改，无法正确恢复
-    public static final int STATE_DATA_DESTROIED = 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);
-    }
- /**
-     * 检查外部存储（SD卡）是否可用
-     * 
-     * @return 如果SD卡已挂载，则返回true；否则返回false
-     */
-    private static boolean externalStorageAvailable() {
-        return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
-    }
-/**
-     * 调用TextExport实例的exportToText方法，将笔记数据导出为文本文件
-     * 
-     * @return 导出操作的状态码，如STATE_SUCCESS、STATE_SD_CARD_UNMOUONTED等
-     */
-    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, // 笔记的ID
-                NoteColumns.MODIFIED_DATE, // 笔记的修改日期
-                NoteColumns.SNIPPET, // 笔记的摘要
-                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, // 数据的MIME类型
-                DataColumns.DATA1, 
-                DataColumns.DATA2, 
-                DataColumns.DATA3, 
-                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 = "";
-        }
-/**
-         * 根据索引获取文本格式字符串
-         * 
-         * @param id 文本格式在数组中的索引
-         * @return 对应的文本格式字符串
-         */
-        private String getFormat(int id) {
-            return TEXT_FORMAT[id];
-        }
-
-        /**
-         * 将指定文件夹下的所有笔记导出到文本文件
-         * 
-         * @param folderId 文件夹的ID
-         * @param ps 用于写入文本的打印流
-         */
-        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);
-
-            f (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))));
-                        // 获取笔记的ID
-                        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 {
-                        // 获取数据的MIME类型
-                        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));
-                            }
-                            // 打印通话日期
-                            ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), 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)) {
-                            // 如果是普通笔记
-                            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();
-            }
-            // 在笔记之间添加换行分隔符
-            try {
-                ps.write(new byte[]{
-                        Character.LINE_SEPARATOR, Character.LETTER_NUMBER
-                });
-            } catch (IOException e) {
-                // 记录写入错误日志
-                Log.e(TAG, e.toString());
-            }
-        }
-
-        /**
-         * 将所有笔记数据导出为文本文件
-         */
-         public int exportToText() {
-            // 检查SD卡是否可用
-            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;
-            }
-
-            // 查询所有文件夹（排除回收站文件夹）和通话记录文件夹
-            Cursor folderCursor = mContext.getContentResolver().query(
-                    Notes.CONTENT_NOTE_URI,
-                    NOTE_PROJECTION,
-                    "(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
-                            + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
-                            + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
-
-            if (folderCursor != null) {
-                if (folderCursor.moveToFirst()) {
-                    do {
-                        // 获取文件夹名称
-                        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));
-                        }
-                        // 获取文件夹ID
-                        String folderId = folderCursor.getString(NOTE_COLUMN_ID);
-                        // 导出该文件夹下的所有笔记
-                        exportFolderToText(folderId, ps);
-                    } while (folderCursor.moveToNext());
-                }
-                // 关闭游标，释放资源
-                folderCursor.close();
-            }
-
-            // 查询根文件夹下的所有笔记
-            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))));
-                        // 获取笔记的ID
-                        String noteId = noteCursor.getString(NOTE_COLUMN_ID);
-                        // 导出该笔记的详细内容
-                        exportNoteToText(noteId, ps);
-                    } while (noteCursor.moveToNext());
-                }
-                // 关闭游标，释放资源
-                noteCursor.close();
-            }
-            // 关闭打印流
-            ps.close();
-
-            return STATE_SUCCESS;
-        }
-
-    /**
-         * 获取用于导出文本文件的打印流
-         * 
-         * @return 打印流实例，如果创建失败则返回null
-         */
-        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;
-        }
-    }
-
-
-     /**
-     * 生成用于存储导出数据的文件
-     * 
-     * @param context 应用上下文，用于获取资源
-     * @param filePathResId 文件路径的资源ID
-     * @param fileNameFormatResId 文件名格式的资源ID
-     * @return 生成的文件实例，如果创建失败则返回null
-     */
-    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) {
-            // 处理IO异常
-            e.printStackTrace();
-        }
-
-        return null;
-    }
-}
-
-

src/tool/DataUtils.java

@@ -1,450 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.tool;
-
-import android.content.ContentProviderOperation;
-import android.content.ContentProviderResult;
-import android.content.ContentResolver;
-import android.content.ContentUris;
-import android.content.ContentValues;
-import android.content.OperationApplicationException;
-import android.database.Cursor;
-import android.os.RemoteException;
-import android.util.Log;
-
-import net.micode.notes.data.Notes;
-import net.micode.notes.data.Notes.CallNote;
-import net.micode.notes.data.Notes.NoteColumns;
-import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-
-/**
- * 该类提供了一系列用于操作笔记数据的工具方法，
- * 涵盖了批量删除、移动笔记、查询文件夹和笔记信息等功能。
- */
-public class DataUtils {
-    // 日志标签，方便在日志中识别与该类相关的信息
-    public static final String TAG = "DataUtils";
-
-    /**
-     * 批量删除指定ID集合中的笔记
-     *
-     * @param resolver 内容解析器，用于与内容提供者交互
-     * @param ids 要删除的笔记ID集合
-     * @return 删除操作是否成功，若集合为空或操作成功返回true，失败返回false
-     */
-    public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
-        // 若传入的ID集合为null，打印日志并返回true
-        if (ids == null) {
-            Log.d(TAG, "the ids is null");
-            return true;
-        }
-        // 若ID集合为空，打印日志并返回true
-        if (ids.size() == 0) {
-            Log.d(TAG, "no id is in the hashset");
-            return true;
-        }
-
-        // 用于存储批量操作的列表
-        ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
-        // 遍历ID集合
-        for (long id : ids) {
-            // 若ID为根文件夹ID，打印错误日志并跳过此次循环
-            if (id == Notes.ID_ROOT_FOLDER) {
-                Log.e(TAG, "Don't delete system folder root");
-                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);
-            // 若操作结果为空或长度为0或第一个结果为空，打印日志并返回false
-            if (results == null || results.length == 0 || results[0] == null) {
-                Log.d(TAG, "delete notes failed, 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()));
-        }
-        return false;
-    }
-
-    /**
-     * 将指定ID的笔记移动到目标文件夹
-     *
-     * @param resolver 内容解析器
-     * @param id 要移动的笔记ID
-     * @param srcFolderId 笔记当前所在的文件夹ID
-     * @param desFolderId 目标文件夹ID
-     */
-    public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
-        // 用于存储要更新的键值对
-        ContentValues values = new ContentValues();
-        // 设置笔记的父文件夹ID为目标文件夹ID
-        values.put(NoteColumns.PARENT_ID, desFolderId);
-        // 设置笔记的原始父文件夹ID为源文件夹ID
-        values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
-        // 标记笔记为本地修改
-        values.put(NoteColumns.LOCAL_MODIFIED, 1);
-        // 执行更新操作
-        resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
-    }
-
-    /**
-     * 批量将指定ID集合中的笔记移动到目标文件夹
-     *
-     * @param resolver 内容解析器
-     * @param ids 要移动的笔记ID集合
-     * @param folderId 目标文件夹ID
-     * @return 移动操作是否成功
-     */
-    public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids, long folderId) {
-        // 若传入的ID集合为null，打印日志并返回true
-        if (ids == null) {
-            Log.d(TAG, "the ids is null");
-            return true;
-        }
-
-        // 用于存储批量操作的列表
-        ArrayList<ContentProviderOperation> operationList = new ArrayList<>();
-        // 遍历ID集合
-        for (long id : ids) {
-            // 创建一个更新操作的构建器
-            ContentProviderOperation.Builder builder = ContentProviderOperation
-                   .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
-            // 设置笔记的父文件夹ID为目标文件夹ID
-            builder.withValue(NoteColumns.PARENT_ID, folderId);
-            // 标记笔记为本地修改
-            builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
-            // 将构建好的操作添加到操作列表中
-            operationList.add(builder.build());
-        }
-
-        try {
-            // 批量执行操作
-            ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
-            // 若操作结果为空或长度为0或第一个结果为空，打印日志并返回false
-            if (results == null || results.length == 0 || results[0] == null) {
-                Log.d(TAG, "delete notes failed, 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()));
-        }
-        return false;
-    }
-
-    /**
-     * 获取用户创建的文件夹数量（排除系统文件夹）
-     *
-     * @param resolver 内容解析器
-     * @return 用户文件夹的数量
-     */
-    public static int getUserFolderCount(ContentResolver resolver) {
-        // 查询用户文件夹的数量
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
-                new String[]{"COUNT(*)"},
-                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
-                new String[]{String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)},
-                null);
-
-        int count = 0;
-        if (cursor != null) {
-            if (cursor.moveToFirst()) {
-                try {
-                    // 获取查询结果中的计数
-                    count = cursor.getInt(0);
-                } catch (IndexOutOfBoundsException e) {
-                    // 处理索引越界异常，打印错误日志
-                    Log.e(TAG, "get folder count failed:" + e.toString());
-                } finally {
-                    // 关闭游标
-                    cursor.close();
-                }
-            }
-        }
-        return count;
-    }
-
-    /**
-     * 检查指定笔记是否在数据库中可见
-     *
-     * @param resolver 内容解析器
-     * @param noteId 笔记ID
-     * @param type 笔记类型
-     * @return 笔记是否可见
-     */
-    public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
-        // 查询指定笔记是否存在且不在回收站
-        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
-                null,
-                NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
-                new String[]{String.valueOf(type)},
-                null);
-
-        boolean exist = false;
-        if (cursor != null) {
-            if (cursor.getCount() > 0) {
-                exist = true;
-            }
-            // 关闭游标
-            cursor.close();
-        }
-        return exist;
-    }
-
-    /**
-     * 检查指定笔记是否存在于数据库中
-     *
-     * @param resolver 内容解析器
-     * @param noteId 笔记ID
-     * @return 笔记是否存在
-     */
-    public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
-        // 查询指定笔记是否存在
-        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
-                null, null, null, null);
-
-        boolean exist = false;
-        if (cursor != null) {
-            if (cursor.getCount() > 0) {
-                exist = true;
-            }
-            // 关闭游标
-            cursor.close();
-        }
-        return exist;
-    }
-
-    /**
-     * 检查指定数据是否存在于数据库中
-     *
-     * @param resolver 内容解析器
-     * @param dataId 数据ID
-     * @return 数据是否存在
-     */
-    public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
-        // 查询指定数据是否存在
-        Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
-                null, null, null, null);
-
-        boolean exist = false;
-        if (cursor != null) {
-            if (cursor.getCount() > 0) {
-                exist = true;
-            }
-            // 关闭游标
-            cursor.close();
-        }
-        return exist;
-    }
-
-    /**
-     * 检查指定名称的可见文件夹是否存在于数据库中
-     *
-     * @param resolver 内容解析器
-     * @param name 文件夹名称
-     * @return 文件夹是否存在
-     */
-    public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
-        // 查询指定名称的可见文件夹是否存在
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
-                NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
-                        " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
-                        " AND " + NoteColumns.SNIPPET + "=?",
-                new String[]{name}, null);
-        boolean exist = false;
-        if (cursor != null) {
-            if (cursor.getCount() > 0) {
-                exist = true;
-            }
-            // 关闭游标
-            cursor.close();
-        }
-        return exist;
-    }
-
-    /**
-     * 获取指定文件夹下的笔记小部件属性集合
-     *
-     * @param resolver 内容解析器
-     * @param folderId 文件夹ID
-     * @return 笔记小部件属性集合
-     */
-    public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
-        // 查询指定文件夹下的笔记小部件信息
-        Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
-                new String[]{NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE},
-                NoteColumns.PARENT_ID + "=?",
-                new String[]{String.valueOf(folderId)},
-                null);
-
-        HashSet<AppWidgetAttribute> set = null;
-        if (c != null) {
-            if (c.moveToFirst()) {
-                set = new HashSet<>();
-                do {
-                    try {
-                        // 创建小部件属性对象
-                        AppWidgetAttribute widget = new AppWidgetAttribute();
-                        // 设置小部件ID
-                        widget.widgetId = c.getInt(0);
-                        // 设置小部件类型
-                        widget.widgetType = c.getInt(1);
-                        // 将小部件属性添加到集合中
-                        set.add(widget);
-                    } catch (IndexOutOfBoundsException e) {
-                        // 处理索引越界异常，打印错误日志
-                        Log.e(TAG, e.toString());
-                    }
-                } while (c.moveToNext());
-            }
-            // 关闭游标
-            c.close();
-        }
-        return set;
-    }
-
-    /**
-     * 根据笔记ID获取通话号码
-     *
-     * @param resolver 内容解析器
-     * @param noteId 笔记ID
-     * @return 通话号码，如果未找到则返回空字符串
-     */
-    public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
-        // 查询指定笔记ID对应的通话号码
-        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
-                new String[]{CallNote.PHONE_NUMBER},
-                CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
-                new String[]{String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE},
-                null);
-
-        if (cursor != null && cursor.moveToFirst()) {
-            try {
-                // 获取通话号码
-                return cursor.getString(0);
-            } catch (IndexOutOfBoundsException e) {
-                // 处理索引越界异常，打印错误日志
-                Log.e(TAG, "Get call number fails " + e.toString());
-            } finally {
-                // 关闭游标
-                cursor.close();
-            }
-        }
-        return "";
-    }
-
-    /**
-     * 根据电话号码和通话日期获取笔记ID
-     *
-     * @param resolver 内容解析器
-     * @param phoneNumber 电话号码
-     * @param callDate 通话日期
-     * @return 笔记ID，如果未找到则返回0
-     */
-    public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
-        // 查询指定电话号码和通话日期对应的笔记ID
-        Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
-                new String[]{CallNote.NOTE_ID},
-                CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
-                        + CallNote.PHONE_NUMBER + ",?)",
-                new String[]{String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber},
-                null);
-
-        if (cursor != null) {
-            if (cursor.moveToFirst()) {
-                try {
-                    // 获取笔记ID
-                    return cursor.getLong(0);
-                } catch (IndexOutOfBoundsException e) {
-                    // 处理索引越界异常，打印错误日志
-                    Log.e(TAG, "Get call note id fails " + e.toString());
-                }
-            }
-            // 关闭游标
-            cursor.close();
-        }
-        return 0;
-    }
-
-    /**
-     * 根据笔记ID获取笔记摘要
-     *
-     * @param resolver 内容解析器
-     * @param noteId 笔记ID
-     * @return 笔记摘要，如果未找到则抛出异常
-     */
-    public static String getSnippetById(ContentResolver resolver, long noteId) {
-        // 查询指定笔记ID对应的摘要
-        Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
-                new String[]{NoteColumns.SNIPPET},
-                NoteColumns.ID + "=?",
-                new String[]{String.valueOf(noteId)},
-                null);
-
-        if (cursor != null) {
-            String snippet = "";
-            if (cursor.moveToFirst()) {
-                // 获取笔记摘要
-                snippet = cursor.getString(0);
-            }
-            // 关闭游标
-            cursor.close();
-            return snippet;
-        }
-        // 若未找到笔记，抛出异常
-        throw new IllegalArgumentException("Note is not found with id: " + noteId);
-    }
-
-    /**
-     * 格式化笔记摘要，去除首尾空格并截取第一行
-     *
-     * @param snippet 原始笔记摘要
-     * @return 格式化后的笔记摘要
-     */
-    public static String getFormattedSnippet(String snippet) {
-        if (snippet != null) {
-            // 去除首尾空格
-            snippet = snippet.trim();
-            // 查找换行符位置
-            int index = snippet.indexOf('\n');
-            if (index != -1) {
-                // 截取第一行
-                snippet = snippet.substring(0, index);
-            }
-        }
-        return snippet;
-    }
-}

src/tool/GTaskStringUtils.java

@@ -1,163 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.tool;
-
-/**
- * 该类定义了一系列与 Google 任务（GTask）相关的 JSON 键名常量，
- * 同时包含一些特定文件夹名称、元数据头部信息等常量，
- * 用于在应用中处理 GTask 数据时保持键名的一致性和可维护性。
- */
-public class GTaskStringUtils {
-
-    // 表示操作 ID 的 JSON 键名
-    public final static String GTASK_JSON_ACTION_ID = "action_id";
-
-    // 表示操作列表的 JSON 键名
-    public final static String GTASK_JSON_ACTION_LIST = "action_list";
-
-    // 表示操作类型的 JSON 键名
-    public final static String GTASK_JSON_ACTION_TYPE = "action_type";
-
-    // 表示创建操作类型的 JSON 值
-    public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
-
-    // 表示获取所有数据操作类型的 JSON 值
-    public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
-
-    // 表示移动操作类型的 JSON 值
-    public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
-
-    // 表示更新操作类型的 JSON 值
-    public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
-
-    // 表示创建者 ID 的 JSON 键名
-    public final static String GTASK_JSON_CREATOR_ID = "creator_id";
-
-    // 表示子实体的 JSON 键名
-    public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
-
-    // 表示客户端版本的 JSON 键名
-    public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
-
-    // 表示任务是否完成的 JSON 键名
-    public final static String GTASK_JSON_COMPLETED = "completed";
-
-    // 表示当前列表 ID 的 JSON 键名
-    public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
-
-    // 表示默认列表 ID 的 JSON 键名
-    public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
-
-    // 表示任务是否已删除的 JSON 键名
-    public final static String GTASK_JSON_DELETED = "deleted";
-
-    // 表示目标列表的 JSON 键名
-    public final static String GTASK_JSON_DEST_LIST = "dest_list";
-
-    // 表示目标父级的 JSON 键名
-    public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
-
-    // 表示目标父级类型的 JSON 键名
-    public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
-
-    // 表示实体增量的 JSON 键名
-    public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
-
-    // 表示实体类型的 JSON 键名
-    public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
-
-    // 表示获取已删除数据的 JSON 键名
-    public final static String GTASK_JSON_GET_DELETED = "get_deleted";
-
-    // 表示 ID 的 JSON 键名
-    public final static String GTASK_JSON_ID = "id";
-
-    // 表示索引的 JSON 键名
-    public final static String GTASK_JSON_INDEX = "index";
-
-    // 表示最后修改时间的 JSON 键名
-    public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
-
-    // 表示最新同步点的 JSON 键名
-    public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
-
-    // 表示列表 ID 的 JSON 键名
-    public final static String GTASK_JSON_LIST_ID = "list_id";
-
-    // 表示列表集合的 JSON 键名
-    public final static String GTASK_JSON_LISTS = "lists";
-
-    // 表示名称的 JSON 键名
-    public final static String GTASK_JSON_NAME = "name";
-
-    // 表示新 ID 的 JSON 键名
-    public final static String GTASK_JSON_NEW_ID = "new_id";
-
-    // 表示备注的 JSON 键名
-    public final static String GTASK_JSON_NOTES = "notes";
-
-    // 表示父级 ID 的 JSON 键名
-    public final static String GTASK_JSON_PARENT_ID = "parent_id";
-
-    // 表示前一个兄弟节点 ID 的 JSON 键名
-    public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
-
-    // 表示操作结果的 JSON 键名
-    public final static String GTASK_JSON_RESULTS = "results";
-
-    // 表示源列表的 JSON 键名
-    public final static String GTASK_JSON_SOURCE_LIST = "source_list";
-
-    // 表示任务集合的 JSON 键名
-    public final static String GTASK_JSON_TASKS = "tasks";
-
-    // 表示类型的 JSON 键名
-    public final static String GTASK_JSON_TYPE = "type";
-
-    // 表示组类型的 JSON 值
-    public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
-
-    // 表示任务类型的 JSON 值
-    public final static String GTASK_JSON_TYPE_TASK = "TASK";
-
-    // 表示用户的 JSON 键名
-    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";
-
-    // 元数据头部中 Google 任务 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] DON'T UPDATE AND DELETE";
-}

src/tool/ResourceParser.java

@@ -1,284 +0,0 @@
-/*
- * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *        http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package net.micode.notes.tool;
-
-import android.content.Context;
-import android.preference.PreferenceManager;
-
-import net.micode.notes.R;
-import net.micode.notes.ui.NotesPreferenceActivity;
-
-/**
- * 资源解析器类，负责管理和解析与笔记相关的各种资源，
- * 如背景颜色、字体大小、背景图片资源等，为应用提供统一的资源获取方式。
- */
-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
-        };
-
-        /**
-         * 根据颜色 ID 获取笔记编辑界面的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的背景资源 ID
-         */
-        public static int getNoteBgResource(int id) {
-            return BG_EDIT_RESOURCES[id];
-        }
-
-        /**
-         * 根据颜色 ID 获取笔记编辑界面标题的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的标题背景资源 ID
-         */
-        public static int getNoteTitleBgResource(int id) {
-            return BG_EDIT_TITLE_RESOURCES[id];
-        }
-    }
-
-    /**
-     * 获取默认的笔记背景颜色 ID
-     *
-     * @param context 应用上下文
-     * @return 默认的背景颜色 ID
-     */
-    public static int getDefaultBgId(Context context) {
-        // 检查是否开启了随机背景颜色的偏好设置
-        if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
-                NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
-            // 如果开启，则随机返回一个背景颜色 ID
-            return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
-        } else {
-            // 如果未开启，则返回默认的背景颜色 ID
-            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
-        };
-
-        /**
-         * 根据颜色 ID 获取笔记列表首项的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的首项背景资源 ID
-         */
-        public static int getNoteBgFirstRes(int id) {
-            return BG_FIRST_RESOURCES[id];
-        }
-
-        /**
-         * 根据颜色 ID 获取笔记列表末项的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的末项背景资源 ID
-         */
-        public static int getNoteBgLastRes(int id) {
-            return BG_LAST_RESOURCES[id];
-        }
-
-        /**
-         * 根据颜色 ID 获取笔记列表单项的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的单项背景资源 ID
-         */
-        public static int getNoteBgSingleRes(int id) {
-            return BG_SINGLE_RESOURCES[id];
-        }
-
-        /**
-         * 根据颜色 ID 获取笔记列表普通项的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的普通项背景资源 ID
-         */
-        public static int getNoteBgNormalRes(int id) {
-            return BG_NORMAL_RESOURCES[id];
-        }
-
-        /**
-         * 获取文件夹的背景资源 ID
-         *
-         * @return 文件夹背景资源 ID
-         */
-        public static int getFolderBgRes() {
-            return R.drawable.list_folder;
-        }
-    }
-
-    /**
-     * 小部件背景资源管理类，负责管理和提供不同尺寸（2x 和 4x）小部件的背景资源。
-     */
-    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,
-        };
-
-        /**
-         * 根据颜色 ID 获取 2x 尺寸小部件的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的 2x 小部件背景资源 ID
-         */
-        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
-        };
-
-        /**
-         * 根据颜色 ID 获取 4x 尺寸小部件的背景资源 ID
-         *
-         * @param id 颜色对应的 ID，取值范围为 0 - 4
-         * @return 对应的 4x 小部件背景资源 ID
-         */
-        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 获取对应的文本外观资源 ID
-         *
-         * @param id 字体大小对应的 ID，取值范围为 0 - 3
-         * @return 对应的文本外观资源 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}
-             */
-            // 防止传入的 ID 超出资源数组的范围，如果超出则返回默认字体大小对应的资源 ID
-            if (id >= TEXTAPPEARANCE_RESOURCES.length) {
-                return BG_DEFAULT_FONT_SIZE;
-            }
-            return TEXTAPPEARANCE_RESOURCES[id];
-        }
-
-        /**
-         * 获取文本外观资源数组的长度
-         *
-         * @return 资源数组的长度
-         */
-        public static int getResourcesSize() {
-            return TEXTAPPEARANCE_RESOURCES.length;
-        }
-    }
-}