补充最新模板 #39

Open
pg6wepubk wants to merge 76 commits from mengcheng_branch into master

@ -14,6 +14,12 @@
* limitations under the License.
*/
/*
*Contact.java
*
* 2025-12-13
* 21
*/
package net.micode.notes.data;
import android.content.Context;
@ -25,10 +31,22 @@ import android.util.Log;
import java.util.HashMap;
/**
*Contact
*
*<P></P>
*
*
* @author
* @version 1.0
* @since []
*/
public class Contact {
//HashMap表示联系人和电话号码之间的映射关系。只声明不new是延迟初始化的表现
private static HashMap<String, String> sContactCache;
private static final String TAG = "Contact";
//说明电话号码格式可兼容国际区号、前缀0等多种格式
private static final String CALLER_ID_SELECTION = "PHONE_NUMBERS_EQUAL(" + Phone.NUMBER
+ ",?) AND " + Data.MIMETYPE + "='" + Phone.CONTENT_ITEM_TYPE + "'"
+ " AND " + Data.RAW_CONTACT_ID + " IN "
@ -36,17 +54,31 @@ public class Contact {
+ " FROM phone_lookup"
+ " WHERE min_match = '+')";
/**
*
* <P></P>
* @param context 访ContentResolver
* @param phoneNumber 0
* @return code null
* @throws
* @see android.provider.ContactsContract.CommonDataKinds
*/
public static String getContact(Context context, String phoneNumber) {
//不到真正要用的时候不给对象分配内存。第一次被调用时才new。
if(sContactCache == null) {
sContactCache = new HashMap<String, String>();
}
//缓存命中,直接返回电话号码
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
//构造匹配串,提取数字核心部分
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
//cursor是数据库游标初始位置是-1query把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;
}

@ -14,43 +14,73 @@
* limitations under the License.
*/
/*
*Notes.java
*
* 2025-12-06
* 37
*/
package net.micode.notes.data;
import android.net.Uri;
/**
*Notes便
* <P>URI便/Intent</P>
* <b>static final</b>
* @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
* <P> Type: INTEGER (long) </P>
*/
public static final String ID = "_id";
@ -159,20 +195,74 @@ public class Notes {
* <P> Type : TEXT </P>
*/
public static final String GTASK_ID = "gtask_id";
/**
* Alert location latitude
* <P> Type: REAL </P>
*/
public static final String ALERT_LATITUDE = "alert_latitude";
/**
* Alert location longitude
* <P> Type: REAL </P>
*/
public static final String ALERT_LONGITUDE = "alert_longitude";
/**
* Alert location radius
* <P> Type: REAL </P>
*/
public static final String ALERT_RADIUS = "alert_radius";
/**
* Alert location name
* <P> Type: TEXT </P>
*/
public static final String ALERT_LOCATION_NAME = "alert_location_name";
/**
* Note tag
* <P> Type: TEXT </P>
*/
public static final String TAG = "tag";
/**
* The version code
* <P> Type : INTEGER (long) </P>
*/
public static final String VERSION = "version";
/**
* Lock status: 0-unlocked, 1-locked
* <P> Type: INTEGER </P>
*/
public static final String LOCKED = "locked";
/**
* Lock type: 0-none, 1-password, 2-gesture
* <P> Type: INTEGER </P>
*/
public static final String LOCK_TYPE = "lock_type";
/**
* Encrypted password for privacy lock
* <P> Type: TEXT </P>
*/
public static final String ENCRYPTED_PASSWORD = "encrypted_password";
}
//九、数据库列名接口 —— Data 表
/**
* DataColumns
*/
public interface DataColumns {
/**
* The unique ID for a row
* <P> Type: INTEGER (long) </P>
*/
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
* <P> Type: INTEGER </P>
*/
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
* <P> Type: INTEGER </P>
*/
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
* <P> Type: TEXT </P>
*/
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
* <P> Type: TEXT </P>
*/
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
* <P> Type: TEXT </P>
*/
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
* <P> Type: Integer 1:check list mode 0: normal mode </P>
*/
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 {
/**
*便
* CallNoteDataColumns
*/
public static final class CallNote implements DataColumns {
/**
* Call date for this record
* <P> Type: INTEGER (long) </P>
*/
public static final String CALL_DATE = DATA1;
public static final String CALL_DATE = DATA1; //DATA1是数据库中的真实列名将通话的时间戳存入DATA1列中
/**
* Phone number for this record

@ -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;
/**
*便
<P>
*
*<ul>
* <li>/ note data </li>
* <li>便便</li>
* <li></li>
* <li></li>
*</ul>
</P>
*
* @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索引列
/**
* NotesNoteColumns
* NotesNoteColumns便IDPARENT_IDNotes
* NOT NULLNULLDEFAULT 0 0NOT NULLDEFAULT
* strftimeSQLite%sUnixnow'
*/
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 SQLNotesDataColumns
* <p>
* {@link DataColumns#NOTE_ID} note.id <br>
* data1~data5 {@link DataColumns#MIME_TYPE}
* </p>
*/
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
* noteparent_id
* Notenotes_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}
* DATAmime_typenote()
* notesnippetcontentnoteid=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
* notedatanote_idnoteid
* 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
* notenoteparent_idid
*/
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 ''");
}
}

@ -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;
/**
* 便
*<P>ContentProviderSQLitenote.db</P>
* <ul>
* <li>CRUD()</li>
* <li></li>
* <li>URI</li>
* </ul>
* <p>URI</p>
* <pre>
* content://micode_notes/note 查询所有便签
* content://micode_notes/note/123 查询 ID=123 的便签
* content://micode_notes/data 查询所有数据行(附件、文本块、通话记录)
* content://micode_notes/search_suggest/xxx 系统搜索框建议接口
* </pre>
*
* @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; //提供搜索建议,实时联想输入关键词的匹配项
/**
* staticAndroid
* UriMatcheruri notedatasearch
* query/insert/delete/update URI
* 使staticqueryuri
*/
static {
//初始化常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
/**
* addURIuri
* uricontent://<AUTHORITY>/<path>(/?)
* "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.noteidsnippetSearchManager NoteColumns.ID SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA
* 2.SNIPPET REPLACEx'0A' '\n'
* TRIM
* SUGGEST_COLUMN_TEXT_1
*3.
* R.drawable.search_resultIntent.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;
}
/**
* ActivitySearchView访
* note/data// URIURIURISQL
* 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路径中的idgetPathSegments()返回[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;
}
/**
* ActivityServicenotedata
* content URI note\datauri
* @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 ID0
* @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;
}
/**
* SQLANDselection
* @param selection WHERE
* @return "AND(selection)"
*/
private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
/**
* idnote.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

@ -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 truefalse
*/
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 truefalse
*/
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 truefalse
*/
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; // 如果加密失败,返回原密码(实际项目中应该更安全地处理)
}
}
}

@ -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.classMetaDataclass
* getSimpleNameMetaData
*/
private final static String TAG = MetaData.class.getSimpleName();
//存储当前元数据关联的gid
private String mRelatedGid = null;
/**
*
* gtask IDJSONTask
* @param gid
* @param metaInfo JSONObjectMetaDataJSON
*/
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;
}
/**
* gtaskJSON
* @param js gtaskJSON
*/
@Override
public void setContentByRemoteJSON(JSONObject js) {
//调用父类方法初始化task基础属性
super.setContentByRemoteJSON(js);
if (getNotes() != null) {
try {
@ -63,17 +92,23 @@ public class MetaData extends Task {
}
}
/**JSON
* MetaDataSQLite
* 便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");

@ -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) {

@ -34,7 +34,11 @@ import net.micode.notes.gtask.exception.ActionFailureException;
import org.json.JSONException;
import org.json.JSONObject;
/**
*便
* JSONJSON /
* 便
*/
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);
}
/**
* JSONSqlData
* 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

@ -37,12 +37,18 @@ import org.json.JSONObject;
import java.util.ArrayList;
/**
* sqlNote
*
*
* AndroidContentProvider
*/
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; //是否有附件01
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<SqlData> mDataList;
private ArrayList<SqlData> mDataList; // 笔记关联的数据列表如文本内容、图片等由SqlData管理
//初始化新笔记
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -143,9 +151,12 @@ public class SqlNote {
mDataList = new ArrayList<SqlData>();
}
//从cursor加载已有笔记
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
//从数据库加载,标记为已存在
mIsCreate = false;
loadFromCursor(c);
mDataList = new ArrayList<SqlData>();
@ -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<SqlData>();
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---
* setContentJSONSqlNote---
*/
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; //标记为已创建
}
}

