From a6ca5a1f7b296211063bdeb76f15fdac1513cf9f Mon Sep 17 00:00:00 2001 From: hui <3635271576@qq.com> Date: Fri, 21 Apr 2023 13:12:25 +0800 Subject: [PATCH] src --- .../java/net/micode/notes/data/Contact.java | 33 ++- .../java/net/micode/notes/data/Notes.java | 1 + .../notes/data/NotesDatabaseHelper.java | 106 +++++--- .../net/micode/notes/data/NotesProvider.java | 89 ++++++- .../net/micode/notes/gtask/data/MetaData.java | 37 ++- .../net/micode/notes/gtask/data/Node.java | 55 +++- .../net/micode/notes/gtask/data/SqlData.java | 80 ++++-- .../net/micode/notes/gtask/data/SqlNote.java | 239 ++++++++++++------ .../net/micode/notes/gtask/data/Task.java | 156 +++++++----- .../net/micode/notes/gtask/data/TaskList.java | 129 +++++++--- 10 files changed, 668 insertions(+), 257 deletions(-) diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/data/Contact.java b/src/Notes-master/app/src/main/java/net/micode/notes/data/Contact.java index 7fa3a7c..993cf41 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/data/Contact.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/data/Contact.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// 联系人数据库类，用于识别和查询联系人电话号码、ID、姓名 package net.micode.notes.data; @@ -26,10 +27,14 @@ import android.util.Log; import java.util.HashMap; public class Contact { // 联系人 - private static HashMap sContactCache; - private static final String TAG = "Contact"; + // 声明一个用于缓存联系人的HashMap + private static HashMap sContactCache; // 定义联系人缓存散列表 - // 定义字符串CALLER_ID_SELECTION + // 声明日志输出的TAG + private static final String TAG = "Contact"; // 标签 + + // 定义字符串CALLER_ID_SELECTION，即联系人信息查询 + // 定义查询联系人的选择条件，使用占位符 "?" 和 "IN" 子句 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 " @@ -37,20 +42,27 @@ public class Contact { // 联系人 + " FROM phone_lookup" + " WHERE min_match = '+')"; - // 获取联系人 + // 获取联系人名称,电话号码 + // context 上下文环境 + // phoneNumber 联系人的电话号码 + // return 联系人的名称，如果找不到返回null public static String getContact(Context context, String phoneNumber) { + // 如果联系人缓存为空，则创建一个新的HashMap if(sContactCache == null) { sContactCache = new HashMap(); } - // 查找HashMap中是否已有phoneNumber信息 + // 查找HashMap中是否已有phoneNumber（电话号码）信息 + // 如果联系人缓存中已经存在该电话号码的联系人，则直接返回联系人名称 if(sContactCache.containsKey(phoneNumber)) { return sContactCache.get(phoneNumber); } - + // 使用PhoneNumberUtils工具类将电话号码转换为拨号最小匹配 String selection = CALLER_ID_SELECTION.replace("+", PhoneNumberUtils.toCallerIDMinMatch(phoneNumber)); - // 查找数据库中phoneNumber的信息 + + // 定义游标，查找数据库中phoneNumber的信息 + // 查询联系人 Cursor cursor = context.getContentResolver().query( Data.CONTENT_URI, new String [] { Phone.DISPLAY_NAME }, @@ -60,9 +72,10 @@ public class Contact { // 联系人 // 判定查询结果 // moveToFirst()返回第一条 + // 如果查询到联系人，则将联系人名称存入缓存并返回联系人名称 if (cursor != null && cursor.moveToFirst()) { try { - // 找到相关信息 + // 找到相关信息，返回联系人姓名 String name = cursor.getString(0); sContactCache.put(phoneNumber, name); return name; @@ -71,9 +84,9 @@ public class Contact { // 联系人 Log.e(TAG, " Cursor get string error " + e.toString()); return null; } finally { - cursor.close(); + cursor.close(); // 关闭游标 } - // 未找到相关信息 + // 未找到联系人相关信息，则打印日志并返回null } else { Log.d(TAG, "No contact matched with number:" + phoneNumber); return null; diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/data/Notes.java b/src/Notes-master/app/src/main/java/net/micode/notes/data/Notes.java index 1580ef0..b94d677 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/data/Notes.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/data/Notes.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// 便签数据库类，用于记录和查询便签的属性、内容数据，内容的数据结构 package net.micode.notes.data; diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java b/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java index 0293276..b12375d 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesDatabaseHelper.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// 便签数据库帮助类，用于对文件夹中note和data进行数据库的操作（增删查改、还原等），以及数据库版本的更新 package net.micode.notes.data; @@ -27,21 +28,28 @@ import net.micode.notes.data.Notes.DataConstants; import net.micode.notes.data.Notes.NoteColumns; //数据库操作，用SQLOpenhelper,对一些note和文件进行数据库的操作，比如删除文件后，将文件里的note也相应删除 +// 数据库帮助类 public class NotesDatabaseHelper extends SQLiteOpenHelper { + // 数据库名 private static final String DB_NAME = "note.db"; + // 数据库版本号 private static final int DB_VERSION = 4; + // 数据表名称常量 public interface TABLE { // 接口，分成note和data两个 public static final String NOTE = "note"; public static final String DATA = "data"; } + // 日志tag 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," + @@ -63,6 +71,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" + ")"; // 数据库中需要存储的note接口项目的名称，相当于创建一个表格的表头的内容 + // 创建笔记内容数据表的SQL语句 private static final String CREATE_DATA_TABLE_SQL = "CREATE TABLE " + TABLE.DATA + "(" + DataColumns.ID + " INTEGER PRIMARY KEY," + @@ -78,14 +87,18 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" + ")"; // 数据库中需要存储的data接口项目的名称，相当于创建一个表格的表头的内容 + // 创建笔记在SQL中的Id private static final String CREATE_DATA_NOTE_ID_INDEX_SQL = - "CREATE INDEX IF NOT EXISTS note_id_index ON " + + //创建一个数据表的索引，用于加速查询和过滤操作。 + "CREATE INDEX IF NOT EXISTS note_id_index ON " + TABLE.DATA + "(" + DataColumns.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 + " BEGIN " + @@ -97,8 +110,10 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * 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 " + + // 当笔记从一个文件夹中移出时，该触发器会自动更新该文件夹中的笔记计数。 + "CREATE TRIGGER decrease_folder_count_on_update " + " AFTER UPDATE OF " + NoteColumns.PARENT_ID + " ON " + TABLE.NOTE + " BEGIN " + " UPDATE " + TABLE.NOTE + @@ -110,8 +125,10 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * 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 " + + // 当笔记被移动到一个文件夹时，该触发器会自动更新该文件夹中的笔记计数。 + "CREATE TRIGGER increase_folder_count_on_insert " + " AFTER INSERT ON " + TABLE.NOTE + " BEGIN " + " UPDATE " + TABLE.NOTE + @@ -122,6 +139,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * 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 + @@ -135,6 +153,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * Update note's content when insert data with type {@link DataConstants#NOTE} */ + // 在插入类型为 {@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 + @@ -148,6 +167,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * Update note's content when data with {@link DataConstants#NOTE} type has changed */ + // 在类型为 {@link DataConstants#NOTE} 的数据更新时更新笔记的内容 private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER = "CREATE TRIGGER update_note_content_on_update " + " AFTER UPDATE ON " + TABLE.DATA + @@ -161,6 +181,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * Update note's content when data with {@link DataConstants#NOTE} type has deleted */ + // 在类型为 {@link DataConstants#NOTE} 的数据删除时更新笔记的内容 private static final String DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER = "CREATE TRIGGER update_note_content_on_delete " + " AFTER delete ON " + TABLE.DATA + @@ -174,6 +195,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * 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 + @@ -185,6 +207,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * 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 + @@ -196,6 +219,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * 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,11 +230,13 @@ 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); @@ -218,31 +244,50 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { Log.d(TAG, "note table has been created"); } // 创建表格（用来存储标签属性） + // 重新创建笔记表的触发器 + // db 数据库对象 private void reCreateNoteTableTriggers(SQLiteDatabase db) { db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update"); + // 删除更新时增加文件夹计数的触发器 db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update"); + // 删除更新时减少文件夹计数的触发器 db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete"); + // 删除删除时减少文件夹计数的触发器 db.execSQL("DROP TRIGGER IF EXISTS delete_data_on_delete"); + // 删除删除时删除数据的触发器 db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_insert"); + // 删除插入时增加文件夹计数的触发器 db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete"); + // 删除文件夹删除时删除笔记的触发器 db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash"); + // 删除将笔记移动到垃圾桶时的触发器 db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER); + // 创建更新时增加文件夹计数的触发器 db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER); + // 创建更新时减少文件夹计数的触发器 db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER); + // 创建删除时减少文件夹计数的触发器 db.execSQL(NOTE_DELETE_DATA_ON_DELETE_TRIGGER); + // 创建删除时删除数据的触发器 db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER); + // 创建插入时增加文件夹计数的触发器 db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER); + // 创建文件夹删除时删除笔记的触发器 db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER); + // 创建将笔记移动到垃圾桶时的触发器 }// execSQL是数据库操作的API，主要是更改行为的SQL语句 // 在这里用来重新创建上述定义的表格，先删除原来有的数据库的触发器再重新创建新的数据库 + // 创建系统文件夹 + // db 数据库对象 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); @@ -250,6 +295,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * root folder which is default folder */ + // 根文件夹，即默认文件夹 values.clear(); values.put(NoteColumns.ID, Notes.ID_ROOT_FOLDER); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); @@ -258,6 +304,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.TYPE, Notes.TYPE_SYSTEM); @@ -266,6 +313,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { /** * create trash folder */ + // 创建垃圾桶文件夹 values.clear(); values.put(NoteColumns.ID, Notes.ID_TRASH_FOLER); values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); @@ -273,68 +321,68 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper { } // 创建系统文件夹 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); // 在数据表上创建笔记 ID 索引 + 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("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); + 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); // 创建删除时更新笔记内容的触发器 }// execSQL是数据库操作的API，主要是更改行为的SQL语句 // 在这里用来重新创建上述定义的表格，先删除原来有的数据库的触发器再重新创建新的数据库 static synchronized NotesDatabaseHelper getInstance(Context context) { if (mInstance == null) { - mInstance = new NotesDatabaseHelper(context); + mInstance = new NotesDatabaseHelper(context); // 如果实例为空，创建新的实例 } - return mInstance; + 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; // 是否跳过版本 2 if (oldVersion == 1) { - upgradeToV2(db); + upgradeToV2(db); // 升级到版本 2 skipV2 = true; // this upgrade including the upgrade from v2 to v3 - oldVersion++; + oldVersion++; // 版本号加 1 } if (oldVersion == 2 && !skipV2) { - upgradeToV3(db); - reCreateTriggers = true; - oldVersion++; + upgradeToV3(db); // 升级到版本 3 + reCreateTriggers = true; // 标记需要重新创建触发器 + oldVersion++; // 版本号加 1 } if (oldVersion == 3) { - upgradeToV4(db); - oldVersion++; + upgradeToV4(db); // 升级到版本 4 + oldVersion++; // 版本号加 1 } if (reCreateTriggers) { - reCreateNoteTableTriggers(db); - reCreateDataTableTriggers(db); + reCreateNoteTableTriggers(db); // 重新创建笔记表触发器 + reCreateDataTableTriggers(db); // 重新创建数据表触发器 } if (oldVersion != newVersion) { throw new IllegalStateException("Upgrade notes database to version " + newVersion - + "fails"); + + "fails"); // 如果版本升级失败，抛出异常 } }// 数据库版本的更新（数据库内容的更改） diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesProvider.java b/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesProvider.java index 54a0e14..a54bb03 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesProvider.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/data/NotesProvider.java @@ -41,14 +41,18 @@ import net.micode.notes.data.NotesDatabaseHelper.TABLE; // delete：删除 // getType：得到数据类型 +// 便签提供类，用于为存储和获取数据提供接口。以便于在不同的应用程序之间共享数据 + public class NotesProvider extends ContentProvider { // UriMatcher用于匹配Uri + // 声明一个 UriMatcher 对象，用于匹配 Uri 和对应的代码 private static final UriMatcher mMatcher; private NotesDatabaseHelper mHelper; private static final String TAG = "NotesProvider"; + // 声明一些常量，用于标识 Uri 匹配的类型 private static final int URI_NOTE = 1; private static final int URI_NOTE_ITEM = 2; private static final int URI_DATA = 3; @@ -57,6 +61,7 @@ public class NotesProvider extends ContentProvider { private static final int URI_SEARCH = 5; private static final int URI_SEARCH_SUGGEST = 6; + // 初始化 UriMatcher 对象，将 Uri 和对应的类型添加到 UriMatcher 中 static { // 创建UriMatcher时，调用UriMatcher(UriMatcher.NO_MATCH)表示不匹配任何路径的返回码 mMatcher = new UriMatcher(UriMatcher.NO_MATCH); @@ -75,6 +80,7 @@ public class NotesProvider extends ContentProvider { * we will trim '\n' and white space in order to show more information. */ // 声明 NOTES_SEARCH_PROJECTION + // x'0A' 代表 sqlite 中的 '\n' 字符。对于搜索结果中的标题和内容，我们会去掉 '\n' 和空格，以展示更多信息。 private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + "," + NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + "," + "TRIM(REPLACE(" + NoteColumns.SNIPPET + ", x'0A','')) AS " + SearchManager.SUGGEST_COLUMN_TEXT_1 + "," @@ -83,6 +89,7 @@ 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_SNIPPET_SEARCH_QUERY + // 定义搜索笔记的 SQL 查询语句，其中包括笔记的搜索投影和搜索条件。 private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION + " FROM " + TABLE.NOTE + " WHERE " + NoteColumns.SNIPPET + " LIKE ?" @@ -91,6 +98,7 @@ public class NotesProvider extends ContentProvider { @Override // Context只有在onCreate()中才被初始化 + // 获取数据库帮助类的实例 // 对mHelper进行实例化 public boolean onCreate() { mHelper = NotesDatabaseHelper.getInstance(getContext()); @@ -101,39 +109,51 @@ public class NotesProvider extends ContentProvider { // 查询uri在数据库中对应的位置 public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) { + // 初始化游标和数据库 Cursor c = null; // 获取可读数据库 SQLiteDatabase db = mHelper.getReadableDatabase(); + // 初始化 id String id = null; - // 匹配查找uri + // 匹配查找uri，根据 Uri 的不同，执行不同的查询操作 switch (mMatcher.match(uri)) { - // 对于不同的匹配值，在数据库中查找相应的条目 + // 对于不同的匹配值，在数据库中查找相应的条目，查询所有笔记 case URI_NOTE: c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null, sortOrder); break; + // 根据 id 查询笔记 case URI_NOTE_ITEM: + // 获取 Uri 中的 id id = uri.getPathSegments().get(1); + // 根据 id 查询笔记 c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs, null, null, sortOrder); break; + // 查询所有数据 case URI_DATA: c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null, sortOrder); break; + // 根据 id 查询数据 case URI_DATA_ITEM: + // 获取 Uri 中的 id id = uri.getPathSegments().get(1); + // 根据 id 查询数据 c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs, null, null, sortOrder); break; + // 查询笔记的搜索结果 case URI_SEARCH: case URI_SEARCH_SUGGEST: + // 如果查询中包含排序或者 projection，则抛出异常 if (sortOrder != null || projection != null) { // 不合法的参数异常 throw new IllegalArgumentException( "do not specify sortOrder, selection, selectionArgs, or projection" + "with this query"); } + // 获取查询的关键词 String searchString = null; if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) { if (uri.getPathSegments().size() > 1) { @@ -145,22 +165,27 @@ public class NotesProvider extends ContentProvider { searchString = uri.getQueryParameter("pattern"); } + // 如果关键词为空，则返回空游标 if (TextUtils.isEmpty(searchString)) { return null; } try { + // 格式化查询字符串 searchString = String.format("%%%s%%", searchString); + // 执行笔记搜索查询 c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY, new String[] { searchString }); } catch (IllegalStateException ex) { Log.e(TAG, "got exception: " + ex.toString()); } break; + // 如果 Uri 不匹配，则抛出异常 default: // 抛出异常 throw new IllegalArgumentException("Unknown URI " + uri); } + // 如果游标不为空，则设置游标的内容变化通知 Uri if (c != null) { c.setNotificationUri(getContext().getContentResolver(), uri); } @@ -171,39 +196,52 @@ public class NotesProvider extends ContentProvider { // 插入一个uri public Uri insert(Uri uri, ContentValues values) { // 获得可写的数据库 + // 获取可写的 SQLiteDatabase 实例 SQLiteDatabase db = mHelper.getWritableDatabase(); + // 定义变量用于存储插入后的数据行 ID long dataId = 0, noteId = 0, insertedId = 0; + // 根据传入的 Uri 进行不同的插入操作 switch (mMatcher.match(uri)) { // 新增一个条目 case URI_NOTE: + // 如果是插入 Note 数据表 insertedId = noteId = db.insert(TABLE.NOTE, null, values); break; // 如果存在，查找NOTE_ID case URI_DATA: + // 如果是插入 Data 数据表 if (values.containsKey(DataColumns.NOTE_ID)) { + // 获取 Note ID noteId = values.getAsLong(DataColumns.NOTE_ID); } else { + // 如果 ContentValues 中没有 Note ID，记录日志并退出方法 Log.d(TAG, "Wrong data format without note id:" + values.toString()); } + // 插入数据行 insertedId = dataId = db.insert(TABLE.DATA, null, values); break; default: + // 如果传入的 Uri 不合法，抛出 IllegalArgumentException 异常 throw new IllegalArgumentException("Unknown URI " + uri); } // Notify the note uri // notifyChange获得一个ContextResolver对象并且更新里面的内容 + // 如果插入操作成功，通知相关 Uri 的观察者 + // 通知 Note Uri if (noteId > 0) { getContext().getContentResolver().notifyChange( ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null); } // Notify the data uri + // 通知 Data Uri if (dataId > 0) { getContext().getContentResolver().notifyChange( ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null); } // 返回插入的uri的路径 + // 返回新插入数据的 Uri return ContentUris.withAppendedId(uri, insertedId); } @@ -211,48 +249,65 @@ public class NotesProvider extends ContentProvider { // 删除一个uri public int delete(Uri uri, String selection, String[] selectionArgs) { // Uri代表要操作的数据，Android上可用的每种资源 -包括 图像、视频片段、音频资源等都可以用Uri来表示 + // 初始化变量 int count = 0; String id = null; // 获得可写的数据库 SQLiteDatabase db = mHelper.getWritableDatabase(); boolean deleteData = false; + // 使用 switch-case 语句匹配传入的 Uri switch (mMatcher.match(uri)) { + // 如果是 URI_NOTE，表示删除笔记 case URI_NOTE: + // 将选定条件和 "ID>0" 结合起来 selection = "(" + selection + ") AND " + NoteColumns.ID + ">0 "; + // 执行删除操作，并返回受影响的行数 count = db.delete(TABLE.NOTE, selection, selectionArgs); break; + // 如果是 URI_NOTE_ITEM，表示删除单个笔记 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 - */ + // 如果笔记 ID 小于等于 0，则不允许删除 long noteId = Long.valueOf(id); if (noteId <= 0) { break; } + // 执行删除操作，并返回受影响的行数 count = db.delete(TABLE.NOTE, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); break; + // 如果是 URI_DATA，表示删除数据 case URI_DATA: + // 执行删除操作，并返回受影响的行数 count = db.delete(TABLE.DATA, selection, selectionArgs); deleteData = true; break; + // 如果是 URI_DATA_ITEM，表示删除单个数据 case URI_DATA_ITEM: + // 从 Uri 中获取数据的 ID id = uri.getPathSegments().get(1); + // 执行删除操作，并返回受影响的行数 count = db.delete(TABLE.DATA, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); deleteData = true; break; + // 如果匹配失败，则抛出异常 default: throw new IllegalArgumentException("Unknown URI " + uri); } + + // 如果受影响的行数大于 0 if (count > 0) { + // 如果删除了数据，则通知数据发生了变化 if (deleteData) { getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); } + // 通知 Uri 发生了变化 getContext().getContentResolver().notifyChange(uri, null); } + + // 返回受影响的行数 return count; } @@ -263,35 +318,48 @@ public class NotesProvider extends ContentProvider { String id = null; SQLiteDatabase db = mHelper.getWritableDatabase(); boolean updateData = false; + // 根据 Uri 进行分支处理 switch (mMatcher.match(uri)) { case URI_NOTE: + // 更新笔记版本号 increaseNoteVersion(-1, selection, selectionArgs); + // 更新笔记数据 count = db.update(TABLE.NOTE, values, selection, selectionArgs); break; case URI_NOTE_ITEM: + // 获取 Uri 中的 id id = uri.getPathSegments().get(1); + // 更新笔记版本号 increaseNoteVersion(Long.valueOf(id), selection, selectionArgs); + // 根据 id 更新笔记数据 count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs); break; case URI_DATA: + // 更新数据表 count = db.update(TABLE.DATA, values, selection, selectionArgs); updateData = true; break; case URI_DATA_ITEM: + // 获取 Uri 中的 id id = uri.getPathSegments().get(1); + // 根据 id 更新数据表 count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs); updateData = true; break; default: + // 如果不匹配任何 Uri，抛出异常 throw new IllegalArgumentException("Unknown URI " + uri); } + // 如果更新成功，发出通知 if (count > 0) { if (updateData) { + // 更新数据表时，通知笔记 Uri getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null); } + // 通知当前 Uri getContext().getContentResolver().notifyChange(uri, null); } return count; @@ -299,11 +367,13 @@ public class NotesProvider extends ContentProvider { // 将字符串解析成规定格式 private String parseSelection(String selection) { + // 如果查询条件不为空，返回 AND (查询条件) return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : ""); } // 增加一个noteVersion private void increaseNoteVersion(long id, String selection, String[] selectionArgs) { + // 构建 SQL 语句 StringBuilder sql = new StringBuilder(120); sql.append("UPDATE "); sql.append(TABLE.NOTE); @@ -311,13 +381,17 @@ public class NotesProvider extends ContentProvider { sql.append(NoteColumns.VERSION); sql.append("=" + NoteColumns.VERSION + "+1 "); + // 如果传入的 ID 或者查询条件不为空，则在 SQL 语句中添加 WHERE 子句 if (id > 0 || !TextUtils.isEmpty(selection)) { sql.append(" WHERE "); } + // 如果传入的 ID 不为空，添加 ID 条件 if (id > 0) { sql.append(NoteColumns.ID + "=" + String.valueOf(id)); } + // 如果查询条件不为空，添加查询条件 if (!TextUtils.isEmpty(selection)) { + // 解析查询条件中的参数 String selectString = id > 0 ? parseSelection(selection) : selection; for (String args : selectionArgs) { selectString = selectString.replaceFirst("\\?", args); @@ -325,6 +399,7 @@ public class NotesProvider extends ContentProvider { sql.append(selectString); } + // 执行 SQL 语句，增加笔记版本号 // execSQL()方法可以执行insert、delete、update和CREATE TABLE之类有更改行为的SQL语句 mHelper.getWritableDatabase().execSQL(sql.toString()); } @@ -332,7 +407,7 @@ public class NotesProvider extends ContentProvider { @Override public String getType(Uri uri) { // TODO Auto-generated method stub - return null; + return null; // 返回 null } } diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/MetaData.java b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/MetaData.java index 3a2050b..ab28a5e 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/MetaData.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/MetaData.java @@ -13,7 +13,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - +// 元数据类，用于生成元数据库，设置元数据内容和同步操作，从元数据中获取信息 +// MetaData类是Task类的子类，表示GTask的元数据。 package net.micode.notes.gtask.data; import android.database.Cursor; @@ -26,57 +27,89 @@ import org.json.JSONObject; public class MetaData extends Task { + // 功能描述：得到类的简写名称存入字符串TAG中 + // 实现过程：调用getSimpleName ()函数 private final static String TAG = MetaData.class.getSimpleName(); - + // 关联的gid private String mRelatedGid = null; + // 功能描述：设置数据，即生成元数据库，设置元数据的gid和相关信息 + // 实现过程：调用JSONObject库函数put ()，Task类中的setNotes ()和setName ()函数 + // 参数注解：gid 元数据的gid metaInfo 元数据的相关信息 public void setMeta(String gid, JSONObject metaInfo) { + // 对函数块进行注释 try { metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid); + // 将关联的gid放入metaInfo这个jsonobject对象中 } catch (JSONException e) { Log.e(TAG, "failed to put related gid"); + // 输出错误信息 } + // 将元数据的相关信息转换为字符串，设置为Task的notes setNotes(metaInfo.toString()); + // 设置Task的名称为元数据的名称 setName(GTaskStringUtils.META_NOTE_NAME); } + // 功能描述：获取相关联的Gid public String getRelatedGid() { return mRelatedGid; } + // 功能描述：判断元数据是否有值，判断当前数据是否为空，若为空则返回真即值得保存 + // return 如果有备注信息则返回true，否则返回false。 @Override public boolean isWorthSaving() { return getNotes() != null; } + // 功能描述：使用远程json数据对象设置元数据内容 + // 实现过程：调用父类Task中的setContentByRemoteJSON ()函数，并 + // 参数注解：js 远程JSON对象。 @Override public void setContentByRemoteJSON(JSONObject js) { super.setContentByRemoteJSON(js); if (getNotes() != null) { try { + // 解析备注信息 JSONObject metaInfo = new JSONObject(getNotes().trim()); mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID); } catch (JSONException e) { Log.w(TAG, "failed to get related gid"); + // 输出警告信息 mRelatedGid = null; } } } + // 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常，本地JSON对象不应该调用该方法。 + // js 本地JSON对象。 @Override public void setContentByLocalJSON(JSONObject js) { + // 不应该被调用的方法 // this function should not be called throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called"); + // 传递非法参数异常 } + // 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常，不应该被调用的方法。 + // return 不应该被调用的方法。 @Override public JSONObject getLocalJSONFromContent() { throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); + // 传递非法参数异常 } + // 该方法接受一个 Cursor 参数，返回一个整型值， + // 方法体中抛出了一个 IllegalAccessError 异常， + // 并指定了异常消息为 "MetaData:getSyncAction should not be called"， + // 即 "MetaData:getSyncAction 不应该被调用"。 + + // 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常 @Override public int getSyncAction(Cursor c) { throw new IllegalAccessError("MetaData:getSyncAction should not be called"); + // 传递非法参数异常 } } diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Node.java b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Node.java index 63950e0..22d6bb1 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Node.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Node.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// 数据抽象类，定义了指示同步操作的常量，用于执行同步操作的基础数据类型，设置和存储同步操作的相关信息 package net.micode.notes.gtask.data; @@ -20,32 +21,45 @@ import android.database.Cursor; import org.json.JSONObject; +// 应该是同步操作的基础数据类型，定义了相关指示同步操作的常量 +// 关键字：abstract 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; - + // 表示节点的全局唯一标识符（global identifier） private String mName; - + // 表示节点的名称 private long mLastModified; - + // 表示节点最后一次修改时间 private boolean mDeleted; + // 表示节点是否已被删除 public Node() { mGid = null; @@ -54,48 +68,61 @@ 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); + // 设置节点 ID public void setGid(String gid) { this.mGid = gid; } + // 设置节点名称 public void setName(String name) { this.mName = name; } + // 设置最后修改时间 public void setLastModified(long lastModified) { this.mLastModified = lastModified; } + // 设置是否已删除 public void setDeleted(boolean deleted) { this.mDeleted = deleted; } + // 获取节点 ID public String getGid() { return this.mGid; } + // 获取节点名称 public String getName() { return this.mName; } + // 获取最后修改时间 public long getLastModified() { return this.mLastModified; } + // 获取是否已删除 public boolean getDeleted() { return this.mDeleted; } - -} +} \ No newline at end of file diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlData.java b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlData.java index d3ec3be..127201b 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlData.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlData.java @@ -13,6 +13,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// Description：用于支持小米便签最底层的数据库相关操作，和sqlnote的关系上是子集关系，即data是note的子集（节点）。 +// SqlData其实就是也就是所谓数据中的数据 +// 数据库中的数据类，用于执行最底层的数据库相关操作，包括初始化、获取、提交、加载、共享数据，获取当前ID package net.micode.notes.gtask.data; @@ -36,15 +39,24 @@ import org.json.JSONObject; public class SqlData { + // 功能描述：得到类的简写名称存入字符串TAG中 + // 实现过程：调用getSimpleName ()函数 private static final String TAG = SqlData.class.getSimpleName(); + // TAG常量，用于在日志中标记这个类 - private static final int INVALID_ID = -99999; + private static final int INVALID_ID = -99999; // 无效ID常量 + // 来自Notes类中定义的DataColumn中的一些常量 + + // 集合了interface DataColumns中所有SF常量 + // PROJECTION_DATA常量数组，用于查询数据表中的字段 public static final String[] PROJECTION_DATA = new String[] { DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1, DataColumns.DATA3 }; + // 以下五个变量作为sql表中5列的编号 + // 数据表字段的索引常量，用于读取查询结果集 public static final int DATA_ID_COLUMN = 0; public static final int DATA_MIME_TYPE_COLUMN = 1; @@ -56,25 +68,29 @@ public class SqlData { public static final int DATA_CONTENT_DATA_3_COLUMN = 4; private ContentResolver mContentResolver; + // ContentResolver对象，用于操作数据表 + // 判断是否直接用Content生成，是为true，否则为false + private boolean mIsCreate; // 是否创建了数据 - private boolean mIsCreate; - - private long mDataId; + private long mDataId; // 数据ID - private String mDataMimeType; + private String mDataMimeType; // 数据类型 - private String mDataContent; + private String mDataContent; // 数据内容 - private long mDataContentData1; + private long mDataContentData1; // 数据字段1 - private String mDataContentData3; + private String mDataContentData3; // 数据字段3 - private ContentValues mDiffDataValues; + private ContentValues mDiffDataValues; // ContentValues对象，用于更新数据表的内容 + // 功能描述：构造函数，用于初始化数据，初始化ContentResolver对象 + // 参数注解：mContentResolver用于获取ContentProvider提供的数据 + // 参数注解：mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同） public SqlData(Context context) { mContentResolver = context.getContentResolver(); mIsCreate = true; - mDataId = INVALID_ID; + mDataId = INVALID_ID; // mDataId置初始值-99999 mDataMimeType = DataConstants.NOTE; mDataContent = ""; mDataContentData1 = 0; @@ -82,6 +98,9 @@ public class SqlData { mDiffDataValues = new ContentValues(); } + // 功能描述：构造函数，初始化数据 + // 参数注解：mContentResolver用于获取ContentProvider提供的数据 + // 参数注解：mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同） public SqlData(Context context, Cursor c) { mContentResolver = context.getContentResolver(); mIsCreate = false; @@ -89,16 +108,23 @@ public class SqlData { mDiffDataValues = new ContentValues(); } + // 功能描述：从光标处加载数据，从Cursor对象中读取数据 + // 从当前的光标处将五列的数据加载到该类的对象 private void loadFromCursor(Cursor c) { - mDataId = c.getLong(DATA_ID_COLUMN); - mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); - mDataContent = c.getString(DATA_CONTENT_COLUMN); - mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); - mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); + mDataId = c.getLong(DATA_ID_COLUMN); // 读取数据ID + mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN); // 读取数据类型 + mDataContent = c.getString(DATA_CONTENT_COLUMN); // 读取数据内容 + mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); // 读取数据字段1 + mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); // 读取数据字段3 } + // 功能描述：设置用于共享的数据，并提供异常抛出与处理机制，设置数据内容 + // 参数注解： public void setContent(JSONObject js) throws JSONException { + // 如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID + // 从JSONObject对象中读取数据，若不存在则使用默认值 long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; + // 比较新数据和旧数据，如果不同则添加到ContentValues对象中 if (mIsCreate || mDataId != dataId) { mDiffDataValues.put(DataColumns.ID, dataId); } @@ -130,11 +156,15 @@ public class SqlData { mDataContentData3 = dataContentData3; } + // 功能描述：获取共享的数据内容，并提供异常抛出与处理机制 + // 参数注解： public JSONObject getContent() throws JSONException { + // 如果数据还没有在数据库中创建，则返回null，并打印错误日志 if (mIsCreate) { Log.e(TAG, "it seems that we haven't created this in database yet"); return null; } + // 创建JSONObject对象。并将相关数据放入其中，并返回。 JSONObject js = new JSONObject(); js.put(DataColumns.ID, mDataId); js.put(DataColumns.MIME_TYPE, mDataMimeType); @@ -144,46 +174,56 @@ public class SqlData { return js; } + // 功能描述：commit函数用于把当前造作所做的修改保存到数据库 + // 参数注解： public void commit(long noteId, boolean validateVersion, long version) { - + // 如果数据还没有在数据库中创建，则将其插入到数据库中 if (mIsCreate) { + // 如果数据id无效且存在于差异数据值中，则从差异数据值中删除该id if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { mDiffDataValues.remove(DataColumns.ID); } - + // 将数据与所属笔记的id关联起来，并将其插入到数据库中 mDiffDataValues.put(DataColumns.NOTE_ID, noteId); Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); try { + // 从uri中获取新插入数据的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 { + // 如果数据已存在于数据库中，则将其更新 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, + Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE + " WHERE " + NoteColumns.VERSION + "=?)", new String[] { String.valueOf(noteId), String.valueOf(version) }); } + // 如果更新的数据数量为0，则打印警告日志 if (result == 0) { Log.w(TAG, "there is no update. maybe user updates note when syncing"); } } } - + // 清空差异数据值，并将是否创建标志设为false mDiffDataValues.clear(); mIsCreate = false; } + // 功能描述：获取当前id + // 实现过程：返回数据索引 + // 参数注解： public long getId() { return mDataId; } -} +} \ No newline at end of file diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java index 79a4095..8c24dda 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/SqlNote.java @@ -13,6 +13,9 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// Description：用于支持小米便签最底层的数据库相关操作，和sqldata的关系上是父集关系，即note是data的子父集。 +// 和SqlData相比，SqlNote算是真正意义上的数据了。 +// 数据库中便签数据类，用于执行最底层的数据库相关操作，包括初始化数据，加载数据，获取共享数据，初始化修改，提交修改到数据库 package net.micode.notes.gtask.data; @@ -39,9 +42,12 @@ import java.util.ArrayList; public class SqlNote { + // 功能描述：得到类的简写名称存入字符串TAG中 + // 实现过程：调用getSimpleName ()函数 private static final String TAG = SqlNote.class.getSimpleName(); private static final int INVALID_ID = -99999; + // 集合了interface NoteColumns中所有SF常量（17个） public static final String[] PROJECTION_NOTE = new String[] { NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID, @@ -50,11 +56,15 @@ public class SqlNote { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE, NoteColumns.SYNC_ID, NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID, NoteColumns.VERSION + // 以下设置17个列的编号 }; + // 定义一个公共静态常量PROJECTION_NOTE，表示需要查询的列名数组 public static final int ID_COLUMN = 0; + // 定义一个公共静态常量ID_COLUMN，表示查询结果集合中id列的下标 public static final int ALERTED_DATE_COLUMN = 1; + // 定义一个公共静态常量ALERTED_DATE_COLUMN，表示查询结果集合中alerted_date列的下标 public static final int BG_COLOR_ID_COLUMN = 2; @@ -86,6 +96,7 @@ public class SqlNote { public static final int VERSION_COLUMN = 16; + // 一下定义了17个内部的变量，其中12个可以由content中获得，5个需要初始化为0或者new private Context mContext; private ContentResolver mContentResolver; @@ -119,65 +130,82 @@ public class SqlNote { private long mVersion; private ContentValues mDiffNoteValues; + // 定义一个私有成员变量mDiffNoteValues，表示当前对象的差异值 private ArrayList mDataList; + // 定义一个私有成员变量mDataList，表示当前对象的数据列表 + // 功能描述：构造函数 + // 参数注解： mIsCreate用于标示构造方式 + + // 构造函数只有context，对所有的变量进行初始化 public SqlNote(Context context) { - mContext = context; - mContentResolver = context.getContentResolver(); - mIsCreate = true; - mId = INVALID_ID; - mAlertDate = 0; - mBgColorId = ResourceParser.getDefaultBgId(context); - mCreatedDate = System.currentTimeMillis(); - mHasAttachment = 0; - mModifiedDate = System.currentTimeMillis(); - mParentId = 0; - mSnippet = ""; - mType = Notes.TYPE_NOTE; - mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; - mWidgetType = Notes.TYPE_WIDGET_INVALIDE; - mOriginParent = 0; - mVersion = 0; - mDiffNoteValues = new ContentValues(); - mDataList = new ArrayList(); + mContext = context; // 保存上下文对象 + mContentResolver = context.getContentResolver(); // 获取ContentResolver对象 + mIsCreate = true; // 标记对象是否新建 + mId = INVALID_ID; // 设置对象的id为无效值 + mAlertDate = 0; // 设置提醒日期为0 + mBgColorId = ResourceParser.getDefaultBgId(context); // 设置默认背景颜色 + mCreatedDate = System.currentTimeMillis(); // 获取当前系统时间作为创建日期 + mHasAttachment = 0; // 设置对象是否有附件为0（没有） + mModifiedDate = System.currentTimeMillis(); // 获取当前系统时间作为修改日期 + mParentId = 0; // 设置对象的父id为0 + mSnippet = ""; // 设置摘要为空字符串 + mType = Notes.TYPE_NOTE; // 设置对象类型为笔记 + mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 设置小部件id为无效值 + mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 设置小部件类型为无效值 + mOriginParent = 0; // 设置对象的原始父id为0 + mVersion = 0; // 设置对象版本号为0 + mDiffNoteValues = new ContentValues(); // 初始化对象值差异 + mDataList = new ArrayList(); // 初始化数据列表 } + // 功能描述：构造函数 + // SqlNote类的构造函数，用于从Cursor对象中加载数据，创建SqlNote对象 + // 参数注解： mIsCreate用于标示构造方式 + + // 构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化 public SqlNote(Context context, Cursor c) { - mContext = context; - mContentResolver = context.getContentResolver(); - mIsCreate = false; - loadFromCursor(c); - mDataList = new ArrayList(); - if (mType == Notes.TYPE_NOTE) - loadDataContent(); - mDiffNoteValues = new ContentValues(); + mContext = context; // 保存上下文对象 + mContentResolver = context.getContentResolver(); // 获取ContentResolver对象 + mIsCreate = false; // 标记对象不是新建 + loadFromCursor(c); // 从Cursor对象中加载数据 + mDataList = new ArrayList(); // 初始化数据列表 + if (mType == Notes.TYPE_NOTE) // 如果对象是笔记类型 + loadDataContent(); // 加载笔记数据内容 + mDiffNoteValues = new ContentValues(); // 初始化对象值差异 } + // 功能描述：构造函数 + // SqlNote类的构造函数，用于从id值中加载数据，创建SqlNote对象 + // 参数注解： mIsCreate用于标示构造方式 public SqlNote(Context context, long id) { - mContext = context; - mContentResolver = context.getContentResolver(); - mIsCreate = false; - loadFromCursor(id); - mDataList = new ArrayList(); - if (mType == Notes.TYPE_NOTE) - loadDataContent(); - mDiffNoteValues = new ContentValues(); - + mContext = context; // 保存上下文对象 + mContentResolver = context.getContentResolver(); // 获取ContentResolver对象 + mIsCreate = false; // 标记对象不是新建 + loadFromCursor(id); // 从id值中加载数据 + mDataList = new ArrayList(); // 初始化数据列表 + if (mType == Notes.TYPE_NOTE) // 如果对象是笔记类型 + loadDataContent(); // 加载笔记数据内容 + mDiffNoteValues = new ContentValues(); // 初始化对象值差异 } + // 功能描述：通过id从光标处加载数据，根据id从数据库中查询便签数据并加载 private void loadFromCursor(long id) { - Cursor c = null; + Cursor c = null; // 声明一个 Cursor 变量并初始化为 null try { c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)", new String[] { String.valueOf(id) }, null); + // 通过id获得对应的ContentResolver中的cursor，通过内容提供器获取便签的 Cursor if (c != null) { - c.moveToNext(); - loadFromCursor(c); + c.moveToNext(); // 将 Cursor 移到下一行，因为默认情况下它指向的是查询结果的第一行之前的位置 + loadFromCursor(c); // 加载数据到 SqlNote 的成员变量中 + // 然后加载数据进行初始化，这与函数SqlNote(Context context, long id) + // 与SqlNote(Context context, long id)的实现方式基本相同 } else { - Log.w(TAG, "loadFromCursor: cursor = null"); + Log.w(TAG, "loadFromCursor: cursor = null"); // 输出警告日志 } } finally { if (c != null) @@ -185,60 +213,71 @@ public class SqlNote { } } + // 功能描述：通过游标从光标处加载数据，从 Cursor 中加载便签数据 private void loadFromCursor(Cursor c) { - mId = c.getLong(ID_COLUMN); - mAlertDate = c.getLong(ALERTED_DATE_COLUMN); - mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); - mCreatedDate = c.getLong(CREATED_DATE_COLUMN); - mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); - mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); - mParentId = c.getLong(PARENT_ID_COLUMN); - mSnippet = c.getString(SNIPPET_COLUMN); - mType = c.getInt(TYPE_COLUMN); - mWidgetId = c.getInt(WIDGET_ID_COLUMN); - mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); - mVersion = c.getLong(VERSION_COLUMN); + // 直接从一条记录中的获得以下变量的初始值 + mId = c.getLong(ID_COLUMN); // 获取便签的 id + mAlertDate = c.getLong(ALERTED_DATE_COLUMN); // 获取提醒时间 + mBgColorId = c.getInt(BG_COLOR_ID_COLUMN); // 获取背景颜色 ID + mCreatedDate = c.getLong(CREATED_DATE_COLUMN); // 获取创建时间 + mHasAttachment = c.getInt(HAS_ATTACHMENT_COLUMN); // 获取是否有附件 + mModifiedDate = c.getLong(MODIFIED_DATE_COLUMN); // 获取修改时间 + mParentId = c.getLong(PARENT_ID_COLUMN); // 获取父级便签的 id + mSnippet = c.getString(SNIPPET_COLUMN); // 获取便签内容的摘要信息 + mType = c.getInt(TYPE_COLUMN); // 获取便签类型 + mWidgetId = c.getInt(WIDGET_ID_COLUMN); // 获取小部件的 id + mWidgetType = c.getInt(WIDGET_TYPE_COLUMN); // 获取小部件类型 + mVersion = c.getLong(VERSION_COLUMN); // 获取版本号 } + // 功能描述：通过content机制获取共享数据并加载到数据库当前游标处 + // 参数注解： private void loadDataContent() { - Cursor c = null; - mDataList.clear(); + Cursor c = null; //定义游标c + mDataList.clear(); //清空数据列表mDataList try { + //查询内容提供器，获取数据，条件为note_id=mId，即查询当前笔记的数据内容 c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA, "(note_id=?)", new String[] { - String.valueOf(mId) + String.valueOf(mId) }, null); - if (c != null) { - if (c.getCount() == 0) { - Log.w(TAG, "it seems that the note has not data"); - return; + if (c != null) { //如果游标c不为空 + if (c.getCount() == 0) { //如果游标c的数量为0，则表示当前笔记无数据内容 + Log.w(TAG, "it seems that the note has not data"); //输出警告信息 + return; //返回 } - while (c.moveToNext()) { - SqlData data = new SqlData(mContext, c); - mDataList.add(data); + while (c.moveToNext()) { //如果游标c有下一行记录，则遍历游标c + SqlData data = new SqlData(mContext, c); //新建SqlData对象data，传入mContext和游标c + mDataList.add(data); //将data加入到数据列表mDataList中 } } else { - Log.w(TAG, "loadDataContent: cursor = null"); + Log.w(TAG, "loadDataContent: cursor = null"); //输出警告信息 } } finally { + //无论如何都执行finally块中的代码 if (c != null) c.close(); } } + // 功能描述：设置通过content机制用于共享的数据信息 + // 参数注解： public boolean setContent(JSONObject js) { try { + // 获取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) { - // for folder we can only update the snnipet and type - String snippet = note.has(NoteColumns.SNIPPET) ? note - .getString(NoteColumns.SNIPPET) : ""; + } + // 如果笔记类型为文件夹 + else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + // 可以更新snippet和类型 + String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : ""; + // 如果是新建笔记或者snippet改变，则将新值放入mDiffNoteValues中 if (mIsCreate || !mSnippet.equals(snippet)) { mDiffNoteValues.put(NoteColumns.SNIPPET, snippet); } - mSnippet = snippet; int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE; @@ -246,7 +285,9 @@ 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); long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID; if (mIsCreate || mId != id) { @@ -254,13 +295,16 @@ public class SqlNote { } mId = id; + // 获取提醒时间 long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note .getLong(NoteColumns.ALERTED_DATE) : 0; if (mIsCreate || mAlertDate != alertDate) { mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); } + mAlertDate = alertDate; + // 获取背景颜色id int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note .getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext); if (mIsCreate || mBgColorId != bgColorId) { @@ -268,6 +312,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 +320,7 @@ public class SqlNote { } mCreatedDate = createDate; + // 获取笔记是否有附件 int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note .getInt(NoteColumns.HAS_ATTACHMENT) : 0; if (mIsCreate || mHasAttachment != hasAttachment) { @@ -296,6 +342,7 @@ public class SqlNote { } mParentId = parentId; + // 获取笔记的摘要 String snippet = note.has(NoteColumns.SNIPPET) ? note .getString(NoteColumns.SNIPPET) : ""; if (mIsCreate || !mSnippet.equals(snippet)) { @@ -303,6 +350,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 +358,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 +366,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) { @@ -331,6 +381,7 @@ public class SqlNote { } mOriginParent = originParent; + // 获取笔记的附加数据 for (int i = 0; i < dataArray.length(); i++) { JSONObject data = dataArray.getJSONObject(i); SqlData sqlData = null; @@ -359,15 +410,20 @@ public class SqlNote { return true; } + // 功能描述：获取content机制提供的数据并加载到note中， 获取笔记内容的JSONObject对象 + // return 笔记内容的JSONObject对象，若该笔记未在数据库中创建，则返回null + // 参数注解： public JSONObject getContent() { try { JSONObject js = new JSONObject(); + // 如果该笔记未在数据库中创建，则返回null if (mIsCreate) { Log.e(TAG, "it seems that we haven't created this in database yet"); return null; } + // 构造笔记的JSONObject对象 JSONObject note = new JSONObject(); if (mType == Notes.TYPE_NOTE) { note.put(NoteColumns.ID, mId); @@ -384,6 +440,7 @@ public class SqlNote { note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); js.put(GTaskStringUtils.META_HEAD_NOTE, note); + // 构造数据的JSONArray对象 JSONArray dataArray = new JSONArray(); for (SqlData sqlData : mDataList) { JSONObject data = sqlData.getContent(); @@ -393,6 +450,7 @@ public class SqlNote { } js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { + // 如果该笔记为文件夹或系统笔记，则构造简单的笔记JSONObject对象 note.put(NoteColumns.ID, mId); note.put(NoteColumns.TYPE, mType); note.put(NoteColumns.SNIPPET, mSnippet); @@ -407,45 +465,66 @@ public class SqlNote { return null; } + // 功能描述：给当前id设置父id + // 参数注解： public void setParentId(long id) { mParentId = id; mDiffNoteValues.put(NoteColumns.PARENT_ID, id); } + // 功能描述：给当前id设置Gtaskid + // 参数注解： public void setGtaskId(String gid) { mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); } + // 功能描述：给当前id设置同步id + // 参数注解： public void setSyncId(long syncId) { mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); } + // 功能描述：初始化本地修改，即撤销所有当前修改 + // 参数注解： public void resetLocalModified() { mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); } + // 功能描述：获得当前id + // 参数注解： public long getId() { return mId; } + // 功能描述：获得当前id的父id + // 参数注解： public long getParentId() { return mParentId; } + // 功能描述：获取小片段即用于显示的部分便签内容 + // 参数注解： public String getSnippet() { return mSnippet; } + // 功能描述：判断是否为便签类型 + // 参数注解： public boolean isNoteType() { return mType == Notes.TYPE_NOTE; } + // 功能描述：commit函数用于把当前造作所做的修改保存到数据库 + // 参数注解： public void commit(boolean validateVersion) { if (mIsCreate) { + // 如果当前的 Note 是新建的 + // 如果当前 Note 的 ID 是无效的，并且存在 ID 字段，则将其从 DiffNoteValues 中移除 if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { mDiffNoteValues.remove(NoteColumns.ID); } + // 将当前 Note 插入到数据库中，并从返回的 URI 中获取 Note 的 ID Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); try { mId = Long.valueOf(uri.getPathSegments().get(1)); @@ -453,31 +532,37 @@ public class SqlNote { Log.e(TAG, "Get note id error :" + e.toString()); throw new ActionFailureException("create note failed"); } + + // 如果获取到的 Note 的 ID 为 0，则抛出异常 if (mId == 0) { throw new IllegalStateException("Create thread id failed"); } + // 如果当前 Note 是普通笔记，则将其关联的 SqlData 数据写入到数据库中 if (mType == Notes.TYPE_NOTE) { for (SqlData sqlData : mDataList) { sqlData.commit(mId, false, -1); } } - } else { + } else { // 如果当前的 Note 不是新建的 + // 如果当前 Note 的 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"); } + + // 如果当前 Note 的 DiffNoteValues 中存在修改过的值，则将其更新到数据库中 if (mDiffNoteValues.size() > 0) { - mVersion ++; + mVersion ++; // 更新 Note 的版本号 int result = 0; - if (!validateVersion) { + if (!validateVersion) { // 如果不需要验证版本号，则直接更新数据库 result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?)", new String[] { - String.valueOf(mId) + String.valueOf(mId) }); - } else { + } else { // 如果需要验证版本号，则在更新数据库时指定版本号 result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" - + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", + + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", new String[] { String.valueOf(mId), String.valueOf(mVersion) }); @@ -487,6 +572,7 @@ public class SqlNote { } } + // 如果当前 Note 是普通笔记，则将其关联的 SqlData 数据写入到数据库中 if (mType == Notes.TYPE_NOTE) { for (SqlData sqlData : mDataList) { sqlData.commit(mId, validateVersion, mVersion); @@ -494,12 +580,11 @@ public class SqlNote { } } - // refresh local info + // 刷新当前 Note 对象的本地数据，并将其 DiffNoteValues 清空 loadFromCursor(mId); if (mType == Notes.TYPE_NOTE) loadDataContent(); - mDiffNoteValues.clear(); mIsCreate = false; } -} +} \ No newline at end of file diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Task.java b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Task.java index 6a19454..c104d01 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Task.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/Task.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// 任务类，用于在任务列表中查询当前所执行的任务，将任务相关信息进行本地和远程的同步，对结点内容进行设置，获取同步任务信息 package net.micode.notes.gtask.data; @@ -35,22 +36,22 @@ import org.json.JSONObject; public class Task extends Node { private static final String TAG = Task.class.getSimpleName(); - private boolean mCompleted; + private boolean mCompleted; // 是否完成 private String mNotes; - private JSONObject mMetaInfo; + private JSONObject mMetaInfo; // 将在实例中存储数据的类型 - private Task mPriorSibling; + private Task mPriorSibling; // 对应的优先兄弟Task的指针 - private TaskList mParent; + private TaskList mParent; // 所在的任务列表的指针 public Task() { super(); mCompleted = false; mNotes = null; - mPriorSibling = null; - mParent = null; + mPriorSibling = null; // TaskList中当前Task前面的Task的指针 + mParent = null; // 当前Task所在的TaskList mMetaInfo = null; } @@ -62,44 +63,46 @@ public class Task extends Node { js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); - // action_id + // 设置创建操作的ID js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); - // index + // 设置待办事项在父任务中的索引位置 js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); - // entity_delta + // 设置待办事项任务的entity_delta对象 JSONObject entity = new JSONObject(); - entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); - entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置待办事项任务的名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 设置待办事项任务的创建者ID entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, - GTaskStringUtils.GTASK_JSON_TYPE_TASK); - if (getNotes() != null) { + GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 设置待办事项任务的entity类型为"task" + if (getNotes() != null) { // 如果待办事项任务有备注信息，则添加到entity_delta对象中 entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); } js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); - // parent_id + // 设置待办事项任务所属的父任务ID js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); - // dest_parent_type + // 设置父任务类型为"group" js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, GTaskStringUtils.GTASK_JSON_TYPE_GROUP); - // list_id + // 设置待办事项任务所属的列表ID js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); - // prior_sibling_id + // 如果待办事项任务有前一个同级任务，则设置prior_sibling_id为前一个同级任务的ID if (mPriorSibling != null) { js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); } - } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to generate task-create jsonobject"); + + } catch (JSONException e) { + Log.e(TAG, e.toString()); // 打印异常信息 + e.printStackTrace(); // 打印堆栈跟踪信息 + throw new ActionFailureException("fail to generate task-create jsonobject"); // 抛出创建操作失败的异常 } + // 返回待办事项任务的创建操作的JSONObject对象 return js; } @@ -107,31 +110,32 @@ public class Task extends Node { JSONObject js = new JSONObject(); try { - // action_type + // 设置待办事项任务的操作类型为更新 js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); - // action_id + // 设置待办事项任务的操作ID js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); - // id + // 设置待办事项任务的ID js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); - // entity_delta + // 设置待办事项任务的实体差异 JSONObject entity = new JSONObject(); - entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); + 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); + entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 设置待办事项任务是否已经被删除 + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体差异添加到操作JSONObject对象中 } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to generate task-update jsonobject"); + Log.e(TAG, e.toString()); // 打印异常信息 + e.printStackTrace(); // 打印堆栈跟踪信息 + throw new ActionFailureException("fail to generate task-update jsonobject"); // 抛出更新操作失败的异常 } + // 返回待办事项任务的更新操作的JSONObject对象 return js; } @@ -139,38 +143,35 @@ public class Task extends Node { if (js != null) { try { // id - if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { - setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); - } - + // 设置任务id // last_modified if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { - setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); + setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); // 设置任务最后修改时间 } // name if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { - setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); + setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); // 设置任务名称 } // notes if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { - setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); + setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); // 设置任务备注信息 } // deleted if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { - setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); + setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); // 设置任务是否被删除 } // completed if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { - setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); + setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); // 设置任务是否已完成 } } catch (JSONException e) { - Log.e(TAG, e.toString()); - e.printStackTrace(); - throw new ActionFailureException("fail to get task content from jsonobject"); + Log.e(TAG, e.toString()); // 打印异常信息 + e.printStackTrace(); // 打印异常堆栈信息 + throw new ActionFailureException("fail to get task content from jsonobject"); // 抛出操作失败异常 } } } @@ -178,7 +179,7 @@ public class Task extends Node { public void setContentByLocalJSON(JSONObject js) { if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) || !js.has(GTaskStringUtils.META_HEAD_DATA)) { - Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); + Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");// 打印警告日志 } try { @@ -193,7 +194,7 @@ public class Task extends Node { for (int i = 0; i < dataArray.length(); i++) { JSONObject data = dataArray.getJSONObject(i); if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { - setName(data.getString(DataColumns.CONTENT)); + setName(data.getString(DataColumns.CONTENT));// 设置任务名称 break; } } @@ -208,7 +209,7 @@ public class Task extends Node { String name = getName(); try { if (mMetaInfo == null) { - // new task created from web + // 从网络创建新任务 if (name == null) { Log.w(TAG, "the note seems to be an empty one"); return null; @@ -225,14 +226,14 @@ public class Task extends Node { js.put(GTaskStringUtils.META_HEAD_NOTE, note); return js; } else { - // synced task + // 同步任务 JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); for (int i = 0; i < dataArray.length(); i++) { JSONObject data = dataArray.getJSONObject(i); if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { - data.put(DataColumns.CONTENT, getName()); + data.put(DataColumns.CONTENT, getName());// 更新任务名称 break; } } @@ -247,6 +248,7 @@ public class Task extends Node { } } + // 设置元数据信息 public void setMetaInfo(MetaData metaData) { if (metaData != null && metaData.getNotes() != null) { try { @@ -266,43 +268,44 @@ public class Task extends Node { } if (noteInfo == null) { - Log.w(TAG, "it seems that note meta has been deleted"); - return SYNC_ACTION_UPDATE_REMOTE; + Log.w(TAG, "笔记元信息已被删除"); + return SYNC_ACTION_UPDATE_REMOTE; // 本地笔记元信息已被删除，需要更新到远程 } if (!noteInfo.has(NoteColumns.ID)) { - Log.w(TAG, "remote note id seems to be deleted"); - return SYNC_ACTION_UPDATE_LOCAL; + Log.w(TAG, "远程笔记ID已被删除"); + return SYNC_ACTION_UPDATE_LOCAL; // 远程笔记ID已被删除，需要更新到本地 } - // validate the note id now + // 验证笔记ID if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { - Log.w(TAG, "note id doesn't match"); - return SYNC_ACTION_UPDATE_LOCAL; + Log.w(TAG, "笔记ID不匹配"); + return SYNC_ACTION_UPDATE_LOCAL; // 本地笔记ID与远程笔记ID不匹配，需要更新到本地 } if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { - // there is no local update + // 没有本地更新 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // no update both side - return SYNC_ACTION_NONE; + // 两边都没有更新 + return SYNC_ACTION_NONE; // 无需同步 } else { - // apply remote to local - return SYNC_ACTION_UPDATE_LOCAL; + // 应用远程更新到本地 + return SYNC_ACTION_UPDATE_LOCAL; // 远程有更新，需要更新到本地 } } else { - // validate gtask id + // 验证gtask ID if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { - Log.e(TAG, "gtask id doesn't match"); - return SYNC_ACTION_ERROR; + Log.e(TAG, "gtask ID不匹配"); + return SYNC_ACTION_ERROR; // gtask ID不匹配，错误 } if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // local modification only - return SYNC_ACTION_UPDATE_REMOTE; + // 本地有修改 + return SYNC_ACTION_UPDATE_REMOTE; // 本地有更新，需要更新到远程 } else { - return SYNC_ACTION_UPDATE_CONFLICT; + return SYNC_ACTION_UPDATE_CONFLICT; // 本地和远程都有更新，冲突 } } + } catch (Exception e) { Log.e(TAG, e.toString()); e.printStackTrace(); @@ -311,39 +314,58 @@ public class Task extends Node { return SYNC_ACTION_ERROR; } + // 判断任务是否值得保存 + // return 若任务的元信息不为空，或任务名称非空且去除空格后长度大于0， + // 或任务备注非空且去除空格后长度大于0，则返回 true，否则返回 false。 public boolean isWorthSaving() { return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) || (getNotes() != null && getNotes().trim().length() > 0); } + // 设置任务的完成状态 + // completed 任务是否已完成 public void setCompleted(boolean completed) { this.mCompleted = completed; } + // 设置任务的备注 + // notes 任务的备注 public void setNotes(String notes) { this.mNotes = notes; } + // 设置任务的上一个同级节点 + // priorSibling 任务的上一个同级节点 public void setPriorSibling(Task priorSibling) { this.mPriorSibling = priorSibling; } + // 设置任务所属的任务列表 + // parent 任务所属的任务列表 public void setParent(TaskList parent) { this.mParent = parent; } + // 获取任务的完成状态 + // return 任务是否已完成 public boolean getCompleted() { return this.mCompleted; } + // 获取任务的备注 + // return 任务的备注 public String getNotes() { return this.mNotes; } + // 获取任务的上一个同级节点 + // return 任务的上一个同级节点 public Task getPriorSibling() { return this.mPriorSibling; } + // 获取任务所属的任务列表 + // return 任务所属的任务列表 public TaskList getParent() { return this.mParent; } diff --git a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/TaskList.java b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/TaskList.java index 4ea21c5..d31fd27 100644 --- a/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/TaskList.java +++ b/src/Notes-master/app/src/main/java/net/micode/notes/gtask/data/TaskList.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +// 任务列表类，用于将任务（Task）标记并存储到任务列表中进行管理操作，并在任务表的指定位置进行增删查改，移动等操作 package net.micode.notes.gtask.data; @@ -31,92 +32,106 @@ import java.util.ArrayList; public class TaskList extends Node { + // 定义TaskList类，继承自GTask类 private static final String TAG = TaskList.class.getSimpleName(); + // 定义TAG常量，用于日志输出 + // tag标记 private int mIndex; + // 当前TaskList的指针 + // 定义mIndex变量，表示任务列表的序号 private ArrayList mChildren; + // 类中主要的保存数据的单元，用来实现一个以Task为元素的ArrayList + // 定义mChildren变量，表示该任务列表包含的子任务列表 + // TaskList类的构造函数，初始化mChildren变量为一个空的Task列表，mIndex为1 public TaskList() { super(); mChildren = new ArrayList(); mIndex = 1; } + // 生成并返回一个包含了一定数据的JSONObject实体 + // 返回一个用于创建该任务列表的JSON对象 public JSONObject getCreateAction(int actionId) { JSONObject js = new JSONObject(); try { // action_type js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, - GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); // 设置动作类型为创建任务列表 // action_id - js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 设置动作ID // index - js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); + js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); // 设置任务列表的序号 // entity_delta - JSONObject entity = new JSONObject(); - entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); - entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); + JSONObject entity = new JSONObject(); // 创建一个新的JSON对象，用于存储任务列表信息 + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置任务列表的名称 + entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 设置任务列表的创建者ID为空 entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, - GTaskStringUtils.GTASK_JSON_TYPE_GROUP); - js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 设置任务列表的类型为GROUP + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将entity对象添加到js对象中 } catch (JSONException e) { Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to generate tasklist-create jsonobject"); + throw new ActionFailureException("fail to generate tasklist-create jsonobject"); // 抛出异常 } - return js; + return js; // 返回创建的JSON对象 } + // 生成并返回一个包含了一定数据的JSONObject实体 + // 返回一个用于更新该任务列表的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); + GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); // 设置动作类型为更新任务列表 // action_id - js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); + js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 设置动作ID // id - js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); + js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); // 设置任务列表的ID // entity_delta - JSONObject entity = new JSONObject(); - entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); - entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); - js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); + JSONObject entity = new JSONObject(); // 创建一个新的JSON对象，用于存储任务列表信息 + entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置任务列表的名称 + entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 设置任务列表是否被删除的状态 + js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将entity对象添加到js对象中 } catch (JSONException e) { Log.e(TAG, e.toString()); e.printStackTrace(); - throw new ActionFailureException("fail to generate tasklist-update jsonobject"); + throw new ActionFailureException("fail to generate tasklist-update jsonobject"); // 抛出异常 } - return js; + return js; // 返回创建的JSON对象 } + // 通过远程 JSON 对象设置任务列表内容 + // js 远程 JSON 对象 public void setContentByRemoteJSON(JSONObject js) { if (js != null) { try { - // id + // 设置 ID if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); } - // last_modified + // 设置最后修改时间 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); } - // name + // 设置名称 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); } @@ -129,29 +144,39 @@ public class TaskList extends Node { } } + // 根据本地 JSON 对象设置内容。 + // js 本地 JSON 对象 public void setContentByLocalJSON(JSONObject js) { + // 设置内容，通过本地JSON对象 if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { + // 如果JSON对象为空或者没有指定键值对，记录警告日志并退出方法 Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); } try { + // 尝试解析JSON对象，获取指定键的值 JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { + // 如果获取到的值为"文件夹"类型 String name = folder.getString(NoteColumns.SNIPPET); setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name); } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { + // 如果获取到的值为"系统"类型 if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER) setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT); else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER) setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE); else + // 如果获取到的值为无效类型 Log.e(TAG, "invalid system folder"); } else { + // 如果获取到的值为错误类型 Log.e(TAG, "error type"); } } catch (JSONException e) { + // 如果出现解析异常，记录错误日志并输出异常栈 Log.e(TAG, e.toString()); e.printStackTrace(); } @@ -159,6 +184,7 @@ public class TaskList extends Node { public JSONObject getLocalJSONFromContent() { try { + // 尝试创建一个新的JSON对象 JSONObject js = new JSONObject(); JSONObject folder = new JSONObject(); @@ -177,6 +203,7 @@ public class TaskList extends Node { return js; } catch (JSONException e) { + // 如果出现解析异常，记录错误日志并输出异常栈 Log.e(TAG, e.toString()); e.printStackTrace(); return null; @@ -186,17 +213,18 @@ public class TaskList extends Node { public int getSyncAction(Cursor c) { try { if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { - // there is no local update + // 如果本地没有修改 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { - // no update both side + // 如果本地和远程都没有修改 return SYNC_ACTION_NONE; } else { - // apply remote to local + // 如果远程有修改，本地应用远程的修改 return SYNC_ACTION_UPDATE_LOCAL; } } else { - // validate gtask id + // 验证gtask id if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { + // 如果gtask id不匹配，记录错误日志并返回错误状态 Log.e(TAG, "gtask id doesn't match"); return SYNC_ACTION_ERROR; } @@ -216,35 +244,48 @@ public class TaskList extends Node { return SYNC_ACTION_ERROR; } + // 功能：获得TaskList的大小，即mChildren的大小 + // 获取子任务的数量 public int getChildTaskCount() { return mChildren.size(); } + // @param task + // @return 返回值为是否成功添加任务。 + // 功能：在当前任务表末尾添加新的任务。 public boolean addChildTask(Task task) { boolean ret = false; if (task != null && !mChildren.contains(task)) { ret = mChildren.add(task); if (ret) { + // 设置前一个兄弟任务和父任务 // need to set prior sibling and parent task.setPriorSibling(mChildren.isEmpty() ? null : mChildren .get(mChildren.size() - 1)); task.setParent(this); + // 注意：每一次ArrayList的变化都要紧跟相关Task中PriorSibling的更改 + // 接下来几个函数都有相关操作 } } return ret; } + // 功能：在当前任务表的指定位置添加新的任务，返回添加是否成功 + // task + // index public boolean addChildTask(Task task, int index) { + // 如果指定的位置超出了子任务的范围，返回失败 if (index < 0 || index > mChildren.size()) { Log.e(TAG, "add child task: invalid index"); return false; } + // 查找子任务列表中是否已经存在这个子任务，如果不存在则添加到指定位置 int pos = mChildren.indexOf(task); if (task != null && pos == -1) { mChildren.add(index, task); - // update the task list + // 更新任务列表中前一个和后一个任务的信息 Task preTask = null; Task afterTask = null; if (index != 0) @@ -260,6 +301,8 @@ public class TaskList extends Node { return true; } + // 功能：删除TaskList中的一个Task，返回删除是否成功 + // task public boolean removeChildTask(Task task) { boolean ret = false; int index = mChildren.indexOf(task); @@ -267,11 +310,11 @@ public class TaskList extends Node { ret = mChildren.remove(task); if (ret) { - // reset prior sibling and parent + // 重置前一个兄弟和父节点 task.setPriorSibling(null); task.setParent(null); - // update the task list + // 更新任务列表 if (index != mChildren.size()) { mChildren.get(index).setPriorSibling( index == 0 ? null : mChildren.get(index - 1)); @@ -281,38 +324,57 @@ public class TaskList extends Node { return ret; } + // 功能：将当前TaskList中含有的某个Task移到index位置，将一个子任务移动到指定的位置 + // task 要移动的任务 + // index 目标位置 + // return 如果移动成功，返回true；否则返回false + // 将任务移动到给定的索引位置 public boolean moveChildTask(Task task, int index) { - + //如果索引无效，则返回false并记录错误日志 if (index < 0 || index >= mChildren.size()) { Log.e(TAG, "move child task: invalid index"); return false; } + //获取任务在列表中的位置 int pos = mChildren.indexOf(task); + //如果任务不在列表中，则返回false并记录错误日志 if (pos == -1) { Log.e(TAG, "move child task: the task should in the list"); return false; } + //如果任务已经在指定位置，则返回true if (pos == index) return true; + //否则从原位置删除该任务并将其插入新位置，返回插入结果 return (removeChildTask(task) && addChildTask(task, index)); + // 利用已实现好的功能完成当下功能； } + // 功能：按gid寻找Task，根据给定的gid查找并返回子任务 + // gid + // return 返回寻找结果 public Task findChildTaskByGid(String gid) { + //遍历子任务列表，查找并返回与给定gid匹配的子任务 for (int i = 0; i < mChildren.size(); i++) { Task t = mChildren.get(i); if (t.getGid().equals(gid)) { return t; } } + //如果没有找到，则返回null return null; } + // 功能：返回指定Task的index，返回给定任务在子任务列表中的索引，如果找不到则返回-1 + // task public int getChildTaskIndex(Task task) { return mChildren.indexOf(task); } + // 功能：返回指定index的Task，根据给定的索引返回子任务，如果索引无效则返回null + // index public Task getChildTaskByIndex(int index) { if (index < 0 || index >= mChildren.size()) { Log.e(TAG, "getTaskByIndex: invalid index"); @@ -321,22 +383,27 @@ public class TaskList extends Node { return mChildren.get(index); } + // 功能：返回指定gid的Task，根据给定的gid返回子任务，如果找不到则返回null + // gid public Task getChilTaskByGid(String gid) { - for (Task task : mChildren) { + for (Task task : mChildren) { // 一种常见的ArrayList的遍历方法 if (task.getGid().equals(gid)) return task; } return null; } + //返回子任务列表 public ArrayList getChildTaskList() { return this.mChildren; } + //设置任务的索引值 public void setIndex(int index) { this.mIndex = index; } + //返回任务的索引值 public int getIndex() { return this.mIndex; }