pnju9rpvk
/
mijia_node
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

添加注释1 #2

Merged
pnju9rpvk merged 8 commits from Lulanjian into main 4 months ago
Conversation 0 Commits 8 Files Changed 7
7 changed files with 500 additions and 393 deletions
Show Stats Download Patch File Download Diff File

36
MiNotes-master/app/src/main/java/net/micode/notes/data/Contact.java
Unescape View File

@ -24,11 +24,18 @@ import android.telephony.PhoneNumberUtils;
import android.util.Log;
import java.util.HashMap;
//该工具类用于通过电话号码查询联系人姓名，并且会对查询结果进行缓存，从而避免重复查询，提高后续查询的效率。
public class Contact {
// 用于缓存已查询过的电话号码及其对应的联系人姓名
private static HashMap<String, String> sContactCache;
private static final String TAG = "Contact";
// 用于查询联系人的 SQL 条件语句，借助 PHONE_NUMBERS_EQUAL 函数
// 来匹配电话号码，同时会对原始联系人 ID 进行验证
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,36 +43,55 @@ public class Contact {
+ " FROM phone_lookup"
+ " WHERE min_match = '+')";
//依据给定的电话号码，在联系人数据库中查找对应的联系人姓名。 要是找到了联系人，就会将结果缓存起来，方便后续使用。上下文对象，用于获取 ContentResolver。要查询的电话号码。若找到联系人，返回其显示名称；若未找到或者出现错误，返回 null。
public static String getContact(Context context, String phoneNumber) {
// 初始化缓存
if(sContactCache == null) {
sContactCache = new HashMap<String, String>();
}
// 先检查缓存，若已有结果则直接返回
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
// 针对当前电话号码，定制化查询条件
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
// 执行联系人数据库查询
Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI,
new String [] { Phone.DISPLAY_NAME },
selection,
new String[] { phoneNumber },
null);
Data.CONTENT_URI, // 查询的内容 URI
new String [] { Phone.DISPLAY_NAME }, // 要获取的字段
selection, // 定制后的查询条件
new String[] { phoneNumber }, // 查询参数
null); // 不使用排序
// 处理查询结果
if (cursor != null && cursor.moveToFirst()) {
try {
// 获取联系人姓名并缓存
String name = cursor.getString(0);
sContactCache.put(phoneNumber, name);
return name;
} catch (IndexOutOfBoundsException e) {
// 处理可能出现的索引越界异常
Log.e(TAG, " Cursor get string error " + e.toString());
return null;
} finally {
// 确保游标资源被关闭
cursor.close();
}
} else {
// 未找到匹配的联系人
Log.d(TAG, "No contact matched with number:" + phoneNumber);
return null;
}

200
MiNotes-master/app/src/main/java/net/micode/notes/data/Notes.java
Unescape View File

@ -17,12 +17,19 @@
package net.micode.notes.data;
import android.net.Uri;
/**
* 笔记和文件夹管理的核心数据类
* 包含数据类型定义、URI路径、数据库字段常量等
*/
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;
public static final String AUTHORITY = "micode_notes"; // 内容提供器的 authority（用于ContentProvider标识）
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;// 系统类型（如系统文件夹）
/**
* Following IDs are system folders' identifiers
@ -35,245 +42,198 @@ public class Notes {
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";
public static final int TYPE_WIDGET_INVALIDE = -1;
public static final int TYPE_WIDGET_2X = 0;
public static final int TYPE_WIDGET_4X = 1;
// 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";// 背景颜色ID
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id"; // 桌面小部件ID
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";// 小部件类型
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id"; // 文件夹ID
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date"; // 通话日期
// 桌面小部件类型常量
public static final int TYPE_WIDGET_INVALIDE = -1;// 无效类型
public static final int TYPE_WIDGET_2X = 0;// 2x尺寸小部件
public static final int TYPE_WIDGET_4X = 1;// 4x尺寸小部件
public static class DataConstants {
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE; // 文本笔记MIME类型
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;// 通话笔记MIME类型
}
/**
* Uri to query all notes and folders
* 数据类型常量内部类
* 定义不同数据项的MIME类型
*/
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note"); // 通用数据查询URI（包含所有笔记和文件夹）
/**
* Uri to query data
*/
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data"); // 具体数据项查询URI（如附件、内容详情）
public interface NoteColumns {
/**
* The unique ID for a row
* <P> Type: INTEGER (long) </P>
*/
public static final String ID = "_id";
/**
* The parent's id for note or folder
* <P> Type: INTEGER (long) </P>
*/
public static final String PARENT_ID = "parent_id";
/**
* Created data for note or folder
* <P> Type: INTEGER (long) </P>
*/
public static final String CREATED_DATE = "created_date";
public static final String PARENT_ID = "parent_id";//父级ID（笔记所属文件夹ID，文件夹的父文件夹ID）
/**
* Latest modified date
* <P> Type: INTEGER (long) </P>
*/
public static final String MODIFIED_DATE = "modified_date";
public static final String CREATED_DATE = "created_date";//创建时间（时间戳）
/**
* Alert date
* <P> Type: INTEGER (long) </P>
*/
public static final String ALERTED_DATE = "alert_date";
public static final String MODIFIED_DATE = "modified_date";//最后修改时间（时间戳）
/**
* Folder's name or text content of note
* <P> Type: TEXT </P>
*/
public static final String SNIPPET = "snippet";
/**
* Note's widget id
* <P> Type: INTEGER (long) </P>
*/
public static final String WIDGET_ID = "widget_id";
public static final String ALERTED_DATE = "alert_date";//提醒时间（时间戳）
/**
* Note's widget type
* <P> Type: INTEGER (long) </P>
*/
public static final String WIDGET_TYPE = "widget_type";
/**
* Note's background color's id
* <P> Type: INTEGER (long) </P>
*/
public static final String BG_COLOR_ID = "bg_color_id";
public static final String SNIPPET = "snippet";//文件夹名称或笔记内容摘要
public static final String WIDGET_ID = "widget_id";//关联的桌面小部件ID
public static final String WIDGET_TYPE = "widget_type";//桌面小部件类型
public static final String BG_COLOR_ID = "bg_color_id";//背景颜色ID
/**
* For text note, it doesn't has attachment, for multi-media
* note, it has at least one attachment
* <P> Type: INTEGER </P>
是否包含附件
*/
public static final String HAS_ATTACHMENT = "has_attachment";
/**
* Folder's count of notes
* <P> Type: INTEGER (long) </P>
文件夹内的笔记数量
*/
public static final String NOTES_COUNT = "notes_count";
/**
* The file type: folder or note
* <P> Type: INTEGER </P>
数据类型
*/
public static final String TYPE = "type";
/**
* The last sync id
* <P> Type: INTEGER (long) </P>
最后同步ID
*/
public static final String SYNC_ID = "sync_id";
/**
* Sign to indicate local modified or not
* <P> Type: INTEGER </P>
本地是否修改过
*/
public static final String LOCAL_MODIFIED = "local_modified";
/**
* Original parent id before moving into temporary folder
* <P> Type : INTEGER </P>
移动到临时文件夹前的原始父ID
*/
public static final String ORIGIN_PARENT_ID = "origin_parent_id";
/**
* The gtask id
* <P> Type : TEXT </P>
关联的Google任务ID
*/
public static final String GTASK_ID = "gtask_id";
/**
* The version code
* <P> Type : INTEGER (long) </P>
数据版本号
*/
public static final String VERSION = "version";
}
public interface DataColumns {
/**
* The unique ID for a row
* <P> Type: INTEGER (long) </P>
* 数据项字段接口
* 定义具体数据项（如附件、内容）的公共字段
*/
public static final String ID = "_id";
public interface DataColumns {
public static final String ID = "_id"; // 行唯一标识
/**
* The MIME type of the item represented by this row.
* <P> Type: Text </P>
MIME类型（标识数据项类型，如文本、图片、音频等）
*/
public static final String MIME_TYPE = "mime_type";
/**
* The reference id to note that this data belongs to
* <P> Type: INTEGER (long) </P>
所属笔记ID（关联到Note表的ID）
*/
public static final String NOTE_ID = "note_id";
/**
* Created data for note or folder
* <P> Type: INTEGER (long) </P>
创建时间（时间戳）
*/
public static final String CREATED_DATE = "created_date";
/**
* Latest modified date
* <P> Type: INTEGER (long) </P>
最后修改时间（时间戳）
*/
public static final String MODIFIED_DATE = "modified_date";
/**
* Data's content
* <P> Type: TEXT </P>
数据内容（具体内容根据MIME类型而定）
*/
public static final String CONTENT = "content";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* integer data type
* <P> Type: INTEGER </P>
通用数据字段1（类型由MIME类型决定）
*/
public static final String DATA1 = "data1";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* integer data type
* <P> Type: INTEGER </P>
通用数据字段2（类型由MIME类型决定）
*/
public static final String DATA2 = "data2";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
通用数据字段3（类型由MIME类型决定）
*/
public static final String DATA3 = "data3";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
通用数据字段4（类型由MIME类型决定）
*/
public static final String DATA4 = "data4";
/**
* Generic data column, the meaning is {@link #MIMETYPE} specific, used for
* TEXT data type
* <P> Type: TEXT </P>
通用数据字段5（类型由MIME类型决定）
*/
public static final String DATA5 = "data5";
}
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>
笔记模式（1=待办清单模式，0=普通文本模式）
*/
public static final String MODE = DATA1;
public static final int MODE_CHECK_LIST = 1;
public static final int MODE_CHECK_LIST = 1;// 待办清单模式标识
// MIME类型定义
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/text_note";
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/text_note";
// 文本笔记内容URI
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
public static final class CallNote implements DataColumns {
/**
* Call date for this record
* <P> Type: INTEGER (long) </P>
通话时间
*/
public static final String CALL_DATE = DATA1;
/**
* Phone number for this record
* <P> Type: TEXT </P>
电话号码
*/
public static final String PHONE_NUMBER = DATA3;
// MIME类型定义
public static final String CONTENT_TYPE = "vnd.android.cursor.dir/call_note";
public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/call_note";
// 通话笔记内容URI
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/call_note");
}
}

188
MiNotes-master/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java
Unescape View File

@ -28,63 +28,75 @@ import net.micode.notes.data.Notes.NoteColumns;
public class NotesDatabaseHelper extends SQLiteOpenHelper {
// 数据库名称
private static final String DB_NAME = "note.db";
// 数据库版本号
private static final int DB_VERSION = 4;
// 表名接口
public interface TABLE {
// 笔记表名
public static final String NOTE = "note";
// 数据项表名（如附件、内容详情）
public static final String DATA = "data";
}
// 日志标签
private static final String TAG = "NotesDatabaseHelper";
// 单例实例
private static NotesDatabaseHelper mInstance;
// 创建笔记表的SQL语句
private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" +
NoteColumns.ID + " INTEGER PRIMARY KEY," +
NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," +
NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," +
NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," +
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.ID + " INTEGER PRIMARY KEY," + // 主键ID
NoteColumns.PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 父文件夹ID（默认0）
NoteColumns.ALERTED_DATE + " INTEGER NOT NULL DEFAULT 0," + // 提醒时间（默认0）
NoteColumns.BG_COLOR_ID + " INTEGER NOT NULL DEFAULT 0," + // 背景颜色ID（默认0）
NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 创建时间（默认当前时间戳）
NoteColumns.HAS_ATTACHMENT + " INTEGER NOT NULL DEFAULT 0," + // 是否有附件（默认0）
NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 修改时间（默认当前时间戳）
NoteColumns.NOTES_COUNT + " INTEGER NOT NULL DEFAULT 0," + // 子笔记数量（默认0）
NoteColumns.SNIPPET + " TEXT NOT NULL DEFAULT ''," + // 内容摘要（默认空）
NoteColumns.TYPE + " INTEGER NOT NULL DEFAULT 0," + // 类型（默认0：笔记）
NoteColumns.WIDGET_ID + " INTEGER NOT NULL DEFAULT 0," + // 小部件ID（默认0）
NoteColumns.WIDGET_TYPE + " INTEGER NOT NULL DEFAULT -1," + // 小部件类型（默认-1：无效）
NoteColumns.SYNC_ID + " INTEGER NOT NULL DEFAULT 0," + // 同步ID（默认0）
NoteColumns.LOCAL_MODIFIED + " INTEGER NOT NULL DEFAULT 0," + // 本地修改标记（默认0）
NoteColumns.ORIGIN_PARENT_ID + " INTEGER NOT NULL DEFAULT 0," + // 原始父ID（默认0）
NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," + // Google任务ID（默认空）
NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + // 版本号（默认0）
")";
// 创建数据项表的SQL语句
private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" +
DataColumns.ID + " INTEGER PRIMARY KEY," +
DataColumns.MIME_TYPE + " TEXT NOT NULL," +
DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," +
NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," +
DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," +
DataColumns.DATA1 + " INTEGER," +
DataColumns.DATA2 + " INTEGER," +
DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," +
DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
DataColumns.ID + " INTEGER PRIMARY KEY," + // 主键ID
DataColumns.MIME_TYPE + " TEXT NOT NULL," + // MIME类型（必填）
DataColumns.NOTE_ID + " INTEGER NOT NULL DEFAULT 0," + // 所属笔记ID（默认0）
NoteColumns.CREATED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 创建时间（默认当前时间戳）
NoteColumns.MODIFIED_DATE + " INTEGER NOT NULL DEFAULT (strftime('%s','now') * 1000)," + // 修改时间（默认当前时间戳）
DataColumns.CONTENT + " TEXT NOT NULL DEFAULT ''," + // 内容（默认空）
DataColumns.DATA1 + " INTEGER," + // 通用数据1（整数）
DataColumns.DATA2 + " INTEGER," + // 通用数据2（整数）
DataColumns.DATA3 + " TEXT NOT NULL DEFAULT ''," + // 通用数据3（文本）
DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," + // 通用数据4（文本）
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + // 通用数据5（文本）
")";
// 创建数据项表的笔记ID索引SQL
private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
"CREATE INDEX IF NOT EXISTS note_id_index ON " +
TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
TABLE.DATA + "(" + DataColumns.NOTE_ID + ");"; // 基于note_id创建索引
/**
* Increase folder's note count when move note to the folder
* 以下为数据库触发器（用于自动维护数据一致性）
*/
// 更新笔记父文件夹时增加目标文件夹笔记数的触发器
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_update "+
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
@ -94,9 +106,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
" END";
/**
* Decrease folder's note count when move note from folder
*/
// 更新笔记父文件夹时减少原文件夹笔记数的触发器
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_update " +
" AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE +
@ -107,9 +117,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" AND " + NoteColumns.NOTES_COUNT + ">0" + ";" +
" END";
/**
* Increase folder's note count when insert new note to the folder
*/
// 插入新笔记时增加目标文件夹笔记数的触发器
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_insert " +
" AFTER INSERT ON " + TABLE.NOTE +
@ -119,9 +127,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.ID + "=new." + NoteColumns.PARENT_ID + ";" +
" END";
/**
* Decrease folder's note count when delete note from the folder
*/
// 删除笔记时减少原文件夹笔记数的触发器
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE +
@ -132,9 +138,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" AND " + NoteColumns.NOTES_COUNT + ">0;" +
" END";
/**
* Update note's content when insert data with type {@link DataConstants#NOTE}
*/
// 插入文本笔记数据时更新笔记内容的触发器
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " +
" AFTER INSERT ON " + TABLE.DATA +
@ -145,9 +149,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END";
/**
* Update note's content when data with {@link DataConstants#NOTE} type has changed
*/
// 更新文本笔记数据时更新笔记内容的触发器
private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER update_note_content_on_update " +
" AFTER UPDATE ON " + TABLE.DATA +
@ -158,9 +160,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.ID + "=new." + DataColumns.NOTE_ID + ";" +
" END";
/**
* Update note's content when data with {@link DataConstants#NOTE} type has deleted
*/
// 删除文本笔记数据时清空笔记内容的触发器
private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER =
"CREATE TRIGGER update_note_content_on_delete " +
" AFTER delete ON " + TABLE.DATA +
@ -171,9 +171,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.ID + "=old." + DataColumns.NOTE_ID + ";" +
" END";
/**
* Delete datas belong to note which has been deleted
*/
// 删除笔记时级联删除相关数据项的触发器
private static final String NOTE_DELETE_DATA_ON_DELETE_TRIGGER =
"CREATE TRIGGER delete_data_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE +
@ -182,9 +180,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + DataColumns.NOTE_ID + "=old." + NoteColumns.ID + ";" +
" END";
/**
* Delete notes belong to folder which has been deleted
*/
// 删除文件夹时级联删除子笔记的触发器
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " +
" AFTER DELETE ON " + TABLE.NOTE +
@ -193,9 +189,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
/**
* Move notes belong to folder which has been moved to trash folder
*/
// 文件夹移动到回收站时级联移动子笔记的触发器
private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
"CREATE TRIGGER folder_move_notes_on_trash " +
" AFTER UPDATE ON " + TABLE.NOTE +
@ -206,18 +200,22 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
// 构造方法
public NotesDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
// 创建笔记表（含触发器和系统文件夹）
public void createNoteTable(SQLiteDatabase db) {
db.execSQL(CREATE_NOTE_TABLE_SQL);
reCreateNoteTableTriggers(db);
createSystemFolder(db);
Log.d(TAG, "note table has been created");
db.execSQL(CREATE_NOTE_TABLE_SQL); // 执行建表语句
reCreateNoteTableTriggers(db); // 重建触发器
createSystemFolder(db); // 创建系统文件夹
Log.d(TAG, "note table has been created"); // 日志记录
}
// 重建笔记表相关触发器（先删除旧触发器再创建新触发器）
private void reCreateNoteTableTriggers(SQLiteDatabase db) {
// 删除旧触发器
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
@ -226,6 +224,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
// 创建新触发器
db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
@ -235,58 +234,56 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
// 创建系统文件夹（根文件夹、临时文件夹等）
private void createSystemFolder(SQLiteDatabase db) {
ContentValues values = new ContentValues();
/**
* call record foler for call notes
*/
// 创建通话记录文件夹
values.put(NoteColumns.ID, Notes.ID_CALL_RECORD_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
/**
* root folder which is default folder
*/
// 创建根文件夹
values.clear();
values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
/**
* temporary folder which is used for moving note
*/
// 创建临时文件夹
values.clear();
values.put(NoteColumns.ID, Notes.ID_TEMPARAY_FOLDER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
/**
* create trash folder
*/
// 创建回收站文件夹
values.clear();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
// 创建数据项表（含触发器和索引）
public void createDataTable(SQLiteDatabase db) {
db.execSQL(CREATE_DATA_TABLE_SQL);
reCreateDataTableTriggers(db);
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
Log.d(TAG, "data table has been created");
db.execSQL(CREATE_DATA_TABLE_SQL); // 执行建表语句
reCreateDataTableTriggers(db); // 重建触发器
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL); // 创建索引
Log.d(TAG, "data table has been created"); // 日志记录
}
// 重建数据项表相关触发器
private void reCreateDataTableTriggers(SQLiteDatabase db) {
// 删除旧触发器
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_update");
db.execSQL("DROP TRIGGER IF EXISTS update_note_content_on_delete");
// 创建新触发器
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER);
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
}
// 获取单例实例
static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context);
@ -294,68 +291,83 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
return mInstance;
}
// 数据库创建回调（首次创建时调用）
@Override
public void onCreate(SQLiteDatabase db) {
createNoteTable(db);
createDataTable(db);
createNoteTable(db); // 创建笔记表
createDataTable(db); // 创建数据项表
}
// 数据库升级回调（版本号变更时调用）
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false;
boolean skipV2 = false;
boolean reCreateTriggers = false; // 是否需要重建触发器
boolean skipV2 = false; // 是否跳过V2升级步骤
// 从版本1升级到版本2（全量重建表）
if (oldVersion == 1) {
upgradeToV2(db);
skipV2 = true; // this upgrade including the upgrade from v2 to v3
skipV2 = true; // 标记已完成V2升级（避免重复处理）
oldVersion++;
}
// 从版本2升级到版本3（添加GTASK_ID和回收站文件夹）
if (oldVersion == 2 && !skipV2) {
upgradeToV3(db);
reCreateTriggers = true;
reCreateTriggers = true; // 需要重建触发器
oldVersion++;
}
// 从版本3升级到版本4（添加VERSION字段）
if (oldVersion == 3) {
upgradeToV4(db);
oldVersion++;
}
// 按需重建触发器
if (reCreateTriggers) {
reCreateNoteTableTriggers(db);
reCreateDataTableTriggers(db);
}
// 升级失败处理
if (oldVersion != newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails");
}
}
// 升级到版本2（全量重建表）
private void upgradeToV2(SQLiteDatabase db) {
// 删除旧表
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
// 重新创建表（包含最新结构和触发器）
createNoteTable(db);
createDataTable(db);
}
// 升级到版本3（添加GTASK_ID字段和回收站文件夹）
private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers
// 删除不再使用的触发器（旧版本遗留）
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_update");
// add a column for gtask id
// 向笔记表添加GTASK_ID字段（用于关联Google任务）
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ " TEXT NOT NULL DEFAULT ''");
// add a trash system folder
// 创建回收站系统文件夹（ID为-3）
ContentValues values = new ContentValues();
values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 标记为系统类型
db.insert(TABLE.NOTE, null, values); // 插入系统文件夹数据
}
// 升级到版本4（添加VERSION字段用于数据版本管理）
private void upgradeToV4(SQLiteDatabase db) {
// 向笔记表添加VERSION字段（记录数据版本号，用于升级校验）
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");
}