@ -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;
}
/**JSONz
*
* @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
* +
* entitygid
*/
// 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 {
}
}
/**
* 便JSONTask
* 便
* @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 {
}
}
/**
* 便cursortaskmMetaInfo
* 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_COLUMNSqlNote
*
* 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);

@ -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<Task> mChildren;
private ArrayList<Task> 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<Task> getChildTaskList() {

@ -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);
}

@ -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);
}

@ -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
* GTaskGTaskManager
*
* / /
* 广
*/
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
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);
}
/**
* 线
* GTaskManagersync
* @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()));

@ -60,35 +60,40 @@ import java.util.zip.GZIPInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
/**
* Google
* GoogleHTTP/
*/
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<Bundle> 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<Cookie> 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 = ")}</script>";
String jsBegin = "_setup("; // 响应中包含客户端版本的JS前缀
String jsEnd = ")}</script>"; // 后缀
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<BasicNameValuePair> list = new LinkedList<BasicNameValuePair>();
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 = ")}</script>";
String jsBegin = "_setup("; // 响应中任务列表的JS前缀
String jsEnd = ")}</script>"; // 后缀
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;
}

@ -47,21 +47,24 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
/**
* Google
* NoteGoogle
*/
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<String, TaskList> mGTaskListHashMap;
private HashMap<String, TaskList> mGTaskListHashMap; //远程任务列表key任务列表GID
private HashMap<String, Node> mGTaskHashMap;
private HashMap<String, Node> mGTaskHashMap; //所有远程节点(任务/列表key节点GID
private HashMap<String, MetaData> mMetaHashMap;
private HashMap<String, MetaData> mMetaHashMap; //元数据key关联的任务GID
private TaskList mMetaList;
private TaskList mMetaList; //元数据列表
private HashSet<Long> mLocalDeleteIdMap;
private HashSet<Long> mLocalDeleteIdMap; //记录需要从远程删除的本地笔记ID
private HashMap<String, Long> mGidToNid;
private HashMap<String, Long> mGidToNid; //远程GID到本地笔记ID的映射关系
private HashMap<Long, String> mNidToGid;
private HashMap<Long, String> mNidToGid; //本地笔记ID到远程GID的映射关系
//初始化所有集合和状态变量(单例模式防止外部实例化)
private GTaskManager() {
mSyncing = false;
mCancelled = false;
@ -99,6 +103,7 @@ public class GTaskManager {
mNidToGid = new HashMap<Long, String>();
}
// 单例获取方法:保证全局唯一实例
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<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, Node> 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<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, TaskList> 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<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, TaskList> 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;
}

