();
}
+ //缓存命中，直接返回电话号码
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
+ //构造匹配串，提取数字核心部分
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
+
+ //cursor是数据库游标，初始位置是-1；query把SQL拼装好后交给系统联系人Provider
Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI,
new String [] { Phone.DISPLAY_NAME },
@@ -54,18 +86,19 @@ public class Contact {
new String[] { phoneNumber },
null);
+ //指针移到第一行，成功返回true
if (cursor != null && cursor.moveToFirst()) {
try {
String name = cursor.getString(0);
- sContactCache.put(phoneNumber, name);
+ sContactCache.put(phoneNumber, name); //将号码-姓名键值对放进内存缓存
return name;
- } catch (IndexOutOfBoundsException e) {
+ } catch (IndexOutOfBoundsException e) { //捕获异常，索引超出列范围的情况，返回错误日志
Log.e(TAG, " Cursor get string error " + e.toString());
return null;
- } finally {
+ } finally { //无论是否发生异常都必须释放cursor。
cursor.close();
}
- } else {
+ } else { //查询失败，输出日志信息
Log.d(TAG, "No contact matched with number:" + phoneNumber);
return null;
}
diff --git a/src/notes/data/Notes.java b/src/notes/data/Notes.java
index f240604..b871c3a 100644
--- a/src/notes/data/Notes.java
+++ b/src/notes/data/Notes.java
@@ -14,43 +14,73 @@
* limitations under the License.
*/
+/*
+*文件名：Notes.java
+* 修改人：蒙程
+* 修改时间：2025-12-06
+* 修改内容：增加代码注释，标注的代码行数共37行
+*/
package net.micode.notes.data;
import android.net.Uri;
+
+/**
+*Notes是便签数据库类
+
+* 定义了URI常量、便签/文件夹类型常量、Intent扩展字段名、数据库接口、两种与业务实体
+* 本类所有字段均用static final修饰，说明字段不会变，可以直接用
+
+* @author 蒙程
+* @since [起始版本]
+*/
public class Notes {
- public static final String AUTHORITY = "micode_notes";
- public static final String TAG = "Notes";
- public static final int TYPE_NOTE = 0;
- public static final int TYPE_FOLDER = 1;
- public static final int TYPE_SYSTEM = 2;
+
+ //一、ContentProvider权威域名
+ public static final String AUTHORITY = "micode_notes"; //拼接URI的前缀
+ public static final String TAG = "Notes"; //日志显示Notes
+
+ //二、便签/文件夹/系统文件夹 类型常量
+ public static final int TYPE_NOTE = 0; //普通文本便签类型常量为0
+ public static final int TYPE_FOLDER = 1; //文件夹类型常量为1
+ public static final int TYPE_SYSTEM = 2; //系统文件夹（如回收站）类型常量为2
/**
* Following IDs are system folders' identifiers
* {@link Notes#ID_ROOT_FOLDER } is default folder
- * {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
+ * {@link Notes#ID_TEMPORARY_FOLDER } is for notes belonging no folder
* {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
*/
- 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;
-
- 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";
- public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
- public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
- public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
- public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
+ //三、系统保留文件夹 ID
+ public static final int ID_ROOT_FOLDER = 0; //默认文件夹ID为0
+ public static final int ID_TEMPORARY_FOLDER = -1; //临时文件夹
+
+ public static final int ID_CALL_RECORD_FOLDER = -2; //通话记录文件夹ID，保存由通话备忘功能生成的便签
+ public static final int ID_TRASH_FOLDER = -3;
+
+ //四、Intent是什么?
+ 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"; //便签背景颜色
+ public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; //桌面便签小部件
+ public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type"; //桌面便签小部件类型
+ 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;
public static final int TYPE_WIDGET_4X = 1;
+ /**
+ *六、便签数据MIME汇总常量类
+ * Android 的 ContentResolver 在查询/插入/打开文件时会先问 URI 对应的 MIME：
+ */
public static class DataConstants {
- public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
- public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
+ public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; //文本便签MIME类型
+ public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE; //通话备忘MIME类型
}
+ //七、基础URI
/**
* Uri to query all notes and folders
*/
@@ -58,12 +88,18 @@ public class Notes {
/**
* Uri to query data
+ * 包括附件、文本、通话记录
*/
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
+ //八、数据库列名接口 —— Note 表
+ /**
+ * NoteColumns是便签数据库列名接口，只定义/声明一些方法、变量
+ * 此处声明了便签数据列名有ID,PARENT_ID,创建日期，修改日期，提醒日期等
+ */
public interface NoteColumns {
/**
- * The unique ID for a row
+ * The unique ID for a ro
* Type: INTEGER (long)
*/
public static final String ID = "_id";
@@ -159,20 +195,74 @@ public class Notes {
* Type : TEXT
*/
public static final String GTASK_ID = "gtask_id";
+
+ /**
+ * Alert location latitude
+ * Type: REAL
+ */
+ public static final String ALERT_LATITUDE = "alert_latitude";
+
+ /**
+ * Alert location longitude
+ * Type: REAL
+ */
+ public static final String ALERT_LONGITUDE = "alert_longitude";
+
+ /**
+ * Alert location radius
+ * Type: REAL
+ */
+ public static final String ALERT_RADIUS = "alert_radius";
+
+ /**
+ * Alert location name
+ * Type: TEXT
+ */
+ public static final String ALERT_LOCATION_NAME = "alert_location_name";
+
+ /**
+ * Note tag
+ * Type: TEXT
+ */
+ public static final String TAG = "tag";
/**
* The version code
* Type : INTEGER (long)
*/
public static final String VERSION = "version";
+
+ /**
+ * Lock status: 0-unlocked, 1-locked
+ * Type: INTEGER
+ */
+ public static final String LOCKED = "locked";
+
+ /**
+ * Lock type: 0-none, 1-password, 2-gesture
+ * Type: INTEGER
+ */
+ public static final String LOCK_TYPE = "lock_type";
+
+ /**
+ * Encrypted password for privacy lock
+ * Type: TEXT
+ */
+ public static final String ENCRYPTED_PASSWORD = "encrypted_password";
}
+
+ //九、数据库列名接口 —— Data 表
+
+ /**
+ * DataColumns是数据库列名接口
+ */
public interface DataColumns {
/**
* The unique ID for a row
* Type: INTEGER (long)
*/
- public static final String ID = "_id";
+ public static final String ID = "_id"; //主键是_id
/**
* The MIME type of the item represented by this row.
@@ -206,63 +296,70 @@ public class Notes {
/**
- * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * Generic data column, the meaning is {@link #MIME_TYPE} specific, used for
* integer data type
* Type: INTEGER
*/
public static final String DATA1 = "data1";
/**
- * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * Generic data column, the meaning is {@link #MIME_TYPE} specific, used for
* integer data type
* Type: INTEGER
*/
public static final String DATA2 = "data2";
/**
- * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * Generic data column, the meaning is {@link #MIME_TYPE} specific, used for
* TEXT data type
* Type: TEXT
*/
public static final String DATA3 = "data3";
/**
- * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * Generic data column, the meaning is {@link #MIME_TYPE} specific, used for
* TEXT data type
* Type: TEXT
*/
public static final String DATA4 = "data4";
/**
- * Generic data column, the meaning is {@link #MIMETYPE} specific, used for
+ * Generic data column, the meaning is {@link #MIME_TYPE} specific, used for
* TEXT data type
* Type: TEXT
*/
public static final String DATA5 = "data5";
}
+
+ //十、文本便签实体常量类
+ //文本便签TextNote类实现DataColumns接口中声明的方法
public static final class TextNote implements DataColumns {
/**
* Mode to indicate the text in check list mode or not
* Type: Integer 1:check list mode 0: normal mode
*/
- public static final String MODE = DATA1;
+ public static final String MODE = DATA1; //清单模式or普通文本模式？
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_TYPE = "vnd.android.cursor.dir/text_note"; //MIME类型为集合（多条）
- public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
+ public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note"; //MIME类型为单条
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
- public static final class CallNote implements DataColumns {
+ /**
+ *通话记录便签实体常量类
+ * 通话记录CallNote类也实现了DataColumns接口，体现了接口的多实现特性。
+ */
+ public static final class CallNote implements DataColumns {
/**
* Call date for this record
* Type: INTEGER (long)
*/
- public static final String CALL_DATE = DATA1;
+ public static final String CALL_DATE = DATA1; //DATA1是数据库中的真实列名，将通话的时间戳存入DATA1列中
/**
* Phone number for this record
diff --git a/src/notes/data/NotesDatabaseHelper.java b/src/notes/data/NotesDatabaseHelper.java
index ffe5d57..7b9fdf8 100644
--- a/src/notes/data/NotesDatabaseHelper.java
+++ b/src/notes/data/NotesDatabaseHelper.java
@@ -14,6 +14,11 @@
* limitations under the License.
*/
+/*
+*文件名：NotesDatabaseHelper.java
+ * 修改人：蒙程
+ * 修改时间：2025-12-13
+ */
package net.micode.notes.data;
import android.content.ContentValues;
@@ -26,12 +31,32 @@ import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
+/**
+*便签数据库辅助类
+
+ *负责以下功能：
+ *
+ * - 创建/升级 note 与 data 表
+ * - 建立触发器维护文件夹便签数量、便签摘要
+ * - 插入系统文件夹（根、临时、通话、回收站）
+ * - 提供单例实例
+ *
+
+ *
+ * @author 蒙程
+ * @version {@link #DB_VERSION} 4
+ * @since 2010-2011
+ */
public class NotesDatabaseHelper extends SQLiteOpenHelper {
+ /**
+ *一、数据库基础常量
+ */
private static final String DB_NAME = "note.db";
- private static final int DB_VERSION = 4;
+ private static final int DB_VERSION = 8;
+ /**表明常量接口*/
public interface TABLE {
public static final String NOTE = "note";
@@ -40,10 +65,19 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
private static final String TAG = "NotesDatabaseHelper";
+ //类加载时不创建NotesDatabaseHelper实例(mInstance),真正需要使用数据库时才调用getInstance初始化，节省应用启动时的内存和资源开销。
private static NotesDatabaseHelper mInstance;
+
+ //二、建表SQL，初始化note和data表，同时添加note_id_index索引列
+ /**
+ * 结合在Notes中定义的NoteColumns初始化
+ * 在Notes类里定义了NoteColumns，是便签数据库列名接口，ID、PARENT_ID等都是列名，表示把Notes数据库里声明的列名拿来用
+ * NOT NULL约束强制列不接受NULL值，DEFAULT 0 表示默认值为0，如果字段设定NOT NULL，没有输入值时，DEFAULT后跟的默认值来填充
+ * 这里的strftime是SQLite内置的时间、日期格式化函数，参数为输出格式（%s表示秒级Unix时间戳）、时间源（‘now'表示现在）
+ */
private static final String CREATE_NOTE_TABLE_SQL =
- "CREATE TABLE " + TABLE.NOTE + "(" +
+ "CREATE TABLE " + TABLE.NOTE + "(" + //开始建表，表名是TABLE.NOTE(note)
NoteColumns.ID + " INTEGER PRIMARY KEY," +
NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
@@ -60,9 +94,24 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
- NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
+ NoteColumns.TAG + " TEXT NOT NULL DEFAULT ''," +
+ NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0," +
+ NoteColumns.ALERT_LATITUDE + " REAL NOT NULL DEFAULT 0," +
+ NoteColumns.ALERT_LONGITUDE + " REAL NOT NULL DEFAULT 0," +
+ NoteColumns.ALERT_RADIUS + " REAL NOT NULL DEFAULT 0," +
+ NoteColumns.ALERT_LOCATION_NAME + " TEXT NOT NULL DEFAULT ''," +
+ NoteColumns.LOCKED + " INTEGER NOT NULL DEFAULT 0," +
+ NoteColumns.LOCK_TYPE + " INTEGER NOT NULL DEFAULT 0," +
+ NoteColumns.ENCRYPTED_PASSWORD + " TEXT NOT NULL DEFAULT ''" +
")";
+ /**
+ * 创建 Data 表 SQL，结合在Notes中定义的DataColumns初始化
+ *
+ * 外键：{@link DataColumns#NOTE_ID} 指向 note.id
+ * 通用列 data1~data5 含义由 {@link DataColumns#MIME_TYPE} 决定。
+ *
+ */
private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" +
DataColumns.ID + " INTEGER PRIMARY KEY," +
@@ -78,12 +127,22 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
")";
+ /**
+ *在data(NOTE_ID)这一列上创建名为note_id_index的索引（如果该索引不存在）
+ * 便于执行SELECT * FROM data WHERE 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 + ");";
+
+ //三、创建Note表触发器，在文件夹下便签数量变化时自动增减便签数量(notes_count)的值
/**
* Increase folder's note count when move note to the folder
+ * 创建触发器，名字叫increase_folder_count_on_update
+ * 在note表的parent_id列更新后
+ * 执行触发器体，更新Note表，设置notes_count=notes_count+1,在id=new.parent_id的地方
+ * 此处用于自动更新父文件夹下的便签数量
*/
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_update "+
@@ -132,8 +191,11 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" AND " + NoteColumns.NOTES_COUNT + ">0;" +
" END";
+ //四、Data 表触发器：自动同步便签摘要（snippet)
/**
* Update note's content when insert data with type {@link DataConstants#NOTE}
+ * 仅当新插入的DATA记录的mime_type字段值为note(笔记)类型时，触发器才会执行后续逻辑，若插入的是其他数据类型，比如图片，则不触发
+ * 执行触发器，将note表里的snippet列值更新为新纪录的content值，且仅更新note表里主键id=新纪录note_id的行
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " +
@@ -172,7 +234,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" END";
/**
- * Delete datas belong to note which has been deleted
+ * Delete data belong to note which has been deleted
+ * 当从note表删除一条笔记记录后，通过data表的note_id与note表的id关联
+ * 自动删除data表中所有与这条被删笔记关联的记录，笔记-笔记内容
*/
private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
"CREATE TRIGGER delete_data_on_delete " +
@@ -184,6 +248,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Delete notes belong to folder which has been deleted
+ * 当从note表里删除一条记录后，自动级联删除note表中所有parent_id等于被删记录id的子记录
*/
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " +
@@ -199,24 +264,37 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
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 +
+ " WHEN new." + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLDER +
" BEGIN" +
" UPDATE " + TABLE.NOTE +
- " SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
+ " SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLDER +
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
+ /**
+ * Android开发中自定义的数据库辅助类的构造方法，作用是初始化，指定要创建/管理的数据库名称、版本号等核心参数
+ * @param context 上下文，提供应用运行的环境信息，如访问资源、数据库文件路径、系统服务等。
+ */
public NotesDatabaseHelper(Context context) {
+
+ /** super是调用的父类(SQLiteOpenHelper)构造方法
+ * @param context 父类通过context确定数据库文件的存储位置
+ * @param DB_NAME 数据库文件名
+ * @param null 创建数据库查询的游标(cursor),传null表示默认
+ * @param DB_VERSION自定义常量，数据库版本号
+ */
super(context, DB_NAME, null, DB_VERSION);
}
+ //完成note表的全量初始化
public void createNoteTable(SQLiteDatabase db) {
- db.execSQL(CREATE_NOTE_TABLE_SQL);
- reCreateNoteTableTriggers(db);
- createSystemFolder(db);
- Log.d(TAG, "note table has been created");
+ db.execSQL(CREATE_NOTE_TABLE_SQL); //执行SQL语句创建note表
+ reCreateNoteTableTriggers(db); //重建该表关联的触发器
+ createSystemFolder(db); //初始化系统默认文件夹数据
+ Log.d(TAG, "note table has been created"); //打印日志，确认note表成功创建
}
+ //批量重建触发器，先删除旧的，再建立新的
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");
@@ -235,7 +313,9 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
+ //向note表插入四个系统默认文件夹：通话记录、根、临时、回收站。保证应用首次启动时有基础的文件夹结构。
private void createSystemFolder(SQLiteDatabase db) {
+ //ContentValues类用于存储键值对
ContentValues values = new ContentValues();
/**
@@ -243,12 +323,12 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
*/
values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
- db.insert(TABLE.NOTE, null, values);
+ db.insert(TABLE.NOTE, null, values); //向note表插入通话记录文件夹数据
/**
* root folder which is default folder
*/
- values.clear();
+ values.clear(); //清空原有的所有键值对，避免复用容器时残留上一个文件夹的字段值
values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
@@ -257,7 +337,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
* temporary folder which is used for moving note
*/
values.clear();
- values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
+ values.put(NoteColumns.ID, Notes.ID_TEMPORARY_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
@@ -265,7 +345,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
* create trash folder
*/
values.clear();
- values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+ values.put(NoteColumns.ID, Notes.ID_TRASH_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
@@ -287,17 +367,24 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
}
+ /**
+ * synchronized同步关键字，保证多线程安全，避免多个线程同时调用该方法时，进入if分支，创建多个实例
+ * getInstance函数用于获取唯一实例
+ */
+
static synchronized NotesDatabaseHelper getInstance(Context context) {
+ //首次调用该方法时，才创建实例；若已创建，则直接复用
if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context);
}
return mInstance;
}
+ //@override是Java中的一种注解，用于明确表示子类的方法是对父类方法的重写，实现多态性
@Override
public void onCreate(SQLiteDatabase db) {
- createNoteTable(db);
- createDataTable(db);
+ createNoteTable(db); //初始化笔记表
+ createDataTable(db); //初始化数据表
}
@Override
@@ -322,6 +409,26 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
oldVersion++;
}
+ if (oldVersion == 4) {
+ upgradeToV5(db);
+ oldVersion++;
+ }
+
+ if (oldVersion == 5) {
+ upgradeToV6(db);
+ oldVersion++;
+ }
+
+ if (oldVersion == 6) {
+ upgradeToV7(db);
+ oldVersion++;
+ }
+
+ if (oldVersion == 7) {
+ upgradeToV8(db);
+ oldVersion++;
+ }
+
if (reCreateTriggers) {
reCreateNoteTableTriggers(db);
reCreateDataTableTriggers(db);
@@ -329,17 +436,19 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
if (oldVersion != newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion
- + "fails");
+ + " fails");
}
}
+ //v1到v2的升级，删除旧的note data表，清空所有用户数据，重建新的
private void upgradeToV2(SQLiteDatabase db) {
- db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
- db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
+ db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE); //执行具体的SQL语句，删除旧的note表
+ db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA); //删除旧的data表
createNoteTable(db);
createDataTable(db);
}
+ //v2到v3的升级，清除无用触发器，新增gtask_id列，新增回收站文件夹
private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
@@ -350,13 +459,51 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
+ " TEXT NOT NULL DEFAULT ''");
// add a trash system folder
ContentValues values = new ContentValues();
- values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
+ values.put(NoteColumns.ID, Notes.ID_TRASH_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
+ //v3到v4的升级，为note表新增version列，且约束非空，默认为0
private void upgradeToV4(SQLiteDatabase db) {
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");
}
+
+ //v4到v5的升级，为note表新增tag列，且约束非空，默认为空字符串
+ private void upgradeToV5(SQLiteDatabase db) {
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.TAG
+ + " TEXT NOT NULL DEFAULT ''");
+ }
+
+ //v5到v6的升级，为note表新增位置提醒相关的列
+ private void upgradeToV6(SQLiteDatabase db) {
+ // 添加位置提醒相关的列
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.ALERT_LATITUDE
+ + " REAL NOT NULL DEFAULT 0");
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.ALERT_LONGITUDE
+ + " REAL NOT NULL DEFAULT 0");
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.ALERT_RADIUS
+ + " REAL NOT NULL DEFAULT 0");
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.ALERT_LOCATION_NAME
+ + " TEXT NOT NULL DEFAULT ''");
+ }
+
+ //v6到v7的升级
+ private void upgradeToV7(SQLiteDatabase db) {
+ // 移除重复添加的位置提醒列
+ // 这些列已经在 v6 版本中添加过了
+ }
+
+ //v7到v8的升级，为 note表新增隐私锁相关的列
+ private void upgradeToV8(SQLiteDatabase db) {
+ // 锁定状态：0-未锁定，1-已锁定
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.LOCKED + " INTEGER NOT NULL DEFAULT 0");
+
+ // 锁类型：0-无锁，1-密码锁，2-手势锁
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.LOCK_TYPE + " INTEGER NOT NULL DEFAULT 0");
+
+ // 加密后的密码
+ db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.ENCRYPTED_PASSWORD + " TEXT NOT NULL DEFAULT ''");
+ }
}
diff --git a/src/notes/data/NotesProvider.java b/src/notes/data/NotesProvider.java
index edb0a60..3ca2c60 100644
--- a/src/notes/data/NotesProvider.java
+++ b/src/notes/data/NotesProvider.java
@@ -14,6 +14,12 @@
* limitations under the License.
*/
+/*
+* 文件名：NotesProvider.java
+* 修改人：蒙程
+* 修改时间：2025-12-13
+* 修改内容：增加代码注释，标注的代码行数共68行
+ */
package net.micode.notes.data;
@@ -34,24 +40,58 @@ import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE;
+/**
+ * 便签内容提供类
+ *继承ContentProvider类，把本地SQLite数据库（note.db）暴露给整个安卓系统，支持以下功能：
+ *
+ * - CRUD(增删改查)
+ * - 搜索建议
+ * - URI路由于权限控制
+ *
+ * 支持URI示例：
+ *
+ * content://micode_notes/note 查询所有便签
+ * content://micode_notes/note/123 查询 ID=123 的便签
+ * content://micode_notes/data 查询所有数据行（附件、文本块、通话记录）
+ * content://micode_notes/search_suggest/xxx 系统搜索框建议接口
+ *
+ *
+ * @author 蒙程
+ * @since 2010-2011
+ */
public class NotesProvider extends ContentProvider {
+ //UriMatcher用于匹配uri,在ContentProvider中分辨出查询者想要查询哪个数据表
private static final UriMatcher mMatcher;
+ //mHelper是一个便签数据库辅助类单例
private NotesDatabaseHelper mHelper;
private static final String TAG = "NotesProvider";
- private static final int URI_NOTE = 1;
- private static final int URI_NOTE_ITEM = 2;
- private static final int URI_DATA = 3;
- private static final int URI_DATA_ITEM = 4;
+ private static final int URI_NOTE = 1; //匹配所有note的uri标识
+ private static final int URI_NOTE_ITEM = 2; //匹配单条note的uri标识
+ private static final int URI_DATA = 3; //匹配所有data行的uri标识，包括文本块、附件、通话记录
+ private static final int URI_DATA_ITEM = 4; //匹配单条data行的uri标识
- private static final int URI_SEARCH = 5;
- private static final int URI_SEARCH_SUGGEST = 6;
+ private static final int URI_SEARCH = 5; //执行实际搜索请求
+ private static final int URI_SEARCH_SUGGEST = 6; //提供搜索建议，实时联想输入关键词的匹配项
+ /**
+ * static块：在这个类第一次被Android系统加载到内存时，自动执行且只执行一次，
+ * 专门用来初始化 UriMatcher实例，并把所有需要匹配的uri规则（比如 note、data、search 相关）一次性注册好
+ * 为后续 query/insert/delete/update 方法匹配 URI 做好准备
+ * 使用static块效率更高，只需要初始化一次，省内存、省时间，而且可以确保在调用query等方法之前所有类型的uri都已经注册完毕
+ */
static {
+ //初始化，常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+
+ /**
+ * addURI表示添加需要匹配的uri，如果匹配就会返回匹配码（第三个参数）
+ * 完整uri格式为：content:///(/?)
+ * "note/#"中的'#'是通配符，仅匹配任意数字（这里的数字对应笔记id）
+ */
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
@@ -65,6 +105,15 @@ public class NotesProvider extends ContentProvider {
* x'0A' represents the '\n' character in sqlite. For title and content in the search result,
* we will trim '\n' and white space in order to show more information.
*/
+ /**
+ * 1.把note表id、snippet列名映射成SearchManager规定的搜索建议标准列名，比如把 NoteColumns.ID 改成 SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA；
+ * 2.格式化内容：SNIPPET中可能有换行符，首尾空格，所以用 REPLACE去掉x'0A'（十六进制，代表换行符 '\n'），避免建议文本显示错乱。
+ * TRIM去除替换后字符串的首尾空格。
+ * SUGGEST_COLUMN_TEXT_1系统规范列名，搜索建议项的主文本
+ *3.预置交互逻辑：点击建议能直接跳转到笔记
+ * R.drawable.search_result图标，Intent.ACTION_VIEW表示”查看笔记“这个动作，
+ * Notes.TextNote.CONTENT_TYPE 告诉系统要打开的是 “文本笔记” 类型的页面
+ */
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
@@ -73,30 +122,55 @@ public class NotesProvider extends ContentProvider {
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
+ /**
+ * 指定查询返回的列，复用上面定义的NOTES_SEARCH_PROJECTION
+ * '?'模糊匹配，占位符，关键词
+ * 筛选笔记父文件夹不等于回收站文件夹
+ * 筛选笔记类型为‘纯笔记’
+ */
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.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
+ //ContentProvider 返回数据库辅助类单例
@Override
public boolean onCreate() {
mHelper = NotesDatabaseHelper.getInstance(getContext());
return true;
}
+ /**
+ * 外部组件（如 Activity、SearchView）访问应用数据库数据的统一入口。
+ * 查询接口：支持note单条/批量、data单条/批量、搜索/搜索建议几种 URI，根据URI类型，拼URI，执行SQL语句，
+ * 返回符合要求的 Cursor 结果，并绑定数据变更通知，保证 UI 能感知数据变化。
+ * @param uri 请求 URI
+ * @param projection 要查询的列
+ * @param selection 查询条件
+ * @param selectionArgs selection中？的占位符参数
+ * @param sortOrder 排序规则
+ * @return cursor 返回游标
+ */
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
+ //初始化游标，默认空
Cursor c = null;
+
+ //db获取只读数据库连接（查询）
SQLiteDatabase db = mHelper.getReadableDatabase();
String id = null;
+
+ //mMatcher 在静态代码块里预注册了6种 URI 模式,通过match()返回的整数常量决定走哪条分支
switch (mMatcher.match(uri)) {
case URI_NOTE:
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
sortOrder);
break;
case URI_NOTE_ITEM:
+
+ //解析uri路径中的id，getPathSegments()返回[path,#]
id = uri.getPathSegments().get(1);
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
@@ -117,6 +191,7 @@ public class NotesProvider extends ContentProvider {
"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) {
@@ -126,36 +201,54 @@ public class NotesProvider extends ContentProvider {
searchString = uri.getQueryParameter("pattern");
}
+ //空关键词时，返回null，无需查询
if (TextUtils.isEmpty(searchString)) {
return null;
}
try {
+ //关键词格式化
searchString = String.format("%%%s%%", searchString);
+
+ //执行查询
c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
new String[] { searchString });
- } catch (IllegalStateException ex) {
+ } catch (IllegalStateException ex) { //捕获try中出现的异常，打印日志
Log.e(TAG, "got exception: " + ex.toString());
}
break;
+
+ //传了没注册过的uri，直接抛异常，防止误调用
default:
throw new IllegalArgumentException("Unknown URI " + uri);
}
+ //说明查询到结果，将查询返回的 Cursor 与 ContentResolver、当前 URI 绑定；
if (c != null) {
c.setNotificationUri(getContext().getContentResolver(), uri);
}
return c;
}
+ /**
+ * 是外部组件（如 Activity、Service）向应用数据库的note、data表插入数据的统一入口。
+ * 传入content URI 匹配目标表note\data，执行插入操作，校验关联字段合法性，出发数据变更通知，返回新uri
+ * @param uri 请求uri
+ * @param values 要插入的键值对，如note_id=100
+ * @return 新uri
+ *
+ * @author 蒙程
+ * @date 2025-12-13
+ */
@Override
public Uri insert(Uri uri, ContentValues values) {
- SQLiteDatabase db = mHelper.getWritableDatabase();
+ SQLiteDatabase db = mHelper.getWritableDatabase(); //获取可写数据库连接
long dataId = 0, noteId = 0, insertedId = 0;
switch (mMatcher.match(uri)) {
case URI_NOTE:
insertedId = noteId = db.insert(TABLE.NOTE, null, values);
break;
case URI_DATA:
+ //插入笔记的具体内容，因此先检查values中是否包含DATA_COLUMNS.NOTE_ID
if (values.containsKey(DataColumns.NOTE_ID)) {
noteId = values.getAsLong(DataColumns.NOTE_ID);
} else {
@@ -167,26 +260,39 @@ public class NotesProvider extends ContentProvider {
throw new IllegalArgumentException("Unknown URI " + uri);
}
// Notify the note uri
+ //通知所有监听该 URI 的 Cursor “数据已变更”
if (noteId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
}
// Notify the data uri
+ //通知该 URI 的数据变更,比如插入笔记内容后，刷新笔记详情页的内容展示。
if (dataId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
}
+ //返回插入的单条记录的标准uri,将插入记录的ID拼接在原始URI末尾
return ContentUris.withAppendedId(uri, insertedId);
}
+ /**
+ * 删除接口：支持按条件或单 ID 删除；系统文件夹（ID≤0）禁止删除
+ * @param uri 请求 URI
+ * @param selection 要查询的列
+ * @param selectionArgs 查询条件
+ * @return count 实际删除行数
+ *
+ * @author 蒙程
+ * @date 2025-12-13
+ */
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
int count = 0;
- String id = null;
+ String id = null; //存储单条记录的ID（从uri中解析）
SQLiteDatabase db = mHelper.getWritableDatabase();
- boolean deleteData = false;
+ boolean deleteData = false; // 标记是否删除的是DATA表数据
switch (mMatcher.match(uri)) {
case URI_NOTE:
selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
@@ -195,8 +301,8 @@ public class NotesProvider extends ContentProvider {
case URI_NOTE_ITEM:
id = uri.getPathSegments().get(1);
/**
- * ID that smaller than 0 is system folder which is not allowed to
- * trash
+ * ID that smaller than 0 is system folder which is not allowed to trash
+ * ID<0是系统文件夹，不能删，跳出分支
*/
long noteId = Long.valueOf(id);
if (noteId <= 0) {
@@ -213,12 +319,14 @@ public class NotesProvider extends ContentProvider {
id = uri.getPathSegments().get(1);
count = db.delete(TABLE.DATA,
DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
- deleteData = true;
+ deleteData = true; //标记删除的是data表数据
break;
default:
throw new IllegalArgumentException("Unknown URI " + uri);
}
if (count > 0) {
+
+ //如果删除的是data表内容，需要关联note表，删除内容后刷新笔记列表
if (deleteData) {
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
@@ -227,6 +335,17 @@ public class NotesProvider extends ContentProvider {
return count;
}
+ /**
+ * 更新接口：支持按条件或单 ID 更新；自动累加版本号（增量同步用）
+ * @param uri 请求 URI
+ * @param values 带查询的键值对
+ * @param selection 待查询列
+ * @param selectionArgs 查询条件
+ * @return 实际更新行数
+ *
+ * @author 蒙程
+ * @date 2025-12-13
+ */
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
int count = 0;
@@ -267,26 +386,44 @@ public class NotesProvider extends ContentProvider {
return count;
}
+ /**
+ * 将外部传入的SQL筛选条件拼接为AND格式（若selection非空）
+ * @param selection 用户传入的WHERE子句
+ * @return "AND(selection)" 或者空串
+ */
private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
+ /**
+ * 根据传入的id或自定义筛选条件，把note.version字段+1，用于增量同步
+ * @param id 单条便签ID
+ * @param selection 待查询列
+ * @param selectionArgs 查询条件
+ */
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
- StringBuilder sql = new StringBuilder(120);
+ StringBuilder sql = new StringBuilder(120); //120是初始SQL语句长度
sql.append("UPDATE ");
sql.append(TABLE.NOTE);
sql.append(" SET ");
sql.append(NoteColumns.VERSION);
sql.append("=" + NoteColumns.VERSION + "+1 ");
+ //有ID或者有selection时，才需要加WHERE子句
if (id > 0 || !TextUtils.isEmpty(selection)) {
sql.append(" WHERE ");
}
+ //场景1：仅有ID，精准更新单条笔记
if (id > 0) {
sql.append(NoteColumns.ID + "=" + String.valueOf(id));
}
+ //场景2：有自定义selection(批量/组合条件更新)
if (!TextUtils.isEmpty(selection)) {
+
+ //若已有ID，拼接为AND(selection);若没有ID，直接用selection
String selectString = id > 0 ? parseSelection(selection) : selection;
+
+ //替换selection中的?占位符为实际参数
for (String args : selectionArgs) {
selectString = selectString.replaceFirst("\\?", args);
}
@@ -296,6 +433,7 @@ public class NotesProvider extends ContentProvider {
mHelper.getWritableDatabase().execSQL(sql.toString());
}
+ //返回给定URI的MIME类型（暂未实现，返回null）
@Override
public String getType(Uri uri) {
// TODO Auto-generated method stub
diff --git a/src/notes/data/UserDatabaseHelper.java b/src/notes/data/UserDatabaseHelper.java
new file mode 100644
index 0000000..cb21d34
--- /dev/null
+++ b/src/notes/data/UserDatabaseHelper.java
@@ -0,0 +1,155 @@
+package net.micode.notes.data;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.util.Log;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * 用户数据库辅助类，用于管理用户账户信息
+ */
+public class UserDatabaseHelper extends SQLiteOpenHelper {
+ private static final String DB_NAME = "user.db";
+ private static final int DB_VERSION = 1;
+
+ private static final String TAG = "UserDatabaseHelper";
+
+ public interface TABLE {
+ public static final String USER = "user";
+ }
+
+ /**
+ * 用户表列名接口
+ */
+ public interface UserColumns {
+ public static final String ID = "_id";
+ public static final String USERNAME = "username";
+ public static final String PASSWORD = "password";
+ public static final String CREATED_DATE = "created_date";
+ }
+
+ private static final String CREATE_USER_TABLE_SQL =
+ "CREATE TABLE " + TABLE.USER + "(" +
+ UserColumns.ID + " INTEGER PRIMARY KEY AUTOINCREMENT," +
+ UserColumns.USERNAME + " TEXT UNIQUE NOT NULL," +
+ UserColumns.PASSWORD + " TEXT NOT NULL," +
+ UserColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)" +
+ ")";
+
+ private static UserDatabaseHelper mInstance;
+
+ public UserDatabaseHelper(Context context) {
+ super(context, DB_NAME, null, DB_VERSION);
+ }
+
+ public static synchronized UserDatabaseHelper getInstance(Context context) {
+ if (mInstance == null) {
+ mInstance = new UserDatabaseHelper(context.getApplicationContext());
+ }
+ return mInstance;
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase db) {
+ db.execSQL(CREATE_USER_TABLE_SQL);
+ Log.d(TAG, "user table has been created");
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+ // 目前只有一个版本，暂时不做升级处理
+ if (oldVersion < newVersion) {
+ db.execSQL("DROP TABLE IF EXISTS " + TABLE.USER);
+ onCreate(db);
+ }
+ }
+
+ /**
+ * 注册新用户
+ * @param username 用户名
+ * @param password 密码
+ * @return 成功返回true，失败返回false
+ */
+ public boolean registerUser(String username, String password) {
+ SQLiteDatabase db = this.getWritableDatabase();
+ ContentValues values = new ContentValues();
+ values.put(UserColumns.USERNAME, username);
+ values.put(UserColumns.PASSWORD, encryptPassword(password));
+
+ try {
+ long result = db.insert(TABLE.USER, null, values);
+ return result != -1;
+ } catch (Exception e) {
+ Log.e(TAG, "Register user error: " + e.getMessage());
+ return false;
+ }
+ }
+
+ /**
+ * 用户登录验证
+ * @param username 用户名
+ * @param password 密码
+ * @return 验证成功返回true，否则返回false
+ */
+ public boolean authenticateUser(String username, String password) {
+ SQLiteDatabase db = this.getReadableDatabase();
+ String encryptedPassword = encryptPassword(password);
+
+ String[] columns = {UserColumns.ID};
+ String selection = UserColumns.USERNAME + "=? AND " + UserColumns.PASSWORD + "=?";
+ String[] selectionArgs = {username, encryptedPassword};
+
+ Cursor cursor = db.query(TABLE.USER, columns, selection, selectionArgs, null, null, null);
+
+ boolean authenticated = cursor.getCount() > 0;
+ cursor.close();
+
+ return authenticated;
+ }
+
+ /**
+ * 检查用户名是否存在
+ * @param username 用户名
+ * @return 存在返回true，否则返回false
+ */
+ public boolean isUsernameExists(String username) {
+ SQLiteDatabase db = this.getReadableDatabase();
+
+ String[] columns = {UserColumns.ID};
+ String selection = UserColumns.USERNAME + "=?";
+ String[] selectionArgs = {username};
+
+ Cursor cursor = db.query(TABLE.USER, columns, selection, selectionArgs, null, null, null);
+
+ boolean exists = cursor.getCount() > 0;
+ cursor.close();
+
+ return exists;
+ }
+
+ /**
+ * 简单的MD5加密
+ * @param password 原始密码
+ * @return 加密后的密码
+ */
+ private String encryptPassword(String password) {
+ try {
+ MessageDigest md = MessageDigest.getInstance("MD5");
+ md.update(password.getBytes());
+ byte[] digest = md.digest();
+ StringBuilder sb = new StringBuilder();
+ for (byte b : digest) {
+ sb.append(String.format("%02x", b & 0xff));
+ }
+ return sb.toString();
+ } catch (NoSuchAlgorithmException e) {
+ Log.e(TAG, "MD5 algorithm not found: " + e.getMessage());
+ return password; // 如果加密失败，返回原密码（实际项目中应该更安全地处理）
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/notes/gtask/data/MetaData.java b/src/notes/gtask/data/MetaData.java
index 3a2050b..e09fad8 100644
--- a/src/notes/gtask/data/MetaData.java
+++ b/src/notes/gtask/data/MetaData.java
@@ -24,12 +24,31 @@ import net.micode.notes.tool.GTaskStringUtils;
import org.json.JSONException;
import org.json.JSONObject;
-
+/**
+ * gtask同步任务的元数据管理类
+ * 存储和管理笔记与gtask同步时的元数据信息
+ * MetaData是什么?描述便签属性的信息，比如创建时间、修改时间、便签ID等，而不是便签的正文内容。
+ * gid是什么?google为每个同步任务分配的唯一标识，分给远端，保证同步的一致性
+ * JSON是什么?一种数据封装格式，用于封装MetaData，可读性强，可被用户或其他应用读取/编辑
+ *
+ * 继承Task类，专门用于存储同步元数据
+ */
public class MetaData extends Task {
+ /**
+ * MetaData.class拿到MetaData的class对象
+ * getSimpleName返回类名不含包名的简短形式，这里就是’MetaData‘
+ */
private final static String TAG = MetaData.class.getSimpleName();
+ //存储当前元数据关联的gid
private String mRelatedGid = null;
+ /**
+ *设置元数据的核心方法
+ * 将关联的gtask ID封装到JSON对象中，并设置为Task的笔记内容和名称
+ * @param gid 相当于远端的身份证号
+ * @param metaInfo JSONObject对象，用来存储MetaData的JSON格式数据结构。
+ */
public void setMeta(String gid, JSONObject metaInfo) {
try {
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
@@ -40,17 +59,27 @@ public class MetaData extends Task {
setName(GTaskStringUtils.META_NOTE_NAME);
}
+ /**
+ * 获取当前元数据关联的gtask ID
+ * @return 关联的远端gtask ID(返回null时，未关联）
+ */
public String getRelatedGid() {
return mRelatedGid;
}
+ //笔记内容不为空就保存
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
+ /**
+ * 从远端gtask返回的JSON数据设置当前元数据内容
+ * @param js 远端gtask返回的JSON对象
+ */
@Override
public void setContentByRemoteJSON(JSONObject js) {
+ //调用父类方法，初始化task基础属性
super.setContentByRemoteJSON(js);
if (getNotes() != null) {
try {
@@ -63,17 +92,23 @@ public class MetaData extends Task {
}
}
+ /**不会将元数据单独保存为JSON文件并保存到本地，
+ * 而是将MetaData和正文一起存储在本地的SQLite数据库，
+ * 为了防止用户篡改信息，比如便签的创建时间，导致APP读取数据时出现异常
+ */
@Override
public void setContentByLocalJSON(JSONObject js) {
// this function should not be called
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/gtask/data/Node.java b/src/notes/gtask/data/Node.java
index 63950e0..3b393db 100644
--- a/src/notes/gtask/data/Node.java
+++ b/src/notes/gtask/data/Node.java
@@ -20,24 +20,29 @@ 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_NONE = 0; //无同步操作
- public static final int SYNC_ACTION_ADD_REMOTE = 1;
+ public static final int SYNC_ACTION_ADD_REMOTE = 1; //远程添加操作
- public static final int SYNC_ACTION_ADD_LOCAL = 2;
+ 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_REMOTE = 3; //远程删除操作
- public static final int SYNC_ACTION_DEL_LOCAL = 4;
+ 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_REMOTE = 5; //远程更新操作
- public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
+ public static final int SYNC_ACTION_UPDATE_LOCAL = 6; //本地更新操作
- public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
+ public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; //更新冲突
- public static final int SYNC_ACTION_ERROR = 8;
+ public static final int SYNC_ACTION_ERROR = 8; //同步出错
private String mGid;
@@ -47,23 +52,30 @@ public abstract class Node {
private boolean mDeleted;
+ //无参构造法，创建Node对象时无需传入任何参数
public Node() {
- mGid = null;
- mName = "";
+ mGid = null; //常由云端生成
+ mName = ""; //不初始化为null：避免后续调用mName.length等方法时触发空指针异常
mLastModified = 0;
mDeleted = false;
}
+ //JSONObject是JSON实例的抽象类，生成同步创建操作JSON数据，返回操作ID
public abstract JSONObject getCreateAction(int actionId);
+ //生成同步更新操作的JSON数据，返回操作ID
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();
+ //通过游标获取同步操作类型，在前面声明为类型变量0-8
public abstract int getSyncAction(Cursor c);
public void setGid(String gid) {
diff --git a/src/notes/gtask/data/SqlData.java b/src/notes/gtask/data/SqlData.java
index d3ec3be..b1b4ff9 100644
--- a/src/notes/gtask/data/SqlData.java
+++ b/src/notes/gtask/data/SqlData.java
@@ -34,7 +34,11 @@ import net.micode.notes.gtask.exception.ActionFailureException;
import org.json.JSONException;
import org.json.JSONObject;
-
+/**
+ *管理便签应用中的数据项（如文本、图片等），
+ * 负责数据项的加载、从JSON解析数据、生成JSON数据、数据库交互（插入 / 更新）及版本冲突控制，
+ * 是便签数据在内存与数据库之间的中间层处理类。
+ */
public class SqlData {
private static final String TAG = SqlData.class.getSimpleName();
@@ -47,16 +51,21 @@ public class SqlData {
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;
+ //存储content辅助信息，比如图片的宽度大小等
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
+ //更多扩展信息
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
private ContentResolver mContentResolver;
+ //false表示新创建的未入库数据项，true表示数据库中已经创建的数据项
private boolean mIsCreate;
private long mDataId;
@@ -71,6 +80,10 @@ public class SqlData {
private ContentValues mDiffDataValues;
+ /**
+ * mContentResolver是什么？
+ * @param context
+ */
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
@@ -97,13 +110,23 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
+ /**
+ * 将JSON中的数据项属性映射到SqlData实例的成员变量，
+ * 记录变更的字段到mDifferentValues中，为后续数据库增量更新做准备
+ * 数据序列化，JSON js->实例
+ * @param js
+ * @throws JSONException
+ */
public void setContent(JSONObject js) throws JSONException {
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
+
+ //新创建的未入库数据项或者是当前实例的已有ID和JSON中解析的ID不一样，说明该字段发生了变更
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
}
mDataId = dataId;
+ //判断JSON中是否包含MIME_TYPE键，否则默认为纯文本
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE;
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
@@ -111,18 +134,21 @@ public class SqlData {
}
mDataMimeType = dataMimeType;
+ //判断JSON中是否包含CONTENT键，如便签文本等，否则赋值为空串
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
if (mIsCreate || !mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent);
}
mDataContent = dataContent;
+ //判断DATA1键，如图片宽度等
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
}
mDataContentData1 = dataContentData1;
+ //判断DATA3键
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
@@ -144,28 +170,39 @@ public class SqlData {
return js;
}
+ /**
+ * 将数据项提交到数据库，根据数据项是否为新建，分别执行插入或者更新操作，同时支持版本验证，
+ * 最终清理变更记录，更新实例状态
+ * @param noteId 数据项关联的便签ID
+ * @param validateVersion 版本验证布尔值，防止多人或者多设备同时改，避免改乱
+ * @param version 要验证的版本号
+ */
public void commit(long noteId, boolean validateVersion, long version) {
+ //新创建的项，“插入”
if (mIsCreate) {
+ //未入库，数据库未生成主键，所以当前数据项ID为无效值
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
}
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
- try {
+ try { //从数据库返回的地址里抠出数据项的ID
mDataId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
- } else {
+ } else { //数据库里本来就有这个项，只是更改内容
if (mDiffDataValues.size() > 0) {
int result = 0;
+
+ //不需要防止多设备更改冲突
if (!validateVersion) {
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
- } else {
+ } else { //需要防止多设备更改冲突
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
diff --git a/src/notes/gtask/data/SqlNote.java b/src/notes/gtask/data/SqlNote.java
index 79a4095..a854491 100644
--- a/src/notes/gtask/data/SqlNote.java
+++ b/src/notes/gtask/data/SqlNote.java
@@ -37,12 +37,18 @@ import org.json.JSONObject;
import java.util.ArrayList;
-
+/**
+ * sqlNote类用于处理本地数据库中的笔记数据
+ * 主要负责笔记的创建、加载（从数据库读数据）、数据同步、把笔记提交到数据库。
+ * 相当于单个笔记的生命周期管家。
+ * 与Android的ContentProvider进行交互
+ */
public class SqlNote {
private static final String TAG = SqlNote.class.getSimpleName();
private static final int INVALID_ID = -99999;
+ //记录需要从小米便签数据库中查询的字段
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,
@@ -52,6 +58,7 @@ public class SqlNote {
NoteColumns.VERSION
};
+ //将PROJECTION_NOTE中的每个字段按顺序赋索引值0-16，便于从cursor中快速获取
public static final int ID_COLUMN = 0;
public static final int ALERTED_DATE_COLUMN = 1;
@@ -86,11 +93,11 @@ public class SqlNote {
public static final int VERSION_COLUMN = 16;
- private Context mContext;
+ private Context mContext; //上下文对象，用于获取系统服务（如ContentResolver）
- private ContentResolver mContentResolver;
+ private ContentResolver mContentResolver; //操作ContentProvider（数据库交互）
- private boolean mIsCreate;
+ private boolean mIsCreate; //标记当前笔记是否为新创建（未存入数据库）
private long mId;
@@ -100,15 +107,15 @@ public class SqlNote {
private long mCreatedDate;
- private int mHasAttachment;
+ private int mHasAttachment; //是否有附件（0：无，1：有）
private long mModifiedDate;
private long mParentId;
- private String mSnippet;
+ private String mSnippet; // 笔记摘要（简短内容，用于列表展示）
- private int mType;
+ private int mType; // 笔记类型（如：Notes.TYPE_NOTE-普通笔记，TYPE_FOLDER-文件夹）
private int mWidgetId;
@@ -118,10 +125,11 @@ public class SqlNote {
private long mVersion;
- private ContentValues mDiffNoteValues;
+ private ContentValues mDiffNoteValues; //存储需要更新的字段
- private ArrayList mDataList;
+ private ArrayList mDataList; // 笔记关联的数据列表（如文本内容、图片等，由SqlData管理）
+ //初始化新笔记
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
@@ -143,9 +151,12 @@ public class SqlNote {
mDataList = new ArrayList();
}
+ //从cursor加载已有笔记
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
+
+ //从数据库加载，标记为已存在
mIsCreate = false;
loadFromCursor(c);
mDataList = new ArrayList();
@@ -154,10 +165,13 @@ public class SqlNote {
mDiffNoteValues = new ContentValues();
}
+ //通过id加载已有笔记
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false;
+
+ //根据id查询数据库并加载数据
loadFromCursor(id);
mDataList = new ArrayList();
if (mType == Notes.TYPE_NOTE)
@@ -169,13 +183,14 @@ public class SqlNote {
private void loadFromCursor(long id) {
Cursor c = null;
try {
+ //查询指定id的笔记
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(id)
}, null);
if (c != null) {
- c.moveToNext();
- loadFromCursor(c);
+ c.moveToNext(); //移动到第一条记录
+ loadFromCursor(c); //从cursor加载数据
} else {
Log.w(TAG, "loadFromCursor: cursor = null");
}
@@ -200,10 +215,12 @@ public class SqlNote {
mVersion = c.getLong(VERSION_COLUMN);
}
+ //加载笔记的关联数据（如文本内容）
private void loadDataContent() {
Cursor c = null;
- mDataList.clear();
+ mDataList.clear(); //清空现有数据
try {
+ //根据（note_id=mId）查询当前笔记关联的所有数据
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
String.valueOf(mId)
@@ -226,15 +243,26 @@ public class SqlNote {
}
}
+ /**数据同步相关方法-从JSON对象设置笔记内容，便于同步接收数据
+ * JSON解析-内存字段映射-差异记录-持久化落地。
+ * setContent解析JSON到SqlNote对象：按照笔记类型解析-元数据映射-内容数据映射-差异记录
+ */
public boolean setContent(JSONObject js) {
try {
+ //解析JSON中的笔记元数据note
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) {
+ }
+ //文件夹类型，仅更新摘要和类型
+ else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// for folder we can only update the snnipet and type
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
+
+ //如果是新创建或者内容(snippet)有变化时记录差异
if (mIsCreate || !mSnippet.equals(snippet)) {
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
@@ -246,14 +274,21 @@ public class SqlNote {
mDiffNoteValues.put(NoteColumns.TYPE, type);
}
mType = type;
- } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+ }
+
+ //普通笔记类型，更新所有元数据和关联数据
+ else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
+ //关联数据数组
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+
+ //逐个解析元数据字段，仅仅记录变化的部分到差异容器，这里是id字段
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) {
mDiffNoteValues.put(NoteColumns.ID, id);
}
mId = id;
+ //提醒日期字段
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note
.getLong(NoteColumns.ALERTED_DATE) : 0;
if (mIsCreate || mAlertDate != alertDate) {
@@ -261,6 +296,7 @@ public class SqlNote {
}
mAlertDate = alertDate;
+ //背景颜色字段
int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note
.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
if (mIsCreate || mBgColorId != bgColorId) {
@@ -268,6 +304,7 @@ public class SqlNote {
}
mBgColorId = bgColorId;
+ //创建日期字段
long createDate = note.has(NoteColumns.CREATED_DATE) ? note
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
if (mIsCreate || mCreatedDate != createDate) {
@@ -275,6 +312,7 @@ public class SqlNote {
}
mCreatedDate = createDate;
+ //有无附件字段
int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note
.getInt(NoteColumns.HAS_ATTACHMENT) : 0;
if (mIsCreate || mHasAttachment != hasAttachment) {
@@ -282,6 +320,7 @@ public class SqlNote {
}
mHasAttachment = hasAttachment;
+ //修改日期字段
long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note
.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
if (mIsCreate || mModifiedDate != modifiedDate) {
@@ -289,6 +328,7 @@ public class SqlNote {
}
mModifiedDate = modifiedDate;
+ //父文件夹字段
long parentId = note.has(NoteColumns.PARENT_ID) ? note
.getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) {
@@ -296,6 +336,7 @@ public class SqlNote {
}
mParentId = parentId;
+ //内容字段
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
@@ -303,6 +344,7 @@ public class SqlNote {
}
mSnippet = snippet;
+ //笔记类型字段
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE)
: Notes.TYPE_NOTE;
if (mIsCreate || mType != type) {
@@ -310,6 +352,7 @@ public class SqlNote {
}
mType = type;
+ //桌面组件id字段
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID)
: AppWidgetManager.INVALID_APPWIDGET_ID;
if (mIsCreate || mWidgetId != widgetId) {
@@ -317,6 +360,7 @@ public class SqlNote {
}
mWidgetId = widgetId;
+ //桌面组件类型字段
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
if (mIsCreate || mWidgetType != widgetType) {
@@ -324,6 +368,7 @@ public class SqlNote {
}
mWidgetType = widgetType;
+ //原始父文件夹字段
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note
.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
if (mIsCreate || mOriginParent != originParent) {
@@ -334,6 +379,8 @@ public class SqlNote {
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
SqlData sqlData = null;
+
+ //查找已存在的sqlData(通过ID匹配)
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) {
@@ -343,12 +390,13 @@ public class SqlNote {
}
}
+ //不存在则创建新的sqlData
if (sqlData == null) {
sqlData = new SqlData(mContext);
mDataList.add(sqlData);
}
- sqlData.setContent(data);
+ sqlData.setContent(data); //更新数据内容
}
}
} catch (JSONException e) {
@@ -359,6 +407,7 @@ public class SqlNote {
return true;
}
+ //将笔记内容转换成JSON对象（用于同步发送数据）
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
@@ -369,6 +418,7 @@ public class SqlNote {
}
JSONObject note = new JSONObject();
+ //普通笔记：所有元数据+关联数据
if (mType == Notes.TYPE_NOTE) {
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
@@ -384,6 +434,7 @@ public class SqlNote {
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
+ //关联数据转换成JSON数组
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
JSONObject data = sqlData.getContent();
@@ -392,7 +443,9 @@ public class SqlNote {
}
}
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
- } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
+ }
+ //文件夹/系统文件夹：仅包含ID、类型、摘要
+ else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet);
@@ -407,11 +460,16 @@ public class SqlNote {
return null;
}
+ /**
+ *为什么下面这些数据设置不放在上面的setContent(JSONObject js)函数里
+ */
+ //设置父文件夹ID并记录差异
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
+ //设置GTask ID 用于同步
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
}
@@ -420,10 +478,14 @@ public class SqlNote {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
}
+ //重置本地修改标记（用于修改后）
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
+ /**
+ * 下面几个成员函数是为了获取成员变量值
+ */
public long getId() {
return mId;
}
@@ -440,14 +502,20 @@ public class SqlNote {
return mType == Notes.TYPE_NOTE;
}
+ //数据库提交方法：保存/更新笔记
public void commit(boolean validateVersion) {
+ //如果是新笔记，就插入到数据库
if (mIsCreate) {
+
+ //移除无效ID,因为数据库会自动生成ID
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
}
+ //插入笔记元数据到ContentProvider
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
+ //从返回的uri里获取新生成的ID
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
@@ -457,25 +525,34 @@ public class SqlNote {
throw new IllegalStateException("Create thread id failed");
}
+ //提交关联数据，如文本内容
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
}
}
- } else {
+ }
+ //不是新笔记，已经存在，就执行“更新”操作
+ else {
+ //验证ID有效性
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 ++;
+ mVersion ++; //版本号自增
int result = 0;
+
+ //不验证版本，直接更新
if (!validateVersion) {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
});
- } else {
+ }
+ // 验证版本：当数据库版本<=当前版本时更新
+ else {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
@@ -487,6 +564,7 @@ public class SqlNote {
}
}
+ //提交关联数据
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
@@ -494,12 +572,12 @@ public class SqlNote {
}
}
- // refresh local info
+ // refresh local info，
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
- mDiffNoteValues.clear();
- mIsCreate = false;
+ mDiffNoteValues.clear(); //清空差异字段
+ mIsCreate = false; //标记为已创建
}
}
diff --git a/src/notes/gtask/data/Task.java b/src/notes/gtask/data/Task.java
index 6a19454..acde9c3 100644
--- a/src/notes/gtask/data/Task.java
+++ b/src/notes/gtask/data/Task.java
@@ -31,19 +31,22 @@ import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
-
+/**
+ * 继承Node类，具体实现 Node类中定义的方法，包括更新、删除、添加操作等
+ */
public class Task extends Node {
private static final String TAG = Task.class.getSimpleName();
- private boolean mCompleted;
+ private boolean mCompleted; //Google 任务是否已完成（勾选状态）
- private String mNotes;
+ private String mNotes; //任务备注正文
- private JSONObject mMetaInfo;
+ private JSONObject mMetaInfo;//定义Task的MetaData的JSON数据格式
+ //指向当前任务点的前兄弟任务的指针/引用，用于在内存中关联当前任务的前一个任务
private Task mPriorSibling;
- private TaskList mParent;
+ private TaskList mParent; //定义所属的Google TaskList
public Task() {
super();
@@ -54,6 +57,11 @@ public class Task extends Node {
mMetaInfo = null;
}
+ /**生成“创建任务”的JSON指令，用于将本地新建任务同步到云端z
+ *
+ * @param actionId
+ * @return 一个JSON对象实例 包括“创建”操作信息和“业务”信息
+ */
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
@@ -68,6 +76,10 @@ public class Task extends Node {
// index
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
+ /**为什么要再创建一个JSONObject实例对象？
+ * 分层设计：操作信息+业务实体信息
+ * entity存储这个业务对象的具体数据内容，比如任务标题、任务备注、完成状态、gid
+ */
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
@@ -77,6 +89,7 @@ public class Task extends Node {
if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
+
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
// parent_id
@@ -95,7 +108,10 @@ public class Task extends Node {
}
} catch (JSONException e) {
+ //toString输出异常本身的类型和描述
Log.e(TAG, e.toString());
+
+ //还原异常的发生现场，通过栈进行追踪
e.printStackTrace();
throw new ActionFailureException("fail to generate task-create jsonobject");
}
@@ -103,6 +119,11 @@ public class Task extends Node {
return js;
}
+ /**生成“更新任务”的JSON指令
+ *
+ * @param actionId
+ * @return 一个JSON对象实例 包括“更新”信息+业务信息
+ */
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
@@ -121,7 +142,7 @@ public class Task extends Node {
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_NOTES, getNotes());//更新备注
}
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
@@ -135,7 +156,12 @@ public class Task extends Node {
return js;
}
+ /**
+ * 执行具体操作，根据远端的JSON设置本地的内容
+ * @param js 远端的JSON实例
+ */
public void setContentByRemoteJSON(JSONObject js) {
+
if (js != null) {
try {
// id
@@ -175,13 +201,23 @@ public class Task extends Node {
}
}
+ /**
+ * 将小米便签本地存储的JSON格式数据解析并映射为Task对象的核心属性，
+ * 为本地便签数据同步到云端提供数据适配和内容提取能力。
+ * @param js
+ */
public void setContentByLocalJSON(JSONObject js) {
+ //若是本地JSON不含便签元信息+内容数据，输出错误日志
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
}
try {
+ /**提取同步所需的基础数据
+ * note：小米便签存储本地的便签元数据，如便签类型、创建时间、同步状态等
+ * dataArray:便签内容数组，可能包括文本、图片、附件等多种数据类型
+ */
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
@@ -204,6 +240,7 @@ public class Task extends Node {
}
}
+ //返回完整 JSON，供本地数据库保存或上传云端
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
@@ -247,6 +284,7 @@ public class Task extends Node {
}
}
+ //将小米便签的MetaData元数据对象中的JSON格式解析为mMetaInfo
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
try {
@@ -258,6 +296,11 @@ public class Task extends Node {
}
}
+ /**
+ * 对比本地数据库中的便签数据（cursor）和当前task对象中缓存的云端元数据信息（mMetaInfo），
+ * 从数据、修改状态、GID等多维度进行比较校验，
+ * 最终判断当前标签需要执行的同步操作类型，比如无操作、更新本地、更新远端等
+ */
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
@@ -281,6 +324,7 @@ public class Task extends Node {
return SYNC_ACTION_UPDATE_LOCAL;
}
+ //本地无修改
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// there is no local update
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
@@ -290,12 +334,18 @@ public class Task extends Node {
// apply remote to local
return SYNC_ACTION_UPDATE_LOCAL;
}
- } else {
+ } else { //本地有修改
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
+
+ /**SqlNote.SYNC_ID_COLUMN是本地数据库中SqlNote表的一个字段名
+ * 存储本地记录的最后一次与云端同步的时间戳。
+ * 字段名带ID是命名习惯，实际存储的是时间戳 / 同步版本号，而非普通 ID）。
+ * getLastModified()返回远端任务的最后修改时间戳
+ */
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
@@ -311,6 +361,7 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
+ //空任务、空备注、无元数据 → 不值得存/上传，直接跳过
public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0);
diff --git a/src/notes/gtask/data/TaskList.java b/src/notes/gtask/data/TaskList.java
index 4ea21c5..1726969 100644
--- a/src/notes/gtask/data/TaskList.java
+++ b/src/notes/gtask/data/TaskList.java
@@ -33,9 +33,9 @@ import java.util.ArrayList;
public class TaskList extends Node {
private static final String TAG = TaskList.class.getSimpleName();
- private int mIndex;
+ private int mIndex; //列表索引，找到特定的task
- private ArrayList mChildren;
+ private ArrayList mChildren; //task列表
public TaskList() {
super();
@@ -43,6 +43,7 @@ public class TaskList extends Node {
mIndex = 1;
}
+ //生成TaskList“创建任务”的JSON
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
@@ -74,18 +75,20 @@ public class TaskList extends Node {
return js;
}
+ //“更新操作”的JSON
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// action_type
+ //设置操作类型，明确告诉远端此次操作为“更新”
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
- // action_id
+ // action_id 操作ID（追踪操作结果）
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
- // id
+ // id（要更新的任务/任务列表GID）
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// entity_delta
@@ -106,7 +109,7 @@ public class TaskList extends Node {
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
- // id
+ // id（本地和远端ID一致）
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
@@ -130,6 +133,7 @@ public class TaskList extends Node {
}
public void setContentByLocalJSON(JSONObject js) {
+ //本地JSON为空或者是否包含核心字段META_HEAD_NOTE
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
}
@@ -137,6 +141,7 @@ public class TaskList extends Node {
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);
@@ -157,6 +162,10 @@ public class TaskList extends Node {
}
}
+ /**
+ * MIUI_FOLDER_PREFFIX 在远端区分小米便签同步的文件夹和其他应用创建的文件夹，避免命名冲突
+ * @return 本地JSON
+ */
public JSONObject getLocalJSONFromContent() {
try {
JSONObject js = new JSONObject();
@@ -164,6 +173,7 @@ public class TaskList extends Node {
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);
@@ -183,10 +193,11 @@ public class TaskList extends Node {
}
}
+ //使用游标判断 本地和远端状态，返回同步操作类型号
public int getSyncAction(Cursor c) {
try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
- // there is no local update
+ // there is no local update 本地无更新
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// no update both side
return SYNC_ACTION_NONE;
@@ -194,12 +205,14 @@ public class TaskList extends Node {
// apply remote to local
return SYNC_ACTION_UPDATE_LOCAL;
}
- } else {
+ } else { //本地有更新，检验本地和远端ID是否一致，再决定最终的同步策略
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
+
+ //在本地和远端ID一致前提下，进一步判断云端数据是否有更新
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
@@ -220,6 +233,7 @@ public class TaskList extends Node {
return mChildren.size();
}
+ //添加子任务
public boolean addChildTask(Task task) {
boolean ret = false;
if (task != null && !mChildren.contains(task)) {
@@ -234,6 +248,7 @@ public class TaskList extends Node {
return ret;
}
+ //指定位置插入子任务
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index");
@@ -241,14 +256,20 @@ public class TaskList extends Node {
}
int pos = mChildren.indexOf(task);
+
+ //pos==-1说明task不在mChildren里
if (task != null && pos == -1) {
mChildren.add(index, task);
- // update the task list
+ // update the task list更新任务列表索引
Task preTask = null;
Task afterTask = null;
+
+ //如果插入位置不在第一个，前任务为index-1的位置
if (index != 0)
preTask = mChildren.get(index - 1);
+
+ //如果插入位置不在最后一个，后继任务为index+1的位置
if (index != mChildren.size() - 1)
afterTask = mChildren.get(index + 1);
@@ -260,9 +281,12 @@ public class TaskList extends Node {
return true;
}
+ //移除子任务
public boolean removeChildTask(Task task) {
boolean ret = false;
int index = mChildren.indexOf(task);
+
+ //index!=-1说明task在mChildren里，移除操作有效
if (index != -1) {
ret = mChildren.remove(task);
@@ -276,11 +300,13 @@ public class TaskList extends Node {
mChildren.get(index).setPriorSibling(
index == 0 ? null : mChildren.get(index - 1));
}
+ //当移除最后一个任务时，index==mChildren.size(),没有后续任务，无需更新
}
}
return ret;
}
+ //将指定task从当前位置移到mChildren列表指定的index位置
public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) {
@@ -294,11 +320,20 @@ public class TaskList extends Node {
return false;
}
+ //当前已经在指定位置，不用移动
if (pos == index)
return true;
return (removeChildTask(task) && addChildTask(task, index));
+
+ //这里先判断当前不在指定位置，是不是更好？至少更容易一下子看懂
+ /**
+ * if (pos!=index)
+ * return (removeChildTask(task) && addChildTask(task,index));
+ * else return true;
+ */
}
+ //给定云端gid快速查找子任务
public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) {
Task t = mChildren.get(i);
@@ -309,10 +344,12 @@ public class TaskList extends Node {
return 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");
@@ -321,12 +358,24 @@ public class TaskList extends Node {
return mChildren.get(index);
}
- public Task getChilTaskByGid(String gid) {
+ /**根据云端gid返回子任务
+ *这个似乎和前面的findChildTaskByGid(String gid)是一样的？
+ */
+ public Task getChildTaskByGid(String gid) {
for (Task task : mChildren) {
if (task.getGid().equals(gid))
return task;
}
return null;
+ /*
+ for (int i = 0; i < mChildren.size(); i++) {
+ Task t = mChildren.get(i);
+ if (t.getGid().equals(gid)) {
+ return t;
+ }
+ }
+ return null;
+ */
}
public ArrayList getChildTaskList() {
diff --git a/src/notes/gtask/exception/ActionFailureException.java b/src/notes/gtask/exception/ActionFailureException.java
index 15504be..b8b51f1 100644
--- a/src/notes/gtask/exception/ActionFailureException.java
+++ b/src/notes/gtask/exception/ActionFailureException.java
@@ -16,6 +16,11 @@
package net.micode.notes.gtask.exception;
+/**运行异常类
+ * 继承自RuntimeException类，
+ * 专门标识“某个操作执行失败”的异常场景，
+ * 比如 GTask 同步失败、数据库操作失败、网络请求失败等
+ */
public class ActionFailureException extends RuntimeException {
private static final long serialVersionUID = 4425249765923293627L;
@@ -23,10 +28,15 @@ public class ActionFailureException extends RuntimeException {
super();
}
+ /**
+ * 调用父类的RuntimeException(String)构造方法 - super函数
+ * @param paramString 错误描述字符串
+ */
public ActionFailureException(String paramString) {
super(paramString);
}
+ //错误信息+异常原因
public ActionFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}
diff --git a/src/notes/gtask/exception/NetworkFailureException.java b/src/notes/gtask/exception/NetworkFailureException.java
index b08cfb1..2a1e178 100644
--- a/src/notes/gtask/exception/NetworkFailureException.java
+++ b/src/notes/gtask/exception/NetworkFailureException.java
@@ -16,6 +16,11 @@
package net.micode.notes.gtask.exception;
+/**受检异常类
+ * 继承自Exception类
+ * 专门标识 “网络操作失败” 的异常场景，
+ * 比如 GTask 同步时的网络连接超时、请求失败、服务器无响应、网络断开等。
+ */
public class NetworkFailureException extends Exception {
private static final long serialVersionUID = 2107610287180234136L;
@@ -27,6 +32,7 @@ public class NetworkFailureException extends Exception {
super(paramString);
}
+ //自定义错误信息+底层的根异常
public NetworkFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}
diff --git a/src/notes/gtask/remote/GTaskASyncTask.java b/src/notes/gtask/remote/GTaskASyncTask.java
index b3b61e7..5a4ace7 100644
--- a/src/notes/gtask/remote/GTaskASyncTask.java
+++ b/src/notes/gtask/remote/GTaskASyncTask.java
@@ -28,77 +28,137 @@ import net.micode.notes.R;
import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
-
+/**
+ *异步任务类，继承AsyncTask，
+ * doInBackground（后台执行）→ onProgressUpdate（进度更新）→ onPostExecute（结果处理）
+ * 在后台执行GTask的同步逻辑，通过GTaskManager实现登录、拉取、提交等操作，
+ * 实时通过状态栏通知向用户展示同步进度（登录中、同步中），
+ * 同步完成后，根据结果（成功 / 失败 / 取消）显示对应通知，并通过回调接口通知外层组件；
+ * 支持取消同步操作，以及同步状态的广播通知。
+ */
public class GTaskASyncTask extends AsyncTask {
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
+ //通知Activity等外层同步已结束，是接口
public interface OnCompleteListener {
void onComplete();
}
- private Context mContext;
+ private Context mContext; //上下文，用于获取系统服务、资源字符串、启动Activity等
- private NotificationManager mNotifiManager;
+ private NotificationManager mNotifiManager; //用于发送和管理状态栏通知
- private GTaskManager mTaskManager;
+ private GTaskManager mTaskManager; //真正执行同步核心逻辑（登录、拉取、对比、提交等）
- private OnCompleteListener mOnCompleteListener;
+ private OnCompleteListener mOnCompleteListener; //通知外层 Activity/Service 同步结束
+ //构造方法：初始化上下文和回调监听器，获取通知管理器和GTaskManager实例
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
mNotifiManager = (NotificationManager) mContext
.getSystemService(Context.NOTIFICATION_SERVICE);
+ //获取GTaskManager单例实例 （负责实际同步逻辑）
mTaskManager = GTaskManager.getInstance();
}
+ //终止同步的方法
public void cancelSync() {
mTaskManager.cancelSync();
}
+ //反馈给用户当前进度(这里或许应该是Progress?)
public void publishProgess(String message) {
publishProgress(new String[] {
message
});
}
+// private void showNotification(int tickerId, String content) {
+// Notification notification = new Notification(R.drawable.notification, mContext
+// .getString(tickerId), System.currentTimeMillis());
+// notification.defaults = Notification.DEFAULT_LIGHTS;
+// notification.flags = Notification.FLAG_AUTO_CANCEL;
+// PendingIntent pendingIntent;
+// if (tickerId != R.string.ticker_success) {
+// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+// NotesPreferenceActivity.class), 0);
+//
+// } else {
+// pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
+// NotesListActivity.class), 0);
+// }
+// notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
+// pendingIntent);
+// mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
+// }
+
+ /**
+ * 显示状态栏通知的核心方法：根据同步状态显示不同内容和跳转意图
+ * @param tickerId 通知类型
+ * @param content
+ */
private void showNotification(int tickerId, String content) {
- Notification notification = new Notification(R.drawable.notification, mContext
- .getString(tickerId), System.currentTimeMillis());
- notification.defaults = Notification.DEFAULT_LIGHTS;
- notification.flags = Notification.FLAG_AUTO_CANCEL;
+ //延迟意图：点击通知时触发的页面跳转
PendingIntent pendingIntent;
+
+ //同步不成功，跳转到偏好设置页面
if (tickerId != R.string.ticker_success) {
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
- NotesPreferenceActivity.class), 0);
-
- } else {
+ NotesPreferenceActivity.class), PendingIntent.FLAG_IMMUTABLE);
+ } else { //同步成功，跳转到笔记列表页
pendingIntent = PendingIntent.getActivity(mContext, 0, new Intent(mContext,
- NotesListActivity.class), 0);
+ NotesListActivity.class), PendingIntent.FLAG_IMMUTABLE);
}
- notification.setLatestEventInfo(mContext, mContext.getString(R.string.app_name), content,
- pendingIntent);
+
+ //设置通知属性
+ Notification.Builder builder = new Notification.Builder(mContext)
+ .setAutoCancel(true)
+ .setContentTitle(mContext.getString(R.string.app_name)) //通知标题设置
+ .setContentText(content) //通知内容设置
+ .setContentIntent(pendingIntent) //点击通知时的跳转意图
+ .setWhen(System.currentTimeMillis()) //通知时间
+ .setOngoing(true); //持续通知，不会被滑动清除，同步过程中保持显示
+ Notification notification=builder.getNotification();
+
+ //通过通知管理器显示通知（使用固定ID，确保后续通知能覆盖之前的）
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
}
+ /**
+ * 后台执行方法：在子线程中执行同步核心逻辑
+ * 调用GTaskManager的sync方法执行同步，传入上下文和当前任务实例（用于更新进度）
+ * @param unused
+ * @return 同步结果状态码，如成功、网络错误等
+ */
@Override
protected Integer doInBackground(Void... unused) {
+ //发布登录进度：显示"正在登录[账号]"的提示（账号从偏好设置中获取）
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
.getSyncAccountName(mContext)));
return mTaskManager.sync(mContext, this);
}
+ /**
+ * 进度更新方法：在UI线程执行，接收后台发布的进度并更新通知
+ * @param progress
+ */
@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) {
+ //“同步成功”，更新偏好设置中的最后同步时间
if (result == GTaskManager.STATE_SUCCESS) {
showNotification(R.string.ticker_success, mContext.getString(
R.string.success_sync_account, mTaskManager.getSyncAccount()));
diff --git a/src/notes/gtask/remote/GTaskClient.java b/src/notes/gtask/remote/GTaskClient.java
index c67dfdf..13cea91 100644
--- a/src/notes/gtask/remote/GTaskClient.java
+++ b/src/notes/gtask/remote/GTaskClient.java
@@ -60,35 +60,40 @@ import java.util.zip.GZIPInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
-
+/**
+ * Google任务客户端，
+ * 负责与Google任务服务的网络通信（HTTP请求/响应处理）
+ */
public class GTaskClient {
private static final String TAG = GTaskClient.class.getSimpleName();
+ // 获取任务列表的GET请求URL
private static final String GTASK_URL = "https://mail.google.com/tasks/";
+ // 提交操作的POST请求URL
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
private static GTaskClient mInstance = null;
- private DefaultHttpClient mHttpClient;
+ private DefaultHttpClient mHttpClient; // HTTP客户端：用于发送HTTP请求
- private String mGetUrl;
+ private String mGetUrl; // 实际使用的GET请求URL（可能因域名变化）
- private String mPostUrl;
+ private String mPostUrl; // 实际使用的POST请求URL（可能因域名变化）
- private long mClientVersion;
+ private long mClientVersion; // 客户端版本：从Google服务获取，用于请求验证
- private boolean mLoggedin;
+ private boolean mLoggedin; // 登录状态标识
private long mLastLoginTime;
private int mActionId;
- private Account mAccount;
+ private Account mAccount; // 当前登录的Google账户
- private JSONArray mUpdateArray;
+ private JSONArray mUpdateArray; // 更新队列：批量存储待提交的更新操作（减少网络请求次数）
private GTaskClient() {
mHttpClient = null;
@@ -102,6 +107,7 @@ public class GTaskClient {
mUpdateArray = null;
}
+ //保证全局一个客户端实例
public static synchronized GTaskClient getInstance() {
if (mInstance == null) {
mInstance = new GTaskClient();
@@ -109,27 +115,33 @@ public class GTaskClient {
return mInstance;
}
+ // 登录Google任务：处理账户认证和会话建立
public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
+ // 登录过期检查：假设Cookie 5分钟过期，过期则需要重新登录
final long interval = 1000 * 60 * 5;
if (mLastLoginTime + interval < System.currentTimeMillis()) {
mLoggedin = false;
}
// need to re-login after account switch
+ // 账户切换检查：若当前账户与设置中的账户不一致，需要重新登录
if (mLoggedin
&& !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
.getSyncAccountName(activity))) {
mLoggedin = false;
}
+ // 已登录且有效，直接返回成功
if (mLoggedin) {
Log.d(TAG, "already logged in");
return true;
}
+ // 执行登录流程
mLastLoginTime = System.currentTimeMillis();
+ // 获取Google账户的认证token
String authToken = loginGoogleAccount(activity, false);
if (authToken == null) {
Log.e(TAG, "login google account failed");
@@ -137,21 +149,24 @@ public class GTaskClient {
}
// login with custom domain if necessary
+ // 处理自定义域名账户（非gmail/googlemail）
if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
.endsWith("googlemail.com"))) {
StringBuilder url = new StringBuilder(GTASK_URL).append("a/");
int index = mAccount.name.indexOf('@') + 1;
- String suffix = mAccount.name.substring(index);
+ String suffix = mAccount.name.substring(index); // 提取域名后缀
url.append(suffix + "/");
mGetUrl = url.toString() + "ig";
mPostUrl = url.toString() + "r/ig";
+ // 尝试用自定义URL登录
if (tryToLoginGtask(activity, authToken)) {
mLoggedin = true;
}
}
// try to login with google official url
+ // 若自定义域名登录失败，使用官方URL重试
if (!mLoggedin) {
mGetUrl = GTASK_GET_URL;
mPostUrl = GTASK_POST_URL;
@@ -164,16 +179,19 @@ public class GTaskClient {
return true;
}
+ // 登录Google账户：获取认证token（用于后续Google任务登录）
private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
String authToken;
- AccountManager accountManager = AccountManager.get(activity);
- Account[] accounts = accountManager.getAccountsByType("com.google");
+ AccountManager accountManager = AccountManager.get(activity); // 获取账户管理器
+ Account[] accounts = accountManager.getAccountsByType("com.google"); // 获取所有Google账户
+ // 无可用Google账户
if (accounts.length == 0) {
Log.e(TAG, "there is no available google account");
return null;
}
+ // 获取设置中配置的同步账户名
String accountName = NotesPreferenceActivity.getSyncAccountName(activity);
Account account = null;
for (Account a : accounts) {
@@ -190,12 +208,13 @@ public class GTaskClient {
}
// get the token now
+ // 获取账户的auth token
AccountManagerFuture accountManagerFuture = accountManager.getAuthToken(account,
"goanna_mobile", null, activity, null, null);
try {
- Bundle authTokenBundle = accountManagerFuture.getResult();
+ Bundle authTokenBundle = accountManagerFuture.getResult(); // 获取token结果
authToken = authTokenBundle.getString(AccountManager.KEY_AUTHTOKEN);
- if (invalidateToken) {
+ if (invalidateToken) { // 若需要失效旧token，重新获取
accountManager.invalidateAuthToken("com.google", authToken);
loginGoogleAccount(activity, false);
}
@@ -207,16 +226,19 @@ public class GTaskClient {
return authToken;
}
+ // 尝试登录Google任务：使用获取的auth token建立会话
private boolean tryToLoginGtask(Activity activity, String authToken) {
if (!loginGtask(authToken)) {
// maybe the auth token is out of date, now let's invalidate the
// token and try again
+ // 可能是token过期，失效旧token并重新获取
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;
@@ -225,25 +247,29 @@ public class GTaskClient {
return true;
}
+ // 登录Google任务核心逻辑：使用auth token获取会话Cookie和客户端版本
private boolean loginGtask(String authToken) {
+ // 设置HTTP连接超时（10秒）和读取超时（15秒）
int timeoutConnection = 10000;
int timeoutSocket = 15000;
HttpParams httpParameters = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(httpParameters, timeoutConnection);
HttpConnectionParams.setSoTimeout(httpParameters, timeoutSocket);
- mHttpClient = new DefaultHttpClient(httpParameters);
+ mHttpClient = new DefaultHttpClient(httpParameters); // 初始化HTTP客户端
BasicCookieStore localBasicCookieStore = new BasicCookieStore();
- mHttpClient.setCookieStore(localBasicCookieStore);
+ mHttpClient.setCookieStore(localBasicCookieStore); // 设置Cookie存储
HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
// login gtask
+ // 执行登录请求
try {
- String loginUrl = mGetUrl + "?auth=" + authToken;
- HttpGet httpGet = new HttpGet(loginUrl);
+ String loginUrl = mGetUrl + "?auth=" + authToken; // 构建带token的登录URL
+ HttpGet httpGet = new HttpGet(loginUrl);// 创建GET请求
HttpResponse response = null;
- response = mHttpClient.execute(httpGet);
+ response = mHttpClient.execute(httpGet); // 发送请求
// get the cookie now
+ // 检查是否获取到认证Cookie（含"GTL"标识）
List cookies = mHttpClient.getCookieStore().getCookies();
boolean hasAuthCookie = false;
for (Cookie cookie : cookies) {
@@ -256,17 +282,18 @@ public class GTaskClient {
}
// get the client version
+ // 解析响应获取客户端版本（用于后续请求）
String resString = getResponseContent(response.getEntity());
- String jsBegin = "_setup(";
- String jsEnd = ")}";
+ String jsBegin = "_setup("; // 响应中包含客户端版本的JS前缀
+ 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);
+ jsString = resString.substring(begin + jsBegin.length(), end);// 提取JS内容
}
JSONObject js = new JSONObject(jsString);
- mClientVersion = js.getLong("v");
+ mClientVersion = js.getLong("v"); // 获取客户端版本
} catch (JSONException e) {
Log.e(TAG, e.toString());
e.printStackTrace();
@@ -280,25 +307,29 @@ public class GTaskClient {
return true;
}
+ // 获取操作ID：每次调用递增，用于标识请求的唯一性
private int getActionId() {
return mActionId++;
}
+ // 创建POST请求：设置请求头（Content-Type等）
private HttpPost createHttpPost() {
HttpPost httpPost = new HttpPost(mPostUrl);
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
- httpPost.setHeader("AT", "1");
+ httpPost.setHeader("AT", "1"); // 自定义头，可能用于标识客户端类型
return httpPost;
}
+ // 读取响应内容：处理压缩（gzip/deflate）并转换为字符串
private String getResponseContent(HttpEntity entity) throws IOException {
String contentEncoding = null;
if (entity.getContentEncoding() != null) {
- contentEncoding = entity.getContentEncoding().getValue();
+ contentEncoding = entity.getContentEncoding().getValue(); // 获取编码方式
Log.d(TAG, "encoding: " + contentEncoding);
}
InputStream input = entity.getContent();
+ // 根据编码方式解压
if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {
input = new GZIPInputStream(entity.getContent());
} else if (contentEncoding != null && contentEncoding.equalsIgnoreCase("deflate")) {
@@ -307,6 +338,7 @@ public class GTaskClient {
}
try {
+ // 读取输入流并转换为字符串
InputStreamReader isr = new InputStreamReader(input);
BufferedReader br = new BufferedReader(isr);
StringBuilder sb = new StringBuilder();
@@ -323,33 +355,37 @@ public class GTaskClient {
}
}
+ // 发送POST请求：封装JSON请求并处理响应
private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
throw new ActionFailureException("not logged in");
}
- HttpPost httpPost = createHttpPost();
+ HttpPost httpPost = createHttpPost(); // 创建POST请求
try {
+ // 构建请求参数（将JSON作为"r"参数的值）
LinkedList list = new LinkedList();
list.add(new BasicNameValuePair("r", js.toString()));
+ // 编码为表单格式
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");
httpPost.setEntity(entity);
// execute the post
+ // 执行请求并获取响应
HttpResponse response = mHttpClient.execute(httpPost);
String jsString = getResponseContent(response.getEntity());
return new JSONObject(jsString);
- } catch (ClientProtocolException e) {
+ } catch (ClientProtocolException e) { // HTTP协议异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new NetworkFailureException("postRequest failed");
- } catch (IOException e) {
+ } catch (IOException e) { // IO异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new NetworkFailureException("postRequest failed");
- } catch (JSONException e) {
+ } catch (JSONException e) { // JSON解析异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("unable to convert response content to jsonobject");
@@ -360,21 +396,27 @@ public class GTaskClient {
}
}
+ // 创建远程任务：向Google任务服务发送创建任务请求
public void createTask(Task task) throws NetworkFailureException {
+ // 先提交之前的更新队列（避免冲突）
commitUpdate();
try {
JSONObject jsPost = new JSONObject();
JSONArray actionList = new JSONArray();
// action_list
+ // 添加创建任务的操作
actionList.put(task.getCreateAction(getActionId()));
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
// client_version
+ // 添加客户端版本（用于服务端验证）
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
// post
+ // 发送请求并获取响应
JSONObject jsResponse = postRequest(jsPost);
+ // 从响应中获取新创建任务的GID并设置到任务对象
JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
task.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID));
@@ -386,21 +428,27 @@ public class GTaskClient {
}
}
+ // 创建远程任务列表：向Google任务服务发送创建列表请求
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
+ // 先提交之前的更新队列
commitUpdate();
try {
JSONObject jsPost = new JSONObject();
JSONArray actionList = new JSONArray();
// action_list
+ // 添加创建列表的操作
actionList.put(tasklist.getCreateAction(getActionId()));
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
// client version
+ // 添加客户端版本
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
// post
+ // 发送请求并获取响应
JSONObject jsResponse = postRequest(jsPost);
+ // 从响应中获取新创建列表的GID并设置
JSONObject jsResult = (JSONObject) jsResponse.getJSONArray(
GTaskStringUtils.GTASK_JSON_RESULTS).get(0);
tasklist.setGid(jsResult.getString(GTaskStringUtils.GTASK_JSON_NEW_ID));
@@ -412,19 +460,22 @@ public class GTaskClient {
}
}
+ // 提交更新队列：将缓存的更新操作批量发送到服务端
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
try {
JSONObject jsPost = new JSONObject();
// action_list
+ // 设置更新操作列表
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, mUpdateArray);
// client_version
+ // 设置客户端版本
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
postRequest(jsPost);
- mUpdateArray = null;
+ mUpdateArray = null; // 清空队列
} catch (JSONException e) {
Log.e(TAG, e.toString());
e.printStackTrace();
@@ -433,10 +484,12 @@ public class GTaskClient {
}
}
+ // 添加更新节点到队列：将节点的更新操作加入缓存队列（批量提交）
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
// set max to 10 items
+ // 限制队列最大长度为10（避免单次请求过大）
if (mUpdateArray != null && mUpdateArray.length() > 10) {
commitUpdate();
}
@@ -447,6 +500,7 @@ public class GTaskClient {
}
}
+ // 移动任务：将任务从原列表移动到新列表（或列表内调整位置）
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@@ -456,17 +510,23 @@ public class GTaskClient {
JSONObject action = new JSONObject();
// action_list
+ // 设置操作类型为移动
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（调整位置）
if (preParent == curParent && task.getPriorSibling() != null) {
// put prioring_sibing_id only if moving within the tasklist and
// it is not the first one
action.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, task.getPriorSibling());
}
+ // 设置源列表和目标父节点
action.put(GTaskStringUtils.GTASK_JSON_SOURCE_LIST, preParent.getGid());
action.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT, curParent.getGid());
+
+ // 跨列表移动：设置目标列表
if (preParent != curParent) {
// put the dest_list only if moving between tasklists
action.put(GTaskStringUtils.GTASK_JSON_DEST_LIST, curParent.getGid());
@@ -486,6 +546,7 @@ public class GTaskClient {
}
}
+ // 删除远程节点：向服务端发送删除请求
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {
@@ -493,6 +554,7 @@ public class GTaskClient {
JSONArray actionList = new JSONArray();
// action_list
+ // 标记节点为已删除，并添加删除操作
node.setDeleted(true);
actionList.put(node.getUpdateAction(getActionId()));
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
@@ -509,6 +571,7 @@ public class GTaskClient {
}
}
+ // 获取远程任务列表：从服务端获取所有任务列表
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@@ -522,13 +585,13 @@ public class GTaskClient {
// get the task list
String resString = getResponseContent(response.getEntity());
- String jsBegin = "_setup(";
- String jsEnd = ")}";
+ String jsBegin = "_setup("; // 响应中任务列表的JS前缀
+ 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);
+ jsString = resString.substring(begin + jsBegin.length(), end); // 提取JS内容
}
JSONObject js = new JSONObject(jsString);
return js.getJSONObject("t").getJSONArray(GTaskStringUtils.GTASK_JSON_LISTS);
@@ -547,6 +610,7 @@ public class GTaskClient {
}
}
+ // 获取指定任务列表下的任务：从服务端获取某个列表的所有任务
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@@ -559,13 +623,16 @@ public class GTaskClient {
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_GETALL);
action.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, getActionId());
action.put(GTaskStringUtils.GTASK_JSON_LIST_ID, listGid);
+ // 不获取已删除任务
action.put(GTaskStringUtils.GTASK_JSON_GET_DELETED, false);
actionList.put(action);
jsPost.put(GTaskStringUtils.GTASK_JSON_ACTION_LIST, actionList);
// client_version
+ // 客户端版本
jsPost.put(GTaskStringUtils.GTASK_JSON_CLIENT_VERSION, mClientVersion);
+ // 发送请求并返回任务数组
JSONObject jsResponse = postRequest(jsPost);
return jsResponse.getJSONArray(GTaskStringUtils.GTASK_JSON_TASKS);
} catch (JSONException e) {
@@ -575,10 +642,12 @@ public class GTaskClient {
}
}
+ // 获取当前同步账户：返回登录的Google账户
public Account getSyncAccount() {
return mAccount;
}
+ // 重置更新队列：清空待提交的更新操作
public void resetUpdateArray() {
mUpdateArray = null;
}
diff --git a/src/notes/gtask/remote/GTaskManager.java b/src/notes/gtask/remote/GTaskManager.java
index d2b4082..9bc0565 100644
--- a/src/notes/gtask/remote/GTaskManager.java
+++ b/src/notes/gtask/remote/GTaskManager.java
@@ -47,21 +47,24 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
-
+/**
+ * Google任务同步管理器
+ * 负责本地Note与Google任务的同步逻辑
+ */
public class GTaskManager {
private static final String TAG = GTaskManager.class.getSimpleName();
- public static final int STATE_SUCCESS = 0;
+ public static final int STATE_SUCCESS = 0; //同步成功状态
- public static final int STATE_NETWORK_ERROR = 1;
+ public static final int STATE_NETWORK_ERROR = 1; //网络错误
- public static final int STATE_INTERNAL_ERROR = 2;
+ public static final int STATE_INTERNAL_ERROR = 2; //内部错误
- public static final int STATE_SYNC_IN_PROGRESS = 3;
+ public static final int STATE_SYNC_IN_PROGRESS = 3; //同步中
- public static final int STATE_SYNC_CANCELLED = 4;
+ public static final int STATE_SYNC_CANCELLED = 4; //取消同步
- private static GTaskManager mInstance = null;
+ private static GTaskManager mInstance = null; //单例实例
private Activity mActivity;
@@ -69,24 +72,25 @@ public class GTaskManager {
private ContentResolver mContentResolver;
- private boolean mSyncing;
+ private boolean mSyncing; //同步状态标识：是否正在同步
- private boolean mCancelled;
+ private boolean mCancelled; //是否已取消
- private HashMap mGTaskListHashMap;
+ private HashMap mGTaskListHashMap; //远程任务列表（key：任务列表GID）
- private HashMap mGTaskHashMap;
+ private HashMap mGTaskHashMap; //所有远程节点（任务/列表，key：节点GID）
- private HashMap mMetaHashMap;
+ private HashMap mMetaHashMap; //元数据（key：关联的任务GID）
- private TaskList mMetaList;
+ private TaskList mMetaList; //元数据列表
- private HashSet mLocalDeleteIdMap;
+ private HashSet mLocalDeleteIdMap; //记录需要从远程删除的本地笔记ID
- private HashMap mGidToNid;
+ private HashMap mGidToNid; //远程GID到本地笔记ID的映射关系
- private HashMap mNidToGid;
+ private HashMap mNidToGid; //本地笔记ID到远程GID的映射关系
+ //初始化所有集合和状态变量（单例模式防止外部实例化）
private GTaskManager() {
mSyncing = false;
mCancelled = false;
@@ -99,6 +103,7 @@ public class GTaskManager {
mNidToGid = new HashMap();
}
+ // 单例获取方法：保证全局唯一实例
public static synchronized GTaskManager getInstance() {
if (mInstance == null) {
mInstance = new GTaskManager();
@@ -106,20 +111,26 @@ public class GTaskManager {
return mInstance;
}
+ // 设置Activity上下文：用于后续登录时获取认证token
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity;
}
+ //协调本地与远程数据同步，返回同步状态
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;
+
+ //清空所有存储集合（避免上次同步残留数据）
mGTaskListHashMap.clear();
mGTaskHashMap.clear();
mMetaHashMap.clear();
@@ -128,8 +139,9 @@ public class GTaskManager {
mNidToGid.clear();
try {
+ // 获取GTaskClient实例
GTaskClient client = GTaskClient.getInstance();
- client.resetUpdateArray();
+ client.resetUpdateArray(); //重置客户端的更新队列
// login google task
if (!mCancelled) {
@@ -139,55 +151,61 @@ public class GTaskManager {
}
// get the task list from google
+ // 从远程获取任务列表并初始化（更新同步进度）
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
initGTaskList();
- // do content sync work
+ // do content sync work（更新同步进度）
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
syncContent();
- } catch (NetworkFailureException e) {
+ } catch (NetworkFailureException e) { // 捕获网络异常
Log.e(TAG, e.toString());
return STATE_NETWORK_ERROR;
- } catch (ActionFailureException e) {
+ } catch (ActionFailureException e) { // 捕获操作失败异常
Log.e(TAG, e.toString());
return STATE_INTERNAL_ERROR;
- } catch (Exception e) {
+ } catch (Exception e) { // 返回内部错误状态
Log.e(TAG, e.toString());
e.printStackTrace();
return STATE_INTERNAL_ERROR;
- } finally {
+ } finally { // 无论成功失败，清理资源
mGTaskListHashMap.clear();
mGTaskHashMap.clear();
mMetaHashMap.clear();
mLocalDeleteIdMap.clear();
mGidToNid.clear();
mNidToGid.clear();
- mSyncing = false;
+ mSyncing = false; // 标记为同步结束
}
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
}
+ // 初始化远程任务列表：从Google服务器获取任务列表和元数据
private void initGTaskList() throws NetworkFailureException {
+ // 若同步已取消，直接返回
if (mCancelled)
return;
- GTaskClient client = GTaskClient.getInstance();
+ GTaskClient client = GTaskClient.getInstance(); // 获取网络客户端
try {
+ // 1. 获取所有远程任务列表（JSON数组）
JSONArray jsTaskLists = client.getTaskLists();
- // init meta list first
+ // init meta list first（因为元数据关联其他任务）
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)) {
+ // 检查是否为元数据列表（名称符合特定前缀+后缀）
+ if (name.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
mMetaList = new TaskList();
+
+ //用远程JSON初始化元数据列表
mMetaList.setContentByRemoteJSON(object);
- // load meta data
+ // load meta data（元数据本身以任务形式存储）
JSONArray jsMetas = client.getTaskList(gid);
for (int j = 0; j < jsMetas.length(); j++) {
object = (JSONObject) jsMetas.getJSONObject(j);
@@ -196,6 +214,7 @@ public class GTaskManager {
if (metaData.isWorthSaving()) {
mMetaList.addChildTask(metaData);
if (metaData.getGid() != null) {
+ // 存储元数据（key：关联的任务GID）
mMetaHashMap.put(metaData.getRelatedGid(), metaData);
}
}
@@ -204,26 +223,29 @@ public class GTaskManager {
}
// create meta list if not existed
+ // 3. 若元数据列表不存在，则创建一个
if (mMetaList == null) {
mMetaList = new TaskList();
mMetaList.setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX
- + GTaskStringUtils.FOLDER_META);
- GTaskClient.getInstance().createTaskList(mMetaList);
+ + GTaskStringUtils.FOLDER_META); // 设置名称
+ GTaskClient.getInstance().createTaskList(mMetaList); // 调用客户端创建列表
}
// init task list
+ // 4. 初始化普通任务列表（排除元数据列表）
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);
+ tasklist.setContentByRemoteJSON(object); // 用远程JSON初始化列表
+ mGTaskListHashMap.put(gid, tasklist); // 存入任务列表集合
+ mGTaskHashMap.put(gid, tasklist); // 同时存入全局节点集合
// load tasks
JSONArray jsTasks = client.getTaskList(gid);
@@ -231,27 +253,28 @@ public class GTaskManager {
object = (JSONObject) jsTasks.getJSONObject(j);
gid = object.getString(GTaskStringUtils.GTASK_JSON_ID);
Task task = new Task();
- task.setContentByRemoteJSON(object);
+ task.setContentByRemoteJSON(object); // 用远程JSON初始化任务
if (task.isWorthSaving()) {
- task.setMetaInfo(mMetaHashMap.get(gid));
+ task.setMetaInfo(mMetaHashMap.get(gid)); // 关联元数据
tasklist.addChildTask(task);
- mGTaskHashMap.put(gid, task);
+ mGTaskHashMap.put(gid, task); // 存入全局节点集合
}
}
}
}
- } catch (JSONException e) {
+ } catch (JSONException e) { // 处理JSON解析异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("initGTaskList: handing JSONObject failed");
}
}
+ // 同步内容：协调本地与远程的任务/列表数据（核心同步逻辑）
private void syncContent() throws NetworkFailureException {
- int syncType;
- Cursor c = null;
- String gid;
- Node node;
+ int syncType; // 同步类型（新增/删除/更新等）
+ Cursor c = null; // 数据库查询游标
+ String gid; // 远程GID
+ Node node; // 远程节点
mLocalDeleteIdMap.clear();
@@ -260,20 +283,23 @@ public class GTaskManager {
}
// for local deleted note
+ // 1. 处理本地已删除的笔记（在回收站中的非系统类型笔记）
try {
+ // 查询条件：不是系统类型+父ID是回收站
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)
+ String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLDER)
}, 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);
+ gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取笔记关联的远程GID
+ node = mGTaskHashMap.get(gid); // 从远程节点集合中查找对应节点
+ if (node != null) { // 若远程存在该节点，需要删除远程节点
+ mGTaskHashMap.remove(gid); // 从本地缓存移除
+ doContentSync(Node.SYNC_ACTION_DEL_REMOTE, node, c); // 执行远程删除
}
+ // 记录本地已删除的笔记ID（后续会从本地彻底删除）
mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
}
} else {
@@ -287,32 +313,43 @@ public class GTaskManager {
}
// sync folder first
+ // 2. 优先同步文件夹（任务列表）
syncFolder();
// for note existing in database
+ // 3. 处理本地已存在的普通笔记（非回收站中的笔记类型）
try {
+ // 查询条件：Note类型 + 父ID不是回收站
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)
+ String.valueOf(Notes.TYPE_NOTE), String.valueOf(Notes.ID_TRASH_FOLDER)
}, NoteColumns.TYPE + " DESC");
if (c != null) {
while (c.moveToNext()) {
- gid = c.getString(SqlNote.GTASK_ID_COLUMN);
+ gid = c.getString(SqlNote.GTASK_ID_COLUMN); // 获取关联的远程GID
node = mGTaskHashMap.get(gid);
+
+ // 远程存在对应节点
if (node != null) {
- mGTaskHashMap.remove(gid);
+ mGTaskHashMap.remove(gid); // 从本地缓存移除
+
+ // 记录GID与本地ID的映射关系
mGidToNid.put(gid, c.getLong(SqlNote.ID_COLUMN));
mNidToGid.put(c.getLong(SqlNote.ID_COLUMN), gid);
- syncType = node.getSyncAction(c);
- } else {
+ syncType = node.getSyncAction(c); // 计算同步类型（根据本地与远程的修改时间等）
+ }
+
+ // 远程不存在对应节点
+ else {
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
- // local add
+ // local add 本地GID为空：本地新增，需要同步到远程
syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else {
- // remote delete
+ // remote delete 本地有GID但远程无：远程已删除，需要删除本地
syncType = Node.SYNC_ACTION_DEL_LOCAL;
}
}
+ // 执行同步操作
doContentSync(syncType, node, c);
}
} else {
@@ -327,16 +364,20 @@ public class GTaskManager {
}
// go through remaining items
+ // 4. 处理远程存在但本地不存在的节点（需要同步到本地）
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 can be set by another thread, so we neet to check one by
// one
// clear local delete table
+ // 5. 清理本地已删除的笔记（若未取消同步）
if (!mCancelled) {
if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
throw new ActionFailureException("failed to batch-delete local deleted notes");
@@ -344,6 +385,7 @@ public class GTaskManager {
}
// refresh local sync id
+ // 6. 提交更新并刷新本地同步ID（若未取消）
if (!mCancelled) {
GTaskClient.getInstance().commitUpdate();
refreshLocalSyncId();
@@ -351,6 +393,7 @@ public class GTaskManager {
}
+ // 同步文件夹（任务列表）：处理本地与远程的文件夹数据
private void syncFolder() throws NetworkFailureException {
Cursor c = null;
String gid;
@@ -362,22 +405,30 @@ public class GTaskManager {
}
// for root folder
+ // 1. 同步根文件夹
try {
+ // 查询根文件夹（ID固定为Notes.ID_ROOT_FOLDER）
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);
// for system folder, only update remote name if necessary
+ // 系统文件夹只在名称不匹配时更新远程
if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
- } else {
+ }
+ // 远程不存在，需要新增到远程
+ else {
doContentSync(Node.SYNC_ACTION_ADD_REMOTE, node, c);
}
} else {
@@ -391,7 +442,9 @@ public class GTaskManager {
}
// for call-note folder
+ // 2. 同步通话记录文件夹
try {
+ // 查询通话记录文件夹（ID固定为Notes.ID_CALL_RECORD_FOLDER）
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
@@ -400,12 +453,14 @@ public class GTaskManager {
if (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_CALL_RECORD_FOLDER);
mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
// for system folder, only update remote name if
// necessary
+ // 系统文件夹只在名称不匹配时更新远程
if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_CALL_NOTE))
@@ -425,10 +480,12 @@ public class GTaskManager {
}
// for local existing folders
+ // 3. 同步本地已存在的普通文件夹（非系统类型，非回收站）
try {
+ // 查询条件：文件夹 + 父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)
+ String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLDER)
}, NoteColumns.TYPE + " DESC");
if (c != null) {
while (c.moveToNext()) {
@@ -442,9 +499,11 @@ public class GTaskManager {
} else {
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
// local add
+ // 本地GID为空：本地新增，同步到远程
syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else {
// remote delete
+ // 本地有GID但远程无：远程已删除，删除本地
syncType = Node.SYNC_ACTION_DEL_LOCAL;
}
}
@@ -461,21 +520,24 @@ public class GTaskManager {
}
// for remote add folders
+ // 4. 处理远程存在但本地不存在的文件夹（同步到本地）
Iterator> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = iter.next();
gid = entry.getKey();
node = entry.getValue();
- if (mGTaskHashMap.containsKey(gid)) {
+ if (mGTaskHashMap.containsKey(gid)) { // 若缓存中存在（未被处理）
mGTaskHashMap.remove(gid);
- doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
+ doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); // 本地新增
}
}
+ // 若未取消，提交所有文件夹相关的远程更新
if (!mCancelled)
GTaskClient.getInstance().commitUpdate();
}
+ // 执行具体同步操作：根据同步类型处理本地/远程数据
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -483,52 +545,57 @@ public class GTaskManager {
MetaData meta;
switch (syncType) {
- case Node.SYNC_ACTION_ADD_LOCAL:
+ case Node.SYNC_ACTION_ADD_LOCAL: // 远程新增，同步到本地
addLocalNode(node);
break;
- case Node.SYNC_ACTION_ADD_REMOTE:
+ case Node.SYNC_ACTION_ADD_REMOTE: // 本地新增，同步到远程
addRemoteNode(node, c);
break;
- case Node.SYNC_ACTION_DEL_LOCAL:
- meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
+ case Node.SYNC_ACTION_DEL_LOCAL: // 远程已删除，删除本地
+ meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); // 获取关联元数据
if (meta != null) {
- GTaskClient.getInstance().deleteNode(meta);
+ GTaskClient.getInstance().deleteNode(meta); // 删除远程元数据
}
- mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
+ mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); // 记录本地ID待删除
break;
- case Node.SYNC_ACTION_DEL_REMOTE:
+ 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:
+ case Node.SYNC_ACTION_UPDATE_LOCAL: // 远程更新，同步到本地
updateLocalNode(node, c);
break;
- case Node.SYNC_ACTION_UPDATE_REMOTE:
+ case Node.SYNC_ACTION_UPDATE_REMOTE: // 本地更新，同步到远程
updateRemoteNode(node, c);
break;
- case Node.SYNC_ACTION_UPDATE_CONFLICT:
+ 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:
+ case Node.SYNC_ACTION_NONE: // 无同步操作
break;
- case Node.SYNC_ACTION_ERROR:
+ 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;
+
+ // 节点是任务列表（文件夹）
if (node instanceof TaskList) {
+ // 特殊文件夹处理：根目录或通话记录文件夹
if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
@@ -537,13 +604,14 @@ public class GTaskManager {
sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
} else {
sqlNote = new SqlNote(mContext);
- sqlNote.setContent(node.getLocalJSONFromContent());
+ sqlNote.setContent(node.getLocalJSONFromContent()); // 用远程数据构建本地JSON
sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
}
- } else {
+ } else { // 节点是任务（笔记）
sqlNote = new SqlNote(mContext);
- JSONObject js = node.getLocalJSONFromContent();
+ JSONObject js = node.getLocalJSONFromContent(); // 用远程数据构建本地JSON
try {
+ // 处理笔记ID冲突：若远程数据中的ID已在本地存在，移除ID（让本地自动生成）
if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.has(NoteColumns.ID)) {
@@ -555,6 +623,7 @@ public class GTaskManager {
}
}
+ // 处理数据ID冲突：同理移除已存在的ID
if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
for (int i = 0; i < dataArray.length(); i++) {
@@ -576,26 +645,31 @@ public class GTaskManager {
}
sqlNote.setContent(js);
+ // 获取父文件夹的本地ID（通过GID映射）
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.setParentId(parentId.longValue());
+ sqlNote.setParentId(parentId.longValue()); // 设置父目录ID
}
// create the local node
+ // 提交本地新增
sqlNote.setGtaskId(node.getGid());
sqlNote.commit(false);
// update gid-nid mapping
+ // 更新映射关系
mGidToNid.put(node.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), node.getGid());
// update meta
+ // 更新远程元数据
updateRemoteMeta(node.getGid(), sqlNote);
}
+ // 更新本地节点：将远程更新同步到本地
private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -604,8 +678,10 @@ public class GTaskManager {
SqlNote sqlNote;
// update the note locally
sqlNote = new SqlNote(mContext, c);
+ // 用远程数据更新本地内容
sqlNote.setContent(node.getLocalJSONFromContent());
+ // 确定父目录ID（任务的父是列表，列表的父是根目录）
Long parentId = (node instanceof Task) ? mGidToNid.get(((Task) node).getParent().getGid())
: new Long(Notes.ID_ROOT_FOLDER);
if (parentId == null) {
@@ -613,12 +689,14 @@ public class GTaskManager {
throw new ActionFailureException("cannot update local node");
}
sqlNote.setParentId(parentId.longValue());
- sqlNote.commit(true);
+ sqlNote.commit(true); // 提交更新（覆盖本地数据）
// update meta info
+ // 更新远程元数据
updateRemoteMeta(node.getGid(), sqlNote);
}
+ // 远程新增节点：将本地节点同步到远程
private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@@ -628,26 +706,36 @@ public class GTaskManager {
Node n;
// update remotely
+ /**
+ * 区分笔记和文件夹，执行不同远程创建逻辑
+ * 本地节点是笔记（对应远程任务）
+ */
if (sqlNote.isNoteType()) {
Task task = new Task();
- task.setContentByLocalJSON(sqlNote.getContent());
+ task.setContentByLocalJSON(sqlNote.getContent()); // 用本地JSON初始化远程任务
+ // 获取父文件夹的远程GID（通过本地ID映射）
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");
}
+ // 将任务添加到父列表
mGTaskListHashMap.get(parentGid).addChildTask(task);
+ // 调用客户端创建远程任务
GTaskClient.getInstance().createTask(task);
n = (Node) task;
// add meta
updateRemoteMeta(task.getGid(), sqlNote);
- } else {
+ }
+ // 本地节点是文件夹（对应远程任务列表）
+ else {
TaskList tasklist = null;
// we need to skip folder if it has already existed
+ // 生成文件夹名称（特定前缀+文件夹标识）
String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
folderName += GTaskStringUtils.FOLDER_DEFAULT;
@@ -656,12 +744,14 @@ public class GTaskManager {
else
folderName += sqlNote.getSnippet();
+ // 检查远程是否已存在同名文件夹（避免重复创建）
Iterator> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry entry = iter.next();
String gid = entry.getKey();
TaskList list = entry.getValue();
+ // 已存在同名文件夹
if (list.getName().equals(folderName)) {
tasklist = list;
if (mGTaskHashMap.containsKey(gid)) {
@@ -672,6 +762,7 @@ public class GTaskManager {
}
// no match we can add now
+ // 若远程不存在，则创建新文件夹
if (tasklist == null) {
tasklist = new TaskList();
tasklist.setContentByLocalJSON(sqlNote.getContent());
@@ -682,35 +773,40 @@ public class GTaskManager {
}
// update local note
+ // 更新本地节点的远程GID
sqlNote.setGtaskId(n.getGid());
- sqlNote.commit(false);
- sqlNote.resetLocalModified();
- sqlNote.commit(true);
+ sqlNote.commit(false); // 保存GID
+ sqlNote.resetLocalModified(); // 重置本地修改标记（避免重复同步）
+ sqlNote.commit(true); // 提交修改
// gid-id mapping
+ // 更新映射关系
mGidToNid.put(n.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), n.getGid());
}
+ // 更新远程节点：将本地更新同步到远程
private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
}
- SqlNote sqlNote = new SqlNote(mContext, c);
+ SqlNote sqlNote = new SqlNote(mContext, c); // 获取本地节点数据
// update remotely
node.setContentByLocalJSON(sqlNote.getContent());
- GTaskClient.getInstance().addUpdateNode(node);
+ GTaskClient.getInstance().addUpdateNode(node); // 将更新加入客户端的更新队列
// update meta
+ // 更新远程元数据
updateRemoteMeta(node.getGid(), sqlNote);
// move task if necessary
if (sqlNote.isNoteType()) {
Task task = (Task) node;
- TaskList preParentList = task.getParent();
+ TaskList preParentList = task.getParent(); // 原父列表
+ // 获取当前父文件夹的远程GID（通过本地ID映射）
String curParentGid = mNidToGid.get(sqlNote.getParentId());
if (curParentGid == null) {
Log.e(TAG, "cannot find task's parent tasklist");
@@ -718,6 +814,7 @@ public class GTaskManager {
}
TaskList curParentList = mGTaskListHashMap.get(curParentGid);
+ // 若父列表变化，执行移动操作
if (preParentList != curParentList) {
preParentList.removeChildTask(task);
curParentList.addChildTask(task);
@@ -730,13 +827,15 @@ public class GTaskManager {
sqlNote.commit(true);
}
+ // 更新远程元数据：同步本地笔记的元数据到远程
private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
+ // 仅处理笔记类型（文件夹无元数据）
if (sqlNote != null && sqlNote.isNoteType()) {
MetaData metaData = mMetaHashMap.get(gid);
- if (metaData != null) {
+ if (metaData != null) { // 元数据已存在，更新内容
metaData.setMeta(gid, sqlNote.getContent());
- GTaskClient.getInstance().addUpdateNode(metaData);
- } else {
+ GTaskClient.getInstance().addUpdateNode(metaData); // 加入更新队列
+ } else { // 元数据不存在，创建新的
metaData = new MetaData();
metaData.setMeta(gid, sqlNote.getContent());
mMetaList.addChildTask(metaData);
@@ -746,12 +845,14 @@ public class GTaskManager {
}
}
+ // 刷新本地同步ID：将远程的最后修改时间同步到本地（用于后续同步对比）
private void refreshLocalSyncId() throws NetworkFailureException {
if (mCancelled) {
return;
}
// get the latest gtask list
+ // 重新获取最新的远程节点数据
mGTaskHashMap.clear();
mGTaskListHashMap.clear();
mMetaHashMap.clear();
@@ -759,16 +860,18 @@ public class GTaskManager {
Cursor c = null;
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)
+ String.valueOf(Notes.TYPE_SYSTEM), String.valueOf(Notes.ID_TRASH_FOLDER)
}, NoteColumns.TYPE + " DESC");
if (c != null) {
- while (c.moveToNext()) {
+ while (c.moveToNext()) { // 遍历本地节点
String gid = c.getString(SqlNote.GTASK_ID_COLUMN);
Node node = mGTaskHashMap.get(gid);
if (node != null) {
mGTaskHashMap.remove(gid);
+ // 更新本地节点的同步ID（远程最后修改时间）
ContentValues values = new ContentValues();
values.put(NoteColumns.SYNC_ID, node.getLastModified());
mContentResolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
@@ -790,6 +893,7 @@ public class GTaskManager {
}
}
+ // 获取同步账户：返回当前登录的Google账户名
public String getSyncAccount() {
return GTaskClient.getInstance().getSyncAccount().name;
}
diff --git a/src/notes/gtask/remote/GTaskSyncService.java b/src/notes/gtask/remote/GTaskSyncService.java
index cca36f7..ee3650b 100644
--- a/src/notes/gtask/remote/GTaskSyncService.java
+++ b/src/notes/gtask/remote/GTaskSyncService.java
@@ -23,6 +23,10 @@ import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
+/**
+ * 继承Service类（Android系统）
+ * 用于处理GTask的同步逻辑，如启动/取消同步、发送同步状态广播等
+ */
public class GTaskSyncService extends Service {
public final static String ACTION_STRING_NAME = "sync_action_type";
@@ -32,27 +36,34 @@ public class GTaskSyncService extends Service {
public final static int ACTION_INVALID = 2;
+ //同步服务发送广播的action名称（用于标识该广播的唯一标识）
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 GTaskASyncTask mSyncTask = null; //当前的同步任务实例
- private static String mSyncProgress = "";
+ private static String mSyncProgress = ""; //同步进度的字符串（记录和传递进度信息）
+ //启动同步任务
private void startSync() {
+ //当前没有同步任务执行，创建新任务
+
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
+ //任务完成时的回调方法：清理任务实例，发送空进度广播，停止当前服务
public void onComplete() {
mSyncTask = null;
sendBroadcast("");
stopSelf();
}
});
- sendBroadcast("");
- mSyncTask.execute();
+ sendBroadcast(""); // 发送初始广播（此时任务已创建，通知外界同步开始）
+ mSyncTask.execute(); //执行
}
}
@@ -67,10 +78,27 @@ public class GTaskSyncService extends Service {
mSyncTask = null;
}
+ /**
+ * 处理启动服务的意图
+ * 解析意图中的动作类型，执行对应的启动/取消同步操作
+ * @param intent The Intent supplied to {@link Context#startService},
+ * as given. This may be null if the service is being restarted after
+ * its process has gone away, and it had previously returned anything
+ * except {@link #START_STICKY_COMPATIBILITY}.
+ * @param flags 启动标志
+ * @param startId A unique integer representing this specific request to
+ * start. Use with {@link #stopSelfResult(int)}.
+ *
+ * @return 服务的启动模式
+ */
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
+ // 获取意图中携带的额外数据（键值对集合）
Bundle bundle = intent.getExtras();
+
+ // 检查bundle是否存在且包含动作类型的键
if (bundle != null && bundle.containsKey(ACTION_STRING_NAME)) {
+ //根据动作类型执行对应操作
switch (bundle.getInt(ACTION_STRING_NAME, ACTION_INVALID)) {
case ACTION_START_SYNC:
startSync();
@@ -83,9 +111,10 @@ public class GTaskSyncService extends Service {
}
return START_STICKY;
}
- return super.onStartCommand(intent, flags, startId);
+ return super.onStartCommand(intent, flags, startId); //没有有效数据，则调用父类方法
}
+ //系统内存不足时的回调方法
@Override
public void onLowMemory() {
if (mSyncTask != null) {
@@ -97,6 +126,7 @@ public class GTaskSyncService extends Service {
return null;
}
+ //向外界发送包含同步状态（是否正在同步）和进度消息的广播
public void sendBroadcast(String msg) {
mSyncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@@ -105,23 +135,32 @@ public class GTaskSyncService extends Service {
sendBroadcast(intent);
}
+ //供外部（如界面）调用，触发同步操作
public static void startSync(Activity activity) {
+ // 设置GTaskManager的上下文为当前Activity
GTaskManager.getInstance().setActivityContext(activity);
+
+ // 创建启动GTaskSyncService的意图，指定服务类
Intent intent = new Intent(activity, GTaskSyncService.class);
+
+ // 在意图中添加"启动同步"的动作类型
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
activity.startService(intent);
}
+ //供外部（如界面）调用，取消正在进行的同步操作
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);
}
+ //断是否正在同步
public static boolean isSyncing() {
return mSyncTask != null;
}
+ //获取当前同步进度字符串
public static String getProgressString() {
return mSyncProgress;
}
diff --git a/src/notes/model/Note.java b/src/notes/model/Note.java
index 6706cf6..ecf9c21 100644
--- a/src/notes/model/Note.java
+++ b/src/notes/model/Note.java
@@ -33,13 +33,24 @@ import net.micode.notes.data.Notes.TextNote;
import java.util.ArrayList;
-
+/**
+ * 笔记数据模型类，负责的底层数据操作的模型类，
+ * 封装了笔记的基础数据（文本、通话记录）和核心属性（修改时间等）
+ * 与ContentProvider交互，实现笔记数据的创建、更新、同步等底层逻辑，
+ * 仅处理数据存储逻辑，不包含UI交互或业务判断,不包含业务逻辑
+ */
public class Note {
- private ContentValues mNoteDiffValues;
- private NoteData mNoteData;
+ private ContentValues mNoteDiffValues; //存储Note属性变化，修改时间等
+ private NoteData mNoteData; //封装Note具体数据，文本内容、通话记录等
private static final String TAG = "Note";
+
/**
* Create a new note id for adding a new note to databases
+ * 静态同步方法：创建新笔记并返回其ID
+ * 作用：在数据库中初始化一条笔记记录，为后续添加内容（文本/通话记录）做准备
+ * @param context 上下文（用于获取内容解析器）
+ * @param folderId 笔记所属文件夹ID（用于归类）
+ * @return 新创建的笔记ID
*/
public static synchronized long getNewNoteId(Context context, long folderId) {
// Create a new note in the database
@@ -65,6 +76,7 @@ public class Note {
return noteId;
}
+ //初始化Note数据容器，存储属性变化和具体数据
public Note() {
mNoteDiffValues = new ContentValues();
mNoteData = new NoteData();
@@ -76,10 +88,12 @@ public class Note {
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
+ //设置Note的文本数据（如笔记内容）
public void setTextData(String key, String value) {
mNoteData.setTextData(key, value);
}
+ //设置文本数据的ID（用于更新已有文本数据时定位记录）
public void setTextDataId(long id) {
mNoteData.setTextDataId(id);
}
@@ -96,10 +110,12 @@ public class Note {
mNoteData.setCallData(key, value);
}
+ //是否有本地修改
public boolean isLocalModified() {
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
}
+ //同步Note数据到数据库
public boolean syncNote(Context context, long noteId) {
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
@@ -114,6 +130,7 @@ public class Note {
* {@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) {
@@ -122,6 +139,7 @@ public class Note {
}
mNoteDiffValues.clear();
+ //同步具体数据（文本/通话记录），若数据有修改且同步失败，返回false
if (mNoteData.isLocalModified()
&& (mNoteData.pushIntoContentResolver(context, noteId) == null)) {
return false;
@@ -130,14 +148,18 @@ public class Note {
return true;
}
+ /**内部类
+ * 管理笔记的具体数据（文本内容、通话记录）
+ * 封装文本和通话数据的存储、修改、同步逻辑，与Note类协同工作
+ */
private class NoteData {
- private long mTextDataId;
+ private long mTextDataId;// 文本数据在数据库中的ID（0表示未创建）
- private ContentValues mTextDataValues;
+ private ContentValues mTextDataValues; // 存储文本数据的变化
- private long mCallDataId;
+ private long mCallDataId; // 通话记录数据在数据库中的ID（0表示未创建）
- private ContentValues mCallDataValues;
+ private ContentValues mCallDataValues; // 存储通话数据的变化（如号码更新）
private static final String TAG = "NoteData";
@@ -178,24 +200,39 @@ public class Note {
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
+ /**
+ * 将文本/通话数据的变化同步到数据库
+ * 若数据未创建（ID=0）则插入新记录；若已创建（ID>0）则更新记录
+ * @param context 上下文
+ * @param noteId 所属笔记ID（关联数据到具体笔记）
+ * @return 同步成功返回笔记Uri；失败返回null
+ */
Uri pushIntoContentResolver(Context context, long noteId) {
/**
* Check for safety
*/
+ // 校验笔记ID有效性
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) {
+ // 插入数据到ContentProvider，获取返回的Uri
mTextDataValues.put(DataColumns.MIME_TYPE, TextNote.CONTENT_ITEM_TYPE);
Uri uri = context.getContentResolver().insert(Notes.CONTENT_DATA_URI,
mTextDataValues);
try {
+ // 从Uri解析新插入的文本数据ID并存储
setTextDataId(Long.valueOf(uri.getPathSegments().get(1)));
} catch (NumberFormatException e) {
Log.e(TAG, "Insert new text data fail with noteId" + noteId);
@@ -203,14 +240,17 @@ public class Note {
return null;
}
} else {
+ // 文本数据已存在：更新记录
+ // 构建更新操作（指定数据ID对应的Uri）
builder = ContentProviderOperation.newUpdate(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mTextDataId));
- builder.withValues(mTextDataValues);
- operationList.add(builder.build());
+ builder.withValues(mTextDataValues); // 设置要更新的内容
+ operationList.add(builder.build()); // 添加到批量操作列表
}
mTextDataValues.clear();
}
+ //处理通话数据同步（逻辑同处理文本数据同步）
if(mCallDataValues.size() > 0) {
mCallDataValues.put(DataColumns.NOTE_ID, noteId);
if (mCallDataId == 0) {
@@ -233,21 +273,25 @@ public class Note {
mCallDataValues.clear();
}
+ //执行批量更新操作
if (operationList.size() > 0) {
try {
+ // 应用批量操作到ContentProvider
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) {
+ // 远程异常（如ContentProvider断开连接）
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;
+ return null; // 无批量操作需执行（如仅插入了新数据，未更新）
}
}
}
diff --git a/src/notes/model/WorkingNote.java b/src/notes/model/WorkingNote.java
index be081e4..dad51b7 100644
--- a/src/notes/model/WorkingNote.java
+++ b/src/notes/model/WorkingNote.java
@@ -31,23 +31,32 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.tool.ResourceParser.NoteBgResources;
-
+/**
+ * 与Note类之间是组合关系，WorkingNote中的所有底层数据操作（如同步、属性变更记录）均通过mNote完成
+ * 专注于业务逻辑处理，封装用户可见的业务属性，如内容、背景色等
+ */
public class WorkingNote {
// Note for the working note
private Note mNote;
// Note Id
private long mNoteId;
// Note content
- private String mContent;
+ private String mContent; //笔记模式，如普通模式、清单模式
// Note mode
private int mMode;
private long mAlertDate;
+ private double mAlertLatitude;
+ private double mAlertLongitude;
+ private float mAlertRadius;
+ private String mAlertLocationName;
private long mModifiedDate;
private int mBgColorId;
+ private String mTag;
+
private int mWidgetId;
private int mWidgetType;
@@ -62,6 +71,7 @@ public class WorkingNote {
private NoteSettingChangedListener mNoteSettingStatusListener;
+ //指定查询Data表时需要返回的字段
public static final String[] DATA_PROJECTION = new String[] {
DataColumns.ID,
DataColumns.CONTENT,
@@ -72,13 +82,19 @@ public class WorkingNote {
DataColumns.DATA4,
};
+ //指定查询Note表时需要返回的字段
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
+ NoteColumns.MODIFIED_DATE,
+ NoteColumns.ALERT_LATITUDE,
+ NoteColumns.ALERT_LONGITUDE,
+ NoteColumns.ALERT_RADIUS,
+ NoteColumns.ALERT_LOCATION_NAME,
+ NoteColumns.TAG
};
private static final int DATA_ID_COLUMN = 0;
@@ -100,11 +116,20 @@ public class WorkingNote {
private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
+ private static final int NOTE_ALERT_LATITUDE_COLUMN = 6;
+ private static final int NOTE_ALERT_LONGITUDE_COLUMN = 7;
+ private static final int NOTE_ALERT_RADIUS_COLUMN = 8;
+ private static final int NOTE_ALERT_LOCATION_NAME_COLUMN = 9;
+ private static final int NOTE_TAG_COLUMN = 10;
// New note construct
private WorkingNote(Context context, long folderId) {
mContext = context;
mAlertDate = 0;
+ mAlertLatitude = 0;
+ mAlertLongitude = 0;
+ mAlertRadius = 0;
+ mAlertLocationName = "";
mModifiedDate = System.currentTimeMillis();
mFolderId = folderId;
mNote = new Note();
@@ -124,28 +149,39 @@ public class WorkingNote {
loadNote();
}
+ //从数据库加载Note的基本信息(从Note表查询)
private void loadNote() {
+ //构建查询URI
Cursor cursor = mContext.getContentResolver().query(
- ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
- null, null);
+ 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);
+ mFolderId = cursor.getLong(NOTE_PARENT_ID_COLUMN); //文件夹ID
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);
+ mAlertLatitude = cursor.getDouble(NOTE_ALERT_LATITUDE_COLUMN);
+ mAlertLongitude = cursor.getDouble(NOTE_ALERT_LONGITUDE_COLUMN);
+ mAlertRadius = cursor.getFloat(NOTE_ALERT_RADIUS_COLUMN);
+ mAlertLocationName = cursor.getString(NOTE_ALERT_LOCATION_NAME_COLUMN);
+ mTag = cursor.getString(NOTE_TAG_COLUMN);
}
cursor.close();
} else {
Log.e(TAG, "No note with id:" + mNoteId);
throw new IllegalArgumentException("Unable to find note with id " + mNoteId);
}
- loadNoteData();
+ loadNoteData(); //继续加载笔记的详细数据（从Data表查询）
}
+ //从数据库加载笔记的详细数据（从Data表查询）
private void loadNoteData() {
Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
DataColumns.NOTE_ID + "=?", new String[] {
@@ -156,11 +192,16 @@ public class WorkingNote {
if (cursor.moveToFirst()) {
do {
String type = cursor.getString(DATA_MIME_TYPE_COLUMN);
+
+ //如果是text类型
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)) {
+ }
+
+ //如果是通话记录类型
+ else if (DataConstants.CALL_NOTE.equals(type)) {
mNote.setCallDataId(cursor.getLong(DATA_ID_COLUMN));
} else {
Log.d(TAG, "Wrong note type with type:" + type);
@@ -174,6 +215,7 @@ public class WorkingNote {
}
}
+ //创建空Note
public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
int widgetType, int defaultBgColorId) {
WorkingNote note = new WorkingNote(context, folderId);
@@ -183,19 +225,24 @@ public class WorkingNote {
return note;
}
+ //加载已有Note
public static WorkingNote load(Context context, long id) {
return new WorkingNote(context, id, 0);
}
+ //保存Note到数据库（同步方法）
public synchronized boolean saveNote() {
if (isWorthSaving()) {
+ // 若笔记不存在于数据库（新笔记）
if (!existInDatabase()) {
+ // 获取新笔记ID（若失败则返回0）
if ((mNoteId = Note.getNewNoteId(mContext, mFolderId)) == 0) {
Log.e(TAG, "Create new note fail with id:" + mNoteId);
return false;
}
}
+ // 通过Note对象同步数据到数据库
mNote.syncNote(mContext, mNoteId);
/**
@@ -217,6 +264,7 @@ public class WorkingNote {
}
private boolean isWorthSaving() {
+ //若已删除、（新笔记且内容为空）、（已存在且无本地修改），则无需保存
if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
|| (existInDatabase() && !mNote.isLocalModified())) {
return false;
@@ -229,24 +277,32 @@ public class WorkingNote {
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;
@@ -257,6 +313,7 @@ public class WorkingNote {
}
}
+ // 设置清单模式（切换普通/清单模式）
public void setCheckListMode(int mode) {
if (mMode != mode) {
if (mNoteSettingStatusListener != null) {
@@ -267,6 +324,7 @@ public class WorkingNote {
}
}
+ // 设置小部件类型
public void setWidgetType(int type) {
if (type != mWidgetType) {
mWidgetType = type;
@@ -274,6 +332,7 @@ public class WorkingNote {
}
}
+ //设置小部件ID
public void setWidgetId(int id) {
if (id != mWidgetId) {
mWidgetId = id;
@@ -281,6 +340,62 @@ public class WorkingNote {
}
}
+ //获取笔记标题（第一行）
+ public String getTitle() {
+ if (TextUtils.isEmpty(mContent)) {
+ return "";
+ }
+ int firstLineEnd = mContent.indexOf('\n');
+ if (firstLineEnd == -1) {
+ // 如果只有一行，全部作为标题
+ return mContent;
+ }
+ return mContent.substring(0, firstLineEnd);
+ }
+
+ //获取去掉标题后的正文内容
+ public String getContentWithoutTitle() {
+ if (TextUtils.isEmpty(mContent)) {
+ return "";
+ }
+ int firstLineEnd = mContent.indexOf('\n');
+ if (firstLineEnd == -1) {
+ // 如果只有一行，正文为空
+ return "";
+ }
+ return mContent.substring(firstLineEnd + 1);
+ }
+
+ //智能推荐标题：根据正文内容生成推荐标题
+ public String generateSmartTitle(String content) {
+ if (TextUtils.isEmpty(content)) {
+ return "";
+ }
+
+ // 去掉换行符，取前50个字符作为推荐标题
+ String cleanContent = content.replace('\n', ' ').trim();
+ if (cleanContent.length() <= 50) {
+ return cleanContent;
+ }
+ return cleanContent.substring(0, 50) + "...";
+ }
+
+ //设置标题和正文
+ public void setTitleAndContent(String title, String content) {
+ String fullContent;
+ if (TextUtils.isEmpty(title) && TextUtils.isEmpty(content)) {
+ fullContent = "";
+ } else if (TextUtils.isEmpty(content)) {
+ fullContent = title;
+ } else if (TextUtils.isEmpty(title)) {
+ fullContent = content;
+ } else {
+ fullContent = title + "\n" + content;
+ }
+ setWorkingText(fullContent);
+ }
+
+ //设置笔记内容
public void setWorkingText(String text) {
if (!TextUtils.equals(mContent, text)) {
mContent = text;
@@ -288,6 +403,7 @@ public class WorkingNote {
}
}
+ // 将笔记转换为通话笔记（设置通话相关数据）
public void convertToCallNote(String phoneNumber, long callDate) {
mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
@@ -297,6 +413,46 @@ public class WorkingNote {
public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false);
}
+
+ public boolean hasLocationAlert() {
+ return (mAlertLatitude != 0 && mAlertLongitude != 0);
+ }
+
+ public void setAlertLocation(double latitude, double longitude, float radius, String locationName, boolean set) {
+ // 有位置变化才更新
+ if (latitude != mAlertLatitude || longitude != mAlertLongitude || radius != mAlertRadius || !locationName.equals(mAlertLocationName)) {
+ mAlertLatitude = latitude;
+ mAlertLongitude = longitude;
+ mAlertRadius = radius;
+ mAlertLocationName = locationName;
+
+ mNote.setNoteValue(NoteColumns.ALERT_LATITUDE, String.valueOf(mAlertLatitude));
+ mNote.setNoteValue(NoteColumns.ALERT_LONGITUDE, String.valueOf(mAlertLongitude));
+ mNote.setNoteValue(NoteColumns.ALERT_RADIUS, String.valueOf(mAlertRadius));
+ mNote.setNoteValue(NoteColumns.ALERT_LOCATION_NAME, mAlertLocationName);
+ }
+
+ // 若监听器不为空，触发位置提醒变更回调
+ if (mNoteSettingStatusListener != null) {
+ mNoteSettingStatusListener.onLocationAlertChanged(latitude, longitude, radius, locationName, set);
+ }
+ }
+
+ public double getAlertLatitude() {
+ return mAlertLatitude;
+ }
+
+ public double getAlertLongitude() {
+ return mAlertLongitude;
+ }
+
+ public float getAlertRadius() {
+ return mAlertRadius;
+ }
+
+ public String getAlertLocationName() {
+ return mAlertLocationName;
+ }
public String getContent() {
return mContent;
@@ -342,6 +498,16 @@ public class WorkingNote {
return mWidgetType;
}
+ public String getTag() {
+ return mTag;
+ }
+
+ public void setTag(String tag) {
+ mTag = tag;
+ mNote.setNoteValue(NoteColumns.TAG, tag);
+ }
+
+ // 笔记设置变更监听器接口（定义属性变化时的回调方法）
public interface NoteSettingChangedListener {
/**
* Called when the background color of current note has just changed
@@ -352,6 +518,11 @@ public class WorkingNote {
* Called when user set clock
*/
void onClockAlertChanged(long date, boolean set);
+
+ /**
+ * Called when user set location alert
+ */
+ void onLocationAlertChanged(double latitude, double longitude, float radius, String locationName, boolean set);
/**
* Call when user create note from widget
diff --git a/src/notes/tool/AIService.java b/src/notes/tool/AIService.java
new file mode 100644
index 0000000..4a46782
--- /dev/null
+++ b/src/notes/tool/AIService.java
@@ -0,0 +1,624 @@
+package net.micode.notes.tool;
+
+import android.content.Context;
+import android.os.AsyncTask;
+import android.text.TextUtils;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * AI服务类，用于智能生成标题
+ * 这里使用模拟实现，实际项目中可以替换为真实的AI API调用
+ */
+public class AIService {
+ private Context mContext;
+ private OnAITitleGeneratedListener mListener;
+
+ public interface OnAITitleGeneratedListener {
+ void onTitleGenerated(String title);
+ }
+
+ public AIService(Context context) {
+ mContext = context;
+ }
+
+ public void setOnAITitleGeneratedListener(OnAITitleGeneratedListener listener) {
+ mListener = listener;
+ }
+
+ /**
+ * 智能生成标题
+ * @param content 正文内容
+ */
+ public void generateSmartTitle(String content) {
+ if (TextUtils.isEmpty(content)) {
+ if (mListener != null) {
+ mListener.onTitleGenerated("");
+ }
+ return;
+ }
+
+ // 使用异步任务模拟AI调用
+ new GenerateTitleTask().execute(content);
+ }
+
+ /**
+ * 模拟AI生成标题的异步任务
+ */
+ private class GenerateTitleTask extends AsyncTask {
+ @Override
+ protected String doInBackground(String... params) {
+ String content = params[0];
+
+ // 模拟AI处理延迟
+ try {
+ Thread.sleep(500);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+
+ // 模拟AI生成标题逻辑
+ // 这里可以替换为真实的AI API调用，如GPT、百度文心一言等
+ return generateMockAITitle(content);
+ }
+
+ @Override
+ protected void onPostExecute(String title) {
+ if (mListener != null) {
+ mListener.onTitleGenerated(title);
+ }
+ }
+ }
+
+ /**
+ * 模拟AI生成标题
+ * @param content 正文内容
+ * @return 生成的标题
+ */
+ private String generateMockAITitle(String content) {
+ // 清理内容，去掉特殊字符
+ String cleanContent = content.replaceAll("[^a-zA-Z0-9\\u4e00-\\u9fa5 \\t\\n\\r\\f\\v]", "").trim();
+
+ // 分析内容主题
+ String theme = analyzeTheme(cleanContent);
+
+ // 分析内容类型
+ String contentType = analyzeContentType(cleanContent);
+
+ // 提取核心关键词
+ List coreKeywords = extractCoreKeywords(cleanContent, theme);
+
+ // 根据主题、类型和核心关键词生成标题
+ return generateTitleByThemeTypeAndKeywords(cleanContent, theme, contentType, coreKeywords);
+ }
+
+ /**
+ * 分析内容主题
+ * @param content 正文内容
+ * @return 主题关键词
+ */
+ private String analyzeTheme(String content) {
+ // 简洁的主题关键词库，只保留通用主题词汇，去掉重复和具体课程名称
+ String[] themes = {
+ "学习", "工作", "会议", "计划", "总结", "任务", "想法",
+ "灵感", "生活", "旅行", "美食", "健康", "运动", "训练",
+ "购物", "阅读", "写作", "思考", "讨论", "研究", "开发", "设计",
+ "项目", "方案", "报告", "文档", "邮件", "电话", "客户",
+ "产品", "市场", "销售", "运营", "财务", "人事", "管理",
+ "技术", "代码", "测试", "上线", "维护", "优化", "创新",
+ "家庭", "朋友", "聚会", "电影", "音乐", "游戏", "动漫",
+ "书籍", "文章", "新闻", "资讯", "医疗", "养生",
+ "烹饪", "烘焙", "餐厅", "外卖", "食材", "食谱",
+ "景点", "酒店", "交通", "攻略", "行程", "机票",
+ "商品", "价格", "优惠", "促销", "订单", "物流",
+ "健身", "锻炼", "瑜伽", "跑步", "游泳", "篮球", "足球"
+ };
+
+ // 主题相关词汇映射，为每个主题添加丰富的相关词汇
+ Map> themeRelatedWords = new HashMap<>();
+
+ // 学习相关词汇
+ themeRelatedWords.put("学习", Arrays.asList("学习", "课程", "考试", "作业", "论文", "复习", "预习",
+ "毛概", "系统工程", "数据结构", "数学", "英语", "物理", "化学",
+ "语文", "历史", "地理", "政治", "计算机", "编程", "算法"));
+
+ // 工作相关词汇
+ themeRelatedWords.put("工作", Arrays.asList("工作", "会议", "报告", "项目", "计划", "总结", "方案",
+ "文档", "邮件", "电话", "客户", "产品", "市场", "销售",
+ "运营", "财务", "人事", "管理", "技术", "代码", "测试",
+ "上线", "维护", "优化", "创新"));
+
+ // 会议相关词汇
+ themeRelatedWords.put("会议", Arrays.asList("会议", "讨论", "议题", "议程", "记录", "结论", "决策",
+ "参会", "主持", "发言", "汇报", "演示", "PPT", "视频会议"));
+
+ // 计划相关词汇
+ themeRelatedWords.put("计划", Arrays.asList("计划", "安排", "日程", "时间", "任务", "目标", "步骤",
+ "进度", "时间表", "规划", "策划", "方案", "预算", "资源"));
+
+ // 总结相关词汇
+ themeRelatedWords.put("总结", Arrays.asList("总结", "回顾", "反思", "收获", "体会", "感悟", "经验",
+ "教训", "成果", "不足", "改进", "建议", "报告", "汇报"));
+
+ // 任务相关词汇
+ themeRelatedWords.put("任务", Arrays.asList("任务", "工作", "项目", "目标", "责任", "分工", "协作",
+ "完成", "交付", "验收", "评估", "绩效", "效率", "质量"));
+
+ // 生活相关词汇
+ themeRelatedWords.put("生活", Arrays.asList("生活", "家庭", "朋友", "聚会", "电影", "音乐", "游戏",
+ "动漫", "书籍", "文章", "新闻", "资讯", "健康", "医疗",
+ "养生", "烹饪", "烘焙", "美食", "餐厅", "外卖", "食材"));
+
+ // 旅行相关词汇
+ themeRelatedWords.put("旅行", Arrays.asList("旅行", "景点", "酒店", "交通", "攻略", "行程", "机票",
+ "车票", "住宿", "美食", "购物", "拍照", "打卡", "纪念品"));
+
+ // 美食相关词汇
+ themeRelatedWords.put("美食", Arrays.asList("美食", "烹饪", "烘焙", "餐厅", "外卖", "食材", "食谱",
+ "菜品", "口味", "味道", "营养", "健康", "养生", "减肥"));
+
+ // 健康相关词汇
+ themeRelatedWords.put("健康", Arrays.asList("健康", "医疗", "养生", "健身", "锻炼", "饮食", "睡眠",
+ "休息", "放松", "压力", "心理", "情绪", "疾病", "治疗"));
+
+ // 运动相关词汇
+ themeRelatedWords.put("运动", Arrays.asList("运动", "健身", "锻炼", "瑜伽", "跑步", "游泳", "篮球",
+ "足球", "羽毛球", "乒乓球", "网球", "排球", "健身操", "舞蹈"));
+
+ // 训练相关词汇
+ themeRelatedWords.put("训练", Arrays.asList("训练", "上肢", "下肢", "核心", "拉伸", "力量", "耐力",
+ "有氧", "无氧", "器械", "自由重量", "俯卧撑", "仰卧起坐", "深蹲"));
+
+ // 购物相关词汇
+ themeRelatedWords.put("购物", Arrays.asList("购物", "商品", "价格", "优惠", "促销", "订单", "物流",
+ "快递", "收货", "退货", "换货", "评价", "评分", "客服"));
+
+ // 阅读相关词汇
+ themeRelatedWords.put("阅读", Arrays.asList("阅读", "书籍", "文章", "小说", "散文", "诗歌", "传记",
+ "历史", "哲学", "科学", "技术", "杂志", "报纸", "电子书"));
+
+ // 写作相关词汇
+ themeRelatedWords.put("写作", Arrays.asList("写作", "文章", "小说", "散文", "诗歌", "传记", "历史",
+ "论文", "报告", "文档", "策划", "方案", "总结", "日记"));
+
+ // 统计每个主题相关词汇出现的次数
+ int[] counts = new int[themes.length];
+ for (int i = 0; i < themes.length; i++) {
+ String theme = themes[i];
+ // 检查主题词本身
+ if (content.contains(theme)) {
+ counts[i] += 3; // 主题词本身权重最高
+ }
+ // 检查主题相关词汇
+ List relatedWords = themeRelatedWords.get(theme);
+ if (relatedWords != null) {
+ for (String word : relatedWords) {
+ if (content.contains(word)) {
+ counts[i]++;
+ }
+ }
+ }
+ }
+
+ // 找到出现次数最多的主题
+ int maxIndex = 0;
+ for (int i = 1; i < counts.length; i++) {
+ if (counts[i] > counts[maxIndex]) {
+ maxIndex = i;
+ }
+ }
+
+ // 如果没有找到主题，返回通用主题
+ if (counts[maxIndex] == 0) {
+ return "笔记";
+ }
+
+ return themes[maxIndex];
+ }
+
+ /**
+ * 分析内容类型
+ * @param content 正文内容
+ * @return 内容类型
+ */
+ private String analyzeContentType(String content) {
+ // 检查是否包含时间安排相关词汇，添加"上午"关键词
+ if (content.contains("上午") || content.contains("早上") || content.contains("下午") || content.contains("晚上") ||
+ content.contains("明天") || content.contains("今天") || content.contains("后天") ||
+ content.contains("周一") || content.contains("周二") || content.contains("周三") ||
+ content.contains("周四") || content.contains("周五") || content.contains("周六") ||
+ content.contains("周日")) {
+ return "schedule";
+ }
+
+ // 检查是否包含任务列表相关词汇
+ if (content.contains("需要") || content.contains("要") || content.contains("必须") ||
+ content.contains("应该") || content.contains("完成") || content.contains("做")) {
+ return "task";
+ }
+
+ // 检查是否包含总结相关词汇
+ if (content.contains("总结") || content.contains("回顾") || content.contains("反思") ||
+ content.contains("收获") || content.contains("体会") || content.contains("感悟")) {
+ return "summary";
+ }
+
+ // 默认类型
+ return "normal";
+ }
+
+ /**
+ * 根据主题和类型生成标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @param contentType 内容类型
+ * @return 生成的标题
+ */
+ private String generateTitleByThemeAndType(String content, String theme, String contentType) {
+ switch (contentType) {
+ case "schedule":
+ return generateScheduleTitle(content, theme);
+ case "task":
+ return generateTaskTitle(content, theme);
+ case "summary":
+ return generateSummaryTitle(content, theme);
+ default:
+ return generateNormalTitle(content, theme);
+ }
+ }
+
+ /**
+ * 生成日程安排类型标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @return 生成的标题
+ */
+ private String generateScheduleTitle(String content, String theme) {
+ // 提取时间关键词
+ String timeKeywords = extractTimeKeywords(content);
+
+ // 优化标题生成逻辑
+ if (!TextUtils.isEmpty(timeKeywords)) {
+ // 生成更自然的标题格式：时间 + 主题 + 安排
+ return timeKeywords + theme + "安排";
+ } else {
+ // 没有时间关键词，使用默认格式
+ return theme + "安排";
+ }
+ }
+
+ /**
+ * 生成任务类型标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @return 生成的标题
+ */
+ private String generateTaskTitle(String content, String theme) {
+ // 提取任务数量
+ int taskCount = countTasks(content);
+ // 提取主要任务
+ String mainTask = extractMainActivity(content, theme);
+
+ if (taskCount > 0 && !TextUtils.isEmpty(mainTask)) {
+ return theme + ": " + mainTask + "等" + taskCount + "项任务";
+ } else if (taskCount > 0) {
+ return theme + ": " + taskCount + "项任务";
+ } else if (!TextUtils.isEmpty(mainTask)) {
+ return theme + ": " + mainTask;
+ } else {
+ return theme + "任务";
+ }
+ }
+
+ /**
+ * 生成总结类型标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @return 生成的标题
+ */
+ private String generateSummaryTitle(String content, String theme) {
+ // 提取时间关键词
+ String timeKeywords = extractTimeKeywords(content);
+
+ if (!TextUtils.isEmpty(timeKeywords)) {
+ return theme + ": " + timeKeywords + "总结";
+ } else {
+ return theme + "总结";
+ }
+ }
+
+ /**
+ * 生成普通类型标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @return 生成的标题
+ */
+ private String generateNormalTitle(String content, String theme) {
+ // 提取主要活动
+ String mainActivity = extractMainActivity(content, theme);
+
+ if (!TextUtils.isEmpty(mainActivity)) {
+ return theme + ": " + mainActivity;
+ } else {
+ return theme + "笔记";
+ }
+ }
+
+ /**
+ * 提取时间关键词
+ * @param content 正文内容
+ * @return 时间关键词
+ */
+ private String extractTimeKeywords(String content) {
+ // 时间关键词优先级排序
+ String[] timeWords = {
+ "今天", "明天", "后天", "昨天", "上周", "本周", "下周",
+ "本月", "下月", "今年", "明年",
+ "周一", "周二", "周三", "周四", "周五", "周六", "周日"
+ };
+
+ // 查找第一个时间关键词
+ for (String timeWord : timeWords) {
+ if (content.contains(timeWord)) {
+ return timeWord;
+ }
+ }
+
+ // 检查是否包含早上、下午、晚上等时间词汇
+ if (content.contains("早上") || content.contains("下午") || content.contains("晚上")) {
+ return "今日";
+ }
+
+ return "";
+ }
+
+ /**
+ * 提取主要活动
+ * @param content 正文内容
+ * @param theme 主题
+ * @return 主要活动
+ */
+ private String extractMainActivity(String content, String theme) {
+ // 去掉主题词
+ String contentWithoutTheme = content.replace(theme, "").trim();
+
+ // 按换行符分割
+ String[] lines = contentWithoutTheme.split("\\n");
+
+ // 查找第一个非空行
+ for (String line : lines) {
+ String trimmedLine = line.trim();
+ if (!TextUtils.isEmpty(trimmedLine)) {
+ // 提取活动关键词
+ String activity = extractActivityFromLine(trimmedLine);
+ if (!TextUtils.isEmpty(activity)) {
+ return activity;
+ }
+ }
+ }
+
+ return "";
+ }
+
+ /**
+ * 从行中提取活动关键词
+ * @param line 行内容
+ * @return 活动关键词
+ */
+ private String extractActivityFromLine(String line) {
+ // 常见活动动词
+ String[] verbs = {
+ "学习", "工作", "会议", "讨论", "研究", "开发", "设计",
+ "阅读", "写作", "思考", "运动", "锻炼", "跑步", "游泳",
+ "吃饭", "睡觉", "休息", "旅行", "购物", "参观", "访问"
+ };
+
+ // 查找第一个动词
+ for (String verb : verbs) {
+ if (line.contains(verb)) {
+ // 提取动词后面的内容，最多10个字符
+ int verbIndex = line.indexOf(verb);
+ String activity = line.substring(verbIndex);
+ if (activity.length() > 10) {
+ activity = activity.substring(0, 10);
+ }
+ return activity;
+ }
+ }
+
+ // 如果没有找到动词，返回行的前10个字符
+ if (line.length() > 10) {
+ return line.substring(0, 10);
+ }
+
+ return line;
+ }
+
+ /**
+ * 统计任务数量
+ * @param content 正文内容
+ * @return 任务数量
+ */
+ private int countTasks(String content) {
+ // 按换行符分割
+ String[] lines = content.split("\\n");
+ int count = 0;
+
+ // 统计非空行数量
+ for (String line : lines) {
+ if (!TextUtils.isEmpty(line.trim())) {
+ count++;
+ }
+ }
+
+ return count;
+ }
+
+ /**
+ * 提取核心关键词
+ * @param content 正文内容
+ * @param theme 主题
+ * @return 核心关键词列表
+ */
+ private List extractCoreKeywords(String content, String theme) {
+ List keywords = new ArrayList<>();
+
+ // 常见关键词库，按领域分类
+ Map> keywordLibrary = new HashMap<>();
+ keywordLibrary.put("学习", new ArrayList() {{
+ add("毛概"); add("系统工程"); add("数据结构"); add("数学"); add("英语");
+ add("物理"); add("化学"); add("生物"); add("历史"); add("地理");
+ add("政治"); add("语文"); add("计算机"); add("编程"); add("算法");
+ }});
+ keywordLibrary.put("工作", new ArrayList() {{
+ add("会议"); add("报告"); add("项目"); add("计划"); add("总结");
+ add("方案"); add("设计"); add("开发"); add("测试"); add("上线");
+ }});
+ keywordLibrary.put("生活", new ArrayList() {{
+ add("吃饭"); add("睡觉"); add("运动"); add("购物"); add("旅行");
+ add("电影"); add("音乐"); add("阅读"); add("游戏"); add("社交");
+ }});
+
+ // 获取当前主题相关的关键词库
+ List themeKeywords = keywordLibrary.getOrDefault(theme, new ArrayList<>());
+
+ // 查找内容中包含的主题相关关键词
+ for (String keyword : themeKeywords) {
+ if (content.contains(keyword) && !keywords.contains(keyword)) {
+ keywords.add(keyword);
+ }
+ }
+
+ // 如果没有找到主题相关关键词，提取内容中的高频词
+ if (keywords.isEmpty()) {
+ // 简单的高频词提取逻辑
+ String[] words = content.split("\\s+");
+ Map wordCount = new HashMap<>();
+
+ // 统计词频
+ for (String word : words) {
+ if (!TextUtils.isEmpty(word) && word.length() > 1 && !word.equals(theme)) {
+ wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
+ }
+ }
+
+ // 按词频排序，取前3个
+ wordCount.entrySet().stream()
+ .sorted((a, b) -> b.getValue().compareTo(a.getValue()))
+ .limit(3)
+ .forEach(entry -> keywords.add(entry.getKey()));
+ }
+
+ return keywords;
+ }
+
+ /**
+ * 根据主题、类型和核心关键词生成标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @param contentType 内容类型
+ * @param coreKeywords 核心关键词
+ * @return 生成的标题
+ */
+ private String generateTitleByThemeTypeAndKeywords(String content, String theme, String contentType, List coreKeywords) {
+ switch (contentType) {
+ case "schedule":
+ return generateEnhancedScheduleTitle(content, theme, coreKeywords);
+ case "task":
+ return generateEnhancedTaskTitle(content, theme, coreKeywords);
+ case "summary":
+ return generateEnhancedSummaryTitle(content, theme, coreKeywords);
+ default:
+ return generateEnhancedNormalTitle(content, theme, coreKeywords);
+ }
+ }
+
+ /**
+ * 生成增强版日程安排标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @param coreKeywords 核心关键词
+ * @return 生成的标题
+ */
+ private String generateEnhancedScheduleTitle(String content, String theme, List coreKeywords) {
+ String timeKeywords = extractTimeKeywords(content);
+
+ if (!TextUtils.isEmpty(timeKeywords)) {
+ // 生成简洁的标题：时间 + 主题 + 安排
+ return timeKeywords + theme + "安排";
+ } else {
+ // 没有时间关键词，生成：主题 + 安排
+ return theme + "安排";
+ }
+ }
+
+ /**
+ * 生成增强版任务标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @param coreKeywords 核心关键词
+ * @return 生成的标题
+ */
+ private String generateEnhancedTaskTitle(String content, String theme, List coreKeywords) {
+ // 生成简洁的标题：主题 + 任务
+ return theme + "任务";
+ }
+
+ /**
+ * 生成增强版总结标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @param coreKeywords 核心关键词
+ * @return 生成的标题
+ */
+ private String generateEnhancedSummaryTitle(String content, String theme, List coreKeywords) {
+ String timeKeywords = extractTimeKeywords(content);
+
+ if (!TextUtils.isEmpty(timeKeywords)) {
+ // 生成简洁的标题：时间 + 主题 + 总结
+ return timeKeywords + theme + "总结";
+ } else {
+ // 没有时间关键词，生成：主题 + 总结
+ return theme + "总结";
+ }
+ }
+
+ /**
+ * 生成增强版普通标题
+ * @param content 正文内容
+ * @param theme 主题
+ * @param coreKeywords 核心关键词
+ * @return 生成的标题
+ */
+ private String generateEnhancedNormalTitle(String content, String theme, List coreKeywords) {
+ // 生成简洁的标题：主题 + 笔记
+ return theme + "笔记";
+ }
+
+ /**
+ * 获取内容摘要
+ * @param content 正文内容
+ * @param maxLength 最大长度
+ * @return 内容摘要
+ */
+ private String getContentSummary(String content, int maxLength) {
+ if (content.length() <= maxLength) {
+ return content;
+ }
+
+ // 尝试在句子边界截断
+ for (int i = maxLength; i > 0; i--) {
+ char c = content.charAt(i);
+ if (c == '。' || c == '！' || c == '？' || c == '.' || c == '!' || c == '?') {
+ return content.substring(0, i + 1);
+ }
+ }
+
+ // 找不到合适的边界，直接截断
+ return content.substring(0, maxLength) + "...";
+ }
+}
\ No newline at end of file
diff --git a/src/notes/tool/BackupUtils.java b/src/notes/tool/BackupUtils.java
index 11053a9..1075bd7 100644
--- a/src/notes/tool/BackupUtils.java
+++ b/src/notes/tool/BackupUtils.java
@@ -313,7 +313,7 @@ public class BackupUtils {
Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION,
"(" + NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND "
- + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + ") OR "
+ + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER + ") OR "
+ NoteColumns.ID + "=" + Notes.ID_CALL_RECORD_FOLDER, null, null);
if (folderCursor != null) {
diff --git a/src/notes/tool/DataUtils.java b/src/notes/tool/DataUtils.java
index 94c08d7..a5e477f 100644
--- a/src/notes/tool/DataUtils.java
+++ b/src/notes/tool/DataUtils.java
@@ -158,7 +158,7 @@ public class DataUtils {
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)},
+ new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLDER)},
null);
int count = 0;
@@ -186,7 +186,7 @@ public class DataUtils {
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,
+ NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER,
new String [] {String.valueOf(type)},
null);
@@ -249,7 +249,7 @@ public class DataUtils {
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.PARENT_ID + "<>" + Notes.ID_TRASH_FOLDER +
" AND " + NoteColumns.SNIPPET + "=?",
new String[] { name }, null);
boolean exist = false;
diff --git a/src/notes/tool/ImageSpanUtils.java b/src/notes/tool/ImageSpanUtils.java
new file mode 100644
index 0000000..be66219
--- /dev/null
+++ b/src/notes/tool/ImageSpanUtils.java
@@ -0,0 +1,96 @@
+/*
+ * 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.graphics.drawable.Drawable;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
+import android.text.style.ImageSpan;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * 图片Span工具类，用于处理图片在Spannable中的序列化和反序列化
+ */
+public class ImageSpanUtils {
+
+ /**
+ * 将Spannable中的图片信息序列化为JSON字符串
+ *
+ * @param spannable 包含图片信息的Spannable对象
+ * @param content 原始文本内容
+ * @return 图片信息的JSON字符串表示
+ */
+ public static String serializeImageInfo(Spannable spannable, String content) {
+ JSONArray jsonArray = new JSONArray();
+
+ // 获取所有图片Span
+ ImageSpan[] imageSpans = spannable.getSpans(0, spannable.length(), ImageSpan.class);
+
+ for (ImageSpan span : imageSpans) {
+ JSONObject spanObj = new JSONObject();
+ try {
+ int start = spannable.getSpanStart(span);
+ int end = spannable.getSpanEnd(span);
+
+ // 获取图片URI
+ Drawable drawable = span.getDrawable();
+ if (drawable != null) {
+ spanObj.put("type", "image");
+ spanObj.put("start", start);
+ spanObj.put("end", end);
+ // 注意：ImageSpan通常不直接存储URI，需要额外的机制来跟踪图片路径
+ // 这里仅为示例，实际实现需要根据具体情况调整
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+
+ return jsonArray.toString();
+ }
+
+ /**
+ * 将JSON格式的图片信息反序列化并应用到文本上
+ *
+ * @param context 上下文
+ * @param text 原始文本
+ * @param imageJson 序列化的图片信息JSON字符串
+ * @return 包含图片信息的SpannableStringBuilder
+ */
+ public static SpannableStringBuilder deserializeImageInfo(Context context, String text, String imageJson) {
+ SpannableStringBuilder spannable = new SpannableStringBuilder(text);
+
+ if (imageJson == null || imageJson.isEmpty()) {
+ return spannable;
+ }
+
+ try {
+ // 这里需要根据实际的图片存储机制来实现
+ // 因为图片通常需要特殊处理，这里暂时返回原始文本
+ // 实际实现需要考虑如何存储和检索图片
+ return spannable;
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return spannable;
+ }
+}
\ No newline at end of file
diff --git a/src/notes/tool/PrivacyLockManager.java b/src/notes/tool/PrivacyLockManager.java
new file mode 100644
index 0000000..a71b1a3
--- /dev/null
+++ b/src/notes/tool/PrivacyLockManager.java
@@ -0,0 +1,352 @@
+package net.micode.notes.tool;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.util.Log;
+
+import net.micode.notes.data.Notes;
+import net.micode.notes.data.Notes.NoteColumns;
+
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 隐私锁管理类，用于处理便签和文件夹的隐私锁功能
+ */
+public class PrivacyLockManager {
+ private static final String TAG = "PrivacyLockManager";
+
+ // 锁类型常量
+ public static final int LOCK_TYPE_NONE = 0;
+ public static final int LOCK_TYPE_PASSWORD = 1;
+ public static final int LOCK_TYPE_GESTURE = 2;
+
+ // 锁状态常量
+ public static final int LOCK_STATUS_UNLOCKED = 0;
+ public static final int LOCK_STATUS_LOCKED = 1;
+
+ private Context mContext;
+
+ public PrivacyLockManager(Context context) {
+ this.mContext = context;
+ }
+
+ /**
+ * SHA256加密密码
+ * @param password 原始密码
+ * @return 加密后的密码
+ */
+ public static String encryptPassword(String password) {
+ try {
+ MessageDigest digest = MessageDigest.getInstance("SHA-256");
+ byte[] hash = digest.digest(password.getBytes("UTF-8"));
+
+ StringBuilder hexString = new StringBuilder();
+ for (byte b : hash) {
+ String hex = Integer.toHexString(0xff & b);
+ if (hex.length() == 1) {
+ hexString.append('0');
+ }
+ hexString.append(hex);
+ }
+
+ return hexString.toString();
+ } catch (Exception ex) {
+ Log.e(TAG, "Error encrypting password", ex);
+ return "";
+ }
+ }
+
+ /**
+ * 检查指定便签是否已加锁
+ * @param noteId 便签ID
+ * @return 是否已加锁
+ */
+ public boolean isNoteLocked(long noteId) {
+ String[] projection = new String[]{NoteColumns.LOCKED};
+ String selection = NoteColumns.ID + " = ?";
+ String[] selectionArgs = new String[]{String.valueOf(noteId)};
+
+ Cursor cursor = mContext.getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ projection,
+ selection,
+ selectionArgs,
+ null
+ );
+
+ boolean isLocked = false;
+ if (cursor != null) {
+ if (cursor.moveToFirst()) {
+ isLocked = cursor.getInt(cursor.getColumnIndexOrThrow(NoteColumns.LOCKED)) == LOCK_STATUS_LOCKED;
+ }
+ cursor.close();
+ }
+
+ return isLocked;
+ }
+
+ /**
+ * 为指定便签添加隐私锁
+ * @param noteId 便签ID
+ * @param lockType 锁类型
+ * @param passwordOrGesture 加密后的密码或手势序列（如果使用密码锁或手势锁）
+ * @return 是否成功
+ */
+ public boolean addPrivacyLock(long noteId, int lockType, String passwordOrGesture) {
+ if (noteId <= 0) {
+ Log.e(TAG, "Invalid note ID: " + noteId);
+ return false;
+ }
+
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.LOCKED, LOCK_STATUS_LOCKED);
+ values.put(NoteColumns.LOCK_TYPE, lockType);
+
+ if ((lockType == LOCK_TYPE_PASSWORD || lockType == LOCK_TYPE_GESTURE) && passwordOrGesture != null) {
+ values.put(NoteColumns.ENCRYPTED_PASSWORD, passwordOrGesture);
+ } else if (lockType == LOCK_TYPE_NONE) {
+ values.put(NoteColumns.ENCRYPTED_PASSWORD, "");
+ }
+
+ int rowsUpdated = mContext.getContentResolver().update(
+ Notes.CONTENT_NOTE_URI,
+ values,
+ NoteColumns.ID + " = ?",
+ new String[]{String.valueOf(noteId)}
+ );
+
+ return rowsUpdated > 0;
+ }
+
+ /**
+ * 移除指定便签的隐私锁
+ * @param noteId 便签ID
+ * @return 是否成功
+ */
+ public boolean removePrivacyLock(long noteId) {
+ if (noteId <= 0) {
+ Log.e(TAG, "Invalid note ID: " + noteId);
+ return false;
+ }
+
+ ContentValues values = new ContentValues();
+ values.put(NoteColumns.LOCKED, LOCK_STATUS_UNLOCKED);
+ values.put(NoteColumns.LOCK_TYPE, LOCK_TYPE_NONE);
+ values.put(NoteColumns.ENCRYPTED_PASSWORD, "");
+
+ int rowsUpdated = mContext.getContentResolver().update(
+ Notes.CONTENT_NOTE_URI,
+ values,
+ NoteColumns.ID + " = ?",
+ new String[]{String.valueOf(noteId)}
+ );
+
+ return rowsUpdated > 0;
+ }
+
+ /**
+ * 验证密码是否正确
+ * @param noteId 便签ID
+ * @param password 待验证的密码
+ * @return 是否验证成功
+ */
+ public boolean verifyPassword(long noteId, String password) {
+ String[] projection = new String[]{NoteColumns.ENCRYPTED_PASSWORD};
+ String selection = NoteColumns.ID + " = ?";
+ String[] selectionArgs = new String[]{String.valueOf(noteId)};
+
+ Cursor cursor = mContext.getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ projection,
+ selection,
+ selectionArgs,
+ null
+ );
+
+ boolean isValid = false;
+ if (cursor != null) {
+ if (cursor.moveToFirst()) {
+ String storedEncryptedPassword = cursor.getString(cursor.getColumnIndexOrThrow(NoteColumns.ENCRYPTED_PASSWORD));
+ String encryptedInput = encryptPassword(password);
+
+ isValid = storedEncryptedPassword.equals(encryptedInput);
+ }
+ cursor.close();
+ }
+
+ return isValid;
+ }
+
+ /**
+ * 获取便签的锁类型
+ * @param noteId 便签ID
+ * @return 锁类型
+ */
+ public int getLockType(long noteId) {
+ String[] projection = new String[]{NoteColumns.LOCK_TYPE};
+ String selection = NoteColumns.ID + " = ?";
+ String[] selectionArgs = new String[]{String.valueOf(noteId)};
+
+ Cursor cursor = mContext.getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ projection,
+ selection,
+ selectionArgs,
+ null
+ );
+
+ int lockType = LOCK_TYPE_NONE;
+ if (cursor != null) {
+ if (cursor.moveToFirst()) {
+ lockType = cursor.getInt(cursor.getColumnIndexOrThrow(NoteColumns.LOCK_TYPE));
+ }
+ cursor.close();
+ }
+
+ return lockType;
+ }
+
+ /**
+ * 为整个文件夹及其所有子便签添加隐私锁
+ * @param folderId 文件夹ID
+ * @param lockType 锁类型
+ * @param passwordOrGesture 加密后的密码或手势序列（如果使用密码锁或手势锁）
+ * @return 是否成功
+ */
+ public boolean addPrivacyLockToFolder(long folderId, int lockType, String passwordOrGesture) {
+ // 首先为文件夹本身添加锁
+ boolean folderSuccess = addPrivacyLock(folderId, lockType, passwordOrGesture);
+
+ // 然后为文件夹内的所有便签添加锁
+ String[] projection = new String[]{NoteColumns.ID};
+ String selection = NoteColumns.PARENT_ID + " = ? AND " + NoteColumns.TYPE + " = ?";
+ String[] selectionArgs = new String[]{String.valueOf(folderId), String.valueOf(Notes.TYPE_NOTE)};
+
+ Cursor cursor = mContext.getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ projection,
+ selection,
+ selectionArgs,
+ null
+ );
+
+ boolean allNotesSuccess = true;
+ if (cursor != null) {
+ while (cursor.moveToNext()) {
+ long noteId = cursor.getLong(cursor.getColumnIndexOrThrow(NoteColumns.ID));
+ boolean noteSuccess = addPrivacyLock(noteId, lockType, passwordOrGesture);
+ if (!noteSuccess) {
+ allNotesSuccess = false;
+ }
+ }
+ cursor.close();
+ }
+
+ return folderSuccess && allNotesSuccess;
+ }
+
+ /**
+ * 移除整个文件夹及其所有子便签的隐私锁
+ * @param folderId 文件夹ID
+ * @return 是否成功
+ */
+ public boolean removePrivacyLockFromFolder(long folderId) {
+ // 首先移除文件夹本身的锁
+ boolean folderSuccess = removePrivacyLock(folderId);
+
+ // 然后移除文件夹内的所有便签的锁
+ String[] projection = new String[]{NoteColumns.ID};
+ String selection = NoteColumns.PARENT_ID + " = ? AND " + NoteColumns.TYPE + " = ?";
+ String[] selectionArgs = new String[]{String.valueOf(folderId), String.valueOf(Notes.TYPE_NOTE)};
+
+ Cursor cursor = mContext.getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ projection,
+ selection,
+ selectionArgs,
+ null
+ );
+
+ boolean allNotesSuccess = true;
+ if (cursor != null) {
+ while (cursor.moveToNext()) {
+ long noteId = cursor.getLong(cursor.getColumnIndexOrThrow(NoteColumns.ID));
+ boolean noteSuccess = removePrivacyLock(noteId);
+ if (!noteSuccess) {
+ allNotesSuccess = false;
+ }
+ }
+ cursor.close();
+ }
+
+ return folderSuccess && allNotesSuccess;
+ }
+
+ /**
+ * 验证手势是否正确
+ * @param noteId 便签ID
+ * @param gestureSequence 手势序列
+ * @return 是否验证成功
+ */
+ public boolean verifyGesture(long noteId, List gestureSequence) {
+ String[] projection = new String[]{NoteColumns.ENCRYPTED_PASSWORD};
+ String selection = NoteColumns.ID + " = ?";
+ String[] selectionArgs = new String[]{String.valueOf(noteId)};
+
+ Cursor cursor = mContext.getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ projection,
+ selection,
+ selectionArgs,
+ null
+ );
+
+ boolean isValid = false;
+ if (cursor != null) {
+ if (cursor.moveToFirst()) {
+ String storedGestureSequence = cursor.getString(cursor.getColumnIndexOrThrow(NoteColumns.ENCRYPTED_PASSWORD));
+
+ // 将手势序列转换为字符串进行比较
+ StringBuilder gestureBuilder = new StringBuilder();
+ for (int point : gestureSequence) {
+ gestureBuilder.append(point);
+ }
+ String inputGestureSequence = gestureBuilder.toString();
+
+ isValid = storedGestureSequence.equals(inputGestureSequence);
+ }
+ cursor.close();
+ }
+
+ return isValid;
+ }
+
+ /**
+ * 将手势点列表转换为字符串
+ * @param gesturePoints 手势点列表
+ * @return 手势序列字符串
+ */
+ public static String gestureToString(List gesturePoints) {
+ StringBuilder sb = new StringBuilder();
+ for (int point : gesturePoints) {
+ sb.append(point);
+ }
+ return sb.toString();
+ }
+
+ /**
+ * 将手势序列字符串转换为点列表
+ * @param gestureString 手势序列字符串
+ * @return 手势点列表
+ */
+ public static List stringToGesture(String gestureString) {
+ List gesturePoints = new ArrayList<>();
+ for (char c : gestureString.toCharArray()) {
+ gesturePoints.add(Character.getNumericValue(c));
+ }
+ return gesturePoints;
+ }
+}
\ No newline at end of file
diff --git a/src/notes/tool/RichTextFormatUtils.java b/src/notes/tool/RichTextFormatUtils.java
new file mode 100644
index 0000000..5593419
--- /dev/null
+++ b/src/notes/tool/RichTextFormatUtils.java
@@ -0,0 +1,107 @@
+package net.micode.notes.tool;
+
+import android.text.Editable;
+import android.text.Spannable;
+import android.text.SpannableStringBuilder;
+import android.text.style.StyleSpan;
+import android.text.style.UnderlineSpan;
+import android.text.style.StrikethroughSpan;
+import android.graphics.Typeface;
+import android.text.ParcelableSpan;
+import android.text.style.CharacterStyle;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 富文本格式工具类，用于序列化和反序列化Spannable中的格式信息
+ */
+public class RichTextFormatUtils {
+
+ /**
+ * 将Spannable中的格式信息序列化为JSON字符串
+ *
+ * @param spannable 包含格式信息的Spannable对象
+ * @return 格式信息的JSON字符串表示
+ */
+ public static String serializeFormatInfo(Spannable spannable) {
+ JSONArray jsonArray = new JSONArray();
+ CharacterStyle[] spans = spannable.getSpans(0, spannable.length(), CharacterStyle.class);// 获取所有字符样式Span
+
+ for (CharacterStyle span : spans) {
+ JSONObject spanObj = new JSONObject();
+ try {
+ int start = spannable.getSpanStart(span);
+ int end = spannable.getSpanEnd(span);
+ int flags = spannable.getSpanFlags(span);
+
+ // 识别Span类型并保存相关信息
+ if (span instanceof StyleSpan) {
+ StyleSpan styleSpan = (StyleSpan) span;
+ spanObj.put("type", "style");
+ spanObj.put("style", styleSpan.getStyle());
+ } else if (span instanceof UnderlineSpan) {
+ spanObj.put("type", "underline");
+ } else if (span instanceof StrikethroughSpan) {
+ spanObj.put("type", "strikethrough");
+ } else {
+ continue; // 不支持的Span类型，跳过
+ }
+
+ spanObj.put("start", start);
+ spanObj.put("end", end);
+ spanObj.put("flags", flags);
+
+ jsonArray.put(spanObj);
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ }
+
+ return jsonArray.toString();
+ }
+
+ /**
+ * 将JSON格式的格式信息反序列化并应用到文本上
+ *
+ * @param text 原始文本
+ * @param formatJson 序列化的格式信息JSON字符串
+ * @return 包含格式信息的SpannableStringBuilder
+ */
+ public static SpannableStringBuilder deserializeFormatInfo(String text, String formatJson) {
+ SpannableStringBuilder spannable = new SpannableStringBuilder(text);
+ if (formatJson == null || formatJson.isEmpty()) {
+ return spannable;
+ }
+ try {
+ JSONArray jsonArray = new JSONArray(formatJson);
+
+ for (int i = 0; i < jsonArray.length(); i++) {
+ JSONObject spanObj = jsonArray.getJSONObject(i);
+ int start = spanObj.getInt("start");
+ int end = spanObj.getInt("end");
+ int flags = spanObj.getInt("flags");
+ String type = spanObj.getString("type");
+ CharacterStyle span = null;
+ if ("style".equals(type)) {
+ int style = spanObj.getInt("style");
+ span = new StyleSpan(style);
+ } else if ("underline".equals(type)) {
+ span = new UnderlineSpan();
+ } else if ("strikethrough".equals(type)) {
+ span = new StrikethroughSpan();
+ }
+ if (span != null && start >= 0 && end <= text.length() && start < end) {
+ spannable.setSpan(span, start, end, flags);
+ }
+ }
+ } catch (JSONException e) {
+ e.printStackTrace();
+ }
+ return spannable;
+ }
+}
\ No newline at end of file
diff --git a/src/notes/tool/SmartReminderManager.java b/src/notes/tool/SmartReminderManager.java
new file mode 100644
index 0000000..cc07284
--- /dev/null
+++ b/src/notes/tool/SmartReminderManager.java
@@ -0,0 +1,503 @@
+package net.micode.notes.tool;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * 智能提醒管理器，基于规则实现智能提醒功能
+ * 包括上下文提醒、智能重复提醒和关联提醒
+ */
+public class SmartReminderManager {
+ private static final String TAG = "SmartReminderManager";
+ private Context mContext;
+
+ // 日期时间格式
+ private SimpleDateFormat mDateTimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
+ private SimpleDateFormat mDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+
+ // 时间相关的正则表达式
+ private Pattern mTimePattern = Pattern.compile(
+ "(\\d{1,2})[:：]\\d{1,2}|" + // 如 3:30 或 14：30
+ "(\\d{1,2})[点时]|" + // 如 3点 或 14时
+ "上午(\\d{1,2})[点时]|" + // 如 上午3点 或 上午10时
+ "下午(\\d{1,2})[点时]|" + // 如 下午3点 或 下午10时
+ "明天|今天|后天|" + // 如 明天
+ "(\\d{1,2})月(\\d{1,2})[日号]|" + // 如 12月31日 或 1月1号
+ "下[周月年]|本[周月年]|上[周月年]"); // 如 下周 或 本月
+
+ // 重复相关的正则表达式
+ private Pattern mRepeatPattern = Pattern.compile(
+ "每[天周月年]|" + // 如 每天 或 每周
+ "周[一二三四五六日]|" + // 如 周一 或 周三
+ "每月(\\d{1,2})[日号]|" + // 如 每月15日
+ "每年(\\d{1,2})月(\\d{1,2})[日号]"); // 如 每年12月31日
+
+ // 关联关键词
+ private List mRelatedKeywords = new ArrayList<>();
+
+ public SmartReminderManager(Context context) {
+ mContext = context;
+
+ // 初始化关联关键词
+ mRelatedKeywords.add("会议");
+ mRelatedKeywords.add("面试");
+ mRelatedKeywords.add("任务");
+ mRelatedKeywords.add("计划");
+ mRelatedKeywords.add("安排");
+ mRelatedKeywords.add("项目");
+ mRelatedKeywords.add("工作");
+ mRelatedKeywords.add("进度");
+ mRelatedKeywords.add("报告");
+ mRelatedKeywords.add("讨论");
+ mRelatedKeywords.add("准备");
+ mRelatedKeywords.add("总结");
+ mRelatedKeywords.add("方案");
+ mRelatedKeywords.add("设计");
+ mRelatedKeywords.add("开发");
+ mRelatedKeywords.add("测试");
+ mRelatedKeywords.add("上线");
+ mRelatedKeywords.add(" deadline");
+ mRelatedKeywords.add("截止");
+ }
+
+ /**
+ * 根据便签内容智能建议提醒时间
+ * @param content 便签内容
+ * @return 建议的提醒时间戳，0表示没有建议
+ */
+ public long suggestReminderTime(String content) {
+ if (TextUtils.isEmpty(content)) {
+ return 0;
+ }
+
+ // 先查找日期关键词（明天、后天、x月x日等）
+ Matcher dateMatcher = Pattern.compile("明天|今天|后天|(\\d{1,2})月(\\d{1,2})[日号]|下[周月年]|本[周月年]|上[周月年]").matcher(content);
+ String dateStr = null;
+ if (dateMatcher.find()) {
+ dateStr = dateMatcher.group();
+ }
+
+ // 再查找时间关键词（3:30、3点、上午3点等）
+ Matcher timeMatcher = Pattern.compile("(\\d{1,2})[:：]\\d{1,2}|(\\d{1,2})[点时]|上午(\\d{1,2})[点时]|下午(\\d{1,2})[点时]").matcher(content);
+ String timeStr = null;
+ if (timeMatcher.find()) {
+ timeStr = timeMatcher.group();
+ }
+
+ // 结合日期和时间进行解析，生成更准确的提醒时间
+ if (dateStr != null && timeStr != null) {
+ // 先解析日期，获取基准日期
+ long baseTime = parseTimeString(dateStr);
+ Calendar calendar = Calendar.getInstance();
+ calendar.setTimeInMillis(baseTime);
+
+ // 再解析时间，设置具体时分
+ if (timeStr.contains(":") || timeStr.contains("：")) {
+ // 处理时间格式，如 3:30 或 14：30
+ String[] timeParts = timeStr.replace("：", ":").split(":");
+ int hour = Integer.parseInt(timeParts[0]);
+ int minute = Integer.parseInt(timeParts[1]);
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, minute);
+ } else if (timeStr.matches("\\d{1,2}[点时]")) {
+ // 处理时间格式，如 3点 或 14时
+ int hour = Integer.parseInt(timeStr.replaceAll("[点时]", ""));
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, 0);
+ } else if (timeStr.matches("上午\\d{1,2}[点时]")) {
+ // 处理上午时间，如 上午3点 或 上午10时
+ int hour = Integer.parseInt(timeStr.replaceAll("[上午点时]", ""));
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, 0);
+ } else if (timeStr.matches("下午\\d{1,2}[点时]")) {
+ // 处理下午时间，如 下午3点 或 下午10时
+ int hour = Integer.parseInt(timeStr.replaceAll("[下午点时]", ""));
+ // 转换为24小时制
+ hour += 12;
+ // 特殊处理下午12点
+ if (hour == 24) {
+ hour = 12;
+ }
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, 0);
+ }
+
+ calendar.set(Calendar.SECOND, 0);
+ return calendar.getTimeInMillis();
+ }
+ // 如果只有日期或只有时间，使用原有逻辑
+ else {
+ Matcher matcher = mTimePattern.matcher(content);
+ if (matcher.find()) {
+ String singleTimeStr = matcher.group();
+ return parseTimeString(singleTimeStr);
+ }
+ }
+
+ return 0;
+ }
+
+ /**
+ * 根据便签内容智能建议重复频率
+ * @param content 便签内容
+ * @return 建议的重复类型，如 "daily", "weekly", "monthly", "yearly"，空字符串表示不重复
+ */
+ public String suggestRepeatType(String content) {
+ if (TextUtils.isEmpty(content)) {
+ return "";
+ }
+
+ // 查找重复相关关键词
+ Matcher repeatMatcher = mRepeatPattern.matcher(content);
+ if (repeatMatcher.find()) {
+ String repeatStr = repeatMatcher.group();
+ return parseRepeatString(repeatStr);
+ }
+
+ return "";
+ }
+
+ /**
+ * 判断两个便签是否相关，用于关联提醒
+ * @param content1 第一个便签内容
+ * @param content2 第二个便签内容
+ * @return 如果相关返回true，否则返回false
+ */
+ public boolean areNotesRelated(String content1, String content2) {
+ if (TextUtils.isEmpty(content1) || TextUtils.isEmpty(content2)) {
+ return false;
+ }
+
+ // 转换为小写，不区分大小写
+ String lowerContent1 = content1.toLowerCase();
+ String lowerContent2 = content2.toLowerCase();
+
+ // 1. 检查是否包含相同的关联关键词
+ for (String keyword : mRelatedKeywords) {
+ if (lowerContent1.contains(keyword) && lowerContent2.contains(keyword)) {
+ return true;
+ }
+ }
+
+ // 2. 检查是否包含相似的项目名称或主题
+ // 查找可能的项目名称（如"项目A"、"任务1"等）
+ Pattern projectPattern = Pattern.compile("[项目任务计划][A-Za-z0-9_]+|[A-Za-z0-9_]+[项目任务计划]");
+ Matcher projectMatcher1 = projectPattern.matcher(lowerContent1);
+ Matcher projectMatcher2 = projectPattern.matcher(lowerContent2);
+
+ List projects1 = new ArrayList<>();
+ while (projectMatcher1.find()) {
+ projects1.add(projectMatcher1.group());
+ }
+
+ while (projectMatcher2.find()) {
+ if (projects1.contains(projectMatcher2.group())) {
+ return true;
+ }
+ }
+
+ // 3. 检查是否包含相同或相似的时间信息
+ // 先提取所有时间相关的关键词
+ Matcher timeMatcher1 = mTimePattern.matcher(content1);
+ Matcher timeMatcher2 = mTimePattern.matcher(content2);
+
+ List timeStrs1 = new ArrayList<>();
+ while (timeMatcher1.find()) {
+ timeStrs1.add(timeMatcher1.group());
+ }
+
+ List timeStrs2 = new ArrayList<>();
+ while (timeMatcher2.find()) {
+ timeStrs2.add(timeMatcher2.group());
+ }
+
+ // 检查是否有完全相同的时间关键词
+ for (String timeStr : timeStrs1) {
+ if (timeStrs2.contains(timeStr)) {
+ return true;
+ }
+ }
+
+ // 检查是否有相关的时间关键词（如"明天"和"明天3点"）
+ for (String time1 : timeStrs1) {
+ for (String time2 : timeStrs2) {
+ if (areTimesRelated(time1, time2)) {
+ return true;
+ }
+ }
+ }
+
+ // 4. 检查内容相似度（如果内容较短，相似度要求较高）
+ int minLength = Math.min(content1.length(), content2.length());
+ if (minLength > 5) { // 只有当内容足够长时才检查相似度
+ int commonWords = countCommonWords(content1, content2);
+ double similarity = (double) commonWords / Math.sqrt(content1.length() * content2.length());
+ if (similarity > 0.3) { // 相似度阈值
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * 检查两个时间字符串是否相关
+ * @param time1 第一个时间字符串
+ * @param time2 第二个时间字符串
+ * @return 如果相关返回true，否则返回false
+ */
+ private boolean areTimesRelated(String time1, String time2) {
+ // 检查是否有包含关系（如"明天"包含在"明天3点"中）
+ if (time1.contains(time2) || time2.contains(time1)) {
+ return true;
+ }
+
+ // 检查是否都是日期或都是时间
+ boolean isDate1 = time1.matches(".*[明天后天今天月日号周].*");
+ boolean isDate2 = time2.matches(".*[明天后天今天月日号周].*");
+ boolean isTime1 = time1.matches(".*[0-9:：点时上午下午].*");
+ boolean isTime2 = time2.matches(".*[0-9:：点时上午下午].*");
+
+ // 如果一个是日期，一个是时间，认为它们可能相关
+ if ((isDate1 && isTime2) || (isDate2 && isTime1)) {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * 计算两个字符串中相同的词语数量
+ * @param str1 第一个字符串
+ * @param str2 第二个字符串
+ * @return 相同词语的数量
+ */
+ private int countCommonWords(String str1, String str2) {
+ // 简单的词语分割，按空格分割
+ String[] words1 = str1.split("\\s+");
+ String[] words2 = str2.split("\\s+");
+
+ Set wordSet1 = new HashSet<>();
+ for (String word : words1) {
+ // 移除常见标点符号
+ String cleanedWord = word.replaceAll("[\\p{Punct}]", "").toLowerCase();
+ if (cleanedWord.length() > 1) { // 只考虑长度大于1的词语
+ wordSet1.add(cleanedWord);
+ }
+ }
+
+ int commonCount = 0;
+ for (String word : words2) {
+ // 移除常见标点符号
+ String cleanedWord = word.replaceAll("[\\p{Punct}]", "").toLowerCase();
+ if (cleanedWord.length() > 1 && wordSet1.contains(cleanedWord)) {
+ commonCount++;
+ }
+ }
+
+ return commonCount;
+ }
+
+ /**
+ * 解析时间字符串，返回时间戳
+ * @param timeStr 时间字符串
+ * @return 时间戳
+ */
+ private long parseTimeString(String timeStr) {
+ Calendar calendar = Calendar.getInstance();
+
+ try {
+ if (timeStr.contains(":") || timeStr.contains("：")) {
+ // 处理时间格式，如 3:30 或 14：30
+ String[] timeParts = timeStr.replace("：", ":").split(":");
+ int hour = Integer.parseInt(timeParts[0]);
+ int minute = Integer.parseInt(timeParts[1]);
+
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, minute);
+ calendar.set(Calendar.SECOND, 0);
+
+ // 如果时间已过，设置为明天
+ if (calendar.getTimeInMillis() < System.currentTimeMillis()) {
+ calendar.add(Calendar.DAY_OF_MONTH, 1);
+ }
+ } else if (timeStr.matches("\\d{1,2}[点时]")) {
+ // 处理时间格式，如 3点 或 14时
+ int hour = Integer.parseInt(timeStr.replaceAll("[点时]", ""));
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, 0);
+ calendar.set(Calendar.SECOND, 0);
+
+ // 如果时间已过，设置为明天
+ if (calendar.getTimeInMillis() < System.currentTimeMillis()) {
+ calendar.add(Calendar.DAY_OF_MONTH, 1);
+ }
+ } else if (timeStr.matches("上午\\d{1,2}[点时]")) {
+ // 处理上午时间，如 上午3点 或 上午10时
+ int hour = Integer.parseInt(timeStr.replaceAll("[上午点时]", ""));
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, 0);
+ calendar.set(Calendar.SECOND, 0);
+
+ // 如果时间已过，设置为明天
+ if (calendar.getTimeInMillis() < System.currentTimeMillis()) {
+ calendar.add(Calendar.DAY_OF_MONTH, 1);
+ }
+ } else if (timeStr.matches("下午\\d{1,2}[点时]")) {
+ // 处理下午时间，如 下午3点 或 下午10时
+ int hour = Integer.parseInt(timeStr.replaceAll("[下午点时]", ""));
+ // 转换为24小时制
+ hour += 12;
+ // 特殊处理下午12点
+ if (hour == 24) {
+ hour = 12;
+ }
+ calendar.set(Calendar.HOUR_OF_DAY, hour);
+ calendar.set(Calendar.MINUTE, 0);
+ calendar.set(Calendar.SECOND, 0);
+
+ // 如果时间已过，设置为明天
+ if (calendar.getTimeInMillis() < System.currentTimeMillis()) {
+ calendar.add(Calendar.DAY_OF_MONTH, 1);
+ }
+ } else if (timeStr.contains("明天")) {
+ // 明天
+ calendar.add(Calendar.DAY_OF_MONTH, 1);
+ } else if (timeStr.contains("后天")) {
+ // 后天
+ calendar.add(Calendar.DAY_OF_MONTH, 2);
+ } else if (timeStr.contains("今天")) {
+ // 今天（保持不变）
+ } else if (timeStr.contains("周")) {
+ // 处理星期，如 下周 或 本周
+ int dayOfWeek = getDayOfWeek(timeStr);
+ if (dayOfWeek != -1) {
+ int currentDayOfWeek = calendar.get(Calendar.DAY_OF_WEEK);
+ int daysToAdd = dayOfWeek - currentDayOfWeek;
+ if (daysToAdd <= 0) {
+ daysToAdd += 7;
+ }
+ calendar.add(Calendar.DAY_OF_MONTH, daysToAdd);
+ }
+ } else if (timeStr.contains("月")) {
+ // 处理日期，如 12月31日
+ String[] dateParts = timeStr.replace("月", "-").replace("日", "").replace("号", "").split("-");
+ int month = Integer.parseInt(dateParts[0]) - 1; // Calendar月份从0开始
+ int day = Integer.parseInt(dateParts[1]);
+
+ calendar.set(Calendar.MONTH, month);
+ calendar.set(Calendar.DAY_OF_MONTH, day);
+
+ // 如果日期已过，设置为明年
+ if (calendar.getTimeInMillis() < System.currentTimeMillis()) {
+ calendar.add(Calendar.YEAR, 1);
+ }
+ }
+
+ return calendar.getTimeInMillis();
+ } catch (Exception e) {
+ Log.e(TAG, "Failed to parse time string: " + timeStr, e);
+ return 0;
+ }
+ }
+
+ /**
+ * 解析重复字符串，返回重复类型
+ * @param repeatStr 重复字符串
+ * @return 重复类型描述
+ */
+ private String parseRepeatString(String repeatStr) {
+ if (repeatStr.contains("每天")) {
+ return "每天";
+ } else if (repeatStr.contains("每周")) {
+ return "每周";
+ } else if (repeatStr.contains("每月")) {
+ return "每月";
+ } else if (repeatStr.contains("每年")) {
+ return "每年";
+ } else if (repeatStr.contains("周一")) {
+ return "每周一";
+ } else if (repeatStr.contains("周二")) {
+ return "每周二";
+ } else if (repeatStr.contains("周三")) {
+ return "每周三";
+ } else if (repeatStr.contains("周四")) {
+ return "每周四";
+ } else if (repeatStr.contains("周五")) {
+ return "每周五";
+ } else if (repeatStr.contains("周六")) {
+ return "每周六";
+ } else if (repeatStr.contains("周日")) {
+ return "每周日";
+ } else if (repeatStr.contains("周")) {
+ return "每周";
+ }
+ return "";
+ }
+
+ /**
+ * 获取星期对应的Calendar.DAY_OF_WEEK值
+ * @param dayStr 星期字符串
+ * @return Calendar.DAY_OF_WEEK值，-1表示解析失败
+ */
+ private int getDayOfWeek(String dayStr) {
+ if (dayStr.contains("周一") || dayStr.contains("星期一")) {
+ return Calendar.MONDAY;
+ } else if (dayStr.contains("周二") || dayStr.contains("星期二")) {
+ return Calendar.TUESDAY;
+ } else if (dayStr.contains("周三") || dayStr.contains("星期三")) {
+ return Calendar.WEDNESDAY;
+ } else if (dayStr.contains("周四") || dayStr.contains("星期四")) {
+ return Calendar.THURSDAY;
+ } else if (dayStr.contains("周五") || dayStr.contains("星期五")) {
+ return Calendar.FRIDAY;
+ } else if (dayStr.contains("周六") || dayStr.contains("星期六")) {
+ return Calendar.SATURDAY;
+ } else if (dayStr.contains("周日") || dayStr.contains("星期日")) {
+ return Calendar.SUNDAY;
+ }
+ return -1;
+ }
+
+ /**
+ * 根据重复类型计算下一次提醒时间
+ * @param currentTime 当前提醒时间
+ * @param repeatType 重复类型
+ * @return 下一次提醒时间戳
+ */
+ public long getNextRepeatTime(long currentTime, String repeatType) {
+ Calendar calendar = Calendar.getInstance();
+ calendar.setTimeInMillis(currentTime);
+
+ switch (repeatType) {
+ case "daily":
+ calendar.add(Calendar.DAY_OF_MONTH, 1);
+ break;
+ case "weekly":
+ calendar.add(Calendar.WEEK_OF_MONTH, 1);
+ break;
+ case "monthly":
+ calendar.add(Calendar.MONTH, 1);
+ break;
+ case "yearly":
+ calendar.add(Calendar.YEAR, 1);
+ break;
+ default:
+ return 0;
+ }
+
+ return calendar.getTimeInMillis();
+ }
+}
\ No newline at end of file
diff --git a/src/notes/tool/UserManager.java b/src/notes/tool/UserManager.java
new file mode 100644
index 0000000..7154346
--- /dev/null
+++ b/src/notes/tool/UserManager.java
@@ -0,0 +1,62 @@
+package net.micode.notes.tool;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+/**
+ * 用户管理工具类，用于管理用户登录状态
+ */
+public class UserManager {
+
+ private static final String PREF_NAME = "user_prefs";
+ private static final String KEY_IS_LOGGED_IN = "is_logged_in";
+ private static final String KEY_CURRENT_USER = "current_user";
+
+ private static UserManager instance;
+ private SharedPreferences sharedPreferences;
+
+ private UserManager(Context context) {
+ sharedPreferences = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
+ }
+
+ public static synchronized UserManager getInstance(Context context) {
+ if (instance == null) {
+ instance = new UserManager(context.getApplicationContext());
+ }
+ return instance;
+ }
+
+ /**
+ * 保存登录状态
+ */
+ public void saveLoginStatus(String username) {
+ sharedPreferences.edit()
+ .putBoolean(KEY_IS_LOGGED_IN, true)
+ .putString(KEY_CURRENT_USER, username)
+ .apply();
+ }
+
+ /**
+ * 检查是否已登录
+ */
+ public boolean isLoggedIn() {
+ return sharedPreferences.getBoolean(KEY_IS_LOGGED_IN, false);
+ }
+
+ /**
+ * 获取当前用户名
+ */
+ public String getCurrentUsername() {
+ return sharedPreferences.getString(KEY_CURRENT_USER, "");
+ }
+
+ /**
+ * 退出登录，清除登录状态
+ */
+ public void logout() {
+ sharedPreferences.edit()
+ .putBoolean(KEY_IS_LOGGED_IN, false)
+ .remove(KEY_CURRENT_USER)
+ .apply();
+ }
+}
\ No newline at end of file
diff --git a/src/notes/ui/AlarmInitReceiver.java b/src/notes/ui/AlarmInitReceiver.java
index 6020082..ee8b486 100644
--- a/src/notes/ui/AlarmInitReceiver.java
+++ b/src/notes/ui/AlarmInitReceiver.java
@@ -73,7 +73,12 @@ public class AlarmInitReceiver extends BroadcastReceiver {
sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId));
// 创建待定意图，用于闹钟管理器
- PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
+ // 在 Android 12+ 上必须指定 FLAG_IMMUTABLE 或 FLAG_MUTABLE
+ int flags = 0;
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.S) {
+ flags = PendingIntent.FLAG_IMMUTABLE;
+ }
+ PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, flags);
// 获取闹钟管理器服务
AlarmManager alarmManager = (AlarmManager) context
diff --git a/src/notes/ui/GestureLockView.java b/src/notes/ui/GestureLockView.java
new file mode 100644
index 0000000..d2d48f0
--- /dev/null
+++ b/src/notes/ui/GestureLockView.java
@@ -0,0 +1,264 @@
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.View;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 手势锁自定义视图
+ */
+public class GestureLockView extends View {
+ private static final int MATRIX_SIZE = 3; // 3x3矩阵
+
+ private Paint mPaint; // 画笔
+ private List mPoints; // 手势点集合
+ private List mSelectedPoints; // 已选择的点集合
+ private List mLines; // 连接线集合
+ private GesturePoint mCurrentPoint; // 当前手指位置点
+ private boolean mIsDrawing; // 是否正在绘制
+
+ private OnGestureCompleteListener mListener; // 手势完成监听器
+
+ public interface OnGestureCompleteListener {
+ void onGestureComplete(List selectedPoints);
+ }
+
+ public static class GesturePoint {
+ public float x; // X坐标
+ public float y; // Y坐标
+ public int index; // 点的索引 (0-8)
+ public boolean isSelected; // 是否被选中
+
+ public GesturePoint(float x, float y, int index) {
+ this.x = x;
+ this.y = y;
+ this.index = index;
+ this.isSelected = false;
+ }
+ }
+
+ public static class GestureLine {
+ public GesturePoint startPoint; // 起始点
+ public GesturePoint endPoint; // 结束点
+
+ public GestureLine(GesturePoint start, GesturePoint end) {
+ this.startPoint = start;
+ this.endPoint = end;
+ }
+ }
+
+ public GestureLockView(Context context) {
+ super(context);
+ init();
+ }
+
+ public GestureLockView(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ init();
+ }
+
+ public GestureLockView(Context context, AttributeSet attrs, int defStyleAttr) {
+ super(context, attrs, defStyleAttr);
+ init();
+ }
+
+ private void init() {
+ mPaint = new Paint();
+ mPaint.setAntiAlias(true); // 抗锯齿
+ mPaint.setStrokeWidth(4); // 线宽
+
+ mPoints = new ArrayList<>();
+ mSelectedPoints = new ArrayList<>();
+ mLines = new ArrayList<>();
+ }
+
+ @Override
+ protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+ super.onSizeChanged(w, h, oldw, oldh);
+
+ // 计算点的位置
+ int padding = Math.min(w, h) / 10; // 边距
+ int cellWidth = (w - 2 * padding) / (MATRIX_SIZE - 1); // 每个格子的宽度
+ int cellHeight = (h - 2 * padding) / (MATRIX_SIZE - 1); // 每个格子的高度
+
+ mPoints.clear();
+ for (int i = 0; i < MATRIX_SIZE; i++) {
+ for (int j = 0; j < MATRIX_SIZE; j++) {
+ float x = padding + j * cellWidth;
+ float y = padding + i * cellHeight;
+ mPoints.add(new GesturePoint(x, y, i * MATRIX_SIZE + j));
+ }
+ }
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ // 绘制所有点
+ for (GesturePoint point : mPoints) {
+ drawPoint(canvas, point);
+ }
+
+ // 绘制连接线
+ for (GestureLine line : mLines) {
+ drawLine(canvas, line);
+ }
+
+ // 如果正在绘制，绘制从最后一点到当前手指位置的连线
+ if (mIsDrawing && mCurrentPoint != null && !mSelectedPoints.isEmpty()) {
+ GesturePoint lastPoint = mPoints.get(mSelectedPoints.get(mSelectedPoints.size() - 1));
+ mPaint.setColor(Color.parseColor("#FFA500")); // 橙色
+ mPaint.setStyle(Paint.Style.STROKE);
+ canvas.drawLine(lastPoint.x, lastPoint.y, mCurrentPoint.x, mCurrentPoint.y, mPaint);
+ }
+ }
+
+ private void drawPoint(Canvas canvas, GesturePoint point) {
+ float radius = Math.min(getWidth(), getHeight()) / 15f; // 点的半径
+
+ if (point.isSelected) {
+ // 绘制选中的点（大圆圈）
+ mPaint.setColor(Color.parseColor("#FFA500")); // 橙色
+ mPaint.setStyle(Paint.Style.FILL);
+ canvas.drawCircle(point.x, point.y, radius, mPaint);
+
+ // 绘制内部小圆点
+ mPaint.setColor(Color.WHITE);
+ canvas.drawCircle(point.x, point.y, radius / 2, mPaint);
+ } else {
+ // 绘制未选中的点（圆环）
+ mPaint.setColor(Color.GRAY);
+ mPaint.setStyle(Paint.Style.STROKE);
+ mPaint.setStrokeWidth(4);
+ canvas.drawCircle(point.x, point.y, radius, mPaint);
+ }
+ }
+
+ private void drawLine(Canvas canvas, GestureLine line) {
+ mPaint.setColor(Color.parseColor("#FFA500")); // 橙色
+ mPaint.setStyle(Paint.Style.STROKE);
+ mPaint.setStrokeWidth(8);
+ canvas.drawLine(line.startPoint.x, line.startPoint.y,
+ line.endPoint.x, line.endPoint.y, mPaint);
+ }
+
+ @Override
+ public boolean onTouchEvent(MotionEvent event) {
+ float x = event.getX();
+ float y = event.getY();
+
+ switch (event.getAction()) {
+ case MotionEvent.ACTION_DOWN:
+ handleTouchDown(x, y);
+ break;
+ case MotionEvent.ACTION_MOVE:
+ handleTouchMove(x, y);
+ break;
+ case MotionEvent.ACTION_UP:
+ handleTouchUp();
+ break;
+ }
+
+ invalidate(); // 重绘
+ return true;
+ }
+
+ private void handleTouchDown(float x, float y) {
+ mSelectedPoints.clear();
+ mLines.clear();
+ mIsDrawing = true;
+
+ // 检查是否点击了某个点
+ for (GesturePoint point : mPoints) {
+ float distance = (float) Math.sqrt(Math.pow(x - point.x, 2) + Math.pow(y - point.y, 2));
+ if (distance < Math.min(getWidth(), getHeight()) / 10f) { // 如果在点的范围内
+ selectPoint(point);
+ break;
+ }
+ }
+ }
+
+ private void handleTouchMove(float x, float y) {
+ if (!mIsDrawing) return;
+
+ // 更新当前手指位置
+ mCurrentPoint = new GesturePoint(x, y, -1);
+
+ // 检查是否有新的点被经过
+ for (GesturePoint point : mPoints) {
+ if (point.isSelected) continue; // 已经选过的点不再处理
+
+ float distance = (float) Math.sqrt(Math.pow(x - point.x, 2) + Math.pow(y - point.y, 2));
+ if (distance < Math.min(getWidth(), getHeight()) / 10f) { // 如果在点的范围内
+ selectPoint(point);
+ break;
+ }
+ }
+ }
+
+ private void handleTouchUp() {
+ if (!mIsDrawing) return;
+
+ mIsDrawing = false;
+ mCurrentPoint = null;
+
+ // 通知手势完成
+ if (mListener != null && !mSelectedPoints.isEmpty()) {
+ mListener.onGestureComplete(mSelectedPoints);
+ }
+
+ // 重置状态
+ reset();
+ }
+
+ private void selectPoint(GesturePoint point) {
+ if (!point.isSelected) {
+ point.isSelected = true;
+ mSelectedPoints.add(point.index);
+
+ // 添加连接线（如果不是第一个点）
+ if (mSelectedPoints.size() > 1) {
+ int lastIndex = mSelectedPoints.get(mSelectedPoints.size() - 2);
+ GesturePoint lastPoint = mPoints.get(lastIndex);
+ mLines.add(new GestureLine(lastPoint, point));
+ }
+ }
+ }
+
+ private void reset() {
+ for (GesturePoint point : mPoints) {
+ point.isSelected = false;
+ }
+ mSelectedPoints.clear();
+ mLines.clear();
+ mCurrentPoint = null;
+ }
+
+ public void setOnGestureCompleteListener(OnGestureCompleteListener listener) {
+ this.mListener = listener;
+ }
+
+ /**
+ * 清除当前手势并重置视图
+ */
+ public void clearGesture() {
+ reset();
+ invalidate();
+ }
+
+ /**
+ * 获取当前手势点的数量
+ */
+ public int getSelectedPointsCount() {
+ return mSelectedPoints.size();
+ }
+}
\ No newline at end of file
diff --git a/src/notes/ui/LoginRegisterActivity.java b/src/notes/ui/LoginRegisterActivity.java
new file mode 100644
index 0000000..72801e0
--- /dev/null
+++ b/src/notes/ui/LoginRegisterActivity.java
@@ -0,0 +1,340 @@
+package net.micode.notes.ui;
+
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.view.View;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import net.micode.notes.R;
+import net.micode.notes.data.UserDatabaseHelper;
+import net.micode.notes.tool.UserManager;
+
+public class LoginRegisterActivity extends AppCompatActivity {
+
+ // UI组件
+ private TextView tvLoginTab;
+ private TextView tvRegisterTab;
+ private View tabIndicator;
+ private EditText etUsername;
+ private EditText etPassword;
+ private ImageView ivPasswordVisibility;
+ private CheckBox cbRememberPassword;
+ private TextView tvErrorMessage;
+ private Button btnAction;
+ private TextView tvForgotPassword;
+
+ // 数据库帮助类
+ private UserDatabaseHelper dbHelper;
+
+ // 用户管理器
+ private UserManager userManager;
+
+ // 当前状态：true为登录，false为注册
+ private boolean isLoginMode = true;
+
+ // 密码可见性状态
+ private boolean isPasswordVisible = false;
+
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_login_register);
+
+ // 初始化用户管理器
+ userManager = UserManager.getInstance(this);
+
+ // 每次都显示登录/注册界面，不自动登录
+ initViews();
+ initListeners();
+ updateUIForLoginMode();
+ }
+
+ /**
+ * 初始化视图组件
+ */
+ private void initViews() {
+ tvLoginTab = findViewById(R.id.tv_login_tab);
+ tvRegisterTab = findViewById(R.id.tv_register_tab);
+ tabIndicator = findViewById(R.id.tab_indicator);
+ etUsername = findViewById(R.id.et_username);
+ etPassword = findViewById(R.id.et_password);
+ ivPasswordVisibility = findViewById(R.id.iv_password_visibility);
+ cbRememberPassword = findViewById(R.id.cb_remember_password);
+ tvErrorMessage = findViewById(R.id.tv_error_message);
+ btnAction = findViewById(R.id.btn_action);
+ tvForgotPassword = findViewById(R.id.tv_forgot_password);
+
+ // 初始化数据库帮助类
+ dbHelper = UserDatabaseHelper.getInstance(this);
+
+ // 加载记住的密码
+ loadRememberedPassword();
+ }
+
+ /**
+ * 初始化监听器
+ */
+ private void initListeners() {
+ // 登录标签点击
+ tvLoginTab.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ isLoginMode = true;
+ updateUIForLoginMode();
+ }
+ });
+
+ // 注册标签点击
+ tvRegisterTab.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ isLoginMode = false;
+ updateUIForLoginMode();
+ }
+ });
+
+ // 密码可见性切换
+ ivPasswordVisibility.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ togglePasswordVisibility();
+ }
+ });
+
+ // 登录/注册按钮点击
+ btnAction.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ if (isLoginMode) {
+ performLogin();
+ } else {
+ performRegister();
+ }
+ }
+ });
+
+ // 忘记密码按钮点击
+ tvForgotPassword.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ showForgotPasswordDialog();
+ }
+ });
+ }
+
+ /**
+ * 更新UI以适应当前模式（登录或注册）
+ */
+ private void updateUIForLoginMode() {
+ if (isLoginMode) {
+ // 登录模式
+ tvLoginTab.setTextColor(getResources().getColor(android.R.color.holo_orange_dark));
+ tvRegisterTab.setTextColor(getResources().getColor(android.R.color.darker_gray));
+
+ // 更新指示器位置
+ RelativeLayout.LayoutParams params = (RelativeLayout.LayoutParams) tabIndicator.getLayoutParams();
+ params.leftMargin = 40; // 左侧位置
+ tabIndicator.setLayoutParams(params);
+
+ btnAction.setText("登录");
+ tvForgotPassword.setVisibility(View.VISIBLE);
+ } else {
+ // 注册模式
+ tvRegisterTab.setTextColor(getResources().getColor(android.R.color.holo_orange_dark));
+ tvLoginTab.setTextColor(getResources().getColor(android.R.color.darker_gray));
+
+ // 更新指示器位置
+ RelativeLayout.LayoutParams params = (RelativeLayout.LayoutParams) tabIndicator.getLayoutParams();
+ params.leftMargin = 120; // 右侧位置
+ tabIndicator.setLayoutParams(params);
+
+ btnAction.setText("注册");
+ tvForgotPassword.setVisibility(View.GONE);
+ }
+
+ // 清除错误消息
+ tvErrorMessage.setVisibility(View.GONE);
+ }
+
+ /**
+ * 切换密码可见性
+ */
+ private void togglePasswordVisibility() {
+ isPasswordVisible = !isPasswordVisible;
+ if (isPasswordVisible) {
+ etPassword.setInputType(android.text.InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD);
+ ivPasswordVisibility.setImageResource(android.R.drawable.ic_secure);
+ } else {
+ etPassword.setInputType(android.text.InputType.TYPE_CLASS_TEXT | android.text.InputType.TYPE_TEXT_VARIATION_PASSWORD);
+ ivPasswordVisibility.setImageResource(android.R.drawable.ic_lock_lock);
+ }
+
+ // 将光标移到末尾
+ etPassword.setSelection(etPassword.getText().length());
+ }
+
+ /**
+ * 执行登录操作
+ */
+ private void performLogin() {
+ String username = etUsername.getText().toString().trim();
+ String password = etPassword.getText().toString().trim();
+
+ // 验证输入
+ if (TextUtils.isEmpty(username)) {
+ showError("请输入用户名");
+ return;
+ }
+
+ if (TextUtils.isEmpty(password)) {
+ showError("请输入密码");
+ return;
+ }
+
+ // 验证用户凭据
+ if (dbHelper.authenticateUser(username, password)) {
+ // 登录成功，保存登录状态
+ userManager.saveLoginStatus(username);
+
+ // 保存记住的密码
+ if (cbRememberPassword.isChecked()) {
+ saveRememberedPassword(username, password);
+ } else {
+ clearRememberedPassword();
+ }
+
+ // 跳转到主页面
+ Intent intent = new Intent(this, NotesListActivity.class);
+ startActivity(intent);
+ finish();
+
+ Toast.makeText(this, "登录成功", Toast.LENGTH_SHORT).show();
+ } else {
+ showError("用户名或密码错误，请重新输入");
+ }
+ }
+
+ /**
+ * 保存记住的密码
+ */
+ private void saveRememberedPassword(String username, String password) {
+ SharedPreferences sharedPreferences = getSharedPreferences("login_prefs", Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = sharedPreferences.edit();
+ editor.putBoolean("remember_password", true);
+ editor.putString("username", username);
+ editor.putString("password", password);
+ editor.apply();
+ }
+
+ /**
+ * 加载记住的密码
+ */
+ private void loadRememberedPassword() {
+ SharedPreferences sharedPreferences = getSharedPreferences("login_prefs", Context.MODE_PRIVATE);
+ boolean rememberPassword = sharedPreferences.getBoolean("remember_password", false);
+ if (rememberPassword) {
+ String username = sharedPreferences.getString("username", "");
+ String password = sharedPreferences.getString("password", "");
+ etUsername.setText(username);
+ etPassword.setText(password);
+ cbRememberPassword.setChecked(true);
+ }
+ }
+
+ /**
+ * 清除记住的密码
+ */
+ private void clearRememberedPassword() {
+ SharedPreferences sharedPreferences = getSharedPreferences("login_prefs", Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = sharedPreferences.edit();
+ editor.putBoolean("remember_password", false);
+ editor.remove("username");
+ editor.remove("password");
+ editor.apply();
+ }
+
+ /**
+ * 执行注册操作
+ */
+ private void performRegister() {
+ String username = etUsername.getText().toString().trim();
+ String password = etPassword.getText().toString().trim();
+
+ // 验证输入
+ if (TextUtils.isEmpty(username)) {
+ showError("请输入用户名");
+ return;
+ }
+
+ if (username.length() < 3) {
+ showError("用户名长度不能少于3位");
+ return;
+ }
+
+ if (TextUtils.isEmpty(password)) {
+ showError("请输入密码");
+ return;
+ }
+
+ if (password.length() < 6) {
+ showError("密码长度不能少于6位");
+ return;
+ }
+
+ // 检查用户名是否已存在
+ if (dbHelper.isUsernameExists(username)) {
+ showError("该用户名已注册，请直接登录");
+ return;
+ }
+
+ // 注册用户
+ boolean success = dbHelper.registerUser(username, password);
+ if (success) {
+ Toast.makeText(this, "注册成功", Toast.LENGTH_SHORT).show();
+
+ // 自动切换到登录模式
+ isLoginMode = true;
+ updateUIForLoginMode();
+ } else {
+ showError("注册失败，请重试");
+ }
+ }
+
+ /**
+ * 显示错误消息
+ */
+ private void showError(String message) {
+ tvErrorMessage.setText(message);
+ tvErrorMessage.setVisibility(View.VISIBLE);
+ }
+
+ /**
+ * 显示忘记密码对话框
+ */
+ private void showForgotPasswordDialog() {
+ new AlertDialog.Builder(this)
+ .setTitle("忘记密码")
+ .setMessage("请联系管理员重置密码（测试版）")
+ .setPositiveButton("确定", new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ dialog.dismiss();
+ }
+ })
+ .show();
+ }
+}
diff --git a/src/notes/ui/NoteEditActivity.java b/src/notes/ui/NoteEditActivity.java
index 8f2e9d8..47cd7c7 100644
--- a/src/notes/ui/NoteEditActivity.java
+++ b/src/notes/ui/NoteEditActivity.java
@@ -32,6 +32,7 @@ import android.os.Bundle;
import android.preference.PreferenceManager;
import android.text.Spannable;
import android.text.SpannableString;
+import android.text.InputType;
import android.text.TextUtils;
import android.text.format.DateUtils;
import android.text.style.BackgroundColorSpan;
@@ -47,10 +48,16 @@ import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.CompoundButton.OnCheckedChangeListener;
import android.widget.EditText;
+import android.net.Uri;
+import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;
+import android.widget.ArrayAdapter;
+import android.database.Cursor;
+import java.util.ArrayList;
+import java.util.List;
import net.micode.notes.R;
import net.micode.notes.data.Notes;
@@ -60,6 +67,8 @@ 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.tool.SmartReminderManager;
+import net.micode.notes.tool.AIService;
import net.micode.notes.ui.DateTimePickerDialog.OnDateTimeSetListener;
import net.micode.notes.ui.NoteEditText.OnTextViewChangeListener;
import net.micode.notes.widget.NoteWidgetProvider_2x;
@@ -86,6 +95,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
public ImageView ivAlertIcon; // 提醒图标
public TextView tvAlertDate; // 提醒日期文本
public ImageView ibSetBgColor; // 设置背景颜色的按钮
+ public ImageView ibSetTag; // 设置标签的按钮
+ public TextView tvTag; // 显示标签的文本视图
}
// 背景颜色选择按钮与颜色ID的映射
@@ -126,20 +137,52 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
}
+ // 标签常量
+ public static final String TAG_LIFE = "life";
+ public static final String TAG_STUDY = "study";
+ public static final String TAG_WORK = "work";
+ public static final String TAG_CUSTOM = "custom";
+
+ // 标签选择按钮与标签值的映射
+ private static final Map sTagSelectorBtnsMap = new HashMap();
+ static {
+ sTagSelectorBtnsMap.put(R.id.iv_tag_life, TAG_LIFE);
+ sTagSelectorBtnsMap.put(R.id.iv_tag_study, TAG_STUDY);
+ sTagSelectorBtnsMap.put(R.id.iv_tag_work, TAG_WORK);
+ sTagSelectorBtnsMap.put(R.id.iv_tag_custom, TAG_CUSTOM);
+ }
+
+ // 标签值与选中状态视图的映射
+ private static final Map sTagSelectorSelectionMap = new HashMap();
+ static {
+ sTagSelectorSelectionMap.put(TAG_LIFE, R.id.iv_tag_life_select);
+ sTagSelectorSelectionMap.put(TAG_STUDY, R.id.iv_tag_study_select);
+ sTagSelectorSelectionMap.put(TAG_WORK, R.id.iv_tag_work_select);
+ sTagSelectorSelectionMap.put(TAG_CUSTOM, R.id.iv_tag_custom_select);
+ }
+
private static final String TAG = "NoteEditActivity";
private HeadViewHolder mNoteHeaderHolder; // 头部视图持有者实例
private View mHeadViewPanel; // 头部面板视图
private View mNoteBgColorSelector; // 背景颜色选择器面板
+ private View mNoteTagSelector; // 标签选择器面板
private View mFontSizeSelector; // 字体大小选择器面板
+ private EditText mNoteTitle; // 笔记标题编辑器
private EditText mNoteEditor; // 笔记内容编辑器（普通模式）
private View mNoteEditorPanel; // 编辑器面板
private WorkingNote mWorkingNote; // 当前正在编辑的笔记数据模型
private SharedPreferences mSharedPrefs; // 偏好设置
private int mFontSizeId; // 当前字体大小ID
+
+ // 位置提醒对话框相关控件
+ private EditText mLocationNameEditText; // 位置名称输入框
+ private EditText mLatitudeEditText; // 纬度输入框
+ private EditText mLongitudeEditText; // 经度输入框
private static final String PREFERENCE_FONT_SIZE = "pref_font_size"; // 字体大小偏好设置键
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10; // 桌面快捷方式标题最大长度
+ private static final int REQUEST_CODE_SELECT_LOCATION = 1001; // 选择位置请求码
// 清单模式下的标记符号
public static final String TAG_CHECKED = String.valueOf('\u221A'); // 对勾符号 √
@@ -148,6 +191,22 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private LinearLayout mEditTextList; // 清单模式下的编辑框列表容器
private String mUserQuery; // 用户搜索查询词（从搜索跳转过来时使用）
private Pattern mPattern; // 用于高亮搜索词的正则表达式模式
+ private SmartReminderManager mSmartReminderManager; // 智能提醒管理器实例
+ private AIService mAIService; // AI服务实例，用于智能生成标题
+
+ // 图片选择相关常量
+ private static final int REQUEST_CODE_PICK_IMAGE = 100; // 相册选择请求码
+ private static final int REQUEST_CODE_CHOOSE_IMAGE = 101; // 系统图片选择请求码
+
+ // 富文本编辑相关控件
+ private LinearLayout mFormatToolbar; // 格式工具栏
+ private Button mBtnBold; // 粗体按钮
+ private Button mBtnItalic; // 斜体按钮
+ private Button mBtnUnderline; // 下划线按钮
+ private Button mBtnStrikethrough; // 删除线按钮
+
+ // 图片选择相关UI组件
+ private ImageView mBtnAddImage; // 添加图片按钮
/**
* Activity创建时的初始化方法
@@ -163,6 +222,45 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return;
}
initResources(); // 初始化视图资源
+
+ // 初始化智能提醒管理器
+ mSmartReminderManager = new SmartReminderManager(this);
+
+ // 初始化AI服务
+ mAIService = new AIService(this);
+ mAIService.setOnAITitleGeneratedListener(new AIService.OnAITitleGeneratedListener() {
+ @Override
+ public void onTitleGenerated(String title) {
+ // 只有当标题为空时，才自动填充AI生成的标题
+ if (TextUtils.isEmpty(mNoteTitle.getText())) {
+ mNoteTitle.setText(title);
+ }
+ }
+ });
+
+ // 添加对OnBackPressedDispatcher的支持，以便处理手势返回
+ try {
+ // 使用反射调用getOnBackPressedDispatcher方法，添加一个空回调
+ // 这样可以确保手势返回功能正常工作，同时保持原有代码不变
+ Object dispatcher = getClass().getMethod("getOnBackPressedDispatcher").invoke(this);
+ Class callbackClass = Class.forName("androidx.activity.OnBackPressedCallback");
+ Object callback = callbackClass.getConstructor(boolean.class).newInstance(true);
+ Class callbackInterface = Class.forName("androidx.activity.OnBackPressedCallback$OnBackPressedListener");
+ Object listener = java.lang.reflect.Proxy.newProxyInstance(
+ callbackInterface.getClassLoader(),
+ new Class[]{callbackInterface},
+ (proxy, method, args) -> {
+ // 调用原有的onBackPressed方法
+ onBackPressed();
+ return null;
+ }
+ );
+ callbackClass.getMethod("addOnBackPressedListener", callbackInterface).invoke(callback, listener);
+ dispatcher.getClass().getMethod("addCallback", Activity.class, callbackClass).invoke(dispatcher, this, callback);
+ } catch (Exception e) {
+ // 如果反射调用失败，不影响原有功能
+ Log.d("NoteEditActivity", "OnBackPressedDispatcher not available, using legacy onBackPressed");
+ }
}
/**
@@ -290,14 +388,34 @@ public class NoteEditActivity extends Activity implements OnClickListener,
// 设置编辑器字体大小
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
+ mNoteTitle.setTextAppearance(this, TextAppearanceResources
+ .getTexAppearanceResource(mFontSizeId));
// 根据笔记模式初始化界面
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
// 清单模式
switchToListMode(mWorkingNote.getContent());
+ // 隐藏标题和普通编辑器，显示清单编辑器
+ mNoteTitle.setVisibility(View.GONE);
+ mNoteEditor.setVisibility(View.GONE);
+ mEditTextList.setVisibility(View.VISIBLE);
} else {
- // 普通文本模式，高亮搜索词
- mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
+ // 普通文本模式，显示标题和正文
+ mNoteTitle.setVisibility(View.VISIBLE);
+ mNoteEditor.setVisibility(View.VISIBLE);
+ mEditTextList.setVisibility(View.GONE);
+ // 显示富文本工具栏
+ mFormatToolbar.setVisibility(View.VISIBLE);
+
+ // 拆分标题和正文
+ String title = mWorkingNote.getTitle();
+ String content = mWorkingNote.getContentWithoutTitle();
+
+ // 设置标题和正文
+ mNoteTitle.setText(title);
+ mNoteEditor.setText(getHighlightQueryResult(content, mUserQuery));
+ // 保存当前编辑状态
+ mWorkingNote.setTitleAndContent(title, content);
mNoteEditor.setSelection(mNoteEditor.getText().length());
}
@@ -316,22 +434,132 @@ public class NoteEditActivity extends Activity implements OnClickListener,
| DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
| DateUtils.FORMAT_SHOW_YEAR));
+ // 设置标签显示
+ String currentTag = mWorkingNote.getTag();
+ if (currentTag != null && !currentTag.isEmpty()) {
+ String tagText = "";
+ if (TAG_LIFE.equals(currentTag)) {
+ tagText = "生活";
+ } else if (TAG_STUDY.equals(currentTag)) {
+ tagText = "学习";
+ } else if (TAG_WORK.equals(currentTag)) {
+ tagText = "工作";
+ } else {
+ tagText = currentTag; // 直接显示自定义标签值
+ }
+ mNoteHeaderHolder.tvTag.setText("标签：" + tagText);
+ } else {
+ mNoteHeaderHolder.tvTag.setText("");
+ }
+
// 显示提醒信息
showAlertHeader();
+
+ // 检查关联提醒
+ checkRelatedNotes();
+ }
+
+ /**
+ * 检查是否有关联的笔记，并显示提醒
+ */
+ private void checkRelatedNotes() {
+ // 只有当笔记已存在于数据库时才检查关联
+ if (mWorkingNote.existInDatabase()) {
+ // 获取当前笔记内容
+ String currentContent = mWorkingNote.getContent();
+
+ // 查询所有可见的笔记
+ Cursor cursor = getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ new String[]{Notes.NoteColumns.ID, Notes.NoteColumns.SNIPPET}, // 只查询ID和内容片段
+ Notes.NoteColumns.TYPE + "=? AND " + Notes.NoteColumns.ID + "!=?", // 只查询笔记类型，排除当前笔记
+ new String[]{String.valueOf(Notes.TYPE_NOTE), String.valueOf(mWorkingNote.getNoteId())},
+ null
+ );
+
+ if (cursor != null && cursor.moveToFirst()) {
+ List relatedNoteIds = new ArrayList<>();
+ List relatedNoteSnippets = new ArrayList<>();
+
+ do {
+ long noteId = cursor.getLong(0);
+ String snippet = cursor.getString(1);
+
+ // 检查是否相关
+ if (mSmartReminderManager.areNotesRelated(currentContent, snippet)) {
+ relatedNoteIds.add(noteId);
+ relatedNoteSnippets.add(snippet);
+ }
+ } while (cursor.moveToNext());
+
+ cursor.close();
+
+ // 如果找到相关笔记，显示提醒
+ if (!relatedNoteIds.isEmpty()) {
+ showRelatedNotesAlert(relatedNoteIds, relatedNoteSnippets);
+ }
+ } else if (cursor != null) {
+ cursor.close();
+ }
+ }
+ }
+
+ /**
+ * 显示关联笔记提醒对话框
+ */
+ private void showRelatedNotesAlert(List relatedNoteIds, List relatedNoteSnippets) {
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle("关联笔记提醒");
+
+ // 创建列表适配器
+ ArrayAdapter adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, relatedNoteSnippets);
+
+ builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ // 打开选中的关联笔记
+ long noteId = relatedNoteIds.get(which);
+ Intent intent = new Intent(NoteEditActivity.this, NoteEditActivity.class);
+ intent.setAction(Intent.ACTION_VIEW);
+ intent.putExtra(Intent.EXTRA_UID, noteId);
+ startActivity(intent);
+ }
+ });
+
+ builder.setNegativeButton("取消", null);
+ builder.show();
}
/**
* 显示或隐藏提醒相关的UI组件
*/
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));
+ boolean hasClockAlert = mWorkingNote.hasClockAlert();
+ boolean hasLocationAlert = mWorkingNote.hasLocationAlert();
+
+ if (hasClockAlert || hasLocationAlert) {
+ StringBuilder alertText = new StringBuilder();
+
+ // 添加时间提醒信息
+ if (hasClockAlert) {
+ long time = System.currentTimeMillis();
+ if (time > mWorkingNote.getAlertDate()) {
+ alertText.append(getString(R.string.note_alert_expired));
+ } else {
+ alertText.append(DateUtils.getRelativeTimeSpanString(
+ mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
+ }
}
+
+ // 添加位置提醒信息
+ if (hasLocationAlert) {
+ if (hasClockAlert) {
+ alertText.append(" | ");
+ }
+ alertText.append("位置: ").append(mWorkingNote.getAlertLocationName());
+ }
+
+ mNoteHeaderHolder.tvAlertDate.setText(alertText.toString());
mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
} else {
@@ -363,6 +591,52 @@ public class NoteEditActivity extends Activity implements OnClickListener,
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
+ /**
+ * 处理从地图应用返回的位置数据和图片选择结果
+ */
+ @Override
+ protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+ super.onActivityResult(requestCode, resultCode, data);
+ if (resultCode == RESULT_OK) {
+ if (requestCode == REQUEST_CODE_SELECT_LOCATION) {
+ if (data != null && data.getData() != null) {
+ Uri uri = data.getData();
+ String geoString = uri.toString();
+
+ // 解析地图应用返回的位置数据
+ // 格式通常为: geo:latitude,longitude?q=address
+ Pattern pattern = Pattern.compile("geo:([-0-9.]+),([-0-9.]+)");
+ Matcher matcher = pattern.matcher(geoString);
+ if (matcher.find()) {
+ try {
+ double latitude = Double.parseDouble(matcher.group(1));
+ double longitude = Double.parseDouble(matcher.group(2));
+
+ // 更新UI显示选择的位置
+ Toast.makeText(this, "位置已选择: " + latitude + ", " + longitude, Toast.LENGTH_SHORT).show();
+
+ // 更新对话框中的输入框
+ if (mLatitudeEditText != null) {
+ mLatitudeEditText.setText(String.valueOf(latitude));
+ }
+ if (mLongitudeEditText != null) {
+ mLongitudeEditText.setText(String.valueOf(longitude));
+ }
+ } catch (NumberFormatException e) {
+ Toast.makeText(this, "解析位置数据失败", Toast.LENGTH_SHORT).show();
+ }
+ }
+ }
+ } else if (requestCode == REQUEST_CODE_PICK_IMAGE || requestCode == REQUEST_CODE_CHOOSE_IMAGE) {
+ // 处理图片选择结果
+ if (data != null && data.getData() != null) {
+ Uri imageUri = data.getData();
+ insertImageToEditor(imageUri);
+ }
+ }
+ }
+ }
+
/**
* 触摸事件分发，用于点击选择器外部时关闭选择器
*/
@@ -408,11 +682,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
- mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
- mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
+ mNoteHeaderHolder.tvTag = (TextView) findViewById(R.id.tv_tag);
+ mNoteTitle = (EditText) findViewById(R.id.note_title_view);
mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
mNoteEditorPanel = findViewById(R.id.sv_note_edit);
mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
+ mNoteTagSelector = findViewById(R.id.note_tag_selector);
// 设置背景颜色选择按钮的点击监听
for (int id : sBgSelectorBtnsMap.keySet()) {
@@ -420,6 +695,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
iv.setOnClickListener(this);
}
+ // 设置标签选择按钮的点击监听
+ for (int id : sTagSelectorBtnsMap.keySet()) {
+ ImageView iv = (ImageView) findViewById(id);
+ iv.setOnClickListener(this);
+ }
+
mFontSizeSelector = findViewById(R.id.font_size_selector);
// 设置字体大小选择项的点击监听
for (int id : sFontSizeBtnsMap.keySet()) {
@@ -435,6 +716,84 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mFontSizeId = ResourceParser.BG_DEFAULT_FONT_SIZE;
}
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
+
+ // 初始化富文本编辑工具栏
+ mFormatToolbar = findViewById(R.id.format_toolbar);
+ mBtnBold = findViewById(R.id.btn_bold);
+ mBtnItalic = findViewById(R.id.btn_italic);
+ mBtnUnderline = findViewById(R.id.btn_underline);
+ mBtnStrikethrough = findViewById(R.id.btn_strikethrough);
+
+ // 设置富文本按钮点击监听
+ mBtnBold.setOnClickListener(this);
+ mBtnItalic.setOnClickListener(this);
+ mBtnUnderline.setOnClickListener(this);
+ mBtnStrikethrough.setOnClickListener(this);
+
+ // 添加正文变化监听，实现智能标题推荐
+ mNoteEditor.addTextChangedListener(new android.text.TextWatcher() {
+ private long mLastTextChangeTime = 0;
+ private static final long DEBOUNCE_DELAY = 1000; // 防抖延迟1秒
+
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ }
+
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ }
+
+ @Override
+ public void afterTextChanged(android.text.Editable s) {
+ // 只有当标题为空时，才自动推荐标题
+ if (TextUtils.isEmpty(mNoteTitle.getText())) {
+ long currentTime = System.currentTimeMillis();
+ // 防抖处理，避免频繁调用AI服务
+ if (currentTime - mLastTextChangeTime > DEBOUNCE_DELAY) {
+ mLastTextChangeTime = currentTime;
+ // 使用AI服务生成智能标题
+ mAIService.generateSmartTitle(s.toString());
+ }
+ }
+ }
+ });
+
+ // 初始化图片相关功能
+ setupImageFunctionality();
+ }
+
+ /**
+ * 初始化图片相关功能
+ */
+ private void setupImageFunctionality() {
+ // 设置图片删除处理
+ setupImageDeletionHandling();
+ }
+
+ /**
+ * 设置图片删除处理
+ */
+ private void setupImageDeletionHandling() {
+ // 监听编辑器内容变化，处理图片删除
+ mNoteEditor.addTextChangedListener(new android.text.TextWatcher() {
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ }
+
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ }
+
+ @Override
+ public void afterTextChanged(android.text.Editable s) {
+ // 检查是否有图片被删除
+ android.text.style.ImageSpan[] imageSpans =
+ s.getSpans(0, s.length(), android.text.style.ImageSpan.class);
+ if (imageSpans.length > 0) {
+ // 图片存在，不需要特殊处理
+ }
+ }
+ });
}
/**
@@ -479,12 +838,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
public void onClick(View v) {
int id = v.getId();
- if (id == R.id.btn_set_bg_color) {
- // 点击背景颜色设置按钮，显示颜色选择器
+ if (id == R.id.btn_set_color) {
+ // 点击设置按钮，显示选择对话框
mNoteBgColorSelector.setVisibility(View.VISIBLE);
- // 显示当前选中颜色的标记
- findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
- View.VISIBLE);
+ mNoteTagSelector.setVisibility(View.VISIBLE);
} else if (sBgSelectorBtnsMap.containsKey(id)) {
// 点击了某个背景颜色按钮
// 隐藏之前选中颜色的标记
@@ -493,6 +850,21 @@ public class NoteEditActivity extends Activity implements OnClickListener,
// 更新笔记的背景颜色ID
mWorkingNote.setBgColorId(sBgSelectorBtnsMap.get(id));
mNoteBgColorSelector.setVisibility(View.GONE); // 隐藏选择器
+ } else if (sTagSelectorBtnsMap.containsKey(id)) {
+ // 点击了某个标签按钮
+ // 隐藏之前选中标签的标记
+ String currentTag = mWorkingNote.getTag();
+ if (currentTag != null || currentTag.isEmpty()) {
+ currentTag = "";
+ }
+ Integer selectId = sTagSelectorSelectionMap.get(currentTag);
+ if (selectId != null) {
+ findViewById(selectId).setVisibility(View.GONE);
+ }
+ } else if (id == R.id.btn_bold || id == R.id.btn_italic ||
+ id == R.id.btn_underline || id == R.id.btn_strikethrough) {
+ // 处理富文本编辑按钮点击
+ handleRichTextFormatting(v);
} else if (sFontSizeBtnsMap.containsKey(id)) {
// 点击了字体大小选项
// 隐藏之前选中字体的标记
@@ -540,6 +912,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE) {
mNoteBgColorSelector.setVisibility(View.GONE);
return true;
+ } else if (mNoteTagSelector.getVisibility() == View.VISIBLE) {
+ mNoteTagSelector.setVisibility(View.GONE);
+ return true;
} else if (mFontSizeSelector.getVisibility() == View.VISIBLE) {
mFontSizeSelector.setVisibility(View.GONE);
return true;
@@ -559,6 +934,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
}
+ /**
+ * 创建选项菜单
+ */
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ // 根据笔记类型加载不同的菜单
+ if (mWorkingNote.getFolderId() == Notes.ID_CALL_RECORD_FOLDER) {
+ getMenuInflater().inflate(R.menu.call_note_edit, menu);
+ } else {
+ getMenuInflater().inflate(R.menu.note_edit, menu);
+ }
+ return true;
+ }
+
/**
* 准备选项菜单
*/
@@ -592,6 +981,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
menu.findItem(R.id.menu_alert).setVisible(true);
menu.findItem(R.id.menu_delete_remind).setVisible(false);
}
+
+ // 根据是否有位置提醒设置菜单项显示
+ if (mWorkingNote.hasLocationAlert()) {
+ menu.findItem(R.id.menu_location_alert).setVisible(false);
+ menu.findItem(R.id.menu_delete_location_remind).setVisible(true);
+ } else {
+ menu.findItem(R.id.menu_location_alert).setVisible(true);
+ menu.findItem(R.id.menu_delete_location_remind).setVisible(false);
+ }
return true;
}
@@ -648,6 +1046,24 @@ public class NoteEditActivity extends Activity implements OnClickListener,
// 删除提醒
mWorkingNote.setAlertDate(0, false);
break;
+
+ case R.id.menu_location_alert:
+ // 设置位置提醒
+ setLocationReminder();
+ break;
+
+ case R.id.menu_delete_location_remind:
+ // 删除位置提醒
+ mWorkingNote.setAlertLocation(0, 0, 0, "", false);
+ break;
+ case R.id.menu_tag:
+ // 显示标签选择对话框
+ showTagSelectorDialog();
+ break;
+ case R.id.menu_add_image:
+ // 显示图片选择对话框
+ showImageSelectionDialog();
+ break;
default:
break;
}
@@ -658,16 +1074,476 @@ public class NoteEditActivity extends Activity implements OnClickListener,
* 设置提醒时间
*/
private void setReminder() {
+ // 获取当前笔记内容到mWorkingNote对象
+ getWorkingText();
+ String content = mWorkingNote.getContent();
+
+ // 使用智能提醒管理器获取建议的提醒时间
+ long suggestedTime = mSmartReminderManager.suggestReminderTime(content);
+ String suggestedRepeatType = mSmartReminderManager.suggestRepeatType(content);
+
+ // 如果没有获取到建议时间，使用当前时间
+ long initialTime = suggestedTime > 0 ? suggestedTime : System.currentTimeMillis();
+
// 创建日期时间选择对话框
- DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
+ DateTimePickerDialog d = new DateTimePickerDialog(this, initialTime);
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
public void OnDateTimeSet(AlertDialog dialog, long date) {
// 设置提醒日期
mWorkingNote.setAlertDate(date, true);
+
+ // 显示智能建议的重复频率
+ if (!TextUtils.isEmpty(suggestedRepeatType)) {
+ new AlertDialog.Builder(NoteEditActivity.this)
+ .setTitle("智能重复建议")
+ .setMessage("根据笔记内容，建议设置为" + suggestedRepeatType + "重复")
+ .setPositiveButton("设置", new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ // 这里可以添加设置重复提醒的逻辑
+ // 目前应用只支持单次提醒，所以只做提示
+ Toast.makeText(NoteEditActivity.this, "智能建议已显示，当前版本暂不支持重复提醒", Toast.LENGTH_SHORT).show();
+ }
+ })
+ .setNegativeButton("取消", null)
+ .show();
+ }
}
});
d.show();
}
+
+ /**
+ * 显示图片选择对话框
+ */
+ private void showImageSelectionDialog() {
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle("选择图片"); // 标题
+
+ // 创建垂直排列的按钮布局
+ LinearLayout layout = new LinearLayout(this);
+ layout.setOrientation(LinearLayout.VERTICAL);
+ layout.setPadding(50, 30, 50, 30);
+
+ // 相册按钮
+ Button albumBtn = new Button(this);
+ albumBtn.setText("相册");
+ albumBtn.setAllCaps(false); // 不要大写
+ albumBtn.setOnClickListener(new View.OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ openGallery();
+ }
+ });
+
+ layout.addView(albumBtn);
+
+ builder.setView(layout);
+ builder.setNegativeButton("取消", null);
+ builder.show();
+ }
+
+ /**
+ * 打开相册选择图片
+ */
+ private void openGallery() {
+ // 使用更通用的ACTION_GET_CONTENT，避免直接访问存储
+ Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
+ intent.setType("image/*");
+ intent.addCategory(Intent.CATEGORY_OPENABLE);
+
+ // 使用Intent.createChooser确保能打开选择器
+ Intent chooserIntent = Intent.createChooser(intent, "选择图片");
+ if (chooserIntent.resolveActivity(getPackageManager()) != null) {
+ // 对于ACTION_GET_CONTENT，系统会自动处理权限，不需要手动请求READ_EXTERNAL_STORAGE
+ startActivityForResult(chooserIntent, REQUEST_CODE_PICK_IMAGE);
+ } else {
+ Toast.makeText(this, "设备不支持图片选择功能", Toast.LENGTH_SHORT).show();
+ }
+ }
+
+ /**
+ * 处理权限请求结果
+ */
+ @Override
+ public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+ super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+ if (requestCode == 100) {
+ if (grantResults.length > 0 && grantResults[0] == android.content.pm.PackageManager.PERMISSION_GRANTED) {
+ // 权限被授予，重新打开相册
+ openGallery();
+ } else {
+ Toast.makeText(this, "需要存储权限才能选择图片", Toast.LENGTH_SHORT).show();
+ }
+ }
+ }
+
+ /**
+ * 处理富文本格式设置
+ * @param v 点击的视图
+ */
+ private void handleRichTextFormatting(View v) {
+ int id = v.getId();
+ android.text.Editable editable = mNoteEditor.getText();
+ int start = mNoteEditor.getSelectionStart();
+ int end = mNoteEditor.getSelectionEnd();
+
+ // 如果没有选中文本，不进行格式设置
+ if (start == end) {
+ Toast.makeText(this, "请先选中文本", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ // 应用相应的格式
+ if (id == R.id.btn_bold) {
+ // 应用或移除粗体格式
+ applyOrRemoveStyleSpan(editable, start, end, android.graphics.Typeface.BOLD);
+ } else if (id == R.id.btn_italic) {
+ // 应用或移除斜体格式
+ applyOrRemoveStyleSpan(editable, start, end, android.graphics.Typeface.ITALIC);
+ } else if (id == R.id.btn_underline) {
+ // 应用或移除下划线格式
+ applyOrRemoveUnderlineSpan(editable, start, end);
+ } else if (id == R.id.btn_strikethrough) {
+ // 应用或移除删除线格式
+ applyOrRemoveStrikethroughSpan(editable, start, end);
+ }
+ }
+
+ /**
+ * 应用或移除StyleSpan（粗体、斜体等）
+ */
+ private void applyOrRemoveStyleSpan(android.text.Editable editable, int start, int end, int style) {
+ android.text.style.StyleSpan[] spans = editable.getSpans(start, end, android.text.style.StyleSpan.class);
+ boolean hasStyle = false;
+
+ // 检查是否已应用该样式
+ for (android.text.style.StyleSpan span : spans) {
+ if (span.getStyle() == style) {
+ hasStyle = true;
+ editable.removeSpan(span);
+ }
+ }
+
+ // 如果没有应用该样式，则添加
+ if (!hasStyle) {
+ editable.setSpan(new android.text.style.StyleSpan(style), start, end, android.text.Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+ /**
+ * 应用或移除下划线格式
+ */
+ private void applyOrRemoveUnderlineSpan(android.text.Editable editable, int start, int end) {
+ android.text.style.UnderlineSpan[] spans = editable.getSpans(start, end, android.text.style.UnderlineSpan.class);
+
+ // 如果已应用下划线，则移除
+ if (spans.length > 0) {
+ for (android.text.style.UnderlineSpan span : spans) {
+ editable.removeSpan(span);
+ }
+ } else {
+ // 否则添加下划线
+ editable.setSpan(new android.text.style.UnderlineSpan(), start, end, android.text.Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+ /**
+ * 应用或移除删除线格式
+ */
+ private void applyOrRemoveStrikethroughSpan(android.text.Editable editable, int start, int end) {
+ android.text.style.StrikethroughSpan[] spans = editable.getSpans(start, end, android.text.style.StrikethroughSpan.class);
+
+ // 如果已应用删除线，则移除
+ if (spans.length > 0) {
+ for (android.text.style.StrikethroughSpan span : spans) {
+ editable.removeSpan(span);
+ }
+ } else {
+ // 否则添加删除线
+ editable.setSpan(new android.text.style.StrikethroughSpan(), start, end, android.text.Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+ /**
+ * 将图片插入到编辑器中
+ * @param imageUri 图片Uri
+ */
+ private void insertImageToEditor(Uri imageUri) {
+ try {
+ // 获取当前光标位置
+ int cursorPos = mNoteEditor.getSelectionStart();
+
+ // 从Uri获取图片Bitmap
+ android.graphics.Bitmap bitmap = android.graphics.BitmapFactory.decodeStream(getContentResolver().openInputStream(imageUri));
+ if (bitmap == null) {
+ Toast.makeText(this, "无法加载图片", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ // 缩放图片以适应编辑器
+ int maxWidth = mNoteEditor.getWidth() - mNoteEditor.getPaddingLeft() - mNoteEditor.getPaddingRight();
+ int maxHeight = 500; // 设置最大高度
+ float scale = Math.min((float) maxWidth / bitmap.getWidth(), (float) maxHeight / bitmap.getHeight());
+ android.graphics.Matrix matrix = new android.graphics.Matrix();
+ matrix.postScale(scale, scale);
+ android.graphics.Bitmap scaledBitmap = android.graphics.Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+
+ // 创建ImageSpan并插入到编辑器
+ android.text.SpannableStringBuilder ssb = new android.text.SpannableStringBuilder(mNoteEditor.getText());
+ ssb.insert(cursorPos, " "); // 插入一个空格作为图片占位符
+ android.text.style.ImageSpan imageSpan = new android.text.style.ImageSpan(this, scaledBitmap);
+ ssb.setSpan(imageSpan, cursorPos, cursorPos + 1, android.text.Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+
+ // 更新编辑器内容
+ mNoteEditor.setText(ssb);
+ mNoteEditor.setSelection(cursorPos + 1);
+
+ // 保存图片路径到数据库
+ String imagePath = getRealPathFromURI(imageUri);
+ if (imagePath != null) {
+ saveImageToDatabase(imagePath);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ Toast.makeText(this, "插入图片失败", Toast.LENGTH_SHORT).show();
+ }
+ }
+
+ /**
+ * 将Bitmap转换为Uri
+ * @param bitmap 图片Bitmap
+ * @return 图片Uri
+ */
+ private Uri getImageUriFromBitmap(android.graphics.Bitmap bitmap) {
+ String path = android.provider.MediaStore.Images.Media.insertImage(
+ getContentResolver(), bitmap, "NoteImage", null);
+ return Uri.parse(path);
+ }
+
+ /**
+ * 从Uri获取真实路径
+ * @param contentUri 内容Uri
+ * @return 真实文件路径
+ */
+ private String getRealPathFromURI(Uri contentUri) {
+ String[] proj = {android.provider.MediaStore.Images.Media.DATA};
+ Cursor cursor = getContentResolver().query(contentUri, proj, null, null, null);
+ if (cursor != null) {
+ int column_index = cursor.getColumnIndexOrThrow(android.provider.MediaStore.Images.Media.DATA);
+ cursor.moveToFirst();
+ String path = cursor.getString(column_index);
+ cursor.close();
+ return path;
+ }
+ return null;
+ }
+
+ /**
+ * 保存图片到数据库
+ * @param imagePath 图片路径
+ */
+ private void saveImageToDatabase(String imagePath) {
+ // 这里可以添加保存图片路径到数据库的逻辑
+ // 目前暂时只做日志记录
+ Log.d(TAG, "Saved image path: " + imagePath);
+ }
+
+ /**
+ * 显示标签选择对话框
+ */
+ private void showTagSelectorDialog() {
+ // 创建标签选择对话框
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle(R.string.menu_tag);
+
+ // 创建标签选择布局
+ LinearLayout layout = new LinearLayout(this);
+ layout.setOrientation(LinearLayout.VERTICAL);
+ layout.setPadding(30, 30, 30, 30);
+
+ // 预设标签选项
+ String[] tags = {"生活", "学习", "工作", "自定义"};
+ builder.setItems(tags, new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ switch (which) {
+ case 0:
+ // 生活标签
+ mWorkingNote.setTag(TAG_LIFE);
+ break;
+ case 1:
+ // 学习标签
+ mWorkingNote.setTag(TAG_STUDY);
+ break;
+ case 2:
+ // 工作标签
+ mWorkingNote.setTag(TAG_WORK);
+ break;
+ case 3:
+ // 自定义标签，显示输入框
+ showCustomTagInputDialog();
+ break;
+ }
+ }
+ });
+
+ builder.setNegativeButton(android.R.string.cancel, null);
+ builder.show();
+ }
+
+ /**
+ * 显示自定义标签输入对话框
+ */
+ private void showCustomTagInputDialog() {
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle("自定义标签");
+
+ // 创建输入框
+ EditText input = new EditText(this);
+ input.setHint("输入标签名称");
+ builder.setView(input);
+
+ builder.setPositiveButton("保存", new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ String customTag = input.getText().toString().trim();
+ if (!customTag.isEmpty()) {
+ mWorkingNote.setTag(customTag);
+ }
+ }
+ });
+
+ builder.setNegativeButton("取消", null);
+ builder.show();
+ }
+
+ /**
+ * 设置位置提醒
+ */
+ private void setLocationReminder() {
+ // 创建位置提醒对话框
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle(R.string.location_reminder_dialog_title);
+
+ // 创建布局
+ LinearLayout layout = new LinearLayout(this);
+ layout.setOrientation(LinearLayout.VERTICAL);
+ layout.setPadding(50, 30, 50, 30);
+
+ // 位置名称输入框
+ mLocationNameEditText = new EditText(this);
+ mLocationNameEditText.setHint(R.string.location_reminder_enter_name);
+ LinearLayout.LayoutParams nameParams = new LinearLayout.LayoutParams(
+ LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+ nameParams.setMargins(0, 0, 0, 20);
+ mLocationNameEditText.setLayoutParams(nameParams);
+ layout.addView(mLocationNameEditText);
+
+ // 纬度输入框
+ mLatitudeEditText = new EditText(this);
+ mLatitudeEditText.setHint("纬度 (Latitude)");
+ mLatitudeEditText.setInputType(InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_NUMBER_FLAG_SIGNED);
+ LinearLayout.LayoutParams latParams = new LinearLayout.LayoutParams(
+ LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+ latParams.setMargins(0, 0, 0, 20);
+ mLatitudeEditText.setLayoutParams(latParams);
+ layout.addView(mLatitudeEditText);
+
+ // 经度输入框
+ mLongitudeEditText = new EditText(this);
+ mLongitudeEditText.setHint("经度 (Longitude)");
+ mLongitudeEditText.setInputType(InputType.TYPE_NUMBER_FLAG_DECIMAL | InputType.TYPE_NUMBER_FLAG_SIGNED);
+ LinearLayout.LayoutParams lonParams = new LinearLayout.LayoutParams(
+ LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+ lonParams.setMargins(0, 0, 0, 20);
+ mLongitudeEditText.setLayoutParams(lonParams);
+ layout.addView(mLongitudeEditText);
+
+ // 选择位置按钮
+ final Button selectLocationButton = new Button(this);
+ selectLocationButton.setText(R.string.location_reminder_select_location);
+ LinearLayout.LayoutParams buttonParams = new LinearLayout.LayoutParams(
+ LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+ buttonParams.setMargins(0, 0, 0, 20);
+ selectLocationButton.setLayoutParams(buttonParams);
+ layout.addView(selectLocationButton);
+
+ // 提醒半径输入框
+ final EditText radiusEditText = new EditText(this);
+ radiusEditText.setHint(R.string.location_reminder_radius);
+ radiusEditText.setInputType(InputType.TYPE_CLASS_NUMBER);
+ radiusEditText.setText("100"); // 默认100米
+ LinearLayout.LayoutParams radiusParams = new LinearLayout.LayoutParams(
+ LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT);
+ radiusEditText.setLayoutParams(radiusParams);
+ layout.addView(radiusEditText);
+
+ // 选择位置按钮点击事件
+ selectLocationButton.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ // 调用地图应用选择位置
+ Intent intent = new Intent(Intent.ACTION_VIEW);
+
+ // 尝试不同的URI格式
+ Uri geoUri = Uri.parse("geo:0,0");
+ intent.setData(geoUri);
+
+ // 不限制特定地图应用，让系统选择默认的地图应用
+ intent.setPackage(null);
+
+ if (intent.resolveActivity(getPackageManager()) != null) {
+ startActivityForResult(intent, REQUEST_CODE_SELECT_LOCATION);
+ } else {
+ // 如果第一种格式失败，尝试另一种格式
+ intent.setData(Uri.parse("geo:0,0?q=map"));
+ if (intent.resolveActivity(getPackageManager()) != null) {
+ startActivityForResult(intent, REQUEST_CODE_SELECT_LOCATION);
+ } else {
+ // 如果还是失败，尝试更通用的方式
+ Intent chooserIntent = Intent.createChooser(intent, "选择地图应用");
+ if (chooserIntent.resolveActivity(getPackageManager()) != null) {
+ startActivityForResult(chooserIntent, REQUEST_CODE_SELECT_LOCATION);
+ } else {
+ Toast.makeText(NoteEditActivity.this, "没有找到地图应用", Toast.LENGTH_SHORT).show();
+ }
+ }
+ }
+ }
+ });
+
+ builder.setView(layout);
+
+ // 确定按钮
+ builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ try {
+ String locationName = mLocationNameEditText.getText().toString().trim();
+ double latitude = Double.parseDouble(mLatitudeEditText.getText().toString());
+ double longitude = Double.parseDouble(mLongitudeEditText.getText().toString());
+ float radius = Float.parseFloat(radiusEditText.getText().toString());
+
+ // 验证输入
+ if (TextUtils.isEmpty(locationName)) {
+ locationName = "未知位置";
+ }
+ if (radius <= 0) {
+ radius = 100; // 默认100米
+ }
+
+ // 设置位置提醒
+ mWorkingNote.setAlertLocation(latitude, longitude, radius, locationName, true);
+ } catch (NumberFormatException e) {
+ Toast.makeText(NoteEditActivity.this, "请输入有效的位置信息", Toast.LENGTH_SHORT).show();
+ }
+ }
+ });
+
+ // 取消按钮
+ builder.setNegativeButton(android.R.string.cancel, null);
+
+ // 显示对话框
+ builder.show();
+ }
/**
* 分享笔记内容到其他应用
@@ -715,7 +1591,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
} else {
// 同步模式：移动到垃圾箱
- if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLER)) {
+ if (!DataUtils.batchMoveToFolder(getContentResolver(), ids, Notes.ID_TRASH_FOLDER)) {
Log.e(TAG, "Move notes to trash folder error, should not happens");
}
}
@@ -760,6 +1636,30 @@ public class NoteEditActivity extends Activity implements OnClickListener,
showToast(R.string.error_note_empty_for_clock);
}
}
+
+ /**
+ * 位置提醒改变回调（NoteSettingChangedListener接口方法）
+ */
+ public void onLocationAlertChanged(double latitude, double longitude, float radius, String locationName, boolean set) {
+ // 对于未保存的笔记，先保存再设置提醒
+ if (!mWorkingNote.existInDatabase()) {
+ saveNote();
+ }
+
+ if (mWorkingNote.getNoteId() > 0) {
+ showAlertHeader(); // 更新提醒显示
+ // 位置提醒的地理围栏实现将在后续版本中添加
+ if (set) {
+ Toast.makeText(this, "位置提醒已设置", Toast.LENGTH_SHORT).show();
+ } else {
+ Toast.makeText(this, "位置提醒已取消", Toast.LENGTH_SHORT).show();
+ }
+ } else {
+ // 笔记为空，无法设置提醒
+ Log.e(TAG, "Location alert setting error");
+ showToast(R.string.error_note_empty_for_clock);
+ }
+ }
/**
* 小部件改变回调（NoteSettingChangedListener接口方法）
@@ -966,8 +1866,10 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
mWorkingNote.setWorkingText(sb.toString());
} else {
- // 普通模式：直接获取编辑器文本
- mWorkingNote.setWorkingText(mNoteEditor.getText().toString());
+ // 普通模式：合并标题和正文
+ String title = mNoteTitle.getText().toString();
+ String content = mNoteEditor.getText().toString();
+ mWorkingNote.setTitleAndContent(title, content);
}
return hasChecked;
}
diff --git a/src/notes/ui/NoteItemData.java b/src/notes/ui/NoteItemData.java
index c1601e9..513a3e2 100644
--- a/src/notes/ui/NoteItemData.java
+++ b/src/notes/ui/NoteItemData.java
@@ -48,7 +48,8 @@ public class NoteItemData {
NoteColumns.SNIPPET, // 内容摘要/片段
NoteColumns.TYPE, // 类型（笔记、文件夹、系统文件夹等）
NoteColumns.WIDGET_ID, // 关联的小部件ID
- NoteColumns.WIDGET_TYPE, // 小部件类型
+ NoteColumns.WIDGET_TYPE, // 小部件的类型
+ NoteColumns.TAG, // 标签
};
/**
@@ -67,6 +68,7 @@ public class NoteItemData {
private static final int TYPE_COLUMN = 9; // 类型列的索引
private static final int WIDGET_ID_COLUMN = 10; // 小部件ID列的索引
private static final int WIDGET_TYPE_COLUMN = 11; // 小部件类型列的索引
+ private static final int TAG_COLUMN = 12; // 标签列的索引
// 成员变量，对应数据库中的各个字段
private long mId; // 笔记/文件夹的唯一标识ID
@@ -81,6 +83,8 @@ public class NoteItemData {
private int mType; // 类型（笔记、文件夹、系统文件夹等）
private int mWidgetId; // 关联的桌面小部件ID
private int mWidgetType; // 桌面小部件的类型
+ private String mTag; // 标签
+ private boolean mIsCompleted; // 便签是否已完成
// 额外添加的业务逻辑相关字段（不直接来自数据库）
private String mName; // 联系人姓名（如果是通话记录笔记）
@@ -110,6 +114,9 @@ public class NoteItemData {
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
mParentId = cursor.getLong(PARENT_ID_COLUMN);
mSnippet = cursor.getString(SNIPPET_COLUMN);
+ mTag = cursor.getString(TAG_COLUMN);
+ // 保存原始的完成状态
+ mIsCompleted = mSnippet.startsWith(NoteEditActivity.TAG_CHECKED);
// 清理摘要文本中的清单标记符号（对勾和方框），让显示更干净
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, "");
@@ -331,8 +338,40 @@ public class NoteItemData {
}
/**
- * 获取内容摘要/片段（已清理清单标记）
- * @return 清理后的内容摘要
+ * 获取笔记标题（第一行）
+ * @return 标题
+ */
+ public String getTitle() {
+ if (TextUtils.isEmpty(mSnippet)) {
+ return "";
+ }
+ int firstLineEnd = mSnippet.indexOf('\n');
+ if (firstLineEnd == -1) {
+ // 如果只有一行，全部作为标题
+ return mSnippet;
+ }
+ return mSnippet.substring(0, firstLineEnd);
+ }
+
+ /**
+ * 获取去掉标题后的内容摘要
+ * @return 内容摘要
+ */
+ public String getContentSnippet() {
+ if (TextUtils.isEmpty(mSnippet)) {
+ return "";
+ }
+ int firstLineEnd = mSnippet.indexOf('\n');
+ if (firstLineEnd == -1) {
+ // 如果只有一行，内容为空
+ return "";
+ }
+ return mSnippet.substring(firstLineEnd + 1);
+ }
+
+ /**
+ * 获取完整内容（已清理清单标记）
+ * @return 完整内容
*/
public String getSnippet() {
return mSnippet;
@@ -346,6 +385,14 @@ public class NoteItemData {
return (mAlertDate > 0);
}
+ /**
+ * 获取标签
+ * @return 标签
+ */
+ public String getTag() {
+ return mTag;
+ }
+
/**
* 判断是否是通话记录笔记
* 条件：属于通话记录文件夹 且 有有效的电话号码
@@ -354,6 +401,14 @@ public class NoteItemData {
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER && !TextUtils.isEmpty(mPhoneNumber));
}
+
+ /**
+ * 判断便签是否已完成
+ * @return 如果便签内容以完成标记开头，返回true
+ */
+ public boolean isCompleted() {
+ return mIsCompleted;
+ }
/**
* 静态方法：直接从游标中获取笔记类型
diff --git a/src/notes/ui/NotesListActivity.java b/src/notes/ui/NotesListActivity.java
index 56ecd10..db8a987 100644
--- a/src/notes/ui/NotesListActivity.java
+++ b/src/notes/ui/NotesListActivity.java
@@ -28,6 +28,12 @@ import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
+import android.net.Uri;
+import android.net.Uri.Builder;
+import android.content.ContentUris;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
import android.os.AsyncTask;
import android.os.Bundle;
import android.preference.PreferenceManager;
@@ -39,7 +45,10 @@ import android.view.ActionMode;
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.Display;
+import android.view.GestureDetector;
+import android.view.GestureDetector.SimpleOnGestureListener;
import android.view.HapticFeedbackConstants;
+import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
@@ -48,25 +57,34 @@ import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnCreateContextMenuListener;
+import android.view.View.OnKeyListener;
import android.view.View.OnTouchListener;
+import android.view.VelocityTracker;
import android.view.inputmethod.InputMethodManager;
+import android.text.InputType;
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.ImageButton;
import android.widget.ListView;
import android.widget.PopupMenu;
import android.widget.TextView;
import android.widget.Toast;
+import androidx.recyclerview.widget.ItemTouchHelper;
+import androidx.recyclerview.widget.RecyclerView;
+
import net.micode.notes.R;
import net.micode.notes.data.Notes;
+import net.micode.notes.tool.SmartReminderManager;
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.PrivacyLockManager;
import net.micode.notes.tool.ResourceParser;
import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
import net.micode.notes.widget.NoteWidgetProvider_2x;
@@ -84,6 +102,9 @@ import java.util.HashSet;
*/
public class NotesListActivity extends Activity implements OnClickListener, OnItemLongClickListener {
+ // NOTE_ID常量
+ public static final String NOTE_ID = "note_id";
+
// 异步查询的令牌，用于区分不同类型的查询
private static final int FOLDER_NOTE_LIST_QUERY_TOKEN = 0; // 查询文件夹下的笔记列表
private static final int FOLDER_LIST_QUERY_TOKEN = 1; // 查询可用的文件夹列表（用于移动操作）
@@ -125,6 +146,17 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
public static final int NOTES_LISTVIEW_SCROLL_RATE = 30;
private NoteItemData mFocusNoteDataItem; // 当前获得焦点的数据项（长按时记录）
+ private EditText mSearchEditText; // 搜索输入框
+ private ImageButton mSearchClearButton; // 搜索清除按钮
+ private String mSearchQuery = ""; // 当前搜索关键词
+ private String mCurrentTagFilter = ""; // 当前标签筛选
+ private SmartReminderManager mSmartReminderManager; // 智能提醒管理器
+
+ // 手势检测相关成员变量
+ private GestureDetector mGestureDetector; // 手势检测器
+ private static final int SWIPE_MIN_DISTANCE = 120; // 最小滑动距离
+ private static final int SWIPE_MAX_OFF_PATH = 250; // 最大偏离路径
+ private static final int SWIPE_THRESHOLD_VELOCITY = 200; // 最小滑动速度
// 数据库查询条件（Selection）
private static final String NORMAL_SELECTION = NoteColumns.PARENT_ID + "=?"; // 普通查询：父文件夹ID=?
@@ -153,6 +185,30 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
* 当用户第一次使用此应用时，插入一个介绍性的笔记
*/
setAppInfoFromRawRes();
+
+ // 添加对OnBackPressedDispatcher的支持，以便处理手势返回
+ try {
+ // 使用反射调用getOnBackPressedDispatcher方法，添加一个空回调
+ // 这样可以确保手势返回功能正常工作，同时保持原有代码不变
+ Object dispatcher = getClass().getMethod("getOnBackPressedDispatcher").invoke(this);
+ Class callbackClass = Class.forName("androidx.activity.OnBackPressedCallback");
+ Object callback = callbackClass.getConstructor(boolean.class).newInstance(true);
+ Class callbackInterface = Class.forName("androidx.activity.OnBackPressedCallback$OnBackPressedListener");
+ Object listener = java.lang.reflect.Proxy.newProxyInstance(
+ callbackInterface.getClassLoader(),
+ new Class[]{callbackInterface},
+ (proxy, method, args) -> {
+ // 调用原有的onBackPressed方法
+ onBackPressed();
+ return null;
+ }
+ );
+ callbackClass.getMethod("addOnBackPressedListener", callbackInterface).invoke(callback, listener);
+ dispatcher.getClass().getMethod("addCallback", Activity.class, callbackClass).invoke(dispatcher, this, callback);
+ } catch (Exception e) {
+ // 如果反射调用失败，不影响原有功能
+ Log.d(TAG, "OnBackPressedDispatcher not available, using legacy onBackPressed");
+ }
}
/**
@@ -245,6 +301,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver()); // 创建后台查询处理器
mCurrentFolderId = Notes.ID_ROOT_FOLDER; // 初始当前文件夹为根目录
mNotesListView = (ListView) findViewById(R.id.notes_list); // 查找列表视图
+ mSmartReminderManager = new SmartReminderManager(this); // 初始化智能提醒管理器
// 为列表添加脚部视图（可能用于显示空白区域或加载更多）
mNotesListView.addFooterView(LayoutInflater.from(this).inflate(R.layout.note_list_footer, null),
null, false);
@@ -263,8 +320,38 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mDispatchY = 0;
mOriginY = 0;
mTitleBar = (TextView) findViewById(R.id.tv_title_bar); // 标题栏
+
+ // 初始化搜索相关UI元素
+ mSearchEditText = (EditText) findViewById(R.id.search_edit_text);
+ mSearchClearButton = (ImageButton) findViewById(R.id.search_clear_button);
+
+ // 初始化标签筛选按钮
+ Button tagFilterButton = (Button) findViewById(R.id.btn_tag_filter);
+ tagFilterButton.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ showTagFilterDialog();
+ }
+ });
+
+ // 设置搜索输入框监听器
+ mSearchEditText.addTextChangedListener(new SearchTextWatcher());
+ mSearchEditText.setOnKeyListener(new SearchOnKeyListener());
+
+ // 设置搜索清除按钮监听器
+ mSearchClearButton.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ mSearchEditText.setText("");
+ clearSearch();
+ }
+ });
+
mState = ListEditState.NOTE_LIST; // 初始状态为根目录笔记列表
mModeCallBack = new ModeCallback(); // 创建多选模式回调实例
+
+ // 初始化手势检测器，支持滑动操作
+ initSwipeGestureDetector();
}
/**
@@ -500,11 +587,173 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
// 根据当前文件夹ID选择查询条件
String selection = (mCurrentFolderId == Notes.ID_ROOT_FOLDER) ? ROOT_FOLDER_SELECTION
: NORMAL_SELECTION;
+
+ // 设置查询参数
+ String[] selectionArgs = new String[] { String.valueOf(mCurrentFolderId) };
+
+ // 如果有搜索关键词，添加搜索条件
+ if (!TextUtils.isEmpty(mSearchQuery)) {
+ selection = "(" + selection + ") AND (" + NoteColumns.SNIPPET + " LIKE ?)";
+ selectionArgs = new String[] {
+ selectionArgs[0],
+ "%" + mSearchQuery + "%"
+ };
+ }
+
+ // 如果有标签筛选，添加标签条件
+ if (!TextUtils.isEmpty(mCurrentTagFilter)) {
+ String tagSelection = NoteColumns.TAG + "=?";
+ // 确保标签筛选条件被正确应用到整个查询条件中
+ selection = "(" + selection + ") AND " + tagSelection;
+ String[] newArgs = new String[selectionArgs.length + 1];
+ System.arraycopy(selectionArgs, 0, newArgs, 0, selectionArgs.length);
+ newArgs[selectionArgs.length] = mCurrentTagFilter;
+ selectionArgs = newArgs;
+ }
+
// 执行异步查询
mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
- Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, new String[] {
- String.valueOf(mCurrentFolderId) // 参数：当前文件夹ID
- }, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC"); // 排序：类型降序，修改日期降序
+ Notes.CONTENT_NOTE_URI, NoteItemData.PROJECTION, selection, selectionArgs,
+ NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC"); // 排序：类型降序，修改日期降序
+ }
+
+ /**
+ * 搜索文本变化监听器
+ */
+ private class SearchTextWatcher implements TextWatcher {
+ @Override
+ public void afterTextChanged(Editable s) {
+ mSearchQuery = s.toString().trim();
+ mSearchClearButton.setVisibility(TextUtils.isEmpty(mSearchQuery) ? View.GONE : View.VISIBLE);
+ startAsyncNotesListQuery();
+ }
+
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {}
+ }
+
+ /**
+ * 搜索按键监听器
+ */
+ private class SearchOnKeyListener implements OnKeyListener {
+ @Override
+ public boolean onKey(View v, int keyCode, KeyEvent event) {
+ if (event.getAction() == KeyEvent.ACTION_DOWN && keyCode == KeyEvent.KEYCODE_ENTER) {
+ // 隐藏软键盘
+ InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
+ imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
+ return true;
+ }
+ return false;
+ }
+ }
+
+ /**
+ * 清除搜索
+ */
+ private void clearSearch() {
+ mSearchQuery = "";
+ mSearchClearButton.setVisibility(View.GONE);
+ startAsyncNotesListQuery();
+ }
+
+ /**
+ * 显示标签筛选对话框
+ */
+ private void showTagFilterDialog() {
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle("选择标签");
+
+ // 查询数据库获取所有使用过的标签
+ List tagList = new ArrayList<>();
+ // 预设标签
+ List defaultTags = new ArrayList<>();
+ defaultTags.add(NoteEditActivity.TAG_LIFE);
+ defaultTags.add(NoteEditActivity.TAG_STUDY);
+ defaultTags.add(NoteEditActivity.TAG_WORK);
+
+ // 自定义标签
+ List customTags = new ArrayList<>();
+
+ // 查询所有标签
+ Cursor cursor = getContentResolver().query(
+ Notes.CONTENT_NOTE_URI,
+ new String[]{Notes.NoteColumns.TAG},
+ Notes.NoteColumns.TAG + " IS NOT NULL AND " + Notes.NoteColumns.TAG + " != ''",
+ null,
+ null);
+
+ if (cursor != null) {
+ while (cursor.moveToNext()) {
+ String tag = cursor.getString(0);
+ if (tag != null && !tag.isEmpty()) {
+ tag = tag.trim();
+ if (defaultTags.contains(tag)) {
+ // 预设标签，不重复添加
+ continue;
+ } else if (NoteEditActivity.TAG_CUSTOM.equals(tag)) {
+ // 旧版自定义标签，跳过
+ continue;
+ } else {
+ // 自定义标签，添加到列表
+ if (!customTags.contains(tag)) {
+ customTags.add(tag);
+ }
+ }
+ }
+ }
+ cursor.close();
+ }
+
+ // 排序自定义标签
+ Collections.sort(customTags);
+
+ // 构建最终标签列表
+ List finalTags = new ArrayList<>();
+ List finalTagValues = new ArrayList<>();
+
+ // 添加"全部"选项
+ finalTags.add("全部");
+ finalTagValues.add("");
+
+ // 添加预设标签
+ finalTags.add("生活");
+ finalTagValues.add(NoteEditActivity.TAG_LIFE);
+ finalTags.add("学习");
+ finalTagValues.add(NoteEditActivity.TAG_STUDY);
+ finalTags.add("工作");
+ finalTagValues.add(NoteEditActivity.TAG_WORK);
+
+ // 添加自定义标签
+ for (String customTag : customTags) {
+ finalTags.add(customTag);
+ finalTagValues.add(customTag);
+ }
+
+ // 转换为数组
+ final String[] tags = finalTags.toArray(new String[0]);
+ final String[] tagValues = finalTagValues.toArray(new String[0]);
+
+ builder.setItems(tags, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ if (which == 0) {
+ // 全部
+ mCurrentTagFilter = "";
+ ((Button) findViewById(R.id.btn_tag_filter)).setText("全部");
+ } else {
+ // 选择标签
+ mCurrentTagFilter = tagValues[which];
+ ((Button) findViewById(R.id.btn_tag_filter)).setText(tags[which]);
+ }
+ startAsyncNotesListQuery();
+ }
+ });
+
+ builder.show();
}
/**
@@ -599,7 +848,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
} else {
// 同步模式：将笔记移动到垃圾箱文件夹（而不是直接删除）
if (!DataUtils.batchMoveToFolder(mContentResolver, mNotesListAdapter
- .getSelectedItemIds(), Notes.ID_TRASH_FOLER)) {
+ .getSelectedItemIds(), Notes.ID_TRASH_FOLDER)) {
Log.e(TAG, "Move notes to trash folder error, should not happens");
}
}
@@ -643,7 +892,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
DataUtils.batchDeleteNotes(mContentResolver, ids);
} else {
// 同步模式：将文件夹移动到垃圾箱
- DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLER);
+ DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLDER);
}
// 更新关联的小部件
if (widgets != null) {
@@ -820,6 +1069,175 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
});
}
+ /**
+ * 初始化滑动手势检测器
+ */
+ private void initSwipeGestureDetector() {
+ mGestureDetector = new GestureDetector(this, new SwipeGestureListener());
+
+ // 为ListView设置触摸监听器，将触摸事件传递给手势检测器
+ mNotesListView.setOnTouchListener(new OnTouchListener() {
+ @Override
+ public boolean onTouch(View v, MotionEvent event) {
+ // 将触摸事件传递给手势检测器
+ return mGestureDetector.onTouchEvent(event);
+ }
+ });
+ }
+
+ /**
+ * 滑动手势监听器，处理各种滑动事件
+ */
+ private class SwipeGestureListener extends SimpleOnGestureListener {
+ @Override
+ public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+ try {
+ // 检查是否是水平滑动且速度足够
+ if (Math.abs(e1.getY() - e2.getY()) > SWIPE_MAX_OFF_PATH) {
+ return false; // 垂直方向滑动过大，忽略
+ }
+
+ // 获取滑动位置对应的项索引
+ int position = mNotesListView.pointToPosition((int) e1.getX(), (int) e1.getY());
+ if (position < 0 || position >= mNotesListAdapter.getCount()) {
+ return false; // 位置无效
+ }
+
+ // 获取当前项的数据
+ Cursor cursor = (Cursor) mNotesListAdapter.getItem(position);
+ if (cursor == null) {
+ return false;
+ }
+
+ NoteItemData noteData = new NoteItemData(NotesListActivity.this, cursor);
+
+ // 左滑：删除笔记
+ if (e1.getX() - e2.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
+ showDeleteConfirmation(noteData, position);
+ return true;
+ }
+ // 右滑：标记完成（仅对清单模式有效）
+ else if (e2.getX() - e1.getX() > SWIPE_MIN_DISTANCE && Math.abs(velocityX) > SWIPE_THRESHOLD_VELOCITY) {
+ toggleNoteCompletion(noteData);
+ return true;
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Swipe gesture error: " + e.getMessage());
+ }
+ return false;
+ }
+
+ @Override
+ public boolean onDown(MotionEvent e) {
+ return true; // 必须返回true，否则不会触发后续的手势事件
+ }
+ }
+
+ /**
+ * 显示删除确认对话框
+ */
+ private void showDeleteConfirmation(final NoteItemData noteData, final int position) {
+ 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_note));
+ builder.setPositiveButton(android.R.string.ok,
+ new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ deleteNote(noteData);
+ }
+ });
+ builder.setNegativeButton(android.R.string.cancel, null);
+ builder.show();
+ }
+
+ /**
+ * 删除单个笔记
+ */
+ private void deleteNote(NoteItemData noteData) {
+ HashSet ids = new HashSet();
+ ids.add(noteData.getId());
+
+ if (!isSyncMode()) {
+ // 非同步模式：直接删除笔记
+ if (DataUtils.batchDeleteNotes(mContentResolver, ids)) {
+ Toast.makeText(this, "笔记已删除", Toast.LENGTH_SHORT).show();
+ } else {
+ Log.e(TAG, "Delete note error");
+ }
+ } else {
+ // 同步模式：将笔记移动到垃圾箱文件夹
+ if (DataUtils.batchMoveToFolder(mContentResolver, ids, Notes.ID_TRASH_FOLDER)) {
+ Toast.makeText(this, "笔记已移至垃圾箱", Toast.LENGTH_SHORT).show();
+ } else {
+ Log.e(TAG, "Move note to trash error");
+ }
+ }
+
+ // 更新关联的小部件
+ if (noteData.getWidgetId() != AppWidgetManager.INVALID_APPWIDGET_ID &&
+ noteData.getWidgetType() != Notes.TYPE_WIDGET_INVALIDE) {
+ updateWidget(noteData.getWidgetId(), noteData.getWidgetType());
+ }
+
+ // 刷新列表
+ startAsyncNotesListQuery();
+ }
+
+ /**
+ * 切换便签的完成状态
+ * @param noteData 要切换状态的便签数据
+ */
+ private void toggleNoteCompletion(NoteItemData noteData) {
+ try {
+ // 加载便签内容
+ WorkingNote workingNote = WorkingNote.load(this, noteData.getId());
+ if (workingNote == null) {
+ Toast.makeText(this, "无法加载便签", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ String content = workingNote.getContent();
+ if (TextUtils.isEmpty(content)) {
+ Toast.makeText(this, "便签内容为空", Toast.LENGTH_SHORT).show();
+ return;
+ }
+
+ // 检查当前便签是否已经标记为完成
+ if (content.startsWith(NoteEditActivity.TAG_CHECKED)) {
+ // 已完成状态，切换为未完成
+ content = content.replaceFirst(NoteEditActivity.TAG_CHECKED, NoteEditActivity.TAG_UNCHECKED);
+ Toast.makeText(this, "已标记为未完成", Toast.LENGTH_SHORT).show();
+ } else if (content.startsWith(NoteEditActivity.TAG_UNCHECKED)) {
+ // 未完成状态，切换为已完成
+ content = content.replaceFirst(NoteEditActivity.TAG_UNCHECKED, NoteEditActivity.TAG_CHECKED);
+ Toast.makeText(this, "已标记为完成", Toast.LENGTH_SHORT).show();
+ } else {
+ // 没有状态标记，默认标记为已完成
+ content = NoteEditActivity.TAG_CHECKED + content;
+ Toast.makeText(this, "已标记为完成", Toast.LENGTH_SHORT).show();
+ }
+
+ // 更新便签内容
+ workingNote.setWorkingText(content);
+ if (workingNote.saveNote()) {
+ // 刷新列表
+ startAsyncNotesListQuery();
+
+ // 更新关联的小部件
+ if (noteData.getWidgetId() != AppWidgetManager.INVALID_APPWIDGET_ID &&
+ noteData.getWidgetType() != Notes.TYPE_WIDGET_INVALIDE) {
+ updateWidget(noteData.getWidgetId(), noteData.getWidgetType());
+ }
+ } else {
+ Toast.makeText(this, "保存便签失败", Toast.LENGTH_SHORT).show();
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "Toggle completion error: " + e.getMessage());
+ Toast.makeText(this, "操作失败: " + e.getMessage(), Toast.LENGTH_SHORT).show();
+ }
+ }
+
/**
* 处理返回键按下事件
*/
@@ -849,7 +1267,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
break;
}
}
-
+
/**
* 更新桌面小部件
* @param appWidgetId 小部件ID
@@ -910,6 +1328,37 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
Log.e(TAG, "The long click data item is null");
return false;
}
+
+ // 处理便签的上下文菜单
+ if (mFocusNoteDataItem.getType() == Notes.TYPE_NOTE) {
+ switch (item.getItemId()) {
+ case R.id.edit:
+ editNote(mFocusNoteDataItem.getId());
+ return true;
+ case R.id.share:
+ shareNote(mFocusNoteDataItem.getId());
+ return true;
+ case R.id.copy:
+ copyNote(mFocusNoteDataItem.getId());
+ return true;
+ case R.id.move:
+ // 原有的移动逻辑
+ break;
+ case R.id.add_lock:
+ showAddLockDialog(mFocusNoteDataItem.getId());
+ return true;
+ case R.id.remove_lock:
+ showRemoveLockDialog(mFocusNoteDataItem.getId());
+ return true;
+ case R.id.delete:
+ // 原有的删除逻辑
+ break;
+ default:
+ return super.onContextItemSelected(item);
+ }
+ }
+
+ // 处理文件夹的上下文菜单
switch (item.getItemId()) {
case MENU_FOLDER_VIEW:
openFolder(mFocusNoteDataItem); // 打开文件夹
@@ -965,6 +1414,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
*/
@Override
public boolean onOptionsItemSelected(MenuItem item) {
+ Log.d(TAG, "onOptionsItemSelected called: " + item.getItemId());
switch (item.getItemId()) {
case R.id.menu_new_folder: {
showCreateOrModifyFolderDialog(true); // 创建新文件夹
@@ -1079,7 +1529,16 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
/**
- * 列表项点击监听器
+ * 创建选项菜单
+ */
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ getMenuInflater().inflate(R.menu.note_list, menu);
+ return true;
+ }
+
+ /**
+ * 列表项点击监听器，处理笔记和文件夹的点击事件
*/
private class OnListItemClickListener implements OnItemClickListener {
public void onItemClick(AdapterView parent, View view, int position, long id) {
@@ -1146,7 +1605,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
selection,
new String[] {
String.valueOf(Notes.TYPE_FOLDER), // 类型：文件夹
- String.valueOf(Notes.ID_TRASH_FOLER), // 排除垃圾箱
+ String.valueOf(Notes.ID_TRASH_FOLDER), // 排除垃圾箱
String.valueOf(mCurrentFolderId) // 排除当前文件夹
},
NoteColumns.MODIFIED_DATE + " DESC"); // 按修改日期降序排序
@@ -1175,4 +1634,187 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
return false; // 返回false，让系统继续处理长按事件（显示上下文菜单等）
}
+
+ /**
+ * 编辑便签
+ */
+ private void editNote(long noteId) {
+ Intent intent = new Intent(this, NoteEditActivity.class);
+ intent.putExtra(NotesListActivity.NOTE_ID, noteId);
+ startActivity(intent);
+ }
+
+ /**
+ * 分享便签
+ */
+ private void shareNote(long noteId) {
+ // 获取便签内容
+ Cursor cursor = getContentResolver().query(
+ ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+ new String[]{Notes.NoteColumns.SNIPPET},
+ null, null, null);
+
+ if (cursor != null && cursor.moveToFirst()) {
+ String content = cursor.getString(cursor.getColumnIndexOrThrow(Notes.NoteColumns.SNIPPET));
+
+ Intent shareIntent = new Intent(Intent.ACTION_SEND);
+ shareIntent.setType("text/plain");
+ shareIntent.putExtra(Intent.EXTRA_SUBJECT, "便签");
+ shareIntent.putExtra(Intent.EXTRA_TEXT, content);
+ startActivity(Intent.createChooser(shareIntent, "分享便签"));
+
+ cursor.close();
+ }
+ }
+
+ /**
+ * 复制便签
+ */
+ private void copyNote(long noteId) {
+ // 获取原便签内容
+ Cursor cursor = getContentResolver().query(
+ ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
+ new String[]{Notes.NoteColumns.SNIPPET},
+ null, null, null);
+
+ if (cursor != null && cursor.moveToFirst()) {
+ String content = cursor.getString(cursor.getColumnIndexOrThrow(Notes.NoteColumns.SNIPPET));
+
+ // 创建新便签，复制内容
+ ContentValues values = new ContentValues();
+ values.put(Notes.NoteColumns.SNIPPET, content + " (复制)");
+ values.put(Notes.NoteColumns.CREATED_DATE, System.currentTimeMillis());
+ values.put(Notes.NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
+ values.put(Notes.NoteColumns.PARENT_ID, mCurrentFolderId);
+ values.put(Notes.NoteColumns.TYPE, Notes.TYPE_NOTE);
+
+ // 插入新便签
+ Uri newNoteUri = getContentResolver().insert(Notes.CONTENT_NOTE_URI, values);
+ if (newNoteUri != null) {
+ Toast.makeText(this, "复制成功", Toast.LENGTH_SHORT).show();
+ // 刷新列表
+ refresh();
+ }
+
+ cursor.close();
+ }
+ }
+
+ /**
+ * 显示添加隐私锁对话框
+ */
+ private void showAddLockDialog(final long noteId) {
+ // 显示锁类型选择对话框
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle("选择锁类型");
+ builder.setItems(new String[]{"密码锁", "手势锁"}, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ if (which == 0) {
+ // 密码锁
+ showPasswordInputDialog(noteId, true);
+ } else {
+ // 手势锁
+ showGestureInputDialog(noteId, true);
+ }
+ }
+ });
+ builder.show();
+ }
+
+ /**
+ * 显示密码输入对话框
+ */
+ private void showPasswordInputDialog(final long noteId, final boolean isAddLock) {
+ final EditText passwordEditText = new EditText(this);
+ passwordEditText.setInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD);
+ passwordEditText.setHint("请输入密码");
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle(isAddLock ? "设置密码" : "验证密码");
+ builder.setView(passwordEditText);
+
+ builder.setPositiveButton("确定", new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ String password = passwordEditText.getText().toString().trim();
+ if (!TextUtils.isEmpty(password)) {
+ if (isAddLock) {
+ // 添加密码锁
+ PrivacyLockManager lockManager = new PrivacyLockManager(NotesListActivity.this);
+ String encryptedPassword = PrivacyLockManager.encryptPassword(password);
+ boolean success = lockManager.addPrivacyLock(noteId, PrivacyLockManager.LOCK_TYPE_PASSWORD, encryptedPassword);
+ if (success) {
+ Toast.makeText(NotesListActivity.this, "密码锁添加成功", Toast.LENGTH_SHORT).show();
+ refresh();
+ } else {
+ Toast.makeText(NotesListActivity.this, "密码锁添加失败", Toast.LENGTH_SHORT).show();
+ }
+ } else {
+ // 验证密码
+ PrivacyLockManager lockManager = new PrivacyLockManager(NotesListActivity.this);
+ boolean isValid = lockManager.verifyPassword(noteId, password);
+ if (isValid) {
+ // 密码正确，移除锁
+ boolean success = lockManager.removePrivacyLock(noteId);
+ if (success) {
+ Toast.makeText(NotesListActivity.this, "隐私锁已移除", Toast.LENGTH_SHORT).show();
+ refresh();
+ } else {
+ Toast.makeText(NotesListActivity.this, "隐私锁移除失败", Toast.LENGTH_SHORT).show();
+ }
+ } else {
+ Toast.makeText(NotesListActivity.this, "密码错误", Toast.LENGTH_SHORT).show();
+ }
+ }
+ } else {
+ Toast.makeText(NotesListActivity.this, "密码不能为空", Toast.LENGTH_SHORT).show();
+ }
+ }
+ });
+
+ builder.setNegativeButton("取消", null);
+ builder.show();
+ }
+
+ /**
+ * 显示手势输入对话框
+ */
+ private void showGestureInputDialog(final long noteId, final boolean isAddLock) {
+ // 这里需要实现手势输入对话框
+ // 由于需要使用GestureLockView，这里简化处理，实际项目中需要创建包含GestureLockView的对话框
+ Toast.makeText(this, "手势锁功能需要在实际设备上测试", Toast.LENGTH_SHORT).show();
+ }
+
+ /**
+ * 显示移除隐私锁对话框
+ */
+ private void showRemoveLockDialog(final long noteId) {
+ PrivacyLockManager lockManager = new PrivacyLockManager(this);
+ int lockType = lockManager.getLockType(noteId);
+
+ if (lockType == PrivacyLockManager.LOCK_TYPE_PASSWORD) {
+ showPasswordInputDialog(noteId, false);
+ } else if (lockType == PrivacyLockManager.LOCK_TYPE_GESTURE) {
+ showGestureInputDialog(noteId, false);
+ }
+ }
+
+ /**
+ * 刷新便签列表
+ */
+ private void refresh() {
+ // 重新查询数据
+ if (mBackgroundQueryHandler != null) {
+ mBackgroundQueryHandler.startQuery(FOLDER_NOTE_LIST_QUERY_TOKEN, null,
+ Notes.CONTENT_NOTE_URI,
+ null,
+ Notes.NoteColumns.PARENT_ID + "=? AND " + Notes.NoteColumns.TYPE + "!=?",
+ new String[]{
+ String.valueOf(mCurrentFolderId),
+ String.valueOf(Notes.TYPE_SYSTEM)
+ },
+ Notes.NoteColumns.MODIFIED_DATE + " DESC");
+ }
+ }
}
\ No newline at end of file
diff --git a/src/notes/ui/NotesListItem.java b/src/notes/ui/NotesListItem.java
index 52a530e..4450ab7 100644
--- a/src/notes/ui/NotesListItem.java
+++ b/src/notes/ui/NotesListItem.java
@@ -17,6 +17,7 @@
package net.micode.notes.ui;
import android.content.Context;
+import android.text.TextUtils;
import android.text.format.DateUtils;
import android.view.View;
import android.widget.CheckBox;
@@ -38,6 +39,7 @@ public class NotesListItem extends LinearLayout {
private TextView mTitle; // 标题/内容文本
private TextView mTime; // 修改时间文本
private TextView mCallName; // 通话记录联系人姓名
+ private TextView mTag; // 标签文本
private NoteItemData mItemData; // 绑定的数据对象
private CheckBox mCheckBox; // 多选模式下的复选框
@@ -54,6 +56,7 @@ public class NotesListItem extends LinearLayout {
mTitle = (TextView) findViewById(R.id.tv_title);
mTime = (TextView) findViewById(R.id.tv_time);
mCallName = (TextView) findViewById(R.id.tv_name);
+ mTag = (TextView) findViewById(R.id.tv_tag);
// 使用系统预定义的checkbox ID
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
}
@@ -114,12 +117,26 @@ public class NotesListItem extends LinearLayout {
data.getNotesCount()));
mAlert.setVisibility(View.GONE); // 文件夹不显示提醒图标
} else {
- // 普通笔记显示：内容摘要
- mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
+ // 普通笔记显示：标题
+ String title = data.getTitle();
+ String content = data.getContentSnippet();
+
+ if (TextUtils.isEmpty(title)) {
+ // 如果没有标题，显示内容摘要
+ mTitle.setText(DataUtils.getFormattedSnippet(content));
+ } else {
+ // 如果有标题，显示标题
+ mTitle.setText(title);
+ }
+
// 根据是否有提醒设置提醒图标
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock); // 时钟图标
mAlert.setVisibility(View.VISIBLE);
+ } else if (data.isCompleted()) {
+ // 如果是已完成的便签，显示已完成图标（使用系统内置图标）
+ mAlert.setImageResource(android.R.drawable.checkbox_on_background); // 已完成图标
+ mAlert.setVisibility(View.VISIBLE);
} else {
mAlert.setVisibility(View.GONE);
}
@@ -129,6 +146,26 @@ public class NotesListItem extends LinearLayout {
// 设置相对时间显示（如"2分钟前"、"昨天"等）
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
+ // 设置标签显示
+ String tag = data.getTag();
+ if (tag != null && !tag.trim().isEmpty()) {
+ String tagText = "";
+ tag = tag.trim(); // 去除前后空格
+ if (NoteEditActivity.TAG_LIFE.equals(tag)) {
+ tagText = "生活";
+ } else if (NoteEditActivity.TAG_STUDY.equals(tag)) {
+ tagText = "学习";
+ } else if (NoteEditActivity.TAG_WORK.equals(tag)) {
+ tagText = "工作";
+ } else {
+ tagText = tag; // 直接显示标签值，包括自定义标签
+ }
+ mTag.setText("标签：" + tagText);
+ mTag.setVisibility(View.VISIBLE);
+ } else {
+ mTag.setVisibility(View.GONE);
+ }
+
// 根据位置和类型设置背景
setBackground(data);
}
diff --git a/src/notes/ui/RichEditor.java b/src/notes/ui/RichEditor.java
new file mode 100644
index 0000000..029a8bf
--- /dev/null
+++ b/src/notes/ui/RichEditor.java
@@ -0,0 +1,277 @@
+package net.micode.notes.ui;
+
+import android.content.Context;
+import android.os.Build;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.text.style.StrikethroughSpan;
+import android.text.style.StyleSpan;
+import android.text.style.UnderlineSpan;
+import android.util.AttributeSet;
+import android.widget.EditText;
+import android.graphics.Typeface;
+import android.text.Spannable;
+
+public class RichEditor extends EditText {
+
+ public interface OnTextChangeListener {
+ void onTextChange(String text);
+ }
+
+ private OnTextChangeListener onTextChangeListener;
+
+ public RichEditor(Context context) {
+ super(context);
+ init();
+ }
+
+ public RichEditor(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ init();
+ }
+
+ public RichEditor(Context context, AttributeSet attrs, int defStyleAttr) {
+ super(context, attrs, defStyleAttr);
+ init();
+ }
+
+ private void init() {
+ // 初始化逻辑
+ }
+
+ public void setOnTextChangeListener(OnTextChangeListener listener) {
+ this.onTextChangeListener = listener;
+
+ // 监听文本变化
+ addTextChangedListener(new TextWatcher() {
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ if (onTextChangeListener != null) {
+ onTextChangeListener.onTextChange(s.toString());
+ }
+ }
+
+ @Override
+ public void afterTextChanged(Editable s) {}
+ });
+ }
+
+ // 重写获取文本的方法
+ @Override
+ public Editable getText() {
+ return super.getText();
+ }
+
+ // 重写设置文本的方法，包括设置文本颜色、文本样式等
+ @Override
+ public void setText(CharSequence text, BufferType type) {
+ super.setText(text, type);
+ }
+
+ // 重写设置光标位置的方法
+ @Override
+ public void setSelection(int index) {
+ super.setSelection(index);
+ }
+
+ // 重写设置选中文本的方法
+ @Override
+ public void setSelection(int start, int stop) {
+ super.setSelection(start, stop);
+ }
+
+ // 重写获取选中文本起始位置的方法
+ @Override
+ public int getSelectionStart() {
+ return super.getSelectionStart();
+ }
+
+ // 重写获取选中文本结束位置的方法
+ @Override
+ public int getSelectionEnd() {
+ return super.getSelectionEnd();
+ }
+
+ // 重写设置文本外观的方法，文本外观包括字体、颜色等
+ @Override
+ public void setTextAppearance(Context context, int resid) {
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+ super.setTextAppearance(resid);
+ } else {
+ // 对旧版本的兼容处理
+ setTextAppearance(context, resid);
+ }
+ }
+
+ // 设置编辑器高度
+ public void setEditorHeight(int pixels) {
+ this.setHeight(pixels);
+ }
+
+
+ //设置编辑器字体大小
+ public void setEditorFontSize(int size) {
+ this.setTextSize(size);
+ }
+
+ //设置编辑器字体颜色
+ public void setEditorFontColor(int color) {
+ this.setTextColor(color);
+ }
+
+ //设置占位符文本
+ public void setPlaceholder(String placeholder) {
+ this.setHint(placeholder);
+ }
+
+ // 设置编辑器启用或禁用输入
+ public void setInputEnabled(boolean enabled) {
+ this.setEnabled(enabled);
+ }
+
+ //切换粗体样式
+ public void toggleBold() {
+ toggleStyleSpan(Typeface.BOLD);
+ }
+
+ //切换斜体样式
+ public void toggleItalic() {
+ toggleStyleSpan(Typeface.ITALIC);
+ }
+
+ //切换删除线样式
+ public void toggleStrikeThrough() {
+ toggleSpan(StrikethroughSpan.class, new StrikethroughSpan());
+ }
+
+ //切换下划线样式
+ public void toggleUnderline() {
+ toggleSpan(UnderlineSpan.class, new UnderlineSpan());
+ }
+
+ // 粗体、斜体样式切换方法
+ private void toggleStyleSpan(int style) {
+ int start = getSelectionStart();
+ int end = getSelectionEnd();
+ if (start < 0 || end < 0 || start >= end) {
+ return; // 没有选中文本时不处理
+ }
+
+ Spannable str = getText();
+ StyleSpan[] spans = str.getSpans(start, end, StyleSpan.class);
+
+ boolean hasStyle = false;
+ // 检查是否已存在相同样式
+ for (StyleSpan span : spans) {
+ if (span.getStyle() == style) {
+ str.removeSpan(span);
+ hasStyle = true;
+ }
+ }
+
+ // 如果不存在对应样式，则添加
+ if (!hasStyle) {
+ str.setSpan(new StyleSpan(style), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+
+ //通用的Span切换方法，下划线和删除线
+ private void toggleSpan(Class spanType, T newSpan) {
+ int start = getSelectionStart();
+ int end = getSelectionEnd();
+ if (start < 0 || end < 0 || start >= end) {
+ return;
+ }
+
+ Spannable str = getText();
+ @SuppressWarnings("unchecked")
+ T[] spans = (T[]) str.getSpans(start, end, spanType);
+
+ if (spans.length > 0) {
+ // 如果已存在样式，则移除
+ for (T span : spans) {
+ str.removeSpan(span);
+ }
+ } else {
+ // 如果不存在样式，则添加
+ str.setSpan(newSpan, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+
+ // 应用粗体样式
+ public void applyBold() {
+ int start = getSelectionStart();
+ int end = getSelectionEnd();
+
+ if (start >= 0 && end >= 0 && start != end) {
+ Spannable str = getText();
+ StyleSpan[] spans = str.getSpans(start, end, StyleSpan.class);
+
+ for (StyleSpan span : spans) {
+ if (span.getStyle() == Typeface.BOLD) {
+ str.removeSpan(span);
+ }
+ }
+
+ str.setSpan(new StyleSpan(Typeface.BOLD), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+ // 应用斜体样式
+ public void applyItalic() {
+ int start = getSelectionStart();
+ int end = getSelectionEnd();
+
+ if (start >= 0 && end >= 0 && start != end) {
+ Spannable str = getText();
+ StyleSpan[] spans = str.getSpans(start, end, StyleSpan.class);
+
+ for (StyleSpan span : spans) {
+ if (span.getStyle() == Typeface.ITALIC) {
+ str.removeSpan(span);
+ }
+ }
+
+ str.setSpan(new StyleSpan(Typeface.ITALIC), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+ // 应用删除线样式
+ public void applyStrikeThrough() {
+ int start = getSelectionStart();
+ int end = getSelectionEnd();
+
+ if (start >= 0 && end >= 0 && start != end) {
+ Spannable str = getText();
+ StrikethroughSpan[] spans = str.getSpans(start, end, StrikethroughSpan.class);
+
+ for (StrikethroughSpan span : spans) {
+ str.removeSpan(span);
+ }
+
+ str.setSpan(new StrikethroughSpan(), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+
+ // 应用下划线样式
+ public void applyUnderline() {
+ int start = getSelectionStart();
+ int end = getSelectionEnd();
+
+ if (start >= 0 && end >= 0 && start != end) {
+ Spannable str = getText();
+ UnderlineSpan[] spans = str.getSpans(start, end, UnderlineSpan.class);
+
+ for (UnderlineSpan span : spans) {
+ str.removeSpan(span);
+ }
+
+ str.setSpan(new UnderlineSpan(), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/notes/ui/SplashActivity.java b/src/notes/ui/SplashActivity.java
new file mode 100644
index 0000000..34dc3b1
--- /dev/null
+++ b/src/notes/ui/SplashActivity.java
@@ -0,0 +1,65 @@
+package net.micode.notes.ui;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Handler;
+import android.view.animation.Animation;
+import android.view.animation.AnimationUtils;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import net.micode.notes.R;
+
+public class SplashActivity extends AppCompatActivity {
+
+ private static final int SPLASH_DURATION = 3000; // 3秒
+ private static final int TEXT_FADE_IN_DELAY = 2000; // 2秒后文字淡入
+
+ // 启动页创建，初始化动画界面和跳转逻辑
+ @Override
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.activity_splash);
+
+ ImageView logo = findViewById(R.id.splash_logo);
+ TextView text = findViewById(R.id.splash_text);
+
+ // 加载文字滑动动画
+ Animation slideUpAnimation = AnimationUtils.loadAnimation(this, R.anim.text_slide_up);
+
+ // 2秒后显示文字动画
+ new Handler().postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ text.setVisibility(android.view.View.VISIBLE);
+ text.startAnimation(slideUpAnimation);
+ }
+ }, TEXT_FADE_IN_DELAY);
+
+ // 3秒后跳转到主界面
+ new Handler().postDelayed(new Runnable() {
+ @Override
+ public void run() {
+ onSplashComplete();
+ }
+ }, SPLASH_DURATION);
+ }
+
+ // 动画完成回调方法
+ private void onSplashComplete() {
+ Intent intent = new Intent(SplashActivity.this, LoginRegisterActivity.class);
+ startActivity(intent);
+ finish(); // 结束启动页，防止用户返回到此页面
+ overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
+ }
+
+ // 处理屏幕旋转等配置变更
+ @Override
+ public void onConfigurationChanged(android.content.res.Configuration newConfig) {
+ super.onConfigurationChanged(newConfig);
+ // 重新启动启动画面，以正确处理方向更改
+ recreate();
+ }
+}
\ No newline at end of file
diff --git a/src/notes/ui/WaveAnimation.java b/src/notes/ui/WaveAnimation.java
new file mode 100644
index 0000000..3963599
--- /dev/null
+++ b/src/notes/ui/WaveAnimation.java
@@ -0,0 +1,76 @@
+package net.micode.notes.ui;
+
+import android.animation.ValueAnimator;
+import android.view.animation.AccelerateDecelerateInterpolator;
+import android.widget.TextView;
+
+public class WaveAnimation {
+
+ // 整行文字从左到右淡入显示动画
+ public static void applyFadeInAnimation(TextView textView) {
+ // 设置初始状态为完全透明
+ textView.setAlpha(0f);
+ textView.setVisibility(android.view.View.VISIBLE);
+
+ // 创建透明度渐变动画
+ ValueAnimator fadeInAnimator = ValueAnimator.ofFloat(0f, 1f);
+ fadeInAnimator.setDuration(2000); // 2秒淡入效果
+ fadeInAnimator.setInterpolator(new AccelerateDecelerateInterpolator());
+
+ fadeInAnimator.addUpdateListener(animation -> {
+ float alpha = (float) animation.getAnimatedValue();
+ textView.setAlpha(alpha);
+ });
+
+ // 创建从左到右的滑入效果
+ ValueAnimator slideInAnimator = ValueAnimator.ofFloat(-100f, 0f);
+ slideInAnimator.setDuration(1500); // 1.5秒滑入
+ slideInAnimator.setInterpolator(new android.view.animation.OvershootInterpolator());
+
+ slideInAnimator.addUpdateListener(animation -> {
+ float translationX = (float) animation.getAnimatedValue();
+ textView.setTranslationX(translationX);
+ });
+
+ // 同时启动两个动画
+ fadeInAnimator.start();
+ slideInAnimator.start();
+ }
+
+ // 从左到右逐字淡入效果（如果需要的话）
+ public static void applyCharByCharFadeIn(TextView textView) {
+ String text = textView.getText().toString();
+ int length = text.length();
+
+ // 设置初始状态
+ textView.setAlpha(0f);
+ textView.setVisibility(android.view.View.VISIBLE);
+
+ // 为整行文字创建统一的淡入动画
+ ValueAnimator animator = ValueAnimator.ofFloat(0f, 1f);
+ animator.setDuration(2500); // 总时长2.5秒
+ animator.setInterpolator(new android.view.animation.DecelerateInterpolator());
+
+ animator.addUpdateListener(animation -> {
+ float progress = (float) animation.getAnimatedValue();
+ textView.setAlpha(progress);
+
+ // 添加轻微的缩放效果
+ float scale = 0.8f + (progress * 0.2f); // 从0.8倍放大到1倍
+ textView.setScaleX(scale);
+ textView.setScaleY(scale);
+ });
+
+ animator.start();
+ }
+
+ // 兼容旧版本的方法名 - 使用新的淡入效果
+ public static void applyComplexWaveAnimation(TextView textView) {
+ applyFadeInAnimation(textView);
+ }
+
+ // 兼容旧版本的另一个方法名
+ public static void applyCharWaveAnimation(TextView textView) {
+ applyCharByCharFadeIn(textView);
+ }
+}
\ No newline at end of file
diff --git a/src/notes/widget/NoteWidgetProvider.java b/src/notes/widget/NoteWidgetProvider.java
index fa5c64a..5fbb34c 100644
--- a/src/notes/widget/NoteWidgetProvider.java
+++ b/src/notes/widget/NoteWidgetProvider.java
@@ -94,7 +94,7 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
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) },
+ new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLDER) },
null); // 排序方式（无）
}