();
+ }
+
+ // 如果缓存中已经存在该电话号码的联系人名，直接返回
+ 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,
+ 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, " Cursor get string error " + e.toString());
+ return null;
+ } finally {
+ // 关闭cursor，释放资源
+ cursor.close();
+ }
+ } else {
+ // 如果没有找到匹配的联系人，记录日志
+ Log.d(TAG, "No contact matched with number:" + phoneNumber);
+ return null;
+ }
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/data/Notes.java b/src/Notes-master/src/net/micode/notes/data/Notes.java
new file mode 100644
index 0000000..56518a5
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/data/Notes.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * 依据 Apache 许可证第2.0版（“许可证”）授权；
+ * 您不得在未遵守许可证的情况下使用本文件。
+ * 您可以在以下网址获取许可证副本：
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 除非适用法律要求或书面同意，依据许可证分发的软件
+ * 是按照 "按原样" 基础提供的，
+ * 不提供任何形式的保证或条件，无论明确或隐含。
+ * 请参阅许可证以获取特定语言涉及的权限和限制。
+ */
+
+package net.micode.notes.data;
+
+import android.net.Uri;
+
+public class Notes {
+ // 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; // 系统类型
+
+ /**
+ * 以下 IDs 是系统文件夹的标识符
+ * {@link Notes#ID_ROOT_FOLDER } 是默认文件夹
+ * {@link Notes#ID_TEMPARAY_FOLDER } 是放置无文件夹笔记的临时文件夹
+ * {@link Notes#ID_CALL_RECORD_FOLDER} 是存储通话记录的文件夹
+ */
+ public static final int ID_ROOT_FOLDER = 0; // 根文件夹
+ public static final int ID_TEMPARAY_FOLDER = -1; // 临时文件夹
+ public static final int ID_CALL_RECORD_FOLDER = -2; // 通话记录文件夹
+ public static final int ID_TRASH_FOLER = -3; // 垃圾箱文件夹
+
+ // Intent Extra Strings
+ public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date"; // 提醒日期
+ 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"; // 小部件ID
+ public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; // 小部件类型
+ public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; // 文件夹ID
+ public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; // 通话日期
+
+ // 小部件类型
+ public static final int TYPE_WIDGET_INVALIDE = -1; // 无效的小部件类型
+ public static final int TYPE_WIDGET_2X = 0; // 2x小部件类型
+ public static final int TYPE_WIDGET_4X = 1; // 4x小部件类型
+
+ public static class DataConstants {
+ public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; // 笔记内容类型
+ public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; // 通话记录内容类型
+ }
+
+ /**
+ * 查询所有笔记和文件夹的 URI
+ */
+ public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
+
+ /**
+ * 查询数据的 URI
+ */
+ public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+
+ public interface NoteColumns {
+ /**
+ * 行的独特 ID
+ * 类型: INTEGER (long)
+ */
+ public static final String ID = "_id";
+
+ /**
+ * 笔记或文件夹的父 ID
+ * 类型: INTEGER (long)
+ */
+ public static final String PARENT_ID = "parent_id";
+
+ /**
+ * 创建日期用于笔记或文件夹
+ * 类型: INTEGER (long)
+ */
+ public static final String CREATED_DATE = "created_date";
+
+ /**
+ * 最新修改日期
+ * 类型: INTEGER (long)
+ */
+ public static final String MODIFIED_DATE = "modified_date";
+
+ /**
+ * 提醒日期
+ * 类型: INTEGER (long)
+ */
+ public static final String ALERTED_DATE = "alert_date";
+
+ /**
+ * 文件夹的名称或笔记的文本内容
+ * 类型: TEXT
+ */
+ public static final String SNIPPET = "snippet";
+
+ /**
+ * 笔记的小部件 ID
+ * 类型: INTEGER (long)
+ */
+ public static final String WIDGET_ID = "widget_id";
+
+ /**
+ * 笔记的小部件类型
+ * 类型: INTEGER (long)
+ */
+ public static final String WIDGET_TYPE = "widget_type";
+
+ /**
+ * 笔记的背景颜色的 ID
+ * 类型: INTEGER (long)
+ */
+ public static final String BG_COLOR_ID = "bg_color_id";
+
+ /**
+ * 对于文本笔记，没有附件；对于多媒体笔记，至少有一个附件
+ * 类型: INTEGER
+ */
+ public static final String HAS_ATTACHMENT = "has_attachment";
+
+ /**
+ * 文件夹中笔记的数量
+ * 类型: INTEGER (long)
+ */
+ public static final String NOTES_COUNT = "notes_count";
+
+ /**
+ * 文件类型：文件夹或笔记
+ * 类型: INTEGER
+ */
+ public static final String TYPE = "type";
+
+ /**
+ * 最后同步 ID
+ * 类型: INTEGER (long)
+ */
+ public static final String SYNC_ID = "sync_id";
+
+ /**
+ * 标记以指示本地是否已修改
+ * 类型: INTEGER
+ */
+ public static final String LOCAL_MODIFIED = "local_modified";
+
+ /**
+ * 移动到临时文件夹之前的原始父 ID
+ * 类型 : INTEGER
+ */
+ public static final String ORIGIN_PARENT_ID = "origin_parent_id";
+
+ /**
+ * gtask ID
+ * 类型 : TEXT
+ */
+ public static final String GTASK_ID = "gtask_id";
+
+ /**
+ * 版本代码
+ * 类型 : INTEGER (long)
+ */
+ public static final String VERSION = "version";
+ }
+
+ public interface DataColumns {
+ /**
+ * 行的独特 ID
+ * 类型: INTEGER (long)
+ */
+ public static final String ID = "_id";
+
+ /**
+ * 此行所表示项目的 MIME 类型。
+ * 类型: Text
+ */
+ public static final String MIME_TYPE = "mime_type";
+
+ /**
+ * 该数据所属笔记的参考 ID
+ * 类型: INTEGER (long)
+ */
+ public static final String NOTE_ID = "note_id";
+
+ /**
+ * 创建日期用于笔记或文件夹
+ * 类型: INTEGER (long)
+ */
+ public static final String CREATED_DATE = "created_date";
+
+ /**
+ * 最新修改日期
+ * 类型: INTEGER (long)
+ */
+ public static final String MODIFIED_DATE = "modified_date";
+
+ /**
+ * 数据内容
+ * 类型: TEXT
+ */
+ public static final String CONTENT = "content";
+
+ /**
+ * 通用数据列，具体含义取决于 {@link #MIMETYPE}，用于
+ * 整数数据类型
+ * 类型: INTEGER
+ */
+ public static final String DATA1 = "data1";
+
+ /**
+ * 通用数据列，具体含义取决于 {@link #MIMETYPE}，用于
+ * 整数数据类型
+ * 类型: INTEGER
+ */
+ public static final String DATA2 = "data2";
+
+ /**
+ * 通用数据列，具体含义取决于 {@link #MIMETYPE}，用于
+ * TEXT 数据类型
+ * 类型: TEXT
+ */
+ public static final String DATA3 = "data3";
+
+ /**
+ * 通用数据列，具体含义取决于 {@link #MIMETYPE}，用于
+ * TEXT 数据类型
+ * 类型: TEXT
+ */
+ public static final String DATA4 = "data4";
+
+ /**
+ * 通用数据列，具体含义取决于 {@link #MIMETYPE}，用于
+ * TEXT 数据类型
+ * 类型: TEXT
+ */
+ public static final String DATA5 = "data5";
+ }
+
+ public static final class TextNote implements DataColumns {
+ /**
+ * 指示文本处于检查列表模式还是普通模式
+ * 类型: Integer 1:检查列表模式 0:普通模式
+ */
+ 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"; // 单个笔记项内容类型
+
+ public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note"); // 笔记的内容URI
+ }
+
+ public static final class CallNote implements DataColumns {
+ /**
+ * 此记录的通话日期
+ * 类型: INTEGER (long)
+ */
+ public static final String CALL_DATE = DATA1;
+
+ /**
+ * 此记录的电话号码
+ * 类型: TEXT
+ */
+ 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"; // 单个通话记录项内容类型
+
+ public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note"); // 通话记录的内容URI
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java b/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
new file mode 100644
index 0000000..6057f34
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * 本文件采用Apache 2.0许可协议进行许可。
+ * 未经许可，您不得使用本文件。您可以在以下地址获取许可证：
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 除非适用法律另有规定或书面协议另有约定，否则根据许可证分发的软件是按"原样"提供的，
+ * 不附带任何明示或暗示的担保或条件。有关许可证下的特定语言条款和限制，请参阅许可证。
+ */
+
+// 指定包名
+package net.micode.notes.data;
+
+// 导入必要的类
+import android.content.ContentValues; // 用于数据库内容的存储
+import android.content.Context; // 上下文类
+import android.database.sqlite.SQLiteDatabase; // SQLite数据库类
+import android.database.sqlite.SQLiteOpenHelper; // SQLite数据库帮助类
+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; // 笔记列模型
+
+// 创建NotesDatabaseHelper类，继承自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 + "(" +
+ NoteColumns.ID + " INTEGER PRIMARY KEY," + // 笔记ID，主键
+ NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 父级ID
+ NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," + // 提醒日期
+ NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," + // 背景颜色ID
+ NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 创建日期
+ NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," + // 是否有附件
+ NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 修改日期
+ NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," + // 笔记数量
+ NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," + // 笔记摘要
+ NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," + // 笔记类型
+ NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," + // 小部件ID
+ NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," + // 小部件类型
+ NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," + // 同步ID
+ NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," + // 本地修改标志
+ NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 原始父级ID
+ NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," + // GTASK ID
+ NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + // 版本号
+ ")";
+
+ // 创建数据表的SQL语句
+ private static final String CREATE_DATA_TABLE_SQL =
+ "CREATE TABLE " + TABLE.DATA + "(" +
+ DataColumns.ID + " INTEGER PRIMARY KEY," + // 数据ID，主键
+ DataColumns.MIME_TYPE + " TEXT NOT NULL," + // MIME类型
+ DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," + // 关联的笔记ID
+ 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 ''," + // 内容
+ DataColumns.DATA1 + " INTEGER," + // 数据字段1
+ DataColumns.DATA2 + " INTEGER," + // 数据字段2
+ DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," + // 数据字段3
+ DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," + // 数据字段4
+ DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + // 数据字段5
+ ")";
+
+ // 创建数据表中NOTE_ID字段的索引
+ private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
+ "CREATE INDEX IF NOT EXISTS note_id_index ON " +
+ TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
+
+ // 当更新笔记时增加文件夹的笔记计数的触发器
+ 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";
+
+ // 当从文件夹中移动笔记时减少文件夹的笔记计数的触发器
+ 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";
+
+ // 当在文件夹中插入新笔记时增加文件夹的笔记计数的触发器
+ 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";
+
+ // 当从文件夹中删除笔记时减少文件夹的笔记计数的触发器
+ 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";
+
+ // 在插入类型为NOTE的数据时更新笔记内容的触发器
+ 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";
+
+ // 当类型为NOTE的数据发生变化时更新笔记内容的触发器
+ 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";
+
+ // 当类型为NOTE的数据被删除时更新笔记内容的触发器
+ 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";
+
+ // 删除已删除笔记的所有数据的触发器
+ 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";
+
+ // 删除已删除文件夹中的笔记的触发器
+ 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";
+
+ // 当文件夹被移动到垃圾桶时移动文件夹中的笔记的触发器
+ 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";
+
+ // 构造函数，接受上下文参数
+ public NotesDatabaseHelper(Context context) {
+ super(context, DB_NAME, null, DB_VERSION); // 调用父类构造函数
+ }
+
+ // 创建笔记表
+ public void createNoteTable(SQLiteDatabase db) {
+ db.execSQL(CREATE_NOTE_TABLE_SQL); // 执行创建表的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);
+ }
+
+ // 创建系统文件夹
+ 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); // 插入记录
+ }
+
+ // 创建数据表
+ public void createDataTable(SQLiteDatabase db) {
+ db.execSQL(CREATE_DATA_TABLE_SQL); // 执行创建表的SQL语句
+ reCreateDataTableTriggers(db); // 重新创建触发器
+ db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); // 创建索引
+ Log.d(TAG, "data table has been created"); // 日志输出
+ }
+
+ // 重新创建数据表的所有触发器
+ private void reCreateDataTableTriggers(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert"); // 删除触发器
+ db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update"); // 删除触发器
+ db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete"); // 删除触发器
+
+ // 创建新的触发器
+ db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
+ db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
+ db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
+ }
+
+ // 获取NotesDatabaseHelper的单例实例
+ 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; // 重创建触发器的标志
+ boolean skipV2 = false; // 跳过V2的标志
+
+ if (oldVersion == 1) { // 如果旧版本是1
+ upgradeToV2(db); // 升级到V2
+ skipV2 = true; // 跳过V2的标志设为true
+ oldVersion++; // 增加版本号
+ }
+
+ if (oldVersion == 2 && !skipV2) { // 如果旧版本是2且没有跳过
+ upgradeToV3(db); // 升级到V3
+ reCreateTriggers = true; // 设置重创建触发器的标志为true
+ oldVersion++; // 增加版本号
+ }
+
+ if (oldVersion == 3) { // 如果旧版本是3
+ upgradeToV4(db); // 升级到V4
+ oldVersion++; // 增加版本号
+ }
+
+ if (reCreateTriggers) { // 如果需要重创建触发器
+ reCreateNoteTableTriggers(db); // 重新创建笔记表的触发器
+ reCreateDataTableTriggers(db); // 重新创建数据表的触发器
+ }
+
+ if (oldVersion != newVersion) { // 如果版本不一致，则抛出异常
+ throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ + " fails");
+ }
+ }
+
+ // 升级到V2
+ 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); // 创建数据表
+ }
+
+ // 升级到V3
+ 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");
+ // 为笔记添加一个新的字符ID列
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ + " TEXT NOT NULL DEFAULT ''");
+ // 添加一个垃圾桶系统文件夹
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+ values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+ db.insert(TABLE.NOTE, null, values); // 插入记录
+ }
+
+ // 升级到V4
+ private void upgradeToV4(SQLiteDatabase db) {
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ + " INTEGER NOT NULL DEFAULT 0"); // 为笔记表添加版本列
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/data/NotesProvider.java b/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
new file mode 100644
index 0000000..23a981f
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/data/NotesProvider.java
@@ -0,0 +1,351 @@
+/*
+ * 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;
+
+// 导入需要的Android和本地类
+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;
+
+/**
+ * NotesProvider 类继承自 ContentProvider，
+ * 负责与外部交互以进行笔记数据的增删改查操作。
+ */
+public class NotesProvider extends ContentProvider {
+ // UriMatcher，用于匹配不同的URI请求
+ 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; // 搜索建议 URI
+
+ // 静态代码块，初始化 URI 匹配器并添加各种 URI 匹配规则
+ static {
+ mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+ 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); // 带参数的搜索建议 URI
+ }
+
+ /**
+ * 在搜索结果中，x'0A' 代表换行符。为了更好地展示信息，
+ * 我们将搜索结果中的标题和内容进行修剪以去除换行符和空格。
+ */
+ private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + "," // 笔记 ID
+ + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + "," // 笔记 ID 作为意图额外数据
+ + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + "," // 修剪后的内容作为建议文本1
+ + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + "," // 修剪后的内容作为建议文本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; // 笔记内容类型
+
+ // 搜索笔记的 SQL 查询语句
+ 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; // 仅匹配笔记类型
+
+ @Override
+ public boolean onCreate() {
+ // 初始化数据库助手
+ mHelper = NotesDatabaseHelper.getInstance(getContext());
+ return true; // 创建成功
+ }
+
+ @Override
+ public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
+ String sortOrder) {
+ // 查询方法，处理不同的URI请求并返回结果的Cursor
+ Cursor c = null;
+ SQLiteDatabase db = mHelper.getReadableDatabase(); // 获取可读数据库
+ String id = null; // 用于存储ID
+
+ switch (mMatcher.match(uri)) { // 根据URI匹配不同的查询类型
+ case URI_NOTE:
+ // 查询所有笔记
+ c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, sortOrder);
+ break;
+ case URI_NOTE_ITEM:
+ // 查询单个笔记
+ id = uri.getPathSegments().get(1); // 从URI中获取笔记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:
+ // 查询单个数据
+ id = uri.getPathSegments().get(1); // 从URI中获取数据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;
+ if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
+ // 获取搜索建议的参数
+ if (uri.getPathSegments().size() > 1) {
+ searchString = uri.getPathSegments().get(1);
+ }
+ } else {
+ // 从查询参数获取搜索字符串
+ searchString = uri.getQueryParameter("pattern");
+ }
+
+ if (TextUtils.isEmpty(searchString)) {
+ return null; // 如果搜索字符串为空，则返回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);
+ }
+
+ if (c != null) {
+ // 设置通知URI，数据变化时通知的URI
+ c.setNotificationUri(getContext().getContentResolver(), uri);
+ }
+ return c; // 返回查询结果
+ }
+
+ @Override
+ public Uri insert(Uri uri, ContentValues values) {
+ // 插入数据方法
+ SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
+ long dataId = 0, noteId = 0, insertedId = 0; // 初始化ID
+
+ switch (mMatcher.match(uri)) { // 根据URI匹配不同的插入类型
+ case URI_NOTE:
+ // 插入新的笔记
+ insertedId = noteId = db.insert(TABLE.NOTE, null, values);
+ break;
+ case URI_DATA:
+ // 插入新的数据
+ 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()); // 记录错误日志
+ }
+ insertedId = dataId = db.insert(TABLE.DATA, null, values);
+ break;
+ default:
+ // 未知的URI，抛出异常
+ throw new IllegalArgumentException("Unknown URI " + uri);
+ }
+
+ // 当笔记插入成功时，通知笔记URI
+ if (noteId > 0) {
+ getContext().getContentResolver().notifyChange(
+ ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
+ }
+
+ // 当数据插入成功时，通知数据URI
+ if (dataId > 0) {
+ getContext().getContentResolver().notifyChange(
+ ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
+ }
+
+ return ContentUris.withAppendedId(uri, insertedId); // 返回新插入项的URI
+ }
+
+ @Override
+ public int delete(Uri uri, String selection, String[] selectionArgs) {
+ // 删除数据方法
+ int count = 0; // 计数删除的行数
+ String id = null; // 用于存储ID
+ SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
+ boolean deleteData = false; // 标记是否删除数据
+
+ switch (mMatcher.match(uri)) { // 根据URI匹配不同的删除类型
+ case URI_NOTE:
+ // 删除所有笔记
+ selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; // 除去系统文件夹
+ count = db.delete(TABLE.NOTE, selection, selectionArgs);
+ break;
+ case URI_NOTE_ITEM:
+ // 删除单个笔记
+ id = uri.getPathSegments().get(1); // 从URI中获取笔记ID
+ long noteId = Long.valueOf(id);
+ if (noteId <= 0) {
+ break; // 系统文件夹不允许删除
+ }
+ 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:
+ // 删除单个数据
+ id = uri.getPathSegments().get(1); // 从URI中获取数据ID
+ count = db.delete(TABLE.DATA,
+ DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
+ deleteData = true; // 标记为删除数据
+ break;
+ default:
+ // 未知的URI，抛出异常
+ throw new IllegalArgumentException("Unknown URI " + uri);
+ }
+
+ if (count > 0) {
+ if (deleteData) {
+ // 如果删除了数据，通知笔记URI
+ 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; // 计数更新的行数
+ String id = null; // 用于存储ID
+ SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
+ boolean updateData = false; // 标记是否更新数据
+
+ switch (mMatcher.match(uri)) { // 根据URI匹配不同的更新类型
+ case URI_NOTE:
+ // 更新所有笔记
+ increaseNoteVersion(-1, selection, selectionArgs); // 更新版本
+ count = db.update(TABLE.NOTE, values, selection, selectionArgs);
+ break;
+ case URI_NOTE_ITEM:
+ // 更新单个笔记
+ id = uri.getPathSegments().get(1); // 从URI中获取笔记ID
+ increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); // 更新版本
+ 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:
+ // 更新单个数据
+ id = uri.getPathSegments().get(1); // 从URI中获取数据ID
+ count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+ + parseSelection(selection), selectionArgs);
+ updateData = true; // 标记为更新数据
+ break;
+ default:
+ // 未知的URI，抛出异常
+ throw new IllegalArgumentException("Unknown URI " + uri);
+ }
+
+ if (count > 0) {
+ if (updateData) {
+ // 如果更新了数据，通知笔记URI
+ 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 + ')' : ""); // 如果选择条件不为空则添加 AND
+ }
+
+ // 辅助方法，用于增加笔记版本
+ private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
+ StringBuilder sql = new StringBuilder(120);
+ sql.append("UPDATE ");
+ sql.append(TABLE.NOTE);
+ sql.append(" SET ");
+ sql.append(NoteColumns.VERSION);
+ sql.append("=" + NoteColumns.VERSION + "+1 "); // 增加版本号
+
+ if (id > 0 || !TextUtils.isEmpty(selection)) {
+ sql.append(" WHERE "); // 如果有ID或选择条件，添加WHERE
+ }
+ if (id > 0) {
+ sql.append(NoteColumns.ID + "=" + String.valueOf(id)); // 添加ID条件
+ }
+ if (!TextUtils.isEmpty(selection)) {
+ // 处理选择参数
+ String selectString = id > 0 ? parseSelection(selection) : selection;
+ for (String args : selectionArgs) {
+ selectString = selectString.replaceFirst("\\?", args); // 替换占位符
+ }
+ sql.append(selectString);
+ }
+
+ mHelper.getWritableDatabase().execSQL(sql.toString()); // 执行SQL更新版本号
+ }
+
+ @Override
+ public String getType(Uri uri) {
+ // 返回特定URI的MIME类型，这里暂时不实现
+ return null;
+ }
+
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java b/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
new file mode 100644
index 0000000..6225cb0
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * 该文件属于Apache License, Version 2.0（“许可证”）下的版权作品；
+ * 你不能以不符合许可证的方式使用此文件。
+ * 你可以在以下网址获取许可证副本：
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 除非适用法律要求或书面同意，软件
+ * 根据许可证分发是在“原样”基础上进行的，
+ * 不提供任何形式的保证或条件，无论是明示或暗示的。
+ * 查看许可证以获取有关权限和
+ * 限制的具体信息。
+ */
+
+package net.micode.notes.gtask.data; // 定义该类的位置
+
+import android.database.Cursor; // 导入Android的Cursor类，用于数据库操作
+import android.util.Log; // 导入Android的Log类，用于日志输出
+
+import net.micode.notes.tool.GTaskStringUtils; // 导入自定义工具类，用于字符串处理
+
+import org.json.JSONException; // 导入JSON异常处理类
+import org.json.JSONObject; // 导入JSON对象类
+
+// MetaData类继承自Task类，表示元数据的管理类
+public class MetaData extends Task {
+ private final static String TAG = MetaData.class.getSimpleName(); // 获取当前类名作为日志标签
+
+ private String mRelatedGid = null; // 声明一个私有属性，用于存储相关的GID
+
+ // 设置元数据的方法，接收GID和JSON对象作为参数
+ public void setMeta(String gid, JSONObject metaInfo) {
+ try {
+ // 将GID放入metadata信息中
+ metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+ } catch (JSONException e) {
+ // 捕获JSON异常并记录错误
+ Log.e(TAG, "failed to put related gid");
+ }
+ // 设置笔记内容为JSON对象的字符串表示
+ setNotes(metaInfo.toString());
+ // 设置名称为常量名称
+ setName(GTaskStringUtils.META_NOTE_NAME);
+ }
+
+ // 获取相关GID的方法
+ public String getRelatedGid() {
+ return mRelatedGid; // 返回相关GID
+ }
+
+ // 重写isWorthSaving方法，判断是否值得保存
+ @Override
+ public boolean isWorthSaving() {
+ return getNotes() != null; // 如果笔记内容不为空，则值得保存
+ }
+
+ // 重写通过远程JSON设置内容的方法
+ @Override
+ public void setContentByRemoteJSON(JSONObject js) {
+ super.setContentByRemoteJSON(js); // 调用父类的方法
+ if (getNotes() != null) { // 如果笔记内容不为空
+ try {
+ // 将笔记内容转换为JSON对象
+ JSONObject metaInfo = new JSONObject(getNotes().trim());
+ // 获取相关GID并保存
+ mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+ } catch (JSONException e) {
+ // 捕获JSON异常并记录警告
+ Log.w(TAG, "failed to get related gid");
+ mRelatedGid = null; // 将相关GID设置为null
+ }
+ }
+ }
+
+ // 重写通过本地JSON设置内容的方法，该方法不应被调用
+ @Override
+ public void setContentByLocalJSON(JSONObject js) {
+ throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); // 抛出异常，指明不应调用
+ }
+
+ // 重写从内容获取本地JSON的方法，该方法不应被调用
+ @Override
+ public JSONObject getLocalJSONFromContent() {
+ throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); // 抛出异常，指明不应调用
+ }
+
+ // 重写获取同步操作的方法，该方法不应被调用
+ @Override
+ public int getSyncAction(Cursor c) {
+ throw new IllegalAccessError("MetaData:getSyncAction should not be called"); // 抛出异常，指明不应调用
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/Node.java b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
new file mode 100644
index 0000000..a520edc
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Node.java
@@ -0,0 +1,108 @@
+/*
+ * 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.gtask.data;
+
+// 导入必要的类
+import android.database.Cursor;
+import org.json.JSONObject;
+
+// 抽象类 Node，表示一个数据节点的基本结构
+public abstract class Node {
+ // 定义同步操作的常量
+ public static final int SYNC_ACTION_NONE = 0; // 无操作
+ public static final int SYNC_ACTION_ADD_REMOTE = 1; // 从远程添加
+ public static final int SYNC_ACTION_ADD_LOCAL = 2; // 从本地添加
+ public static final int SYNC_ACTION_DEL_REMOTE = 3; // 从远程删除
+ public static final int SYNC_ACTION_DEL_LOCAL = 4; // 从本地删除
+ public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 从远程更新
+ public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 从本地更新
+ public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突
+ public static final int SYNC_ACTION_ERROR = 8; // 错误操作
+
+ // 定义节点的属性
+ private String mGid; // 唯一标识符
+ private String mName; // 节点名称
+ private long mLastModified; // 最后修改时间
+ private boolean mDeleted; // 是否删除标记
+
+ // 构造函数，初始化节点属性
+ public Node() {
+ mGid = null; // 初始化 Gid 为 null
+ mName = ""; // 初始化名称为空字符串
+ mLastModified = 0; // 初始化最后修改时间为 0
+ mDeleted = false; // 初始化删除状态为 false
+ }
+
+ // 抽象方法，获取创建操作的 JSON 对象
+ public abstract JSONObject getCreateAction(int actionId);
+
+ // 抽象方法，获取更新操作的 JSON 对象
+ public abstract JSONObject getUpdateAction(int actionId);
+
+ // 抽象方法，通过远程 JSON 设置内容
+ public abstract void setContentByRemoteJSON(JSONObject js);
+
+ // 抽象方法，通过本地 JSON 设置内容
+ public abstract void setContentByLocalJSON(JSONObject js);
+
+ // 抽象方法，从内容获取本地 JSON
+ public abstract JSONObject getLocalJSONFromContent();
+
+ // 抽象方法，从 Cursor 获取同步操作类型
+ public abstract int getSyncAction(Cursor c);
+
+ // 设置 Gid
+ public void setGid(String gid) {
+ this.mGid = gid;
+ }
+
+ // 设置名称
+ public void setName(String name) {
+ this.mName = name;
+ }
+
+ // 设置最后修改时间
+ public void setLastModified(long lastModified) {
+ this.mLastModified = lastModified;
+ }
+
+ // 设置删除状态
+ public void setDeleted(boolean deleted) {
+ this.mDeleted = deleted;
+ }
+
+ // 获取 Gid
+ public String getGid() {
+ return this.mGid;
+ }
+
+ // 获取名称
+ public String getName() {
+ return this.mName;
+ }
+
+ // 获取最后修改时间
+ public long getLastModified() {
+ return this.mLastModified;
+ }
+
+ // 获取删除状态
+ public boolean getDeleted() {
+ return this.mDeleted;
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java b/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
new file mode 100644
index 0000000..88e1fe8
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
@@ -0,0 +1,186 @@
+/*
+ * 版权所有 (c) 2010-2011 MiCode 开源社区 (www.micode.net)
+ *
+ * 根据 Apache 许可证第 2.0 版（“许可证”）授权；
+ * 您不得在未遵守许可证的情况下使用此文件。
+ * 您可以在以下网址获得许可证的副本：
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 除非适用法律要求或书面同意，否则根据许可证分发的软件
+ * 是在“按原样”基础上分发的，不附带任何明示或暗示的担保或条件。
+ * 有关许可证下权限和限制的具体语言，请参阅许可证。
+ */
+
+package net.micode.notes.gtask.data; // 定义包名
+
+import android.content.ContentResolver; // 导入ContentResolver类，用于管理内容提供者的操作
+import android.content.ContentUris; // 导入ContentUris类，用于构造内容URI
+import android.content.ContentValues; // 导入ContentValues类，用于存储行的列值
+import android.content.Context; // 导入Context类，表示应用环境
+import android.database.Cursor; // 导入Cursor类，用于访问数据库查询结果
+import android.net.Uri; // 导入Uri类，用于表示内容的URI
+import android.util.Log; // 导入Log类，用于记录调试信息
+
+import net.micode.notes.data.Notes; // 导入Notes类，表示笔记相关的数据结构
+import net.micode.notes.data.Notes.DataColumns; // 导入数据列常量
+import net.micode.notes.data.Notes.DataConstants; // 导入数据常量
+import net.micode.notes.data.Notes.NoteColumns; // 导入笔记列常量
+import net.micode.notes.data.NotesDatabaseHelper.TABLE; // 导入数据库表名常量
+import net.micode.notes.gtask.exception.ActionFailureException; // 导入自定义异常类
+
+import org.json.JSONException; // 导入JSONException类，用于处理JSON异常
+import org.json.JSONObject; // 导入JSONObject类，表示一个JSON对象
+
+
+public class SqlData { // 定义SqlData类
+ private static final String TAG = SqlData.class.getSimpleName(); // 定义日志标签
+
+ private static final int INVALID_ID = -99999; // 定义无效ID常量
+
+ // 定义数据投影数组，包含要查询的列
+ public static final String[] PROJECTION_DATA = new String[] {
+ DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
+ DataColumns.DATA3
+ };
+
+ // 列索引常量
+ public static final int DATA_ID_COLUMN = 0;
+ public static final int DATA_MIME_TYPE_COLUMN = 1;
+ public static final int DATA_CONTENT_COLUMN = 2;
+ public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+ public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
+
+ private ContentResolver mContentResolver; // 内容解析器实例
+ private boolean mIsCreate; // 标记是否为创建状态
+ private long mDataId; // 数据ID
+ private String mDataMimeType; // 数据MIME类型
+ private String mDataContent; // 数据内容
+ private long mDataContentData1; // 数据内容的第一个额外字段
+ private String mDataContentData3; // 数据内容的第三个额外字段
+ private ContentValues mDiffDataValues; // 存储变化的数据值
+
+ // 构造函数，用于创建新的SqlData实例
+ public SqlData(Context context) {
+ mContentResolver = context.getContentResolver(); // 获取内容解析器
+ mIsCreate = true; // 设置为创建状态
+ mDataId = INVALID_ID; // 初始化ID为无效值
+ mDataMimeType = DataConstants.NOTE; // 默认MIME类型为笔记
+ mDataContent = ""; // 初始化内容为空
+ mDataContentData1 = 0; // 第一个数据字段初始化为0
+ mDataContentData3 = ""; // 第三个数据字段初始化为空
+ mDiffDataValues = new ContentValues(); // 创建内容值实例
+ }
+
+ // 构造函数，用于从游标中加载SqlData实例
+ public SqlData(Context context, Cursor c) {
+ mContentResolver = context.getContentResolver(); // 获取内容解析器
+ mIsCreate = false; // 设置为非创建状态
+ loadFromCursor(c); // 从游标加载数据
+ mDiffDataValues = new ContentValues(); // 创建内容值实例
+ }
+
+ // 从游标中加载数据到SqlData实例
+ private void loadFromCursor(Cursor c) {
+ mDataId = c.getLong(DATA_ID_COLUMN); // 获取数据ID
+ mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); // 获取MIME类型
+ mDataContent = c.getString(DATA_CONTENT_COLUMN); // 获取内容
+ mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); // 获取第一个数据字段
+ mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); // 获取第三个数据字段
+ }
+
+ // 设置内容，从JSONObject填充数据
+ public void setContent(JSONObject js) throws JSONException {
+ long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; // 获取ID
+ if (mIsCreate || mDataId != dataId) { // 如果是创建状态或ID不相等
+ mDiffDataValues.put(DataColumns.ID, dataId); // 更新变化的ID值
+ }
+ mDataId = dataId; // 更新数据ID
+
+ String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
+ : DataConstants.NOTE; // 获取MIME类型
+ if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { // 如果是创建状态或MIME类型不同
+ mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); // 更新变化的MIME类型
+ }
+ mDataMimeType = dataMimeType; // 更新MIME类型
+
+ String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; // 获取内容
+ if (mIsCreate || !mDataContent.equals(dataContent)) { // 如果是创建状态或内容不同
+ mDiffDataValues.put(DataColumns.CONTENT, dataContent); // 更新变化的内容
+ }
+ mDataContent = dataContent; // 更新内容
+
+ long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; // 获取第一个数据字段
+ if (mIsCreate || mDataContentData1 != dataContentData1) { // 如果是创建状态或字段不同
+ mDiffDataValues.put(DataColumns.DATA1, dataContentData1); // 更新变化的第一个数据字段
+ }
+ mDataContentData1 = dataContentData1; // 更新第一个数据字段
+
+ String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; // 获取第三个数据字段
+ if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { // 如果是创建状态或字段不同
+ mDiffDataValues.put(DataColumns.DATA3, dataContentData3); // 更新变化的第三个数据字段
+ }
+ mDataContentData3 = dataContentData3; // 更新第三个数据字段
+ }
+
+ // 获取内容，返回为JSONObject
+ public JSONObject getContent() throws JSONException {
+ if (mIsCreate) { // 如果是创建状态
+ Log.e(TAG, "it seems that we haven't created this in database yet"); // 记录错误日志
+ return null; // 返回null
+ }
+ JSONObject js = new JSONObject(); // 创建新的JSON对象
+ // 将数据添加到JSON对象中
+ js.put(DataColumns.ID, mDataId);
+ js.put(DataColumns.MIME_TYPE, mDataMimeType);
+ js.put(DataColumns.CONTENT, mDataContent);
+ js.put(DataColumns.DATA1, mDataContentData1);
+ js.put(DataColumns.DATA3, mDataContentData3);
+ return js; // 返回填充的JSON对象
+ }
+
+ // 提交更改到数据库
+ public void commit(long noteId, boolean validateVersion, long version) {
+
+ if (mIsCreate) { // 如果是创建状态
+ if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { // 如果ID无效且变化值中包含ID
+ mDiffDataValues.remove(DataColumns.ID); // 移除变化值中的ID
+ }
+
+ mDiffDataValues.put(DataColumns.NOTE_ID, noteId); // 添加笔记ID到变化值
+ Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); // 插入数据
+ try {
+ mDataId = Long.valueOf(uri.getPathSegments().get(1)); // 获取新创建的ID
+ } catch (NumberFormatException e) { // 捕获数字格式异常
+ Log.e(TAG, "Get note id error :" + e.toString()); // 记录错误日志
+ throw new ActionFailureException("create note failed"); // 抛出创建失败异常
+ }
+ } else { // 如果不是创建状态
+ if (mDiffDataValues.size() > 0) { // 如果有变化值
+ int result = 0; // 定义返回结果
+ if (!validateVersion) { // 如果不验证版本
+ result = mContentResolver.update(ContentUris.withAppendedId(
+ Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null); // 更新数据
+ } else { // 如果验证版本
+ result = mContentResolver.update(ContentUris.withAppendedId(
+ Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
+ " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ + " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
+ String.valueOf(noteId), String.valueOf(version)
+ }); // 根据版本更新数据
+ }
+ if (result == 0) { // 如果没有更新行
+ Log.w(TAG, "there is no update. maybe user updates note when syncing"); // 记录警告日志
+ }
+ }
+ }
+
+ mDiffDataValues.clear(); // 清空变化的数据值
+ mIsCreate = false; // 设置为非创建状态
+ }
+
+ // 获取数据ID
+ public long getId() {
+ return mDataId; // 返回数据ID
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
new file mode 100644
index 0000000..cb58657
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
@@ -0,0 +1,496 @@
+/*
+ * 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.gtask.data;
+
+// 导入相关的类
+import android.appwidget.AppWidgetManager; // 用于访问小部件管理器
+import android.content.ContentResolver; // 用于访问内容提供者
+import android.content.ContentValues; // 表示一组键值对
+import android.content.Context; // Android的上下文类
+import android.database.Cursor; // 用于访问查询结果
+import android.net.Uri; // 表示统一资源标识符
+import android.util.Log; // 日志记录工具
+
+import net.micode.notes.data.Notes; // 引入笔记数据类
+import net.micode.notes.data.Notes.DataColumns; // 数据列常量
+import net.micode.notes.data.Notes.NoteColumns; // 笔记列常量
+import net.micode.notes.gtask.exception.ActionFailureException; // 异常类
+import net.micode.notes.tool.GTaskStringUtils; // 工具类，用于处理GTask字符串
+import net.micode.notes.tool.ResourceParser; // 资源解析工具类
+
+import org.json.JSONArray; // 用于处理JSON数组
+import org.json.JSONException; // JSON异常处理
+import org.json.JSONObject; // 用于处理JSON对象
+
+import java.util.ArrayList; // 动态数组
+
+// SqlNote 类表示笔记的数据库操作
+public class SqlNote {
+ private static final String TAG = SqlNote.class.getSimpleName(); // 日志标签
+
+ private static final int INVALID_ID = -99999; // 无效ID常量
+
+ // 定义查询笔记所需的列
+ public static final String[] PROJECTION_NOTE = new String[] {
+ NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
+ NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
+ NoteColumns.NOTES_COUNT, NoteColumns.PARENT_ID, NoteColumns.SNIPPET, NoteColumns.TYPE,
+ NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID,
+ NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
+ NoteColumns.VERSION
+ };
+
+ // 定义各个列的索引常量
+ public static final int ID_COLUMN = 0;
+ public static final int ALERTED_DATE_COLUMN = 1;
+ public static final int BG_COLOR_ID_COLUMN = 2;
+ public static final int CREATED_DATE_COLUMN = 3;
+ public static final int HAS_ATTACHMENT_COLUMN = 4;
+ public static final int MODIFIED_DATE_COLUMN = 5;
+ public static final int NOTES_COUNT_COLUMN = 6;
+ public static final int PARENT_ID_COLUMN = 7;
+ public static final int SNIPPET_COLUMN = 8;
+ public static final int TYPE_COLUMN = 9;
+ public static final int WIDGET_ID_COLUMN = 10;
+ public static final int WIDGET_TYPE_COLUMN = 11;
+ public static final int SYNC_ID_COLUMN = 12;
+ public static final int LOCAL_MODIFIED_COLUMN = 13;
+ public static final int ORIGIN_PARENT_ID_COLUMN = 14;
+ public static final int GTASK_ID_COLUMN = 15;
+ public static final int VERSION_COLUMN = 16;
+
+ // 成员变量定义
+ private Context mContext; // 上下文对象
+ private ContentResolver mContentResolver; // 内容解析器
+ private boolean mIsCreate; // 指示是否为新建笔记的标志
+ private long mId; // 笔记ID
+ private long mAlertDate; // 提醒日期
+ private int mBgColorId; // 背景颜色ID
+ private long mCreatedDate; // 创建日期
+ private int mHasAttachment; // 是否有附件
+ private long mModifiedDate; // 修改日期
+ private long mParentId; // 父级ID
+ private String mSnippet; // 笔记摘录
+ private int mType; // 笔记类型
+ private int mWidgetId; // 小部件ID
+ private int mWidgetType; // 小部件类型
+ private long mOriginParent; // 原始父级ID
+ private long mVersion; // 版本号
+ private ContentValues mDiffNoteValues; // 存储变化的笔记值
+ private ArrayList mDataList; // 存储笔记数据的列表
+
+ // 构造函数：创建新的SqlNote实例
+ public SqlNote(Context context) {
+ mContext = context; // 设置上下文
+ mContentResolver = context.getContentResolver(); // 获取内容解析器
+ mIsCreate = true; // 设置为新建状态
+ mId = INVALID_ID; // 设置ID为无效值
+ mAlertDate = 0; // 初始化提醒日期
+ mBgColorId = ResourceParser.getDefaultBgId(context); // 获取默认背景ID
+ mCreatedDate = System.currentTimeMillis(); // 获取当前时间作为创建日期
+ mHasAttachment = 0; // 初始化无附件
+ mModifiedDate = System.currentTimeMillis(); // 获取当前时间作为修改日期
+ mParentId = 0; // 初始化父级ID
+ mSnippet = ""; // 初始化笔记摘录
+ mType = Notes.TYPE_NOTE; // 默认类型为笔记
+ mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 设置小部件ID为无效值
+ mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 设置小部件类型为无效值
+ mOriginParent = 0; // 初始化原始父级ID
+ mVersion = 0; // 初始化版本号
+ mDiffNoteValues = new ContentValues(); // 初始化变化的笔记值
+ mDataList = new ArrayList(); // 初始化笔记数据列表
+ }
+
+ // 构造函数：根据Cursor创建SqlNote实例
+ public SqlNote(Context context, Cursor c) {
+ mContext = context; // 设置上下文
+ mContentResolver = context.getContentResolver(); // 获取内容解析器
+ mIsCreate = false; // 设置为非新建状态
+ loadFromCursor(c); // 从Cursor加载数据
+ mDataList = new ArrayList(); // 初始化笔记数据列表
+ if (mType == Notes.TYPE_NOTE) // 如果类型为笔记
+ loadDataContent(); // 加载数据内容
+ mDiffNoteValues = new ContentValues(); // 初始化变化的笔记值
+ }
+
+ // 构造函数：根据ID创建SqlNote实例
+ public SqlNote(Context context, long id) {
+ mContext = context; // 设置上下文
+ mContentResolver = context.getContentResolver(); // 获取内容解析器
+ mIsCreate = false; // 设置为非新建状态
+ loadFromCursor(id); // 根据ID加载数据
+ mDataList = new ArrayList(); // 初始化笔记数据列表
+ if (mType == Notes.TYPE_NOTE) // 如果类型为笔记
+ loadDataContent(); // 加载数据内容
+ mDiffNoteValues = new ContentValues(); // 初始化变化的笔记值
+ }
+
+ // 从Cursor中加载笔记数据
+ private void loadFromCursor(long id) {
+ Cursor c = null; // 初始化Cursor
+ try {
+ // 查询笔记数据
+ c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
+ new String[] {
+ String.valueOf(id) // 根据ID查询
+ }, null);
+ if (c != null) { // 如果Cursor不为空
+ c.moveToNext(); // 移动到下一行
+ loadFromCursor(c); // 从Cursor加载数据
+ } else {
+ Log.w(TAG, "loadFromCursor: cursor = null"); // 如果Cursor为空，记录警告日志
+ }
+ } finally {
+ if (c != null) // 关闭Cursor
+ c.close();
+ }
+ }
+
+ // 从Cursor中加载笔记数据
+ private void loadFromCursor(Cursor c) {
+ mId = c.getLong(ID_COLUMN); // 获取ID
+ mAlertDate = c.getLong(ALERTED_DATE_COLUMN); // 获取提醒日期
+ mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); // 获取背景颜色ID
+ mCreatedDate = c.getLong(CREATED_DATE_COLUMN); // 获取创建日期
+ mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); // 获取附件标志
+ mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); // 获取修改日期
+ mParentId = c.getLong(PARENT_ID_COLUMN); // 获取父级ID
+ mSnippet = c.getString(SNIPPET_COLUMN); // 获取笔记摘录
+ mType = c.getInt(TYPE_COLUMN); // 获取笔记类型
+ mWidgetId = c.getInt(WIDGET_ID_COLUMN); // 获取小部件ID
+ mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); // 获取小部件类型
+ mVersion = c.getLong(VERSION_COLUMN); // 获取版本号
+ }
+
+ // 加载笔记数据内容
+ private void loadDataContent() {
+ Cursor c = null; // 初始化Cursor
+ mDataList.clear(); // 清空数据列表
+ try {
+ // 查询笔记数据内容
+ c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
+ "(note_id=?)", new String[] {
+ String.valueOf(mId) // 根据笔记ID查询
+ }, null);
+ if (c != null) { // 如果Cursor不为空
+ if (c.getCount() == 0) { // 如果没有数据
+ Log.w(TAG, "it seems that the note has not data"); // 记录警告日志
+ return; // 返回
+ }
+ // 遍历Cursor中的数据
+ while (c.moveToNext()) {
+ SqlData data = new SqlData(mContext, c); // 创建SqlData实例
+ mDataList.add(data); // 添加到数据列表
+ }
+ } else {
+ Log.w(TAG, "loadDataContent: cursor = null"); // 如果Cursor为空，记录警告日志
+ }
+ } finally {
+ if (c != null) // 关闭Cursor
+ c.close();
+ }
+ }
+
+ // 设置笔记内容
+ public boolean setContent(JSONObject js) {
+ try {
+ JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记对象
+ if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { // 如果是系统文件夹
+ Log.w(TAG, "cannot set system folder"); // 记录警告日志
+ } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { // 如果是文件夹
+ // 只更新摘录和类型
+ String snippet = note.has(NoteColumns.SNIPPET) ? note
+ .getString(NoteColumns.SNIPPET) : ""; // 获取摘录
+ if (mIsCreate || !mSnippet.equals(snippet)) {
+ mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); // 更新摘录
+ }
+ mSnippet = snippet; // 设置摘录
+
+ int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+ : Notes.TYPE_NOTE; // 获取类型
+ if (mIsCreate || mType != type) {
+ mDiffNoteValues.put(NoteColumns.TYPE, type); // 更新类型
+ }
+ mType = type; // 设置类型
+ } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { // 如果是笔记
+ JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 获取数据数组
+ long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; // 获取ID
+ if (mIsCreate || mId != id) {
+ mDiffNoteValues.put(NoteColumns.ID, id); // 更新ID
+ }
+ mId = id; // 设置ID
+
+ long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
+ .getLong(NoteColumns.ALERTED_DATE) : 0; // 获取提醒日期
+ if (mIsCreate || mAlertDate != alertDate) {
+ mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); // 更新提醒日期
+ }
+ mAlertDate = alertDate; // 设置提醒日期
+
+ int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
+ .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); // 获取背景颜色ID
+ if (mIsCreate || mBgColorId != bgColorId) {
+ mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); // 更新背景颜色ID
+ }
+ mBgColorId = bgColorId; // 设置背景颜色ID
+
+ long createDate = note.has(NoteColumns.CREATED_DATE) ? note
+ .getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis(); // 获取创建日期
+ if (mIsCreate || mCreatedDate != createDate) {
+ mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); // 更新创建日期
+ }
+ mCreatedDate = createDate; // 设置创建日期
+
+ int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
+ .getInt(NoteColumns.HAS_ATTACHMENT) : 0; // 获取附件标志
+ if (mIsCreate || mHasAttachment != hasAttachment) {
+ mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment); // 更新附件标志
+ }
+ mHasAttachment = hasAttachment; // 设置附件标志
+
+ long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
+ .getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); // 获取修改日期
+ if (mIsCreate || mModifiedDate != modifiedDate) {
+ mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); // 更新修改日期
+ }
+ mModifiedDate = modifiedDate; // 设置修改日期
+
+ long parentId = note.has(NoteColumns.PARENT_ID) ? note
+ .getLong(NoteColumns.PARENT_ID) : 0; // 获取父级ID
+ if (mIsCreate || mParentId != parentId) {
+ mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); // 更新父级ID
+ }
+ mParentId = parentId; // 设置父级ID
+
+ String snippet = note.has(NoteColumns.SNIPPET) ? note
+ .getString(NoteColumns.SNIPPET) : ""; // 获取摘录
+ if (mIsCreate || !mSnippet.equals(snippet)) {
+ mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); // 更新摘录
+ }
+ mSnippet = snippet; // 设置摘录
+
+ int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
+ : Notes.TYPE_NOTE; // 获取类型
+ if (mIsCreate || mType != type) {
+ mDiffNoteValues.put(NoteColumns.TYPE, type); // 更新类型
+ }
+ mType = type; // 设置类型
+
+ int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
+ : AppWidgetManager.INVALID_APPWIDGET_ID; // 获取小部件ID
+ if (mIsCreate || mWidgetId != widgetId) {
+ mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); // 更新小部件ID
+ }
+ mWidgetId = widgetId; // 设置小部件ID
+
+ int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
+ .getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; // 获取小部件类型
+ if (mIsCreate || mWidgetType != widgetType) {
+ mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); // 更新小部件类型
+ }
+ mWidgetType = widgetType; // 设置小部件类型
+
+ long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
+ .getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; // 获取原始父级ID
+ if (mIsCreate || mOriginParent != originParent) {
+ mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); // 更新原始父级ID
+ }
+ mOriginParent = originParent; // 设置原始父级ID
+
+ // 加载数据数组中的每一项
+ for (int i = 0; i < dataArray.length(); i++) {
+ JSONObject data = dataArray.getJSONObject(i); // 获取JSON数据对象
+ SqlData sqlData = null; // 初始化SqlData对象
+ if (data.has(DataColumns.ID)) { // 如果数据中有ID
+ long dataId = data.getLong(DataColumns.ID); // 获取数据ID
+ for (SqlData temp : mDataList) { // 查找对应的SqlData实例
+ if (dataId == temp.getId()) {
+ sqlData = temp; // 找到对应的SqlData
+ }
+ }
+ }
+
+ if (sqlData == null) { // 如果没有找到对应的SqlData
+ sqlData = new SqlData(mContext); // 创建新的SqlData实例
+ mDataList.add(sqlData); // 添加到数据列表
+ }
+
+ sqlData.setContent(data); // 设置SqlData内容
+ }
+ }
+ } catch (JSONException e) { // 捕获JSON异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈信息
+ return false; // 返回false表示失败
+ }
+ return true; // 返回true表示成功
+ }
+
+ // 获取笔记内容
+ public JSONObject getContent() {
+ try {
+ JSONObject js = new JSONObject(); // 创建新的JSON对象
+
+ if (mIsCreate) { // 如果是新建状态
+ Log.e(TAG, "it seems that we haven't created this in database yet"); // 记录错误日志
+ return null; // 返回null
+ }
+
+ JSONObject note = new JSONObject(); // 创建笔记对象
+ if (mType == Notes.TYPE_NOTE) { // 如果类型为笔记
+ note.put(NoteColumns.ID, mId); // 添加ID
+ note.put(NoteColumns.ALERTED_DATE, mAlertDate); // 添加提醒日期
+ note.put(NoteColumns.BG_COLOR_ID, mBgColorId); // 添加背景颜色ID
+ note.put(NoteColumns.CREATED_DATE, mCreatedDate); // 添加创建日期
+ note.put(NoteColumns.HAS_ATTACHMENT, mHasAttachment); // 添加附件标志
+ note.put(NoteColumns.MODIFIED_DATE, mModifiedDate); // 添加修改日期
+ note.put(NoteColumns.PARENT_ID, mParentId); // 添加父级ID
+ note.put(NoteColumns.SNIPPET, mSnippet); // 添加摘录
+ note.put(NoteColumns.TYPE, mType); // 添加笔记类型
+ note.put(NoteColumns.WIDGET_ID, mWidgetId); // 添加小部件ID
+ note.put(NoteColumns.WIDGET_TYPE, mWidgetType); // 添加小部件类型
+ note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); // 添加原始父级ID
+ js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将笔记对象放入结果JSON
+
+ JSONArray dataArray = new JSONArray(); // 创建数据数组
+ for (SqlData sqlData : mDataList) { // 遍历数据列表
+ JSONObject data = sqlData.getContent(); // 获取数据的JSON对象
+ if (data != null) { // 如果数据不为空
+ dataArray.put(data); // 添加到数组
+ }
+ }
+ js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 将数据数组放入结果JSON
+ } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { // 如果是文件夹或系统类型
+ note.put(NoteColumns.ID, mId); // 添加ID
+ note.put(NoteColumns.TYPE, mType); // 添加类型
+ note.put(NoteColumns.SNIPPET, mSnippet); // 添加摘录
+ js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将笔记对象放入结果JSON
+ }
+
+ return js; // 返回结果JSON对象
+ } catch (JSONException e) { // 捕获JSON异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈信息
+ }
+ return null; // 返回null
+ }
+
+ // 设置父级ID
+ public void setParentId(long id) {
+ mParentId = id; // 设置父级ID
+ mDiffNoteValues.put(NoteColumns.PARENT_ID, id); // 更新变化的值
+ }
+
+ // 设置GTask Id
+ public void setGtaskId(String gid) {
+ mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); // 更新变化的值
+ }
+
+ // 设置同步ID
+ public void setSyncId(long syncId) {
+ mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); // 更新变化的值
+ }
+
+ // 重置本地修改标志
+ public void resetLocalModified() {
+ mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); // 更新变化的值
+ }
+
+ // 获取笔记ID
+ public long getId() {
+ return mId; // 返回ID
+ }
+
+ // 获取父级ID
+ public long getParentId() {
+ return mParentId; // 返回父级ID
+ }
+
+ // 获取笔记摘录
+ public String getSnippet() {
+ return mSnippet; // 返回摘录
+ }
+
+ // 判断是否为笔记类型
+ public boolean isNoteType() {
+ return mType == Notes.TYPE_NOTE; // 返回类型是否为笔记
+ }
+
+ // 提交笔记到数据库
+ public void commit(boolean validateVersion) {
+ if (mIsCreate) { // 如果是新建状态
+ if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
+ mDiffNoteValues.remove(NoteColumns.ID); // 移除ID
+ }
+
+ Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); // 插入笔记
+ try {
+ mId = Long.valueOf(uri.getPathSegments().get(1)); // 获取笔记ID
+ } catch (NumberFormatException e) { // 捕获数字格式异常
+ Log.e(TAG, "Get note id error :" + e.toString()); // 记录错误日志
+ throw new ActionFailureException("create note failed"); // 抛出创建失败异常
+ }
+ if (mId == 0) { // 如果ID为0，表示创建失败
+ throw new IllegalStateException("Create thread id failed"); // 抛出异常
+ }
+
+ if (mType == Notes.TYPE_NOTE) { // 如果类型为笔记
+ for (SqlData sqlData : mDataList) {
+ sqlData.commit(mId, false, -1); // 提交每个SqlData
+ }
+ }
+ } else { // 如果不是新建状态
+ if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
+ Log.e(TAG, "No such note"); // 记录错误日志
+ throw new IllegalStateException("Try to update note with invalid id"); // 抛出异常
+ }
+ if (mDiffNoteValues.size() > 0) { // 如果有变化的值
+ mVersion++; // 增加版本号
+ int result = 0; // 结果初始化
+ if (!validateVersion) { // 如果不需要验证版本
+ result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ + NoteColumns.ID + "=?)", new String[] {
+ String.valueOf(mId) // 根据ID更新
+ });
+ } else { // 需要验证版本
+ result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
+ new String[] {
+ String.valueOf(mId), String.valueOf(mVersion) // 根据ID和版本更新
+ });
+ }
+ if (result == 0) { // 如果没有更新，可能是同步中
+ Log.w(TAG, "there is no update. maybe user updates note when syncing"); // 记录警告日志
+ }
+ }
+
+ if (mType == Notes.TYPE_NOTE) { // 如果类型为笔记
+ for (SqlData sqlData : mDataList) { // 提交每个SqlData
+ sqlData.commit(mId, validateVersion, mVersion);
+ }
+ }
+ }
+
+ // 刷新本地信息
+ loadFromCursor(mId); // 重新加载笔记数据
+ if (mType == Notes.TYPE_NOTE)
+ loadDataContent(); // 重新加载数据内容
+
+ mDiffNoteValues.clear(); // 清空变化的值
+ mIsCreate = false; // 设置为非新建状态
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/Task.java b/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
new file mode 100644
index 0000000..b36e2bd
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/Task.java
@@ -0,0 +1,368 @@
+/*
+ * 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.gtask.data; // 声明该类属于 net.micode.notes.gtask.data 包
+
+import android.database.Cursor; // 导入 Cursor 类，用于操作数据库结果集
+import android.text.TextUtils; // 导入 TextUtils 类，用于处理文本操作
+import android.util.Log; // 导入 Log 类，用于日志记录
+
+import net.micode.notes.data.Notes; // 导入 Notes 类，用于引用笔记相关的常量和方法
+import net.micode.notes.data.Notes.DataColumns; // 导入数据列常量
+import net.micode.notes.data.Notes.DataConstants; // 导入数据常量
+import net.micode.notes.data.Notes.NoteColumns; // 导入笔记列常量
+import net.micode.notes.gtask.exception.ActionFailureException; // 导入自定义异常类
+import net.micode.notes.tool.GTaskStringUtils; // 导入工具类，用于处理任务字符串
+
+import org.json.JSONArray; // 导入 JSONArray 类，用于处理 JSON 数组
+import org.json.JSONException; // 导入 JSONException 类，用于处理 JSON 异常
+import org.json.JSONObject; // 导入 JSONObject 类，用于处理 JSON 对象
+
+
+// 定义 Task 类，继承自 Node 类
+public class Task extends Node {
+ private static final String TAG = Task.class.getSimpleName(); // 定义日志标签
+
+ private boolean mCompleted; // 任务完成状态
+
+ private String mNotes; // 任务备注
+
+ private JSONObject mMetaInfo; // 任务的元信息（JSON 格式）
+
+ private Task mPriorSibling; // 任务的前一个兄弟任务
+
+ private TaskList mParent; // 任务的父任务列表
+
+ // 构造函数，初始化任务的状态
+ public Task() {
+ super(); // 调用父类构造函数
+ mCompleted = false; // 默认未完成
+ mNotes = null; // 默认无备注
+ mPriorSibling = null; // 默认无前一个兄弟任务
+ mParent = null; // 默认无父任务列表
+ mMetaInfo = null; // 默认无元信息
+ }
+
+ // 获取创建任务的操作 JSON 对象
+ public JSONObject getCreateAction(int actionId) {
+ JSONObject js = new JSONObject(); // 创建 JSON 对象
+
+ try {
+ // action_type - 设置操作类型为创建
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+
+ // action_id - 设置操作 ID
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+ // index - 任务在父任务中的索引位置
+ js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
+
+ // entity_delta - 创建任务的实体数据
+ JSONObject entity = new JSONObject();
+ entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务名称
+ entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者 ID，初始化为 null
+ entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+ GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 实体类型为任务
+ if (getNotes() != null) {
+ entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 任务备注
+ }
+ js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体数据加入 JSON 对象
+
+ // parent_id - 设置父任务 ID
+ js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
+
+ // dest_parent_type - 设置目标父类型
+ js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
+ GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+
+ // list_id - 设置任务列表 ID
+ js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
+
+ // prior_sibling_id - 设置前一个兄弟任务 ID
+ if (mPriorSibling != null) {
+ js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
+ }
+
+ } catch (JSONException e) { // 捕获 JSON 异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈跟踪
+ throw new ActionFailureException("fail to generate task-create jsonobject"); // 抛出自定义异常
+ }
+
+ return js; // 返回创建操作的 JSON 对象
+ }
+
+ // 获取更新任务的操作 JSON 对象
+ public JSONObject getUpdateAction(int actionId) {
+ JSONObject js = new JSONObject(); // 创建 JSON 对象
+
+ try {
+ // action_type - 设置操作类型为更新
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+
+ // action_id - 设置操作 ID
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+ // id - 设置任务 ID
+ js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+
+ // entity_delta - 更新的实体数据
+ JSONObject entity = new JSONObject();
+ entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 任务名称
+ if (getNotes() != null) {
+ entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); // 任务备注
+ }
+ entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 任务删除状态
+ js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体数据加入 JSON 对象
+
+ } catch (JSONException e) { // 捕获 JSON 异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈跟踪
+ throw new ActionFailureException("fail to generate task-update jsonobject"); // 抛出自定义异常
+ }
+
+ return js; // 返回更新操作的 JSON 对象
+ }
+
+ // 根据远程 JSON 设置任务内容
+ public void setContentByRemoteJSON(JSONObject js) {
+ if (js != null) { // 如果 JSON 对象不为空
+ try {
+ // id - 获取任务 ID
+ if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+ setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+ }
+
+ // last_modified - 获取最后修改时间
+ if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+ setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+ }
+
+ // name - 获取任务名称
+ if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+ setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+ }
+
+ // notes - 获取任务备注
+ if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
+ setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
+ }
+
+ // deleted - 获取任务删除状态
+ if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
+ setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
+ }
+
+ // completed - 获取任务完成状态
+ if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
+ setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
+ }
+ } catch (JSONException e) { // 捕获 JSON 异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈跟踪
+ throw new ActionFailureException("fail to get task content from jsonobject"); // 抛出自定义异常
+ }
+ }
+ }
+
+ // 根据本地 JSON 设置任务内容
+ public void setContentByLocalJSON(JSONObject js) {
+ if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
+ || !js.has(GTaskStringUtils.META_HEAD_DATA)) { // 检查 JSON 对象是否包含必要字段
+ Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); // 记录警告日志
+ }
+
+ try {
+ JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记信息
+ JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 获取数据数组
+
+ if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { // 检查笔记类型
+ Log.e(TAG, "invalid type"); // 记录错误日志
+ return; // 退出
+ }
+
+ // 遍历数据数组，寻找内容
+ for (int i = 0; i < dataArray.length(); i++) {
+ JSONObject data = dataArray.getJSONObject(i);
+ if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+ setName(data.getString(DataColumns.CONTENT)); // 设置任务名称
+ break; // 找到后退出循环
+ }
+ }
+
+ } catch (JSONException e) { // 捕获 JSON 异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈跟踪
+ }
+ }
+
+ // 从任务内容生成本地 JSON
+ public JSONObject getLocalJSONFromContent() {
+ String name = getName(); // 获取任务名称
+ try {
+ if (mMetaInfo == null) { // 如果元信息为空（表示从网页创建的任务）
+ if (name == null) { // 检查任务名称是否为空
+ Log.w(TAG, "the note seems to be an empty one"); // 记录警告日志
+ return null; // 返回空
+ }
+
+ JSONObject js = new JSONObject(); // 创建 JSON 对象
+ JSONObject note = new JSONObject(); // 创建笔记对象
+ JSONArray dataArray = new JSONArray(); // 创建数据数组
+ JSONObject data = new JSONObject(); // 创建数据对象
+ data.put(DataColumns.CONTENT, name); // 设置内容为任务名称
+ dataArray.put(data); // 将数据对象加入数据数组
+ js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 将数据数组加入 JSON 对象
+ note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型
+ js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 将笔记对象加入 JSON 对象
+ return js; // 返回 JSON 对象
+ } else { // 处理已同步的任务
+ JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记对象
+ JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 获取数据数组
+
+ for (int i = 0; i < dataArray.length(); i++) {
+ JSONObject data = dataArray.getJSONObject(i);
+ if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+ data.put(DataColumns.CONTENT, getName()); // 更新内容为任务名称
+ break; // 找到后退出循环
+ }
+ }
+
+ note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 设置笔记类型
+ return mMetaInfo; // 返回元信息 JSON 对象
+ }
+ } catch (JSONException e) { // 捕获 JSON 异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈跟踪
+ return null; // 返回空
+ }
+ }
+
+ // 设置任务的元信息
+ public void setMetaInfo(MetaData metaData) {
+ if (metaData != null && metaData.getNotes() != null) { // 检查元数据和笔记是否为空
+ try {
+ mMetaInfo = new JSONObject(metaData.getNotes()); // 将笔记设置为元信息的 JSON 对象
+ } catch (JSONException e) { // 捕获 JSON 异常
+ Log.w(TAG, e.toString()); // 记录警告日志
+ mMetaInfo = null; // 将元信息设置为 null
+ }
+ }
+ }
+
+ // 获取同步操作类型
+ public int getSyncAction(Cursor c) {
+ try {
+ JSONObject noteInfo = null;
+ if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
+ noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记信息
+ }
+
+ if (noteInfo == null) { // 检查笔记信息是否为 null
+ Log.w(TAG, "it seems that note meta has been deleted"); // 记录警告日志
+ return SYNC_ACTION_UPDATE_REMOTE; // 返回远程更新操作
+ }
+
+ if (!noteInfo.has(NoteColumns.ID)) { // 检查笔记 ID 是否存在
+ Log.w(TAG, "remote note id seems to be deleted"); // 记录警告日志
+ return SYNC_ACTION_UPDATE_LOCAL; // 返回本地更新操作
+ }
+
+ // 验证笔记 ID
+ if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
+ Log.w(TAG, "note id doesn't match"); // 记录警告日志
+ return SYNC_ACTION_UPDATE_LOCAL; // 返回本地更新操作
+ }
+
+ if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { // 检查本地是否未修改
+ // 无本地更新
+ if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+ // 双方均无更新
+ return SYNC_ACTION_NONE; // 返回无更新
+ } else {
+ // 应用远程到本地
+ return SYNC_ACTION_UPDATE_LOCAL; // 返回本地更新操作
+ }
+ } else {
+ // 验证 gtask ID
+ if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
+ Log.e(TAG, "gtask id doesn't match"); // 记录错误日志
+ return SYNC_ACTION_ERROR; // 返回错误操作
+ }
+ if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+ // 仅本地修改
+ return SYNC_ACTION_UPDATE_REMOTE; // 返回远程更新操作
+ } else {
+ return SYNC_ACTION_UPDATE_CONFLICT; // 返回冲突操作
+ }
+ }
+ } catch (Exception e) { // 捕获异常
+ Log.e(TAG, e.toString()); // 记录错误日志
+ e.printStackTrace(); // 打印堆栈跟踪
+ }
+
+ return SYNC_ACTION_ERROR; // 默认返回错误操作
+ }
+
+ // 判断任务是否值得保存
+ public boolean isWorthSaving() {
+ return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
+ || (getNotes() != null && getNotes().trim().length() > 0); // 检查是否有元信息、名称或备注
+ }
+
+ // 设置任务完成状态
+ public void setCompleted(boolean completed) {
+ this.mCompleted = completed; // 赋值完成状态
+ }
+
+ // 设置任务备注
+ public void setNotes(String notes) {
+ this.mNotes = notes; // 赋值备注
+ }
+
+ // 设置前一个兄弟任务
+ public void setPriorSibling(Task priorSibling) {
+ this.mPriorSibling = priorSibling; // 赋值前一个兄弟任务
+ }
+
+ // 设置父任务列表
+ public void setParent(TaskList parent) {
+ this.mParent = parent; // 赋值父任务列表
+ }
+
+ // 获取任务完成状态
+ public boolean getCompleted() {
+ return this.mCompleted; // 返回完成状态
+ }
+
+ // 获取任务备注
+ public String getNotes() {
+ return this.mNotes; // 返回备注
+ }
+
+ // 获取前一个兄弟任务
+ public Task getPriorSibling() {
+ return this.mPriorSibling; // 返回前一个兄弟任务
+ }
+
+ // 获取父任务列表
+ public TaskList getParent() {
+ return this.mParent; // 返回父任务列表
+ }
+
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java b/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
new file mode 100644
index 0000000..d76b4b7
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
@@ -0,0 +1,368 @@
+/*
+ * 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.gtask.data;
+
+// 导入所需的类
+import android.database.Cursor;
+import android.util.Log;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.tool.GTaskStringUtils;
+import org.json.JSONException;
+import org.json.JSONObject;
+import java.util.ArrayList;
+
+// TaskList类继承自Node类，表示一个任务列表
+public class TaskList extends Node {
+ // 定义日志标签
+ private static final String TAG = TaskList.class.getSimpleName();
+
+ // 任务列表的索引
+ private int mIndex;
+
+ // 存储子任务的列表
+ private ArrayList mChildren;
+
+ // TaskList的构造函数，初始化子任务列表和索引
+ public TaskList() {
+ super();
+ mChildren = new ArrayList();
+ mIndex = 1; // 默认索引为1
+ }
+
+ // 获取创建任务列表的JSON对象
+ public JSONObject getCreateAction(int actionId) {
+ JSONObject js = new JSONObject(); // 创建一个新的JSON对象
+
+ try {
+ // 设置动作类型为创建
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
+
+ // 设置动作ID
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+ // 设置索引
+ js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
+
+ // 创建实体的变化对象
+ JSONObject entity = new JSONObject();
+ entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置名称
+ entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 创建者ID
+ entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+ GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 实体类型
+ js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体变化对象放入主对象中
+
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString()); // 打印错误日志
+ e.printStackTrace();
+ throw new ActionFailureException("fail to generate tasklist-create jsonobject"); // 抛出异常
+ }
+
+ return js; // 返回生成的JSON对象
+ }
+
+ // 获取更新任务列表的JSON对象
+ public JSONObject getUpdateAction(int actionId) {
+ JSONObject js = new JSONObject(); // 创建一个新的JSON对象
+
+ try {
+ // 设置动作类型为更新
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
+
+ // 设置动作ID
+ js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
+
+ // 设置任务列表ID
+ js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+
+ // 创建实体的变化对象
+ JSONObject entity = new JSONObject();
+ entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置名称
+ entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 设置删除状态
+ js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体变化对象放入主对象中
+
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString()); // 打印错误日志
+ e.printStackTrace();
+ throw new ActionFailureException("fail to generate tasklist-update jsonobject"); // 抛出异常
+ }
+
+ return js; // 返回生成的JSON对象
+ }
+
+ // 根据远程JSON设置任务列表的内容
+ public void setContentByRemoteJSON(JSONObject js) {
+ if (js != null) {
+ try {
+ // 设置任务列表ID
+ if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+ setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
+ }
+
+ // 设置最后修改时间
+ if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
+ setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
+ }
+
+ // 设置名称
+ if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
+ setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
+ }
+
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString()); // 打印错误日志
+ e.printStackTrace();
+ throw new ActionFailureException("fail to get tasklist content from jsonobject"); // 抛出异常
+ }
+ }
+ }
+
+ // 根据本地JSON设置任务列表的内容
+ public void setContentByLocalJSON(JSONObject js) {
+ // 检查JSON对象是否有效
+ if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+ Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); // 发出警告日志
+ }
+
+ try {
+ // 获取任务列表的文件夹对象
+ JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+
+ // 根据文件夹类型设置名称
+ if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+ String name = folder.getString(NoteColumns.SNIPPET);
+ setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name); // 设置文件夹名称
+ } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+ // 检查系统文件夹ID并设置相应名称
+ if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
+ setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
+ else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
+ setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ + GTaskStringUtils.FOLDER_CALL_NOTE);
+ else
+ Log.e(TAG, "invalid system folder"); // 打印错误日志
+ } else {
+ Log.e(TAG, "error type"); // 打印错误日志
+ }
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString()); // 打印错误日志
+ e.printStackTrace();
+ }
+ }
+
+ // 从内容生成本地JSON对象
+ public JSONObject getLocalJSONFromContent() {
+ try {
+ JSONObject js = new JSONObject(); // 创建一个新的JSON对象
+ JSONObject folder = new JSONObject(); // 创建文件夹的JSON对象
+
+ String folderName = getName(); // 获取任务列表名称
+ if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
+ folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
+ folderName.length()); // 去掉前缀
+
+ // 设置文件夹名称和类型
+ folder.put(NoteColumns.SNIPPET, folderName);
+ if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
+ || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
+ folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
+ else
+ folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
+
+ js.put(GTaskStringUtils.META_HEAD_NOTE, folder); // 将文件夹对象放入主对象中
+
+ return js; // 返回生成的JSON对象
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString()); // 打印错误日志
+ e.printStackTrace();
+ return null; // 出现异常时返回null
+ }
+ }
+
+ // 获取同步操作
+ public int getSyncAction(Cursor c) {
+ try {
+ if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
+ // 本地没有更新
+ if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+ // 本地和远程都没有更新
+ return SYNC_ACTION_NONE; // 返回无操作
+ } else {
+ // 将远程应用到本地
+ return SYNC_ACTION_UPDATE_LOCAL;
+ }
+ } else {
+ // 校验任务ID
+ if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
+ Log.e(TAG, "gtask id doesn't match"); // 打印错误日志
+ return SYNC_ACTION_ERROR; // 返回错误状态
+ }
+ if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+ // 仅本地修改
+ return SYNC_ACTION_UPDATE_REMOTE;
+ } else {
+ // 对于文件夹冲突，采用本地修改
+ return SYNC_ACTION_UPDATE_REMOTE;
+ }
+ }
+ } catch (Exception e) {
+ Log.e(TAG, e.toString()); // 打印错误日志
+ e.printStackTrace();
+ }
+
+ return SYNC_ACTION_ERROR; // 出现异常时返回错误状态
+ }
+
+ // 获取子任务数量
+ public int getChildTaskCount() {
+ return mChildren.size(); // 返回子任务列表大小
+ }
+
+ // 添加子任务
+ public boolean addChildTask(Task task) {
+ boolean ret = false;
+ if (task != null && !mChildren.contains(task)) {
+ ret = mChildren.add(task); // 尝试添加任务
+ if (ret) {
+ // 需要设置前一个兄弟任务和父任务
+ task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
+ .get(mChildren.size() - 1));
+ task.setParent(this); // 设置父任务
+ }
+ }
+ return ret; // 返回添加结果
+ }
+
+ // 根据索引添加子任务
+ public boolean addChildTask(Task task, int index) {
+ if (index < 0 || index > mChildren.size()) {
+ Log.e(TAG, "add child task: invalid index"); // 打印错误日志
+ return false; // 返回失败
+ }
+
+ int pos = mChildren.indexOf(task); // 查找任务在列表中的位置
+ if (task != null && pos == -1) {
+ mChildren.add(index, task); // 根据索引添加任务
+
+ // 更新任务列表
+ Task preTask = null;
+ Task afterTask = null;
+ if (index != 0)
+ preTask = mChildren.get(index - 1); // 获取前一个任务
+ if (index != mChildren.size() - 1)
+ afterTask = mChildren.get(index + 1); // 获取后一个任务
+
+ task.setPriorSibling(preTask); // 设置前一个兄弟任务
+ if (afterTask != null)
+ afterTask.setPriorSibling(task); // 设置后一个兄弟任务
+ }
+
+ return true; // 返回成功
+ }
+
+ // 移除子任务
+ public boolean removeChildTask(Task task) {
+ boolean ret = false;
+ int index = mChildren.indexOf(task); // 查找任务在列表中的位置
+ if (index != -1) {
+ ret = mChildren.remove(task); // 尝试移除任务
+
+ if (ret) {
+ // 重置前一个兄弟任务和父任务
+ task.setPriorSibling(null);
+ task.setParent(null);
+
+ // 更新任务列表
+ if (index != mChildren.size()) {
+ mChildren.get(index).setPriorSibling(
+ index == 0 ? null : mChildren.get(index - 1)); // 更新前一个兄弟任务
+ }
+ }
+ }
+ return ret; // 返回移除结果
+ }
+
+ // 移动子任务
+ public boolean moveChildTask(Task task, int index) {
+ if (index < 0 || index >= mChildren.size()) {
+ Log.e(TAG, "move child task: invalid index"); // 打印错误日志
+ return false; // 返回失败
+ }
+
+ int pos = mChildren.indexOf(task); // 查找任务在列表中的位置
+ if (pos == -1) {
+ Log.e(TAG, "move child task: the task should in the list"); // 打印错误日志
+ return false; // 返回失败
+ }
+
+ if (pos == index)
+ return true; // 位置不变返回成功
+ return (removeChildTask(task) && addChildTask(task, index)); // 移除并重新添加任务
+ }
+
+ // 根据GID查找子任务
+ public Task findChildTaskByGid(String gid) {
+ for (int i = 0; i < mChildren.size(); i++) {
+ Task t = mChildren.get(i);
+ if (t.getGid().equals(gid)) {
+ return t; // 找到任务返回
+ }
+ }
+ return null; // 未找到返回null
+ }
+
+ // 获取子任务索引
+ public int getChildTaskIndex(Task task) {
+ return mChildren.indexOf(task); // 返回任务在列表中的位置
+ }
+
+ // 根据索引获取子任务
+ public Task getChildTaskByIndex(int index) {
+ if (index < 0 || index >= mChildren.size()) {
+ Log.e(TAG, "getTaskByIndex: invalid index"); // 打印错误日志
+ return null; // 返回null
+ }
+ return mChildren.get(index); // 返回任务
+ }
+
+ // 根据GID获取子任务
+ public Task getChilTaskByGid(String gid) {
+ for (Task task : mChildren) {
+ if (task.getGid().equals(gid))
+ return task; // 找到任务返回
+ }
+ return null; // 未找到返回null
+ }
+
+ // 获取子任务列表
+ public ArrayList getChildTaskList() {
+ return this.mChildren; // 返回子任务列表
+ }
+
+ // 设置索引
+ public void setIndex(int index) {
+ this.mIndex = index; // 设置任务列表索引
+ }
+
+ // 获取索引
+ public int getIndex() {
+ return this.mIndex; // 返回任务列表索引
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java b/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
new file mode 100644
index 0000000..be517f6
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ * // 版权声明，指定代码的版权所有者和代码编写的时间范围
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * // 声明该代码是根据Apache License 2.0版本授权的
+ * 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
+ * // 许可证的URL链接
+ *
+ * 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.
+ * // 指出根据许可证分发的软件是“按现状”提供的，没有明示或暗示的任何保证或条件
+ */
+
+<<<<<<< HEAD
+package net.micode.notes.gtask.exception; // 定义该类所在的包
+=======
+package net.micode.notes.gtask.exception;
+// 指定该Java文件的包路径
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+
+/**
+ * ActionFailureException 是一个运行时异常，表示执行操作失败的情况。
+ * 这个异常可以通过不同的构造函数来创建，允许提供详细的错误信息和导致异常的原因。
+ */
+public class ActionFailureException extends RuntimeException {
+<<<<<<< HEAD
+ private static final long serialVersionUID = 4425249765923293627L; // 序列化版本UID，用于序列化机制
+=======
+ // 声明一个名为ActionFailureException的公共类，该类继承自RuntimeException
+ private static final long serialVersionUID = 4425249765923293627L;
+ // 声明一个常量serialVersionUID，用于序列化时保持版本的兼容性
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+
+ // 默认构造函数
+ public ActionFailureException() {
+<<<<<<< HEAD
+ super(); // 调用父类的构造函数
+=======
+ super();
+ // 默认构造函数，调用父类RuntimeException的无参构造函数
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ }
+
+ // 带有错误信息的构造函数
+ public ActionFailureException(String paramString) {
+<<<<<<< HEAD
+ super(paramString); // 调用父类构造函数，传递错误信息
+=======
+ super(paramString);
+ // 带有一个字符串参数的构造函数，调用父类RuntimeException的带字符串参数的构造函数
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ }
+
+ // 带有错误信息和根本原因的构造函数
+ public ActionFailureException(String paramString, Throwable paramThrowable) {
+<<<<<<< HEAD
+ super(paramString, paramThrowable); // 调用父类构造函数，传递错误信息和原因
+=======
+ super(paramString, paramThrowable);
+ // 带有一个字符串和一个Throwable参数的构造函数，调用父类RuntimeException的相应构造函数
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java b/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
new file mode 100644
index 0000000..278a3bb
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
@@ -0,0 +1,68 @@
+/*
+ * 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.
+ */
+
+<<<<<<< HEAD
+package net.micode.notes.gtask.exception; // 定义包路径
+
+/**
+ * NetworkFailureException 是一个自定义异常类，
+ * 用于表示网络故障的相关异常情况。
+ */
+public class NetworkFailureException extends Exception {
+ // 序列版本UID，用于序列化
+ private static final long serialVersionUID = 2107610287180234136L;
+
+ // 默认构造函数
+=======
+// 该类所属的包名，表明这个类是位于net.micode.notes.gtask.exception包下，用于存放相关的异常类
+package net.micode.notes.gtask.exception;
+
+// NetworkFailureException类继承自Exception，用于表示网络相关的操作出现故障时抛出的异常情况
+public class NetworkFailureException extends Exception {
+ // 序列化版本号，用于在对象序列化和反序列化过程中确保版本的兼容性，这里是一个固定的长整型数值
+ private static final long serialVersionUID = 2107610287180234136L;
+
+ // 无参构造函数，调用父类（Exception）的无参构造函数，用于创建一个默认的NetworkFailureException实例，不附带任何详细信息
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public NetworkFailureException() {
+ super(); // 调用父类的构造函数
+ }
+
+<<<<<<< HEAD
+ // 带有消息的构造函数
+=======
+ // 带有一个字符串参数的构造函数，该字符串参数通常用于传递异常相关的详细描述信息，
+ // 调用父类（Exception）的对应构造函数，将传入的字符串作为异常的详细消息
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public NetworkFailureException(String paramString) {
+ super(paramString); // 调用父类的构造函数，传入异常消息
+ }
+
+<<<<<<< HEAD
+ // 带有消息和原因的构造函数
+=======
+ // 带有一个字符串参数和一个Throwable参数的构造函数，字符串参数用于传递异常相关的详细描述信息，
+ // Throwable参数通常用于关联引起当前异常的其他异常（例如底层网络库抛出的原始异常等），
+ // 调用父类（Exception）的对应构造函数进行初始化，将两个参数传递给父类构造函数
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public NetworkFailureException(String paramString, Throwable paramThrowable) {
+ super(paramString, paramThrowable); // 调用父类的构造函数，传入异常消息和原因
+ }
+<<<<<<< HEAD
+}
+=======
+}
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
new file mode 100644
index 0000000..bd3553e
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
+ *
+ * 根据Apache License, Version 2.0（以下简称“许可证”）授权；
+ * 除非遵守许可证，否则不得使用此文件。
+ * 你可以在以下网址获得许可证的副本：
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 除非适用法律要求或书面同意，否则按“原样”提供软件
+ * 在许可证下分发，不附带任何明示或暗示的保证或条件。
+ * 请参阅许可证，了解有关权限和限制的具体语言。
+ */
+
+package net.micode.notes.gtask.remote; // 定义包名
+
+import android.app.Notification; // 导入通知相关类
+import android.app.NotificationManager; // 导入通知管理类
+import android.app.PendingIntent; // 导入待处理意图类
+import android.content.Context; // 导入上下文类
+import android.content.Intent; // 导入意图类
+import android.os.AsyncTask; // 导入异步任务类
+
+<<<<<<< HEAD
+import net.micode.notes.R; // 导入资源文件
+import net.micode.notes.ui.NotesListActivity; // 导入笔记列表活动
+import net.micode.notes.ui.NotesPreferenceActivity; // 导入笔记偏好设置活动
+
+// 定义GTaskASyncTask类，继承自AsyncTask
+public class GTaskASyncTask extends AsyncTask {
+
+ private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; // 定义用于同步通知的ID
+
+ // 定义完成监听器接口
+=======
+// 异步任务类，用于执行GTask同步操作
+public class GTaskASyncTask extends AsyncTask {
+
+ // 定义GTASK同步通知的ID
+ private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
+
+ // 定义完成监听接口
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public interface OnCompleteListener {
+ void onComplete(); // 监听完成事件
+ }
+
+<<<<<<< HEAD
+ private Context mContext; // 上下文
+ private NotificationManager mNotifiManager; // 通知管理器
+ private GTaskManager mTaskManager; // 任务管理器
+ private OnCompleteListener mOnCompleteListener; // 完成监听器
+
+ // 构造函数，初始化上下文和监听器
+=======
+ // 上下文对象
+ private Context mContext;
+ // 通知管理器
+ private NotificationManager mNotifiManager;
+ // 任务管理器
+ private GTaskManager mTaskManager;
+ // 完成监听器
+ private OnCompleteListener mOnCompleteListener;
+
+ // 构造函数，初始化上下文、通知管理器、任务管理器和完成监听器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public GTaskASyncTask(Context context, OnCompleteListener listener) {
+ mContext = context; // 设置上下文
+ mOnCompleteListener = listener; // 设置完成监听器
+ mNotifiManager = (NotificationManager) mContext
+ .getSystemService(Context.NOTIFICATION_SERVICE); // 获取通知服务
+ mTaskManager = GTaskManager.getInstance(); // 获取任务管理器实例
+ }
+
+<<<<<<< HEAD
+ // 取消同步
+=======
+ // 取消同步的方法
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public void cancelSync() {
+ mTaskManager.cancelSync(); // 调用任务管理器的取消同步方法
+ }
+
+<<<<<<< HEAD
+ // 发布进度
+ public void publishProgess(String message) {
+ publishProgress(new String[] {
+ message // 发布进度消息
+=======
+ // 发布进度消息的方法
+ public void publishProgess(String message) {
+ publishProgress(new String[] {
+ message
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ });
+ }
+
+ // 显示通知的方法
+ private void showNotification(int tickerId, String content) {
+ // 创建通知对象
+ Notification notification = new Notification(R.drawable.notification, mContext
+ .getString(tickerId), System.currentTimeMillis());
+<<<<<<< HEAD
+ notification.defaults = Notification.DEFAULT_LIGHTS; // 设置默认灯光效果
+ notification.flags = Notification.FLAG_AUTO_CANCEL; // 设置自动取消标志
+ PendingIntent pendingIntent; // 定义待处理意图
+ // 根据tickerId判断要跳转的活动
+ if (tickerId != R.string.ticker_success) {
+ pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+ NotesPreferenceActivity.class), 0); // 启动偏好设置活动
+
+=======
+ notification.defaults = Notification.DEFAULT_LIGHTS;
+ notification.flags = Notification.FLAG_AUTO_CANCEL;
+ // 根据tickerId创建不同的PendingIntent
+ PendingIntent pendingIntent;
+ if (tickerId != R.string.ticker_success) {
+ pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+ NotesPreferenceActivity.class), 0);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ } else {
+ pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+ NotesListActivity.class), 0); // 启动笔记列表活动
+ }
+ // 设置通知的最新事件信息
+ notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
+ pendingIntent);
+<<<<<<< HEAD
+ mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification); // 发送通知
+=======
+ // 发送通知
+ mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ }
+
+ // 后台执行同步操作的方法
+ @Override
+ protected Integer doInBackground(Void... unused) {
+ // 发布登录进度
+ publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
+ .getSyncAccountName(mContext)));
+ return mTaskManager.sync(mContext, this); // 调用同步方法并返回状态
+ }
+
+ // 更新进度的方法
+ @Override
+ protected void onProgressUpdate(String... progress) {
+ showNotification(R.string.ticker_syncing, progress[0]); // 显示同步进度通知
+ // 如果上下文是GTaskSyncService，则广播进度消息
+ if (mContext instanceof GTaskSyncService) {
+ ((GTaskSyncService) mContext).sendBroadcast(progress[0]);
+ }
+ }
+
+ // 执行完毕后的方法
+ @Override
+ protected void onPostExecute(Integer result) {
+<<<<<<< HEAD
+ // 根据同步结果显示相应的通知
+=======
+ // 根据结果展示不同的通知
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ if (result == GTaskManager.STATE_SUCCESS) {
+ showNotification(R.string.ticker_success, mContext.getString(
+ R.string.success_sync_account, mTaskManager.getSyncAccount()));
+ NotesPreferenceActivity.setLastSyncTime(mContext, System.currentTimeMillis()); // 记录最后同步时间
+ } else if (result == GTaskManager.STATE_NETWORK_ERROR) {
+ showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_network)); // 显示网络错误通知
+ } else if (result == GTaskManager.STATE_INTERNAL_ERROR) {
+ showNotification(R.string.ticker_fail, mContext.getString(R.string.error_sync_internal)); // 显示内部错误通知
+ } else if (result == GTaskManager.STATE_SYNC_CANCELLED) {
+ showNotification(R.string.ticker_cancel, mContext
+ .getString(R.string.error_sync_cancelled)); // 显示取消同步通知
+ }
+<<<<<<< HEAD
+ // 如果存在完成监听器，则在新线程中调用其onComplete方法
+=======
+ // 如果存在完成监听器，则通知监听器任务完成
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ if (mOnCompleteListener != null) {
+ new Thread(new Runnable() {
+ public void run() {
+ mOnCompleteListener.onComplete(); // 调用完成监听器的onComplete方法
+ }
+ }).start();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
new file mode 100644
index 0000000..beb8e62
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
@@ -0,0 +1,966 @@
+<<<<<<< HEAD
+/*
+ * 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.
+ */
+
+// 定义包名
+=======
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+package net.micode.notes.gtask.remote;
+
+// 导入相关类和接口
+import android.accounts.Account; // 引入账户类
+import android.accounts.AccountManager; // 引入账户管理类
+import android.accounts.AccountManagerFuture; // 引入账户管理未来对象类
+import android.app.Activity; // 引入活动类
+import android.os.Bundle; // 引入包类
+import android.text.TextUtils; // 引入文本工具类
+import android.util.Log; // 引入日志工具类
+
+// 导入自定义数据模型和异常处理类
+import net.micode.notes.gtask.data.Node; // 引入节点数据模型
+import net.micode.notes.gtask.data.Task; // 引入任务数据模型
+import net.micode.notes.gtask.data.TaskList; // 引入任务列表数据模型
+import net.micode.notes.gtask.exception.ActionFailureException; // 引入动作失败异常
+import net.micode.notes.gtask.exception.NetworkFailureException; // 引入网络失败异常
+import net.micode.notes.tool.GTaskStringUtils; // 引入GTask字符串工具类
+import net.micode.notes.ui.NotesPreferenceActivity; // 引入笔记偏好活动类
+
+// 导入Apache HttpClient相关的类
+import org.apache.http.HttpEntity; // 引入HTTP实体类
+import org.apache.http.HttpResponse; // 引入HTTP响应类
+import org.apache.http.client.ClientProtocolException; // 引入客户端协议异常
+import org.apache.http.client.entity.UrlEncodedFormEntity; // 引入URL编码表单实体类
+import org.apache.http.client.methods.HttpGet; // 引入HTTP GET请求类
+import org.apache.http.client.methods.HttpPost; // 引入HTTP POST请求类
+import org.apache.http.cookie.Cookie; // 引入Cookie类
+import org.apache.http.impl.client.BasicCookieStore; // 引入基本Cookie存储类
+import org.apache.http.impl.client.DefaultHttpClient; // 引入默认HTTP客户端类
+import org.apache.http.message.BasicNameValuePair; // 引入基本名称值对类
+import org.apache.http.params.BasicHttpParams; // 引入基本HTTP参数类
+import org.apache.http.params.HttpConnectionParams; // 引入HTTP连接参数类
+import org.apache.http.params.HttpParams; // 引入HTTP参数类
+
+// 导入JSON相关的类
+import org.json.JSONArray; // 引入JSON数组类
+import org.json.JSONException; // 引入JSON异常类
+import org.json.JSONObject; // 引入JSON对象类
+
+<<<<<<< HEAD
+// 引入JDK类
+import java.io.BufferedReader; // 引入缓冲读取器类
+import java.io.IOException; // 引入IO异常类
+import java.io.InputStream; // 引入输入流类
+import java.io.InputStreamReader; // 引入输入流读取器类
+import java.util.LinkedList; // 引入链表类
+import java.util.List; // 引入列表类
+import java.util.zip.GZIPInputStream; // 引入GZIP输入流类
+import java.util.zip.Inflater; // 引入解压缩类
+import java.util.zip.InflaterInputStream; // 引入解压缩输入流类
+
+// GTaskClient类负责处理与Google任务(GTask)的通信
+=======
+// GTaskClient类用于与Google Tasks进行交互，实现诸如登录、任务和任务列表的创建、更新、移动、删除以及获取相关数据等功能
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+public class GTaskClient {
+ // 日志标签
+ private static final String TAG = GTaskClient.class.getSimpleName();
+
+<<<<<<< HEAD
+ // Google任务相关的URL
+ private static final String GTASK_URL = "https://mail.google.com/tasks/";
+ private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
+=======
+ // Google Tasks的基础URL
+ private static final String GTASK_URL = "https://mail.google.com/tasks/";
+ // 用于获取Google Tasks数据的URL
+ private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
+ // 用于向Google Tasks发送POST请求的URL
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
+
+ // 单例实例
+ private static GTaskClient mInstance = null;
+
+<<<<<<< HEAD
+ // HTTP客户端
+ private DefaultHttpClient mHttpClient;
+
+ // GET和POST请求的URL
+ private String mGetUrl;
+ private String mPostUrl;
+
+ // 客户端版本和登录状态相关的字段
+ private long mClientVersion;
+ private boolean mLoggedin;
+ private long mLastLoginTime;
+ private int mActionId;
+ private Account mAccount;
+
+ // 更新数组
+ private JSONArray mUpdateArray;
+
+ // 私有构造函数，初始化类的成员变量
+=======
+ // 用于发送HTTP请求的HttpClient对象
+ private DefaultHttpClient mHttpClient;
+ // 获取数据的具体URL
+ private String mGetUrl;
+ // 发送POST请求的具体URL
+ private String mPostUrl;
+ // 客户端版本号
+ private long mClientVersion;
+ // 标记是否已登录
+ private boolean mLoggedin;
+ // 上次登录的时间戳
+ private long mLastLoginTime;
+ // 用于标识操作的ID，每次操作自增
+ private int mActionId;
+ // 当前使用的账户
+ private Account mAccount;
+ // 用于暂存更新操作相关数据的JSON数组
+ private JSONArray mUpdateArray;
+
+ // 私有构造函数，初始化相关成员变量
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ private GTaskClient() {
+ mHttpClient = null;
+ mGetUrl = GTASK_GET_URL;
+ mPostUrl = GTASK_POST_URL;
+ mClientVersion = -1;
+ mLoggedin = false;
+ mLastLoginTime = 0;
+ mActionId = 1;
+ mAccount = null;
+ mUpdateArray = null;
+ }
+
+<<<<<<< HEAD
+ // 获取单例实例
+=======
+ // 获取GTaskClient的单例实例
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public static synchronized GTaskClient getInstance() {
+ if (mInstance == null) {
+ mInstance = new GTaskClient();
+ }
+ return mInstance;
+ }
+
+<<<<<<< HEAD
+ // 登录方法
+ public boolean login(Activity activity) {
+ // 假设cookie在5分钟后过期
+=======
+ // 执行登录操作
+ public boolean login(Activity activity) {
+ // 假设Cookie在5分钟后过期，若距离上次登录时间超过5分钟，则需要重新登录
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ final long interval = 1000 * 60 * 5;
+ if (mLastLoginTime + interval < System.currentTimeMillis()) {
+ mLoggedin = false; // 如果超时，设置未登录
+ }
+
+<<<<<<< HEAD
+ // 如果账户切换，需要重新登录
+ if (mLoggedin && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity.getSyncAccountName(activity))) {
+ mLoggedin = false; // 账户切换，重新登录
+=======
+ // 如果已登录，但当前账户与设置中的同步账户不一致，也需要重新登录
+ if (mLoggedin
+ && !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
+ .getSyncAccountName(activity))) {
+ mLoggedin = false;
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ }
+
+ // 若已经登录，无需再次登录
+ if (mLoggedin) {
+ Log.d(TAG, "already logged in");
+ return true;
+ }
+
+<<<<<<< HEAD
+ mLastLoginTime = System.currentTimeMillis(); // 更新最后登录时间
+ String authToken = loginGoogleAccount(activity, false); // 获取Google账户的认证令牌
+=======
+ mLastLoginTime = System.currentTimeMillis();
+ // 登录Google账户获取授权令牌
+ String authToken = loginGoogleAccount(activity, false);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ if (authToken == null) {
+ Log.e(TAG, "login google account failed");
+ return false; // 登录失败
+ }
+
+<<<<<<< HEAD
+ // 如果为自定义域，则尝试进行登录
+ if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase().endsWith("googlemail.com"))) {
+=======
+ // 如果账户不是以gmail.com或googlemail.com结尾（可能是自定义域名），则使用自定义域名相关的URL进行登录
+ if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
+ .endsWith("googlemail.com"))) {
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
+ int index = mAccount.name.indexOf('@') + 1;
+ String suffix = mAccount.name.substring(index);
+ url.append(suffix + "/");
+ mGetUrl = url.toString() + "ig"; // 更新GET请求的URL
+ mPostUrl = url.toString() + "r/ig"; // 更新POST请求的URL
+
+ if (tryToLoginGtask(activity, authToken)) {
+ mLoggedin = true; // 登录成功
+ }
+ }
+
+<<<<<<< HEAD
+ // 尝试以 Google 官方 URL 登录
+=======
+ // 如果使用自定义域名登录失败，则尝试使用Google官方URL登录
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ if (!mLoggedin) {
+ mGetUrl = GTASK_GET_URL; // 恢复默认的GET请求URL
+ mPostUrl = GTASK_POST_URL; // 恢复默认的POST请求URL
+ if (!tryToLoginGtask(activity, authToken)) {
+ return false; // 登录失败
+ }
+ }
+
+ mLoggedin = true; // 设置为已登录
+ return true;
+ }
+
+<<<<<<< HEAD
+ // 获取Google账户认证令牌的方法
+ private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
+ String authToken;
+ AccountManager accountManager = AccountManager.get(activity); // 获取账户管理器
+ Account[] accounts = accountManager.getAccountsByType("com.google"); // 获取Google账户
+=======
+ // 登录Google账户获取授权令牌
+ private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
+ String authToken;
+ // 获取账户管理器
+ AccountManager accountManager = AccountManager.get(activity);
+ // 获取所有Google类型的账户
+ Account[] accounts = accountManager.getAccountsByType("com.google");
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+
+ // 如果没有可用的Google账户，日志记录并返回null
+ if (accounts.length == 0) {
+ Log.e(TAG, "there is no available google account");
+ return null;
+ }
+
+<<<<<<< HEAD
+ String accountName = NotesPreferenceActivity.getSyncAccountName(activity); // 获取同步的账户名
+=======
+ // 获取设置中的同步账户名称
+ String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ Account account = null;
+
+ // 找到设置中与账户名匹配的账户
+ for (Account a : accounts) {
+ if (a.name.equals(accountName)) {
+ account = a;
+ break;
+ }
+ }
+ if (account != null) {
+ mAccount = account; // 设置账户
+ } else {
+ Log.e(TAG, "unable to get an account with the same name in the settings");
+ return null; // 找不到匹配账户，返回null
+ }
+
+<<<<<<< HEAD
+ // 获取认证令牌
+ AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account, "goanna_mobile", null, activity, null, null);
+=======
+ // 获取授权令牌
+ AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account,
+ "goanna_mobile", null, activity, null, null);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ try {
+ Bundle authTokenBundle = accountManagerFuture.getResult(); // 获取结果
+ authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN); // 读取令牌
+
+ // 如果需要无效化令牌，则重新获取
+ if (invalidateToken) {
+ // 如果需要使令牌失效，则先失效再重新获取
+ accountManager.invalidateAuthToken("com.google", authToken);
+ loginGoogleAccount(activity, false); // 递归调用获取新令牌
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "get auth token failed");
+ authToken = null; // 获取token失败
+ }
+
+ return authToken; // 返回令牌
+ }
+
+<<<<<<< HEAD
+ // 尝试登录到GTask
+ private boolean tryToLoginGtask(Activity activity, String authToken) {
+ if (!loginGtask(authToken)) {
+ // 如果认证令牌过期，则无效化并尝试重新登录
+=======
+ // 尝试登录Google Tasks
+ private boolean tryToLoginGtask(Activity activity, String authToken) {
+ if (!loginGtask(authToken)) {
+ // 如果登录失败，可能是授权令牌过期，先使令牌失效再重新尝试登录Google账户获取新令牌，然后再次登录Google Tasks
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ authToken = loginGoogleAccount(activity, true);
+ if (authToken == null) {
+ Log.e(TAG, "login google account failed");
+ return false; // 登录失败
+ }
+
+ if (!loginGtask(authToken)) {
+ Log.e(TAG, "login gtask failed");
+ return false; // 登录失败
+ }
+ }
+ return true; // 登录成功
+ }
+
+<<<<<<< HEAD
+ // 使用认证令牌登录到GTask
+ private boolean loginGtask(String authToken) {
+ int timeoutConnection = 10000; // 连接超时设置
+ int timeoutSocket = 15000; // Socket超时设置
+ HttpParams httpParameters = new BasicHttpParams(); // 创建基本HTTP参数
+ HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection); // 设置连接超时
+ HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket); // 设置Socket超时
+ mHttpClient = new DefaultHttpClient(httpParameters); // 创建HTTP客户端
+ BasicCookieStore localBasicCookieStore = new BasicCookieStore(); // 创建Cookie存储
+ mHttpClient.setCookieStore(localBasicCookieStore); // 设置Cookie存储
+ HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false); // 设置HTTP协议参数
+
+ // 登录GTask
+=======
+ // 实际执行登录Google Tasks的操作，获取相关信息（如客户端版本号等）
+ private boolean loginGtask(String authToken) {
+ int timeoutConnection = 10000;
+ int timeoutSocket = 15000;
+ // 设置HTTP请求的参数，包括连接超时和读取超时时间
+ HttpParams httpParameters = new BasicHttpParams();
+ HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
+ HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
+ mHttpClient = new DefaultHttpClient(httpParameters);
+ BasicCookieStore localBasicCookieStore = new BasicCookieStore();
+ mHttpClient.setCookieStore(localBasicCookieStore);
+ HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
+
+ // 登录Google Tasks，发送带有授权令牌的GET请求
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ try {
+ String loginUrl = mGetUrl + "?auth=" + authToken; // 创建登录URL
+ HttpGet httpGet = new HttpGet(loginUrl); // 创建GET请求
+ HttpResponse response = mHttpClient.execute(httpGet); // 执行请求
+
+<<<<<<< HEAD
+ // 获取Cookie
+=======
+ // 获取登录后的Cookie信息，检查是否包含认证相关的Cookie（名称包含"GTL"）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ List cookies = mHttpClient.getCookieStore().getCookies();
+ boolean hasAuthCookie = false; // 验证是否存在认证Cookie
+ for (Cookie cookie : cookies) {
+ if (cookie.getName().contains("GTL")) {
+ hasAuthCookie = true; // 存在认证Cookie
+ }
+ }
+ if (!hasAuthCookie) {
+ Log.w(TAG, "it seems that there is no auth cookie"); // 没有认证Cookie的警告
+ }
+
+<<<<<<< HEAD
+ // 从响应中获取客户端版本
+=======
+ // 从响应中获取客户端版本号等信息，通过解析返回的JavaScript代码中的相关数据
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ String resString = getResponseContent(response.getEntity());
+ String jsBegin = "_setup(";
+ String jsEnd = ")}";
+ int begin = resString.indexOf(jsBegin);
+ int end = resString.lastIndexOf(jsEnd);
+ String jsString = null;
+ if (begin != -1 && end != -1 && begin < end) {
+ jsString = resString.substring(begin + jsBegin.length(), end); // 提取JSON字符串
+ }
+ JSONObject js = new JSONObject(jsString); // 创建JSON对象
+ mClientVersion = js.getLong("v"); // 获取客户端版本
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ return false; // 处理JSON异常，返回登录失败
+ } catch (Exception e) {
+<<<<<<< HEAD
+=======
+ // 捕获其他所有异常，若发生异常则登录失败
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ Log.e(TAG, "httpget gtask_url failed");
+ return false; // 处理其他异常，返回登录失败
+ }
+
+ return true; // 登录成功
+ }
+
+<<<<<<< HEAD
+ // 获取下一个动作ID
+=======
+ // 获取下一个操作的ID
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ private int getActionId() {
+ return mActionId++; // 返回当前ID并递增
+ }
+
+<<<<<<< HEAD
+ // 创建HTTP POST请求
+=======
+ // 创建用于发送POST请求的HttpPost对象，并设置相关请求头
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ private HttpPost createHttpPost() {
+ HttpPost httpPost = new HttpPost(mPostUrl); // 创建POST请求
+ httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8"); // 设置请求头
+ httpPost.setHeader("AT", "1"); // 设置自定义请求头
+ return httpPost; // 返回POST请求
+ }
+
+<<<<<<< HEAD
+ // 获取HTTP响应内容
+=======
+ // 从HTTP实体中获取响应内容，根据内容编码（如gzip、deflate等）进行相应的解压处理
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ private String getResponseContent(HttpEntity entity) throws IOException {
+ String contentEncoding = null; // 声明内容编码
+ if (entity.getContentEncoding() != null) {
+ contentEncoding = entity.getContentEncoding().getValue(); // 获取内容编码
+ Log.d(TAG, "encoding: " + contentEncoding);
+ }
+
+ InputStream input = entity.getContent(); // 获取输入流
+ // 根据内容编码类型进行处理
+ if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {
+ input = new GZIPInputStream(entity.getContent()); // 处理GZIP编码
+ } else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {
+ Inflater inflater = new Inflater(true);
+ input = new InflaterInputStream(entity.getContent(), inflater); // 处理Deflate编码
+ }
+
+ try {
+ InputStreamReader isr = new InputStreamReader(input); // 创建输入流读取器
+ BufferedReader br = new BufferedReader(isr); // 创建缓冲读取器
+ StringBuilder sb = new StringBuilder(); // 创建字符串构建器
+
+ // 持续读取内容
+ while (true) {
+ String buff = br.readLine(); // 读取一行
+ if (buff == null) {
+ return sb.toString(); // 如果没有内容，返回结果
+ }
+ sb = sb.append(buff); // 添加读取内容
+ }
+ } finally {
+ input.close(); // 关闭输入流
+ }
+ }
+
+<<<<<<< HEAD
+ // 发送POST请求
+=======
+ // 发送POST请求，将JSON数据发送到Google Tasks服务器，并处理响应返回的JSON数据
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
+ if (!mLoggedin) {
+ Log.e(TAG, "please login first"); // 如果未登录，记录错误
+ throw new ActionFailureException("not logged in"); // 抛出异常
+ }
+
+ HttpPost httpPost = createHttpPost(); // 创建POST请求
+ try {
+ LinkedList list = new LinkedList(); // 创建参数列表
+ list.add(new BasicNameValuePair("r", js.toString())); // 添加请求参数
+ UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8"); // 创建实体
+ httpPost.setEntity(entity); // 设置POST实体
+
+<<<<<<< HEAD
+ // 执行POST请求并获取响应
+=======
+ // 执行POST请求并获取响应，然后解析响应内容为JSONObject返回
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ HttpResponse response = mHttpClient.execute(httpPost);
+ String jsString = getResponseContent(response.getEntity()); // 获取响应内容
+ return new JSONObject(jsString); // 返回响应的JSON对象
+
+ } catch (ClientProtocolException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new NetworkFailureException("postRequest failed"); // 抛出网络失败异常
+ } catch (IOException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new NetworkFailureException("postRequest failed"); // 抛出IO异常
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("unable to convert response content to jsonobject"); // 抛出JSON转换异常
+ } catch (Exception e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("error occurs when posting request"); // 其它异常处理
+ }
+ }
+
+<<<<<<< HEAD
+ // 创建任务
+=======
+ // 创建一个任务并发送到Google Tasks服务器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public void createTask(Task task) throws NetworkFailureException {
+ commitUpdate(); // 提交更新
+ try {
+ JSONObject jsPost = new JSONObject(); // 创建JSON对象
+ JSONArray actionList = new JSONArray(); // 创建动作列表
+
+<<<<<<< HEAD
+ // 添加创建动作到动作列表
+=======
+ // 将任务的创建操作添加到操作列表中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ actionList.put(task.getCreateAction(getActionId()));
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 添加动作列表到JSON对象
+
+<<<<<<< HEAD
+ // 添加客户端版本到JSON对象
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ // 执行POST请求
+=======
+ // 设置客户端版本号
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ // 发送POST请求并处理响应，获取新创建任务的ID并设置到任务对象中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ JSONObject jsResponse = postRequest(jsPost);
+ JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_RESULTS).get(0); // 获取返回结果
+ task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); // 设置任务的ID
+
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("create task: handing jsonobject failed"); // 抛出JSON处理异常
+ }
+ }
+
+<<<<<<< HEAD
+ // 创建任务列表
+=======
+ // 创建一个任务列表并发送到Google Tasks服务器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public void createTaskList(TaskList tasklist) throws NetworkFailureException {
+ commitUpdate(); // 提交更新
+ try {
+ JSONObject jsPost = new JSONObject(); // 创建JSON对象
+ JSONArray actionList = new JSONArray(); // 创建动作列表
+
+<<<<<<< HEAD
+ // 添加创建动作到动作列表
+=======
+ // 将任务列表的创建操作添加到操作列表中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ actionList.put(tasklist.getCreateAction(getActionId()));
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 添加动作列表到JSON对象
+
+<<<<<<< HEAD
+ // 添加客户端版本到JSON对象
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ // 执行POST请求
+=======
+ // 设置客户端版本号
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ // 发送POST请求并处理响应，获取新创建任务列表的ID并设置到任务列表对象中
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ JSONObject jsResponse = postRequest(jsPost);
+ JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_RESULTS).get(0); // 获取返回结果
+ tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID)); // 设置任务列表的ID
+
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("create tasklist: handing jsonobject failed"); // 抛出JSON处理异常
+ }
+ }
+
+<<<<<<< HEAD
+ // 提交更新
+=======
+ // 提交更新操作，将暂存的更新操作数组发送到服务器
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public void commitUpdate() throws NetworkFailureException {
+ // 如果存在更新数组
+ if (mUpdateArray != null) {
+ try {
+ JSONObject jsPost = new JSONObject(); // 创建JSON对象
+
+<<<<<<< HEAD
+ // 添加动作列表到JSON对象
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray);
+ // 添加客户端版本到JSON对象
+=======
+ // 设置操作列表
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray);
+
+ // 设置客户端版本号
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ postRequest(jsPost); // 执行POST请求
+ mUpdateArray = null; // 清空更新数组
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("commit update: handing jsonobject failed"); // 抛出JSON处理异常
+ }
+ }
+ }
+
+<<<<<<< HEAD
+ // 添加更新节点
+ public void addUpdateNode(Node node) throws NetworkFailureException {
+ if (node != null) {
+ // 更新项目过多可能会导致错误，最多设为10个项目
+=======
+ // 添加一个节点的更新操作到暂存的更新操作数组中，限制最多10个更新项
+ // 将节点的更新操作添加到更新数组中，如果更新数组中的元素超过10个，则先提交更新
+ public void addUpdateNode(Node node) throws NetworkFailureException {
+ if (node != null) {
+ // 过多的更新项可能会导致错误，所以设置最大更新项数量为10个
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ if (mUpdateArray != null && mUpdateArray.length() > 10) {
+ commitUpdate(); // 提交更新
+ }
+
+ // 如果更新数组为空，则创建一个新的JSONArray对象用于存放更新操作
+ if (mUpdateArray == null)
+<<<<<<< HEAD
+ mUpdateArray = new JSONArray(); // 初始化更新数组
+ mUpdateArray.put(node.getUpdateAction(getActionId())); // 将更新的节点添加到数组
+ }
+ }
+
+ // 移动任务
+ public void moveTask(Task task, TaskList preParent, TaskList curParent) throws NetworkFailureException {
+ commitUpdate(); // 提交更新
+=======
+ mUpdateArray = new JSONArray();
+ // 将节点的更新操作（通过节点获取，操作ID使用当前的操作ID）添加到更新数组中
+ mUpdateArray.put(node.getUpdateAction(getActionId()));
+ }
+ }
+
+ // 移动任务，将任务从一个任务列表移动到另一个任务列表（可能是同一个列表内移动位置）
+ public void moveTask(Task task, TaskList preParent, TaskList curParent)
+ throws NetworkFailureException {
+ commitUpdate();
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ try {
+ JSONObject jsPost = new JSONObject(); // 创建JSON对象
+ JSONArray actionList = new JSONArray(); // 创建动作列表
+ JSONObject action = new JSONObject(); // 创建动作对象
+
+<<<<<<< HEAD
+ // 构建移动动作
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE);
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
+ action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid()); // 设置任务ID
+
+ // 如果前后父任务相同且任务有前兄弟，则附加前兄弟ID
+ if (preParent == curParent && task.getPriorSibling() != null) {
+ action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
+ }
+ action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid()); // 源任务列表ID
+ action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid()); // 目标父任务列表ID
+
+ // 如果任务从一个任务列表移动到另一个任务列表，则附加目标列表ID
+ if (preParent != curParent) {
+ action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
+ }
+ actionList.put(action); // 添加动作到动作列表
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 添加动作列表到JSON对象
+
+ // 添加客户端版本到JSON对象
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ postRequest(jsPost); // 执行POST请求
+=======
+ // 操作列表相关设置
+ // 设置操作类型为移动任务（对应预定义的移动操作类型常量）
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_MOVE);
+ // 设置操作的唯一ID，通过获取下一个可用的操作ID来赋值
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
+ // 设置要移动的任务的全局唯一ID
+ action.put(GTaskStringUtils.GTASK_JSON_ID, task.getGid());
+ // 如果移动前后的父任务列表相同（即在同一个任务列表内移动），并且任务不是该列表中的第一个任务，
+ // 则设置其前一个兄弟任务的ID，用于确定移动后的顺序
+ if (preParent == curParent && task.getPriorSibling() != null) {
+ action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
+ }
+ // 设置任务原来所在的任务列表的全局唯一ID（源列表）
+ action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());
+ // 设置任务要移动到的目标任务列表的父级任务列表的全局唯一ID（目标父列表）
+ action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid());
+ // 如果移动是在不同的任务列表之间进行，则设置目标任务列表的全局唯一ID（目标列表）
+ if (preParent != curParent) {
+ action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
+ }
+ // 将这个移动操作添加到操作列表中
+ actionList.put(action);
+ // 将操作列表添加到要发送的JSON数据对象中，对应预定义的操作列表的JSON键
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+ // 设置客户端版本号，对应预定义的客户端版本号的JSON键
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ // 发送POST请求，将包含移动任务操作信息的JSON数据发送到服务器进行处理
+ postRequest(jsPost);
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+<<<<<<< HEAD
+ throw new ActionFailureException("move task: handing jsonobject failed"); // 抛出JSON处理异常
+ }
+ }
+
+ // 删除节点
+=======
+ // 如果JSON处理出现异常，抛出操作失败异常，并说明是移动任务时处理JSON对象失败
+ throw new ActionFailureException("move task: handing jsonobject failed");
+ }
+ }
+
+ // 删除节点（比如任务、任务列表等），通过设置节点的删除标记为true，并将其更新操作发送到服务器来实现删除
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public void deleteNode(Node node) throws NetworkFailureException {
+ commitUpdate(); // 提交更新
+ try {
+ JSONObject jsPost = new JSONObject(); // 创建JSON对象
+ JSONArray actionList = new JSONArray(); // 创建动作列表
+
+<<<<<<< HEAD
+ // 标记节点为已删除并添加到动作列表
+ node.setDeleted(true);
+ actionList.put(node.getUpdateAction(getActionId())); // 获取节点更新动作并添加到列表
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 添加动作列表到JSON对象
+
+ // 添加客户端版本到JSON对象
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ postRequest(jsPost); // 执行POST请求
+ mUpdateArray = null; // 清空更新数组
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("delete node: handing jsonobject failed"); // 抛出JSON处理异常
+ }
+ }
+
+ // 获取任务列表
+=======
+ // 操作列表相关设置
+ // 将节点标记为已删除
+ node.setDeleted(true);
+ // 将节点的更新操作（此时因为已标记为删除，对应的就是删除操作）添加到操作列表中
+ actionList.put(node.getUpdateAction(getActionId()));
+ // 将操作列表添加到要发送的JSON数据对象中，对应预定义的操作列表的JSON键
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+ // 设置客户端版本号，对应预定义的客户端版本号的JSON键
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ // 发送POST请求，将包含删除节点操作信息的JSON数据发送到服务器进行处理
+ postRequest(jsPost);
+ // 发送成功后，将更新数组置空，因为相关更新操作已提交完成
+ mUpdateArray = null;
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ // 如果JSON处理出现异常，抛出操作失败异常，并说明是删除节点时处理JSON对象失败
+ throw new ActionFailureException("delete node: handing jsonobject failed");
+ }
+ }
+
+ // 获取所有的任务列表信息，前提是已经登录成功，否则会抛出异常提示需要先登录
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public JSONArray getTaskLists() throws NetworkFailureException {
+ if (!mLoggedin) {
+ Log.e(TAG, "please login first"); // 如果未登录，记录错误
+ throw new ActionFailureException("not logged in"); // 抛出异常
+ }
+
+ try {
+<<<<<<< HEAD
+ HttpGet httpGet = new HttpGet(mGetUrl); // 创建GET请求
+ HttpResponse response = mHttpClient.execute(httpGet); // 执行请求
+
+ // 获取任务列表
+ String resString = getResponseContent(response.getEntity()); // 获取响应内容
+=======
+ // 创建一个HTTP GET请求对象，用于获取任务列表数据，请求的URL是之前设置好的获取数据的URL
+ HttpGet httpGet = new HttpGet(mGetUrl);
+ HttpResponse response = null;
+ // 执行HTTP GET请求，获取服务器的响应
+ response = mHttpClient.execute(httpGet);
+
+ // 从响应的实体中获取内容，并进行处理，提取出包含任务列表信息的JSON数据部分
+ String resString = getResponseContent(response.getEntity());
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ String jsBegin = "_setup(";
+ String jsEnd = ")}";
+ int begin = resString.indexOf(jsBegin);
+ int end = resString.lastIndexOf(jsEnd);
+ String jsString = null;
+ // 提取JSON字符串
+ if (begin != -1 && end != -1 && begin < end) {
+ jsString = resString.substring(begin + jsBegin.length(), end);
+ }
+<<<<<<< HEAD
+ JSONObject js = new JSONObject(jsString); // 创建JSON对象
+ return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS); // 返回任务列表
+ } catch (ClientProtocolException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new NetworkFailureException("gettasklists: httpget failed"); // 抛出网络请求失败异常
+ } catch (IOException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new NetworkFailureException("gettasklists: httpget failed"); // 抛出IO异常
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("get task lists: handing jasonobject failed"); // 抛出JSON处理异常
+ }
+ }
+
+ // 获取指定任务列表
+=======
+ JSONObject js = new JSONObject(jsString);
+ // 从解析后的JSON对象中获取任务列表数组并返回，对应预定义的任务列表的JSON键
+ return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS);
+ } catch (ClientProtocolException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ // 如果HTTP协议相关操作出现异常，抛出网络失败异常，并说明是获取任务列表时HTTP GET请求失败
+ throw new NetworkFailureException("gettasklists: httpget failed");
+ } catch (IOException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ // 如果输入输出操作出现异常，抛出网络失败异常，并说明是获取任务列表时HTTP GET请求失败
+ throw new NetworkFailureException("gettasklists: httpget failed");
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ // 如果JSON处理出现异常，抛出操作失败异常，并说明是获取任务列表时处理JSON对象失败
+ throw new ActionFailureException("get task lists: handing jasonobject failed");
+ }
+ }
+
+ // 根据给定的任务列表全局唯一ID，获取该任务列表中的任务信息，需要先提交之前暂存的更新操作
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public JSONArray getTaskList(String listGid) throws NetworkFailureException {
+ commitUpdate(); // 提交更新
+ try {
+ JSONObject jsPost = new JSONObject(); // 创建JSON对象
+ JSONArray actionList = new JSONArray(); // 创建动作列表
+ JSONObject action = new JSONObject(); // 创建动作对象
+
+<<<<<<< HEAD
+ // 构建获取所有任务的动作
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL);
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
+ action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid); // 设置列表ID
+ action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false); // 不获取已删除的任务
+ actionList.put(action); // 添加动作到动作列表
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList); // 添加动作列表到JSON对象
+
+ // 添加客户端版本到JSON对象
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ JSONObject jsResponse = postRequest(jsPost); // 执行POST请求
+ return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS); // 返回任务数组
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("get task list: handing jsonobject failed"); // 抛出JSON处理异常
+ }
+ }
+
+ // 获取同步账户
+=======
+ // 操作列表相关设置
+ // 设置操作类型为获取所有任务（对应预定义的获取所有任务操作类型常量）
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
+ GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL);
+ // 设置操作的唯一ID，通过获取下一个可用的操作ID来赋值
+ action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
+ // 设置要获取任务的任务列表的全局唯一ID
+ action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid);
+ // 设置是否获取已删除的任务，这里设置为false，表示不获取已删除任务
+ action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false);
+ // 将这个获取任务操作添加到操作列表中
+ actionList.put(action);
+ // 将操作列表添加到要发送的JSON数据对象中，对应预定义的操作列表的JSON键
+ jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
+
+ // 设置客户端版本号，对应预定义的客户端版本号的JSON键
+ jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+
+ // 发送POST请求，将包含获取任务列表中任务操作信息的JSON数据发送到服务器进行处理
+ JSONObject jsResponse = postRequest(jsPost);
+ // 从服务器响应的JSON数据中获取任务数组并返回，对应预定义的任务的JSON键
+ return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS);
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ // 如果JSON处理出现异常，抛出操作失败异常，并说明是获取任务列表时处理JSON对象失败
+ throw new ActionFailureException("get task list: handing jsonobject failed");
+ }
+ }
+
+ // 获取当前用于同步的账户信息
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public Account getSyncAccount() {
+ return mAccount; // 返回账户信息
+ }
+
+<<<<<<< HEAD
+ // 重置更新数组
+ public void resetUpdateArray() {
+ mUpdateArray = null; // 清空更新数组
+ }
+}
+=======
+ // 重置更新数组，即将其置为空，一般用于清除之前暂存的更新操作相关数据
+public void resetUpdateArray() {
+ mUpdateArray = null;
+}
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
new file mode 100644
index 0000000..83b6a11
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
@@ -0,0 +1,945 @@
+/*
+ * 版权所有 (c) 2010-2011, MiCode 开源社区 (www.micode.net)
+ *
+ * 根据 Apache 许可证，第 2.0 版（“许可证”）许可；
+ * 除非遵循许可证，否则不得使用此文件。
+ * 可以在以下网址获取许可证副本：
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 除非适用于相关法律或书面协议，否则根据许可证分发的软件
+ * 是以“原样”基础提供，不提供任何形式的保证或条件，无论是明示的还是暗示的。
+ * 请参阅许可证以了解特定语言管理权限和
+ * 许可证下的限制。
+ */
+
+// 定义包
+package net.micode.notes.gtask.remote;
+
+// 导入需要的类
+import android.app.Activity; // 用于活动管理的类
+import android.content.ContentResolver; // 用于内容提供者的类
+import android.content.ContentUris; // 处理内容 URI 的工具类
+import android.content.ContentValues; // 包含 ContentProvider 插入或更新所需值的类
+import android.content.Context; // 应用上下文类
+import android.database.Cursor; // 数据库查询结果的类
+import android.util.Log; // 记录日志的工具类
+
+// 导入项目中的相关类
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+<<<<<<< HEAD
+import net.micode.notes.data.Notes.DataColumns; // 数据列常量
+import net.micode.notes.data.Notes.NoteColumns; // 笔记列常量
+import net.micode.notes.gtask.data.MetaData; // 任务元数据类
+import net.micode.notes.gtask.data.Node; // 节点类
+import net.micode.notes.gtask.data.SqlNote; // SQL 笔记类
+import net.micode.notes.gtask.data.Task; // 任务类
+import net.micode.notes.gtask.data.TaskList; // 任务列表类
+import net.micode.notes.gtask.exception.ActionFailureException; // 操作失败异常
+import net.micode.notes.gtask.exception.NetworkFailureException; // 网络失败异常
+import net.micode.notes.tool.DataUtils; // 数据工具类
+import net.micode.notes.tool.GTaskStringUtils; // GTask 字符串工具类
+
+import org.json.JSONArray; // JSON 数组类
+import org.json.JSONException; // JSON 异常类
+import org.json.JSONObject; // JSON 对象类
+
+import java.util.HashMap; // 哈希表实现
+import java.util.HashSet; // 哈希集合实现
+import java.util.Iterator; // 迭代器类
+=======
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.data.MetaData;
+import net.micode.notes.gtask.data.Node;
+import net.micode.notes.gtask.data.SqlNote;
+import net.micode.notes.gtask.data.Task;
+import net.micode.notes.gtask.data.TaskList;
+import net.micode.notes.gtask.exception.ActionFailureException;
+import net.micode.notes.gtask.exception.NetworkFailureException;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.GTaskStringUtils;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+
+// GTaskManager类用于管理与Google Tasks的同步操作，包括初始化任务列表、同步内容、处理各种同步类型的操作等功能
+public class GTaskManager {
+ private static final String TAG = GTaskManager.class.getSimpleName();
+
+ // 同步成功状态码
+ public static final int STATE_SUCCESS = 0;
+ // 网络错误状态码
+ public static final int STATE_NETWORK_ERROR = 1;
+ // 内部错误状态码
+ public static final int STATE_INTERNAL_ERROR = 2;
+ // 同步正在进行状态码
+ public static final int STATE_SYNC_IN_PROGRESS = 3;
+ // 同步被取消状态码
+ public static final int STATE_SYNC_CANCELLED = 4;
+
+ private static GTaskManager mInstance = null;
+
+ // 关联的Activity，用于获取授权令牌等操作
+ private Activity mActivity;
+ // 应用上下文
+ private Context mContext;
+ // 用于操作内容提供器，进行数据查询、更新等操作
+ private ContentResolver mContentResolver;
+ // 标记是否正在同步
+ private boolean mSyncing;
+ // 标记同步是否被取消
+ private boolean mCancelled;
+ // 存储Google Tasks任务列表的哈希表，以任务列表的全局唯一ID（GID）为键，任务列表对象为值
+ private HashMap mGTaskListHashMap;
+ // 存储Google Tasks节点（任务、任务列表等）的哈希表，以节点的全局唯一ID（GID）为键，节点对象为值
+ private HashMap mGTaskHashMap;
+ // 存储元数据的哈希表，以相关的全局唯一ID为键，元数据对象为值
+ private HashMap mMetaHashMap;
+ // 元数据对应的任务列表
+ private TaskList mMetaList;
+ // 存储本地已删除记录的ID集合，用于后续清理本地数据
+ private HashSet mLocalDeleteIdMap;
+ // 存储从Google Tasks的全局唯一ID（GID）到本地记录ID（NID）的映射关系
+ private HashMap mGidToNid;
+ // 存储从本地记录ID（NID）到Google Tasks的全局唯一ID（GID）的映射关系
+ private HashMap mNidToGid;
+
+ // 私有构造函数，初始化相关成员变量
+ private GTaskManager() {
+ mSyncing = false;
+ mCancelled = false;
+ mGTaskListHashMap = new HashMap();
+ mGTaskHashMap = new HashMap();
+ mMetaHashMap = new HashMap();
+ mMetaList = null;
+ mLocalDeleteIdMap = new HashSet();
+ mGidToNid = new HashMap();
+ mNidToGid = new HashMap();
+ }
+
+ // 获取GTaskManager的单例实例
+ public static synchronized GTaskManager getInstance() {
+ if (mInstance == null) {
+ mInstance = new GTaskManager();
+ }
+ return mInstance;
+ }
+
+ // 设置关联的Activity上下文，主要用于获取授权令牌等相关操作
+ public synchronized void setActivityContext(Activity activity) {
+ // used for getting authtoken
+ mActivity = activity;
+ }
+
+ // 执行同步操作，与Google Tasks进行数据同步
+ public int sync(Context context, GTaskASyncTask asyncTask) {
+ if (mSyncing) {
+ Log.d(TAG, "Sync is in progress");
+ return STATE_SYNC_IN_PROGRESS;
+ }
+ mContext = context;
+ mContentResolver = mContext.getContentResolver();
+ mSyncing = true;
+ mCancelled = false;
+ // 清除之前同步相关的数据缓存，如任务列表、节点、元数据等的哈希表以及ID映射关系等
+ mGTaskListHashMap.clear();
+ mGTaskHashMap.clear();
+ mMetaHashMap.clear();
+ mLocalDeleteIdMap.clear();
+ mGidToNid.clear();
+ mNidToGid.clear();
+
+ try {
+ GTaskClient client = GTaskClient.getInstance();
+ client.resetUpdateArray();
+
+ // 登录Google Tasks，如果取消同步则不再进行登录操作，如果登录失败则抛出网络异常
+ if (!mCancelled) {
+ if (!client.login(mActivity)) {
+ throw new NetworkFailureException("login google task failed");
+ }
+ }
+
+ // 发布同步进度信息，初始化任务列表阶段
+ asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
+ initGTaskList();
+
+ // 发布同步进度信息，进行内容同步阶段
+ asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
+ syncContent();
+ } catch (NetworkFailureException e) {
+ Log.e(TAG, e.toString());
+ return STATE_NETWORK_ERROR;
+ } catch (ActionFailureException e) {
+ Log.e(TAG, e.toString());
+ return STATE_INTERNAL_ERROR;
+ } catch (Exception e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ return STATE_INTERNAL_ERROR;
+ } finally {
+ // 无论同步是否成功，最终都清除同步相关的数据缓存
+ mGTaskListHashMap.clear();
+ mGTaskHashMap.clear();
+ mMetaHashMap.clear();
+ mLocalDeleteIdMap.clear();
+ mGidToNid.clear();
+ mNidToGid.clear();
+ mSyncing = false;
+ }
+
+ return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
+ }
+
+ // 初始化Google Tasks任务列表相关信息，包括获取任务列表、元数据列表以及加载任务等操作
+ private void initGTaskList() throws NetworkFailureException {
+ if (mCancelled)
+ return;
+ GTaskClient client = GTaskClient.getInstance();
+ try {
+ // 从Google Tasks获取任务列表信息，返回JSON数组形式的数据
+ JSONArray jsTaskLists = client.getTaskLists();
+
+ // 先初始化元数据列表，查找名为特定前缀加上"meta"的任务列表作为元数据列表
+ mMetaList = null;
+ for (int i = 0; i < jsTaskLists.length(); i++) {
+ JSONObject object = jsTaskLists.getJSONObject(i);
+ String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+ String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
+
+ if (name
+ .equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
+ mMetaList = new TaskList();
+ mMetaList.setContentByRemoteJSON(object);
+
+ // 加载元数据，获取元数据列表对应的任务列表中的具体元数据信息
+ JSONArray jsMetas = client.getTaskList(gid);
+ for (int j = 0; j < jsMetas.length(); j++) {
+ object = (JSONObject) jsMetas.getJSONObject(j);
+ MetaData metaData = new MetaData();
+ metaData.setContentByRemoteJSON(object);
+ if (metaData.isWorthSaving()) {
+ mMetaList.addChildTask(metaData);
+ if (metaData.getGid() != null) {
+ mMetaHashMap.put(metaData.getRelatedGid(), metaData);
+ }
+ }
+ }
+ }
+ }
+
+ // 如果元数据列表不存在，则创建一个新的元数据列表，并发送到Google Tasks服务器创建对应的任务列表
+ if (mMetaList == null) {
+ mMetaList = new TaskList();
+ mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ + GTaskStringUtils.FOLDER_META);
+ GTaskClient.getInstance().createTaskList(mMetaList);
+ }
+
+ // 初始化普通任务列表，遍历获取到的任务列表信息，创建任务列表对象并加载对应的任务信息
+ for (int i = 0; i < jsTaskLists.length(); i++) {
+ JSONObject object = jsTaskLists.getJSONObject(i);
+ String gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+ String name = object.getString(GTaskStringUtils.GTASK_JSON_NAME);
+
+ if (name.startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)
+ && !name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ + GTaskStringUtils.FOLDER_META)) {
+ TaskList tasklist = new TaskList();
+ tasklist.setContentByRemoteJSON(object);
+ mGTaskListHashMap.put(gid, tasklist);
+ mGTaskHashMap.put(gid, tasklist);
+
+ // 加载任务，获取当前任务列表对应的任务信息
+ JSONArray jsTasks = client.getTaskList(gid);
+ for (int j = 0; j < jsTasks.length(); j++) {
+ object = (JSONObject) jsTasks.getJSONObject(j);
+ gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
+ Task task = new Task();
+ task.setContentByRemoteJSON(object);
+ if (task.isWorthSaving()) {
+ task.setMetaInfo(mMetaHashMap.get(gid));
+ tasklist.addChildTask(task);
+ mGTaskHashMap.put(gid, task);
+ }
+ }
+ }
+ }
+ } catch (JSONException e) {
+ Log.e(TAG, e.toString());
+ e.printStackTrace();
+ throw new ActionFailureException("initGTaskList: handing JSONObject failed");
+ }
+ }
+
+ // 进行内容同步操作，处理本地与Google Tasks之间的数据同步，包括本地删除、文件夹同步、数据库中已有记录的同步等情况
+ private void syncContent() throws NetworkFailureException {
+ int syncType;
+ Cursor c = null;
+ String gid;
+ Node node;
+
+ mLocalDeleteIdMap.clear();
+
+ if (mCancelled) {
+ return;
+ }
+
+ // 处理本地已删除的笔记（记录），查询本地回收站文件夹中的记录，对比Google Tasks中的对应节点进行相应的同步操作
+ try {
+ c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+ "(type<>? AND parent_id=?)", new String[] {
+ String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
+ }, null);
+ if (c != null) {
+ while (c.moveToNext()) {
+ gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+ node = mGTaskHashMap.get(gid);
+ if (node != null) {
+ mGTaskHashMap.remove(gid);
+ doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c);
+ }
+
+ mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+ }
+ } else {
+ Log.w(TAG, "failed to query trash folder");
+ }
+ } finally {
+ if (c != null) {
+ c.close();
+ c = null;
+ }
+ }
+
+ // 同步文件夹相关信息
+ syncFolder();
+
+ // 处理数据库中已存在的笔记（记录），根据其在Google Tasks中的对应情况确定同步类型，然后进行相应的同步操作
+ try {
+ c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+ "(type=? AND parent_id<>?)", new String[] {
+ String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLER)
+ }, NoteColumns.TYPE + " DESC");
+ if (c != null) {
+ while (c.moveToNext()) {
+ gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+ node = mGTaskHashMap.get(gid);
+ if (node != null) {
+ mGTaskHashMap.remove(gid);
+ mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+ mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+ syncType = node.getSyncAction(c);
+ } else {
+ if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+ // 本地新增情况
+ syncType = Node.SYNC_ACTION_ADD_REMOTE;
+ } else {
+ // 远程已删除情况
+ syncType = Node.SYNC_ACTION_DEL_LOCAL;
+ }
+ }
+ doContentSync(syncType, node, c);
+ }
+ } else {
+ Log.w(TAG, "failed to query existing note in database");
+ }
+
+ } finally {
+ if (c != null) {
+ c.close();
+ c = null;
+ }
+ }
+
+ // 处理剩余的在Google Tasks中存在但本地未处理的节点，进行相应的同步操作（一般是添加到本地）
+ Iterator> iter = mGTaskHashMap.entrySet().iterator();
+ while (iter.hasNext()) {
+ Map.Entry entry = iter.next();
+ node = entry.getValue();
+ doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+ }
+
+ // mCancelled可能被其他线程设置，所以需要逐个检查，清除本地已删除记录的相关数据（如果同步未取消）
+ if (!mCancelled) {
+ if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
+ throw new ActionFailureException("failed to batch-delete local deleted notes");
+ }
+ }
+
+ // 刷新本地同步ID（如果同步未取消），提交更新并进行相关操作来更新本地记录的同步ID
+ if (!mCancelled) {
+ GTaskClient.getInstance().commitUpdate();
+ refreshLocalSyncId();
+ }
+
+ }
+
+ // 同步文件夹相关信息，包括根文件夹、通话记录文件夹、本地已存在的文件夹以及远程新增的文件夹等情况的处理
+ private void syncFolder() throws NetworkFailureException {
+ Cursor c = null;
+ String gid;
+ Node node;
+ int syncType;
+
+ if (mCancelled) {
+ return;
+ }
+
+ // 处理根文件夹的同步情况，根据其在Google Tasks中的对应情况进行相应的同步操作（添加、更新等）
+ try {
+ c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+ Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
+ if (c != null) {
+ c.moveToNext();
+ gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+ node = mGTaskHashMap.get(gid);
+ if (node != null) {
+ mGTaskHashMap.remove(gid);
+ mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
+ mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
+ // 对于系统文件夹，仅在必要时更新远程名称
+ if (!node.getName().equals(
+ GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
+ doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+ } else {
+ doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+ }
+ } else {
+ Log.w(TAG, "failed to query root folder");
+ }
+ } finally {
+ if (c != null) {
+ c.close();
+ c = null;
+ }
+ }
+
+ // for call-note文件夹相关的同步操作处理
+ // 查询通话记录文件夹在本地数据库中的信息，根据其在Google Tasks中的对应情况进行相应的同步操作（添加、更新等）
+ // 如果查询到该文件夹信息存在（即游标c不为空且能移动到下一条记录），则进一步处理
+ try {
+ // 通过ContentResolver查询本地数据库中通话记录文件夹的记录信息，指定查询条件为_id等于通话记录文件夹的特定ID
+ c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
+ new String[] {
+ String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
+ }, null);
+ if (c != null) {
+ if (c.moveToNext()) {
+ // 获取该文件夹在Google Tasks中对应的全局唯一ID（GID）
+ gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+ // 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
+ node = mGTaskHashMap.get(gid);
+ if (node != null) {
+ // 如果节点存在，从哈希表中移除该节点（表示已处理）
+ mGTaskHashMap.remove(gid);
+ // 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系，键为GID，值为通话记录文件夹的本地ID
+ mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
+ // 在Google Tasks的GID到本地ID映射表中记录映射关系，键为本地ID，值为GID
+ mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
+ // 对于系统文件夹，仅在其名称与预期的通话记录文件夹名称不一致时（即可能有更新情况），进行远程更新操作
+ if (!node.getName().equals(
+ GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ + GTaskStringUtils.FOLDER_CALL_NOTE))
+ doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
+ } else {
+ // 如果节点不存在，则执行添加远程节点的操作（意味着本地有该文件夹记录，但在Google Tasks中还未创建对应节点）
+ doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
+ }
+ }
+ } else {
+ // 如果查询失败，打印警告日志
+ Log.w(TAG, "failed to query call note folder");
+ }
+ } finally {
+ // 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
+ if (c != null) {
+ c.close();
+ c = null;
+ }
+ }
+
+ // 处理本地已存在的文件夹的同步情况
+ // 查询本地除回收站外的文件夹记录信息，根据其在Google Tasks中的对应情况进行相应的同步操作
+ try {
+ // 通过ContentResolver查询本地数据库中符合条件的文件夹记录信息，条件为类型是文件夹且父ID不等于回收站文件夹的ID
+ c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+ "(type=? AND parent_id<>?)", new String[] {
+ String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)
+ }, NoteColumns.TYPE + " DESC");
+ if (c != null) {
+ while (c.moveToNext()) {
+ // 获取文件夹在Google Tasks中对应的全局唯一ID（GID）
+ gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+ // 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
+ node = mGTaskHashMap.get(gid);
+ if (node != null) {
+ // 如果节点存在，从哈希表中移除该节点（表示已处理）
+ mGTaskHashMap.remove(gid);
+ // 在本地ID到Google Tasks的GID映射表中记录该文件夹的映射关系，键为GID，值为文件夹的本地ID
+ mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
+ // 在Google Tasks的GID到本地ID映射表中记录映射关系，键为本地ID，值为GID
+ mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
+ // 获取该节点对应的同步操作类型（根据节点和游标信息判断是添加、更新、删除等哪种类型）
+ syncType = node.getSyncAction(c);
+ } else {
+ // 如果节点不存在，根据其GID是否为空字符串判断是本地新增还是远程删除情况，进而确定同步类型
+ if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
+ // 本地新增情况，同步类型设置为添加远程节点
+ syncType = Node.SYNC_ACTION_ADD_REMOTE;
+ } else {
+ // 远程删除情况，同步类型设置为删除本地节点
+ syncType = Node.SYNC_ACTION_DEL_LOCAL;
+ }
+ }
+ // 根据确定的同步类型执行相应的内容同步操作
+ doContentSync(syncType, node, c);
+ }
+ } else {
+ // 如果查询失败，打印警告日志
+ Log.w(TAG, "failed to query existing folder");
+ }
+ } finally {
+ // 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
+ if (c != null) {
+ c.close();
+ c = null;
+ }
+ }
+
+ // 处理远程新增文件夹的同步情况
+ // 遍历存储Google Tasks任务列表的哈希表，对于在Google
+ // Tasks中存在但本地未处理（还在mGTaskHashMap中）的文件夹，进行添加本地节点的同步操作
+ Iterator> iter = mGTaskListHashMap.entrySet().iterator();
+ while (iter.hasNext()) {
+ Map.Entry entry = iter.next();
+ gid = entry.getKey();
+ node = entry.getValue();
+ if (mGTaskHashMap.containsKey(gid)) {
+ mGTaskHashMap.remove(gid);
+ doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+ }
+ }
+
+ // 如果同步未被取消，提交Google Tasks客户端的更新操作（将之前暂存的更新操作发送到服务器执行）
+ if (!mCancelled)
+ GTaskClient.getInstance().commitUpdate();
+ }
+
+ // 根据给定的同步类型执行具体的内容同步操作
+ private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
+ if (mCancelled) {
+ return;
+ }
+
+ MetaData meta;
+ switch (syncType) {
+ // 同步类型为添加本地节点，调用相应方法进行本地节点添加操作
+ case Node.SYNC_ACTION_ADD_LOCAL:
+ addLocalNode(node);
+ break;
+ // 同步类型为添加远程节点，调用相应方法进行远程节点添加操作，并传入节点和游标信息
+ case Node.SYNC_ACTION_ADD_REMOTE:
+ addRemoteNode(node, c);
+ break;
+ // 同步类型为删除本地节点，先从元数据哈希表中获取对应的元数据，若存在则调用Google Tasks客户端删除该元数据节点，
+ // 同时将本地记录的ID添加到本地已删除记录集合中
+ case Node.SYNC_ACTION_DEL_LOCAL:
+ meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
+ if (meta != null) {
+ GTaskClient.getInstance().deleteNode(meta);
+ }
+ mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+ break;
+ // 同步类型为删除远程节点，先从元数据哈希表中获取对应节点的元数据，若存在则调用Google Tasks客户端删除该元数据节点，
+ // 然后再删除该节点本身
+ case Node.SYNC_ACTION_DEL_REMOTE:
+ meta = mMetaHashMap.get(node.getGid());
+ if (meta != null) {
+ GTaskClient.getInstance().deleteNode(meta);
+ }
+ GTaskClient.getInstance().deleteNode(node);
+ break;
+ // 同步类型为更新本地节点，调用相应方法进行本地节点更新操作，并传入节点和游标信息
+ case Node.SYNC_ACTION_UPDATE_LOCAL:
+ updateLocalNode(node, c);
+ break;
+ // 同步类型为更新远程节点，调用相应方法进行远程节点更新操作，并传入节点和游标信息
+ case Node.SYNC_ACTION_UPDATE_REMOTE:
+ updateRemoteNode(node, c);
+ break;
+ // 同步类型为更新冲突，目前简单采用本地更新的方式（可能后续可以考虑合并修改等更好的处理方式），调用远程节点更新方法
+ case Node.SYNC_ACTION_UPDATE_CONFLICT:
+ // merging both modifications maybe a good idea
+ // right now just use local update simply
+ updateRemoteNode(node, c);
+ break;
+ // 同步类型为无操作，直接跳过不做任何处理
+ case Node.SYNC_ACTION_NONE:
+ break;
+ // 同步类型为错误或其他未知类型，抛出操作失败异常，表示遇到了未知的同步操作类型
+ case Node.SYNC_ACTION_ERROR:
+ default:
+ throw new ActionFailureException("unkown sync action type");
+ }
+ }
+
+ // 添加本地节点的操作方法
+ private void addLocalNode(Node node) throws NetworkFailureException {
+ if (mCancelled) {
+ return;
+ }
+
+ SqlNote sqlNote;
+ // 如果节点是任务列表类型（TaskList）
+ if (node instanceof TaskList) {
+ // 如果节点名称是默认根文件夹的名称，创建一个对应根文件夹的SqlNote对象，传入上下文和根文件夹的本地ID
+ if (node.getName().equals(
+ GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
+ sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
+ } else if (node.getName().equals(
+ GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
+ // 如果节点名称是通话记录文件夹的名称，创建一个对应通话记录文件夹的SqlNote对象，传入上下文和通话记录文件夹的本地ID
+ sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
+ } else {
+ // 其他普通任务列表情况，创建一个新的SqlNote对象，传入上下文
+ sqlNote = new SqlNote(mContext);
+ // 设置SqlNote的内容为节点的本地JSON格式内容（从节点获取）
+ sqlNote.setContent(node.getLocalJSONFromContent());
+ // 设置父ID为根文件夹的本地ID
+ sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
+ }
+ } else {
+ // 如果节点是普通任务（Task）类型，创建一个新的SqlNote对象，传入上下文
+ sqlNote = new SqlNote(mContext);
+ JSONObject js = node.getLocalJSONFromContent();
+ try {
+ // 如果节点的本地JSON数据中包含特定的笔记头部信息（META_HEAD_NOTE）
+ if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+ JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+ if (note.has(NoteColumns.ID)) {
+ long id = note.getLong(NoteColumns.ID);
+ // 检查该笔记ID在本地笔记数据库中是否已存在，如果存在则移除该ID（可能需要重新生成新的ID）
+ if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
+ // the id is not available, have to create a new one
+ note.remove(NoteColumns.ID);
+ }
+ }
+ }
+
+ // 如果节点的本地JSON数据中包含特定的数据头部信息（META_HEAD_DATA）
+ if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
+ JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+ for (int i = 0; i < dataArray.length(); i++) {
+ JSONObject data = dataArray.getJSONObject(i);
+ if (data.has(DataColumns.ID)) {
+ long dataId = data.getLong(DataColumns.ID);
+ // 检查该数据ID在本地数据数据库中是否已存在，如果存在则移除该ID（可能需要重新生成新的ID）
+ if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
+ // the data id is not available, have to create
+ // a new one
+ data.remove(DataColumns.ID);
+ }
+ }
+ }
+
+ }
+ } catch (JSONException e) {
+ Log.w(TAG, e.toString());
+ e.printStackTrace();
+ }
+ // 设置SqlNote的内容为处理后的JSON数据
+ sqlNote.setContent(js);
+
+ // 获取任务节点的父节点在本地ID到Google Tasks的GID映射表中的对应父ID，如果不存在则抛出异常表示找不到本地父ID
+ Long parentId = mGidToNid.get(((Task) node).getParent().getGid());
+ if (parentId == null) {
+ Log.e(TAG, "cannot find task's parent id locally");
+ throw new ActionFailureException("cannot add local node");
+ }
+ // 设置SqlNote的父ID为获取到的父节点的本地ID
+ sqlNote.setParentId(parentId.longValue());
+ }
+
+ // 设置SqlNote的Google Tasks全局唯一ID（GID）为节点的GID
+ sqlNote.setGtaskId(node.getGid());
+ // 将SqlNote对象提交保存到本地数据库（传入参数false可能表示不触发某些额外的相关操作）
+ sqlNote.commit(false);
+
+ // 在本地ID到Google Tasks的GID映射表中记录该节点的映射关系，键为节点的GID，值为SqlNote的本地ID
+ mGidToNid.put(node.getGid(), sqlNote.getId());
+ // 在Google Tasks的GID到本地ID映射表中记录映射关系，键为SqlNote的本地ID，值为节点的GID
+ mNidToGid.put(sqlNote.getId(), node.getGid());
+
+ // 更新远程元数据，传入节点的GID和对应的SqlNote对象
+ updateRemoteMeta(node.getGid(), sqlNote);
+ }
+
+ // 更新本地节点的操作方法
+ private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
+ if (mCancelled) {
+ return;
+ }
+
+ SqlNote sqlNote;
+ // 根据传入的上下文和游标信息创建一个新的SqlNote对象，用于更新本地节点信息
+ sqlNote = new SqlNote(mContext, c);
+ // 设置SqlNote的内容为节点的本地JSON格式内容（从节点获取）
+ sqlNote.setContent(node.getLocalJSONFromContent());
+
+ Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid())
+ : new Long(Notes.ID_ROOT_FOLDER);
+ if (parentId == null) {
+ Log.e(TAG, "cannot find task's parent id locally");
+ throw new ActionFailureException("cannot update local node");
+ }
+ // 设置SqlNote的父ID为获取到的父节点的本地ID
+ sqlNote.setParentId(parentId.longValue());
+ // 将更新后的SqlNote对象提交保存到本地数据库（传入参数true可能表示触发某些额外的相关操作）
+ sqlNote.commit(true);
+
+ // 更新远程元数据，传入节点的GID和对应的SqlNote对象
+ updateRemoteMeta(node.getGid(), sqlNote);
+ }
+
+ // 添加远程节点的操作方法
+ private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+ if (mCancelled) {
+ return;
+ }
+
+ SqlNote sqlNote = new SqlNote(mContext, c);
+ Node n;
+
+ // 如果SqlNote对应的是笔记类型（即普通任务）
+ if (sqlNote.isNoteType()) {
+ Task task = new Task();
+ // 设置任务的内容为从本地SqlNote获取的JSON格式内容
+ task.setContentByLocalJSON(sqlNote.getContent());
+
+ String parentGid = mNidToGid.get(sqlNote.getParentId());
+ if (parentGid == null) {
+ Log.e(TAG, "cannot find task's parent tasklist");
+ throw new ActionFailureException("cannot add remote task");
+ }
+ // 将任务添加到对应的父任务列表中（通过本地ID到Google Tasks的GID映射表找到父任务列表）
+ mGTaskListHashMap.get(parentGid).addChildTask(task);
+
+ // 通过Google Tasks客户端创建该任务（发送到服务器创建对应的任务节点）
+ GTaskClient.getInstance().createTask(task);
+ n = (Node) task;
+
+ // 更新远程元数据，传入任务的GID和对应的SqlNote对象
+ updateRemoteMeta(task.getGid(), sqlNote);
+ } else {
+ TaskList tasklist = null;
+
+ // 构建文件夹名称，先添加特定的前缀，然后根据SqlNote的本地ID判断是否是根文件夹或通话记录文件夹，添加相应的后缀名称，
+ // 否则添加SqlNote的摘要信息作为后缀
+ String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
+ if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
+ folderName += GTaskStringUtils.FOLDER_DEFAULT;
+ else if (sqlNote.getId() == Notes.ID_CALL_RECORD_FOLDER)
+ folderName += GTaskStringUtils.FOLDER_CALL_NOTE;
+ else
+ folderName += sqlNote.getSnippet();
+
+ // 遍历存储Google Tasks任务列表的哈希表（mGTaskListHashMap）的迭代器
+ Iterator> iter = mGTaskListHashMap.entrySet().iterator();
+ while (iter.hasNext()) {
+ // 获取哈希表中的每一个键值对，键是任务列表的全局唯一ID（GID），值是对应的任务列表对象（TaskList）
+ Map.Entry entry = iter.next();
+ String gid = entry.getKey();
+ TaskList list = entry.getValue();
+
+ // 判断当前任务列表的名称是否与之前构建的文件夹名称（folderName）相等
+ if (list.getName().equals(folderName)) {
+ // 如果相等，说明找到了对应的任务列表，将其赋值给tasklist变量
+ tasklist = list;
+ // 如果在存储Google Tasks节点的哈希表（mGTaskHashMap）中包含该任务列表的GID，说明已经处理过，将其移除
+ if (mGTaskHashMap.containsKey(gid)) {
+ mGTaskHashMap.remove(gid);
+ }
+ // 找到匹配的任务列表后就可以结束循环了
+ break;
+ }
+ }
+
+ // 如果经过上述查找没有找到匹配的任务列表（tasklist仍为null），则创建一个新的任务列表对象
+ if (tasklist == null) {
+ tasklist = new TaskList();
+ // 设置新任务列表的内容为从本地SqlNote获取的JSON格式内容
+ tasklist.setContentByLocalJSON(sqlNote.getContent());
+ // 通过Google Tasks客户端创建该任务列表（发送到服务器创建对应的任务列表节点）
+ GTaskClient.getInstance().createTaskList(tasklist);
+ // 将新创建的任务列表添加到存储Google Tasks任务列表的哈希表中，键为任务列表的GID，值为任务列表对象
+ mGTaskListHashMap.put(tasklist.getGid(), tasklist);
+ }
+ // 将创建或找到的任务列表对象转换为Node类型并赋值给n（因为Node是更通用的节点类型，TaskList是一种特殊的Node）
+ n = (Node) tasklist;
+ }
+
+ // 更新本地笔记相关信息
+ // 设置本地SqlNote的Google Tasks全局唯一ID（GID）为n的GID，即与远程任务列表或任务对应的GID保持一致
+ sqlNote.setGtaskId(n.getGid());
+ // 将SqlNote对象提交保存到本地数据库（传入参数false可能表示不触发某些额外的相关操作，此处用于保存基本的关联信息等）
+ sqlNote.commit(false);
+ // 重置本地修改标志（可能表示将本地记录标记为已与远程同步，不再是本地修改状态）
+ sqlNote.resetLocalModified();
+ // 再次提交保存SqlNote对象到本地数据库（传入参数true可能表示触发一些更新相关的额外操作，确保修改标志等信息更新成功）
+ sqlNote.commit(true);
+
+ // gid-id映射更新
+ // 在本地ID到Google Tasks的GID映射表（mGidToNid）中记录该节点（n）的映射关系，键为节点的GID，值为SqlNote的本地ID
+ mGidToNid.put(n.getGid(), sqlNote.getId());
+ // 在Google Tasks的GID到本地ID映射表（mNidToGid）中记录映射关系，键为SqlNote的本地ID，值为节点的GID
+ mNidToGid.put(sqlNote.getId(), n.getGid());
+ }
+
+ // 更新远程节点的操作方法
+ private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
+ if (mCancelled) {
+ return;
+ }
+
+ // 根据传入的上下文和游标信息创建一个新的SqlNote对象，用于后续操作
+ SqlNote sqlNote = new SqlNote(mContext, c);
+
+ // 远程更新操作
+ // 设置远程节点（node）的内容为从本地SqlNote获取的JSON格式内容，即将本地修改同步到远程节点
+ node.setContentByLocalJSON(sqlNote.getContent());
+ // 通过Google Tasks客户端将更新后的节点添加到更新队列中（后续会批量提交更新到服务器）
+ GTaskClient.getInstance().addUpdateNode(node);
+
+ // 更新远程元数据，传入节点的GID和对应的SqlNote对象
+ updateRemoteMeta(node.getGid(), sqlNote);
+
+ // 如果SqlNote对应的是笔记类型（即普通任务），则可能需要处理任务移动相关操作
+ if (sqlNote.isNoteType()) {
+ Task task = (Task) node;
+ // 获取任务当前的父任务列表
+ TaskList preParentList = task.getParent();
+
+ // 通过本地ID到Google Tasks的GID映射表，根据本地记录的父ID获取当前任务在远程对应的父任务列表的GID
+ String curParentGid = mNidToGid.get(sqlNote.getParentId());
+ if (curParentGid == null) {
+ Log.e(TAG, "cannot find task's parent tasklist");
+ throw new ActionFailureException("cannot update remote task");
+ }
+ // 根据获取到的GID从存储Google Tasks任务列表的哈希表中获取当前任务在远程对应的父任务列表对象
+ TaskList curParentList = mGTaskListHashMap.get(curParentGid);
+
+ // 如果当前任务的前后父任务列表不一致，说明任务需要在远程进行移动操作
+ if (preParentList != curParentList) {
+ // 先从原父任务列表中移除该任务
+ preParentList.removeChildTask(task);
+ // 将任务添加到新的父任务列表中
+ curParentList.addChildTask(task);
+ // 通过Google Tasks客户端执行任务移动操作，告知服务器任务在远程的位置变更
+ GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
+ }
+ }
+
+ // 清除本地修改标志，标记本地记录已同步到远程，不再处于本地修改状态
+ sqlNote.resetLocalModified();
+ // 将更新后的SqlNote对象提交保存到本地数据库（传入参数true可能表示触发一些更新相关的额外操作，确保修改标志等信息更新成功）
+ sqlNote.commit(true);
+ }
+
+ // 更新远程元数据的操作方法
+ private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
+ if (sqlNote != null && sqlNote.isNoteType()) {
+ // 从存储元数据的哈希表（mMetaHashMap）中根据GID获取对应的元数据对象（MetaData）
+ MetaData metaData = mMetaHashMap.get(gid);
+ if (metaData != null) {
+ // 如果元数据对象存在，设置其元数据内容，传入GID和从本地SqlNote获取的JSON格式内容
+ metaData.setMeta(gid, sqlNote.getContent());
+ // 通过Google Tasks客户端将更新后的元数据添加到更新队列中（后续会批量提交更新到服务器）
+ GTaskClient.getInstance().addUpdateNode(metaData);
+ } else {
+ // 如果元数据对象不存在，则创建一个新的元数据对象
+ metaData = new MetaData();
+ // 设置新元数据对象的元数据内容，传入GID和从本地SqlNote获取的JSON格式内容
+ metaData.setMeta(gid, sqlNote.getContent());
+ // 将新创建的元数据对象添加到元数据列表（mMetaList）中作为子任务（从逻辑上关联起来）
+ mMetaList.addChildTask(metaData);
+ // 将新创建的元数据对象添加到存储元数据的哈希表中，键为GID，值为元数据对象
+ mMetaHashMap.put(gid, metaData);
+ // 通过Google Tasks客户端创建该元数据任务（发送到服务器创建对应的元数据节点）
+ GTaskClient.getInstance().createTask(metaData);
+ }
+ }
+ }
+
+ // 刷新本地同步ID的操作方法
+ private void refreshLocalSyncId() throws NetworkFailureException {
+ if (mCancelled) {
+ return;
+ }
+
+ // 为了获取最新的Google Tasks列表信息，先清空之前存储相关信息的哈希表
+ mGTaskHashMap.clear();
+ mGTaskListHashMap.clear();
+ mMetaHashMap.clear();
+ // 重新初始化Google Tasks列表信息（重新获取任务列表、元数据等相关内容）
+ initGTaskList();
+
+ Cursor c = null;
+ try {
+ // 通过ContentResolver查询本地数据库中除系统类型且不在回收站的笔记记录信息，按照类型降序排列
+ c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
+ "(type<>? AND parent_id<>?)", new String[] {
+ String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLER)
+ }, NoteColumns.TYPE + " DESC");
+ if (c != null) {
+ while (c.moveToNext()) {
+ // 获取笔记在Google Tasks中对应的全局唯一ID（GID）
+ String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+ // 根据GID从存储Google Tasks节点的哈希表中获取对应的节点对象
+ Node node = mGTaskHashMap.get(gid);
+ if (node != null) {
+ // 如果节点存在，从哈希表中移除该节点（表示已处理）
+ mGTaskHashMap.remove(gid);
+ // 创建一个ContentValues对象用于存放要更新的数据，此处将同步ID设置为节点的最后修改时间
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.SYNC_ID, node.getLastModified());
+ // 通过ContentResolver更新本地数据库中对应笔记的记录，设置同步ID字段的值
+ mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
+ c.getLong(SqlNote.ID_COLUMN)), values, null, null);
+ } else {
+ Log.e(TAG, "something is missed");
+ throw new ActionFailureException(
+ "some local items don't have gid after sync");
+ }
+ }
+ } else {
+ Log.w(TAG, "failed to query local note to refresh sync id");
+ }
+ } finally {
+ // 无论查询是否成功，最终都要关闭游标，释放资源，并将游标置空
+ if (c != null) {
+ c.close();
+ c = null;
+ }
+ }
+ }
+
+ // 获取同步账户名称的方法，通过Google Tasks客户端获取同步账户对象，并返回其名称
+ public String getSyncAccount() {
+ return GTaskClient.getInstance().getSyncAccount().name;
+ }
+
+ // 取消同步的方法，将表示同步是否取消的标志（mCancelled）设置为true，其他相关操作可以根据该标志来判断是否停止执行
+ public void cancelSync() {
+ mCancelled = true;
+ }
+}
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
diff --git a/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
new file mode 100644
index 0000000..189946b
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
@@ -0,0 +1,281 @@
+/*
+ * 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.gtask.remote;
+
+import android.app.Activity;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.IBinder;
+
+<<<<<<< HEAD
+/**
+ * GTaskSyncService 是一个用于处理 Google 任务同步的服务类。
+ * 该类扩展自 Android 的 Service 类，负责执行同步操作。
+ */
+public class GTaskSyncService extends Service {
+ // 主要用于标识同步动作的字符串名称
+ public final static String ACTION_STRING_NAME = "sync_action_type";
+
+ // 开始同步的操作类型常量
+ public final static int ACTION_START_SYNC = 0;
+
+ // 取消同步的操作类型常量
+ public final static int ACTION_CANCEL_SYNC = 1;
+
+ // 无效的操作类型常量
+ public final static int ACTION_INVALID = 2;
+
+ // 广播名称，用于通知同步服务的状态
+ public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
+
+ // 广播参数，用于标识当前是否正在同步
+ public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
+
+ // 广播参数，用于传递同步进度消息
+ public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
+
+ // 静态变量，表示当前的异步任务
+ private static GTaskASyncTask mSyncTask = null;
+
+ // 存储当前同步的进度信息
+ private static String mSyncProgress = "";
+
+ /**
+ * 启动同步任务的方法
+ */
+ private void startSync() {
+ // 如果没有正在进行的同步任务，则创建并启动新的任务
+=======
+// GTaskSyncService类继承自Service，用于管理与Google Tasks的同步相关操作，包括启动同步、取消同步以及广播同步状态等功能
+public class GTaskSyncService extends Service {
+
+ // 用于在Intent中传递同步操作类型的字符串常量，作为键来标识具体的操作类型信息
+ public final static String ACTION_STRING_NAME = "sync_action_type";
+
+ // 表示启动同步操作的整数值常量，用于在根据操作类型进行判断时识别启动同步的意图
+ public final static int ACTION_START_SYNC = 0;
+
+ // 表示取消同步操作的整数值常量，用于在根据操作类型进行判断时识别取消同步的意图
+ public final static int ACTION_CANCEL_SYNC = 1;
+
+ // 表示无效操作类型的整数值常量，当获取到的操作类型不匹配已知的有效类型时使用该值来标识
+ public final static int ACTION_INVALID = 2;
+
+ // 用于广播同步服务相关状态信息的Intent的动作名称，其他组件可以通过注册监听该动作来接收同步服务的广播消息
+ public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
+
+ // 在广播Intent中用于传递是否正在同步状态的键名，对应的值为布尔类型，表示同步操作是否正在进行
+ public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
+
+ // 在广播Intent中用于传递同步进度消息的键名，对应的值为字符串类型，可用于展示同步操作的进度相关文本信息
+ public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
+
+ // 静态变量，用于存储正在执行的同步任务对象（GTaskASyncTask类型），方便在不同方法中对同步任务进行控制和判断状态
+ private static GTaskASyncTask mSyncTask = null;
+
+ // 静态变量，用于存储同步进度相关的消息字符串，可通过广播传递给其他关注同步进度的组件
+ private static String mSyncProgress = "";
+
+ // 启动同步的私有方法，用于创建并执行同步任务
+ private void startSync() {
+ // 如果当前没有正在执行的同步任务（mSyncTask为null）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ if (mSyncTask == null) {
+ // 创建一个新的GTaskASyncTask对象，传入当前服务上下文（this）以及一个完成监听器（OnCompleteListener）
+ mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
+ // 当同步任务完成时会调用的回调方法
+ public void onComplete() {
+<<<<<<< HEAD
+ // 同步任务完成后，重置任务状态并发送广播
+=======
+ // 将正在执行的同步任务对象置为null，表示同步已结束
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ mSyncTask = null;
+ // 发送一个空消息的广播（可能用于通知其他组件同步已完成等状态变化）
+ sendBroadcast("");
+ // 停止当前服务（因为同步任务已完成，服务的主要工作完成，可以停止自身运行）
+ stopSelf();
+ }
+ });
+<<<<<<< HEAD
+ // 发送初始广播，表示同步开始
+ sendBroadcast("");
+ // 执行异步任务
+=======
+ // 发送一个空消息的广播（可能在创建任务后就先通知其他组件同步即将开始等情况）
+ sendBroadcast("");
+ // 执行同步任务，开始真正的同步操作流程
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ mSyncTask.execute();
+ }
+ }
+
+<<<<<<< HEAD
+ /**
+ * 取消当前同步任务的方法
+ */
+=======
+ // 取消同步的私有方法，用于取消正在执行的同步任务（如果存在的话）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ private void cancelSync() {
+ // 如果有正在进行的同步任务，则取消该任务
+ if (mSyncTask != null) {
+ mSyncTask.cancelSync();
+ }
+ }
+
+ // 服务创建时调用的方法，在这里将正在执行的同步任务对象初始化为null，确保服务启动时处于初始状态
+ @Override
+ public void onCreate() {
+ // 服务创建时，初始化同步任务为空
+ mSyncTask = null;
+ }
+
+ // 当服务通过startService()方法启动时会调用此方法，用于处理传入的Intent并根据不同的操作意图执行相应操作
+ @Override
+ public int onStartCommand(Intent intent, int flags, int startId) {
+<<<<<<< HEAD
+ // 从 Intent 中获取数据
+=======
+ // 从传入的Intent中获取附加的Bundle数据（通常用于传递额外的参数信息）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ Bundle bundle = intent.getExtras();
+ // 如果获取到的Bundle不为null且包含表示操作类型的键（ACTION_STRING_NAME）
+ if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
+ // 根据操作类型的值进行不同的操作分支判断
+ switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
+ // 如果操作类型是启动同步（ACTION_START_SYNC）
+ case ACTION_START_SYNC:
+ // 开始同步操作
+ startSync();
+ break;
+ // 如果操作类型是取消同步（ACTION_CANCEL_SYNC）
+ case ACTION_CANCEL_SYNC:
+ // 取消同步操作
+ cancelSync();
+ break;
+ // 其他未知或不处理的操作类型，直接跳过不做操作
+ default:
+ break;
+ }
+<<<<<<< HEAD
+ // 返回服务的启动模式
+=======
+ // 返回START_STICKY表示服务在被系统意外终止后会尝试重新创建并保持启动状态（常用于需要持续运行的服务场景）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ return START_STICKY;
+ }
+ // 如果不符合上述条件或者操作类型无效等情况，调用父类的onStartCommand方法进行默认处理
+ return super.onStartCommand(intent, flags, startId);
+ }
+
+ // 当系统内存不足时会调用此方法，在这里用于取消正在执行的同步任务（如果存在的话），释放内存资源
+ @Override
+ public void onLowMemory() {
+ // 当系统内存不足时，取消同步任务
+ if (mSyncTask != null) {
+ mSyncTask.cancelSync();
+ }
+ }
+
+<<<<<<< HEAD
+=======
+ // 用于服务绑定操作的方法，这里返回null表示不支持绑定操作（如果需要支持绑定，需要返回一个有效的IBinder对象）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ @Override
+ public IBinder onBind(Intent intent) {
+ // 返回 null 表示不提供绑定服务的功能
+ return null;
+ }
+
+<<<<<<< HEAD
+ /**
+ * 发送广播以更新同步状态和进度消息
+ */
+=======
+ // 发送广播的公共方法，用于向其他组件广播同步服务的相关状态信息，包括同步进度消息、是否正在同步等
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public void sendBroadcast(String msg) {
+ mSyncProgress = msg;
+ // 创建 Intent 用于发送广播
+ Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
+ // 设置当前是否正在同步的标志
+ intent.putExtra(GTASK_SERVICE_BROADCAST_IS_SYNCING, mSyncTask != null);
+ // 设置进度消息
+ intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
+ // 发送广播
+ sendBroadcast(intent);
+ }
+
+<<<<<<< HEAD
+ /**
+ * 启动同步操作的静态方法
+ */
+ public static void startSync(Activity activity) {
+ // 设置活动上下文
+=======
+ // 静态公共方法，用于在外部（比如Activity中）启动同步服务进行同步操作，需要传入对应的Activity作为上下文来启动服务
+ public static void startSync(Activity activity) {
+ // 设置GTaskManager的Activity上下文（可能用于获取相关授权等操作，与同步操作相关联）
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ GTaskManager.getInstance().setActivityContext(activity);
+ Intent intent = new Intent(activity, GTaskSyncService.class);
+ // 添加启动同步的指令
+ intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
+ // 启动服务
+ activity.startService(intent);
+ }
+
+<<<<<<< HEAD
+ /**
+ * 取消同步操作的静态方法
+ */
+=======
+ // 静态公共方法，用于在外部（比如其他组件中）取消正在进行的同步操作，需要传入上下文（Context）来启动服务发送取消同步的意图
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public static void cancelSync(Context context) {
+ Intent intent = new Intent(context, GTaskSyncService.class);
+ // 添加取消同步的指令
+ intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
+ // 启动服务
+ context.startService(intent);
+ }
+
+<<<<<<< HEAD
+ /**
+ * 判断当前是否正在同步的静态方法
+ */
+=======
+ // 静态公共方法，用于判断当前是否正在进行同步操作，通过检查正在执行的同步任务对象是否为null来返回相应的布尔值结果
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public static boolean isSyncing() {
+ return mSyncTask != null;
+ }
+
+<<<<<<< HEAD
+ /**
+ * 获取当前同步进度的字符串信息
+ */
+=======
+ // 静态公共方法，用于获取当前的同步进度相关的字符串消息，返回存储同步进度消息的静态变量的值
+>>>>>>> a495b394fa4686564cc2bfe7d054eb66276713ae
+ public static String getProgressString() {
+ return mSyncProgress;
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/model/Note.java b/src/Notes-master/src/net/micode/notes/model/Note.java
new file mode 100644
index 0000000..978dbf7
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/model/Note.java
@@ -0,0 +1,269 @@
+/*
+ * 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.model;
+import android.content.ContentProviderOperation;
+import android.content.ContentProviderResult;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.OperationApplicationException;
+import android.net.Uri;
+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.DataColumns;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+
+import java.util.ArrayList;
+
+// 代表一个笔记，包含笔记的基本信息和笔记数据
+public class Note {
+ private ContentValues mNoteDiffValues;
+ private NoteData mNoteData;
+ private static final String TAG = "Note";
+
+ /**
+ * Create a new note id for adding a new note to databases
+ */
+ public static synchronized long getNewNoteId(Context context, long folderId) {
+ // Create a new note in the database
+ ContentValues values = new ContentValues();
+ long createdTime = System.currentTimeMillis();
+ values.put(NoteColumns.CREATED_DATE, createdTime);
+ values.put(NoteColumns.MODIFIED_DATE, createdTime);
+ values.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+ values.put(NoteColumns.LOCAL_MODIFIED, 1);
+ values.put(NoteColumns.PARENT_ID, folderId);
+ Uri uri = context.getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+
+ long noteId = 0;
+ try {
+ noteId = Long.valueOf(uri.getPathSegments().get(1));
+ } catch (NumberFormatException e) {
+ Log.e(TAG, "Get note id error :" + e.toString());
+ noteId = 0;
+ }
+ if (noteId == -1) {
+ throw new IllegalStateException("Wrong note id:" + noteId);
+ }
+ return noteId;
+ }
+
+ public Note() {
+ mNoteDiffValues = new ContentValues();
+ mNoteData = new NoteData();
+ }
+
+ // 设置笔记的基本信息
+ public void setNoteValue(String key, String value) {
+ mNoteDiffValues.put(key, value);
+ mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+ mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+ }
+
+ // 设置文本笔记的数据
+ public void setTextData(String key, String value) {
+ mNoteData.setTextData(key, value);
+ }
+
+ // 设置文本笔记的数据ID
+ public void setTextDataId(long id) {
+ mNoteData.setTextDataId(id);
+ }
+
+ // 获取文本笔记的数据ID
+ public long getTextDataId() {
+ return mNoteData.mTextDataId;
+ }
+
+ // 设置通话笔记的数据ID
+ public void setCallDataId(long id) {
+ mNoteData.setCallDataId(id);
+ }
+
+ // 设置通话笔记的数据
+ public void setCallData(String key, String value) {
+ mNoteData.setCallData(key, value);
+ }
+
+ // 判断笔记是否被本地修改过
+ public boolean isLocalModified() {
+ return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
+ }
+
+ // 同步笔记到数据库
+ public boolean syncNote(Context context, long noteId) {
+ if (noteId <= 0) {
+ throw new IllegalArgumentException("Wrong note id:" + noteId);
+ }
+
+ if (!isLocalModified()) {
+ return true;
+ }
+
+ /**
+ * In theory, once data changed, the note should be updated on {@link NoteColumns#LOCAL_MODIFIED} and
+ * {@link NoteColumns#MODIFIED_DATE}. For data safety, though update note fails, we also update the
+ * note data info
+ */
+ if (context.getContentResolver().update(
+ ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), mNoteDiffValues, null,
+ null) == 0) {
+ Log.e(TAG, "Update note error, should not happen");
+ // Do not return, fall through
+ }
+ mNoteDiffValues.clear();
+
+ if (mNoteData.isLocalModified()
+ && (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ // 笔记数据类，包含文本数据和通话数据
+ private class NoteData {
+ private long mTextDataId;
+
+ private ContentValues mTextDataValues;
+
+ private long mCallDataId;
+
+ private ContentValues mCallDataValues;
+
+ private static final String TAG = "NoteData";
+
+ public NoteData() {
+ mTextDataValues = new ContentValues();
+ mCallDataValues = new ContentValues();
+ mTextDataId = 0;
+ mCallDataId = 0;
+ }
+
+ // 判断笔记数据是否被本地修改过
+ boolean isLocalModified() {
+ return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
+ }
+
+ // 设置文本数据ID
+ void setTextDataId(long id) {
+ if(id <= 0) {
+ throw new IllegalArgumentException("Text data id should larger than 0");
+ }
+ mTextDataId = id;
+ }
+
+ // 设置通话数据ID
+ void setCallDataId(long id) {
+ if (id <= 0) {
+ throw new IllegalArgumentException("Call data id should larger than 0");
+ }
+ mCallDataId = id;
+ }
+
+ // 设置通话数据
+ void setCallData(String key, String value) {
+ mCallDataValues.put(key, value);
+ mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+ mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+ }
+
+ // 设置文本数据
+ void setTextData(String key, String value) {
+ mTextDataValues.put(key, value);
+ mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
+ mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+ }
+
+ // 将笔记数据推送到内容解析器
+ Uri pushIntoContentResolver(Context context, long noteId) {
+ /**
+ * Check for safety
+ */
+ if (noteId <= 0) {
+ throw new IllegalArgumentException("Wrong note id:" + noteId);
+ }
+
+ ArrayList operationList = new ArrayList();
+ ContentProviderOperation.Builder builder = null;
+
+ if(mTextDataValues.size() > 0) {
+ mTextDataValues.put(DataColumns.NOTE_ID, noteId);
+ if (mTextDataId == 0) {
+ mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
+ Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+ mTextDataValues);
+ try {
+ setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
+ } catch (NumberFormatException e) {
+ Log.e(TAG, "Insert new text data fail with noteId" + noteId);
+ mTextDataValues.clear();
+ return null;
+ }
+ } else {
+ builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+ Notes.CONTENT_DATA_URI, mTextDataId));
+ builder.withValues(mTextDataValues);
+ operationList.add(builder.build());
+ }
+ mTextDataValues.clear();
+ }
+
+ if(mCallDataValues.size() > 0) {
+ mCallDataValues.put(DataColumns.NOTE_ID, noteId);
+ if (mCallDataId == 0) {
+ mCallDataValues.put(DataColumns.MIME_TYPE, CallNote.CONTENT_ITEM_TYPE);
+ Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
+ mCallDataValues);
+ try {
+ setCallDataId(Long.valueOf(uri.getPathSegments().get(1)));
+ } catch (NumberFormatException e) {
+ Log.e(TAG, "Insert new call data fail with noteId" + noteId);
+ mCallDataValues.clear();
+ return null;
+ }
+ } else {
+ builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
+ Notes.CONTENT_DATA_URI, mCallDataId));
+ builder.withValues(mCallDataValues);
+ operationList.add(builder.build());
+ }
+ mCallDataValues.clear();
+ }
+
+ if (operationList.size() > 0) {
+ try {
+ ContentProviderResult[] results = context.getContentResolver().applyBatch(
+ Notes.AUTHORITY, operationList);
+ return (results == null || results.length == 0 || results[0] == null) ? null
+ : ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId);
+ } catch (RemoteException e) {
+ Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+ return null;
+ } catch (OperationApplicationException e) {
+ Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
+ return null;
+ }
+ }
+ return null;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/model/WorkingNote.java b/src/Notes-master/src/net/micode/notes/model/WorkingNote.java
new file mode 100644
index 0000000..4e90541
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/model/WorkingNote.java
@@ -0,0 +1,399 @@
+/*
+ * 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.model;
+
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.CallNote;
+import net.micode.notes.data.Notes.DataColumns;
+import net.micode.notes.data.Notes.DataConstants;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.tool.ResourceParser.NoteBgResources;
+
+// 表示正在编辑的笔记类
+public class WorkingNote {
+ // Note for the working note
+ private Note mNote;
+ // Note Id
+ private long mNoteId;
+ // Note content
+ private String mContent;
+ // Note mode
+ private int mMode;
+
+ private long mAlertDate;
+
+ private long mModifiedDate;
+
+ private int mBgColorId;
+
+ private int mWidgetId;
+
+ private int mWidgetType;
+
+ private long mFolderId;
+
+ private Context mContext;
+
+ private static final String TAG = "WorkingNote";
+
+ private boolean mIsDeleted;
+
+ private NoteSettingChangedListener mNoteSettingStatusListener;
+
+ // 数据库查询笔记数据的列
+ public static final String[] DATA_PROJECTION = new String[] {
+ DataColumns.ID,
+ DataColumns.CONTENT,
+ DataColumns.MIME_TYPE,
+ DataColumns.DATA1,
+ DataColumns.DATA2,
+ DataColumns.DATA3,
+ DataColumns.DATA4,
+ };
+
+ // 数据库查询笔记信息的列
+ public static final String[] NOTE_PROJECTION = new String[] {
+ NoteColumns.PARENT_ID,
+ NoteColumns.ALERTED_DATE,
+ NoteColumns.BG_COLOR_ID,
+ NoteColumns.WIDGET_ID,
+ NoteColumns.WIDGET_TYPE,
+ NoteColumns.MODIFIED_DATE
+ };
+
+ private static final int DATA_ID_COLUMN = 0;
+
+ private static final int DATA_CONTENT_COLUMN = 1;
+
+ private static final int DATA_MIME_TYPE_COLUMN = 2;
+
+ private static final int DATA_MODE_COLUMN = 3;
+
+ private static final int NOTE_PARENT_ID_COLUMN = 0;
+
+ private static final int NOTE_ALERTED_DATE_COLUMN = 1;
+
+ private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
+
+ private static final int NOTE_WIDGET_ID_COLUMN = 3;
+
+ private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
+
+ private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+
+ // 新笔记构造方法
+ private WorkingNote(Context context, long folderId) {
+ mContext = context;
+ mAlertDate = 0;
+ mModifiedDate = System.currentTimeMillis();
+ mFolderId = folderId;
+ mNote = new Note();
+ mNoteId = 0;
+ mIsDeleted = false;
+ mMode = 0;
+ mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
+ }
+
+ // 已有笔记构造方法
+ private WorkingNote(Context context, long noteId, long folderId) {
+ mContext = context;
+ mNoteId = noteId;
+ mFolderId = folderId;
+ mIsDeleted = false;
+ mNote = new Note();
+ loadNote();
+ }
+
+ // 从数据库加载笔记信息
+ private void loadNote() {
+ Cursor cursor = mContext.getContentResolver().query(
+ ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
+ null, null);
+
+ if (cursor != null) {
+ if (cursor.moveToFirst()) {
+ mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN);
+ mBgColorId = cursor.getInt(NOTE_BG_COLOR_ID_COLUMN);
+ mWidgetId = cursor.getInt(NOTE_WIDGET_ID_COLUMN);
+ mWidgetType = cursor.getInt(NOTE_WIDGET_TYPE_COLUMN);
+ mAlertDate = cursor.getLong(NOTE_ALERTED_DATE_COLUMN);
+ mModifiedDate = cursor.getLong(NOTE_MODIFIED_DATE_COLUMN);
+ }
+ cursor.close();
+ } else {
+ Log.e(TAG, "No note with id:" + mNoteId);
+ throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
+ }
+ loadNoteData();
+ }
+
+ // 从数据库加载笔记数据
+ private void loadNoteData() {
+ Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
+ DataColumns.NOTE_ID + "=?", new String[] {
+ String.valueOf(mNoteId)
+ }, null);
+
+ if (cursor != null) {
+ if (cursor.moveToFirst()) {
+ do {
+ String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
+ if (DataConstants.NOTE.equals(type)) {
+ mContent = cursor.getString(DATA_CONTENT_COLUMN);
+ mMode = cursor.getInt(DATA_MODE_COLUMN);
+ mNote.setTextDataId(cursor.getLong(DATA_ID_COLUMN));
+ } else if (DataConstants.CALL_NOTE.equals(type)) {
+ mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
+ } else {
+ Log.d(TAG, "Wrong note type with type:" + type);
+ }
+ } while (cursor.moveToNext());
+ }
+ cursor.close();
+ } else {
+ Log.e(TAG, "No data with id:" + mNoteId);
+ throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
+ }
+ }
+
+ // 创建一个空笔记
+ public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
+ int widgetType, int defaultBgColorId) {
+ WorkingNote note = new WorkingNote(context, folderId);
+ note.setBgColorId(defaultBgColorId);
+ note.setWidgetId(widgetId);
+ note.setWidgetType(widgetType);
+ return note;
+ }
+
+ // 从数据库加载笔记
+ public static WorkingNote load(Context context, long id) {
+ return new WorkingNote(context, id, 0);
+ }
+
+ // 保存笔记到数据库
+ public synchronized boolean saveNote() {
+ if (isWorthSaving()) {
+ if (!existInDatabase()) {
+ if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
+ Log.e(TAG, "Create new note fail with id:" + mNoteId);
+ return false;
+ }
+ }
+
+ mNote.syncNote(mContext, mNoteId);
+
+ /**
+ * Update widget content if there exist any widget of this note
+ */
+ if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+ && mWidgetType != Notes.TYPE_WIDGET_INVALIDE
+ && mNoteSettingStatusListener != null) {
+ mNoteSettingStatusListener.onWidgetChanged();
+ }
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ // 判断笔记是否存在于数据库中
+ public boolean existInDatabase() {
+ return mNoteId > 0;
+ }
+
+ // 判断笔记是否值得保存
+ private boolean isWorthSaving() {
+ if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
+ || (existInDatabase() && !mNote.isLocalModified())) {
+ return false;
+ } else {
+ return true;
+ }
+ }
+
+ // 设置笔记信息改变监听器
+ public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
+ mNoteSettingStatusListener = l;
+ }
+
+ // 设置闹钟提醒日期
+ public void setAlertDate(long date, boolean set) {
+ if (date != mAlertDate) {
+ mAlertDate = date;
+ mNote.setNoteValue(NoteColumns.ALERTED_DATE, String.valueOf(mAlertDate));
+ }
+ if (mNoteSettingStatusListener != null) {
+ mNoteSettingStatusListener.onClockAlertChanged(date, set);
+ }
+ }
+
+ // 标记笔记是否已删除
+ public void markDeleted(boolean mark) {
+ mIsDeleted = mark;
+ if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+ && mWidgetType != Notes.TYPE_WIDGET_INVALIDE && mNoteSettingStatusListener != null) {
+ mNoteSettingStatusListener.onWidgetChanged();
+ }
+ }
+
+ // 设置笔记背景颜色ID
+ public void setBgColorId(int id) {
+ if (id != mBgColorId) {
+ mBgColorId = id;
+ if (mNoteSettingStatusListener != null) {
+ mNoteSettingStatusListener.onBackgroundColorChanged();
+ }
+ mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
+ }
+ }
+
+ // 设置笔记的检查列表模式
+ public void setCheckListMode(int mode) {
+ if (mMode != mode) {
+ if (mNoteSettingStatusListener != null) {
+ mNoteSettingStatusListener.onCheckListModeChanged(mMode, mode);
+ }
+ mMode = mode;
+ mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
+ }
+ }
+
+ // 设置窗口小部件类型
+ public void setWidgetType(int type) {
+ if (type != mWidgetType) {
+ mWidgetType = type;
+ mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
+ }
+ }
+
+ // 设置窗口小部件ID
+ public void setWidgetId(int id) {
+ if (id != mWidgetId) {
+ mWidgetId = id;
+ mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
+ }
+ }
+
+ // 设置工作文本内容
+ public void setWorkingText(String text) {
+ if (!TextUtils.equals(mContent, text)) {
+ mContent = text;
+ mNote.setTextData(DataColumns.CONTENT, mContent);
+ }
+ }
+
+ // 将笔记转换为通话笔记
+ public void convertToCallNote(String phoneNumber, long callDate) {
+ mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
+ mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
+ mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
+ }
+
+ // 检查笔记是否有闹钟提醒
+ public boolean hasClockAlert() {
+ return (mAlertDate > 0 ? true : false);
+ }
+
+ // 获取笔记内容
+ public String getContent() {
+ return mContent;
+ }
+
+ // 获取闹钟提醒日期
+ public long getAlertDate() {
+ return mAlertDate;
+ }
+
+ // 获取笔记修改日期
+ public long getModifiedDate() {
+ return mModifiedDate;
+ }
+
+ // 获取笔记背景颜色资源ID
+ public int getBgColorResId() {
+ return NoteBgResources.getNoteBgResource(mBgColorId);
+ }
+
+ // 获取笔记背景颜色ID
+ public int getBgColorId() {
+ return mBgColorId;
+ }
+
+ // 获取笔记标题背景颜色资源ID
+ public int getTitleBgResId() {
+ return NoteBgResources.getNoteTitleBgResource(mBgColorId);
+ }
+
+ // 获取检查列表模式
+ public int getCheckListMode() {
+ return mMode;
+ }
+
+ // 获取笔记ID
+ public long getNoteId() {
+ return mNoteId;
+ }
+
+ // 获取笔记所在的文件夹ID
+ public long getFolderId() {
+ return mFolderId;
+ }
+
+ // 获取窗口小部件ID
+ public int getWidgetId() {
+ return mWidgetId;
+ }
+
+ // 获取窗口小部件类型
+ public int getWidgetType() {
+ return mWidgetType;
+ }
+
+ // 笔记信息改变监听器接口
+ public interface NoteSettingChangedListener {
+ /**
+ * Called when the background color of current note has just changed
+ */
+ void onBackgroundColorChanged();
+
+ /**
+ * Called when user set clock
+ */
+ void onClockAlertChanged(long date, boolean set);
+
+ /**
+ * Call when user create note from widget
+ */
+ void onWidgetChanged();
+
+ /**
+ * Call when switch between check list mode and normal mode
+ * @param oldMode is previous mode before change
+ * @param newMode is new mode
+ */
+ void onCheckListModeChanged(int oldMode, int newMode);
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java b/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
new file mode 100644
index 0000000..c6a1095
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
@@ -0,0 +1,340 @@
+/*
+ * 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";
+ // 单例实例
+ 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;
+
+ // 构造函数，初始化TextExport实例
+ private BackupUtils(Context context) {
+ mTextExport = new TextExport(context);
+ }
+
+ // 检查外部存储是否可用
+ private static boolean externalStorageAvailable() {
+ return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
+ }
+
+ // 导出笔记数据为文本文件
+ public int exportToText() {
+ return mTextExport.exportToText();
+ }
+
+ // 获取导出的文本文件名
+ public String getExportedTextFileName() {
+ return mTextExport.mFileName;
+ }
+
+ // 获取导出的文本文件目录
+ public String getExportedTextFileDir() {
+ return mTextExport.mFileDirectory;
+ }
+
+ // 文本导出类，用于将笔记数据导出为文本格式
+ private static class TextExport {
+ private static final String[] NOTE_PROJECTION = {
+ NoteColumns.ID,
+ NoteColumns.MODIFIED_DATE,
+ NoteColumns.SNIPPET,
+ NoteColumns.TYPE
+ };
+
+ private static final int NOTE_COLUMN_ID = 0;
+
+ private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
+
+ private static final int NOTE_COLUMN_SNIPPET = 2;
+
+ private static final String[] DATA_PROJECTION = {
+ DataColumns.CONTENT,
+ DataColumns.MIME_TYPE,
+ DataColumns.DATA1,
+ DataColumns.DATA2,
+ DataColumns.DATA3,
+ DataColumns.DATA4,
+ };
+
+ private static final int DATA_COLUMN_CONTENT = 0;
+
+ private static final int DATA_COLUMN_MIME_TYPE = 1;
+
+ private static final int DATA_COLUMN_CALL_DATE = 2;
+
+ private static final int DATA_COLUMN_PHONE_NUMBER = 4;
+
+ private final String [] TEXT_FORMAT;
+ private static final int FORMAT_FOLDER_NAME = 0;
+ private static final int FORMAT_NOTE_DATE = 1;
+ private static final int FORMAT_NOTE_CONTENT = 2;
+
+ private Context mContext;
+ private String mFileName;
+ private String mFileDirectory;
+
+ // 构造函数，初始化导出格式和上下文
+ public TextExport(Context context) {
+ TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
+ mContext = context;
+ mFileName = "";
+ mFileDirectory = "";
+ }
+
+ // 根据ID获取导出格式字符串
+ private String getFormat(int id) {
+ return TEXT_FORMAT[id];
+ }
+
+ // 导出指定文件夹下的笔记到文本文件
+ private void exportFolderToText(String folderId, PrintStream ps) {
+ // 查询属于该文件夹的笔记
+ Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+ NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
+ folderId
+ }, null);
+
+ if (notesCursor != null) {
+ if (notesCursor.moveToFirst()) {
+ do {
+ // 打印笔记的最后修改日期
+ ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
+ mContext.getString(R.string.format_datetime_mdhm),
+ notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
+ // 查询属于该笔记的数据
+ String noteId = notesCursor.getString(NOTE_COLUMN_ID);
+ exportNoteToText(noteId, ps);
+ } while (notesCursor.moveToNext());
+ }
+ notesCursor.close();
+ }
+ }
+
+ // 导出指定笔记到文本输出流
+ private void exportNoteToText(String noteId, PrintStream ps) {
+ Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
+ DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
+ noteId
+ }, null);
+
+ if (dataCursor != null) {
+ if (dataCursor.moveToFirst()) {
+ do {
+ String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
+ if (DataConstants.CALL_NOTE.equals(mimeType)) {
+ // 打印电话号码
+ 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() {
+ 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));
+ }
+ 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))));
+ // 查询属于该笔记的数据
+ String noteId = noteCursor.getString(NOTE_COLUMN_ID);
+ exportNoteToText(noteId, ps);
+ } while (noteCursor.moveToNext());
+ }
+ noteCursor.close();
+ }
+ ps.close();
+
+ return STATE_SUCCESS;
+ }
+
+ // 获取指向导出文本文件的PrintStream
+ 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;
+ }
+ }
+
+ // 生成用于存储导入数据的文本文件
+ private static File generateFileMountedOnSDcard(Context context, int filePathResId, int fileNameFormatResId) {
+ StringBuilder sb = new StringBuilder();
+ sb.append(Environment.getExternalStorageDirectory());
+ sb.append(context.getString(filePathResId));
+ File filedir = new File(sb.toString());
+ sb.append(context.getString(
+ fileNameFormatResId,
+ DateFormat.format(context.getString(R.string.format_date_ymd),
+ System.currentTimeMillis())));
+ File file = new File(sb.toString());
+
+ try {
+ if (!filedir.exists()) {
+ filedir.mkdir();
+ }
+ if (!file.exists()) {
+ file.createNewFile();
+ }
+ return file;
+ } catch (SecurityException e) {
+ e.printStackTrace();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+
+ return null;
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/tool/DataUtils.java b/src/Notes-master/src/net/micode/notes/tool/DataUtils.java
new file mode 100644
index 0000000..7de4569
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/tool/DataUtils.java
@@ -0,0 +1,308 @@
+/*
+ * 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";
+
+ // 批量删除笔记
+ public static boolean batchDeleteNotes(ContentResolver resolver, HashSet ids) {
+ if (ids == null) {
+ Log.d(TAG, "the ids is null");
+ return true;
+ }
+ if (ids.size() == 0) {
+ Log.d(TAG, "no id is in the hashset");
+ return true;
+ }
+
+ ArrayList operationList = new ArrayList();
+ for (long id : ids) {
+ 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);
+ 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;
+ }
+
+ // 将笔记移动到指定文件夹
+ public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.PARENT_ID, desFolderId);
+ 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);
+ }
+
+ // 批量将笔记移动到指定文件夹
+ public static boolean batchMoveToFolder(ContentResolver resolver, HashSet ids,
+ long folderId) {
+ if (ids == null) {
+ Log.d(TAG, "the ids is null");
+ return true;
+ }
+
+ ArrayList operationList = new ArrayList();
+ for (long id : ids) {
+ ContentProviderOperation.Builder builder = ContentProviderOperation
+ .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, 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);
+ 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;
+ }
+
+ /**
+ * 获取用户文件夹（非系统文件夹）的数量
+ */
+ 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;
+ }
+
+ // 检查指定类型的笔记是否可见
+ 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;
+ }
+
+ // 检查笔记是否存在于数据库中
+ 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;
+ }
+
+ // 检查数据是否存在于数据库中
+ 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;
+ }
+
+ // 检查指定名称的用户文件夹是否存在
+ 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;
+ }
+
+ // 获取指定文件夹下的笔记小部件信息
+ public static HashSet 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 set = null;
+ if (c != null) {
+ if (c.moveToFirst()) {
+ set = new HashSet();
+ do {
+ try {
+ AppWidgetAttribute widget = new AppWidgetAttribute();
+ 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获取通话号码
+ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
+ 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
+ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
+ 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 {
+ return cursor.getLong(0);
+ } catch (IndexOutOfBoundsException e) {
+ Log.e(TAG, "Get call note id fails " + e.toString());
+ }
+ }
+ cursor.close();
+ }
+ return 0;
+ }
+
+ // 根据笔记ID获取笔记摘要
+ public static String getSnippetById(ContentResolver resolver, long noteId) {
+ 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);
+ }
+
+ // 格式化笔记摘要
+ 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;
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java b/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
new file mode 100644
index 0000000..8903dd7
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
@@ -0,0 +1,114 @@
+/*
+ * 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;
+
+// 此类用于定义和存储GTask相关的JSON字段名常量
+public class GTaskStringUtils {
+
+ public final static String GTASK_JSON_ACTION_ID = "action_id";
+
+ public final static String GTASK_JSON_ACTION_LIST = "action_list";
+
+ public final static String GTASK_JSON_ACTION_TYPE = "action_type";
+
+ public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
+
+ public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
+
+ public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
+
+ public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
+
+ public final static String GTASK_JSON_CREATOR_ID = "creator_id";
+
+ public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
+
+ public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
+
+ public final static String GTASK_JSON_COMPLETED = "completed";
+
+ public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
+
+ public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
+
+ public final static String GTASK_JSON_DELETED = "deleted";
+
+ public final static String GTASK_JSON_DEST_LIST = "dest_list";
+
+ public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
+
+ public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
+
+ public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
+
+ public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
+
+ public final static String GTASK_JSON_GET_DELETED = "get_deleted";
+
+ public final static String GTASK_JSON_ID = "id";
+
+ public final static String GTASK_JSON_INDEX = "index";
+
+ public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
+
+ public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
+
+ public final static String GTASK_JSON_LIST_ID = "list_id";
+
+ public final static String GTASK_JSON_LISTS = "lists";
+
+ public final static String GTASK_JSON_NAME = "name";
+
+ public final static String GTASK_JSON_NEW_ID = "new_id";
+
+ public final static String GTASK_JSON_NOTES = "notes";
+
+ public final static String GTASK_JSON_PARENT_ID = "parent_id";
+
+ public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
+
+ public final static String GTASK_JSON_RESULTS = "results";
+
+ public final static String GTASK_JSON_SOURCE_LIST = "source_list";
+
+ public final static String GTASK_JSON_TASKS = "tasks";
+
+ public final static String GTASK_JSON_TYPE = "type";
+
+ public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
+
+ public final static String GTASK_JSON_TYPE_TASK = "TASK";
+
+ public final static String GTASK_JSON_USER = "user";
+
+ 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";
+
+ 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";
+
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java b/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
new file mode 100644
index 0000000..b813795
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
@@ -0,0 +1,201 @@
+/*
+ * 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获取编辑笔记的背景资源
+ public static int getNoteBgResource(int id) {
+ return BG_EDIT_RESOURCES[id];
+ }
+
+ // 根据ID获取编辑笔记标题的背景资源
+ public static int getNoteTitleBgResource(int id) {
+ return BG_EDIT_TITLE_RESOURCES[id];
+ }
+ }
+
+ // 获取默认笔记背景颜色ID
+ public static int getDefaultBgId(Context context) {
+ if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
+ NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
+ return (int) (Math.random() * NoteBgResources.BG_EDIT_RESOURCES.length);
+ } else {
+ return BG_DEFAULT_COLOR;
+ }
+ }
+
+ // 用于获取笔记列表项的背景资源
+ public static class NoteItemBgResources {
+ private final static int [] BG_FIRST_RESOURCES = new int [] {
+ R.drawable.list_yellow_up,
+ R.drawable.list_blue_up,
+ R.drawable.list_white_up,
+ R.drawable.list_green_up,
+ R.drawable.list_red_up
+ };
+
+ private final static int [] BG_NORMAL_RESOURCES = new int [] {
+ R.drawable.list_yellow_middle,
+ R.drawable.list_blue_middle,
+ R.drawable.list_white_middle,
+ R.drawable.list_green_middle,
+ R.drawable.list_red_middle,
+ };
+
+ private final static int [] BG_LAST_RESOURCES = new int [] {
+ R.drawable.list_yellow_down,
+ R.drawable.list_blue_down,
+ R.drawable.list_white_down,
+ R.drawable.list_green_down,
+ R.drawable.list_red_down,
+ };
+
+ private final static int [] BG_SINGLE_RESOURCES = new int [] {
+ R.drawable.list_yellow_single,
+ R.drawable.list_blue_single,
+ R.drawable.list_white_single,
+ R.drawable.list_green_single,
+ R.drawable.list_red_single
+ };
+
+ // 根据ID获取笔记列表第一项的背景资源
+ public static int getNoteBgFirstRes(int id) {
+ return BG_FIRST_RESOURCES[id];
+ }
+
+ // 根据ID获取笔记列表最后一项的背景资源
+ public static int getNoteBgLastRes(int id) {
+ return BG_LAST_RESOURCES[id];
+ }
+
+ // 根据ID获取单个笔记项的背景资源
+ public static int getNoteBgSingleRes(int id) {
+ return BG_SINGLE_RESOURCES[id];
+ }
+
+ // 根据ID获取笔记列表中间项的背景资源
+ public static int getNoteBgNormalRes(int id) {
+ return BG_NORMAL_RESOURCES[id];
+ }
+
+ // 获取文件夹背景资源
+ public static int getFolderBgRes() {
+ return R.drawable.list_folder;
+ }
+ }
+
+ // 用于获取小部件的背景资源
+ public static class WidgetBgResources {
+ 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小部件的背景资源
+ public static int getWidget2xBgResource(int id) {
+ return BG_2X_RESOURCES[id];
+ }
+
+ 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小部件的背景资源
+ public static int getWidget4xBgResource(int id) {
+ return BG_4X_RESOURCES[id];
+ }
+ }
+
+ // 用于获取文本外观资源
+ public static class TextAppearanceResources {
+ private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
+ R.style.TextAppearanceNormal,
+ R.style.TextAppearanceMedium,
+ R.style.TextAppearanceLarge,
+ R.style.TextAppearanceSuper
+ };
+
+ // 根据ID获取文本外观资源
+ public static int getTexAppearanceResource(int id) {
+ /**
+ * HACKME: Fix bug of store the resource id in shared preference.
+ * The id may larger than the length of resources, in this case,
+ * return the {@link ResourceParser#BG_DEFAULT_FONT_SIZE}
+ */
+ if (id >= TEXTAPPEARANCE_RESOURCES.length) {
+ return BG_DEFAULT_FONT_SIZE;
+ }
+ return TEXTAPPEARANCE_RESOURCES[id];
+ }
+
+ // 获取文本外观资源的数量
+ public static int getResourcesSize() {
+ return TEXTAPPEARANCE_RESOURCES.length;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java b/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
new file mode 100644
index 0000000..7cdca97
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
@@ -0,0 +1,191 @@
+/*
+ * 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.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.DialogInterface.OnDismissListener;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.PowerManager;
+import android.provider.Settings;
+import android.view.Window;
+import android.view.WindowManager;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+
+import java.io.IOException;
+
+/**
+ * 闹钟提醒活动类，继承自Activity，实现了OnClickListener和OnDismissListener接口。
+ * 该活动用于在闹钟响起时显示提醒对话框，并播放默认的闹钟声音。
+ */
+public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
+ private long mNoteId; // 保存笔记的ID
+ private String mSnippet; // 保存笔记的摘要
+ private static final int SNIPPET_PREW_MAX_LEN = 60; // 笔记摘要的最大长度
+ MediaPlayer mPlayer; // 用于播放闹钟声音的MediaPlayer实例
+
+ /**
+ * 创建活动时调用的方法。
+ * @param savedInstanceState 保存的实例状态数据包
+ */
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ requestWindowFeature(Window.FEATURE_NO_TITLE); // 请求无标题窗口
+
+ final Window win = getWindow(); // 获取当前窗口
+ win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED); // 设置窗口在锁屏时显示
+
+ // 如果屏幕未点亮，则添加更多标志以保持屏幕点亮并允许在锁屏时操作
+ if (!isScreenOn()) {
+ win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
+ | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+ | WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
+ | WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR);
+ }
+
+ Intent intent = getIntent(); // 获取启动该活动的Intent
+
+ try {
+ mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1)); // 从Intent中提取笔记ID
+ mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId); // 根据笔记ID获取摘要
+ // 如果摘要长度超过最大限制，则截取前SNIPPET_PREW_MAX_LEN个字符并添加省略号
+ mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
+ SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
+ : mSnippet;
+ } catch (IllegalArgumentException e) {
+ e.printStackTrace(); // 打印异常信息
+ return; // 如果发生异常，则结束该方法
+ }
+
+ mPlayer = new MediaPlayer(); // 创建MediaPlayer实例
+ // 检查数据库中是否存在指定ID的笔记
+ if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
+ showActionDialog(); // 显示操作对话框
+ playAlarmSound(); // 播放闹钟声音
+ } else {
+ finish(); // 如果笔记不存在，则结束该活动
+ }
+ }
+
+ /**
+ * 检查屏幕是否点亮。
+ * @return 如果屏幕点亮则返回true，否则返回false
+ */
+ private boolean isScreenOn() {
+ PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); // 获取电源管理服务
+ return pm.isScreenOn(); // 返回屏幕是否点亮的状态
+ }
+
+ /**
+ * 播放闹钟声音的方法。
+ */
+ private void playAlarmSound() {
+ // 获取实际的默认闹钟铃声URI
+ Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
+
+ // 获取当前设置的静音模式影响的音频流类型
+ int silentModeStreams = Settings.System.getInt(getContentResolver(),
+ Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
+
+ // 如果静音模式影响了闹钟音频流，则设置MediaPlayer的音频流类型为silentModeStreams
+ // 否则，设置为AudioManager.STREAM_ALARM
+ if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
+ mPlayer.setAudioStreamType(silentModeStreams);
+ } else {
+ mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
+ }
+ try {
+ mPlayer.setDataSource(this, url); // 设置MediaPlayer的数据源为闹钟铃声URI
+ mPlayer.prepare(); // 准备MediaPlayer
+ mPlayer.setLooping(true); // 设置MediaPlayer循环播放
+ mPlayer.start(); // 开始播放闹钟声音
+ } catch (IllegalArgumentException e) {
+ e.printStackTrace(); // 打印异常信息
+ } catch (SecurityException e) {
+ e.printStackTrace(); // 打印异常信息
+ } catch (IllegalStateException e) {
+ e.printStackTrace(); // 打印异常信息
+ } catch (IOException e) {
+ e.printStackTrace(); // 打印异常信息
+ }
+ }
+
+ /**
+ * 显示操作对话框的方法。
+ */
+ private void showActionDialog() {
+ AlertDialog.Builder dialog = new AlertDialog.Builder(this); // 创建AlertDialog.Builder实例
+ dialog.setTitle(R.string.app_name); // 设置对话框标题为应用名称
+ dialog.setMessage(mSnippet); // 设置对话框消息为笔记摘要
+ dialog.setPositiveButton(R.string.notealert_ok, this); // 设置确定按钮及其监听器
+ // 如果屏幕已点亮，则添加进入按钮及其监听器
+ if (isScreenOn()) {
+ dialog.setNegativeButton(R.string.notealert_enter, this);
+ }
+ dialog.show().setOnDismissListener(this); // 显示对话框并设置对话框消失监听器
+ }
+
+ /**
+ * 实现OnClickListener接口的方法，处理对话框按钮点击事件。
+ * @param dialog 触发点击事件的对话框
+ * @param which 点击的按钮的ID
+ */
+ public void onClick(DialogInterface dialog, int which) {
+ switch (which) {
+ case DialogInterface.BUTTON_NEGATIVE:
+ Intent intent = new Intent(this, NoteEditActivity.class); // 创建Intent准备跳转到笔记编辑活动
+ intent.setAction(Intent.ACTION_VIEW); // 设置Intent动作类型为ACTION_VIEW
+ intent.putExtra(Intent.EXTRA_UID, mNoteId); // 添加笔记ID作为附加信息
+ startActivity(intent); // 启动笔记编辑活动
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ * 实现OnDismissListener接口的方法，处理对话框消失事件。
+ * @param dialog 消失的对话框
+ */
+ public void onDismiss(DialogInterface dialog) {
+ stopAlarmSound(); // 停止播放闹钟声音
+ finish(); // 结束该活动
+ }
+
+ /**
+ * 停止并释放MediaPlayer的方法。
+ */
+ private void stopAlarmSound() {
+ if (mPlayer != null) {
+ mPlayer.stop(); // 停止MediaPlayer播放
+ mPlayer.release(); // 释放MediaPlayer资源
+ mPlayer = null; // 将mPlayer置为null
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java b/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
new file mode 100644
index 0000000..c1ceb54
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
@@ -0,0 +1,68 @@
+/*
+ * 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.ui;
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+// 该广播接收器用于初始化闹钟，查询即将提醒的笔记并设置闹钟
+public class AlarmInitReceiver extends BroadcastReceiver {
+
+ // 查询笔记数据库时使用的列投影
+ private static final String [] PROJECTION = new String [] {
+ NoteColumns.ID,
+ NoteColumns.ALERTED_DATE
+ };
+
+ // 列索引常量，用于从查询结果中提取数据
+ private static final int COLUMN_ID = 0;
+ private static final int COLUMN_ALERTED_DATE = 1;
+
+ // 接收广播时执行的方法，查询数据库并设置闹钟
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ long currentDate = System.currentTimeMillis();
+ Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+ PROJECTION,
+ NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
+ new String[] { String.valueOf(currentDate) },
+ null);
+
+ if (c != null) {
+ if (c.moveToFirst()) {
+ do {
+ long alertDate = c.getLong(COLUMN_ALERTED_DATE);
+ Intent sender = new Intent(context, AlarmReceiver.class);
+ sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
+ PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+ AlarmManager alermManager = (AlarmManager) context
+ .getSystemService(Context.ALARM_SERVICE);
+ alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
+ } while (c.moveToNext());
+ }
+ c.close();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java b/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
new file mode 100644
index 0000000..3d2b949
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
@@ -0,0 +1,35 @@
+/*
+ * 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.ui;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+// 一个继承自BroadcastReceiver的类，用于接收闹钟触发的广播
+public class AlarmReceiver extends BroadcastReceiver {
+ // 当接收到广播时，该方法会被调用
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ // 设置Intent的目标Activity为AlarmAlertActivity
+ intent.setClass(context, AlarmAlertActivity.class);
+ // 添加标志以允许启动新的Activity
+ intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+ // 启动AlarmAlertActivity
+ context.startActivity(intent);
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java b/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
new file mode 100644
index 0000000..9601ff7
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
@@ -0,0 +1,745 @@
+/*
+ * 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.ui;
+
+import java.text.DateFormatSymbols;
+import java.util.Calendar;
+
+import net.micode.notes.R;
+
+import android.content.Context;
+import android.text.format.DateFormat;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.NumberPicker;
+
+// DateTimePicker类继承自FrameLayout，用于显示日期和时间选择控件
+public class DateTimePicker extends FrameLayout {
+
+ // 默认控件是否可用
+ private static final boolean DEFAULT_ENABLE_STATE = true;
+
+ // 半天中的小时数、全天中的小时数、一周中的天数等常量
+ private static final int HOURS_IN_HALF_DAY = 12;
+ private static final int HOURS_IN_ALL_DAY = 24;
+ private static final int DAYS_IN_ALL_WEEK = 7;
+ private static final int DATE_SPINNER_MIN_VAL = 0;
+ private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
+ private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+ private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+ private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+ private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
+ private static final int MINUT_SPINNER_MIN_VAL = 0;
+ private static final int MINUT_SPINNER_MAX_VAL = 59;
+ private static final int AMPM_SPINNER_MIN_VAL = 0;
+ private static final int AMPM_SPINNER_MAX_VAL = 1;
+
+ // 日期、小时、分钟、AM/PM选择器控件
+ private final NumberPicker mDateSpinner;
+ private final NumberPicker mHourSpinner;
+ private final NumberPicker mMinuteSpinner;
+ private final NumberPicker mAmPmSpinner;
+ // 当前日期时间
+ private Calendar mDate;
+
+ // 日期显示值数组
+ private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
+
+ // 当前是否为AM
+ private boolean mIsAm;
+
+ // 是否为24小时制视图
+ private boolean mIs24HourView;
+
+ // 控件是否可用
+ private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
+
+ // 初始化标志
+ private boolean mInitialising;
+
+ // 日期时间改变监听器
+ private OnDateTimeChangedListener mOnDateTimeChangedListener;
+
+ // 日期选择器值改变监听器
+ private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
+ updateDateControl();
+ onDateTimeChanged();
+ }
+ };
+
+ // 小时选择器值改变监听器
+ private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ boolean isDateChanged = false;
+ Calendar cal = Calendar.getInstance();
+ if (!mIs24HourView) {
+ if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, 1);
+ isDateChanged = true;
+ } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, -1);
+ isDateChanged = true;
+ }
+ if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
+ oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+ mIsAm = !mIsAm;
+ updateAmPmControl();
+ }
+ } else {
+ if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, 1);
+ isDateChanged = true;
+ } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, -1);
+ isDateChanged = true;
+ }
+ }
+ int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
+ mDate.set(Calendar.HOUR_OF_DAY, newHour);
+ onDateTimeChanged();
+ if (isDateChanged) {
+ setCurrentYear(cal.get(Calendar.YEAR));
+ setCurrentMonth(cal.get(Calendar.MONTH));
+ setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
+ }
+ }
+ };
+
+ // 分钟选择器值改变监听器
+ private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ int minValue = mMinuteSpinner.getMinValue();
+ int maxValue = mMinuteSpinner.getMaxValue();
+ int offset = 0;
+ if (oldVal == maxValue && newVal == minValue) {
+ offset += 1;
+ } else if (oldVal == minValue && newVal == maxValue) {
+ offset -= 1;
+ }
+ if (offset != 0) {
+ mDate.add(Calendar.HOUR_OF_DAY, offset);
+ mHourSpinner.setValue(getCurrentHour());
+ updateDateControl();
+ int newHour = getCurrentHourOfDay();
+ if (newHour >= HOURS_IN_HALF_DAY) {
+ mIsAm = false;
+ updateAmPmControl();
+ } else {
+ mIsAm = true;
+ updateAmPmControl();
+ }
+ }
+ mDate.set(Calendar.MINUTE, newVal);
+ onDateTimeChanged();
+ }
+ };
+
+ // AM/PM选择器值改变监听器
+ private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ mIsAm = !mIsAm;
+ if (mIsAm) {
+ mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
+ } else {
+ mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
+ }
+ updateAmPmControl();
+ onDateTimeChanged();
+ }
+ };
+
+ // 日期时间改变监听器接口
+ public interface OnDateTimeChangedListener {
+ void onDateTimeChanged(DateTimePicker view, int year, int month,
+ int dayOfMonth, int hourOfDay, int minute);
+ }
+
+ // 构造函数，默认使用当前时间
+ public DateTimePicker(Context context) {
+ this(context, System.currentTimeMillis());
+ }
+
+ // 构造函数，使用指定时间
+ public DateTimePicker(Context context, long date) {
+ this(context, date, DateFormat.is24HourFormat(context));
+ }
+
+ // 构造函数，使用指定时间和是否为24小时制
+ public DateTimePicker(Context context, long date, boolean is24HourView) {
+ super(context);
+ mDate = Calendar.getInstance();
+ mInitialising = true;
+ mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
+ inflate(context, R.layout.datetime_picker, this);
+
+ mDateSpinner = (NumberPicker) findViewById(R.id.date);
+ mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
+ mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
+ mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
+
+ mHourSpinner = (NumberPicker) findViewById(R.id.hour);
+ mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
+ mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
+ mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
+ mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
+ mMinuteSpinner.setOnLongPressUpdateInterval(100);
+ mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
+
+ String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
+ mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
+ mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
+ mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
+ mAmPmSpinner.setDisplayedValues(stringsForAmPm);
+ mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
+
+ // 更新控件到初始状态
+ updateDateControl();
+ updateHourControl();
+ updateAmPmControl();
+
+ set24HourView(is24HourView);
+
+ // 设置到当前时间
+ setCurrentDate(date);
+
+ setEnabled(isEnabled());
+
+ // 设置内容描述
+ mInitialising = false;
+ }
+
+ // 设置控件是否可用
+ @Override
+ public void setEnabled(boolean enabled) {
+ if (mIsEnabled == enabled) {
+ return;
+ }
+ super.setEnabled(enabled);
+ mDateSpinner.setEnabled(enabled);
+ mMinuteSpinner.setEnabled(enabled);
+ mHourSpinner.setEnabled(enabled);
+ mAmPmSpinner.setEnabled(enabled);
+ mIsEnabled = enabled;
+ }
+
+ // 获取控件是否可用
+ @Override
+ public boolean isEnabled() {
+ return mIsEnabled;
+ }
+
+
+
+```
+/*
+ * 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.ui;
+
+import java.text.DateFormatSymbols;
+import java.util.Calendar;
+
+import net.micode.notes.R;
+
+
+import android.content.Context;
+import android.text.format.DateFormat;
+import android.view.View;
+import android.widget.FrameLayout;
+import android.widget.NumberPicker;
+
+/**
+ * DateTimePicker 类用于显示和选择日期和时间。
+ */
+public class DateTimePicker extends FrameLayout {
+
+ private static final boolean DEFAULT_ENABLE_STATE = true;
+
+ private static final int HOURS_IN_HALF_DAY = 12;
+ private static final int HOURS_IN_ALL_DAY = 24;
+ private static final int DAYS_IN_ALL_WEEK = 7;
+ private static final int DATE_SPINNER_MIN_VAL = 0;
+ private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
+ private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
+ private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
+ private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
+ private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
+ private static final int MINUT_SPINNER_MIN_VAL = 0;
+ private static final int MINUT_SPINNER_MAX_VAL = 59;
+ private static final int AMPM_SPINNER_MIN_VAL = 0;
+ private static final int AMPM_SPINNER_MAX_VAL = 1;
+
+ private final NumberPicker mDateSpinner;
+ private final NumberPicker mHourSpinner;
+ private final NumberPicker mMinuteSpinner;
+ private final NumberPicker mAmPmSpinner;
+ private Calendar mDate;
+
+ private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
+
+ private boolean mIsAm;
+
+ private boolean mIs24HourView;
+
+ private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
+
+ private boolean mInitialising;
+
+ private OnDateTimeChangedListener mOnDateTimeChangedListener;
+
+ private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
+ updateDateControl();
+ onDateTimeChanged();
+ }
+ };
+
+ private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ boolean isDateChanged = false;
+ Calendar cal = Calendar.getInstance();
+ if (!mIs24HourView) {
+ if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, 1);
+ isDateChanged = true;
+ } else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, -1);
+ isDateChanged = true;
+ }
+ if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
+ oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
+ mIsAm = !mIsAm;
+ updateAmPmControl();
+ }
+ } else {
+ if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, 1);
+ isDateChanged = true;
+ } else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, -1);
+ isDateChanged = true;
+ }
+ }
+ int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
+ mDate.set(Calendar.HOUR_OF_DAY, newHour);
+ onDateTimeChanged();
+ if (isDateChanged) {
+ setCurrentYear(cal.get(Calendar.YEAR));
+ setCurrentMonth(cal.get(Calendar.MONTH));
+ setCurrentDay(cal.get(Calendar.DAY_OF_MONTH));
+ }
+ }
+ };
+
+ private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ int minValue = mMinuteSpinner.getMinValue();
+ int maxValue = mMinuteSpinner.getMaxValue();
+ int offset = 0;
+ if (oldVal == maxValue && newVal == minValue) {
+ offset += 1;
+ } else if (oldVal == minValue && newVal == maxValue) {
+ offset -= 1;
+ }
+ if (offset != 0) {
+ mDate.add(Calendar.HOUR_OF_DAY, offset);
+ mHourSpinner.setValue(getCurrentHour());
+ updateDateControl();
+ int newHour = getCurrentHourOfDay();
+ if (newHour >= HOURS_IN_HALF_DAY) {
+ mIsAm = false;
+ updateAmPmControl();
+ } else {
+ mIsAm = true;
+ updateAmPmControl();
+ }
+ }
+ mDate.set(Calendar.MINUTE, newVal);
+ onDateTimeChanged();
+ }
+ };
+
+ private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
+ @Override
+ public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+ mIsAm = !mIsAm;
+ if (mIsAm) {
+ mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
+ } else {
+ mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
+ }
+ updateAmPmControl();
+ onDateTimeChanged();
+ }
+ };
+
+ /**
+ * OnDateTimeChangedListener 接口用于监听日期和时间的变化。
+ */
+ public interface OnDateTimeChangedListener {
+ void onDateTimeChanged(DateTimePicker view, int year, int month,
+ int dayOfMonth, int hourOfDay, int minute);
+ }
+
+ /**
+ * 构造函数，使用当前时间初始化 DateTimePicker。
+ */
+ public DateTimePicker(Context context) {
+ this(context, System.currentTimeMillis());
+ }
+
+ /**
+ * 构造函数，使用指定时间初始化 DateTimePicker。
+ */
+ public DateTimePicker(Context context, long date) {
+ this(context, date, DateFormat.is24HourFormat(context));
+ }
+
+ /**
+ * 构造函数，使用指定时间和24小时制设置初始化 DateTimePicker。
+ */
+ public DateTimePicker(Context context, long date, boolean is24HourView) {
+ super(context);
+ mDate = Calendar.getInstance();
+ mInitialising = true;
+ mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
+ inflate(context, R.layout.datetime_picker, this);
+
+ mDateSpinner = (NumberPicker) findViewById(R.id.date);
+ mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
+ mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
+ mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
+
+ mHourSpinner = (NumberPicker) findViewById(R.id.hour);
+ mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
+ mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
+ mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
+ mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
+ mMinuteSpinner.setOnLongPressUpdateInterval(100);
+ mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
+
+ String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
+ mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
+ mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
+ mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
+ mAmPmSpinner.setDisplayedValues(stringsForAmPm);
+ mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
+
+ // 更新控件到初始状态
+ updateDateControl();
+ updateHourControl();
+ updateAmPmControl();
+
+ set24HourView(is24HourView);
+
+ // 设置为当前时间
+ setCurrentDate(date);
+
+ setEnabled(isEnabled());
+
+ // 设置内容描述
+ mInitialising = false;
+ }
+
+ /**
+ * 设置控件是否启用。
+ */
+ @Override
+ public void setEnabled(boolean enabled) {
+ if (mIsEnabled == enabled) {
+ return;
+ }
+ super.setEnabled(enabled);
+ mDateSpinner.setEnabled(enabled);
+ mMinuteSpinner.setEnabled(enabled);
+ mHourSpinner.setEnabled(enabled);
+ mAmPmSpinner.setEnabled(enabled);
+ mIsEnabled = enabled;
+ }
+
+ /**
+ * 获取控件是否启用。
+ */
+ @Override
+ public boolean isEnabled() {
+ return mIsEnabled;
+ }
+
+ /**
+ * 获取当前日期的毫秒数。
+ */
+ public long getCurrentDateInTimeMillis() {
+ return mDate.getTimeInMillis();
+ }
+
+ /**
+ * 设置当前日期。
+ */
+ public void setCurrentDate(long date) {
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(date);
+ setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
+ cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
+ }
+
+ /**
+ * 设置当前日期。
+ */
+ public void setCurrentDate(int year, int month,
+ int dayOfMonth, int hourOfDay, int minute) {
+ setCurrentYear(year);
+ setCurrentMonth(month);
+ setCurrentDay(dayOfMonth);
+ setCurrentHour(hourOfDay);
+ setCurrentMinute(minute);
+ }
+
+ /**
+ * 获取当前年份。
+ */
+ public int getCurrentYear() {
+ return mDate.get(Calendar.YEAR);
+ }
+
+ /**
+ * 设置当前年份。
+ */
+ public void setCurrentYear(int year) {
+ if (!mInitialising && year == getCurrentYear()) {
+ return;
+ }
+ mDate.set(Calendar.YEAR, year);
+ updateDateControl();
+ onDateTimeChanged();
+ }
+
+ /**
+ * 获取当前月份。
+ */
+ public int getCurrentMonth() {
+ return mDate.get(Calendar.MONTH);
+ }
+
+ /**
+ * 设置当前月份。
+ */
+ public void setCurrentMonth(int month) {
+ if (!mInitialising && month == getCurrentMonth()) {
+ return;
+ }
+ mDate.set(Calendar.MONTH, month);
+ updateDateControl();
+ onDateTimeChanged();
+ }
+
+ /**
+ * 获取当前日期。
+ */
+ public int getCurrentDay() {
+ return mDate.get(Calendar.DAY_OF_MONTH);
+ }
+
+ /**
+ * 设置当前日期。
+ */
+ public void setCurrentDay(int dayOfMonth) {
+ if (!mInitialising && dayOfMonth == getCurrentDay()) {
+ return;
+ }
+ mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth);
+ updateDateControl();
+ onDateTimeChanged();
+ }
+
+ /**
+ * 获取当前小时（24小时制）。
+ */
+ public int getCurrentHourOfDay() {
+ return mDate.get(Calendar.HOUR_OF_DAY);
+ }
+
+ private int getCurrentHour() {
+ if (mIs24HourView){
+ return getCurrentHourOfDay();
+ } else {
+ int hour = getCurrentHourOfDay();
+ if (hour > HOURS_IN_HALF_DAY) {
+ return hour - HOURS_IN_HALF_DAY;
+ } else {
+ return hour == 0 ? HOURS_IN_HALF_DAY : hour;
+ }
+ }
+ }
+
+ /**
+ * 设置当前小时（24小时制）。
+ */
+ public void setCurrentHour(int hourOfDay) {
+ if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
+ return;
+ }
+ mDate.set(Calendar.HOUR_OF_DAY, hourOfDay);
+ if (!mIs24HourView) {
+ if (hourOfDay >= HOURS_IN_HALF_DAY) {
+ mIsAm = false;
+ if (hourOfDay > HOURS_IN_HALF_DAY) {
+ hourOfDay -= HOURS_IN_HALF_DAY;
+ }
+ } else {
+ mIsAm = true;
+ if (hourOfDay == 0) {
+ hourOfDay = HOURS_IN_HALF_DAY;
+ }
+ }
+ updateAmPmControl();
+ }
+ mHourSpinner.setValue(hourOfDay);
+ onDateTimeChanged();
+ }
+
+ /**
+ * 获取当前分钟。
+ */
+ public int getCurrentMinute() {
+ return mDate.get(Calendar.MINUTE);
+ }
+
+ /**
+ * 设置当前分钟。
+ */
+ public void setCurrentMinute(int minute) {
+ if (!mInitialising && minute == getCurrentMinute()) {
+ return;
+ }
+ mMinuteSpinner.setValue(minute);
+ mDate.set(Calendar.MINUTE, minute);
+ onDateTimeChanged();
+ }
+
+ /**
+ * 判断是否为24小时制。
+ */
+ public boolean is24HourView () {
+ return mIs24HourView;
+ }
+
+ /**
+ * 设置是否为24小时制。
+ */
+ public void set24HourView(boolean is24HourView) {
+ if (mIs24HourView == is24HourView) {
+ return;
+ }
+ mIs24HourView = is24HourView;
+ mAmPmSpinner.setVisibility(is24HourView ? View.GONE : View.VISIBLE);
+ int hour = getCurrentHourOfDay();
+ updateHourControl();
+ setCurrentHour(hour);
+ updateAmPmControl();
+ }
+
+ /**
+ * 更新日期控件的显示。
+ */
+ private void updateDateControl() {
+ Calendar cal = Calendar.getInstance();
+ cal.setTimeInMillis(mDate.getTimeInMillis());
+ cal.add(Calendar.DAY_OF_YEAR, -DAYS_IN_ALL_WEEK / 2 - 1);
+ mDateSpinner.setDisplayedValues(null);
+ for (int i = 0; i < DAYS_IN_ALL_WEEK; ++i) {
+ cal.add(Calendar.DAY_OF_YEAR, 1);
+ mDateDisplayValues[i] = (String) DateFormat.format("MM.dd EEEE", cal);
+ }
+ mDateSpinner.setDisplayedValues(mDateDisplayValues);
+ mDateSpinner.setValue(DAYS_IN_ALL_WEEK / 2);
+ mDateSpinner.invalidate();
+ }
+
+ /**
+ * 更新AM/PM控件的显示。
+ */
+ private void updateAmPmControl() {
+ if (mIs24HourView) {
+ mAmPmSpinner.setVisibility(View.GONE);
+ } else {
+ int index = mIsAm ? Calendar.AM : Calendar.PM;
+ mAmPmSpinner.setValue(index);
+ mAmPmSpinner.setVisibility(View.VISIBLE);
+ }
+ }
+
+ /**
+ * 更新小时控件的显示。
+ */
+ private void updateHourControl() {
+ if (mIs24HourView) {
+ mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
+ mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW);
+ } else {
+ mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW);
+ mHourSpinner.setMaxValue(HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW);
+ }
+ }
+
+ /**
+ * 设置日期时间变化的监听器。
+ */
+ public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
+ mOnDateTimeChangedListener = callback;
+ }
+
+ /**
+ * 当日期或时间发生变化时调用此方法。
+ */
+ private void onDateTimeChanged() {
+ if (mOnDateTimeChangedListener != null) {
+ mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),
+ getCurrentMonth(), getCurrentDay(), getCurrentHourOfDay(), getCurrentMinute());
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java b/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
new file mode 100644
index 0000000..e52ad57
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
@@ -0,0 +1,104 @@
+/*
+ * 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
+ *
+ * 除非适用法律要求或书面同意，软件
+ * 在许可证下分发是按“原样”分发，
+ * 不附带任何明示或暗示的担保或条件。
+ * 请参阅许可证以获取特定语言，用于管理权限和
+ * 许可证下的限制。
+ */
+
+package net.micode.notes.ui; // 定义包名，表示该类文件位于net.micode.notes.ui这个包中
+
+import java.util.Calendar; // 导入Java的Calendar类，用于操作日期和时间
+
+import net.micode.notes.R; // 导入R资源文件，用于访问应用中的资源
+import net.micode.notes.ui.DateTimePicker; // 导入自定义的日期时间选择器控件
+import net.micode.notes.ui.DateTimePicker.OnDateTimeChangedListener; // 导入日期时间选择器控件的监听器接口
+
+import android.app.AlertDialog; // 导入Android的AlertDialog类，用于创建对话框
+import android.content.Context; // 导入Android的Context类，用于访问系统资源
+import android.content.DialogInterface; // 导入Android的DialogInterface类，用于处理对话框中的按钮点击事件
+import android.content.DialogInterface.OnClickListener; // 导入DialogInterface的OnClickListener接口
+import android.text.format.DateFormat; // 导入Android的DateFormat工具类，用于格式化日期和时间
+import android.text.format.DateUtils; // 导入Android的DateUtils工具类，用于处理日期和时间相关的操作
+
+// 自定义的日期时间选择对话框，继承自AlertDialog并实现了OnClickListener接口
+public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
+
+ // 存储当前选择的日期时间
+ private Calendar mDate = Calendar.getInstance(); // 创建一个Calendar实例，初始化为当前时间
+
+ // 是否使用24小时制
+ private boolean mIs24HourView; // 布尔变量，用于判断是否使用24小时制显示时间
+
+ // 回调接口，当日期时间设置完成后调用
+ private OnDateTimeSetListener mOnDateTimeSetListener; // 定义一个回调接口，当用户选择好日期时间后进行回调
+
+ // 日期时间选择器控件
+ private DateTimePicker mDateTimePicker; // 定义一个日期时间选择器控件实例，用于在对话框中选择日期时间
+
+ // 定义日期时间设置完成后的回调接口
+ public interface OnDateTimeSetListener {
+ void OnDateTimeSet(AlertDialog dialog, long date); // 定义回调方法，传入当前对话框和选择的日期时间（long类型）
+ }
+
+ // 构造函数，初始化对话框并设置初始日期时间
+ public DateTimePickerDialog(Context context, long date) {
+ super(context); // 调用父类AlertDialog的构造函数，传入上下文环境
+ mDateTimePicker = new DateTimePicker(context); // 创建日期时间选择器控件实例
+ setView(mDateTimePicker); // 将日期时间选择器控件添加到对话框中
+ mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() { // 设置日期时间选择器控件的监听器
+ public void onDateTimeChanged(DateTimePicker view, int year, int month, // 定义监听器回调方法，当日期时间发生变化时调用
+ int dayOfMonth, int hourOfDay, int minute) {
+ mDate.set(Calendar.YEAR, year); // 更新mDate中的年份为选择的年份
+ mDate.set(Calendar.MONTH, month); // 更新mDate中的月份为选择的月份
+ mDate.set(Calendar.DAY_OF_MONTH, dayOfMonth); // 更新mDate中的日期为选择的日期
+ mDate.set(Calendar.HOUR_OF_DAY, hourOfDay); // 更新mDate中的小时为选择的小时
+ mDate.set(Calendar.MINUTE, minute); // 更新mDate中的分钟为选择的分钟
+ mDate.set(Calendar.SECOND, 0); // 将秒设置为0，忽略秒的选择
+ updateTitle(mDate.getTimeInMillis()); // 更新对话框标题，显示当前选择的日期时间
+ }
+ });
+ mDate.setTimeInMillis(date); // 将mDate设置为传入的初始日期时间
+ mDateTimePicker.setCurrentDate(mDate.getTimeInMillis()); // 将日期时间选择器控件的当前日期时间设置为传入的初始日期时间
+ setButton(context.getString(R.string.datetime_dialog_ok), this); // 设置确认按钮，按钮文本为资源文件中的"datetime_dialog_ok"定义的文本，点击事件为当前类
+ setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null); // 设置取消按钮，按钮文本为资源文件中的"datetime_dialog_cancel"定义的文本，点击事件为空
+ set24HourView(DateFormat.is24HourFormat(this.getContext())); // 根据系统设置判断是否使用24小时制显示时间
+ updateTitle(mDate.getTimeInMillis()); // 更新对话框标题，显示初始选择的日期时间
+ }
+
+ // 设置是否使用24小时制显示时间
+ public void set24HourView(boolean is24HourView) {
+ mIs24HourView = is24HourView; // 更新是否使用24小时制的布尔值
+ }
+
+ // 设置日期时间选择完成后的回调监听器
+ public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
+ mOnDateTimeSetListener = callBack; // 设置回调监听器为传入的参数
+ }
+
+ // 更新对话框的标题以显示当前选择的日期时间
+ private void updateTitle(long date) {
+ int flag =
+ DateUtils.FORMAT_SHOW_YEAR | // 格式化标志，显示年份
+ DateUtils.FORMAT_SHOW_DATE | // 格式化标志，显示日期
+ DateUtils.FORMAT_SHOW_TIME; // 格式化标志，显示时间
+ flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_12HOUR; // 根据是否使用24小时制添加相应的格式化标志
+ setTitle(DateUtils.formatDateTime(this.getContext(), date, flag)); // 使用DateUtils.formatDateTime方法格式化日期时间，并设置为对话框的标题
+ }
+
+ // 处理用户点击对话框按钮的事件，如果是确认按钮则调用回调监听器
+ public void onClick(DialogInterface arg0, int arg1) {
+ if (mOnDateTimeSetListener != null) { // 检查回调监听器是否为空
+ mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis()); // 调用回调监听器的OnDateTimeSet方法，传入当前对话框和选择的日期时间
+ }
+ }
+
+}
diff --git a/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java b/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
new file mode 100644
index 0000000..eb009a2
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
@@ -0,0 +1,66 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.widget.Button;
+import android.widget.PopupMenu;
+import android.widget.PopupMenu.OnMenuItemClickListener;
+
+import net.micode.notes.R;
+
+// 下拉菜单类，用于在按钮点击时显示一个弹出菜单
+public class DropdownMenu {
+ private Button mButton; // 用于触发下拉菜单的按钮
+ private PopupMenu mPopupMenu; // 弹出菜单对象
+ private Menu mMenu; // 菜单对象
+
+ // 构造函数，初始化下拉菜单，设置按钮背景，并将菜单资源加载到弹出菜单中
+ public DropdownMenu(Context context, Button button, int menuId) {
+ mButton = button;
+ mButton.setBackgroundResource(R.drawable.dropdown_icon);
+ mPopupMenu = new PopupMenu(context, mButton);
+ mMenu = mPopupMenu.getMenu();
+ mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
+ mButton.setOnClickListener(new OnClickListener() {
+ public void onClick(View v) {
+ mPopupMenu.show();
+ }
+ });
+ }
+
+ // 设置下拉菜单项点击监听器
+ public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
+ if (mPopupMenu != null) {
+ mPopupMenu.setOnMenuItemClickListener(listener);
+ }
+ }
+
+ // 根据菜单项的ID查找菜单项
+ public MenuItem findItem(int id) {
+ return mMenu.findItem(id);
+ }
+
+ // 设置按钮的标题
+ public void setTitle(CharSequence title) {
+ mButton.setText(title);
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java b/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
new file mode 100644
index 0000000..1c6a78a
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
@@ -0,0 +1,89 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+// 自定义的 CursorAdapter 用于显示文件夹列表
+public class FoldersListAdapter extends CursorAdapter {
+ // 定义查询文件夹时需要的列
+ public static final String [] PROJECTION = {
+ NoteColumns.ID,
+ NoteColumns.SNIPPET
+ };
+
+ // 列索引常量
+ public static final int ID_COLUMN = 0;
+ public static final int NAME_COLUMN = 1;
+
+ // 构造函数，初始化 FoldersListAdapter
+ public FoldersListAdapter(Context context, Cursor c) {
+ super(context, c);
+ // TODO Auto-generated constructor stub
+ }
+
+ // 创建一个新的视图项
+ @Override
+ public View newView(Context context, Cursor cursor, ViewGroup parent) {
+ return new FolderListItem(context);
+ }
+
+ // 绑定数据到视图项
+ @Override
+ public void bindView(View view, Context context, Cursor cursor) {
+ if (view instanceof FolderListItem) {
+ String folderName = (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+ .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+ ((FolderListItem) view).bind(folderName);
+ }
+ }
+
+ // 根据位置获取文件夹名称
+ public String getFolderName(Context context, int position) {
+ Cursor cursor = (Cursor) getItem(position);
+ return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
+ .getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
+ }
+
+ // 内部类，定义文件夹列表项的视图结构
+ private class FolderListItem extends LinearLayout {
+ private TextView mName;
+
+ // 构造函数，初始化 FolderListItem 视图
+ public FolderListItem(Context context) {
+ super(context);
+ inflate(context, R.layout.folder_list_item, this);
+ mName = (TextView) findViewById(R.id.tv_folder_name);
+ }
+
+ // 绑定文件夹名称到视图
+ public void bind(String name) {
+ mName.setText(name);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java b/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
new file mode 100644
index 0000000..c2e2ab6
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
@@ -0,0 +1,929 @@
+/*
+ * 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.ui;
+
+import android.app.Activity;
+import android.app.AlarmManager;
+import android.app.AlertDialog;
+import android.app.PendingIntent;
+import android.app.SearchManager;
+import android.appwidget.AppWidgetManager;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.Paint;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.TextUtils;
+import android.text.format.DateUtils;
+import android.text.style.BackgroundColorSpan;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.WindowManager;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.CompoundButton.OnCheckedChangeListener;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.TextNote;
+import net.micode.notes.model.WorkingNote;
+import net.micode.notes.model.WorkingNote.NoteSettingChangedListener;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.tool.ResourceParser.TextAppearanceResources;
+import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
+import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
+import net.micode.notes.widget.NoteWidgetProvider_2x;
+import net.micode.notes.widget.NoteWidgetProvider_4x;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+// 笔记编辑界面的Activity类
+public class NoteEditActivity extends Activity implements OnClickListener,
+ NoteSettingChangedListener, OnTextViewChangeListener {
+ // 用于存储笔记头部视图的ViewHolder类
+ private class HeadViewHolder {
+ public TextView tvModified; // 显示笔记修改日期的TextView
+
+ public ImageView ivAlertIcon; // 显示提醒图标的ImageView
+
+ public TextView tvAlertDate; // 显示提醒日期的TextView
+
+ public ImageView ibSetBgColor; // 设置背景颜色的按钮
+ }
+
+ // 背景色选择按钮和颜色ID的映射
+ private static final Map sBgSelectorBtnsMap = new HashMap();
+ static {
+ sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW); // 黄色按钮对应的颜色ID
+ sBgSelectorBtnsMap.put(R.id.iv_bg_red, ResourceParser.RED); // 红色按钮对应的颜色ID
+ sBgSelectorBtnsMap.put(R.id.iv_bg_blue, ResourceParser.BLUE); // 蓝色按钮对应的颜色ID
+ sBgSelectorBtnsMap.put(R.id.iv_bg_green, ResourceParser.GREEN); // 绿色按钮对应的颜色ID
+ sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE); // 白色按钮对应的颜色ID
+ }
+
+ // 背景色选择后的显示标记和颜色ID的映射
+ private static final Map sBgSelectorSelectionMap = new HashMap();
+ static {
+ sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select); // 黄色选择标记对应的ID
+ sBgSelectorSelectionMap.put(ResourceParser.RED, R.id.iv_bg_red_select); // 红色选择标记对应的ID
+ sBgSelectorSelectionMap.put(ResourceParser.BLUE, R.id.iv_bg_blue_select); // 蓝色选择标记对应的ID
+ sBgSelectorSelectionMap.put(ResourceParser.GREEN, R.id.iv_bg_green_select); // 绿色选择标记对应的ID
+ sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select); // 白色选择标记对应的ID
+ }
+
+ // 字体大小选择按钮和字体大小ID的映射
+ private static final Map sFontSizeBtnsMap = new HashMap();
+ static {
+ sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE); // 大字体按钮对应的字体ID
+ sFontSizeBtnsMap.put(R.id.ll_font_small, ResourceParser.TEXT_SMALL); // 小字体按钮对应的字体ID
+ sFontSizeBtnsMap.put(R.id.ll_font_normal, ResourceParser.TEXT_MEDIUM); // 中字体按钮对应的字体ID
+ sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER); // 超大字体按钮对应的字体ID
+ }
+
+ // 字体大小选择后的显示标记和字体大小ID的映射
+ private static final Map sFontSelectorSelectionMap = new HashMap();
+ static {
+ sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select); // 大字体选择标记对应的ID
+ sFontSelectorSelectionMap.put(ResourceParser.TEXT_SMALL, R.id.iv_small_select); // 小字体选择标记对应的ID
+ sFontSelectorSelectionMap.put(ResourceParser.TEXT_MEDIUM, R.id.iv_medium_select); // 中字体选择标记对应的ID
+ sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select); // 超大字体选择标记对应的ID
+ }
+
+ private static final String TAG = "NoteEditActivity"; // 日志标签
+
+ private HeadViewHolder mNoteHeaderHolder; // 笔记头部视图的ViewHolder
+
+ private View mHeadViewPanel; // 笔记头部视图面板
+
+ private View mNoteBgColorSelector; // 笔记背景颜色选择面板
+
+ private View mFontSizeSelector; // 字体大小选择面板
+
+ private EditText mNoteEditor; // 笔记编辑框
+
+ private View mNoteEditorPanel; // 笔记编辑框面板
+
+ private WorkingNote mWorkingNote; // 正在编辑的笔记对象
+
+ private SharedPreferences mSharedPrefs; // 共享preferences对象，用于存储用户偏好设置
+ private int mFontSizeId; // 当前字体大小ID
+
+ private static final String PREFERENCE_FONT_SIZE = "pref_font_size"; // 存储字体大小的偏好设置键名
+
+ private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; // 桌面快捷方式标题的最大长度
+
+ public static final String TAG_CHECKED = String.valueOf('\u221A'); // 已勾选的复选框标签
+ public static final String TAG_UNCHECKED = String.valueOf('\u25A1'); // 未勾选的复选框标签
+
+ private LinearLayout mEditTextList; // 存储多个NoteEditText的LinearLayout
+
+ private String mUserQuery; // 用户搜索查询的字符串
+ private Pattern mPattern; // 用于匹配查询字符串的正则表达式模式
+
+ // 初始化Activity视图
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState); // 永远调用父类的onCreate方法
+ this.setContentView(R.layout.note_edit); // 设置布局文件为note_edit.xml
+
+ // 如果是首次创建且initActivityState失败，则直接关闭Activity
+ if (savedInstanceState == null && !initActivityState(getIntent())) {
+ finish();
+ return;
+ }
+ initResources(); // 初始化视图资源
+ }
+
+ // 当Activity被系统杀死后，恢复其状态
+ @Override
+ protected void onRestoreInstanceState(Bundle savedInstanceState) {
+ super.onRestoreInstanceState(savedInstanceState); // 永远调用父类的onRestoreInstanceState方法
+ // 如果savedInstanceState不为空且包含Intent.EXTRA_UID键，则重新加载笔记
+ if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
+ Intent intent = new Intent(Intent.ACTION_VIEW);
+ intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
+ if (!initActivityState(intent)) {
+ finish(); // 如果initActivityState失败，则关闭Activity
+ return;
+ }
+ Log.d(TAG, "Restoring from killed activity"); // 记录日志
+ }
+ }
+
+ // 初始化Activity状态，根据Intent决定加载笔记或创建新笔记
+ private boolean initActivityState(Intent intent) {
+ mWorkingNote = null; // 初始化笔记对象为null
+ // 如果Intent动作是ACTION_VIEW，则加载指定笔记
+ if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
+ long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0); // 获取笔记ID
+ mUserQuery = ""; // 初始化用户查询字符串为空
+
+ // 如果Intent包含SearchManager.EXTRA_DATA_KEY，则从搜索结果中加载笔记
+ if (intent.hasExtra(SearchManager.EXTRA_DATA_KEY)) {
+ noteId = Long.parseLong(intent.getStringExtra(SearchManager.EXTRA_DATA_KEY)); // 获取笔记ID
+ mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY); // 获取用户查询字符串
+ }
+
+ // 检查笔记是否存在
+ if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
+ // 如果笔记不存在，则跳转到笔记列表界面，并显示错误信息
+ Intent jump = new Intent(this, NotesListActivity.class);
+ startActivity(jump);
+ showToast(R.string.error_note_not_exist);
+ finish();
+ return false;
+ } else {
+ mWorkingNote = WorkingNote.load(this, noteId); // 加载指定笔记
+ if (mWorkingNote == null) { // 如果加载失败，则显示错误信息并关闭Activity
+ Log.e(TAG, "load note failed with note id" + noteId);
+ finish();
+ return false;
+ }
+ }
+ // 设置软键盘输入模式：隐藏软键盘，调整布局大小
+ getWindow().setSoftInputMode(
+ WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
+ | WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
+ } else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) { // 如果Intent动作是ACTION_INSERT_OR_EDIT，则创建新笔记或编辑现有笔记
+ long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0); // 获取文件夹ID
+ int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
+ AppWidgetManager.INVALID_APPWIDGET_ID); // 获取小部件ID
+ int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
+ Notes.TYPE_WIDGET_INVALIDE); // 获取小部件类型
+ int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
+ ResourceParser.getDefaultBgId(this)); // 获取背景颜色资源ID
+
+ String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER); // 获取电话号码（对于通话记录笔记）
+ long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0); // 获取通话日期（对于通话记录笔记）
+ if (callDate != 0 && phoneNumber != null) { // 如果通话日期和电话号码都存在，则尝试加载通话记录笔记
+ if (TextUtils.isEmpty(phoneNumber)) {
+ Log.w(TAG, "The call record number is null"); // 日志警告
+ }
+ long noteId = 0;
+ // 根据电话号码和通话日期查找笔记ID
+ if ((noteId = DataUtils.getNoteIdByPhoneNumberAndCallDate(getContentResolver(),
+ phoneNumber, callDate)) > 0) {
+ mWorkingNote = WorkingNote.load(this, noteId); // 加载指定笔记
+ if (mWorkingNote == null) { // 如果加载失败，则显示错误信息并关闭Activity
+ Log.e(TAG, "load call note failed with note id" + noteId);
+ finish();
+ return false;
+ }
+ } else { // 如果笔记不存在，则创建新笔记并转换为通话记录笔记
+ mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
+ widgetType, bgResId);
+ mWorkingNote.convertToCallNote(phoneNumber, callDate);
+ }
+ } else { // 如果通话日期或电话号码不存在，则创建新笔记
+ mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
+ bgResId);
+ }
+
+ // 设置软键盘输入模式：调整布局大小，显示软键盘
+ getWindow().setSoftInputMode(
+ WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
+ | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+ } else { // 如果Intent动作不支持，则显示错误信息并关闭Activity
+ Log.e(TAG, "Intent not specified action, should not support");
+ finish();
+ return false;
+ }
+ mWorkingNote.setOnSettingStatusChangedListener(this); // 设置笔记配置变化监听器
+ return true; // 返回true表示初始化成功
+ }
+
+ // Activity恢复时初始化笔记显示
+ @Override
+ protected void onResume() {
+ super.onResume(); // 永远调用父类的onResume方法
+ initNoteScreen(); // 初始化笔记显示界面
+ }
+
+ // 初始化笔记显示界面，包括背景颜色、字体大小、修改日期等
+ private void initNoteScreen() {
+ // 设置编辑框的文本外观为当前选择的字体大小
+ mNoteEditor.setTextAppearance(this, TextAppearanceResources
+ .getTexAppearanceResource(mFontSizeId));
+ // 如果笔记处于检查列表模式，则显示为检查列表，否则高亮显示搜索关键词
+ if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+ switchToListMode(mWorkingNote.getContent()); // 切换到列表模式
+ } else {
+ mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery)); // 获取高亮搜索结果
+ mNoteEditor.setSelection(mNoteEditor.getText().length()); // 将光标移动到文本末尾
+ }
+ // 隐藏所有背景颜色选择标记
+ for (Integer id : sBgSelectorSelectionMap.keySet()) {
+ findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
+ }
+ // 设置头部视图和编辑框面板的背景颜色
+ mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
+ mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
+
+ // 设置修改日期文本
+ mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this, // 格式化日期时间
+ mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE // 显示日期
+ | DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME // 显示数字日期、时间
+ | DateUtils.FORMAT_SHOW_YEAR)); // 显示年份
+
+ showAlertHeader(); // 显示或隐藏提醒头部信息
+ }
+
+ // 显示或隐藏提醒头部信息
+ private void showAlertHeader() {
+ // 如果笔记设置了警报
+ if (mWorkingNote.hasClockAlert()) {
+ long time = System.currentTimeMillis(); // 获取当前时间
+ // 如果当前时间大于警报时间，则显示警报已过期，否则显示相对时间
+ if (time > mWorkingNote.getAlertDate()) {
+ mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
+ } else {
+ mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString( // 获取相对时间字符串
+ mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
+ }
+ mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE); // 显示警报日期
+ mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE); // 显示警报图标
+ } else { // 如果笔记未设置警报，则隐藏警报日期和图标
+ mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
+ mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);
+ };
+ }
+
+ // 处理新的Intent，可能需要重新加载笔记或创建新笔记
+ @Override
+ protected void onNewIntent(Intent intent) {
+ super.onNewIntent(intent); // 永远调用父类的onNewIntent方法
+ initActivityState(intent); // 初始化Activity状态
+ }
+
+ // 保存Activity状态，在系统需要恢复Activity时使用
+ @Override
+ protected void onSaveInstanceState(Bundle outState) {
+ super.onSaveInstanceState(outState); // 永远调用父类的onSaveInstanceState方法
+ // 如果笔记不存在于数据库中，则保存笔记
+ if (!mWorkingNote.existInDatabase()) {
+ saveNote();
+ }
+ outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId()); // 保存笔记ID
+ Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState"); // 记录日志
+ }
+
+ // 处理触摸事件，用于隐藏颜色和字体大小选择面板
+ @Override
+ public boolean dispatchTouchEvent(MotionEvent ev) {
+ // 如果背景颜色选择面板可见且触摸事件不在面板范围内，则隐藏面板
+ if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
+ && !inRangeOfView(mNoteBgColorSelector, ev)) {
+ mNoteBgColorSelector.setVisibility(View.GONE);
+ return true;
+ }
+
+ // 如果字体大小选择面板可见且触摸事件不在面板范围内，则隐藏面板
+ if (mFontSizeSelector.getVisibility() == View.VISIBLE
+ && !inRangeOfView(mFontSizeSelector, ev)) {
+ mFontSizeSelector.setVisibility(View.GONE);
+ return true;
+ }
+ return super.dispatchTouchEvent(ev); // 其他情况，调用父类的方法
+ }
+
+ // 判断触摸事件是否发生在指定视图内
+ private boolean inRangeOfView(View view, MotionEvent ev) {
+ int []location = new int[2];
+ view.getLocationOnScreen(location); // 获取视图在屏幕上的位置
+ int x = location[0]; // 获取视图左上角x坐标
+ int y = location[1]; // 获取视图左上角y坐标
+ // 判断触摸点是否在视图范围内
+ if (ev.getX() < x
+ || ev.getX() > (x + view.getWidth()) // 触摸点x坐标小于视图左边界或大于视图右边界
+ || ev.getY() < y
+ || ev.getY() > (y + view.getHeight())) { // 触摸点y坐标小于视图上边界或大于视图下边界
+ return false; // 返回false表示触摸点不在视图范围内
+ }
+ return true; // 返回true表示触摸点在视图范围内
+ }
+
+ // 初始化视图资源
+ private void initResources() {
+ mHeadViewPanel = findViewById(R.id.note_title); // 获取头部视图面板
+ mNoteHeaderHolder = new HeadViewHolder(); // 创建ViewHolder对象
+ mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date); // 获取修改日期TextView
+ mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon); // 获取警报图标ImageView
+ mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date); // 获取警报日期TextView
+ mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color); // 获取设置背景颜色按钮
+ mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this); // 设置背景颜色按钮的点击监听器
+ mNoteEditor = (EditText) findViewById(R.id.note_edit_view); // 获取编辑框
+ mNoteEditorPanel = findViewById(R.id.sv_note_edit); // 获取编辑框面板
+ mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector); // 获取背景颜色选择面板
+ for (int id : sBgSelectorBtnsMap.keySet()) { // 为背景颜色选择按钮设置点击监听器
+ ImageView iv = (ImageView) findViewById(id);
+ iv.setOnClickListener(this);
+ }
+
+ mFontSizeSelector = findViewById(R.id.font_size_selector); // 获取字体大小选择面板
+ for (int id : sFontSizeBtnsMap.keySet()) { // 为字体大小选择按钮设置点击监听器
+ View view = findViewById(id);
+ view.setOnClickListener(this);
+ };
+ mSharedPrefs = PreferenceManager.getDefaultSharedPreferences(this); // 获取默认SharedPreferences对象
+ mFontSizeId = mSharedPrefs.getInt(PREFERENCE_FONT_SIZE, ResourceParser.BG_DEFAULT_FONT_SIZE); // 获取用户选择的字体大小ID
+ // 如果字体大小ID超出范围，则使用默认字体大小
+ if(mFontSizeId >= TextAppearanceResources.getResourcesSize()) {
+ mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
+ }
+ mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list); // 获取NoteEditText列表
+ }
+
+ // 暂停Activity时保存笔记并清理设置状态
+ @Override
+ protected void onPause() {
+ super.onPause(); // 永远调用父类的onPause方法
+ // 保存笔记内容到数据库，如果成功则记录日志
+ if(saveNote()) {
+ Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
+ }
+ clearSettingState(); // 清理设置状态（隐藏颜色和字体大小选择面板）
+ }
+
+ // 更新桌面小部件显示
+ private void updateWidget() {
+ Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE); // 创建更新小部件的Intent
+ // 根据小部件类型设置Intent的类
+ if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
+ intent.setClass(this, NoteWidgetProvider_2x.class);
+ } else if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_4X) {
+ intent.setClass(this, NoteWidgetProvider_4x.class);
+ } else {
+ Log.e(TAG, "Unspported widget type"); // 日志错误
+ return;
+ }
+
+ intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] { // 添加小部件ID
+ mWorkingNote.getWidgetId()
+ });
+
+ sendBroadcast(intent); // 发送广播更新小部件
+ setResult(RESULT_OK, intent); // 设置Activity结果
+ }
+
+ // 处理视图点击事件，包括颜色和字体大小选择
+ public void onClick(View v) {
+ int id = v.getId(); // 获取点击视图的ID
+ // 如果点击的是设置背景颜色按钮，则显示背景颜色选择面板
+ if (id == R.id.btn_set_bg_color) {
+ mNoteBgColorSelector.setVisibility(View.VISIBLE);
+ // 显示当前选择的背景颜色标记
+ findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+ View.VISIBLE);
+ } else if (sBgSelectorBtnsMap.containsKey(id)) { // 如果点击的是背景颜色选择按钮
+ // 隐藏之前选择的背景颜色标记
+ findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+ View.GONE);
+ mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id)); // 设置新的背景颜色ID
+ mNoteBgColorSelector.setVisibility(View.GONE); // 隐藏背景颜色选择面板
+ } else if (sFontSizeBtnsMap.containsKey(id)) { // 如果点击的是字体大小选择按钮
+ // 隐藏之前选择的字体大小标记
+ findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.GONE);
+ mFontSizeId = sFontSizeBtnsMap.get(id); // 设置新的字体大小ID
+ // 将新的字体大小ID保存到SharedPreferences中
+ mSharedPrefs.edit().putInt(PREFERENCE_FONT_SIZE, mFontSizeId).commit();
+ // 显示新的字体大小标记
+ findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+ // 如果笔记处于检查列表模式，则切换到列表模式；否则设置编辑框的文本外观
+ if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+ getWorkingText(); // 获取正在编辑的文本内容
+ switchToListMode(mWorkingNote.getContent()); // 切换到列表模式
+ } else {
+ mNoteEditor.setTextAppearance(this, // 设置文本外观
+ TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
+ }
+ mFontSizeSelector.setVisibility(View.GONE); // 隐藏字体大小选择面板
+ }
+ }
+
+ // 处理返回键事件，如果设置面板可见则隐藏，否则保存笔记后返回
+ @Override
+ public void onBackPressed() {
+ // 如果设置面板可见，则隐藏并返回
+ if(clearSettingState()) {
+ return;
+ }
+
+ saveNote(); // 保存笔记内容到数据库
+ super.onBackPressed(); // 调用父类的onBackPressed方法
+ }
+
+ // 清理设置面板状态
+ private boolean clearSettingState() {
+ // 如果背景颜色选择面板可见，则隐藏并返回true
+ if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
+ mNoteBgColorSelector.setVisibility(View.GONE);
+ return true;
+ } else if (mFontSizeSelector.getVisibility() == View.VISIBLE) { // 如果字体大小选择面板可见，则隐藏并返回true
+ mFontSizeSelector.setVisibility(View.GONE);
+ return true;
+ }
+ return false; // 如果两个面板都不可见，则返回false
+ }
+
+ // 处理笔记背景颜色变化事件
+ public void onBackgroundColorChanged() {
+ // 显示当前选择的背景颜色标记
+ findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
+ View.VISIBLE);
+ // 设置编辑框面板的背景颜色
+ mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
+ // 设置头部视图面板的背景颜色
+ mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
+ }
+
+ // 准备选项菜单，根据笔记状态动态更新菜单项
+ @Override
+ public boolean onPrepareOptionsMenu(Menu menu) {
+ if (isFinishing()) { // 如果Activity正在结束，则返回true
+ return true;
+ }
+ clearSettingState(); // 清理设置面板状态
+ menu.clear(); // 清空菜单项
+ // 根据笔记所在的文件夹ID动态更新菜单项
+ if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
+ getMenuInflater().inflate(R.menu.call_note_edit, menu); // 加载通话记录笔记编辑菜单
+ } else {
+ getMenuInflater().inflate(R.menu.note_edit, menu); // 加载普通笔记编辑菜单
+ }
+ // 根据笔记的检查列表模式动态更新菜单项标题
+ if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+ menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_normal_mode); // 设置为普通模式
+ } else {
+ menu.findItem(R.id.menu_list_mode).setTitle(R.string.menu_list_mode); // 设置为列表模式
+ }
+ // 根据笔记是否设置了警报动态更新菜单项可见性
+ if (mWorkingNote.hasClockAlert()) {
+ menu.findItem(R.id.menu_alert).setVisible(false); // 隐藏设置警报菜单项
+ } else {
+ menu.findItem(R.id.menu_delete_remind).setVisible(false); // 隐藏删除警报菜单项
+ }
+ return true; // 返回true表示菜单项已准备好
+ }
+
+ // 处理选项菜单项点击事件
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ // 根据菜单项ID执行相应操作
+ switch (item.getItemId()) {
+ case R.id.menu_new_note:
+ createNewNote(); // 创建新笔记
+ break;
+ case R.id.menu_delete:
+ AlertDialog.Builder builder = new AlertDialog.Builder(this); // 创建AlertDialog.Builder对象
+ builder.setTitle(getString(R.string.alert_title_delete)); // 设置提示标题
+ builder.setIcon(android.R.drawable.ic_dialog_alert); // 设置提示图标
+ builder.setMessage(getString(R.string.alert_message_delete_note)); // 设置提示信息
+ builder.setPositiveButton(android.R.string.ok, // 设置确定按钮
+ new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ deleteCurrentNote(); // 删除当前笔记
+ finish(); // 关闭Activity
+ }
+ });
+ builder.setNegativeButton(android.R.string.cancel, null); // 设置取消按钮
+ builder.show(); // 显示对话框
+ break;
+ case R.id.menu_font_size:
+ mFontSizeSelector.setVisibility(View.VISIBLE); // 显示字体大小选择面板
+ // 显示当前选择的字体大小标记
+ findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
+ break;
+ case R.id.menu_list_mode:
+ // 切换笔记的检查列表模式
+ mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
+ TextNote.MODE_CHECK_LIST : 0);
+ break;
+ case R.id.menu_share:
+ getWorkingText(); // 获取正在编辑的文本内容
+ sendTo(this, mWorkingNote.getContent()); // 分享笔记内容
+ break;
+ case R.id.menu_send_to_desktop:
+ sendToDesktop(); // 将笔记添加到桌面
+ break;
+ case R.id.menu_alert:
+ setReminder(); // 设置提醒时间
+ break;
+ case R.id.menu_delete_remind:
+ mWorkingNote.setAlertDate(0, false); // 删除提醒时间
+ break;
+ default:
+ break; // 默认情况，不做任何操作
+ }
+ return true; // 返回true表示菜单项点击事件已处理
+ }
+
+ // 设置提醒时间
+ private void setReminder() {
+ // 创建DateTimePickerDialog对象，设置初始时间为当前时间
+ DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
+ // 设置日期时间选择监听器
+ d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
+ public void OnDateTimeSet(AlertDialog dialog, long date) {
+ mWorkingNote.setAlertDate(date, true); // 设置提醒时间为选择的时间
+ }
+ });
+ d.show(); // 显示日期时间选择对话框
+ }
+
+ // 分享笔记内容到支持ACTION_SEND的其他应用
+ private void sendTo(Context context, String info) {
+ Intent intent = new Intent(Intent.ACTION_SEND); // 创建ACTION_SEND Intent
+ intent.putExtra(Intent.EXTRA_TEXT, info); // 添加文本内容
+ intent.setType("text/plain"); // 设置类型为纯文本
+ context.startActivity(intent); // 启动Intent
+ }
+
+ // 创建新笔记，跳转到新笔记编辑界面
+ private void createNewNote() {
+ saveNote(); // 保存当前笔记内容
+
+ finish(); // 关闭当前Activity
+ Intent intent = new Intent(this, NoteEditActivity.class); // 创建新笔记编辑Activity的Intent
+ intent.setAction(Intent.ACTION_INSERT_OR_EDIT); // 设置Intent动作为插入或编辑笔记
+ intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mWorkingNote.getFolderId()); // 添加文件夹ID
+ startActivity(intent); // 启动新笔记编辑Activity
+ }
+
+ // 删除当前笔记
+ private void deleteCurrentNote() {
+ // 如果笔记存在于数据库中
+ if (mWorkingNote.existInDatabase()) {
+ HashSet ids = new HashSet();
+ long id = mWorkingNote.getNoteId(); // 获取笔记ID
+ // 如果笔记ID不是根文件夹ID，则添加到要删除的ID集合中
+ if (id != Notes.ID_ROOT_FOLDER) {
+ ids.add(id);
+ } else {
+ Log.d(TAG, "Wrong note id, should not happen"); // 日志错误
+ }
+ // 根据是否处于同步模式决定删除或移动到回收站
+ if (!isSyncMode()) {
+ if (!DataUtils.batchDeleteNotes(getContentResolver(), ids)) { // 批量删除笔记
+ Log.e(TAG, "Delete Note error"); // 日志错误
+ }
+ } else {
+ if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) { // 批量移动到回收站
+ Log.e(TAG, "Move notes to trash folder error, should not happens"); // 日志错误
+ }
+ }
+ }
+ mWorkingNote.markDeleted(true); // 标记笔记已删除
+ }
+
+ // 判断是否处于同步模式
+ private boolean isSyncMode() {
+ // 获取同步账户名称，如果非空则返回true，否则返回false
+ return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
+ }
+
+ // 处理时钟提醒变化事件，设置或取消提醒
+ public void onClockAlertChanged(long date, boolean set) {
+ // 如果笔记不存在于数据库中，则保存笔记
+ if (!mWorkingNote.existInDatabase()) {
+ saveNote();
+ }
+ // 如果笔记ID大于0
+ if (mWorkingNote.getNoteId() > 0) {
+ Intent intent = new Intent(this, AlarmReceiver.class); // 创建AlarmReceiver Intent
+ // 添加笔记URI到Intent
+ intent.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mWorkingNote.getNoteId()));
+ // 创建PendingIntent对象
+ PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
+ AlarmManager alarmManager = ((AlarmManager) getSystemService(ALARM_SERVICE)); // 获取AlarmManager对象
+ showAlertHeader(); // 显示或隐藏提醒头部信息
+ // 如果设置为取消提醒，则取消Alarm；否则设置新的Alarm
+ if(!set) {
+ alarmManager.cancel(pendingIntent);
+ } else {
+ alarmManager.set(AlarmManager.RTC_WAKEUP, date, pendingIntent);
+ }
+ } else { // 如果笔记ID无效，则显示错误信息
+ Log.e(TAG, "Clock alert setting error");
+ showToast(R.string.error_note_empty_for_clock);
+ }
+ }
+
+ // 处理小部件变化事件，更新小部件显示
+ public void onWidgetChanged() {
+ updateWidget(); // 更新小部件显示
+ }
+
+ // 处理EditText删除事件，调整列表项索引
+ public void onEditTextDelete(int index, String text) {
+ int childCount = mEditTextList.getChildCount(); // 获取NoteEditText子视图数量
+ // 如果只有一个NoteEditText，则不做任何操作
+ if (childCount == 1) {
+ return;
+ }
+
+ // 调整删除位置之后的NoteEditText索引
+ for (int i = index + 1; i < childCount; i++) {
+ ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
+ .setIndex(i - 1);
+ }
+
+ mEditTextList.removeViewAt(index); // 删除指定位置的NoteEditText
+ NoteEditText edit = null;
+ // 根据删除位置获取新的NoteEditText对象
+ if(index == 0) {
+ edit = (NoteEditText) mEditTextList.getChildAt(0).findViewById(
+ R.id.et_edit_text);
+ } else {
+ edit = (NoteEditText) mEditTextList.getChildAt(index - 1).findViewById(
+ R.id.et_edit_text);
+ }
+ int length = edit.length(); // 获取NoteEditText的文本长度
+ edit.append(text); // 将删除的文本追加到新的NoteEditText对象中
+ edit.requestFocus(); // 设置焦点到新的NoteEditText对象
+ edit.setSelection(length); // 设置光标位置到追加文本之前
+ }
+
+ // 处理EditText输入事件，添加新列表项
+ public void onEditTextEnter(int index, String text) {
+ // 如果索引超出范围，则记录错误日志
+ if(index > mEditTextList.getChildCount()) {
+ Log.e(TAG, "Index out of mEditTextList boundrary, should not happen");
+ }
+
+ View view = getListItem(text, index); // 创建新的NoteEditText视图
+ mEditTextList.addView(view, index); // 将新的视图添加到指定位置
+ NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); // 获取NoteEditText对象
+ edit.requestFocus(); // 设置焦点到新的NoteEditText对象
+ edit.setSelection(0); // 设置光标位置到文本开头
+ // 调整新添加NoteEditText之后的NoteEditText索引
+ for (int i = index + 1; i < mEditTextList.getChildCount(); i++) {
+ ((NoteEditText) mEditTextList.getChildAt(i).findViewById(R.id.et_edit_text))
+ .setIndex(i);
+ }
+ }
+
+ // 切换到列表模式，根据笔记内容生成列表项
+ private void switchToListMode(String text) {
+ mEditTextList.removeAllViews(); // 移除所有NoteEditText视图
+ String[] items = text.split("\n"); // 将笔记内容按换行符分割成多个项
+ int index = 0;
+ // 遍历每一项，创建并添加NoteEditText视图
+ for (String item : items) {
+ if(!TextUtils.isEmpty(item)) { // 如果项不为空
+ mEditTextList.addView(getListItem(item, index)); // 添加NoteEditText视图
+ index++; // 索引加1
+ }
+ }
+ mEditTextList.addView(getListItem("", index)); // 添加一个空的NoteEditText视图
+ // 设置焦点到新添加的NoteEditText对象
+ mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
+
+ mNoteEditor.setVisibility(View.GONE); // 隐藏编辑框
+ mEditTextList.setVisibility(View.VISIBLE); // 显示NoteEditText列表
+ }
+
+ // 获取高亮查询结果，用于显示搜索关键词
+ private Spannable getHighlightQueryResult(String fullText, String userQuery) {
+ SpannableString spannable = new SpannableString(fullText == null ? "" : fullText); // 创建SpannableString对象
+ if (!TextUtils.isEmpty(userQuery)) { // 如果用户查询字符串不为空
+ mPattern = Pattern.compile(userQuery); // 编译正则表达式模式
+ Matcher m = mPattern.matcher(fullText); // 创建Matcher对象
+ int start = 0;
+ // 遍历匹配结果，为搜索关键词添加背景颜色标记
+ while (m.find(start)) {
+ spannable.setSpan(
+ new BackgroundColorSpan(this.getResources().getColor(
+ R.color.user_query_highlight)), m.start(), m.end(), // 设置背景颜色标记
+ Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
+ start = m.end();
+ }
+ }
+ return spannable; // 返回高亮搜索结果
+ }
+
+ // 生成一个新的列表项视图
+ private View getListItem(String item, int index) {
+ View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null); // 创建NoteEditText视图
+ final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); // 获取NoteEditText对象
+ edit.setTextAppearance(this, // 设置文本外观
+ TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
+ CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item)); // 获取CheckBox对象
+ // 设置CheckBox的点击监听器
+ cb.setOnCheckedChangeListener(new OnCheckedChangeListener() {
+ public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+ if (isChecked) {
+ edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); // 设置文本划线
+ } else {
+ edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG); // 清除文本划线
+ }
+ }
+ });
+
+ // 根据项内容设置CheckBox状态
+ if (item.startsWith(TAG_CHECKED)) {
+ cb.setChecked(true); // 设置CheckBox为勾选状态
+ edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG); // 设置文本划线
+ item = item.substring(TAG_CHECKED.length(), item.length()).trim(); // 去掉勾选标签
+ } else if (item.startsWith(TAG_UNCHECKED)) {
+ cb.setChecked(false); // 设置CheckBox为未勾选状态
+ edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG); // 清除文本划线
+ item = item.substring(TAG_UNCHECKED.length(), item.length()).trim(); // 去掉未勾选标签
+ }
+
+ edit.setOnTextViewChangeListener(this); // 设置文本变化监听器
+ edit.setIndex(index); // 设置索引
+ edit.setText(getHighlightQueryResult(item, mUserQuery)); // 设置文本并高亮搜索关键词
+ return view; // 返回生成的NoteEditText视图
+ }
+
+ // 处理EditText文本变化事件，显示或隐藏复选框
+ public void onTextChange(int index, boolean hasText) {
+ // 如果索引超出范围，则记录错误日志
+ if (index >= mEditTextList.getChildCount()) {
+ Log.e(TAG, "Wrong index, should not happen");
+ return;
+ }
+ // 根据文本内容显示或隐藏CheckBox
+ if(hasText) {
+ mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
+ } else {
+ mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
+ }
+ }
+
+ // 处理笔记模式变化事件，从普通模式切换到列表模式或反之
+ public void onCheckListModeChanged(int oldMode, int newMode) {
+ // 如果新模式是检查列表模式，则切换到列表模式
+ if (newMode == TextNote.MODE_CHECK_LIST) {
+ switchToListMode(mNoteEditor.getText().toString());
+ } else { // 如果新模式不是检查列表模式，则切换到普通模式
+ // 如果不是检查列表模式，则从内容中移除检查列表标签
+ if (!getWorkingText()) {
+ mWorkingNote.setWorkingText(mWorkingNote.getContent().replace(TAG_UNCHECKED + " ",
+ ""));
+ }
+ mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery)); // 设置编辑框文本并高亮搜索关键词
+ mEditTextList.setVisibility(View.GONE); // 隐藏NoteEditText列表
+ mNoteEditor.setVisibility(View.VISIBLE); // 显示编辑框
+ }
+ }
+
+ // 获取正在编辑的文本内容，根据列表模式添加标签
+ private boolean getWorkingText() {
+ boolean hasChecked = false; // 是否有勾选项
+ // 如果笔记处于检查列表模式，则从列表项中获取文本内容，并添加标签
+ if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
+ StringBuilder sb = new StringBuilder();
+ // 遍历NoteEditText列表项
+ for (int i = 0; i < mEditTextList.getChildCount(); i++) {
+ View view = mEditTextList.getChildAt(i); // 获取NoteEditText视图
+ NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text); // 获取NoteEditText对象
+ // 如果NoteEditText文本不为空，则根据CheckBox状态添加标签
+ if (!TextUtils.isEmpty(edit.getText())) {
+ // 如果CheckBox被勾选，则添加勾选标签，并设置文本划线
+ if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
+ sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
+ hasChecked = true;
+ } else { // 如果CheckBox未被勾选，则添加未勾选标签
+ sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
+ }
+ }
+ }
+ mWorkingNote.setWorkingText(sb.toString()); // 设置正在编辑的文本内容
+ } else { // 如果笔记不是检查列表模式，则直接设置文本内容
+ mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
+ }
+ return hasChecked; // 返回是否有勾选项
+ }
+
+ // 保存笔记内容到数据库
+ private boolean saveNote() {
+ getWorkingText(); // 获取正在编辑的文本内容
+ boolean saved = mWorkingNote.saveNote(); // 保存笔记
+ if (saved) { // 如果保存成功，则设置Activity结果为RESULT_OK
+ setResult(RESULT_OK);
+ }
+ return saved; // 返回保存结果
+ }
+
+ // 将笔记快捷方式添加到桌面
+ private void sendToDesktop() {
+ // 如果笔记不存在于数据库中，则保存笔记
+ if (!mWorkingNote.existInDatabase()) {
+ saveNote();
+ }
+
+ // 如果笔记ID大于0
+ if (mWorkingNote.getNoteId() > 0) {
+ Intent sender = new Intent(); // 创建Intent对象
+ Intent shortcutIntent = new Intent(this, NoteEditActivity.class); // 创建快捷方式Intent
+ shortcutIntent.setAction(Intent.ACTION_VIEW); // 设置Intent动作为ACTION_VIEW
+ shortcutIntent.putExtra(Intent.EXTRA_UID, mWorkingNote.getNoteId()); // 添加笔记ID
+ sender.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent); // 添加快捷方式Intent
+ sender.putExtra(Intent.EXTRA_SHORTCUT_NAME, // 设置快捷方式名称
+ makeShortcutIconTitle(mWorkingNote.getContent()));
+ sender.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, // 添加快捷方式图标
+ Intent.ShortcutIconResource.fromContext(this, R.drawable.icon_app));
+ sender.putExtra("duplicate", true); // 允许创建重复快捷方式
+ sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT"); // 设置Intent动作为安装快捷方式
+ showToast(R.string.info_note_enter_desktop); // 显示提示信息
+ sendBroadcast(sender); // 发送安装快捷方式的广播
+ } else { // 如果笔记ID无效，则显示错误信息
+ Log.e(TAG, "Send to desktop error");
+ showToast(R.string.error_note_empty_for_send_to_desktop);
+ }
+ }
+
+ // 生成桌面快捷方式的标题，截取笔记内容的一部分作为标题
+ private String makeShortcutIconTitle(String content) {
+ content = content.replace(TAG_CHECKED, ""); // 移除勾选标签
+ content = content.replace(TAG_UNCHECKED, ""); // 移除未勾选标签
+ // 如果内容长度大于最大长度，则截取前10个字符作为标题；否则直接使用内容作为标题
+ return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
+ SHORTCUT_ICON_TITLE_MAX_LEN) : content;
+ }
+
+ // 显示短Toast消息
+ private void showToast(int resId) {
+ showToast(resId, Toast.LENGTH_SHORT); // 调用另一个showToast方法，设置Toast显示时间为短时间
+ }
+
+ // 显示指定持续时间的Toast消息
+ private void showToast(int resId, int duration) {
+ Toast.makeText(this, resId, duration).show(); // 显示Toast消息
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java b/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
new file mode 100644
index 0000000..beaee55
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
@@ -0,0 +1,222 @@
+/*
+ * 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
+ *
+ * 除非适用法律要求或书面同意，根据许可证分发的软件
+ * 将按“原样”基础进行分发，没有任何明示或暗示的担保或条件。
+ * 请参阅许可证以了解管理权限和限制的具体语言。
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.text.Layout;
+import android.text.Selection;
+import android.text.Spanned;
+import android.text.TextUtils;
+import android.text.style.URLSpan;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.widget.EditText;
+
+import net.micode.notes.R;
+
+import java.util.HashMap;
+import java.util.Map;
+
+// 自定义的EditText，用于笔记应用中，支持删除、添加文本事件监听
+public class NoteEditText extends EditText {
+ private static final String TAG = "NoteEditText"; // 日志标签
+ private int mIndex; // 当前文本框的索引
+ private int mSelectionStartBeforeDelete; // 记录删除操作前的光标位置
+
+ private static final String SCHEME_TEL = "tel:"; // 电话号码URL前缀
+ private static final String SCHEME_HTTP = "http:"; // 网络链接URL前缀
+ private static final String SCHEME_EMAIL = "mailto:"; // 邮件链接URL前缀
+
+ // URL方案与对应的字符串资源ID的映射
+ private static final Map sSchemaActionResMap = new HashMap();
+ static {
+ sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
+ sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
+ sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
+ }
+
+ /**
+ * 由 {@link NoteEditActivity} 调用，用于删除或添加编辑文本
+ */
+ public interface OnTextViewChangeListener {
+ /**
+ * 在 {@link KeyEvent#KEYCODE_DEL} 发生且文本为空时删除当前编辑文本
+ */
+ void onEditTextDelete(int index, String text);
+
+ /**
+ * 在 {@link KeyEvent#KEYCODE_ENTER} 发生时在当前编辑文本后添加新的编辑文本
+ */
+ void onEditTextEnter(int index, String text);
+
+ /**
+ * 文本变化时隐藏或显示选项
+ */
+ void onTextChange(int index, boolean hasText);
+ }
+
+ private OnTextViewChangeListener mOnTextViewChangeListener; // 文本变化监听器实例
+
+ public NoteEditText(Context context) {
+ super(context, null); // 调用父类构造函数
+ mIndex = 0; // 初始化文本框索引为0
+ }
+
+ // 设置当前文本框的索引
+ public void setIndex(int index) {
+ mIndex = index;
+ }
+
+ // 设置文本变化监听器
+ public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
+ mOnTextViewChangeListener = listener;
+ }
+
+ public NoteEditText(Context context, AttributeSet attrs) {
+ super(context, attrs, android.R.attr.editTextStyle); // 调用父类构造函数并设置默认样式
+ }
+
+ public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle); // 调用父类构造函数并设置自定义样式
+ // TODO Auto-generated constructor stub
+ }
+
+ // 处理触摸事件，更新光标位置
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_DOWN: // 触摸屏幕时
+ int x = (int) event.getX(); // 获取触摸点的X坐标
+ int y = (int) event.getY(); // 获取触摸点的Y坐标
+ x -= getTotalPaddingLeft(); // 减去左内边距
+ y -= getTotalPaddingTop(); // 减去上内边距
+ x += getScrollX(); // 加上水平滚动位置
+ y += getScrollY(); // 加上垂直滚动位置
+
+ Layout layout = getLayout(); // 获取文本布局信息
+ int line = layout.getLineForVertical(y); // 根据Y坐标获取行号
+ int off = layout.getOffsetForHorizontal(line, x); // 根据行号和X坐标获取偏移量
+ Selection.setSelection(getText(), off); // 更新光标位置
+ break;
+ }
+
+ return super.onTouchEvent(event); // 调用父类的触摸事件处理方法
+ }
+
+ // 处理按键按下事件，记录删除操作前的光标位置
+ @Override
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ switch (keyCode) {
+ case KeyEvent.KEYCODE_ENTER: // 按下回车键
+ if (mOnTextViewChangeListener != null) {
+ return false; // 如果设置了监听器，返回false以拦截按键事件
+ }
+ break;
+ case KeyEvent.KEYCODE_DEL: // 按下删除键
+ mSelectionStartBeforeDelete = getSelectionStart(); // 记录删除操作前的光标位置
+ break;
+ default: // 其他按键
+ break;
+ }
+ return super.onKeyDown(keyCode, event); // 调用父类的按键按下事件处理方法
+ }
+
+ // 处理按键弹起事件，根据按键类型执行相应操作
+ @Override
+ public boolean onKeyUp(int keyCode, KeyEvent event) {
+ switch (keyCode) {
+ case KeyEvent.KEYCODE_DEL: // 弹起删除键
+ if (mOnTextViewChangeListener != null) {
+ if (0 == mSelectionStartBeforeDelete && mIndex != 0) { // 如果光标在文本开头且不是第一个文本框
+ mOnTextViewChangeListener.onEditTextDelete(mIndex, getText().toString()); // 通知监听器删除文本框
+ return true; // 拦截按键事件
+ }
+ } else {
+ Log.d(TAG, "OnTextViewChangeListener was not seted"); // 如果未设置监听器，记录日志
+ }
+ break;
+ case KeyEvent.KEYCODE_ENTER: // 弹起回车键
+ if (mOnTextViewChangeListener != null) {
+ int selectionStart = getSelectionStart(); // 获取光标位置
+ String text = getText().subSequence(selectionStart, length()).toString(); // 获取光标后的文本
+ setText(getText().subSequence(0, selectionStart)); // 将光标后的文本清空
+ mOnTextViewChangeListener.onEditTextEnter(mIndex + 1, text); // 通知监听器添加新的文本框
+ } else {
+ Log.d(TAG, "OnTextViewChangeListener was not seted"); // 如果未设置监听器，记录日志
+ }
+ break;
+ default: // 其他按键
+ break;
+ }
+ return super.onKeyUp(keyCode, event); // 调用父类的按键弹起事件处理方法
+ }
+
+ // 当EditText焦点发生变化时调用，通知监听器文本是否有内容
+ @Override
+ protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
+ if (mOnTextViewChangeListener != null) {
+ if (!focused && TextUtils.isEmpty(getText())) { // 如果失去焦点且文本为空
+ mOnTextViewChangeListener.onTextChange(mIndex, false); // 通知监听器文本内容为空
+ } else {
+ mOnTextViewChangeListener.onTextChange(mIndex, true); // 通知监听器文本内容不为空
+ }
+ }
+ super.onFocusChanged(focused, direction, previouslyFocusedRect); // 调用父类的焦点变化处理方法
+ }
+
+ // 创建上下文菜单，处理URL点击事件
+ @Override
+ protected void onCreateContextMenu(ContextMenu menu) {
+ if (getText() instanceof Spanned) { // 如果文本是Spanned类型
+ int selStart = getSelectionStart(); // 获取选择的起始位置
+ int selEnd = getSelectionEnd(); // 获取选择的结束位置
+
+ int min = Math.min(selStart, selEnd); // 计算选择的最小位置
+ int max = Math.max(selStart, selEnd); // 计算选择的最大位置
+
+ final URLSpan[] urls = ((Spanned) getText()).getSpans(min, max, URLSpan.class); // 获取选择区域内的URLSpan
+ if (urls.length == 1) { // 如果只有一个URLSpan
+ int defaultResId = 0;
+ for (String schema : sSchemaActionResMap.keySet()) {
+ if (urls[0].getURL().indexOf(schema) >= 0) { // 根据URL前缀匹配对应的资源ID
+ defaultResId = sSchemaActionResMap.get(schema);
+ break;
+ }
+ }
+
+ if (defaultResId == 0) { // 如果没有匹配到前缀
+ defaultResId = R.string.note_link_other; // 使用默认的资源ID
+ }
+
+ // 添加上下文菜单项并设置点击监听器
+ menu.add(0, 0, 0, defaultResId).setOnMenuItemClickListener(
+ new OnMenuItemClickListener() {
+ public boolean onMenuItemClick(MenuItem item) {
+ // 点击菜单项时，触发URLSpan的点击事件
+ urls[0].onClick(NoteEditText.this);
+ return true; // 拦截点击事件
+ }
+ });
+ }
+ }
+ super.onCreateContextMenu(menu); // 调用父类的创建上下文菜单方法
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java b/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
new file mode 100644
index 0000000..cde2ecd
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
@@ -0,0 +1,253 @@
+/*
+ * 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
+ *
+ * 除非适用法律要求或书面同意，软件
+ * 分发在“现状”基础上，不附带任何明示或暗示的担保或条件。
+ * 请参阅许可证以了解特定的许可限制和
+ * 适用的条件。
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.text.TextUtils;
+
+import net.micode.notes.data.Contact;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.tool.DataUtils;
+
+// 该类用于从数据库游标中提取笔记项数据，并处理与笔记位置相关的逻辑
+public class NoteItemData {
+ // 定义了查询数据库时要获取的列
+ static final String [] PROJECTION = new String [] {
+ NoteColumns.ID, // 笔记项的唯一标识ID
+ NoteColumns.ALERTED_DATE, // 笔记项的提醒日期
+ NoteColumns.BG_COLOR_ID, // 笔记项的背景颜色ID
+ NoteColumns.CREATED_DATE, // 笔记项的创建日期
+ NoteColumns.HAS_ATTACHMENT, // 笔记项是否有附件
+ NoteColumns.MODIFIED_DATE, // 笔记项的修改日期
+ NoteColumns.NOTES_COUNT, // 笔记项包含的笔记数量
+ NoteColumns.PARENT_ID, // 笔记项的父ID，如果是文件夹下的笔记，则是文件夹ID
+ NoteColumns.SNIPPET, // 笔记项的摘要信息
+ NoteColumns.TYPE, // 笔记项的类型，例如笔记、文件夹等
+ NoteColumns.WIDGET_ID, // 与笔记项关联的小部件ID
+ NoteColumns.WIDGET_TYPE, // 小部件的类型
+ };
+
+ // 定义了游标中各个列的索引位置，便于后续从游标中获取数据时使用
+ private static final int ID_COLUMN = 0;
+ private static final int ALERTED_DATE_COLUMN = 1;
+ private static final int BG_COLOR_ID_COLUMN = 2;
+ private static final int CREATED_DATE_COLUMN = 3;
+ private static final int HAS_ATTACHMENT_COLUMN = 4;
+ private static final int MODIFIED_DATE_COLUMN = 5;
+ private static final int NOTES_COUNT_COLUMN = 6;
+ private static final int PARENT_ID_COLUMN = 7;
+ private static final int SNIPPET_COLUMN = 8;
+ private static final int TYPE_COLUMN = 9;
+ private static final int WIDGET_ID_COLUMN = 10;
+ private static final int WIDGET_TYPE_COLUMN = 11;
+
+ // 笔记项的各种属性
+ private long mId; // 笔记项的唯一标识ID
+ private long mAlertDate; // 笔记项的提醒日期
+ private int mBgColorId; // 笔记项的背景颜色ID
+ private long mCreatedDate; // 笔记项的创建日期
+ private boolean mHasAttachment; // 笔记项是否有附件
+ private long mModifiedDate; // 笔记项的修改日期
+ private int mNotesCount; // 笔记项包含的笔记数量
+ private long mParentId; // 笔记项的父ID，如果是文件夹下的笔记，则是文件夹ID
+ private String mSnippet; // 笔记项的摘要信息
+ private int mType; // 笔记项的类型，例如笔记、文件夹等
+ private int mWidgetId; // 与笔记项关联的小部件ID
+ private int mWidgetType; // 小部件的类型
+ private String mName; // 笔记项关联的联系人名称
+ private String mPhoneNumber; // 笔记项关联的联系人电话号码
+
+ // 笔记项在列表中的位置信息
+ private boolean mIsLastItem; // 是否是列表中的最后一个项
+ private boolean mIsFirstItem; // 是否是列表中的第一个项
+ private boolean mIsOnlyOneItem; // 是否是列表中唯一的项
+ private boolean mIsOneNoteFollowingFolder; // 是否是单个笔记跟在一个文件夹后
+ private boolean mIsMultiNotesFollowingFolder; // 是否是多个笔记跟在一个文件夹后
+
+ // 构造函数，从游标中提取笔记项数据
+ public NoteItemData(Context context, Cursor cursor) {
+ mId = cursor.getLong(ID_COLUMN); // 获取笔记项的ID
+ mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN); // 获取笔记项的提醒日期
+ mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN); // 获取笔记项的背景颜色ID
+ mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN); // 获取笔记项的创建日期
+ mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0) ? true : false; // 判断笔记项是否有附件
+ mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN); // 获取笔记项的修改日期
+ mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN); // 获取笔记项包含的笔记数量
+ mParentId = cursor.getLong(PARENT_ID_COLUMN); // 获取笔记项的父ID
+ mSnippet = cursor.getString(SNIPPET_COLUMN); // 获取笔记项的摘要信息
+ mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(NoteEditActivity.TAG_UNCHECKED, ""); // 清理摘要中的特定标签
+ mType = cursor.getInt(TYPE_COLUMN); // 获取笔记项的类型
+ mWidgetId = cursor.getInt(WIDGET_ID_COLUMN); // 获取笔记项的小部件ID
+ mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN); // 获取笔记项的小部件类型
+
+ mPhoneNumber = ""; // 初始化电话号码为空字符串
+ if (mParentId == Notes.ID_CALL_RECORD_FOLDER) { // 如果笔记项的父ID是呼叫记录文件夹的ID
+ mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId); // 通过笔记ID获取对应的呼叫记录的电话号码
+ if (!TextUtils.isEmpty(mPhoneNumber)) { // 如果电话号码不为空
+ mName = Contact.getContact(context, mPhoneNumber); // 通过电话号码查询联系人信息
+ if (mName == null) { // 如果没有找到对应的联系人名称
+ mName = mPhoneNumber; // 则将电话号码作为名称
+ }
+ }
+ }
+
+ if (mName == null) { // 如果联系人名称依然为null
+ mName = ""; // 初始化为空字符串
+ }
+ checkPostion(cursor); // 检查笔记项在列表中的位置信息
+ }
+
+ // 检查笔记项在列表中的位置信息
+ private void checkPostion(Cursor cursor) {
+ mIsLastItem = cursor.isLast() ? true : false; // 设置是否是列表中的最后一个项
+ mIsFirstItem = cursor.isFirst() ? true : false; // 设置是否是列表中的第一个项
+ mIsOnlyOneItem = (cursor.getCount() == 1); // 如果列表中的项数为1，则设置为唯一项
+ mIsMultiNotesFollowingFolder = false; // 初始化是否是多个笔记跟在一个文件夹后为false
+ mIsOneNoteFollowingFolder = false; // 初始化是否是单个笔记跟在一个文件夹后为false
+
+ // 如果笔记项类型是笔记且不是列表中的第一个项
+ if (mType == Notes.TYPE_NOTE && !mIsFirstItem) {
+ int position = cursor.getPosition(); // 获取当前笔记项的位置
+ if (cursor.moveToPrevious()) { // 将游标移动到前一行
+ // 如果前一行的类型是文件夹或系统类型
+ if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER || cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
+ // 如果列表中的项数大于当前位置加1
+ if (cursor.getCount() > (position + 1)) {
+ mIsMultiNotesFollowingFolder = true; // 设置为多个笔记跟在一个文件夹后
+ } else {
+ mIsOneNoteFollowingFolder = true; // 设置为单个笔记跟在一个文件夹后
+ }
+ }
+ if (!cursor.moveToNext()) { // 将游标移动回原来的位置
+ throw new IllegalStateException("cursor move to previous but can't move back"); // 如果移动失败，抛出异常
+ }
+ }
+ }
+ }
+
+ // 判断该笔记项是否是单个笔记跟在一个文件夹后
+ public boolean isOneFollowingFolder() {
+ return mIsOneNoteFollowingFolder; // 返回是否是单个笔记跟在一个文件夹后的结果
+ }
+
+ // 判断该笔记项是否是多个笔记跟在一个文件夹后
+ public boolean isMultiFollowingFolder() {
+ return mIsMultiNotesFollowingFolder; // 返回是否是多个笔记跟在一个文件夹后的结果
+ }
+
+ // 判断该笔记项是否是列表中的最后一个项
+ public boolean isLast() {
+ return mIsLastItem; // 返回是否是列表中最后一个项的结果
+ }
+
+ // 获取与该笔记项关联的呼叫记录的联系人名称
+ public String getCallName() {
+ return mName; // 返回关联的联系人名称
+ }
+
+ // 判断该笔记项是否是列表中的第一个项
+ public boolean isFirst() {
+ return mIsFirstItem; // 返回是否是列表中第一个项的结果
+ }
+
+ // 判断该笔记项是否是列表中唯一的项
+ public boolean isSingle() {
+ return mIsOnlyOneItem; // 返回是否是列表中唯一项的结果
+ }
+
+ // 获取笔记项的ID
+ public long getId() {
+ return mId; // 返回笔记项的ID
+ }
+
+ // 获取笔记项的提醒日期
+ public long getAlertDate() {
+ return mAlertDate; // 返回笔记项的提醒日期
+ }
+
+ // 获取笔记项的创建日期
+ public long getCreatedDate() {
+ return mCreatedDate; // 返回笔记项的创建日期
+ }
+
+ // 判断该笔记项是否有附件
+ public boolean hasAttachment() {
+ return mHasAttachment; // 返回笔记项是否有附件的结果
+ }
+
+ // 获取笔记项的修改日期
+ public long getModifiedDate() {
+ return mModifiedDate; // 返回笔记项的修改日期
+ }
+
+ // 获取笔记项的背景颜色ID
+ public int getBgColorId() {
+ return mBgColorId; // 返回笔记项的背景颜色ID
+ }
+
+ // 获取笔记项的父ID
+ public long getParentId() {
+ return mParentId; // 返回笔记项的父ID
+ }
+
+ // 获取笔记项包含的笔记数量
+ public int getNotesCount() {
+ return mNotesCount; // 返回笔记项包含的笔记数量
+ }
+
+ // 获取笔记项所在的文件夹ID
+ public long getFolderId () {
+ return mParentId; // 返回笔记项所在的文件夹ID，与getParentId相同
+ }
+
+ // 获取笔记项的类型
+ public int getType() {
+ return mType; // 返回笔记项的类型
+ }
+
+ // 获取笔记项的小部件类型
+ public int getWidgetType() {
+ return mWidgetType; // 返回笔记项的小部件类型
+ }
+
+ // 获取笔记项的小部件ID
+ public int getWidgetId() {
+ return mWidgetId; // 返回笔记项的小部件ID
+ }
+
+ // 获取笔记项的摘要
+ public String getSnippet() {
+ return mSnippet; // 返回笔记项的摘要
+ }
+
+ // 判断该笔记项是否有提醒
+ public boolean hasAlert() {
+ return (mAlertDate > 0); // 如果提醒日期大于0，表示有提醒
+ }
+
+ // 判断该笔记项是否是呼叫记录类型
+ public boolean isCallRecord() {
+ // 如果父ID是呼叫记录文件夹的ID且电话号码不为空，则是呼叫记录类型
+ return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
+ }
+
+ // 静态方法，从游标中获取笔记项的类型
+ public static int getNoteType(Cursor cursor) {
+ return cursor.getInt(TYPE_COLUMN); // 从游标中获取笔记项的类型
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java b/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
new file mode 100644
index 0000000..e54f4a3
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
@@ -0,0 +1,1107 @@
+package net.micode.notes.ui;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.appwidget.AppWidgetManager;
+import android.content.AsyncQueryHandler;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.util.Log;
+import android.view.ActionMode;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.Display;
+import android.view.HapticFeedbackConstants;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.View.OnCreateContextMenuListener;
+import android.view.View.OnTouchListener;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.AdapterView.OnItemLongClickListener;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.PopupMenu;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.remote.GTaskSyncService;
+import net.micode.notes.model.WorkingNote;
+import net.micode.notes.tool.BackupUtils;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
+import net.micode.notes.widget.NoteWidgetProvider_2x;
+import net.micode.notes.widget.NoteWidgetProvider_4x;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.HashSet;
+
+/**
+ * 笔记列表展示Activity，主要用于展示用户的笔记列表，新建笔记，批量删除笔记等操作
+ */
+public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
+ // 定义了用于查询笔记列表和文件夹列表的token
+ private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0;
+ private static final int FOLDER_LIST_QUERY_TOKEN = 1;
+
+ // 定义了文件夹操作菜单项的id
+ private static final int MENU_FOLDER_DELETE = 0;
+ private static final int MENU_FOLDER_VIEW = 1;
+ private static final int MENU_FOLDER_CHANGE_NAME = 2;
+
+ // 用于保存是否已经添加了应用介绍的偏好设置键
+ private static final String PREFERENCE_ADD_INTRODUCTION = "net.micode.notes.introduction";
+
+ // 枚举类，定义了当前Activity的不同状态
+ private enum ListEditState {
+ NOTE_LIST, SUB_FOLDER, CALL_RECORD_FOLDER
+ };
+
+ private ListEditState mState; // 当前Activity状态
+
+ private BackgroundQueryHandler mBackgroundQueryHandler; // 异步查询处理器
+ private NotesListAdapter mNotesListAdapter; // 笔记列表适配器，负责展示笔记列表
+ private ListView mNotesListView; // 笔记列表视图
+ private Button mAddNewNote; // 新建笔记按钮
+ private boolean mDispatch; // 是否需要将触摸事件分发给ListView
+ private int mOriginY; // 触摸开始时的Y坐标
+ private int mDispatchY; // 触摸事件需要被分发时的Y坐标
+ private TextView mTitleBar; // 标题栏文本视图
+ private long mCurrentFolderId; // 当前显示的文件夹ID
+ private ContentResolver mContentResolver; // 内容解析器，用于操作数据库
+ private ModeCallback mModeCallBack; // ActionMode回调，用于处理批量操作菜单
+
+ private static final String TAG = "NotesListActivity"; // 日志标签
+
+ public static final int NOTES_LISTVIEW_SCROLL_RATE = 30; // 笔记列表滚动速率
+
+ private NoteItemData mFocusNoteDataItem; // 当前选中的笔记项数据
+
+ // 查询笔记列表时使用的SQL选择语句
+ private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?";
+
+ // 查询根文件夹下的笔记列表时使用的SQL选择语句
+ private static final String ROOT_FOLDER_SELECTION = "(" + NoteColumns.TYPE + "<>"
+ + Notes.TYPE_SYSTEM + " AND " + NoteColumns.PARENT_ID + "=?)" + " OR ("
+ + NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER + " AND "
+ + NoteColumns.NOTES_COUNT + ">0)";
+
+ // 打开或新建节点后的请求码
+ private final static int REQUEST_CODE_OPEN_NODE = 102;
+ private final static int REQUEST_CODE_NEW_NODE = 103;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.note_list); // 设置布局文件
+ initResources(); // 初始化资源
+
+ /**
+ * 当用户首次使用应用时，插入一个介绍笔记
+ */
+ setAppInfoFromRawRes();
+ }
+
+ /**
+ * 处理Activity返回的结果，如果是新建或打开笔记后的返回结果，则更新笔记列表
+ * @param requestCode 请求码
+ * @param resultCode 返回结果码
+ * @param data 返回的Intent数据
+ */
+ @Override
+ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ if (resultCode == RESULT_OK
+ && (requestCode == REQUEST_CODE_OPEN_NODE || requestCode == REQUEST_CODE_NEW_NODE)) {
+ mNotesListAdapter.changeCursor(null); // 更新笔记列表
+ } else {
+ super.onActivityResult(requestCode, resultCode, data);
+ }
+ }
+
+ /**
+ * 从raw资源文件中读取应用介绍，并保存到本地数据库
+ */
+ private void setAppInfoFromRawRes() {
+ SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this); // 获取偏好设置
+ if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) { // 如果尚未添加介绍
+ StringBuilder sb = new StringBuilder();
+ InputStream in = null;
+ try {
+ in = getResources().openRawResource(R.raw.introduction); // 打开raw资源文件
+ if (in != null) {
+ InputStreamReader isr = new InputStreamReader(in);
+ BufferedReader br = new BufferedReader(isr);
+ char [] buf = new char[1024];
+ int len = 0;
+ while ((len = br.read(buf)) > 0) { // 读取文件内容
+ sb.append(buf, 0, len);
+ }
+ } else {
+ Log.e(TAG, "Read introduction file error");
+ return;
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ return;
+ } finally {
+ if(in != null) {
+ try {
+ in.close(); // 关闭输入流
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
+ AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
+ ResourceParser.RED);
+ note.setWorkingText(sb.toString());
+ if (note.saveNote()) { // 保存介绍笔记到数据库
+ sp.edit().putBoolean(PREFERENCE_ADD_INTRODUCTION, true).commit(); // 更新偏好设置
+ } else {
+ Log.e(TAG, "Save introduction note error");
+ return;
+ }
+ }
+ }
+
+ @Override
+ protected void onStart() {
+ super.onStart();
+ startAsyncNotesListQuery(); // 异步查询笔记列表并展示
+ }
+
+ /**
+ * 初始化资源，主要包括：
+ * 1. 获取ContentResolver
+ * 2. 初始化BackgroundQueryHandler
+ * 3. 设置当前文件夹ID为根文件夹ID
+ * 4. 查找视图控件并设置监听器
+ * 5. 初始化NotesListAdapter并绑定到ListView
+ * 6. 设置Activity状态为NOTE_LIST
+ */
+ private void initResources() {
+ mContentResolver = this.getContentResolver();
+ mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
+ mCurrentFolderId = Notes.ID_ROOT_FOLDER;
+ mNotesListView = (ListView) findViewById(R.id.notes_list);
+ mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
+ null, false); // 添加底部视图
+ mNotesListView.setOnItemClickListener(new OnListItemClickListener()); // 设置点击监听器
+ mNotesListView.setOnItemLongClickListener(this); // 设置长按监听器
+ mNotesListAdapter = new NotesListAdapter(this);
+ mNotesListView.setAdapter(mNotesListAdapter); // 设置适配器
+ mAddNewNote = (Button) findViewById(R.id.btn_new_note);
+ mAddNewNote.setOnClickListener(this); // 设置点击监听器
+ mAddNewNote.setOnTouchListener(new NewNoteOnTouchListener()); // 设置触摸监听器
+ mDispatch = false;
+ mDispatchY = 0;
+ mOriginY = 0;
+ mTitleBar = (TextView) findViewById(R.id.tv_title_bar);
+ mState = ListEditState.NOTE_LIST;
+ mModeCallBack = new ModeCallback(); // 初始化ActionMode回调
+ }
+
+ /**
+ * ActionMode回调类，用于处理批量操作菜单的创建、显示和点击事件
+ */
+ private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
+ private DropdownMenu mDropDownMenu; // 下拉菜单
+ private ActionMode mActionMode; // ActionMode
+ private MenuItem mMoveMenu; // 移动笔记的菜单项
+
+ /**
+ * 创建ActionMode并设置菜单
+ * @param mode ActionMode对象
+ * @param menu 菜单对象
+ * @return 返回true，表示ActionMode创建成功
+ */
+ public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+ getMenuInflater().inflate(R.menu.note_list_options, menu); // 设置菜单
+ menu.findItem(R.id.delete).setOnMenuItemClickListener(this); // 设置删除菜单项的点击监听器
+ mMoveMenu = menu.findItem(R.id.move);
+ if (mFocusNoteDataItem.getParentId() == Notes.ID_CALL_RECORD_FOLDER
+ || DataUtils.getUserFolderCount(mContentResolver) == 0) {
+ mMoveMenu.setVisible(false); // 如果当前文件夹为通话记录文件夹或无用户文件夹，隐藏移动菜单项
+ } else {
+ mMoveMenu.setVisible(true); // 显示移动菜单项
+ mMoveMenu.setOnMenuItemClickListener(this); // 设置移动菜单项的点击监听器
+ }
+ mActionMode = mode;
+ mNotesListAdapter.setChoiceMode(true); // 设置列表适配器为选择模式
+ mNotesListView.setLongClickable(false); // 禁用长按操作
+ mAddNewNote.setVisibility(View.GONE); // 隐藏新建笔记按钮
+
+ // 设置自定义ActionMode视图
+ View customView = LayoutInflater.from(NotesListActivity.this).inflate(
+ R.layout.note_list_dropdown_menu, null);
+ mode.setCustomView(customView);
+ mDropDownMenu = new DropdownMenu(NotesListActivity.this,
+ (Button) customView.findViewById(R.id.selection_menu),
+ R.menu.note_list_dropdown);
+ mDropDownMenu.setOnDropdownMenuItemClickListener(new PopupMenu.OnMenuItemClickListener(){
+ public boolean onMenuItemClick(MenuItem item) {
+ mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected()); // 全选或全不选
+ updateMenu(); // 更新菜单
+ return true;
+ }
+ });
+ return true;
+ }
+
+ /**
+ * 更新菜单，包括下拉菜单的标题和选择项
+ */
+ private void updateMenu() {
+ int selectedCount = mNotesListAdapter.getSelectedCount(); // 获取选中的笔记数量
+ // 更新下拉菜单标题
+ String format = getResources().getString(R.string.menu_select_title, selectedCount);
+ mDropDownMenu.setTitle(format);
+ MenuItem item = mDropDownMenu.findItem(R.id.action_select_all);
+ if (item != null) {
+ if (mNotesListAdapter.isAllSelected()) { // 如果所有笔记都被选中
+ item.setChecked(true);
+ item.setTitle(R.string.menu_deselect_all); // 更新菜单项标题为取消全选
+ } else {
+ item.setChecked(false);
+ item.setTitle(R.string.menu_select_all); // 更新菜单项标题为全选
+ }
+ }
+ }
+
+ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+ // 不需要在ActionMode准备时修改菜单，返回false
+ return false;
+ }
+
+ /**
+ * 处理菜单项点击事件
+ * @param mode ActionMode对象
+ * @param menu 菜单对象
+ * @param item 被点击的菜单项
+ * @param rangeStart 被点击的菜单项的起始位置（未使用）
+ * @param rangeEnd 被点击的菜单项的结束位置（未使用）
+ * @return 返回true，表示菜单项点击事件处理成功
+ */
+ public boolean onCreateActionMode(ActionMode mode, Menu menu, int rangeStart, int rangeEnd) {
+ // 不需要支持多选范围，返回false
+ return false;
+ }
+
+ /**
+ * 处理菜单项点击事件
+ * @param mode ActionMode对象
+ * @param menu 菜单对象
+ * @return 返回true，表示菜单项点击事件处理成功
+ */
+ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+ // 不需要在ActionMode准备时修改菜单，返回false
+ return false;
+ }
+
+ /**
+ * 处理菜单项点击事件
+ * @param mode ActionMode对象
+ * @param item 被点击的菜单项
+ * @return 返回true，表示菜单项点击事件处理成功
+ */
+ public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+ // 由onMenuItemClick方法处理点击事件
+ return onMenuItemClick(item);
+ }
+
+ /**
+ * 结束ActionMode
+ */
+ public void onDestroyActionMode(ActionMode mode) {
+ mNotesListAdapter.setChoiceMode(false); // 取消列表适配器的选择模式
+ mNotesListView.setLongClickable(true); // 启用长按操作
+ mAddNewNote.setVisibility(View.VISIBLE); // 显示新建笔记按钮
+ }
+
+ /**
+ * 结束ActionMode
+ */
+ public void finishActionMode() {
+ mActionMode.finish(); // 结束ActionMode
+ }
+
+ /**
+ * 处理单个笔记项被选中或取消选中的事件
+ * @param mode ActionMode对象
+ * @param position 笔记项的位置
+ * @param id 笔记项的ID
+ * @param checked 是否被选中
+ */
+ public void onItemCheckedStateChanged(ActionMode mode, int position, long id, boolean checked) {
+ mNotesListAdapter.setCheckedItem(position, checked); // 设置笔记项的选中状态
+ updateMenu(); // 更新菜单
+ }
+
+ /**
+ * 处理菜单项点击事件
+ * @param item 被点击的菜单项
+ * @return 返回true，表示菜单项点击事件处理成功
+ */
+ public boolean onMenuItemClick(MenuItem item) {
+ if (mNotesListAdapter.getSelectedCount() == 0) { // 如果没有选中的笔记
+ Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
+ Toast.LENGTH_SHORT).show(); // 显示提示信息
+ return true;
+ }
+
+ switch (item.getItemId()) {
+ case R.id.delete:
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+ builder.setTitle(getString(R.string.alert_title_delete));
+ builder.setIcon(android.R.drawable.ic_dialog_alert);
+ builder.setMessage(getString(R.string.alert_message_delete_notes,
+ mNotesListAdapter.getSelectedCount()));
+ builder.setPositiveButton(android.R.string.ok,
+ new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+ batchDelete(); // 批量删除笔记
+ }
+ });
+ builder.setNegativeButton(android.R.string.cancel, null);
+ builder.show(); // 显示确认对话框
+ break;
+ case R.id.move:
+ startQueryDestinationFolders(); // 查询目标文件夹
+ break;
+ default:
+ return false;
+ }
+ return true;
+ }
+ }
+
+ /**
+ * 新建笔记按钮的触摸监听器，用于处理触摸事件
+ */
+ private class NewNoteOnTouchListener implements OnTouchListener {
+ public boolean onTouch(View v, MotionEvent event) {
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_DOWN: {
+ Display display = getWindowManager().getDefaultDisplay();
+ int screenHeight = display.getHeight();
+ int newNoteViewHeight = mAddNewNote.getHeight();
+ int start = screenHeight - newNoteViewHeight;
+ /**
+ * 减去标题栏的高度，以便准确计算触摸位置
+ */
+ if (mState == ListEditState.SUB_FOLDER) {
+ eventY -= mTitleBar.getHeight();
+ start -= mTitleBar.getHeight();
+ }
+ /**
+ * 处理按钮透明部分的触摸事件，将触摸事件分发给底层的ListView
+ * 透明部分的公式：y=-0.12x+94（单位：像素），基于按钮左边缘的坐标系
+ * 94表示透明部分的最大高度
+ * 注意：如果按钮背景发生变化，此公式需要相应调整
+ */
+ if (event.getY() < (event.getX() * (-0.12) + 94)) {
+ // 获取ListView最后一个可见项
+ View view = mNotesListView.getChildAt(mNotesListView.getChildCount() - 1
+ - mNotesListView.getFooterViewsCount());
+ if (view != null && view.getBottom() > start
+ && (view.getTop() < (start + 94))) {
+ mOriginY = (int) event.getY();
+ mDispatchY = eventY;
+ event.setLocation(event.getX(), mDispatchY); // 设置新的触摸位置
+ mDispatch = true;
+ return mNotesListView.dispatchTouchEvent(event); // 分发触摸事件
+ }
+ }
+ break;
+ }
+ case MotionEvent.ACTION_MOVE: {
+ if (mDispatch) {
+ mDispatchY += (int) event.getY() - mOriginY; // 更新触摸位置
+ event.setLocation(event.getX(), mDispatchY); // 设置新的触摸位置
+ return mNotesListView.dispatchTouchEvent(event); // 分发触摸事件
+ }
+ break;
+ }
+ default: {
+ if (mDispatch) {
+ event.setLocation(event.getX(), mDispatchY); // 设置新的触摸位置
+ mDispatch = false;
+ return mNotesListView.dispatchTouchEvent(event); // 分发触摸事件
+ }
+ break;
+ }
+ }
+ return false;
+ }
+ };
+
+ /**
+ * 异步查询笔记列表
+ */
+ private void startAsyncNotesListQuery() {
+ String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
+ : NORMAL_SELECTION;
+ mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
+ Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[] {
+ String.valueOf(mCurrentFolderId)
+ }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC"); // 执行异步查询
+ }
+
+ /**
+ * BackgroundQueryHandler，用于处理异步查询结果
+ */
+ private final class BackgroundQueryHandler extends AsyncQueryHandler {
+ public BackgroundQueryHandler(ContentResolver contentResolver) {
+ super(contentResolver);
+ }
+
+ /**
+ * 处理查询完成后的结果
+ * @param token 查询token
+ * @param cookie 传递给查询的额外信息（未使用）
+ * @param cursor 查询结果的游标
+ */
+ @Override
+ protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+ switch (token) {
+ case FOLDER_NOTE_LIST_QUERY_TOKEN:
+ mNotesListAdapter.changeCursor(cursor); // 更新笔记列表适配器的游标
+ break;
+ case FOLDER_LIST_QUERY_TOKEN:
+ if (cursor != null && cursor.getCount() > 0) {
+ showFolderListMenu(cursor); // 显示文件夹列表菜单
+ } else {
+ Log.e(TAG, "Query folder failed");
+ }
+ break;
+ default:
+ return;
+ }
+ }
+ }
+
+ /**
+ * 显示文件夹列表菜单
+ * @param cursor 查询结果的游标
+ */
+ private void showFolderListMenu(Cursor cursor) {
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+ builder.setTitle(R.string.menu_title_select_folder);
+ final FoldersListAdapter adapter = new FoldersListAdapter(this, cursor);
+ builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
+ // 处理菜单项点击事件
+ public void onClick(DialogInterface dialog, int which) {
+ DataUtils.batchMoveToFolder(mContentResolver,
+ mNotesListAdapter.getSelectedItemIds(), adapter.getItemId(which));
+ Toast.makeText(
+ NotesListActivity.this,
+ getString(R.string.format_move_notes_to_folder,
+ mNotesListAdapter.getSelectedCount(),
+ adapter.getFolderName(NotesListActivity.this, which)),
+ Toast.LENGTH_SHORT).show(); // 显示提示信息
+ mModeCallBack.finishActionMode(); // 结束ActionMode
+ }
+ });
+ builder.show(); // 显示对话框
+ }
+
+ /**
+ * 创建新笔记
+ */
+ private void createNewNote() {
+ Intent intent = new Intent(this, NoteEditActivity.class);
+ intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+ intent.putExtra(Notes.INTENT_EXTRA_FOLDER_ID, mCurrentFolderId);
+ this.startActivityForResult(intent, REQUEST_CODE_NEW_NODE); // 启动NoteEditActivity并等待返回结果
+ }
+
+ /**
+ * 批量删除笔记
+ */
+ private void batchDelete() {
+ new AsyncTask>() {
+ protected HashSet doInBackground(Void... unused) {
+ HashSet widgets = mNotesListAdapter.getSelectedWidget(); // 获取选中的笔记关联的Widget属性
+ if (!isSyncMode()) {
+ // 如果未同步，则直接删除笔记
+ if (DataUtils.batchDeleteNotes(mContentResolver, mNotesListAdapter
+ .getSelectedItemIds())) {
+ } else {
+ Log.e(TAG, "Delete notes error, should not happens");
+ }
+ } else {
+ // 如果同步模式，则将删除的笔记移动到废纸篓文件夹
+ if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
+ .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
+ Log.e(TAG, "Move notes to trash folder error, should not happens");
+ }
+ }
+ return widgets;
+ }
+
+ @Override
+ protected void onPostExecute(HashSet widgets) {
+ if (widgets != null) {
+ for (AppWidgetAttribute widget : widgets) {
+ if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+ && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+ updateWidget(widget.widgetId, widget.widgetType); // 更新Widget
+ }
+ }
+ }
+ mModeCallBack.finishActionMode(); // 结束ActionMode
+ }
+ }.execute(); // 执行异步任务
+ }
+
+ /**
+ * 删除文件夹
+ * @param folderId 文件夹ID
+ */
+ private void deleteFolder(long folderId) {
+ if (folderId == Notes.ID_ROOT_FOLDER) {
+ Log.e(TAG, "Wrong folder id, should not happen " + folderId);
+ return;
+ }
+
+ HashSet ids = new HashSet();
+ ids.add(folderId);
+ HashSet widgets = DataUtils.getFolderNoteWidget(mContentResolver,
+ folderId); // 获取文件夹关联的Widget属性
+ if (!isSyncMode()) {
+ // 如果未同步，则直接删除文件夹及其下的笔记
+ DataUtils.batchDeleteNotes(mContentResolver, ids);
+ } else {
+ // 如果同步模式，则将删除的文件夹及其下的笔记移动到废纸篓文件夹
+ DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
+ }
+ if (widgets != null) {
+ for (AppWidgetAttribute widget : widgets) {
+ if (widget.widgetId != AppWidgetManager.INVALID_APPWIDGET_ID
+ && widget.widgetType != Notes.TYPE_WIDGET_INVALIDE) {
+ updateWidget(widget.widgetId, widget.widgetType); // 更新Widget
+ }
+ }
+ }
+ }
+
+ /**
+ * 打开笔记节点
+ * @param data 笔记数据
+ */
+ private void openNode(NoteItemData data) {
+ Intent intent = new Intent(this, NoteEditActivity.class);
+ intent.setAction(Intent.ACTION_VIEW);
+ intent.putExtra(Intent.EXTRA_UID, data.getId());
+ this.startActivityForResult(intent, REQUEST_CODE_OPEN_NODE); // 启动NoteEditActivity并等待返回结果
+ }
+
+ /**
+ * 打开文件夹
+ * @param data 文件夹数据
+ */
+ private void openFolder(NoteItemData data) {
+ mCurrentFolderId = data.getId(); // 更新当前文件夹ID
+ startAsyncNotesListQuery(); // 异步查询笔记列表
+ if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+ mState = ListEditState.CALL_RECORD_FOLDER; // 设置为通话记录文件夹状态
+ mAddNewNote.setVisibility(View.GONE); // 隐藏新建笔记按钮
+ } else {
+ mState = ListEditState.SUB_FOLDER; // 设置为子文件夹状态
+ }
+ if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+ mTitleBar.setText(R.string.call_record_folder_name); // 设置标题栏文本为通话记录文件夹名称
+ } else {
+ mTitleBar.setText(data.getSnippet()); // 设置标题栏文本为文件夹的摘要
+ }
+ mTitleBar.setVisibility(View.VISIBLE); // 显示标题栏
+ }
+
+ /**
+ * 处理View的点击事件
+ * @param v 被点击的View
+ */
+ public void onClick(View v) {
+ switch (v.getId()) {
+ case R.id.btn_new_note:
+ createNewNote(); // 创建新笔记
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ * 显示软键盘
+ */
+ private void showSoftInput() {
+ InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+ if (inputMethodManager != null) {
+ inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); // 显示软键盘
+ }
+ }
+
+ /**
+ * 隐藏软键盘
+ * @param view 触发隐藏软键盘的View
+ */
+ private void hideSoftInput(View view) {
+ InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+ inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0); // 隐藏软键盘
+ }
+
+ /**
+ * 显示创建或修改文件夹的对话框
+ * @param create 是否为创建文件夹
+ */
+ private void showCreateOrModifyFolderDialog(final boolean create) {
+ final AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
+ final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
+ showSoftInput(); // 显示软键盘
+ if (!create) {
+ if (mFocusNoteDataItem != null) {
+ etName.setText(mFocusNoteDataItem.getSnippet()); // 设置文件夹名称为当前选中的文件夹摘要
+ builder.setTitle(getString(R.string.menu_folder_change_name)); // 设置对话框标题为修改文件夹名称
+ } else {
+ Log.e(TAG, "The long click data item is null");
+ return;
+ }
+ } else {
+ etName.setText("");
+ builder.setTitle(this.getString(R.string.menu_create_folder)); // 设置对话框标题为创建文件夹
+ }
+
+ builder.setPositiveButton(android.R.string.ok, null);
+ builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ hideSoftInput(etName); // 隐藏软键盘
+ }
+ });
+
+ final Dialog dialog = builder.setView(view).show(); // 显示对话框
+ final Button positive = (Button)dialog.findViewById(android.R.id.button1);
+ positive.setOnClickListener(new OnClickListener() {
+ public void onClick(View v) {
+ hideSoftInput(etName); // 隐藏软键盘
+ String name = etName.getText().toString();
+ if (DataUtils.checkVisibleFolderName(mContentResolver, name)) { // 检查文件夹名称是否已存在
+ Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
+ Toast.LENGTH_LONG).show(); // 显示提示信息
+ etName.setSelection(0, etName.length()); // 选中文件夹名称文本
+ return;
+ }
+ if (!create) {
+ if (!TextUtils.isEmpty(name)) {
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.SNIPPET, name); // 更新文件夹摘要
+ values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹
+ values.put(NoteColumns.LOCAL_MODIFIED, 1); // 设置本地修改标志
+ mContentResolver.update(Notes.CONTENT_NOTE_URI, values, NoteColumns.ID
+ + "=?", new String[] {
+ String.valueOf(mFocusNoteDataItem.getId())
+ }); // 更新数据库中的文件夹信息
+ }
+ } else if (!TextUtils.isEmpty(name)) {
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.SNIPPET, name); // 设置文件夹摘要
+ values.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹
+ mContentResolver.insert(Notes.CONTENT_NOTE_URI, values); // 插入新的文件夹到数据库
+ }
+ dialog.dismiss(); // 关闭对话框
+ }
+ });
+
+ if (TextUtils.isEmpty(etName.getText())) {
+ positive.setEnabled(false); // 如果文件夹名称为空，则禁用确定按钮
+ }
+ /**
+ * 当文件夹名称改变时，更新确定按钮的启用状态
+ */
+ etName.addTextChangedListener(new TextWatcher() {
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ // 不需要处理文本改变前的事件
+ }
+
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ if (TextUtils.isEmpty(s)) {
+ positive.setEnabled(false); // 如果文件夹名称为空，则禁用确定按钮
+ } else {
+ positive.setEnabled(true); // 如果文件夹名称不为空，则启用确定按钮
+ }
+ }
+
+ public void afterTextChanged(Editable s) {
+ // 不需要处理文本改变后的事件
+ }
+ });
+ }
+
+ /**
+ * 处理返回键事件
+ */
+ @Override
+ public void onBackPressed() {
+ switch (mState) {
+ case SUB_FOLDER:
+ mCurrentFolderId = Notes.ID_ROOT_FOLDER; // 返回根文件夹
+ mState = ListEditState.NOTE_LIST; // 设置为笔记列表状态
+ startAsyncNotesListQuery(); // 异步查询笔记列表
+ mTitleBar.setVisibility(View.GONE); // 隐藏标题栏
+ break;
+ case CALL_RECORD_FOLDER:
+ mCurrentFolderId = Notes.ID_ROOT_FOLDER; // 返回根文件夹
+ mState = ListEditState.NOTE_LIST; // 设置为笔记列表状态
+ mAddNewNote.setVisibility(View.VISIBLE); // 显示新建笔记按钮
+ mTitleBar.setVisibility(View.GONE); // 隐藏标题栏
+ startAsyncNotesListQuery(); // 异步查询笔记列表
+ break;
+ case NOTE_LIST:
+ super.onBackPressed(); // 调用父类的返回键处理方法
+ break;
+ default:
+ break;
+ }
+ }
+
+ /**
+ * 更新Widget
+ * @param appWidgetId Widget的ID
+ * @param appWidgetType Widget的类型
+ */
+ private void updateWidget(int appWidgetId, int appWidgetType) {
+ Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+ if (appWidgetType == Notes.TYPE_WIDGET_2X) {
+ intent.setClass(this, NoteWidgetProvider_2x.class); // 设置Widget更新的广播接收器
+ } else if (appWidgetType == Notes.TYPE_WIDGET_4X) {
+ intent.setClass(this, NoteWidgetProvider_4x.class); // 设置Widget更新的广播接收器
+ } else {
+ Log.e(TAG, "Unspported widget type");
+ return;
+ }
+
+ intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
+ appWidgetId
+ });
+
+ sendBroadcast(intent); // 发送广播通知Widget更新内容
+ setResult(RESULT_OK, intent);
+ }
+
+ /**
+ * 创建文件夹的上下文菜单监听器
+ */
+ private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
+ public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
+ if (mFocusNoteDataItem != null) {
+ menu.setHeaderTitle(mFocusNoteDataItem.getSnippet()); // 设置上下文菜单标题为文件夹摘要
+ menu.add(0, MENU_FOLDER_VIEW, 0, R.string.menu_folder_view); // 添加查看文件夹选项
+ menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete); // 添加删除文件夹选项
+ menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name); // 添加修改文件夹名称选项
+ }
+ }
+ };
+
+ @Override
+ public void onContextMenuClosed(Menu menu) {
+ if (mNotesListView != null) {
+ mNotesListView.setOnCreateContextMenuListener(null); // 清除上下文菜单监听器
+ }
+ super.onContextMenuClosed(menu);
+ }
+
+ /**
+ * 处理上下文菜单项点击事件
+ * @param item 被点击的菜单项
+ * @return 返回true，表示事件处理成功
+ */
+ @Override
+ public boolean onContextItemSelected(MenuItem item) {
+ if (mFocusNoteDataItem == null) {
+ Log.e(TAG, "The long click data item is null");
+ return false;
+ }
+ switch (item.getItemId()) {
+ case MENU_FOLDER_VIEW:
+ openFolder(mFocusNoteDataItem); // 打开文件夹
+ break;
+ case MENU_FOLDER_DELETE:
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle(getString(R.string.alert_title_delete));
+ builder.setIcon(android.R.drawable.ic_dialog_alert);
+ builder.setMessage(getString(R.string.alert_message_delete_folder));
+ builder.setPositiveButton(android.R.string.ok,
+ new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ deleteFolder(mFocusNoteDataItem.getId()); // 删除文件夹
+ }
+ });
+ builder.setNegativeButton(android.R.string.cancel, null);
+ builder.show(); // 显示确认对话框
+ break;
+ case MENU_FOLDER_CHANGE_NAME:
+ showCreateOrModifyFolderDialog(false); // 显示修改文件夹名称对话框
+ break;
+ default:
+ break;
+ }
+
+ return true;
+ }
+
+ /**
+ * 准备选项菜单
+ * @param menu 菜单对象
+ * @return 返回true，表示菜单准备成功
+ */
+ @Override
+ public boolean onPrepareOptionsMenu(Menu menu) {
+ menu.clear(); // 清空菜单
+ if (mState == ListEditState.NOTE_LIST) {
+ getMenuInflater().inflate(R.menu.note_list, menu); // 设置笔记列表菜单
+ // 设置同步或取消同步菜单项标题
+ menu.findItem(R.id.menu_sync).setTitle(
+ GTaskSyncService.isSyncing() ? R.string.menu_sync_cancel : R.string.menu_sync);
+ } else if (mState == ListEditState.SUB_FOLDER) {
+ getMenuInflater().inflate(R.menu.sub_folder, menu); // 设置子文件夹菜单
+ } else if (mState == ListEditState.CALL_RECORD_FOLDER) {
+ getMenuInflater().inflate(R.menu.call_record_folder, menu); // 设置通话记录文件夹菜单
+ } else {
+ Log.e(TAG, "Wrong state:" + mState);
+ }
+ return true;
+ }
+
+ /**
+ * 处理选项菜单项点击事件
+ * @param item 被点击的菜单项
+ * @return 返回true，表示事件处理成功
+ */
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case R.id.menu_new_folder: {
+ showCreateOrModifyFolderDialog(true); // 显示创建文件夹对话框
+ break;
+ }
+ case R.id.menu_export_text: {
+ exportNoteToText(); // 导出笔记到文本文件
+ break;
+ }
+ case R.id.menu_sync: {
+ if (isSyncMode()) {
+ if (TextUtils.equals(item.getTitle(), getString(R.string.menu_sync))) {
+ GTaskSyncService.startSync(this); // 开始同步
+ } else {
+ GTaskSyncService.cancelSync(this); // 取消同步
+ }
+ } else {
+ startPreferenceActivity(); // 启动偏好设置Activity
+ }
+ break;
+ }
+ case R.id.menu_setting: {
+ startPreferenceActivity(); // 启动偏好设置Activity
+ break;
+ }
+ case R.id.menu_new_note: {
+ createNewNote(); // 创建新笔记
+ break;
+ }
+ case R.id.menu_search:
+ onSearchRequested(); // 处理搜索请求
+ break;
+ default:
+ break;
+ }
+ return true;
+ }
+
+ /**
+ * 处理搜索请求
+ * @return 返回true，表示搜索请求处理成功
+ */
+ @Override
+ public boolean onSearchRequested() {
+ startSearch(null, false, null /* appData */, false); // 启动搜索
+ return true;
+ }
+
+ /**
+ * 将笔记导出到文本文件
+ */
+ private void exportNoteToText() {
+ final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
+ new AsyncTask() {
+ @Override
+ protected Integer doInBackground(Void... unused) {
+ return backup.exportToText(); // 执行导出操作
+ }
+
+ @Override
+ protected void onPostExecute(Integer result) {
+ if (result == BackupUtils.STATE_SD_CARD_UNMOUONTED) {
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+ builder.setTitle(NotesListActivity.this
+ .getString(R.string.failed_sdcard_export)); // 设置对话框标题为导出失败
+ builder.setMessage(NotesListActivity.this
+ .getString(R.string.error_sdcard_unmounted)); // 设置对话框消息为SD卡未挂载
+ builder.setPositiveButton(android.R.string.ok, null);
+ builder.show(); // 显示对话框
+ } else if (result == BackupUtils.STATE_SUCCESS) {
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+ builder.setTitle(NotesListActivity.this
+ .getString(R.string.success_sdcard_export)); // 设置对话框标题为导出成功
+ builder.setMessage(NotesListActivity.this.getString(
+ R.string.format_exported_file_location, backup
+ .getExportedTextFileName(), backup.getExportedTextFileDir()));
+ builder.setPositiveButton(android.R.string.ok, null);
+ builder.show(); // 显示对话框
+ } else if (result == BackupUtils.STATE_SYSTEM_ERROR) {
+ AlertDialog.Builder builder = new AlertDialog.Builder(NotesListActivity.this);
+ builder.setTitle(NotesListActivity.this
+ .getString(R.string.failed_sdcard_export)); // 设置对话框标题为导出失败
+ builder.setMessage(NotesListActivity.this
+ .getString(R.string.error_sdcard_export)); // 设置对话框消息为系统错误
+ builder.setPositiveButton(android.R.string.ok, null);
+ builder.show(); // 显示对话框
+ }
+ }
+
+ }.execute(); // 执行异步任务
+ }
+
+ /**
+ * 判断是否处于同步模式
+ * @return 返回true，表示处于同步模式；否则返回false
+ */
+ private boolean isSyncMode() {
+ return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0; // 通过偏好设置判断是否设置了同步账户
+ }
+
+ /**
+ * 启动偏好设置Activity
+ */
+ private void startPreferenceActivity() {
+ Activity from = getParent() != null ? getParent() : this;
+ Intent intent = new Intent(from, NotesPreferenceActivity.class);
+ from.startActivityIfNeeded(intent, -1); // 启动偏好设置Activity
+ }
+
+ /**
+ * 笔记列表项点击监听器
+ */
+ private class OnListItemClickListener implements OnItemClickListener {
+ public void onItemClick(AdapterView parent, View view, int position, long id) {
+ if (view instanceof NotesListItem) {
+ NoteItemData item = ((NotesListItem) view).getItemData(); // 获取笔记项数据
+ if (mNotesListAdapter.isInChoiceMode()) {
+ if (item.getType() == Notes.TYPE_NOTE) {
+ position = position - mNotesListView.getHeaderViewsCount(); // 调整位置索引
+ mModeCallBack.onItemCheckedStateChanged(null, position, id,
+ !mNotesListAdapter.isSelectedItem(position)); // 处理笔记项选中或取消选中
+ }
+ return;
+ }
+
+ switch (mState) {
+ case NOTE_LIST:
+ if (item.getType() == Notes.TYPE_FOLDER
+ || item.getType() == Notes.TYPE_SYSTEM) {
+ openFolder(item); // 打开文件夹
+ } else if (item.getType() == Notes.TYPE_NOTE) {
+ openNode(item); // 打开笔记
+ } else {
+ Log.e(TAG, "Wrong note type in NOTE_LIST");
+ }
+ break;
+ case SUB_FOLDER:
+ case CALL_RECORD_FOLDER:
+ if (item.getType() == Notes.TYPE_NOTE) {
+ openNode(item); // 打开笔记
+ } else {
+ Log.e(TAG, "Wrong note type in SUB_FOLDER");
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * 查询目标文件夹
+ */
+ private void startQueryDestinationFolders() {
+ String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
+ selection = (mState == ListEditState.NOTE_LIST) ? selection:
+ "(" + selection + ") OR (" + NoteColumns.ID + "=" + Notes.ID_ROOT_FOLDER + ")";
+
+ mBackgroundQueryHandler.startQuery(FOLDER_LIST_QUERY_TOKEN,
+ null,
+ Notes.CONTENT_NOTE_URI,
+ FoldersListAdapter.PROJECTION,
+ selection,
+ new String[] {
+ String.valueOf(Notes.TYPE_FOLDER), // 文件夹类型
+ String.valueOf(Notes.ID_TRASH_FOLER), // 废纸篓文件夹ID
+ String.valueOf(mCurrentFolderId) // 当前文件夹ID
+ },
+ NoteColumns.MODIFIED_DATE + " DESC"); // 按修改日期降序排序
+ }
+
+ /**
+ * 处理笔记项长按事件
+ * @param parent 父视图
+ * @param view 被长按的视图
+ * @param position 被长按的笔记项的位置
+ * @param id 被长按的笔记项的ID
+ * @return 返回true，表示事件处理成功
+ */
+ public boolean onItemLongClick(AdapterView parent, View view, int position, long id) {
+ if (view instanceof NotesListItem) {
+ mFocusNoteDataItem = ((NotesListItem) view).getItemData(); // 获取笔记项数据
+ if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE && !mNotesListAdapter.isInChoiceMode()) {
+ if (mNotesListView.startActionMode(mModeCallBack) != null) { // 启动ActionMode
+ mModeCallBack.onItemCheckedStateChanged(null, position, id, true); // 选中笔记项
+ mNotesListView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS); // 提供长按反馈
+ } else {
+ Log.e(TAG, "startActionMode fails");
+ }
+ } else if (mFocusNoteDataItem.getType() == Notes.TYPE_FOLDER) {
+ mNotesListView.setOnCreateContextMenuListener(mFolderOnCreateContextMenuListener); // 设置上下文菜单监听器
+ }
+ }
+ return false;
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java b/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
new file mode 100644
index 0000000..66148aa
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
@@ -0,0 +1,193 @@
+/*
+ * 版权 (c) 2010-2011, MiCode开源社区 (www.micode.net)
+ *
+ * 根据Apache许可证2.0版（“许可证”）授权；
+ * 除非适用法律要求或书面同意，软件按“现状”基础提供，
+ * 不附带任何明示或暗示的保证或条件。
+ * 有关许可证下的权限和限制，请参阅许可证。
+ */
+
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CursorAdapter;
+
+import net.micode.notes.data.Notes;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+
+// 自定义的CursorAdapter，用于显示笔记列表
+public class NotesListAdapter extends CursorAdapter {
+ private static final String TAG = "NotesListAdapter";
+ private Context mContext; // 上下文环境
+ private HashMap mSelectedIndex; // 记录选中的笔记位置
+ private int mNotesCount; // 笔记总数
+ private boolean mChoiceMode; // 是否处于多选模式
+
+ // 用于存储小部件属性的内部类
+ public static class AppWidgetAttribute {
+ public int widgetId; // 小部件ID
+ public int widgetType; // 小部件类型
+ };
+
+ // 构造函数，初始化上下文和选择索引
+ public NotesListAdapter(Context context) {
+ super(context, null); // 调用父类构造函数，不立即绑定任何游标
+ mSelectedIndex = new HashMap(); // 初始化选择索引
+ mContext = context; // 初始化上下文
+ mNotesCount = 0; // 初始化笔记数量为0
+ }
+
+ // 创建新的视图项
+ @Override
+ public View newView(Context context, Cursor cursor, ViewGroup parent) {
+ return new NotesListItem(context); // 创建一个新的NotesListItem视图
+ }
+
+ // 绑定数据到视图项
+ @Override
+ public void bindView(View view, Context context, Cursor cursor) {
+ if (view instanceof NotesListItem) { // 检查视图是否为NotesListItem类型
+ NoteItemData itemData = new NoteItemData(context, cursor); // 创建NoteItemData对象，用于封装笔记数据
+ ((NotesListItem) view).bind(context, itemData, mChoiceMode, // 调用NotesListItem的bind方法，绑定数据
+ isSelectedItem(cursor.getPosition())); // 传递当前项是否被选中的信息
+ }
+ }
+
+ // 设置指定位置的项是否被选中，并通知数据集发生变化
+ public void setCheckedItem(final int position, final boolean checked) {
+ mSelectedIndex.put(position, checked); // 更新选中状态
+ notifyDataSetChanged(); // 通知数据集发生变化，刷新UI
+ }
+
+ // 检查当前是否处于多选模式
+ public boolean isInChoiceMode() {
+ return mChoiceMode; // 返回当前的多选模式状态
+ }
+
+ // 设置多选模式，清空选择索引
+ public void setChoiceMode(boolean mode) {
+ mSelectedIndex.clear(); // 清空选择索引
+ mChoiceMode = mode; // 更新多选模式状态
+ }
+
+ // 全选或全不选所有笔记
+ public void selectAll(boolean checked) {
+ Cursor cursor = getCursor(); // 获取当前绑定的游标
+ for (int i = 0; i < getCount(); i++) { // 遍历所有笔记
+ if (cursor.moveToPosition(i)) { // 移动到指定位置
+ if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) { // 检查是否为笔记类型
+ setCheckedItem(i, checked); // 设置选中状态
+ }
+ }
+ }
+ }
+
+ // 获取所有选中的笔记ID集合
+ public HashSet getSelectedItemIds() {
+ HashSet itemSet = new HashSet(); // 初始化选中笔记ID集合
+ for (Integer position : mSelectedIndex.keySet()) { // 遍历所有选中的位置
+ if (mSelectedIndex.get(position) == true) { // 检查位置是否被选中
+ Long id = getItemId(position); // 获取笔记ID
+ if (id == Notes.ID_ROOT_FOLDER) { // 检查是否为根文件夹ID（错误情况）
+ Log.d(TAG, "Wrong item id, should not happen"); // 记录日志
+ } else {
+ itemSet.add(id); // 将笔记ID添加到集合
+ }
+ }
+ }
+ return itemSet; // 返回选中笔记ID集合
+ }
+
+ // 获取所有选中的小部件属性集合
+ public HashSet getSelectedWidget() {
+ HashSet itemSet = new HashSet(); // 初始化选中小部件属性集合
+ for (Integer position : mSelectedIndex.keySet()) { // 遍历所有选中的位置
+ if (mSelectedIndex.get(position) == true) { // 检查位置是否被选中
+ Cursor c = (Cursor) getItem(position); // 获取对应位置的游标
+ if (c != null) { // 检查游标是否有效
+ AppWidgetAttribute widget = new AppWidgetAttribute(); // 创建一个新的小部件属性对象
+ NoteItemData item = new NoteItemData(mContext, c); // 创建NoteItemData对象，用于封装笔记数据
+ widget.widgetId = item.getWidgetId(); // 设置小部件ID
+ widget.widgetType = item.getWidgetType(); // 设置小部件类型
+ itemSet.add(widget); // 将小部件属性对象添加到集合
+ /**
+ * Don't close cursor here, only the adapter could close it
+ * 不要在这里关闭游标，只有适配器可以关闭游标
+ */
+ } else {
+ Log.e(TAG, "Invalid cursor"); // 记录无效游标日志
+ return null; // 返回null
+ }
+ }
+ }
+ return itemSet; // 返回选中小部件属性集合
+ }
+
+ // 获取选中的笔记数量
+ public int getSelectedCount() {
+ Collection values = mSelectedIndex.values(); // 获取所有选中状态值
+ if (null == values) {
+ return 0; // 如果选中状态值为空，返回0
+ }
+ Iterator iter = values.iterator(); // 创建迭代器
+ int count = 0; // 初始化计数器
+ while (iter.hasNext()) {
+ if (true == iter.next()) { // 检查是否为选中状态
+ count++; // 计数器加一
+ }
+ }
+ return count; // 返回选中的笔记数量
+ }
+
+ // 检查是否所有笔记都被选中
+ public boolean isAllSelected() {
+ int checkedCount = getSelectedCount(); // 获取选中的笔记数量
+ return (checkedCount != 0 && checkedCount == mNotesCount); // 检查选中的笔记数量是否等于笔记总数
+ }
+
+ // 检查指定位置的项是否被选中
+ public boolean isSelectedItem(final int position) {
+ if (null == mSelectedIndex.get(position)) { // 检查指定位置是否被选中
+ return false; // 如果没有被选中，返回false
+ }
+ return mSelectedIndex.get(position); // 返回选中状态
+ }
+
+ // 当数据内容发生变化时，更新笔记数量
+ @Override
+ protected void onContentChanged() {
+ super.onContentChanged(); // 调用父类方法
+ calcNotesCount(); // 计算笔记数量
+ }
+
+ // 更改Cursor时，更新笔记数量
+ @Override
+ public void changeCursor(Cursor cursor) {
+ super.changeCursor(cursor); // 调用父类方法
+ calcNotesCount(); // 计算笔记数量
+ }
+
+ // 计算笔记数量
+ private void calcNotesCount() {
+ mNotesCount = 0; // 初始化笔记数量为0
+ for (int i = 0; i < getCount(); i++) { // 遍历所有笔记
+ Cursor c = (Cursor) getItem(i); // 获取对应位置的游标
+ if (c != null) { // 检查游标是否有效
+ if (NoteItemData.getNoteType(c) == Notes.TYPE_NOTE) { // 检查是否为笔记类型
+ mNotesCount++; // 计数器加一
+ }
+ } else {
+ Log.e(TAG, "Invalid cursor"); // 记录无效游标日志
+ return; // 返回
+ }
+ }
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java b/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
new file mode 100644
index 0000000..09f0ebd
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
@@ -0,0 +1,148 @@
+/*
+ * 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.ui;
+
+import android.content.Context;
+import android.text.format.DateUtils;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.DataUtils;
+import net.micode.notes.tool.ResourceParser.NoteItemBgResources;
+
+// NotesListItem 类继承自 LinearLayout，用于表示笔记列表中的一个项
+public class NotesListItem extends LinearLayout {
+ private ImageView mAlert; // 用于显示笔记的提醒图标
+ private TextView mTitle; // 用于显示笔记的标题
+ private TextView mTime; // 用于显示笔记的修改时间
+ private TextView mCallName; // 用于显示与笔记相关的联系人姓名
+ private NoteItemData mItemData; // 存储当前笔记项的数据
+ private CheckBox mCheckBox; // 用于选择笔记项的复选框
+
+ // 构造函数，初始化 NotesListItem 的视图组件
+ public NotesListItem(Context context) {
+ super(context);
+ // 从资源文件中加载布局文件 R.layout.note_item 到当前 NotesListItem 中
+ inflate(context, R.layout.note_item, this);
+ // 查找布局文件中的 ImageView 组件，并赋值给 mAlert
+ mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
+ // 查找布局文件中的 TextView 组件，并赋值给 mTitle
+ mTitle = (TextView) findViewById(R.id.tv_title);
+ // 查找布局文件中的 TextView 组件，并赋值给 mTime
+ mTime = (TextView) findViewById(R.id.tv_time);
+ // 查找布局文件中的 TextView 组件，并赋值给 mCallName
+ mCallName = (TextView) findViewById(R.id.tv_name);
+ // 查找布局文件中的 CheckBox 组件，并赋值给 mCheckBox
+ mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
+ }
+
+ // 绑定数据到 NotesListItem 的视图组件，并设置选择模式和选中状态
+ public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
+ // 如果处于选择模式并且笔记项类型为普通笔记，则显示复选框
+ if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
+ mCheckBox.setVisibility(View.VISIBLE);
+ mCheckBox.setChecked(checked); // 设置复选框的选中状态
+ } else {
+ mCheckBox.setVisibility(View.GONE); // 否则隐藏复选框
+ }
+
+ mItemData = data; // 存储当前绑定的数据
+ // 如果当前笔记项的 ID 是通话记录文件夹的 ID
+ if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
+ mCallName.setVisibility(View.GONE); // 隐藏联系人姓名 TextView
+ mAlert.setVisibility(View.VISIBLE); // 显示提醒图标 ImageView
+ mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); // 设置标题 TextView 的文本样式
+ // 设置标题 TextView 的文本内容为通话记录文件夹名称及其中包含的笔记数量
+ mTitle.setText(context.getString(R.string.call_record_folder_name)
+ + context.getString(R.string.format_folder_files_count, data.getNotesCount()));
+ mAlert.setImageResource(R.drawable.call_record); // 设置提醒图标 ImageView 的图片资源为通话记录图标
+ }
+ // 如果当前笔记项的父目录 ID 是通话记录文件夹的 ID
+ else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
+ mCallName.setVisibility(View.VISIBLE); // 显示联系人姓名 TextView
+ mCallName.setText(data.getCallName()); // 设置联系人姓名 TextView 的文本内容
+ mTitle.setTextAppearance(context, R.style.TextAppearanceSecondaryItem); // 设置标题 TextView 的文本样式
+ // 设置标题 TextView 的文本内容为笔记内容的摘要
+ mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+ // 如果笔记项有提醒，则显示提醒图标 ImageView
+ if (data.hasAlert()) {
+ mAlert.setImageResource(R.drawable.clock); // 设置提醒图标 ImageView 的图片资源为时钟图标
+ mAlert.setVisibility(View.VISIBLE);
+ } else {
+ mAlert.setVisibility(View.GONE); // 否则隐藏提醒图标 ImageView
+ }
+ }
+ // 如果当前笔记项既不是通话记录文件夹也不是其子项
+ else {
+ mCallName.setVisibility(View.GONE); // 隐藏联系人姓名 TextView
+ mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem); // 设置标题 TextView 的文本样式
+
+ // 如果笔记项类型为文件夹
+ if (data.getType() == Notes.TYPE_FOLDER) {
+ mTitle.setText(data.getSnippet() // 设置标题 TextView 的文本内容为文件夹名称
+ + context.getString(R.string.format_folder_files_count,
+ data.getNotesCount())); // 并追加其中包含的笔记数量
+ mAlert.setVisibility(View.GONE); // 隐藏提醒图标 ImageView
+ } else {
+ // 设置标题 TextView 的文本内容为笔记内容的摘要
+ mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+ // 如果笔记项有提醒，则显示提醒图标 ImageView
+ if (data.hasAlert()) {
+ mAlert.setImageResource(R.drawable.clock); // 设置提醒图标 ImageView 的图片资源为时钟图标
+ mAlert.setVisibility(View.VISIBLE);
+ } else {
+ mAlert.setVisibility(View.GONE); // 否则隐藏提醒图标 ImageView
+ }
+ }
+ }
+ // 设置时间 TextView 的文本内容为笔记的相对修改时间（如“3 小时前”）
+ mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
+
+ setBackground(data); // 根据笔记项的数据设置背景资源
+ }
+
+ // 根据数据设置 NotesListItem 的背景资源
+ private void setBackground(NoteItemData data) {
+ int id = data.getBgColorId(); // 获取笔记项的背景颜色 ID
+ // 如果笔记项类型为普通笔记
+ if (data.getType() == Notes.TYPE_NOTE) {
+ // 根据笔记项的位置状态设置不同的背景资源
+ if (data.isSingle() || data.isOneFollowingFolder()) {
+ setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
+ } else if (data.isLast()) {
+ setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
+ } else if (data.isFirst() || data.isMultiFollowingFolder()) {
+ setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
+ } else {
+ setBackgroundResource(NoteItemBgResources.getNoteBgMiddleRes(id));
+ }
+ } else {
+ // 如果笔记项类型为文件夹，则设置文件夹的背景资源
+ setBackgroundResource(NoteItemBgResources.getFolderBgRes());
+ }
+ }
+
+ // 获取绑定到此 NotesListItem 的数据
+ public NoteItemData getItemData() {
+ return mItemData; // 返回存储的当前笔记项数据
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java b/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
new file mode 100644
index 0000000..43b301b
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
@@ -0,0 +1,513 @@
+/*
+ * 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.ui;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.ActionBar;
+import android.app.AlertDialog;
+import android.content.BroadcastReceiver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceActivity;
+import android.preference.PreferenceCategory;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.gtask.remote.GTaskSyncService;
+
+// 设置界面活动类，继承自PreferenceActivity
+public class NotesPreferenceActivity extends PreferenceActivity {
+ // 定义偏好设置文件的名称
+ public static final String PREFERENCE_NAME = "notes_preferences";
+
+ // 定义偏好设置中存储同步账户名称的键
+ public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
+
+ // 定义偏好设置中存储上次同步时间的键
+ public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
+
+ // 定义偏好设置中背景颜色随机出现的键
+ public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
+
+ // 定义偏好设置中同步账户键（用于UI显示）
+ private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
+
+ // 定义过滤器键，用于添加账户设置
+ private static final String AUTHORITIES_FILTER_KEY = "authorities";
+
+ // 定义账户类别，在UI中用于显示账户相关的偏好设置
+ private PreferenceCategory mAccountCategory;
+
+ // 定义一个GTaskReceiver实例，用于接收同步状态更新的广播
+ private GTaskReceiver mReceiver;
+
+ // 存储原始的Google账户列表
+ private Account[] mOriAccounts;
+
+ // 标记用户是否添加了新账户
+ private boolean mHasAddedAccount;
+
+ // 创建活动时初始化界面
+ @Override
+ protected void onCreate(Bundle icicle) {
+ super.onCreate(icicle);
+
+ // 设置ActionBar的返回按钮，以便用户可以通过点击应用图标返回上一级活动
+ getActionBar().setDisplayHomeAsUpEnabled(true);
+
+ // 从指定的XML资源文件加载偏好设置
+ addPreferencesFromResource(R.xml.preferences);
+ // 找到XML中定义的账户类别PreferenceCategory，并赋值给mAccountCategory
+ mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
+ // 创建GTaskReceiver实例，并注册广播接收器，用于接收同步服务的状态广播
+ mReceiver = new GTaskReceiver();
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
+ registerReceiver(mReceiver, filter);
+
+ // 初始化账户列表，目前为空，将在其他方法中进行填充
+ mOriAccounts = null;
+ // 创建并添加自定义的头部视图到设置界面，该视图通常用于显示额外的信息或操作
+ View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
+ getListView().addHeaderView(header, null, true);
+ }
+
+ // 恢复活动时刷新界面
+ @Override
+ protected void onResume() {
+ super.onResume();
+
+ // 如果用户添加了新账户，自动设置同步账户
+ if (mHasAddedAccount) {
+ Account[] accounts = getGoogleAccounts();
+ if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
+ for (Account accountNew : accounts) {
+ boolean found = false;
+ for (Account accountOld : mOriAccounts) {
+ if (TextUtils.equals(accountOld.name, accountNew.name)) {
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ setSyncAccount(accountNew.name);
+ break;
+ }
+ }
+ }
+ }
+
+ // 刷新用户界面，包括账户偏好设置和同步按钮
+ refreshUI();
+ }
+
+ // 销毁活动时注销广播接收器
+ @Override
+ protected void onDestroy() {
+ if (mReceiver != null) {
+ unregisterReceiver(mReceiver);
+ }
+ super.onDestroy();
+ }
+
+ // 加载账户偏好设置
+ private void loadAccountPreference() {
+ // 清空账户类别中的所有偏好设置项
+ mAccountCategory.removeAll();
+
+ // 创建一个新的Preference实例，用于显示账户偏好设置
+ Preference accountPref = new Preference(this);
+ // 获取当前设置的同步账户名称
+ final String defaultAccount = getSyncAccountName(this);
+ // 设置偏好设置项的标题
+ accountPref.setTitle(getString(R.string.preferences_account_title));
+ // 设置偏好设置项的摘要信息
+ accountPref.setSummary(getString(R.string.preferences_account_summary));
+
+ // 设置偏好设置项的点击监听器
+ accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+ @Override
+ public boolean onPreferenceClick(Preference preference) {
+ // 如果当前没有正在进行的同步操作
+ if (!GTaskSyncService.isSyncing()) {
+ // 如果同步账户名称为空，表示第一次设置账户
+ if (TextUtils.isEmpty(defaultAccount)) {
+ showSelectAccountAlertDialog();
+ } else {
+ // 如果账户已经设置，提示用户切换账户的风险
+ showChangeAccountConfirmAlertDialog();
+ }
+ } else {
+ // 如果正在同步，显示提示信息，告知用户无法在同步过程中更改账户
+ Toast.makeText(NotesPreferenceActivity.this,
+ R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
+ .show();
+ }
+ return true;
+ }
+ });
+
+ // 将账户偏好设置项添加到账户类别中
+ mAccountCategory.addPreference(accountPref);
+ }
+
+ // 加载同步按钮
+ private void loadSyncButton() {
+ // 找到布局文件中定义的同步按钮
+ Button syncButton = (Button) findViewById(R.id.preference_sync_button);
+ // 找到布局文件中定义的上次同步时间显示文本
+ TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+
+ // 根据同步服务的状态设置按钮的文本和点击事件
+ if (GTaskSyncService.isSyncing()) {
+ // 如果正在同步，设置按钮文本为取消同步，并添加点击事件以取消同步
+ syncButton.setText(getString(R.string.preferences_button_sync_cancel));
+ syncButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
+ }
+ });
+ } else {
+ // 如果没有同步，设置按钮文本为立即同步，并添加点击事件以开始同步
+ syncButton.setText(getString(R.string.preferences_button_sync_immediately));
+ syncButton.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ GTaskSyncService.startSync(NotesPreferenceActivity.this);
+ }
+ });
+ }
+
+ // 根据同步账户名称是否为空设置按钮是否可用
+ syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
+
+ // 根据同步服务的状态设置上次同步时间的显示
+ if (GTaskSyncService.isSyncing()) {
+ // 如果正在同步，显示同步进度信息
+ lastSyncTimeView.setText(GTaskSyncService.getProgressString());
+ lastSyncTimeView.setVisibility(View.VISIBLE);
+ } else {
+ // 如果没有同步，显示上次同步的时间，如果没有同步过则不显示
+ long lastSyncTime = getLastSyncTime(this);
+ if (lastSyncTime != 0) {
+ lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
+ DateFormat.format(getString(R.string.preferences_last_sync_time_format),
+ lastSyncTime)));
+ lastSyncTimeView.setVisibility(View.VISIBLE);
+ } else {
+ lastSyncTimeView.setVisibility(View.GONE);
+ }
+ }
+ }
+
+ // 刷新用户界面
+ private void refreshUI() {
+ // 加载账户偏好设置
+ loadAccountPreference();
+ // 加载同步按钮
+ loadSyncButton();
+ }
+
+ // 显示选择账户的对话框
+ private void showSelectAccountAlertDialog() {
+ // 创建一个AlertDialog.Builder实例
+ AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+ // 加载自定义的对话框标题布局
+ View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+ TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+ // 设置对话框标题文本
+ titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
+ TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+ // 设置对话框副标题文本
+ subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
+ // 设置自定义的对话框标题
+ dialogBuilder.setCustomTitle(titleView);
+
+ // 设置对话框的确定按钮为空，因为我们使用自定义视图来处理选择
+ dialogBuilder.setPositiveButton(null, null);
+
+ // 获取Google账户列表
+ Account[] accounts = getGoogleAccounts();
+ // 获取当前设置的同步账户名称
+ String defAccount = getSyncAccountName(this);
+
+ // 保存原始账户列表
+ mOriAccounts = accounts;
+ // 重置标记，表示用户尚未添加新账户
+ mHasAddedAccount = false;
+
+ if (accounts.length > 0) {
+ // 创建一个CharSequence数组来存储账户名称
+ CharSequence[] items = new CharSequence[accounts.length];
+ // 由于items是CharSequence数组，需要一个final引用以便在内部类中使用
+ final CharSequence[] itemMapping = items;
+ int checkedItem = -1;
+ int index = 0;
+
+ // 遍历账户列表，将账户名称存储到items数组中，并标记默认账户
+ for (Account account : accounts) {
+ if (TextUtils.equals(account.name, defAccount)) {
+ checkedItem = index;
+ }
+ items[index++] = account.name;
+ }
+
+ // 设置对话框为单选列表，包含所有的Google账户
+ dialogBuilder.setSingleChoiceItems(items, checkedItem,
+ new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ // 用户选择账户后，设置同步账户并刷新UI
+ setSyncAccount(itemMapping[which].toString());
+ dialog.dismiss();
+ refreshUI();
+ }
+ });
+ }
+
+ // 加载添加账户的文本视图布局
+ View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
+ // 将添加账户的文本视图添加到对话框中
+ dialogBuilder.setView(addAccountView);
+
+ // 显示对话框
+ final AlertDialog dialog = dialogBuilder.show();
+ // 设置添加账户文本视图的点击事件，启动系统的添加账户设置界面
+ addAccountView.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mHasAddedAccount = true;
+ Intent intent = new Intent("android.settings.ADD_ACCOUNT_SETTINGS");
+ intent.putExtra(AUTHORITIES_FILTER_KEY, new String[] {
+ "gmail-ls"
+ });
+ startActivityForResult(intent, -1);
+ dialog.dismiss();
+ }
+ });
+ }
+
+ // 显示更改账户确认对话框
+ private void showChangeAccountConfirmAlertDialog() {
+ // 创建一个AlertDialog.Builder实例
+ AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
+
+ // 加载自定义的对话框标题布局
+ View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
+ TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
+ // 设置对话框标题文本，包括当前同步账户名称
+ titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
+ getSyncAccountName(this)));
+ TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
+ // 设置对话框副标题文本，警告用户切换账户可能带来的风险
+ subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
+ // 设置自定义的对话框标题
+ dialogBuilder.setCustomTitle(titleView);
+
+ // 创建一个CharSequence数组来存储对话框中的菜单项
+ CharSequence[] menuItemArray = new CharSequence[] {
+ getString(R.string.preferences_menu_change_account),
+ getString(R.string.preferences_menu_remove_account),
+ getString(R.string.preferences_menu_cancel)
+ };
+
+ // 设置对话框的菜单项
+ dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ // 根据用户选择的菜单项执行相应的操作
+ if (which == 0) {
+ // 如果用户选择更改账户，显示选择账户对话框
+ showSelectAccountAlertDialog();
+ } else if (which == 1) {
+ // 如果用户选择移除账户，移除同步账户并刷新UI
+ removeSyncAccount();
+ refreshUI();
+ }
+ }
+ });
+
+ // 显示对话框
+ dialogBuilder.show();
+ }
+
+ // 获取Google账户列表
+ private Account[] getGoogleAccounts() {
+ // 获取AccountManager实例
+ AccountManager accountManager = AccountManager.get(this);
+ // 返回所有类型为"com.google"的账户
+ return accountManager.getAccountsByType("com.google");
+ }
+
+ // 设置同步账户
+ private void setSyncAccount(String account) {
+ // 如果当前设置的同步账户名称与新的账户名称不同
+ if (!getSyncAccountName(this).equals(account)) {
+ // 获取SharedPreferences实例
+ SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = settings.edit();
+
+ // 如果新的账户名称不为空，则将其存储到偏好设置中
+ if (account != null) {
+ editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
+ } else {
+ // 如果新的账户名称为空，则将其设置为空字符串
+ editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+ }
+ // 提交偏好设置更改
+ editor.commit();
+
+ // 清除上次同步时间
+ setLastSyncTime(this, 0);
+
+ // 清除本地Gtask相关信息
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ ContentValues values = new ContentValues();
+ // 将Gtask ID和SYNC ID设置为空和0
+ values.put(NoteColumns.GTASK_ID, "");
+ values.put(NoteColumns.SYNC_ID, 0);
+ // 更新本地Notes数据库中的相关字段
+ getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+ }
+ }).start();
+
+ // 显示成功设置账户的提示信息
+ Toast.makeText(NotesPreferenceActivity.this,
+ getString(R.string.preferences_toast_success_set_accout, account),
+ Toast.LENGTH_SHORT).show();
+ }
+ }
+
+ // 移除同步账户
+ private void removeSyncAccount() {
+ // 获取SharedPreferences实例
+ SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = settings.edit();
+
+ // 如果偏好设置中包含同步账户名称，则将其移除
+ if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
+ editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
+ }
+ // 如果偏好设置中包含上次同步时间，则将其移除
+ if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
+ editor.remove(PREFERENCE_LAST_SYNC_TIME);
+ }
+ // 提交偏好设置更改
+ editor.commit();
+
+ // 清除本地Gtask相关信息
+ new Thread(new Runnable() {
+ @Override
+ public void run() {
+ ContentValues values = new ContentValues();
+ // 将Gtask ID和SYNC ID设置为空和0
+ values.put(NoteColumns.GTASK_ID, "");
+ values.put(NoteColumns.SYNC_ID, 0);
+ // 更新本地Notes数据库中的相关字段
+ getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
+ }
+ }).start();
+ }
+
+ // 获取同步账户名称
+ public static String getSyncAccountName(Context context) {
+ // 获取SharedPreferences实例
+ SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+ Context.MODE_PRIVATE);
+ // 返回存储的同步账户名称，如果未设置则返回空字符串
+ return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
+ }
+
+ // 设置上次同步时间
+ public static void setLastSyncTime(Context context, long time) {
+ // 获取SharedPreferences实例
+ SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+ Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = settings.edit();
+
+ // 将上次同步时间存储到偏好设置中
+ editor.putLong(PREFERENCE_LAST_SYNC_TIME, time);
+ // 提交偏好设置更改
+ editor.commit();
+ }
+
+ // 获取上次同步时间
+ public static long getLastSyncTime(Context context) {
+ // 获取SharedPreferences实例
+ SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
+ Context.MODE_PRIVATE);
+ // 返回存储的上次同步时间，如果未设置则返回0
+ return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
+ }
+
+ // 广播接收器，用于接收同步状态更新
+ private class GTaskReceiver extends BroadcastReceiver {
+ // 接收到广播时执行的操作
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ // 刷新用户界面，包括账户偏好设置和同步按钮
+ refreshUI();
+
+ // 如果广播中包含同步正在进行的标志
+ if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
+ // 找到布局文件中定义的上次同步时间显示文本
+ TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
+ // 更新文本为同步进度信息
+ syncStatus.setText(intent
+ .getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));
+ }
+ }
+ }
+
+ // 选项菜单项点击事件处理
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case android.R.id.home:
+ // 如果用户点击了返回按钮，启动NotesListActivity并清除当前活动栈中的其他活动
+ Intent intent = new Intent(this, NotesListActivity.class);
+ intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+ startActivity(intent);
+ return true;
+ default:
+ // 对于其他选项，返回false表示不处理
+ return false;
+ }
+ }
+}
diff --git a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
new file mode 100644
index 0000000..549630d
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
@@ -0,0 +1,143 @@
+/*
+ * 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.widget;
+import android.app.PendingIntent;
+import android.appwidget.AppWidgetManager;
+import android.appwidget.AppWidgetProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.database.Cursor;
+import android.util.Log;
+import android.widget.RemoteViews;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+import net.micode.notes.tool.ResourceParser;
+import net.micode.notes.ui.NoteEditActivity;
+import net.micode.notes.ui.NotesListActivity;
+
+// 提供笔记小部件功能的抽象类，继承自AppWidgetProvider
+public abstract class NoteWidgetProvider extends AppWidgetProvider {
+ // 查询笔记时使用的投影列
+ public static final String [] PROJECTION = new String [] {
+ NoteColumns.ID,
+ NoteColumns.BG_COLOR_ID,
+ NoteColumns.SNIPPET
+ };
+
+ // 投影列对应的索引
+ public static final int COLUMN_ID = 0;
+ public static final int COLUMN_BG_COLOR_ID = 1;
+ public static final int COLUMN_SNIPPET = 2;
+
+ // 日志标签
+ private static final String TAG = "NoteWidgetProvider";
+
+ // 当小部件被删除时调用，更新数据库中的小部件ID为无效值
+ @Override
+ public void onDeleted(Context context, int[] appWidgetIds) {
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
+ for (int i = 0; i < appWidgetIds.length; i++) {
+ context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
+ values,
+ NoteColumns.WIDGET_ID + "=?",
+ new String[] { String.valueOf(appWidgetIds[i])});
+ }
+ }
+
+ // 根据小部件ID获取笔记信息
+ private Cursor getNoteWidgetInfo(Context context, int widgetId) {
+ return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
+ PROJECTION,
+ NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
+ new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
+ null);
+ }
+
+ // 更新小部件视图
+ protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+ update(context, appWidgetManager, appWidgetIds, false);
+ }
+
+ // 更新小部件视图，支持隐私模式
+ private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
+ boolean privacyMode) {
+ for (int i = 0; i < appWidgetIds.length; i++) {
+ if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
+ int bgId = ResourceParser.getDefaultBgId(context);
+ String snippet = "";
+ Intent intent = new Intent(context, NoteEditActivity.class);
+ intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
+ intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
+ intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
+
+ Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
+ if (c != null && c.moveToFirst()) {
+ if (c.getCount() > 1) {
+ Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
+ c.close();
+ return;
+ }
+ snippet = c.getString(COLUMN_SNIPPET);
+ bgId = c.getInt(COLUMN_BG_COLOR_ID);
+ intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
+ intent.setAction(Intent.ACTION_VIEW);
+ } else {
+ snippet = context.getResources().getString(R.string.widget_havenot_content);
+ intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
+ }
+
+ if (c != null) {
+ c.close();
+ }
+
+ RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
+ rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
+ intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
+ /**
+ * Generate the pending intent to start host for the widget
+ */
+ PendingIntent pendingIntent = null;
+ if (privacyMode) {
+ rv.setTextViewText(R.id.widget_text,
+ context.getString(R.string.widget_under_visit_mode));
+ pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], new Intent(
+ context, NotesListActivity.class), PendingIntent.FLAG_UPDATE_CURRENT);
+ } else {
+ rv.setTextViewText(R.id.widget_text, snippet);
+ pendingIntent = PendingIntent.getActivity(context, appWidgetIds[i], intent,
+ PendingIntent.FLAG_UPDATE_CURRENT);
+ }
+
+ rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
+ appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
+ }
+ }
+ }
+
+ // 获取背景资源ID的方法，由子类实现
+ protected abstract int getBgResourceId(int bgId);
+
+ // 获取布局ID的方法，由子类实现
+ protected abstract int getLayoutId();
+
+ // 获取小部件类型的ID，由子类实现
+ protected abstract int getWidgetType();
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
new file mode 100644
index 0000000..1adfcdb
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
@@ -0,0 +1,51 @@
+/*
+ * 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.widget;
+
+import android.appwidget.AppWidgetManager;
+import android.content.Context;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.ResourceParser;
+
+// 2x2 小部件提供者类，继承自 NoteWidgetProvider
+public class NoteWidgetProvider_2x extends NoteWidgetProvider {
+ // 更新小部件时调用的方法
+ @Override
+ public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+ super.update(context, appWidgetManager, appWidgetIds);
+ }
+
+ // 返回 2x2 小部件的布局 ID
+ @Override
+ protected int getLayoutId() {
+ return R.layout.widget_2x;
+ }
+
+ // 根据背景 ID 返回对应的 2x2 小部件背景资源 ID
+ @Override
+ protected int getBgResourceId(int bgId) {
+ return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
+ }
+
+ // 返回 2x2 小部件的类型 ID
+ @Override
+ protected int getWidgetType() {
+ return Notes.TYPE_WIDGET_2X;
+ }
+}
\ No newline at end of file
diff --git a/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
new file mode 100644
index 0000000..78b5cc7
--- /dev/null
+++ b/src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
@@ -0,0 +1,34 @@
+package net.micode.notes.widget;
+
+import android.appwidget.AppWidgetManager;
+import android.content.Context;
+
+import net.micode.notes.R;
+import net.micode.notes.data.Notes;
+import net.micode.notes.tool.ResourceParser;
+
+// 定义一个4x4小部件的提供者类，继承自NoteWidgetProvider
+public class NoteWidgetProvider_4x extends NoteWidgetProvider {
+ // 覆盖父类的onUpdate方法，用于更新小部件的视图
+ @Override
+ public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
+ super.update(context, appWidgetManager, appWidgetIds);
+ }
+
+ // 返回4x4小部件的布局资源ID
+ protected int getLayoutId() {
+ return R.layout.widget_4x;
+ }
+
+ // 根据背景ID返回4x4小部件的背景资源ID
+ @Override
+ protected int getBgResourceId(int bgId) {
+ return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
+ }
+
+ // 返回小部件的类型，这里是4x4类型
+ @Override
+ protected int getWidgetType() {
+ return Notes.TYPE_WIDGET_4X;
+ }
+}
\ No newline at end of file
diff --git a/src/README.md b/src/README.md
new file mode 100644
index 0000000..37f3467
--- /dev/null
+++ b/src/README.md
@@ -0,0 +1,69 @@
+
+# CodeReading-MiNote
+
+## 说明
+
+此项目为“开源软件阅读标注”小组作业，小组成员为程星桦、张晋菡、张鹏展、文渤乔
+
+阅读项目为[MiCode便签-小米便签的社区开源版](https://github.com/MiCode/Notes)
+
+具体环境部署和测试在本地进行，同时在“代码注释统计”中对每一名同志的注释情况做了简要记录
+
+
+## 协作规范
+
+### 协作流程
+
+每个参与者将版本库克隆到本地
+
+```
+https://bdgit.educoder.net/pqfx375oj/CodeReading-MiNote.git
+```
+
+切换到到develop分支
+
+```
+git checkout develop
+```
+
+在本地创建自己的分支
+
+```
+git checkout -b your_branch_name (e.g. git checkout -b zjh)
+```
+
+进行修改后，将修改提交到自己的分支
+
+```
+git add .
+git commit -m "your commit message"
+```
+
+提交修改前，拉取develop分支最新代码，解决可能存在的冲突
+
+```
+git pull origin develop
+```
+
+将自己的分支推送到远程仓库
+
+```
+git push origin your_branch_name
+```
+
+**提交pull request**，将个人分支合并到develop分支；由组长进行代码审查，合并代码，并将develop的稳定版本合并到master分支。
+
+### 代码阅读规范
+
+协作者可将代码阅读记录通过注释的方式添加到源代码中，并标注注释的添加者；
+
+各协作者在doc目录中创建一个命名“xxx_notes.md"的文件，进行自己的阅读记录。
+
+具体分工待定。
+
+
+## 参考资料（小组成员可另行补充）
+
+[源码以及阅读报告](https://gitee.com/mi-note-development-team/minote/tree/master/)
+
+[知识荟-过往讨论](https://www.learnerhub.net/#/spaces/146/search?text=%E5%B0%8F%E7%B1%B3%E4%BE%BF%E7%AD%BE&t=1729487479088&type=docs)：有许多往届关于小米便签的阅读讨论帖，有很强的参考价值
\ No newline at end of file
diff --git a/src/代码注释统计.txt b/src/代码注释统计.txt
new file mode 100644
index 0000000..b40d6c8
--- /dev/null
+++ b/src/代码注释统计.txt
@@ -0,0 +1,11 @@
+张晋菡：
+ui中后11段代码
+程星桦：
+ui中前3段代码
+张鹏展：
+gtask中exception和remote中共6段代码
+tool中4段代码
+
+文渤乔：
+data中4段代码
+gtask/中6段代码