@ -23,6 +23,10 @@ import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
/**
* ServiceAndroid
* 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;
}

@ -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;// 文本数据在数据库中的ID0表示未创建
private ContentValues mTextDataValues;
private ContentValues mTextDataValues; // 存储文本数据的变化
private long mCallDataId;
private long mCallDataId; // 通话记录数据在数据库中的ID0表示未创建
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=0ID>0
* @param context
* @param noteId ID
* @return Urinull
*/
Uri pushIntoContentResolver(Context context, long noteId) {
/**
* Check for safety
*/
// 校验笔记ID有效性
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
}
// 创建批量操作列表(支持同时更新文本和通话数据)
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
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; // 无批量操作需执行(如仅插入了新数据,未更新)
}
}
}

@ -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;
/**
* NoteWorkingNotemNote
*
*/
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

@ -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<String, Void, String> {
@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<String> coreKeywords = extractCoreKeywords(cleanContent, theme);
// 根据主题、类型和核心关键词生成标题
return generateTitleByThemeTypeAndKeywords(cleanContent, theme, contentType, coreKeywords);
}
/**
*
* @param content
* @return
*/
private String analyzeTheme(String content) {
// 简洁的主题关键词库,只保留通用主题词汇,去掉重复和具体课程名称
String[] themes = {
"学习", "工作", "会议", "计划", "总结", "任务", "想法",
"灵感", "生活", "旅行", "美食", "健康", "运动", "训练",
"购物", "阅读", "写作", "思考", "讨论", "研究", "开发", "设计",
"项目", "方案", "报告", "文档", "邮件", "电话", "客户",
"产品", "市场", "销售", "运营", "财务", "人事", "管理",
"技术", "代码", "测试", "上线", "维护", "优化", "创新",
"家庭", "朋友", "聚会", "电影", "音乐", "游戏", "动漫",
"书籍", "文章", "新闻", "资讯", "医疗", "养生",
"烹饪", "烘焙", "餐厅", "外卖", "食材", "食谱",
"景点", "酒店", "交通", "攻略", "行程", "机票",
"商品", "价格", "优惠", "促销", "订单", "物流",
"健身", "锻炼", "瑜伽", "跑步", "游泳", "篮球", "足球"
};
// 主题相关词汇映射,为每个主题添加丰富的相关词汇
Map<String, List<String>> 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<String> 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<String> extractCoreKeywords(String content, String theme) {
List<String> keywords = new ArrayList<>();
// 常见关键词库,按领域分类
Map<String, List<String>> keywordLibrary = new HashMap<>();
keywordLibrary.put("学习", new ArrayList<String>() {{
add("毛概"); add("系统工程"); add("数据结构"); add("数学"); add("英语");
add("物理"); add("化学"); add("生物"); add("历史"); add("地理");
add("政治"); add("语文"); add("计算机"); add("编程"); add("算法");
}});
keywordLibrary.put("工作", new ArrayList<String>() {{
add("会议"); add("报告"); add("项目"); add("计划"); add("总结");
add("方案"); add("设计"); add("开发"); add("测试"); add("上线");
}});
keywordLibrary.put("生活", new ArrayList<String>() {{
add("吃饭"); add("睡觉"); add("运动"); add("购物"); add("旅行");
add("电影"); add("音乐"); add("阅读"); add("游戏"); add("社交");
}});
// 获取当前主题相关的关键词库
List<String> 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<String, Integer> 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<String> 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<String> 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<String> coreKeywords) {
// 生成简洁的标题:主题 + 任务
return theme + "任务";
}
/**
*
* @param content
* @param theme
* @param coreKeywords
* @return
*/
private String generateEnhancedSummaryTitle(String content, String theme, List<String> 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<String> 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) + "...";
}
}