202
MiNotes-master/app/src/main/java/net/micode/notes/data/NotesProvider.java
Unescape View File

@ -14,6 +14,8 @@
* limitations under the License.
*/
package net.micode.notes.data;
@ -35,89 +37,114 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE;
/**
* 笔记内容提供器（实现Android ContentProvider接口）
* 负责处理数据的增删改查操作，并支持搜索建议功能
*/
public class NotesProvider extends ContentProvider {
// URI匹配器（用于解析不同的URI请求）
private static final UriMatcher mMatcher;
// 数据库帮助类实例（用于操作数据库）
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_SEARCH = 5;
private static final int URI_SEARCH_SUGGEST = 6;
// URI匹配器常量（对应不同的操作类型）
private static final int URI_NOTE = 1; // 笔记列表URI
private static final int URI_NOTE_ITEM = 2; // 单个笔记URI
private static final int URI_DATA = 3; // 数据项列表URI（如附件）
private static final int URI_DATA_ITEM = 4; // 单个数据项URI
private static final int URI_SEARCH = 5; // 搜索请求URI
private static final int URI_SEARCH_SUGGEST = 6; // 搜索建议URI
// 静态代码块：初始化URI匹配器
static {
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
// 匹配笔记列表URI：content://micode_notes/note
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
// 匹配单个笔记URI：content://micode_notes/note/123
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
// 匹配数据项列表URI：content://micode_notes/data
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
// 匹配单个数据项URI：content://micode_notes/data/456
mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
// 匹配搜索URI：content://micode_notes/search
mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
// 匹配搜索建议URI（带查询词）：content://micode_notes/suggest_query/xxx
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
}
/**
* 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.
* 搜索投影定义（用于构建搜索结果的字段）
* - 替换换行符x'0A'为空格，并修剪空白字符
* - 关联SearchManager所需的字段（如搜索建议文本、图标、意图等）
*/
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + ","
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + ","
+ R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + "," // 传递笔记ID到意图
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + "," // 搜索建议第一行文本
+ "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_2 + "," // 搜索建议第二行文本
+ R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + "," // 搜索结果图标资源ID
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + "," // 点击后的动作（查看笔记）
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA; // 意图数据类型
// 搜索查询语句（查询包含关键词的笔记内容，排除回收站和非笔记类型）
private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+ " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
+ " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?" // 模糊匹配搜索词
+ " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER // 排除回收站中的笔记
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE; // 仅查询普通笔记类型
// ContentProvider初始化方法（创建数据库帮助类实例）
@Override
public boolean onCreate() {
mHelper = NotesDatabaseHelper.getInstance(getContext());
mHelper = NotesDatabaseHelper.getInstance(getContext()); // 获取数据库帮助类单例
return true;
}
// 查询数据方法（处理不同URI的查询请求）
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
Cursor c = null;
SQLiteDatabase db = mHelper.getReadableDatabase();
String id = null;
SQLiteDatabase db = mHelper.getReadableDatabase(); // 获取可读数据库
String id = null; // 用于存储URI中的ID部分
switch (mMatcher.match(uri)) {
case URI_NOTE:
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
sortOrder);
// 查询笔记列表
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, sortOrder);
break;
case URI_NOTE_ITEM:
// 查询单个笔记（从URI路径中提取ID）
id = uri.getPathSegments().get(1);
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
c = db.query(TABLE.NOTE, projection,
NoteColumns.ID + "=" + id + parseSelection(selection), // 添加ID条件和附加查询条件
selectionArgs, null, null, sortOrder);
break;
case URI_DATA:
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
sortOrder);
// 查询数据项列表（如附件）
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null, sortOrder);
break;
case URI_DATA_ITEM:
// 查询单个数据项（从URI路径中提取ID）
id = uri.getPathSegments().get(1);
c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
c = db.query(TABLE.DATA, projection,
DataColumns.ID + "=" + id + parseSelection(selection), // 添加ID条件和附加查询条件
selectionArgs, null, null, sortOrder);
break;
case URI_SEARCH:
case URI_SEARCH_SUGGEST:
// 处理搜索和搜索建议请求
if (sortOrder != null || projection != null) {
throw new IllegalArgumentException(
"do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
"搜索查询不支持排序或投影参数");
}
String searchString = null;
// 从URI中提取搜索词（根据不同的URI类型）
if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
if (uri.getPathSegments().size() > 1) {
searchString = uri.getPathSegments().get(1);
@ -127,179 +154,186 @@ public class NotesProvider extends ContentProvider {
}
if (TextUtils.isEmpty(searchString)) {
return null;
return null; // 空搜索词返回空结果
}
try {
// 构造模糊查询参数（前后添加通配符）
searchString = String.format("%%%s%%", searchString);
c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
new String[] { searchString });
// 执行原生SQL查询（使用预定义的搜索语句）
c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, new String[] { searchString });
} catch (IllegalStateException ex) {
Log.e(TAG, "got exception: " + ex.toString());
Log.e(TAG, "搜索查询异常: " + ex.toString());
}
break;
default:
throw new IllegalArgumentException("Unknown URI " + uri);
throw new IllegalArgumentException("未知URI: " + uri);
}
if (c != null) {
// 设置内容变更通知（当数据变化时通知观察者）
c.setNotificationUri(getContext().getContentResolver(), uri);
}
return c;
}
// 插入数据方法（处理不同URI的插入请求）
@Override
public Uri insert(Uri uri, ContentValues values) {
SQLiteDatabase db = mHelper.getWritableDatabase();
long dataId = 0, noteId = 0, insertedId = 0;
SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
long dataId = 0, noteId = 0, insertedId = 0; // 插入记录的ID
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 插入新笔记
insertedId = noteId = db.insert(TABLE.NOTE, null, values);
break;
case URI_DATA:
// 插入新数据项（需关联笔记ID）
if (values.containsKey(DataColumns.NOTE_ID)) {
noteId = values.getAsLong(DataColumns.NOTE_ID);
noteId = values.getAsLong(DataColumns.NOTE_ID); // 从参数中获取所属笔记ID
} else {
Log.d(TAG, "Wrong data format without note id:" + values.toString());
Log.d(TAG, "错误：数据项未包含笔记ID: " + values.toString());
}
insertedId = dataId = db.insert(TABLE.DATA, null, values);
break;
default:
throw new IllegalArgumentException("Unknown URI " + uri);
throw new IllegalArgumentException("未知URI: " + uri);
}
// Notify the note uri
// 通知内容变更（根据插入的是笔记还是数据项）
if (noteId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null); // 通知笔记URI变更
}
// Notify the data uri
if (dataId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null); // 通知数据项URI变更
}
return ContentUris.withAppendedId(uri, insertedId);
return ContentUris.withAppendedId(uri, insertedId); // 返回插入记录的URI
}
// 删除数据方法（处理不同URI的删除请求）
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
int count = 0;
String id = null;
SQLiteDatabase db = mHelper.getWritableDatabase();
boolean deleteData = false;
SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
boolean deleteData = false; // 是否删除的是数据项（用于通知逻辑）
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 删除笔记列表（添加条件：ID>0，排除系统文件夹）
selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 ";
count = db.delete(TABLE.NOTE, selection, selectionArgs);
break;
case URI_NOTE_ITEM:
// 删除单个笔记（从URI中提取ID，排除系统文件夹）
id = uri.getPathSegments().get(1);
/**
* ID that smaller than 0 is system folder which is not allowed to
* trash
*/
long noteId = Long.valueOf(id);
if (noteId <= 0) {
if (noteId <= 0) { // 系统文件夹ID为负数或0，不允许删除
break;
}
count = db.delete(TABLE.NOTE,
NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
break;
case URI_DATA:
count = db.delete(TABLE.DATA, selection, selectionArgs);
deleteData = true;
break;
case URI_DATA_ITEM:
id = uri.getPathSegments().get(1);
// 删除数据项（标记为删除数据项类型）
count = db.delete(TABLE.DATA,
DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
(uri.getPathSegments().size() > 1 ? DataColumns.ID + "=" + uri.getPathSegments().get(1) : selection)
+ parseSelection(selection), selectionArgs);
deleteData = true;
break;
default:
throw new IllegalArgumentException("Unknown URI " + uri);
throw new IllegalArgumentException("未知URI: " + uri);
}
if (count > 0) {
// 通知内容变更（数据项删除时需通知笔记列表，因为可能影响笔记内容）
if (deleteData) {
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
getContext().getContentResolver().notifyChange(uri, null);
getContext().getContentResolver().notifyChange(uri, null); // 通知当前URI变更
}
return count;
}
// 更新数据方法（处理不同URI的更新请求）
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
int count = 0;
String id = null;
SQLiteDatabase db = mHelper.getWritableDatabase();
boolean updateData = false;
SQLiteDatabase db = mHelper.getWritableDatabase(); // 获取可写数据库
boolean updateData = false; // 是否更新的是数据项（用于通知逻辑）
switch (mMatcher.match(uri)) {
case URI_NOTE:
increaseNoteVersion(-1, selection, selectionArgs);
count = db.update(TABLE.NOTE, values, selection, selectionArgs);
break;
case URI_NOTE_ITEM:
id = uri.getPathSegments().get(1);
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
// 更新笔记时增加版本号（用于数据同步或乐观锁）
increaseNoteVersion(uri.getPathSegments().size() > 1 ?
Long.valueOf(uri.getPathSegments().get(1)) : -1, selection, selectionArgs);
// 执行更新操作
count = db.update(TABLE.NOTE, values,
(uri.getPathSegments().size() > 1 ? NoteColumns.ID + "=" + uri.getPathSegments().get(1) : selection)
+ parseSelection(selection), selectionArgs);
break;
case URI_DATA:
count = db.update(TABLE.DATA, values, selection, selectionArgs);
updateData = true;
break;
case URI_DATA_ITEM:
id = uri.getPathSegments().get(1);
count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
// 更新数据项（标记为更新数据项类型）
count = db.update(TABLE.DATA, values,
(uri.getPathSegments().size() > 1 ? DataColumns.ID + "=" + uri.getPathSegments().get(1) : selection)
+ parseSelection(selection), selectionArgs);
updateData = true;
break;
default:
throw new IllegalArgumentException("Unknown URI " + uri);
throw new IllegalArgumentException("未知URI: " + uri);
}
if (count > 0) {
// 通知内容变更（数据项更新时需通知笔记列表，因为可能影响笔记内容）
if (updateData) {
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
getContext().getContentResolver().notifyChange(uri, null);
getContext().getContentResolver().notifyChange(uri, null); // 通知当前URI变更
}
return count;
}
// 解析附加查询条件（在主条件后添加AND子句）
private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
// 增加笔记版本号（用于数据变更跟踪，支持单条记录或批量更新）
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
StringBuilder sql = new StringBuilder(120);
sql.append("UPDATE ");
sql.append(TABLE.NOTE);
sql.append(" SET ");
sql.append(NoteColumns.VERSION);
sql.append("=" + NoteColumns.VERSION + "+1 ");
sql.append("UPDATE " + TABLE.NOTE + " SET " + NoteColumns.VERSION + "=" + NoteColumns.VERSION + "+1 ");
// 构建WHERE条件（支持按ID或自定义条件更新）
if (id > 0 || !TextUtils.isEmpty(selection)) {
sql.append(" WHERE ");
}
if (id > 0) {
sql.append(NoteColumns.ID + "=" + String.valueOf(id));
}
if (!TextUtils.isEmpty(selection)) {
// 替换占位符?为实际参数值（简化处理，仅适用于简单场景）
String selectString = id > 0 ? parseSelection(selection) : selection;
for (String args : selectionArgs) {
selectString = selectString.replaceFirst("\\?", args);
}
sql.append(selectString);
}
}
mHelper.getWritableDatabase().execSQL(sql.toString());
mHelper.getWritableDatabase().execSQL(sql.toString()); // 执行SQL语句
}
// 获取数据类型（未实现，可根据需求返回MIME类型）
@Override
public String getType(Uri uri) {
// TODO Auto-generated method stub
// TODO: 根据URI返回对应的MIME类型（如vnd.android.cursor.dir/note）
return null;
}
}