@ -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) {

@ -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;

@ -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;
/**
* SpanSpannable
*/
public class ImageSpanUtils {
/**
* SpannableJSON
*
* @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;
}
}

@ -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<Integer> 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<Integer> gesturePoints) {
StringBuilder sb = new StringBuilder();
for (int point : gesturePoints) {
sb.append(point);
}
return sb.toString();
}
/**
*
* @param gestureString
* @return
*/
public static List<Integer> stringToGesture(String gestureString) {
List<Integer> gesturePoints = new ArrayList<>();
for (char c : gestureString.toCharArray()) {
gesturePoints.add(Character.getNumericValue(c));
}
return gesturePoints;
}
}

@ -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 {
/**
* SpannableJSON
*
* @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;
}
}

@ -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 或 1430
"(\\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<String> 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 或 1430
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 truefalse
*/
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<String> 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<String> timeStrs1 = new ArrayList<>();
while (timeMatcher1.find()) {
timeStrs1.add(timeMatcher1.group());
}
List<String> 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 truefalse
*/
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<String> 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 或 1430
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();
}
}

@ -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();
}
}

@ -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

@ -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<GesturePoint> mPoints; // 手势点集合
private List<Integer> mSelectedPoints; // 已选择的点集合
private List<GestureLine> mLines; // 连接线集合
private GesturePoint mCurrentPoint; // 当前手指位置点
private boolean mIsDrawing; // 是否正在绘制
private OnGestureCompleteListener mListener; // 手势完成监听器
public interface OnGestureCompleteListener {
void onGestureComplete(List<Integer> 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();
}
}

@ -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();
}
}

File diff suppressed because it is too large Load Diff

@ -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;
}
/**
*

@ -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<String> tagList = new ArrayList<>();
// 预设标签
List<String> defaultTags = new ArrayList<>();
defaultTags.add(NoteEditActivity.TAG_LIFE);
defaultTags.add(NoteEditActivity.TAG_STUDY);
defaultTags.add(NoteEditActivity.TAG_WORK);
// 自定义标签
List<String> 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<String> finalTags = new ArrayList<>();
List<String> 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<Long> ids = new HashSet<Long>();
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");
}
}
}

@ -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);
}

@ -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 <T> void toggleSpan(Class<T> 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);
}
}
}

@ -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();
}
}

@ -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);
}
}

@ -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); // 排序方式(无)
}

Loading…
Cancel
Save