62
MiNotes-master/app/src/main/java/net/micode/notes/gtask/data/MetaData.java
Unescape View File

@ -25,58 +25,98 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* 元数据任务类（继承自Task类，用于处理Google任务相关的元数据）
* 负责存储和解析与Google任务（GTask）相关的元信息，如关联的GID等
*/
public class MetaData extends Task {
private final static String TAG = MetaData.class.getSimpleName();
private final static String TAG = MetaData.class.getSimpleName(); // 日志标签（类名）
// 关联的Google任务GID（全局唯一标识符）
private String mRelatedGid = null;
/**
* 设置元数据信息
* @param gid 关联的Google任务GID
* @param metaInfo 元数据JSON对象（用于存储额外信息）
*/
public void setMeta(String gid, JSONObject metaInfo) {
try {
// 在元数据中添加GTASK_ID字段，值为传入的gid
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
} catch (JSONException e) {
Log.e(TAG, "failed to put related gid");
Log.e(TAG, "向元数据中添加关联GID失败");
}
// 将元数据JSON转为字符串存储到笔记内容中
setNotes(metaInfo.toString());
// 设置任务名称为固定值（元数据任务的标识）
setName(GTaskStringUtils.META_NOTE_NAME);
}
/**
* 获取关联的Google任务GID
* @return 关联的GID，若不存在则返回null
*/
public String getRelatedGid() {
return mRelatedGid;
}
/**
* 判断元数据是否值得保存（当前逻辑：只要笔记内容不为null则保存）
* @return true-值得保存，false-无需保存
*/
@Override
public boolean isWorthSaving() {
return getNotes() != null;
return getNotes() != null; // 只要存在元数据内容即保存
}
/**
* 从远程JSON数据中解析并设置元数据内容
* @param js 远程获取的JSON数据（包含元数据信息）
*/
@Override
public void setContentByRemoteJSON(JSONObject js) {
super.setContentByRemoteJSON(js);
super.setContentByRemoteJSON(js); // 调用父类方法处理公共字段
if (getNotes() != null) {
try {
// 解析存储的元数据JSON字符串
JSONObject metaInfo = new JSONObject(getNotes().trim());
// 提取关联的GID
mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
} catch (JSONException e) {
Log.w(TAG, "failed to get related gid");
mRelatedGid = null;
Log.w(TAG, "从元数据中获取关联GID失败");
mRelatedGid = null; // 解析失败时清空GID
}
}
}
/**
* 本地JSON内容设置方法（禁止调用，元数据不支持本地生成）
* @throws IllegalAccessError 始终抛出异常，提示方法不可用
*/
@Override
public void setContentByLocalJSON(JSONObject js) {
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
throw new IllegalAccessError("MetaData:setContentByLocalJSON 方法不应该被调用");
}
/**
* 从内容中获取本地JSON数据方法（禁止调用，元数据不支持本地生成）
* @return 始终抛出异常，提示方法不可用
* @throws IllegalAccessError 始终抛出异常
*/
@Override
public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
throw new IllegalAccessError("MetaData:getLocalJSONFromContent 方法不应该被调用");
}
/**
* 获取同步动作方法（禁止调用，元数据不参与同步动作逻辑）
* @param c 数据库游标（未使用）
* @return 始终抛出异常，提示方法不可用
* @throws IllegalAccessError 始终抛出异常
*/
@Override
public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called");
throw new IllegalAccessError("MetaData:getSyncAction 方法不应该被调用");
}
}

56
MiNotes-master/app/src/main/java/net/micode/notes/gtask/data/Node.java
Unescape View File

@ -20,33 +20,29 @@ import android.database.Cursor;
import org.json.JSONObject;
/**
* 同步节点抽象类（所有同步实体的基类）
* 定义同步操作类型常量及公共属性和抽象方法
*/
public abstract class Node {
public static final int SYNC_ACTION_NONE = 0;
public static final int SYNC_ACTION_ADD_REMOTE = 1;
public static final int SYNC_ACTION_ADD_LOCAL = 2;
public static final int SYNC_ACTION_DEL_REMOTE = 3;
public static final int SYNC_ACTION_DEL_LOCAL = 4;
public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
public static final int SYNC_ACTION_ERROR = 8;
private String mGid;
private String mName;
private long mLastModified;
private boolean mDeleted;
// 同步操作类型常量（用于标识不同的同步动作）
public static final int SYNC_ACTION_NONE = 0; // 无操作
public static final int SYNC_ACTION_ADD_REMOTE = 1; // 远程添加
public static final int SYNC_ACTION_ADD_LOCAL = 2; // 本地添加
public static final int SYNC_ACTION_DEL_REMOTE = 3; // 远程删除
public static final int SYNC_ACTION_DEL_LOCAL = 4; // 本地删除
public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 远程更新
public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 本地更新
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突
public static final int SYNC_ACTION_ERROR = 8; // 错误状态
// 公共属性（所有子类共享的同步相关信息）
private String mGid; // Google任务全局唯一标识符（GID）
private String mName; // 节点名称（如任务标题）
private long mLastModified; // 最后修改时间戳
private boolean mDeleted; // 是否已删除标记
// 构造方法：初始化默认值
public Node() {
mGid = null;
mName = "";
@ -54,18 +50,25 @@ public abstract class Node {
mDeleted = false;
}
// 抽象方法：获取创建操作的JSON（由子类实现具体逻辑）
public abstract JSONObject getCreateAction(int actionId);
// 抽象方法：获取更新操作的JSON（由子类实现具体逻辑）
public abstract JSONObject getUpdateAction(int actionId);
// 抽象方法：从远程JSON设置内容（由子类实现解析逻辑）
public abstract void setContentByRemoteJSON(JSONObject js);
// 抽象方法：从本地JSON设置内容（由子类实现序列化逻辑）
public abstract void setContentByLocalJSON(JSONObject js);
// 抽象方法：从内容获取本地JSON（由子类实现反序列化逻辑）
public abstract JSONObject getLocalJSONFromContent();
// 抽象方法：获取同步动作类型（由子类根据数据库游标判断）
public abstract int getSyncAction(Cursor c);
// ==================== 公共属性的访问器和修改器 ====================
public void setGid(String gid) {
this.mGid = gid;
}
@ -97,5 +100,4 @@ public abstract class Node {
public boolean getDeleted() {
return this.mDeleted;
}
}

95
MiNotes-master/app/src/main/java/net/micode/notes/gtask/data/SqlData.java
Unescape View File

@ -34,43 +34,42 @@ import net.micode.notes.gtask.exception.ActionFailureException;
import org.json.JSONException;
import org.json.JSONObject;
/**
* 数据库数据操作类
* 用于处理笔记数据项的增删改查操作，支持JSON格式转换
*/
public class SqlData {
private static final String TAG = SqlData.class.getSimpleName();
// 无效ID标识
private static final int INVALID_ID = -99999;
// 查询数据项的投影字段
public static final String[] PROJECTION_DATA = new String[] {
DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
DataColumns.DATA3
};
// 各字段在投影中的索引位置
public static final int DATA_ID_COLUMN = 0;
public static final int DATA_MIME_TYPE_COLUMN = 1;
public static final int DATA_CONTENT_COLUMN = 2;
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
private ContentResolver mContentResolver;
private boolean mIsCreate;
private long mDataId;
private String mDataMimeType;
private String mDataContent;
private long mDataContentData1;
private String mDataContentData3;
private ContentValues mDiffDataValues;
private ContentResolver mContentResolver; // 内容解析器
private boolean mIsCreate; // 是否为新建数据
private long mDataId; // 数据ID
private String mDataMimeType; // MIME类型
private String mDataContent; // 内容
private long mDataContentData1; // 附加数据1
private String mDataContentData3; // 附加数据3
private ContentValues mDiffDataValues; // 差异值，用于更新操作
/**
* 构造函数（创建新数据项）
* @param context 上下文
*/
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
@ -82,6 +81,11 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 构造函数（从游标加载现有数据项）
* @param context 上下文
* @param c 游标
*/
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
@ -89,6 +93,10 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 从游标加载数据
* @param c 游标
*/
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@ -97,7 +105,13 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
/**
* 从JSON设置内容
* @param js JSON对象
* @throws JSONException JSON解析异常
*/
public void setContent(JSONObject js) throws JSONException {
// 从JSON中获取各字段值，并与当前值比较，记录差异
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
@ -130,9 +144,14 @@ public class SqlData {
mDataContentData3 = dataContentData3;
}
/**
* 获取内容的JSON表示
* @return JSON对象
* @throws JSONException JSON生成异常
*/
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
Log.e(TAG, "数据尚未在数据库中创建");
return null;
}
JSONObject js = new JSONObject();
@ -144,28 +163,38 @@ public class SqlData {
return js;
}
/**
* 提交数据到数据库
* @param noteId 所属笔记ID
* @param validateVersion 是否验证版本
* @param version 版本号
*/
public void commit(long noteId, boolean validateVersion, long version) {
if (mIsCreate) {
// 新建数据项
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
mDiffDataValues.remove(DataColumns.ID); // 移除无效ID
}
mDiffDataValues.put(DataColumns.NOTE_ID, noteId); // 设置所属笔记ID
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
// 插入数据
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try {
mDataId = Long.valueOf(uri.getPathSegments().get(1));
mDataId = Long.valueOf(uri.getPathSegments().get(1)); // 获取插入后的ID
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
Log.e(TAG, "获取数据ID失败: " + e.toString());
throw new ActionFailureException("创建笔记失败");
}
} else {
// 更新现有数据项
if (mDiffDataValues.size() > 0) {
int result = 0;
if (!validateVersion) {
// 不验证版本，直接更新
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else {
// 验证版本，确保在版本匹配时才更新
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
@ -174,15 +203,19 @@ public class SqlData {
});
}
if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing");
Log.w(TAG, "更新失败，可能在同步时有其他更新操作");
}
}
}
mDiffDataValues.clear();
mIsCreate = false;
mDiffDataValues.clear(); // 清空差异值
mIsCreate = false; // 标记为已创建
}
/**
* 获取数据ID
* @return 数据ID
*/
public long getId() {
return mDataId;
}

Write Preview
Loading…
Cancel
Save