pyrwjakib
/
zcsxy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: pyrwjakib:2566bca557c24e79739e201b95d7cf90a59e1f2c
Branches Tags
pyrwjakib:main
pyrwjakib:xy
pyrwjakib:zcs
...
compare: pyrwjakib:1728bb5fbce327df8c4bc3b406324f1bfc7319bf
Branches Tags
pyrwjakib:main
pyrwjakib:xy
pyrwjakib:zcs

7 Commits
2566bca557 ... 1728bb5fbc

Author SHA1 Message Date
xy 1728bb5fbc Merge remote-tracking branch 'remotes/origin/xy'
8 months ago
xy 2c24c58fab Merge remote-tracking branch 'remotes/origin/zcs'
8 months ago
xy 2f4b4d8cd8 许扬 202201002057
8 months ago
zcs 9f0a173905 张昌盛 202201002062
8 months ago
zcs c68c9767d1 张昌盛 202201002062
8 months ago
yunci 518bc5f14d Revert "张昌盛 202201002062"
8 months ago
zcs 1a3da5bc84 张昌盛 202201002062
8 months ago
38 changed files with 2485 additions and 667 deletions
Show Stats

26
src/Notes-master/src/net/micode/notes/data/Contact.java
Unescape View File

@ -24,29 +24,34 @@ import android.telephony.PhoneNumberUtils;
import android.util.Log;
import java.util.HashMap;
//ceshihebing2
// Contact类，主要用于根据电话号码获取对应的联系人姓名
public class Contact {
// 用于缓存联系人信息（电话号码与对应姓名的映射）的哈希表，以避免重复查询数据库
private static HashMap<String, String> sContactCache;
// 用于日志记录的标签，方便在日志中识别相关输出所属的类
private static final String TAG = "Contact";
// 构建查询联系人的SQL语句的选择条件部分，用于从联系人数据中筛选出符合条件的记录
// 条件基于电话号码匹配、MIME类型匹配以及原始联系人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 "
+ "(SELECT raw_contact_id "
+ " FROM phone_lookup"
+ " WHERE min_match = '+')";
// 根据给定的上下文（Context）和电话号码获取对应的联系人姓名
public static String getContact(Context context, String phoneNumber) {
// 如果缓存为空，则初始化缓存哈希表，用于存储已查询过的电话号码与对应联系人姓名的映射关系
if(sContactCache == null) {
sContactCache = new HashMap<String, String>();
}
// 首先检查缓存中是否已经存在该电话号码对应的联系人姓名，如果存在则直接返回缓存中的姓名
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
// 根据给定的电话号码，替换查询条件中的占位符（将'+'替换为适合查询的最小匹配格式）
// 这里使用PhoneNumberUtils工具类来转换电话号码格式，使其符合查询要求
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
Cursor cursor = context.getContentResolver().query(
@ -55,19 +60,28 @@ public class Contact {
selection,
new String[] { phoneNumber },
null);
// 通过上下文的内容解析器（ContentResolver）发起数据库查询操作
// 查询联系人数据的相关表（Data.CONTENT_URI），只获取联系人的显示名称（Phone.DISPLAY_NAME）字段
// 使用上面构建好的选择条件（selection），并传入电话号码作为查询参数
// 如果查询结果游标（Cursor）不为空，并且游标能够移动到第一条记录（意味着有匹配的联系人数据）
if (cursor != null && cursor.moveToFirst()) {
try {
// 从游标中获取联系人的显示名称（假设显示名称在结果集的第0个位置）
String name = cursor.getString(0);
// 从游标中获取联系人的显示名称（假设显示名称在结果集的第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;
}

66
src/Notes-master/src/net/micode/notes/data/NotesDatabaseHelper.java
Unescape View File

@ -25,23 +25,26 @@ import android.util.Log;
import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
// NotesDatabaseHelper类继承自SQLiteOpenHelper，用于管理与笔记相关的数据库的创建、升级以及一些数据库表结构和触发器的初始化操作
public class NotesDatabaseHelper extends SQLiteOpenHelper {
// 定义数据库的名称，这里是"note.db"，即该应用对应的数据库文件名
private static final String DB_NAME = "note.db";
// 定义数据库的版本号，用于数据库升级等场景判断，当前版本为4
private static final int DB_VERSION = 4;
// TABLE接口，用于定义数据库中不同表的名称常量，方便在代码中统一引用，避免硬编码表名
public interface TABLE {
public static final String NOTE = "note";
public static final String DATA = "data";
}
// TABLE接口，用于定义数据库中不同表的名称常量，方便在代码中统一引用，避免硬编码表名
private static final String TAG = "NotesDatabaseHelper";
// 采用单例模式，保存该类的唯一实例，确保整个应用中只有一个数据库帮助类实例存在
private static NotesDatabaseHelper mInstance;
// 创建"note"表的SQL语句，定义了表的各个列名、数据类型以及默认值等信息
// 例如定义了笔记的ID、父级ID、提醒日期、背景颜色ID等列，为笔记相关数据存储做准备
private static final String CREATE_NOTE_TABLE_SQL =
"CREATE TABLE " + TABLE.NOTE + "(" +
NoteColumns.ID + " INTEGER PRIMARY KEY," +
@ -62,7 +65,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
NoteColumns.GTASK_ID + " TEXT NOT NULL DEFAULT ''," +
NoteColumns.VERSION + " INTEGER NOT NULL DEFAULT 0" +
")";
// 创建"data"表的SQL语句，同样定义了表的各列信息，用于存储笔记相关的数据内容等信息，如MIME类型、所属笔记ID、创建日期等
private static final String CREATE_DATA_TABLE_SQL =
"CREATE TABLE " + TABLE.DATA + "(" +
DataColumns.ID + " INTEGER PRIMARY KEY," +
@ -77,13 +80,14 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
DataColumns.DATA4 + " TEXT NOT NULL DEFAULT ''," +
DataColumns.DATA5 + " TEXT NOT NULL DEFAULT ''" +
")";
// 创建针对"data"表中NOTE_ID列的索引的SQL语句，有助于提高基于笔记ID进行数据查询的效率
private static final String CREATE_DATA_NOTE_ID_INDEX_SQL =
"CREATE INDEX IF NOT EXISTS note_id_index ON " +
TABLE.DATA + "(" + DataColumns.NOTE_ID + ");";
/**
* Increase folder's note count when move note to the folder
* 当笔记移动到文件夹时，增加文件夹的笔记数量的触发器SQL语句定义
*/
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_update "+
@ -96,6 +100,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Decrease folder's note count when move note from folder
* 当笔记移动到文件夹时，增加文件夹的笔记数量的触发器SQL语句定义
*/
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_update " +
@ -109,6 +114,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Increase folder's note count when insert new note to the folder
* 当从文件夹中删除笔记时，减少文件夹的笔记数量的触发器SQL语句定义，同样要确保当前笔记数量大于0才进行减少操作
*/
private static final String NOTE_INCREASE_FOLDER_COUNT_ON_INSERT_TRIGGER =
"CREATE TRIGGER increase_folder_count_on_insert " +
@ -121,6 +127,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Decrease folder's note count when delete note from the folder
* 当插入类型为DataConstants.NOTE的数据时，更新笔记内容的触发器SQL语句定义
*/
private static final String NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER =
"CREATE TRIGGER decrease_folder_count_on_delete " +
@ -134,6 +141,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Update note's content when insert data with type {@link DataConstants#NOTE}
* 当类型为DataConstants.NOTE的数据发生变化时，更新笔记内容的触发器SQL语句定义
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_INSERT_TRIGGER =
"CREATE TRIGGER update_note_content_on_insert " +
@ -147,6 +155,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Update note's content when data with {@link DataConstants#NOTE} type has changed
* 当类型为DataConstants.NOTE的数据被删除时，更新笔记内容的触发器SQL语句定义，将对应笔记的内容设置为空字符串
*/
private static final String DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER =
"CREATE TRIGGER update_note_content_on_update " +
@ -184,6 +193,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Delete notes belong to folder which has been deleted
* 当笔记被删除时，删除属于该笔记的数据的触发器SQL语句定义
*/
private static final String FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER =
"CREATE TRIGGER folder_delete_notes_on_delete " +
@ -195,6 +205,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* Move notes belong to folder which has been moved to trash folder
* 当文件夹被移动到回收站文件夹时，将属于该文件夹的笔记也移动到回收站文件夹的触发器SQL语句定义
*/
private static final String FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER =
"CREATE TRIGGER folder_move_notes_on_trash " +
@ -205,18 +216,18 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" SET " + NoteColumns.PARENT_ID + "=" + Notes.ID_TRASH_FOLER +
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
// 构造函数，调用父类SQLiteOpenHelper的构造函数，传入数据库名称、版本号等信息
public NotesDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
// 在给定的SQLiteDatabase对象上执行创建"note"表的操作，包括创建表、重新创建相关触发器以及创建系统文件夹，并输出日志表示表已创建
public void createNoteTable(SQLiteDatabase db) {
db.execSQL(CREATE_NOTE_TABLE_SQL);
reCreateNoteTableTriggers(db);
createSystemFolder(db);
Log.d(TAG, "note table has been created");
}
// 先删除已存在的"note"表相关的触发器（如果有），然后再重新创建所有"note"表对应的触发器
private void reCreateNoteTableTriggers(SQLiteDatabase db) {
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
@ -234,17 +245,17 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(FOLDER_DELETE_NOTES_ON_DELETE_TRIGGER);
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
// 向"note"表中插入代表不同系统文件夹的记录，如通话记录文件夹、根文件夹、临时文件夹、回收站文件夹等，通过构造ContentValues对象并调用db.insert方法来实现
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
*/
@ -252,7 +263,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
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
*/
@ -269,14 +280,14 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
// 在给定数据库对象上创建"data"表，创建表后会重新创建"data"表相关的触发器以及创建针对"data"表NOTE_ID列的索引，并输出日志表示表已创建
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");
}
// 先删除已存在的"data"表相关触发器（如果有），再重新创建相应触发器
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");
@ -286,6 +297,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_UPDATE_TRIGGER);
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
}
// 采用静态同步方法实现单例模式获取类的实例，若实例不存在则创建新的NotesDatabaseHelper实例并返回，保证整个应用只有一个该类的实例在使用
static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) {
@ -293,59 +305,61 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
}
return mInstance;
}
// 重写SQLiteOpenHelper的onCreate方法，在数据库首次创建时调用，内部会分别调用createNoteTable(db)和createDataTable(db)来创建"note"表和"data"表
@Override
public void onCreate(SQLiteDatabase db) {
createNoteTable(db);
createDataTable(db);
}
// 重写SQLiteOpenHelper的onUpgrade方法，用于处理数据库升级操作，根据旧版本号和新版本号进行不同的升级逻辑判断与处理
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false;
boolean skipV2 = false;
// 重写SQLiteOpenHelper的onUpgrade方法，用于处理数据库升级操作，根据旧版本号和新版本号进行不同的升级逻辑判断与处理
if (oldVersion == 1) {
upgradeToV2(db);
skipV2 = true; // this upgrade including the upgrade from v2 to v3
oldVersion++;
}
// 如果旧版本是2且没有跳过v2的升级（即不是从版本1升上来的情况），执行升级到版本3的操作，设置需要重新创建触发器的标记为true，再将旧版本号加1
if (oldVersion == 2 && !skipV2) {
upgradeToV3(db);
reCreateTriggers = true;
oldVersion++;
}
// 如果旧版本是3，执行升级到版本4的操作，然后将旧版本号加1
if (oldVersion == 3) {
upgradeToV4(db);
oldVersion++;
}
// 如果需要重新创建触发器（根据前面的升级逻辑判断），则分别重新创建"note"表和"data"表相关的触发器
if (reCreateTriggers) {
reCreateNoteTableTriggers(db);
reCreateDataTableTriggers(db);
}
// 如果最终旧版本号和新版本号不一致，说明升级出现问题，抛出异常表示升级失败
if (oldVersion != newVersion) {
throw new IllegalStateException("Upgrade notes database to version " + newVersion
+ "fails");
}
}
// 升级到版本2的具体操作，先删除已存在的"note"表和"data"表（如果有），然后重新创建这两个表
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的具体操作，包括删除一些不再使用的触发器，向"note"表添加gtask id列，以及插入一个回收站系统文件夹记录
private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers，删除不再使用的用于更新笔记修改日期的相关触发器
// 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
// 向"note"表添加gtask id列，数据类型为文本，默认值为空字符串
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.GTASK_ID
+ " TEXT NOT NULL DEFAULT ''");
// add a trash system folder
@ -354,7 +368,7 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
values.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
db.insert(TABLE.NOTE, null, values);
}
// 升级到版本4的具体操作，向"note"表添加version列，数据类型为整数，默认值为0
private void upgradeToV4(SQLiteDatabase db) {
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");

67
src/Notes-master/src/net/micode/notes/data/NotesProvider.java
Unescape View File

@ -33,15 +33,17 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes.DataColumns;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE;
// NotesProvider类继承自ContentProvider，用于作为内容提供者，对外提供对笔记相关数据的增删改查等操作，
// 并处理不同类型的Uri请求以区分操作的具体对象（如笔记、笔记数据等）以及搜索相关功能。
public class NotesProvider extends ContentProvider {
// 用于匹配不同的Uri请求的UriMatcher对象，通过静态代码块进行初始化配置
private static final UriMatcher mMatcher;
// 用于匹配不同的Uri请求的UriMatcher对象，通过静态代码块进行初始化配置
private NotesDatabaseHelper mHelper;
// 用于日志输出的标识字符串，便于在调试和记录运行情况时准确识别相关日志信息
private static final String TAG = "NotesProvider";
// 定义不同的Uri匹配码，用于区分不同类型的Uri请求，对应不同的笔记或数据相关操作
private static final int URI_NOTE = 1;
private static final int URI_NOTE_ITEM = 2;
private static final int URI_DATA = 3;
@ -49,7 +51,7 @@ public class NotesProvider extends ContentProvider {
private static final int URI_SEARCH = 5;
private static final int URI_SEARCH_SUGGEST = 6;
// 静态代码块，初始化UriMatcher对象，添加各种不同的Uri匹配规则，以便后续根据传入的Uri来确定具体的操作类型
static {
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
@ -64,6 +66,8 @@ public class NotesProvider extends ContentProvider {
/**
* x'0A' represents the '\n' character in sqlite. For title and content in the search result,
* we will trim '\n' and white space in order to show more information.
* 定义搜索结果的投影（查询返回的列）字符串，用于在搜索笔记时获取特定的列信息，
* 例如笔记的ID、将笔记摘要列处理后作为搜索建议的文本等，同时设置了图标、意图动作、意图数据类型等相关信息。
*/
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
@ -72,46 +76,53 @@ public class NotesProvider extends ContentProvider {
+ R.drawable.search_result + " AS " + SearchManager.SUGGEST_COLUMN_ICON_1 + ","
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
// 定义搜索笔记摘要的查询SQL语句模板，用于根据给定的搜索字符串在非回收站的笔记中查找匹配的笔记信息
private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+ " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
+ " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
// 在ContentProvider创建时调用，获取NotesDatabaseHelper的单例实例，用于后续数据库操作，返回true表示初始化成功
@Override
public boolean onCreate() {
mHelper = NotesDatabaseHelper.getInstance(getContext());
return true;
}
// 根据传入的Uri等参数执行查询操作，根据不同的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;
// 通过UriMatcher匹配传入的Uri，根据匹配结果执行不同的查询逻辑
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 查询笔记表，使用传入的投影、选择条件等参数进行查询
c = db.query(TABLE.NOTE, projection, selection, selectionArgs, null, null,
sortOrder);
break;
case URI_NOTE_ITEM:
// 获取具体笔记项的ID（从Uri路径中解析），然后根据该ID构建更精确的查询条件进行查询
id = uri.getPathSegments().get(1);
c = db.query(TABLE.NOTE, projection, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
break;
case URI_DATA:
// 查询数据表，同样使用传入的相关参数进行查询
c = db.query(TABLE.DATA, projection, selection, selectionArgs, null, null,
sortOrder);
break;
case URI_DATA_ITEM:
// 获取具体数据项的ID（从Uri路径中解析），然后基于该ID构建查询条件查询数据表
id = uri.getPathSegments().get(1);
c = db.query(TABLE.DATA, projection, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs, null, null, sortOrder);
break;
case URI_SEARCH:
case URI_SEARCH_SUGGEST:
// 对于搜索相关的Uri请求，如果传入了排序、投影等额外参数则抛出异常，因为搜索操作有其固定的逻辑
if (sortOrder != null || projection != null) {
throw new IllegalArgumentException(
"do not specify sortOrder, selection, selectionArgs, or projection" + "with this query");
@ -119,10 +130,12 @@ public class NotesProvider extends ContentProvider {
String searchString = null;
if (mMatcher.match(uri) == URI_SEARCH_SUGGEST) {
// 如果是搜索建议的Uri且路径中有搜索字符串，则获取该字符串
if (uri.getPathSegments().size() > 1) {
searchString = uri.getPathSegments().get(1);
}
} else {
// 否则从Uri的查询参数中获取名为"pattern"的搜索字符串
searchString = uri.getQueryParameter("pattern");
}
@ -131,7 +144,9 @@ public class NotesProvider extends ContentProvider {
}
try {
// 格式化搜索字符串，添加通配符用于模糊匹配查询
searchString = String.format("%%%s%%", searchString);
// 使用格式化后的搜索字符串执行原始查询，查询符合条件的笔记信息
c = db.rawQuery(NOTES_SNIPPET_SEARCH_QUERY,
new String[] { searchString });
} catch (IllegalStateException ex) {
@ -141,21 +156,25 @@ public class NotesProvider extends ContentProvider {
default:
throw new IllegalArgumentException("Unknown URI " + uri);
}
// 如果查询结果游标不为空，设置其通知Uri，以便在数据变化时能收到通知更新相关UI等
if (c != null) {
c.setNotificationUri(getContext().getContentResolver(), uri);
}
return c;
}
// 根据传入的Uri和数据值，向相应的数据库表（笔记表或数据表）插入数据，并返回插入后生成的新记录的Uri
@Override
public Uri insert(Uri uri, ContentValues values) {
SQLiteDatabase db = mHelper.getWritableDatabase();
long dataId = 0, noteId = 0, insertedId = 0;
// 通过UriMatcher匹配Uri，根据匹配结果执行不同的插入逻辑
switch (mMatcher.match(uri)) {
case URI_NOTE:
// 向笔记表插入数据，获取插入后生成的记录ID
insertedId = noteId = db.insert(TABLE.NOTE, null, values);
break;
case URI_DATA:
// 如果插入的数据中包含笔记ID，则获取该ID，然后向数据表插入数据并获取插入后的记录ID
if (values.containsKey(DataColumns.NOTE_ID)) {
noteId = values.getAsLong(DataColumns.NOTE_ID);
} else {
@ -167,32 +186,36 @@ public class NotesProvider extends ContentProvider {
throw new IllegalArgumentException("Unknown URI " + uri);
}
// Notify the note uri
// 如果插入的是笔记数据且笔记ID大于0，通知笔记相关的Uri数据发生了变化
if (noteId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null);
}
// 如果插入的是数据且数据ID大于0，通知数据相关的Uri数据发生了变化
// Notify the data uri
if (dataId > 0) {
getContext().getContentResolver().notifyChange(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null);
}
// 返回插入后新记录对应的Uri，通过将插入的记录ID附加到原始Uri上生成
return ContentUris.withAppendedId(uri, insertedId);
}
// 根据传入的Uri和选择条件，从相应的数据库表（笔记表或数据表）中删除数据，并返回删除的记录数量
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
int count = 0;
String id = null;
SQLiteDatabase db = mHelper.getWritableDatabase();
boolean deleteData = false;
// 通过UriMatcher匹配Uri，根据匹配结果执行不同的删除逻辑
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:
// 获取要删除的具体笔记项的ID，先判断是否为不允许删除的系统文件夹（ID小于等于0），如果不是则构建精确的删除条件进行删除操作
id = uri.getPathSegments().get(1);
/**
* ID that smaller than 0 is system folder which is not allowed to
@ -206,10 +229,12 @@ public class NotesProvider extends ContentProvider {
NoteColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
break;
case URI_DATA:
// 直接从数据表中根据选择条件执行删除操作，标记要通知数据相关的Uri变化，并获取删除的记录数量
count = db.delete(TABLE.DATA, selection, selectionArgs);
deleteData = true;
break;
case URI_DATA_ITEM:
// 获取要删除的具体数据项的ID，构建精确的删除条件从数据表中删除数据，同样标记要通知数据相关的Uri变化，并获取删除的记录数量
id = uri.getPathSegments().get(1);
count = db.delete(TABLE.DATA,
DataColumns.ID + "=" + id + parseSelection(selection), selectionArgs);
@ -220,35 +245,42 @@ public class NotesProvider extends ContentProvider {
}
if (count > 0) {
if (deleteData) {
// 如果是更新数据相关操作且有数据被更新，通知笔记相关的Uri数据发生了变化（可能关联的笔记数据有变动）
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
// 通知传入的Uri对应的数据发生了变化
getContext().getContentResolver().notifyChange(uri, null);
}
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;
// 通过UriMatcher匹配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:
// 获取要更新的具体笔记项的ID，调用方法根据该ID等情况更新笔记的版本号，然后构建精确的更新条件对笔记表执行更新操作并获取记录数量
id = uri.getPathSegments().get(1);
increaseNoteVersion(Long.valueOf(id), selection, selectionArgs);
count = db.update(TABLE.NOTE, values, NoteColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs);
break;
case URI_DATA:
// 直接从数据表中根据选择条件执行删除操作，标记要通知数据相关的Uri变化，并获取删除的记录数量
count = db.update(TABLE.DATA, values, selection, selectionArgs);
updateData = true;
break;
case URI_DATA_ITEM:
// 获取要删除的具体数据项的ID，构建精确的删除条件从数据表中删除数据，同样标记要通知数据相关的Uri变化，并获取删除的记录数量
id = uri.getPathSegments().get(1);
count = db.update(TABLE.DATA, values, DataColumns.ID + "=" + id
+ parseSelection(selection), selectionArgs);
@ -260,17 +292,18 @@ public class NotesProvider extends ContentProvider {
if (count > 0) {
if (updateData) {
// 如果是删除数据相关操作且有数据被删除，通知笔记相关的Uri数据发生了变化（可能关联的笔记数据有变动）
getContext().getContentResolver().notifyChange(Notes.CONTENT_NOTE_URI, null);
}
} // 通知传入的Uri对应的数据发生了变化
getContext().getContentResolver().notifyChange(uri, null);
}
return count;
}
// 根据传入的Uri、更新的数据值和选择条件，对相应的数据库表（笔记表或数据表）中的数据进行更新，并返回更新的记录数量
private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
// 根据传入的笔记ID、选择条件和选择参数，构建并执行更新笔记版本号的SQL语句，实现笔记版本号的增加操作
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
StringBuilder sql = new StringBuilder(120);
sql.append("UPDATE ");
@ -292,7 +325,7 @@ public class NotesProvider extends ContentProvider {
}
sql.append(selectString);
}
// 用于获取
mHelper.getWritableDatabase().execSQL(sql.toString());
}

36
src/Notes-master/src/net/micode/notes/gtask/data/MetaData.java
Unescape View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package net.micode.notes.gtask.data;//测试
package net.micode.notes.gtask.data;
import android.database.Cursor;
import android.util.Log;
@ -23,38 +23,51 @@ import net.micode.notes.tool.GTaskStringUtils;
import org.json.JSONException;
import org.json.JSONObject;
// MetaData类继承自Task类，主要用于处理与任务相关的元数据操作，例如设置元数据、获取关联的GID（可能是某种任务相关的唯一标识）等，
// 并且重写了一些父类的方法来适配自身对于元数据处理的特殊逻辑。
public class MetaData extends Task {
// 用于日志输出的标识字符串，其值为类的简单名称，便于在调试和记录运行情况时准确识别相关日志信息
private final static String TAG = MetaData.class.getSimpleName();
// 用于存储与该元数据相关联的GID（可能是Google Tasks等相关任务系统中的任务唯一标识之类的信息），初始化为null
private String mRelatedGid = null;
// 设置元数据的方法，接收一个GID（任务标识）和一个JSONObject类型的元数据信息对象
public void setMeta(String gid, JSONObject metaInfo) {
try {
// 将传入的GID放入元数据信息对象中，对应的键由GTaskStringUtils.META_HEAD_GTASK_ID指定，
// 如果放入过程中出现JSON异常则记录错误日志
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
} catch (JSONException e) {
Log.e(TAG, "failed to put related gid");
}
// 将处理后的元数据信息对象转换为字符串，并调用父类的方法（假设父类有相应的设置笔记内容的方法）设置为笔记内容
setNotes(metaInfo.toString());
// 设置名称为特定的字符串，该字符串由GTaskStringUtils.META_NOTE_NAME指定，可能用于标识这是元数据相关的名称
setName(GTaskStringUtils.META_NOTE_NAME);
}
}
// 获取关联的GID的方法，返回之前存储的mRelatedGid字符串
public String getRelatedGid() {
return mRelatedGid;
}
// 重写父类的方法，用于判断当前的元数据是否值得保存，判断依据是看获取到的笔记内容（通过父类方法获取，可能存储着关键元数据信息）是否为null，
// 如果不为null则表示有值得保存的数据，返回true，否则返回false
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
// 重写父类的方法，用于根据远程的JSON对象来设置自身的内容（包括解析出关联的GID等元数据相关操作）
@Override
public void setContentByRemoteJSON(JSONObject js) {
// 先调用父类的同名方法来执行一些通用的设置内容的基础操作（假设父类该方法有相应逻辑）
super.setContentByRemoteJSON(js);
// 如果获取到的笔记内容不为null（说明有元数据信息）
if (getNotes() != null) {
try {
// 将笔记内容字符串转换为JSONObject对象，以便解析其中的元数据信息
JSONObject metaInfo = new JSONObject(getNotes().trim());
// 从解析后的元数据信息对象中获取关联的GID，并赋值给mRelatedGid成员变量，
// 如果获取过程中出现JSON异常，则记录警告日志并将mRelatedGid设置为null
mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
} catch (JSONException e) {
Log.w(TAG, "failed to get related gid");
@ -62,18 +75,21 @@ public class MetaData extends Task {
}
}
}
// 重写父类的方法，这里明确表示该方法不应该被调用，直接抛出 IllegalAccessError异常，
// 可能是因为对于元数据对象来说，通过本地JSON来设置内容不符合其业务逻辑设计
@Override
public void setContentByLocalJSON(JSONObject js) {
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
}
// 重写父类的方法，同样明确表示该方法不应该被调用，直接抛出 IllegalAccessError异常，
// 可能是因为获取本地JSON对象的操作在元数据对象的业务逻辑中没有对应的合理实现或者不需要这样的操作
@Override
public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
}
// 重写父类的方法，再次明确表示该方法不应该被调用，直接抛出 IllegalAccessError异常，
// 可能是因为获取同步操作相关信息在元数据对象的业务逻辑中没有对应的处理逻辑或者不需要这样的操作
@Override
public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called");

64
src/Notes-master/src/net/micode/notes/gtask/data/Node.java
Unescape View File

@ -13,83 +13,91 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// 包声明，表明该类所属的包名，此处是net.micode.notes.gtask.data包
package net.micode.notes.gtask.data;
import android.database.Cursor;
import org.json.JSONObject;
// 定义抽象类Node，通常作为节点相关数据结构或业务逻辑的抽象表示，
// 具体的节点类可能会继承该抽象类并实现其中的抽象方法
public abstract class Node {
// 定义同步操作的各种类型常量，用于表示不同的同步相关动作
// 表示无同步操作
public static final int SYNC_ACTION_NONE = 0;
// 表示向远程添加的同步操作
public static final int SYNC_ACTION_ADD_REMOTE = 1;
// 表示在本地添加的同步操作
public static final int SYNC_ACTION_ADD_LOCAL = 2;
// 表示从远程删除的同步操作
public static final int SYNC_ACTION_DEL_REMOTE = 3;
// 表示从本地删除的同步操作
public static final int SYNC_ACTION_DEL_LOCAL = 4;
// 表示更新远程的同步操作
public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
// 表示更新本地的同步操作
public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
// 表示更新冲突的同步操作，可能在同步过程中出现两端数据不一致等冲突情况时用到
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
// 表示同步操作出现错误的情况
public static final int SYNC_ACTION_ERROR = 8;
// 用于存储节点的全局唯一标识符（可能是对应任务等的唯一标识），初始化为null
private String mGid;
// 存储节点的名称，初始化为空字符串
private String mName;
// 记录节点最后一次被修改的时间戳，初始化为0
private long mLastModified;
// 标记该节点是否已被删除，初始化为false
private boolean mDeleted;
// 默认构造函数，用于初始化Node对象的各个属性的初始值
public Node() {
mGid = null;
mName = "";
mLastModified = 0;
mDeleted = false;
}
// 抽象方法，用于获取创建动作对应的JSONObject，具体的创建动作由actionId参数指定，
// 不同的子类需要根据自身业务逻辑实现该方法来构造相应的创建动作数据
public abstract JSONObject getCreateAction(int actionId);
// 抽象方法，用于获取更新动作对应的JSONObject，根据传入的actionId来确定具体的更新动作，
// 子类需实现该方法以按照实际情况生成合适的更新动作相关的JSON数据
public abstract JSONObject getUpdateAction(int actionId);
// 抽象方法，根据远程传来的JSONObject数据设置节点的内容，
// 具体的设置逻辑由继承该抽象类的子类来实现，以适配不同类型节点的数据解析和设置
public abstract void setContentByRemoteJSON(JSONObject js);
// 抽象方法，根据本地的JSONObject数据设置节点的内容，同样子类要实现该方法来处理本地数据到节点内容的设置
public abstract void setContentByLocalJSON(JSONObject js);
// 抽象方法，从节点当前内容获取对应的本地JSON表示形式，
// 子类需根据自身保存的数据结构等情况将节点内容转换为合适的JSONObject返回
public abstract JSONObject getLocalJSONFromContent();
// 抽象方法，根据给定的Cursor（通常用于从数据库查询结果中获取数据）来确定节点的同步操作类型，
// 子类要实现该方法以解析Cursor中的数据从而判断出对应的同步动作
public abstract int getSyncAction(Cursor c);
// 设置节点的全局唯一标识符（Gid）的方法
public void setGid(String gid) {
this.mGid = gid;
}
}// 设置节点名称的方法
public void setName(String name) {
this.mName = name;
}
// 设置节点最后一次修改时间戳的方法
public void setLastModified(long lastModified) {
this.mLastModified = lastModified;
}
// 设置节点是否已删除的标记的方法
public void setDeleted(boolean deleted) {
this.mDeleted = deleted;
}
// 获取节点的全局唯一标识符（Gid）的方法
public String getGid() {
return this.mGid;
}
// 获取节点名称的方法
public String getName() {
return this.mName;
}
// 获取节点最后一次修改时间戳的方法
public long getLastModified() {
return this.mLastModified;
}

84
src/Notes-master/src/net/micode/notes/gtask/data/SqlData.java
Unescape View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// 包声明，表明该类所属的包名为net.micode.notes.gtask.data
package net.micode.notes.gtask.data;
import android.content.ContentResolver;
@ -33,45 +33,48 @@ import net.micode.notes.gtask.exception.ActionFailureException;
import org.json.JSONException;
import org.json.JSONObject;
// SqlData类，主要用于处理与数据库相关的数据操作，可能涉及到将数据在数据库和JSON格式之间进行转换、保存等功能
public class SqlData {
// 用于日志记录的标签，取当前类的简单名称
private static final String TAG = SqlData.class.getSimpleName();
// 表示无效的ID值，通常用于初始化或者标识某个非法的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
};
// 定义常量，表示在投影数组中ID列对应的索引位置，方便后续从查询结果的Cursor中获取对应列的数据
public static final int DATA_ID_COLUMN = 0;
// 定义常量，表示在投影数组中MIME_TYPE列对应的索引位置
public static final int DATA_MIME_TYPE_COLUMN = 1;
// 定义常量，表示在投影数组中CONTENT列对应的索引位置
public static final int DATA_CONTENT_COLUMN = 2;
// 定义常量，表示在投影数组中DATA1列对应的索引位置
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
// 定义常量，表示在投影数组中DATA3列对应的索引位置
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
// 用于与内容提供器进行交互，以便执行数据库相关的操作，如查询、插入、更新等
private ContentResolver mContentResolver;
// 标记当前操作是否是创建新数据的操作，初始化为true
private boolean mIsCreate;
// 存储数据对应的ID，初始化为无效ID值
private long mDataId;
// 存储数据的MIME类型，初始化为默认的Note类型（可能对应某种笔记的数据类型）
private String mDataMimeType;
// 存储数据的具体内容，初始化为空字符串
private String mDataContent;
// 存储数据内容中相关的一个长整型数据（具体含义可能根据业务而定），初始化为0
private long mDataContentData1;
// 存储数据内容中相关的一个字符串数据（具体含义可能根据业务而定），初始化为空字符串
private String mDataContentData3;
// 用于存储要进行差异更新的数据值，即记录数据有变化的部分，初始化为一个新的ContentValues对象
private ContentValues mDiffDataValues;
// 构造函数，用于创建一个新的SqlData对象，通常在创建新数据时使用
// 接收一个Context上下文对象，用于获取ContentResolver来操作数据库
public SqlData(Context context) {
// 获取上下文对应的ContentResolver，以便后续进行数据库操作
mContentResolver = context.getContentResolver();
mIsCreate = true;
mDataId = INVALID_ID;
@ -81,14 +84,15 @@ public class SqlData {
mDataContentData3 = "";
mDiffDataValues = new ContentValues();
}
// 另一个构造函数，用于根据已有的Cursor（通常是从数据库查询返回的结果集）来创建SqlData对象，常用于读取已有数据
// 接收一个Context上下文对象和一个Cursor对象，用于初始化该对象的各个属性
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
loadFromCursor(c);
mDiffDataValues = new ContentValues();
}
// 私有方法，用于从给定的Cursor中加载数据到当前对象的各个属性中，根据之前定义的列索引常量来获取对应列的数据
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@ -96,40 +100,47 @@ public class SqlData {
mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
// 用于根据传入的JSONObject来设置当前对象的数据内容，比较传入数据与当前已有数据的差异，
// 将有差异的部分放入mDiffDataValues中，以便后续进行更新操作
public void setContent(JSONObject js) throws JSONException {
// 获取JSON对象中ID字段的值，如果不存在则使用无效ID值
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
// 如果是创建操作或者当前对象的ID与传入JSON中的ID不同，则将新的ID放入差异数据值中
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
}
mDataId = dataId;
// 获取JSON对象中MIME_TYPE字段的值，如果不存在则使用默认的Note类型
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE;
// 如果是创建操作或者当前对象的MIME_TYPE与传入JSON中的不同，则将新的MIME_TYPE放入差异数据值中
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
}
} // 获取JSON对象中CONTENT字段的值，如果不存在则使用空字符串
mDataMimeType = dataMimeType;
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
// 如果是创建操作或者当前对象的CONTENT与传入JSON中的不同，则将新的CONTENT放入差异数据值中
if (mIsCreate || !mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent);
}
mDataContent = dataContent;
// 获取JSON对象中DATA1字段的值，如果不存在则使用0
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
// 如果是创建操作或者当前对象的DATA1值与传入JSON中的不同，则将新的DATA1放入差异数据值中
if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
}
} // 获取JSON对象中DATA3字段的值，如果不存在则使用空字符串
mDataContentData1 = dataContentData1;
// 如果是创建操作或者当前对象的DATA3与传入JSON中的不同，则将新的DATA3放入差异数据值中
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
}
mDataContentData3 = dataContentData3;
}
// 用于获取当前对象的数据内容，并将其转换为JSONObject格式返回，
// 如果当前操作是创建操作（还未在数据库中创建该数据），则记录错误日志并返回null
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
@ -143,46 +154,49 @@ public class SqlData {
js.put(DataColumns.DATA3, mDataContentData3);
return js;
}
// 用于将当前对象的数据提交到数据库中，根据是创建操作还是更新操作执行不同的逻辑
public void commit(long noteId, boolean validateVersion, long version) {
if (mIsCreate) {
// 如果是创建操作，且当前数据ID是无效ID且差异数据值中包含ID字段，则移除该ID字段（可能有默认生成机制）
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
}
// 将关联的笔记ID添加到差异数据值中
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
// 使用ContentResolver插入数据到指定的数据库URI，并获取插入后生成的URI
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 {
} else { // 如果是更新操作，且差异数据值中有数据需要更新
if (mDiffDataValues.size() > 0) {
int result = 0;
if (!validateVersion) {
if (!validateVersion) {// 如果不需要验证版本，则直接更新指定ID的数据
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else {
} else {// 如果需要验证版本，则根据指定的版本条件更新数据，通过SQL语句的条件筛选来确保更新的准确性
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
String.valueOf(noteId), String.valueOf(version)
});
}
} // 如果更新结果为0（即没有数据被更新），记录警告日志，提示可能用户在同步时更新了笔记
if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing");
}
}
}
// 清空差异数据值，准备下一次的数据操作
mDiffDataValues.clear();
mIsCreate = false;
}
// 获取当前数据对象的ID值的方法
public long getId() {
return mDataId;
}

151
src/Notes-master/src/net/micode/notes/gtask/data/SqlNote.java
Unescape View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// 包声明，表明该类所属的包名为net.micode.notes.gtask.data
package net.micode.notes.gtask.data;
import android.appwidget.AppWidgetManager;
@ -37,12 +37,12 @@ import org.json.JSONObject;
import java.util.ArrayList;
public class SqlNote {
// SqlNote类，主要用于处理与笔记相关的数据操作，包括从数据库读取笔记信息、设置笔记内容、将笔记内容转换为JSON格式以及将笔记数据提交到数据库等功能
public class SqlNote {// 用于日志记录的标签，取当前类的简单名称
private static final String TAG = SqlNote.class.getSimpleName();
// 表示无效的ID值，通常用于初始化或者标识某个非法的ID状态
private static final int INVALID_ID = -99999;
// 定义一个字符串数组，用于指定从数据库查询笔记数据时的投影（即要查询的列），包含了笔记相关的多个列名
public static final String[] PROJECTION_NOTE = new String[] {
NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@ -51,77 +51,80 @@ public class SqlNote {
NoteColumns.LOCAL_MODIFIED, NoteColumns.ORIGIN_PARENT_ID, NoteColumns.GTASK_ID,
NoteColumns.VERSION
};
// 定义常量，表示在投影数组中ID列对应的索引位置，方便后续从查询结果的Cursor中获取对应列的数据
public static final int ID_COLUMN = 0;
// 定义常量，表示在投影数组中ALERTED_DATE列对应的索引位置
public static final int ALERTED_DATE_COLUMN = 1;
// 定义常量，表示在投影数组中BG_COLOR_ID列对应的索引位置
public static final int BG_COLOR_ID_COLUMN = 2;
// 定义常量，表示在投影数组中CREATED_DATE列对应的索引位置
public static final int CREATED_DATE_COLUMN = 3;
// 定义常量，表示在投影数组中HAS_ATTACHMENT列对应的索引位置
public static final int HAS_ATTACHMENT_COLUMN = 4;
// 定义常量，表示在投影数组中MODIFIED_DATE列对应的索引位置
public static final int MODIFIED_DATE_COLUMN = 5;
// 定义常量，表示在投影数组中NOTES_COUNT列对应的索引位置
public static final int NOTES_COUNT_COLUMN = 6;
// 定义常量，表示在投影数组中PARENT_ID列对应的索引位置
public static final int PARENT_ID_COLUMN = 7;
// 定义常量，表示在投影数组中SNIPPET列对应的索引位置
public static final int SNIPPET_COLUMN = 8;
// 定义常量，表示在投影数组中TYPE列对应的索引位置
public static final int TYPE_COLUMN = 9;
// 定义常量，表示在投影数组中WIDGET_ID列对应的索引位置
public static final int WIDGET_ID_COLUMN = 10;
// 定义常量，表示在投影数组中WIDGET_TYPE列对应的索引位置
public static final int WIDGET_TYPE_COLUMN = 11;
// 定义常量，表示在投影数组中SYNC_ID列对应的索引位置
public static final int SYNC_ID_COLUMN = 12;
// 定义常量，表示在投影数组中LOCAL_MODIFIED列对应的索引位置
public static final int LOCAL_MODIFIED_COLUMN = 13;
// 定义常量，表示在投影数组中ORIGIN_PARENT_ID列对应的索引位置
public static final int ORIGIN_PARENT_ID_COLUMN = 14;
// 定义常量，表示在投影数组中GTASK_ID列对应的索引位置
public static final int GTASK_ID_COLUMN = 15;
// 定义常量，表示在投影数组中VERSION列对应的索引位置
public static final int VERSION_COLUMN = 16;
// 上下文对象，用于获取系统资源、执行与应用上下文相关的操作等
private Context mContext;
// 用于与内容提供器进行交互，以便执行数据库相关的操作，如查询、插入、更新等
private ContentResolver mContentResolver;
// 标记当前操作是否是创建新笔记的操作，初始化为true
private boolean mIsCreate;
// 存储笔记的ID，初始化为无效ID值
private long mId;
// 存储笔记的提醒日期（时间戳相关，具体含义根据业务而定），初始化为0
private long mAlertDate;
// 存储笔记的背景颜色ID，初始化为通过ResourceParser获取的默认背景颜色ID
private int mBgColorId;
// 存储笔记的创建日期（时间戳），初始化为当前系统时间
private long mCreatedDate;
// 存储笔记是否有附件的标识，0表示没有，初始化为0
private int mHasAttachment;
// 存储笔记的最后修改日期（时间戳），初始化为当前系统时间
private long mModifiedDate;
// 存储笔记的父级ID（可能用于表示笔记的层级关系等），初始化为0
private long mParentId;
// 存储笔记的摘要信息（简短描述等），初始化为空字符串
private String mSnippet;
// 存储笔记的类型，初始化为普通笔记类型（Notes.TYPE_NOTE）
private int mType;
// 存储笔记关联的桌面小部件ID，初始化为无效的小部件ID
private int mWidgetId;
// 存储笔记关联的桌面小部件类型，初始化为无效的小部件类型（Notes.TYPE_WIDGET_INVALIDE）
private int mWidgetType;
// 存储笔记的原始父级ID（具体用途可能与笔记的来源、历史关系等相关），初始化为0
private long mOriginParent;
// 存储笔记的版本号，初始化为0
private long mVersion;
// 用于存储要进行差异更新的笔记数据值，即记录笔记数据有变化的部分，初始化为一个新的ContentValues对象
private ContentValues mDiffNoteValues;
// 存储与该笔记相关的数据列表（可能是笔记包含的多个具体数据项等，每个数据项用SqlData类表示）
private ArrayList<SqlData> mDataList;
// 构造函数，用于创建一个新的SqlNote对象，通常在创建新笔记时使用
// 接收一个Context上下文对象，用于获取ContentResolver等资源来操作数据库以及进行其他相关操作
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -142,7 +145,8 @@ public class SqlNote {
mDiffNoteValues = new ContentValues();
mDataList = new ArrayList<SqlData>();
}
// 构造函数，用于根据已有的Cursor（通常是从数据库查询返回的结果集）来创建SqlNote对象，常用于读取已有笔记数据
// 接收一个Context上下文对象和一个Cursor对象，用于初始化该对象的各个属性
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -153,7 +157,8 @@ public class SqlNote {
loadDataContent();
mDiffNoteValues = new ContentValues();
}
// 构造函数，用于根据指定的笔记ID从数据库中加载笔记数据来创建SqlNote对象
// 接收一个Context上下文对象和一个笔记ID（long类型），用于初始化该对象的各个属性
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -165,10 +170,11 @@ public class SqlNote {
mDiffNoteValues = new ContentValues();
}
// 私有方法，根据给定的笔记ID从数据库中查询并加载笔记数据到当前对象的各个属性中，通过调用另一个loadFromCursor方法实现具体的属性赋值
private void loadFromCursor(long id) {
Cursor c = null;
try {
try {// 使用ContentResolver根据指定的URI、查询条件（通过ID匹配）查询笔记数据
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(id)
@ -184,7 +190,8 @@ public class SqlNote {
c.close();
}
}
// 私有方法，用于从给定的Cursor中加载笔记数据到当前对象的各个属性中，根据之前定义的列索引常量来获取对应列的数据
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -199,11 +206,13 @@ public class SqlNote {
mWidgetType = c.getInt(WIDGET_TYPE_COLUMN);
mVersion = c.getLong(VERSION_COLUMN);
}
// 私有方法，用于加载与当前笔记相关的数据内容（具体数据项，用SqlData类表示），通过查询数据库并将结果封装到SqlData对象中，添加到mDataList列表里
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
try {
try {
// 使用ContentResolver根据指定的URI、查询条件（通过笔记ID匹配）查询与笔记相关的数据
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
String.valueOf(mId)
@ -225,6 +234,8 @@ public class SqlNote {
c.close();
}
}
// 用于根据传入的JSONObject来设置当前笔记对象的数据内容，根据笔记类型（如普通笔记、文件夹等）进行不同的处理，
// 将有差异的部分放入mDiffNoteValues中，以便后续进行更新操作，返回设置是否成功的布尔值
public boolean setContent(JSONObject js) {
try {
@ -232,7 +243,7 @@ public class SqlNote {
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
// for folder we can only update the snnipet and type// 如果是文件夹类型，只能更新摘要和类型信息
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
@ -247,6 +258,7 @@ public class SqlNote {
}
mType = type;
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
// 如果是普通笔记类型
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) {
@ -330,24 +342,24 @@ public class SqlNote {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
}
mOriginParent = originParent;
// 遍历JSON数组中的每个数据项（对应笔记包含的具体数据内容）
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
SqlData sqlData = null;
SqlData sqlData = null; // 如果数据项中有ID字段，尝试在已有的数据列表中查找对应ID的数据对象
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) {
if (dataId == temp.getId()) {
sqlData = temp;
}
}
}// 如果未找到，则创建一个新的SqlData对象，并添加到数据列表中
}
if (sqlData == null) {
sqlData = new SqlData(mContext);
mDataList.add(sqlData);
}
// 调用SqlData对象的方法设置其具体内容
sqlData.setContent(data);
}
}
@ -358,7 +370,8 @@ public class SqlNote {
}
return true;
}
// 用于获取当前笔记对象的数据内容，并将其转换为JSONObject格式返回，
// 如果当前操作是创建操作（还未在数据库中创建该笔记），则记录错误日志并返回null
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
@ -406,46 +419,47 @@ public class SqlNote {
}
return null;
}
// 设置笔记的父级ID的方法，同时将该变化记录到差异更新数据值中，以便后续更新数据库时使用
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
// 设置笔记的Gtask ID（具体含义可能与相关任务关联等有关）的方法，将该值记录到差异更新数据值中
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
}
// 设置笔记的同步ID的方法，将该值记录到差异更新数据值中
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
}
// 重置笔记的本地修改标记（将其设置为0）的方法，通过更新差异数据值来实现
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
// 获取笔记ID的方法
public long getId() {
return mId;
}
// 获取笔记父级ID的方法
public long getParentId() {
return mParentId;
}
// 获取笔记摘要信息的方法
public String getSnippet() {
return mSnippet;
}
// 判断笔记是否为普通笔记类型的方法，返回布尔值
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
}
// 用于将当前笔记对象的数据提交到数据库中，根据是创建操作还是更新操作执行不同的逻辑，
// 同时也会处理与之关联的数据（通过调用SqlData的commit方法）的提交操作
public void commit(boolean validateVersion) {
if (mIsCreate) {
if (mIsCreate) {// 如果是创建操作，且当前笔记ID是无效ID且差异数据值中包含ID字段，则移除该ID字段（可能有默认生成机制）
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID);
}
// 使用ContentResolver插入笔记数据到指定的数据库URI，并获取插入后生成的URI
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
mId = Long.valueOf(uri.getPathSegments().get(1));
@ -458,18 +472,19 @@ public class SqlNote {
}
if (mType == Notes.TYPE_NOTE) {
// 如果是普通笔记类型，遍历与之关联的数据列表，调用每个SqlData对象的commit方法提交数据
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
}
}
} else {
} else {// 如果是更新操作
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
Log.e(TAG, "No such note");
throw new IllegalStateException("Try to update note with invalid id");
}
if (mDiffNoteValues.size() > 0) {
mVersion ++;
int result = 0;
int result = 0;// 根据是否验证版本来决定更新数据库的条件
if (!validateVersion) {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
@ -493,12 +508,12 @@ public class SqlNote {
}
}
}
// 重新从数据库加载笔记数据，刷新本地信息（通过调用相关加载方法）
// refresh local info
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
// 清空差异数据值，准备下一次的数据操作
mDiffNoteValues.clear();
mIsCreate = false;
}

111
src/Notes-master/src/net/micode/notes/gtask/data/Task.java
Unescape View File

@ -30,21 +30,22 @@ import net.micode.notes.tool.GTaskStringUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
// Task类继承自抽象类Node，代表一个任务相关的实体，包含任务自身的各种属性以及与任务操作相关的方法，
// 例如创建、更新任务的JSON表示，从JSON数据设置任务内容等功能，用于处理任务相关的数据逻辑
public class Task extends Node {
public class Task extends Node { // 用于日志记录的标签，取当前类的简单名称
private static final String TAG = Task.class.getSimpleName();
// 标记任务是否已完成，初始化为false
private boolean mCompleted;
// 存储任务的备注信息（可能是对任务的详细描述等），初始化为null
private String mNotes;
// 存储任务的元信息（以JSONObject形式，具体内容结构可能根据业务而定），初始化为null
private JSONObject mMetaInfo;
// 指向当前任务的前一个兄弟任务（在任务列表等场景下用于表示顺序关系），初始化为null
private Task mPriorSibling;
// 指向当前任务所属的父任务列表（表明任务的归属层级关系），初始化为null
private TaskList mParent;
// 构造函数，调用父类（Node类）的构造函数进行初始化，并对Task类特有的属性进行默认初始化
public Task() {
super();
mCompleted = false;
@ -53,21 +54,24 @@ public class Task extends Node {
mParent = null;
mMetaInfo = null;
}
// 实现抽象类Node中定义的抽象方法，用于获取创建任务的操作对应的JSONObject，该JSON对象包含了创建任务所需的各种信息，
// 如操作类型、任务的基本属性（名称、备注等）、所属父任务等相关信息，按照特定的格式进行组装
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
try {
try { // 设置操作类型为创建任务，使用预定义的字符串常量标识
// action_type
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// 设置操作的唯一标识符（具体业务中用于区分不同的创建操作实例）
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务在父任务列表中的索引位置（通过调用父任务列表的方法获取）
// index
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
// 构建表示任务实体的详细信息的JSONObject，包含任务名称、创建者ID（此处设为"null"，可能需根据实际情况调整）、
// 实体类型（标识为任务类型）以及任务备注（如果存在）等信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
@ -78,17 +82,17 @@ public class Task extends Node {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
// 设置任务所属父任务的全局唯一标识符（Gid）
// parent_id
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
// 设置目标父任务的类型（此处设为组类型，可能与任务的分组、归属等概念相关，具体依业务而定）
// dest_parent_type
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// 设置任务所属列表的全局唯一标识符（通常与父任务列表的Gid一致）
// list_id
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
// 如果存在前一个兄弟任务，则设置其全局唯一标识符，用于表示任务的顺序关系
// prior_sibling_id
if (mPriorSibling != null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
@ -102,21 +106,22 @@ public class Task extends Node {
return js;
}
// 实现抽象类Node中定义的抽象方法，用于获取更新任务的操作对应的JSONObject，包含了更新任务所需的关键信息，
// 如操作类型、任务的唯一标识符、任务实体的更新内容（如名称、备注、是否删除等信息），按照特定格式组装JSON数据
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
try {
try {// 设置操作类型为更新任务，使用预定义的字符串常量标识
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// 设置操作的唯一标识符
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务的全局唯一标识符（用于定位要更新的具体任务）
// id
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// 构建表示任务实体更新内容的JSONObject，包含任务名称、任务备注（如果存在）以及任务是否已删除的标记等信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
@ -134,35 +139,38 @@ public class Task extends Node {
return js;
}
// 实现抽象类Node中定义的抽象方法，用于根据远程传来的JSONObject数据设置任务的内容，
// 从JSON对象中解析出任务的各个属性值（如ID、最后修改时间、名称、备注、是否删除、是否完成等）并设置到当前任务对象中，
// 如果解析过程出现JSONException异常，则记录错误日志并抛出相应异常
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
try {// 从JSON对象中获取任务的全局唯一标识符（Gid）并设置到当前任务对象中
// id
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// 从JSON对象中获取任务最后一次修改的时间戳并设置到当前任务对象中
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// 从JSON对象中获取任务的名称并设置到当前任务对象中
// name
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
// 从JSON对象中获取任务的备注信息并设置到当前任务对象中
// notes
if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
}
// 从JSON对象中获取任务是否已删除的标记并设置到当前任务对象中
// deleted
if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
}
// 从JSON对象中获取任务是否已完成的标记并设置到当前任务对象中
// completed
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
@ -174,7 +182,10 @@ public class Task extends Node {
}
}
}
// 实现抽象类Node中定义的抽象方法，用于根据本地的JSONObject数据设置任务的内容，
// 首先进行一些基本的校验（判断JSON对象是否可用，是否包含必要的头部信息等），然后尝试从JSON数据中解析出笔记类型，
// 如果类型为普通笔记类型，则遍历数据数组，找到MIME类型为笔记类型的数据项，从中获取内容并设置为任务的名称，
// 如果解析过程出现JSONException异常，则记录错误日志
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
@ -203,11 +214,14 @@ public class Task extends Node {
e.printStackTrace();
}
}
// 实现抽象类Node中定义的抽象方法，用于从任务当前内容获取对应的本地JSON表示形式，
// 根据任务的元信息是否存在分为两种情况处理：如果是新创建的任务（元信息为空），则按照一定格式构建包含任务名称的JSON对象；
// 如果是已同步过的任务（元信息不为空），则从元信息中提取相关数据并更新任务名称所在的数据项，最后返回构建好的JSON对象，
// 如果在构建JSON对象过程中出现JSONException异常，则记录错误日志并返回null
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
if (mMetaInfo == null) {
if (mMetaInfo == null) { // 新任务创建自网络（可能表示从远程创建后还未完全同步等情况）
// new task created from web
if (name == null) {
Log.w(TAG, "the note seems to be an empty one");
@ -224,7 +238,7 @@ public class Task extends Node {
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
return js;
} else {
} else { // 已同步的任务（已经有过同步操作，存在相关元信息）
// synced task
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
@ -246,7 +260,8 @@ public class Task extends Node {
return null;
}
}
// 用于设置任务的元信息，将传入的MetaData对象中的笔记信息（如果不为空且可转换为JSONObject）转换为JSONObject并赋值给mMetaInfo属性，
// 如果转换过程出现JSONException异常，则记录警告日志并将mMetaInfo设为null
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
try {
@ -257,7 +272,9 @@ public class Task extends Node {
}
}
}
// 实现抽象类Node中定义的抽象方法，用于根据给定的Cursor（通常用于从数据库查询结果中获取数据）来确定任务的同步操作类型，
// 通过一系列的条件判断来分析任务在本地和远程数据之间的差异情况，从而确定是无同步操作、更新本地、更新远程、更新冲突还是出现错误等同步动作，
// 如果在判断过程中出现异常，则记录错误日志并返回表示错误的同步操作类型
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
@ -274,25 +291,30 @@ public class Task extends Node {
Log.w(TAG, "remote note id seems to be deleted");
return SYNC_ACTION_UPDATE_LOCAL;
}
// 验证笔记的ID是否匹配（本地数据库中的ID与从元信息中获取的远程ID进行比较）
// validate the note id now
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
Log.w(TAG, "note id doesn't match");
return SYNC_ACTION_UPDATE_LOCAL;
}
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// 本地没有更新（通过判断本地修改标记是否为0来确定）
// there is no local update
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// 两边都没有更新（本地同步ID与任务最后修改时间戳相同）
// no update both side
return SYNC_ACTION_NONE;
} else {
// 应用远程到本地（本地没有更新但远程有更新，需将远程数据应用到本地）
// apply remote to local
return SYNC_ACTION_UPDATE_LOCAL;
}
} else {
// 验证任务的Gtask ID是否匹配（本地数据库中的Gtask ID与当前任务对象的Gid进行比较）
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
// 只有本地修改（本地修改了但远程没有更新，只需将本地修改同步到远程）
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
@ -310,36 +332,37 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
// 判断任务是否值得保存的方法，根据任务的元信息是否存在、任务名称以及任务备注是否非空（去除空格后长度大于0）来综合判断，
// 如果满足上述条件之一，则认为任务值得保存，返回true，否则返回false
public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0);
}
// 设置任务是否完成的方法，用于更新任务的完成状态
public void setCompleted(boolean completed) {
this.mCompleted = completed;
}
// 设置任务备注信息的方法，用于更新任务的备注内容
public void setNotes(String notes) {
this.mNotes = notes;
}
// 设置任务前一个兄弟任务的方法，用于建立任务之间的顺序关联
public void setPriorSibling(Task priorSibling) {
this.mPriorSibling = priorSibling;
}
// 设置任务所属父任务列表的方法，用于明确任务的层级归属关系
public void setParent(TaskList parent) {
this.mParent = parent;
}
// 获取任务是否完成的方法，返回任务的完成状态（true表示已完成，false表示未完成）
public boolean getCompleted() {
return this.mCompleted;
}
// 获取任务备注信息的方法，返回任务的备注内容
public String getNotes() {
return this.mNotes;
}
// 获取任务所属父任务列表的方法，返回指向当前任务所属父任务列表的引用
public Task getPriorSibling() {
return this.mPriorSibling;
}

99
src/Notes-master/src/net/micode/notes/gtask/data/TaskList.java
Unescape View File

@ -28,35 +28,41 @@ import org.json.JSONException;
import org.json.JSONObject;
import java.util.ArrayList;
// TaskList类继承自抽象类Node，代表一个任务列表相关的实体，包含任务列表自身的各种属性以及与任务列表操作相关的方法，
// 例如创建、更新任务列表的JSON表示，从JSON数据设置任务列表内容，对任务列表中的子任务进行添加、删除、移动等操作的功能，用于处理任务列表相关的数据逻辑
public class TaskList extends Node {
// 用于日志记录的标签，取当前类的简单名称
private static final String TAG = TaskList.class.getSimpleName();
// 存储任务列表的索引（具体含义可能与任务列表在某个整体结构中的顺序、位置等相关，依业务而定），初始化为1
private int mIndex;
// 存储该任务列表包含的所有子任务，以ArrayList形式存储，初始化为一个空的ArrayList
private ArrayList<Task> mChildren;
// 构造函数，调用父类（Node类）的构造函数进行初始化，并对TaskList类特有的属性进行默认初始化，创建一个空的任务列表对象并设置初始索引值
public TaskList() {
super();
mChildren = new ArrayList<Task>();
mIndex = 1;
}
// 实现抽象类Node中定义的抽象方法，用于获取创建任务列表的操作对应的JSONObject，该JSON对象包含了创建任务列表所需的各种信息，
// 如操作类型、操作的唯一标识符、任务列表的索引位置、任务列表实体的基本属性（名称、创建者ID、实体类型等），按照特定的格式进行组装
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
try {
try {
// 设置操作类型为创建任务列表，使用预定义的字符串常量标识
// action_type
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// 设置操作的唯一标识符（具体业务中用于区分不同的创建操作实例）
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务列表的索引位置
// index
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
// 构建表示任务列表实体的详细信息的JSONObject，包含任务列表名称、创建者ID（此处设为"null"，可能需根据实际情况调整）、
// 实体类型（标识为组类型，表示任务列表在整体结构中的类型为组）等信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
@ -73,21 +79,24 @@ public class TaskList extends Node {
return js;
}
// 实现抽象类Node中定义的抽象方法，用于获取更新任务列表的操作对应的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);
// 设置操作的唯一标识符
// action_id
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// 设置任务列表的全局唯一标识符（用于定位要更新的具体任务列表）
// id
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// 构建表示任务列表实体更新内容的JSONObject，包含任务列表名称以及任务列表是否已删除的标记等信息
// entity_delta
JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
@ -101,21 +110,24 @@ public class TaskList extends Node {
}
return js;
}
} // 实现抽象类Node中定义的抽象方法，用于根据远程传来的JSONObject数据设置任务列表的内容，
// 从JSON对象中解析出任务列表的各个属性值（如ID、最后修改时间、名称等）并设置到当前任务列表对象中，
// 如果解析过程出现JSONException异常，则记录错误日志并抛出相应异常
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
// 从JSON对象中获取任务列表的全局唯一标识符（Gid）并设置到当前任务列表对象中
// id
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// 从JSON对象中获取任务列表最后一次修改的时间戳并设置到当前任务列表对象中
// last_modified
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// 从JSON对象中获取任务列表的名称并设置到当前任务列表对象中
// name
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
@ -128,7 +140,12 @@ public class TaskList extends Node {
}
}
}
// 实现抽象类Node中定义的抽象方法，用于根据本地的JSONObject数据设置任务列表的内容，
// 首先进行一些基本的校验（判断JSON对象是否可用，是否包含必要的头部信息等），然后根据笔记类型进行不同的处理：
// 如果是文件夹类型，从JSON中获取摘要信息并设置任务列表名称（添加特定前缀）；
// 如果是系统类型，根据特定的系统文件夹ID设置对应的名称；
// 如果类型不符合预期，则记录错误日志，
// 如果解析过程出现JSONException异常，则记录错误日志并打印异常堆栈信息
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
@ -156,7 +173,9 @@ public class TaskList extends Node {
e.printStackTrace();
}
}
// 实现抽象类Node中定义的抽象方法，用于从任务列表当前内容获取对应的本地JSON表示形式，
// 按照特定格式构建包含任务列表名称和类型信息的JSON对象，根据名称是否包含特定前缀来判断并设置类型（文件夹类型或系统类型），
// 如果构建JSON对象过程中出现JSONException异常，则记录错误日志并返回null
public JSONObject getLocalJSONFromContent() {
try {
JSONObject js = new JSONObject();
@ -182,28 +201,37 @@ public class TaskList extends Node {
return null;
}
}
// 实现抽象类Node中定义的抽象方法，根据给定的Cursor（通常用于从数据库查询结果中获取数据）来确定任务列表的同步操作类型，
// 通过判断本地是否有更新、任务列表的Gtask ID是否匹配以及两边的修改时间戳是否一致等条件，来确定是无同步操作、更新本地、更新远程还是出现错误等同步动作，
// 如果在判断过程中出现异常，则记录错误日志并返回表示错误的同步操作类型，对于文件夹冲突的情况，默认应用本地修改（返回更新远程操作类型）
public int getSyncAction(Cursor c) {
try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// 本地没有更新（通过判断本地修改标记是否为0来确定）
// there is no local update
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// 两边都没有更新（本地同步ID与任务列表最后修改时间戳相同）
// no update both side
return SYNC_ACTION_NONE;
} else {
// 应用远程到本地（本地没有更新但远程有更新，需将远程数据应用到本地）
// apply remote to local
return SYNC_ACTION_UPDATE_LOCAL;
}
} else {
// 验证任务列表的Gtask ID是否匹配（本地数据库中的Gtask ID与当前任务列表对象的Gid进行比较）
// validate gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// 只有本地修改（本地修改了但远程没有更新，只需将本地修改同步到远程）
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
} else {
// 对于文件夹冲突的情况，直接应用本地修改
// for folder conflicts, just apply local modification
return SYNC_ACTION_UPDATE_REMOTE;
}
@ -215,16 +243,19 @@ public class TaskList extends Node {
return SYNC_ACTION_ERROR;
}
// 获取任务列表中子任务的数量的方法，直接返回存储子任务的ArrayList的大小
public int getChildTaskCount() {
return mChildren.size();
}
// 向任务列表中添加子任务的方法，将传入的任务对象添加到子任务列表中，
// 如果任务对象不为空且不在子任务列表中，则添加成功后，设置该任务的前一个兄弟任务（如果列表为空则为null，否则为列表中最后一个任务）以及父任务（当前任务列表），
// 返回添加操作是否成功的布尔值
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));
@ -233,7 +264,11 @@ public class TaskList extends Node {
}
return ret;
}
// 在指定索引位置向任务列表中添加子任务的方法，
// 首先进行索引合法性校验，如果索引无效则记录错误日志并返回false；
// 然后判断任务是否已在列表中，如果不在且任务对象不为空，则将任务添加到指定索引位置，
// 接着更新任务列表中相关任务的前一个兄弟任务关系（设置新添加任务的前一个兄弟任务以及后续任务的前一个兄弟任务指向新添加任务），
// 返回添加操作是否成功的布尔值
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index");
@ -243,7 +278,7 @@ public class TaskList extends Node {
int pos = mChildren.indexOf(task);
if (task != null && pos == -1) {
mChildren.add(index, task);
// 更新任务列表
// update the task list
Task preTask = null;
Task afterTask = null;
@ -259,7 +294,10 @@ public class TaskList extends Node {
return true;
}
// 从任务列表中移除指定子任务的方法，
// 首先查找任务在列表中的索引位置，如果存在则尝试移除该任务，移除成功后，重置该任务的前一个兄弟任务和父任务为null，
// 并且更新任务列表中后续任务的前一个兄弟任务关系（如果移除位置不是列表末尾），
// 返回移除操作是否成功的布尔值
public boolean removeChildTask(Task task) {
boolean ret = false;
int index = mChildren.indexOf(task);
@ -267,10 +305,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(
@ -280,6 +319,9 @@ public class TaskList extends Node {
}
return ret;
}
// 在任务列表中移动指定子任务到新的索引位置的方法，
// 首先进行索引合法性校验以及判断任务是否在列表中，如果校验不通过则记录错误日志并返回false；
// 如果任务当前位置和目标位置相同则直接返回true，否则先移除该任务再添加到新的索引位置，返回操作是否成功的布尔值
public boolean moveChildTask(Task task, int index) {
@ -298,6 +340,7 @@ public class TaskList extends Node {
return true;
return (removeChildTask(task) && addChildTask(task, index));
}
// 根据任务的全局唯一标识符（Gid）查找子任务的方法，遍历子任务列表，找到Gid匹配的任务并返回，如果没找到则返回null
public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) {
@ -308,10 +351,12 @@ public class TaskList extends Node {
}
return null;
}
// 获取指定子任务在任务列表中的索引位置的方法，通过调用ArrayList的indexOf方法来查找并返回任务在列表中的索引，若不存在则返回 -1
public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task);
}
// 根据索引获取子任务的方法，先对索引进行合法性校验，如果索引无效则记录错误日志并返回null，否则返回对应索引位置的子任务
public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) {
@ -320,7 +365,8 @@ public class TaskList extends Node {
}
return mChildren.get(index);
}
// 根据任务的全局唯一标识符（Gid）获取子任务的方法（与findChildTaskByGid方法功能类似，可能是重复定义或者不同使用场景下的同名方法），
// 遍历子任务列表，找到Gid匹配的任务并返回，如果没找到则返回null
public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) {
if (task.getGid().equals(gid))
@ -328,15 +374,16 @@ public class TaskList extends Node {
}
return null;
}
// 获取整个子任务列表的方法，直接返回存储子任务的ArrayList对象，外部可通过该方法获取任务列表包含的所有子任务进行进一步操作
public ArrayList<Task> getChildTaskList() {
return this.mChildren;
}
// 设置任务列表索引的方法，用于更新任务列表的索引值（可能用于改变其在相关结构中的顺序、位置等属性）
public void setIndex(int index) {
this.mIndex = index;
}
// 获取任务列表索引的方法，用于获取当前任务列表的索引值
public int getIndex() {
return this.mIndex;
}

13
src/Notes-master/src/net/micode/notes/gtask/exception/ActionFailureException.java
Unescape View File

@ -15,18 +15,25 @@
*/
package net.micode.notes.gtask.exception;
// ActionFailureException类继承自RuntimeException，意味着它是一个运行时异常，不需要在方法签名中显式声明抛出该异常（与受检异常相对）
// 此类用于表示在执行某个操作时发生了失败的情况，方便在代码中针对操作失败进行统一的异常处理和错误信息传递
public class ActionFailureException extends RuntimeException {
// 用于序列化版本控制的唯一标识符，在Java的序列化机制中使用，保证不同版本的类在序列化和反序列化时的兼容性
private static final long serialVersionUID = 4425249765923293627L;
// 无参构造函数，调用父类（RuntimeException）的无参构造函数，用于创建一个默认的ActionFailureException实例，
// 通常在不需要传递具体错误信息时使用
public ActionFailureException() {
super();
}
// 带有字符串参数的构造函数，接收一个表示错误信息的字符串参数，调用父类（RuntimeException）的对应构造函数，
// 用于创建一个带有特定错误信息的ActionFailureException实例，方便在出现操作失败时传递相应的错误提示内容
public ActionFailureException(String paramString) {
super(paramString);
}
// 带有字符串参数和Throwable参数的构造函数，接收一个表示错误信息的字符串参数以及一个Throwable对象（通常是导致当前异常的底层异常），
// 调用父类（RuntimeException）的对应构造函数，用于创建一个既能传递自定义错误信息，又能关联底层引发异常原因的ActionFailureException实例，
// 方便在复杂的异常链场景中进行准确的异常追踪和错误分析
public ActionFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

17
src/Notes-master/src/net/micode/notes/gtask/exception/NetworkFailureException.java
Unescape View File

@ -15,18 +15,29 @@
*/
package net.micode.notes.gtask.exception;
// NetworkFailureException类继承自Exception，属于受检异常（Checked Exception），这意味着在方法中如果可能抛出该异常，
// 必须在方法签名中使用throws关键字显式声明，调用该方法的代码也需要进行相应的异常处理（try-catch块或者继续向上抛出）。
// 此类专门用于表示在网络相关操作出现故障、失败时抛出的异常情况，方便对网络故障进行统一的异常处理和错误信息传递。
public class NetworkFailureException extends Exception {
// 用于序列化版本控制的唯一标识符，在Java的序列化机制中发挥作用。当类实现了Serializable接口（Exception类间接实现了该接口），
// 这个标识符可以确保不同版本的类在进行序列化和反序列化操作时能够正确匹配，避免因类结构变化等原因导致的兼容性问题。
private static final long serialVersionUID = 2107610287180234136L;
// 无参构造函数，调用父类（Exception）的无参构造函数，用于创建一个默认的NetworkFailureException实例，
// 一般在不需要传递具体错误信息，仅表示网络出现故障这种通用情况时使用。
public NetworkFailureException() {
super();
}
// 带有字符串参数的构造函数，接收一个表示错误信息的字符串参数，调用父类（Exception）的对应构造函数，
// 这样就可以创建一个带有明确错误提示内容的NetworkFailureException实例，便于在网络操作失败时，
// 根据具体的失败原因传递相应有意义的错误信息给调用者或者进行日志记录等操作。
public NetworkFailureException(String paramString) {
super(paramString);
}
// 带有字符串参数和Throwable参数的构造函数，接收一个表示错误信息的字符串参数以及一个Throwable对象（通常是导致当前网络故障异常的底层异常，
// 比如IOException等更具体的网络相关底层异常），调用父类（Exception）的对应构造函数，
// 此构造函数用于创建一个既能传递自定义的网络故障相关错误信息，又能关联底层引发异常原因的NetworkFailureException实例，
// 在复杂的网络异常处理场景中，方便进行准确的异常追踪、错误分析以及更完善的异常处理逻辑编写。
public NetworkFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

41
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -27,24 +27,33 @@ import android.os.AsyncTask;
import net.micode.notes.R;
import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
// GTaskASyncTask类继承自AsyncTask，用于在后台线程执行一些耗时的操作（通常与远程任务同步相关），并能在操作过程中更新进度、在操作完成后处理结果，
// 同时通过接口回调的方式通知外部操作已完成，还涉及到与通知系统的交互来展示同步状态相关的通知信息
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
// 定义一个静态的整型常量，作为同步相关通知的唯一标识符（ID），用于在通知系统中区分不同的通知，此处固定赋值为5234235
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
// 定义一个内部接口OnCompleteListener，用于定义当异步任务完成时需要执行的回调方法，外部类实现该接口来处理任务完成后的逻辑
public interface OnCompleteListener {
void onComplete();
}
// 存储上下文对象，用于获取系统服务、资源等，方便在类中进行各种与Android系统相关的操作，如创建通知、启动Activity等
private Context mContext;
// 用于管理通知的显示、取消等操作，通过获取系统的通知服务来实例化，负责向用户展示同步进度、结果等相关通知信息
private NotificationManager mNotifiManager;
// 用于管理远程任务相关的操作（可能涉及与服务器交互、任务同步等具体逻辑，具体功能由GTaskManager类实现），通过单例模式获取实例
private GTaskManager mTaskManager;
// 存储实现了OnCompleteListener接口的对象引用，用于在异步任务完成时回调相应的方法，通知外部任务已结束
private OnCompleteListener mOnCompleteListener;
// 构造函数，接收上下文对象和OnCompleteListener接口实现对象作为参数，用于初始化类中的相关成员变量，
// 同时获取通知管理器实例，并获取GTaskManager的单例实例，为后续操作做准备
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
@ -52,17 +61,21 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
.getSystemService(Context.NOTIFICATION_SERVICE);
mTaskManager = GTaskManager.getInstance();
}
// 用于取消正在进行的同步操作的方法，通过调用GTaskManager中的取消同步方法来实现具体的取消逻辑，外部可调用此方法来中断同步过程
public void cancelSync() {
mTaskManager.cancelSync();
}
// 用于发布进度信息的方法，接收一个字符串消息参数，将其包装成字符串数组后调用AsyncTask的publishProgress方法，
// 触发onProgressUpdate方法的执行，从而实现向UI线程传递进度信息，以便更新界面展示等相关操作
public void publishProgess(String message) {
publishProgress(new String[] {
message
});
}
// 私有方法，用于显示通知信息，根据传入的通知文本资源ID（tickerId）和通知具体内容（content）创建并配置一个Notification对象，
// 然后通过通知管理器将通知显示出来，设置了通知的图标、默认灯光效果、自动取消等属性，并根据不同的文本资源ID设置点击通知后的跳转意图（PendingIntent）
private void showNotification(int tickerId, String content) {
Notification notification = new Notification(R.drawable.notification, mContext
.getString(tickerId), System.currentTimeMillis());
@ -81,14 +94,18 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
pendingIntent);
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
}
// 在后台线程执行的方法，重写了AsyncTask的抽象方法，是异步任务的核心逻辑所在。
// 首先发布一条表示正在登录进行同步的进度消息（包含同步账号名称），然后调用GTaskManager的sync方法进行实际的同步操作，
// 并返回同步结果（以整数形式表示不同的状态，如成功、网络错误等状态码），该结果将传递给onPostExecute方法进行后续处理
@Override
protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
.getSyncAccountName(mContext)));
return mTaskManager.sync(mContext, this);
}
// 在UI线程执行的方法，用于接收并处理在后台线程通过publishProgress方法传递过来的进度信息，
// 调用showNotification方法展示同步进度通知，并且如果当前上下文是GTaskSyncService类型，还会发送广播（可能用于通知其他组件同步进度情况）
@Override
protected void onProgressUpdate(String... progress) {
showNotification(R.string.ticker_syncing, progress[0]);
@ -96,7 +113,11 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
((GTaskSyncService) mContext).sendBroadcast(progress[0]);
}
}
// 在UI线程执行的方法，当异步任务执行完毕后（无论是正常完成还是出现异常结束），根据返回的结果状态码进行不同的处理：
// 如果结果是成功状态，展示成功同步的通知信息，并记录最后同步时间；
// 如果是网络错误状态、内部错误状态或同步取消状态，分别展示对应的错误通知信息；
// 最后，如果存在实现了OnCompleteListener接口的对象（即外部注册了任务完成回调），则通过开启一个新线程来执行回调方法，通知外部任务已完成
@Override
protected void onPostExecute(Integer result) {
if (result == GTaskManager.STATE_SUCCESS) {

121
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskClient.java
Unescape View File

@ -59,37 +59,40 @@ import java.util.List;
import java.util.zip.GZIPInputStream;
import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
// GTaskClient类用于与Google Tasks等相关服务进行交互，实现诸如登录、创建任务、创建任务列表、更新任务、获取任务列表等功能，
// 内部管理着与服务器通信的HttpClient对象、登录状态、账户信息等，是应用与远程任务服务交互的核心类之一
public class GTaskClient {
// 用于日志记录的标签，取当前类的简单名称
private static final String TAG = GTaskClient.class.getSimpleName();
// Google Tasks服务的基础URL
private static final String GTASK_URL = "https://mail.google.com/tasks/";
// 用于获取任务相关数据的URL（可能是获取初始数据等情况）
private static final String GTASK_GET_URL = "https://mail.google.com/tasks/ig";
// 用于向服务器提交任务相关操作（如创建、更新等）的URL
private static final String GTASK_POST_URL = "https://mail.google.com/tasks/r/ig";
// 单例模式，存储唯一的GTaskClient实例，初始化为null
private static GTaskClient mInstance = null;
// 用于与服务器进行HTTP通信的HttpClient对象，初始化为null，后续根据需要进行初始化和配置
private DefaultHttpClient mHttpClient;
// 当前用于获取数据的URL，初始化为GTASK_GET_URL，可能会根据登录情况（如自定义域名等）进行调整
private String mGetUrl;
// 当前用于提交数据的URL，初始化为GTASK_POST_URL，可能会根据登录情况（如自定义域名等）进行调整
private String mPostUrl;
// 客户端版本号，初始化为 -1，登录成功后会从服务器响应中获取实际版本号
private long mClientVersion;
// 标记用户是否已登录，初始化为false
private boolean mLoggedin;
// 记录上次登录的时间戳，初始化为0
private long mLastLoginTime;
// 用于为每个操作生成唯一的标识符（每次操作后自增），初始化为1
private int mActionId;
// 存储当前登录的账户信息，初始化为null
private Account mAccount;
// 用于存储待提交的更新操作对应的JSON数组（多个更新操作可批量提交），初始化为null
private JSONArray mUpdateArray;
// 私有构造函数，用于初始化GTaskClient类的各个成员变量，采用单例模式，限制外部直接实例化该类
private GTaskClient() {
mHttpClient = null;
mGetUrl = GTASK_GET_URL;
@ -101,41 +104,44 @@ public class GTaskClient {
mAccount = null;
mUpdateArray = null;
}
// 静态方法，用于获取GTaskClient的单例实例，如果实例不存在则创建一个新的实例，保证整个应用中只有一个GTaskClient对象在使用
public static synchronized GTaskClient getInstance() {
if (mInstance == null) {
mInstance = new GTaskClient();
}
return mInstance;
}
// 用于登录到Google Tasks服务的方法，根据一些条件判断是否需要重新登录（如登录间隔超过5分钟、账户切换等情况），
// 先获取Google账户的认证令牌，然后根据账户域名情况尝试不同的登录方式（自定义域名或官方URL），最后返回登录是否成功的布尔值
public boolean login(Activity activity) {
// 假设Cookie在5分钟后过期，超过此时间间隔则需要重新登录
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
final long interval = 1000 * 60 * 5;
if (mLastLoginTime + interval < System.currentTimeMillis()) {
mLoggedin = false;
}
// 在账户切换后需要重新登录
// need to re-login after account switch
if (mLoggedin
&& !TextUtils.equals(getSyncAccount().name, NotesPreferenceActivity
.getSyncAccountName(activity))) {
mLoggedin = false;
}
if (mLoggedin) {
Log.d(TAG, "already logged in");
return true;
}
mLastLoginTime = System.currentTimeMillis();
String authToken = loginGoogleAccount(activity, false);
if (authToken == null) {
Log.e(TAG, "login google account failed");
return false;
}
// 如果账户名不是以gmail.com或googlemail.com结尾，尝试使用自定义域名登录
// login with custom domain if necessary
if (!(mAccount.name.toLowerCase().endsWith("gmail.com") || mAccount.name.toLowerCase()
.endsWith("googlemail.com"))) {
@ -150,7 +156,7 @@ public class GTaskClient {
mLoggedin = true;
}
}
// 如果使用自定义域名登录失败，尝试使用Google官方URL登录
// try to login with google official url
if (!mLoggedin) {
mGetUrl = GTASK_GET_URL;
@ -163,7 +169,10 @@ public class GTaskClient {
mLoggedin = true;
return true;
}
// 用于获取Google账户的认证令牌的私有方法，通过AccountManager获取所有Google类型的账户，
// 根据应用设置中指定的同步账户名称查找对应的账户，然后向AccountManager请求获取认证令牌，
// 如果获取失败则返回null，若需要使令牌失效（invalidateToken为true时），则先失效令牌再重新获取
private String loginGoogleAccount(Activity activity, boolean invalidateToken) {
String authToken;
AccountManager accountManager = AccountManager.get(activity);
@ -188,7 +197,7 @@ public class GTaskClient {
Log.e(TAG, "unable to get an account with the same name in the settings");
return null;
}
// 获取令牌
// get the token now
AccountManagerFuture<Bundle> accountManagerFuture = accountManager.getAuthToken(account,
"goanna_mobile", null, activity, null, null);
@ -206,9 +215,12 @@ public class GTaskClient {
return authToken;
}
// 尝试登录到Google Tasks服务的私有方法，先调用loginGtask方法进行登录，如果登录失败（可能是认证令牌过期等原因），
// 则使令牌失效后重新获取并再次尝试登录，返回最终登录是否成功的布尔值
private boolean tryToLoginGtask(Activity activity, String authToken) {
if (!loginGtask(authToken)) {
// 可能认证令牌已过期，现在使令牌失效并再次尝试
// maybe the auth token is out of date, now let's invalidate the
// token and try again
authToken = loginGoogleAccount(activity, true);
@ -224,7 +236,10 @@ public class GTaskClient {
}
return true;
}
// 实际执行登录到Google Tasks服务的私有方法，配置HttpClient的连接超时、读取超时等参数，设置Cookie存储，
// 禁用Expect-Continue机制，然后向服务器发送带有认证令牌的GET请求进行登录，从响应中获取Cookie判断是否登录成功，
// 同时从响应内容中解析出客户端版本号，若在过程中出现JSONException或其他异常则返回false表示登录失败
private boolean loginGtask(String authToken) {
int timeoutConnection = 10000;
int timeoutSocket = 15000;
@ -235,14 +250,14 @@ public class GTaskClient {
BasicCookieStore localBasicCookieStore = new BasicCookieStore();
mHttpClient.setCookieStore(localBasicCookieStore);
HttpProtocolParams.setUseExpectContinue(mHttpClient.getParams(), false);
// 登录Google Tasks
// login gtask
try {
String loginUrl = mGetUrl + "?auth=" + authToken;
HttpGet httpGet = new HttpGet(loginUrl);
HttpResponse response = null;
response = mHttpClient.execute(httpGet);
// 获取Cookie
// get the cookie now
List<Cookie> cookies = mHttpClient.getCookieStore().getCookies();
boolean hasAuthCookie = false;
@ -254,7 +269,7 @@ public class GTaskClient {
if (!hasAuthCookie) {
Log.w(TAG, "it seems that there is no auth cookie");
}
// 获取客户端版本号
// get the client version
String resString = getResponseContent(response.getEntity());
String jsBegin = "_setup(";
@ -272,6 +287,7 @@ public class GTaskClient {
e.printStackTrace();
return false;
} catch (Exception e) {
// 简单捕获所有异常
// simply catch all exceptions
Log.e(TAG, "httpget gtask_url failed");
return false;
@ -279,18 +295,20 @@ public class GTaskClient {
return true;
}
// 获取下一个操作的唯一标识符（每次调用自增）的私有方法，用于区分不同的操作请求
private int getActionId() {
return mActionId++;
}
// 创建一个用于POST请求的HttpPost对象的私有方法，设置请求头的Content-Type和AT字段，返回配置好的HttpPost对象，
// 方便后续设置请求体并发送POST请求
private HttpPost createHttpPost() {
HttpPost httpPost = new HttpPost(mPostUrl);
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setHeader("AT", "1");
return httpPost;
}
// 从HttpEntity中获取响应内容的私有方法，根据响应内容的编码方式（如gzip、deflate等）对输入流进行相应的解压处理，
// 然后逐行读取内容并拼接成字符串返回，最后关闭输入流，若在读取过程中出现IOException则抛出异常
private String getResponseContent(HttpEntity entity) throws IOException {
String contentEncoding = null;
if (entity.getContentEncoding() != null) {
@ -322,7 +340,10 @@ public class GTaskClient {
input.close();
}
}
// 向服务器发送POST请求并处理响应的私有方法，首先检查是否已登录，若未登录则抛出异常，然后创建HttpPost对象，
// 设置请求体（将传入的JSONObject转换为表单数据），发送请求并获取响应内容，将响应内容转换为JSONObject返回，
// 在过程中若出现ClientProtocolException、IOException、JSONException等异常则分别抛出对应的异常表示请求失败
private JSONObject postRequest(JSONObject js) throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -335,7 +356,7 @@ public class GTaskClient {
list.add(new BasicNameValuePair("r", js.toString()));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(list, "UTF-8");
httpPost.setEntity(entity);
// 执行POST请求
// execute the post
HttpResponse response = mHttpClient.execute(httpPost);
String jsString = getResponseContent(response.getEntity());
@ -359,7 +380,9 @@ public class GTaskClient {
throw new ActionFailureException("error occurs when posting request");
}
}
// 创建任务的方法，首先调用commitUpdate方法提交之前可能积累的更新操作，然后构建包含创建任务操作的JSON数据，
// 设置客户端版本号等信息，向服务器发送POST请求，从响应中获取新创建任务的全局唯一标识符（Gid）并设置到任务对象中，
// 若在处理JSON数据过程中出现异常则抛出相应异常表示创建任务失败
public void createTask(Task task) throws NetworkFailureException {
commitUpdate();
try {
@ -385,7 +408,8 @@ public class GTaskClient {
throw new ActionFailureException("create task: handing jsonobject failed");
}
}
// 创建任务列表的方法，与创建任务的逻辑类似，先提交已有更新，构建包含创建任务列表操作的JSON数据，发送POST请求，
// 从响应中获取新创建任务列表的Gid并设置到任务列表对象中，若处理JSON出现问题则抛出异常表示创建失败
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
commitUpdate();
try {
@ -411,7 +435,9 @@ public class GTaskClient {
throw new ActionFailureException("create tasklist: handing jsonobject failed");
}
}
// 提交更新操作的方法，若存在待提交的更新操作数组（mUpdateArray不为null），则构建包含更新操作列表和客户端版本号的JSON数据，
// 发送POST请求将更新提交到服务器，之后将更新操作数组置为null，表示已提交，若处理JSON过程中出现异常则抛出相应异常表示提交失败
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
try {
@ -432,7 +458,9 @@ public class GTaskClient {
}
}
}
// 添加待更新节点（任务、任务列表等）操作到更新操作数组的方法，首先判断节点是否为空，若不为空且更新操作数组长度超过10个（避免过多更新导致错误），
// 则先提交已有的更新操作，若更新操作数组为空则创建一个新的JSONArray，然后将节点的更新操作对应的JSON数据添加到数组中，用于后续批量提交更新
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
@ -446,7 +474,9 @@ public class GTaskClient {
mUpdateArray.put(node.getUpdateAction(getActionId()));
}
}
// 移动任务的方法，先提交已有更新操作，然后构建包含移动任务操作相关信息（如操作类型、任务ID、源任务列表、目标任务列表等）的JSON数据，
// 设置客户端版本号后发送POST请求到服务器，若处理JSON数据过程中出现异常则抛出相应异常表示移动任务失败
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@ -485,7 +515,9 @@ public class GTaskClient {
throw new ActionFailureException("move task: handing jsonobject failed");
}
}
// 删除节点（任务、任务列表等）的方法，先提交已有更新操作，将节点标记为已删除后构建包含删除操作的JSON数据，设置客户端版本号并发送POST请求到服务器，
// 提交成功后将更新操作数组置为null，若处理JSON过程中出现异常则抛出相应异常表示删除节点失败
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {
@ -508,7 +540,9 @@ public class GTaskClient {
throw new ActionFailureException("delete node: handing jsonobject failed");
}
}
// 获取所有任务列表的方法，首先检查是否已登录，若未登录则抛出异常，然后发送GET请求到服务器获取任务列表相关数据，
// 从响应内容中解析出任务列表的JSON数组并返回，若在请求过程中出现ClientProtocolException、IOException、JSONException等异常则抛出相应异常表示获取失败
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -546,7 +580,9 @@ public class GTaskClient {
throw new ActionFailureException("get task lists: handing jasonobject failed");
}
}
// 获取指定任务列表（根据任务列表的Gid）的方法，先提交已有更新操作，然后构建包含获取指定任务列表操作相关信息的JSON数据，发送POST请求到服务器，
// 从响应中获取任务列表包含的任务的JSON数组并返回，若处理JSON过程中出现异常则抛出相应异常表示获取任务列表失败
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@ -574,11 +610,12 @@ public class GTaskClient {
throw new ActionFailureException("get task list: handing jsonobject failed");
}
}
// 获取当前同步账户的方法，直接返回存储的账户对象，外部可通过此方法获取当前登录用于同步的账户信息
public Account getSyncAccount() {
return mAccount;
}
// 重置更新操作数组的方法，将更新操作数组置为null，用于清空之前积累的待更新操作，通常在一些特定场景下（如重新开始一轮更新操作等）使用
public void resetUpdateArray() {
mUpdateArray = null;
}

191
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskManager.java
Unescape View File

@ -46,47 +46,59 @@ import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
// GTaskManager类用于管理与远程任务服务（如Google Tasks）的同步操作以及相关数据的处理，包括任务列表、任务、元数据等的同步逻辑，
// 通过协调本地数据和远程数据的差异来实现数据的一致性，是整个应用中任务同步功能的核心管理类，采用单例模式确保在应用内只有一个实例进行管理操作。
public class GTaskManager {
// 用于日志记录的标签，取当前类的简单名称
private static final String TAG = GTaskManager.class.getSimpleName();
// 表示同步成功的状态码
public static final int STATE_SUCCESS = 0;
// 表示网络错误导致同步失败的状态码
public static final int STATE_NETWORK_ERROR = 1;
// 表示内部逻辑错误导致同步失败的状态码
public static final int STATE_INTERNAL_ERROR = 2;
// 表示同步正在进行中的状态码
public static final int STATE_SYNC_IN_PROGRESS = 3;
// 表示同步被取消的状态码
public static final int STATE_SYNC_CANCELLED = 4;
// 单例模式，存储唯一的GTaskManager实例，初始化为null
private static GTaskManager mInstance = null;
// 用于获取认证令牌等相关操作的Activity对象，可在不同的同步相关操作中使用，例如登录时获取账户认证信息等
private Activity mActivity;
// 应用上下文对象，用于获取内容解析器（ContentResolver）等系统服务，方便与本地数据库等进行交互操作
private Context mContext;
// 用于与本地内容提供者（Content Provider）进行交互，实现对本地数据（如数据库中的笔记、任务等相关数据）的查询、更新等操作
private ContentResolver mContentResolver;
// 标记当前是否正在进行同步操作，初始化为false，在同步开始时设置为true，结束时设置为false
private boolean mSyncing;
// 标记当前同步操作是否已被取消，初始化为false，可通过相应方法设置为true来取消正在进行的同步过程
private boolean mCancelled;
// 以任务列表的全局唯一标识符（Gid）为键，存储任务列表对象的哈希映射，用于缓存从远程获取的任务列表信息以及在同步过程中管理本地和远程任务列表的对应关系
private HashMap<String, TaskList> mGTaskListHashMap;
// 以节点（任务、任务列表、元数据等都可视为节点，通过共同的父类Node进行抽象）的Gid为键，存储节点对象的哈希映射，方便在同步过程中快速查找和操作各个节点
private HashMap<String, Node> mGTaskHashMap;
// 以相关Gid为键，存储元数据（MetaData）对象的哈希映射，用于管理和跟踪与任务等相关的元数据信息，例如可能包含一些额外的描述、配置等数据
private HashMap<String, MetaData> mMetaHashMap;
// 用于存储特殊的元数据列表（可能是具有特定用途、结构的元数据集合），初始化为null，在同步过程中根据情况进行创建和填充
private TaskList mMetaList;
// 用于存储本地已删除的任务或数据对应的唯一标识符（可能是本地数据库中的主键等），通过哈希集合来避免重复记录，方便后续统一处理删除相关逻辑
private HashSet<Long> mLocalDeleteIdMap;
// 以节点的Gid为键，存储对应本地唯一标识符（如数据库中的记录ID）的哈希映射，用于建立远程节点Gid和本地数据ID之间的对应关系，便于同步时查找和关联数据
private HashMap<String, Long> mGidToNid;
// 以本地唯一标识符为键，存储对应节点Gid的哈希映射，与mGidToNid作用类似，是反向的映射关系，用于在不同的同步操作场景下根据需要进行查找和转换
private HashMap<Long, String> mNidToGid;
// 私有构造函数，用于初始化GTaskManager类的各个成员变量，采用单例模式，限制外部直接实例化该类，在这里初始化了各种用于存储数据和管理同步状态的集合、映射等变量。
private GTaskManager() {
mSyncing = false;
mCancelled = false;
@ -98,6 +110,7 @@ public class GTaskManager {
mGidToNid = new HashMap<String, Long>();
mNidToGid = new HashMap<Long, String>();
}
// 静态方法，用于获取GTaskManager的单例实例，如果实例不存在则创建一个新的实例，保证整个应用中只有一个GTaskManager对象在管理任务同步等相关操作
public static synchronized GTaskManager getInstance() {
if (mInstance == null) {
@ -105,12 +118,16 @@ public class GTaskManager {
}
return mInstance;
}
// 用于设置关联的Activity上下文对象的方法，主要是为了后续在需要获取认证令牌等与Activity相关的操作时能够获取到相应的上下文环境，
// 该方法是同步的，以保证在多线程环境下设置上下文对象的操作的原子性和一致性。
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity;
}
// 执行同步操作的核心方法，负责协调本地数据和远程数据的同步过程，首先检查是否正在同步，如果正在同步则直接返回相应状态码，
// 然后初始化一系列用于同步的数据结构，进行登录操作（通过GTaskClient），获取远程任务列表，执行具体的内容同步逻辑（包括处理本地删除、新增、更新等不同情况的同步），
// 最后根据同步过程中的各种情况（如是否取消、是否出现异常等）返回对应的同步状态码，并且在finally块中清理相关的数据结构，重置同步状态。
public int sync(Context context, GTaskASyncTask asyncTask) {
if (mSyncing) {
Log.d(TAG, "Sync is in progress");
@ -130,18 +147,18 @@ public class GTaskManager {
try {
GTaskClient client = GTaskClient.getInstance();
client.resetUpdateArray();
// 登录Google任务服务
// login google task
if (!mCancelled) {
if (!client.login(mActivity)) {
throw new NetworkFailureException("login google task failed");
}
}
// 获取Google任务列表
// get the task list from google
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_init_list));
initGTaskList();
// 执行内容同步工作
// do content sync work
asyncTask.publishProgess(mContext.getString(R.string.sync_progress_syncing));
syncContent();
@ -167,14 +184,16 @@ public class GTaskManager {
return mCancelled ? STATE_SYNC_CANCELLED : STATE_SUCCESS;
}
// 初始化远程任务列表相关数据的私有方法，首先检查同步是否已取消，如果取消则直接返回，然后通过GTaskClient获取远程任务列表的JSON数据，
// 接着分别处理元数据列表（如果不存在则创建）以及普通任务列表，解析JSON数据创建对应的任务列表和任务对象，并建立相关的映射关系（如将任务列表、任务等存入对应的哈希映射中），
// 若在处理JSON数据过程中出现异常则抛出相应异常表示初始化任务列表失败。
private void initGTaskList() throws NetworkFailureException {
if (mCancelled)
return;
GTaskClient client = GTaskClient.getInstance();
try {
JSONArray jsTaskLists = client.getTaskLists();
// 首先初始化元数据列表
// init meta list first
mMetaList = null;
for (int i = 0; i < jsTaskLists.length(); i++) {
@ -186,7 +205,7 @@ public class GTaskManager {
.equals(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_META)) {
mMetaList = new TaskList();
mMetaList.setContentByRemoteJSON(object);
// 加载元数据
// load meta data
JSONArray jsMetas = client.getTaskList(gid);
for (int j = 0; j < jsMetas.length(); j++) {
@ -202,7 +221,7 @@ public class GTaskManager {
}
}
}
// 如果元数据列表不存在则创建它
// create meta list if not existed
if (mMetaList == null) {
mMetaList = new TaskList();
@ -210,7 +229,7 @@ public class GTaskManager {
+ GTaskStringUtils.FOLDER_META);
GTaskClient.getInstance().createTaskList(mMetaList);
}
// 初始化任务列表
// init task list
for (int i = 0; i < jsTaskLists.length(); i++) {
JSONObject object = jsTaskLists.getJSONObject(i);
@ -224,7 +243,7 @@ public class GTaskManager {
tasklist.setContentByRemoteJSON(object);
mGTaskListHashMap.put(gid, tasklist);
mGTaskHashMap.put(gid, tasklist);
// 加载任务
// load tasks
JSONArray jsTasks = client.getTaskList(gid);
for (int j = 0; j < jsTasks.length(); j++) {
@ -246,7 +265,9 @@ public class GTaskManager {
throw new ActionFailureException("initGTaskList: handing JSONObject failed");
}
}
// 执行具体内容同步的私有方法，负责协调本地和远程数据在内容层面的同步操作，包括处理本地已删除的笔记、文件夹同步、数据库中现有笔记的同步等多种情况，
// 在不同的同步场景下调用相应的辅助方法（如doContentSync）来执行具体的添加、删除、更新等操作，并且在合适的时机提交更新到远程（通过GTaskClient）以及清理本地删除记录等操作，
// 整个过程中会不断检查同步是否已被取消，若已取消则及时终止操作。
private void syncContent() throws NetworkFailureException {
int syncType;
Cursor c = null;
@ -258,7 +279,7 @@ public class GTaskManager {
if (mCancelled) {
return;
}
// 处理本地已删除的笔记
// for local deleted note
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
@ -285,10 +306,10 @@ public class GTaskManager {
c = null;
}
}
// 同步文件夹
// sync folder first
syncFolder();
// 处理数据库中已存在的笔记
// for note existing in database
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
@ -306,9 +327,11 @@ public class GTaskManager {
syncType = node.getSyncAction(c);
} else {
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
// 本地新增
// local add
syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else {
// 远程已删除
// remote delete
syncType = Node.SYNC_ACTION_DEL_LOCAL;
}
@ -325,7 +348,7 @@ public class GTaskManager {
c = null;
}
}
// 处理剩余的项目（可能是本地新增但还未处理完全的等情况）
// go through remaining items
Iterator<Map.Entry<String, Node>> iter = mGTaskHashMap.entrySet().iterator();
while (iter.hasNext()) {
@ -333,16 +356,16 @@ public class GTaskManager {
node = entry.getValue();
doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
}
// mCancelled可以被其他线程设置，所以我们需要逐个检查
// mCancelled can be set by another thread, so we neet to check one by
// one
// one // 清除本地删除表（如果同步未取消）
// clear local delete table
if (!mCancelled) {
if (!DataUtils.batchDeleteNotes(mContentResolver, mLocalDeleteIdMap)) {
throw new ActionFailureException("failed to batch-delete local deleted notes");
}
}
// 刷新本地同步ID（如果同步未取消）
// refresh local sync id
if (!mCancelled) {
GTaskClient.getInstance().commitUpdate();
@ -350,7 +373,9 @@ public class GTaskManager {
}
}
// 专门用于文件夹同步的私有方法，处理各种不同类型的文件夹（如根文件夹、通话记录文件夹、本地已存在的文件夹以及远程新增的文件夹等）的同步逻辑，
// 在不同情况下判断文件夹在本地和远程的存在情况，调用相应的辅助方法（如doContentSync）来执行添加、更新等操作，并且在合适的时机提交更新到远程（通过GTaskClient），
// 整个过程中会不断检查同步是否已被取消，若已取消则及时终止操作。
private void syncFolder() throws NetworkFailureException {
Cursor c = null;
String gid;
@ -360,7 +385,7 @@ public class GTaskManager {
if (mCancelled) {
return;
}
// 处理根文件夹
// for root folder
try {
c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
@ -373,6 +398,7 @@ public class GTaskManager {
mGTaskHashMap.remove(gid);
mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
// 对于系统文件夹，仅在必要时更新远程名称
// for system folder, only update remote name if necessary
if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
@ -389,7 +415,7 @@ public class GTaskManager {
c = null;
}
}
// 处理通话记录文件夹
// for call-note folder
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
@ -404,6 +430,7 @@ public class GTaskManager {
mGTaskHashMap.remove(gid);
mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
// 对于系统文件夹，仅在必要时更新远程名称
// for system folder, only update remote name if
// necessary
if (!node.getName().equals(
@ -423,7 +450,7 @@ public class GTaskManager {
c = null;
}
}
// 处理本地已存在的文件夹
// for local existing folders
try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
@ -441,9 +468,11 @@ public class GTaskManager {
syncType = node.getSyncAction(c);
} else {
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
// 本地新增
// local add
syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else {
// 远程已删除
// remote delete
syncType = Node.SYNC_ACTION_DEL_LOCAL;
}
@ -459,7 +488,7 @@ public class GTaskManager {
c = null;
}
}
// 处理远程新增的文件夹
// for remote add folders
Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) {
@ -475,7 +504,9 @@ public class GTaskManager {
if (!mCancelled)
GTaskClient.getInstance().commitUpdate();
}
// 根据不同的同步操作类型执行具体同步动作的私有方法，通过一个switch语句根据传入的同步类型（syncType）来决定调用相应的添加、删除、更新等具体操作方法，
// 整个过程中会不断检查同步是否已被取消，若已取消则及时终止操作，若传入的同步类型不合法则抛出异常表示未知的同步操作类型。
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -510,6 +541,7 @@ public class GTaskManager {
updateRemoteNode(node, c);
break;
case Node.SYNC_ACTION_UPDATE_CONFLICT:
// 合并双方的修改可能是个好主意，目前简单使用本地更新
// merging both modifications maybe a good idea
// right now just use local update simply
updateRemoteNode(node, c);
@ -521,7 +553,10 @@ public class GTaskManager {
throw new ActionFailureException("unkown sync action type");
}
}
// 将本地节点添加到本地数据库以及处理相关同步逻辑的私有方法，首先判断同步是否已取消，如果取消则直接返回，
// 然后根据节点类型（是任务列表还是普通任务等）进行不同的处理，创建对应的本地数据记录（通过SqlNote），设置相关属性（如父节点ID、全局唯一标识符等），
// 将数据提交到本地数据库，更新本地和远程标识符的映射关系，并且调用updateRemoteMeta方法来处理与元数据相关的更新操作，若在过程中出现找不到父节点ID等问题则抛出异常表示无法添加本地节点。
private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) {
return;
@ -549,6 +584,7 @@ public class GTaskManager {
if (note.has(NoteColumns.ID)) {
long id = note.getLong(NoteColumns.ID);
if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
// 该ID不可用，必须创建一个新的
// the id is not available, have to create a new one
note.remove(NoteColumns.ID);
}
@ -562,6 +598,7 @@ public class GTaskManager {
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
// 数据ID不可用，必须创建一个新的
// the data id is not available, have to create
// a new one
data.remove(DataColumns.ID);
@ -583,25 +620,29 @@ public class GTaskManager {
}
sqlNote.setParentId(parentId.longValue());
}
// 创建本地节点
// create the local node
sqlNote.setGtaskId(node.getGid());
sqlNote.commit(false);
// 更新Gid-Nid映射
// update gid-nid mapping
mGidToNid.put(node.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), node.getGid());
// 更新元数据
// update meta
updateRemoteMeta(node.getGid(), sqlNote);
}
// 更新本地节点数据以及相关同步逻辑的私有方法，首先判断同步是否已取消，如果取消则直接返回，
// 然后根据节点类型（是任务还是其他类型等）获取对应的本地数据记录（通过SqlNote），更新其内容、父节点ID等属性，将更新后的数据提交到本地数据库，
// 并调用updateRemoteMeta方法来处理与元数据相关的更新操作，若在过程中出现找不到父节点ID等问题则抛出异常表示无法更新本地节点。
private void updateLocalNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
}
SqlNote sqlNote;
// 更新本地笔记
// update the note locally
sqlNote = new SqlNote(mContext, c);
sqlNote.setContent(node.getLocalJSONFromContent());
@ -614,11 +655,15 @@ public class GTaskManager {
}
sqlNote.setParentId(parentId.longValue());
sqlNote.commit(true);
// 更新元数据信息
// update meta info
updateRemoteMeta(node.getGid(), sqlNote);
}
// 将远程节点添加到本地数据库以及处理相关同步逻辑的私有方法，首先判断同步是否已取消，如果取消则直接返回，
// 然后根据节点类型（是任务还是任务列表等）进行不同的处理，创建对应的本地数据记录（通过SqlNote），
// 对于任务，找到其对应的父任务列表，添加到任务列表中，然后向远程服务创建任务（通过GTaskClient），对于任务列表，判断是否已存在，不存在则创建，
// 接着更新本地数据记录的相关属性（如全局唯一标识符等），提交到本地数据库，更新本地和远程标识符的映射关系，若在过程中出现找不到父任务列表等问题则抛出异常表示无法添加远程节点。
private void addRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
@ -626,7 +671,7 @@ public class GTaskManager {
SqlNote sqlNote = new SqlNote(mContext, c);
Node n;
// 远程更新
// update remotely
if (sqlNote.isNoteType()) {
Task task = new Task();
@ -641,12 +686,12 @@ public class GTaskManager {
GTaskClient.getInstance().createTask(task);
n = (Node) task;
// 添加元数据
// add meta
updateRemoteMeta(task.getGid(), sqlNote);
} else {
TaskList tasklist = null;
// 我们需要跳过已存在的文件夹
// we need to skip folder if it has already existed
String folderName = GTaskStringUtils.MIUI_FOLDER_PREFFIX;
if (sqlNote.getId() == Notes.ID_ROOT_FOLDER)
@ -670,7 +715,7 @@ public class GTaskManager {
break;
}
}
// 没有匹配的则添加
// no match we can add now
if (tasklist == null) {
tasklist = new TaskList();
@ -680,32 +725,36 @@ public class GTaskManager {
}
n = (Node) tasklist;
}
// 更新本地笔记
// update local note
sqlNote.setGtaskId(n.getGid());
sqlNote.commit(false);
sqlNote.resetLocalModified();
sqlNote.commit(true);
// gid-id映射
// gid-id mapping
mGidToNid.put(n.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), n.getGid());
}
// 更新远程节点数据以及相关同步逻辑的私有方法，首先判断同步是否已取消，如果取消则直接返回，
// 然后获取对应的本地数据记录（通过SqlNote），将本地数据内容设置到远程节点，向远程服务添加更新节点的请求（通过GTaskClient），
// 接着调用updateRemoteMeta方法处理元数据更新，对于任务类型的节点，还会判断是否需要移动任务（根据父任务列表的变化），若需要则执行移动任务操作（通过GTaskClient），
// 最后清除本地数据的修改标记并提交到本地数据库，若在过程中出现找不到父任务列表等问题则抛出异常表示无法更新远程任务。
private void updateRemoteNode(Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) {
return;
}
SqlNote sqlNote = new SqlNote(mContext, c);
// 远程更新
// update remotely
node.setContentByLocalJSON(sqlNote.getContent());
GTaskClient.getInstance().addUpdateNode(node);
// 更新元数据
// update meta
updateRemoteMeta(node.getGid(), sqlNote);
// 如果必要的话移动任务
// move task if necessary
if (sqlNote.isNoteType()) {
Task task = (Task) node;
@ -724,12 +773,15 @@ public class GTaskManager {
GTaskClient.getInstance().moveTask(task, preParentList, curParentList);
}
}
// 清除本地修改标记
// clear local modified flag
sqlNote.resetLocalModified();
sqlNote.commit(true);
}
// 更新远程元数据的私有方法，首先判断传入的本地数据记录（sqlNote）是否为笔记类型且不为空，
// 如果是，则先从元数据映射中查找对应Gid的元数据对象，若存在则更新其元数据内容并向远程服务添加更新节点请求（通过GTaskClient），
// 若不存在则创建新的元数据对象，添加到元数据列表中，然后向远程服务创建元数据任务（通过GTaskClient），以此来保证元数据在本地和远程的同步更新。
private void updateRemoteMeta(String gid, SqlNote sqlNote) throws NetworkFailureException {
if (sqlNote != null && sqlNote.isNoteType()) {
MetaData metaData = mMetaHashMap.get(gid);
@ -745,12 +797,15 @@ public class GTaskManager {
}
}
}
// 刷新本地同步ID的私有方法，用于在同步完成后，根据最新的远程任务列表数据来更新本地数据的同步ID，首先判断同步是否已取消，如果取消则直接返回，
// 然后清空之前缓存的相关任务数据结构（如任务哈希映射、任务列表哈希映射、元数据哈希映射等），重新初始化任务列表数据（通过initGTaskList方法），
// 接着查询本地数据库中的相关数据，对于在远程任务列表中能找到对应节点的数据，更新其同步ID，若在过程中出现找不到对应节点等问题则抛出异常表示同步后本地部分数据缺失对应的Gid。
private void refreshLocalSyncId() throws NetworkFailureException {
if (mCancelled) {
return;
}
// 获取最新的gtask列表
// get the latest gtask list
mGTaskHashMap.clear();
mGTaskListHashMap.clear();
@ -789,11 +844,13 @@ public class GTaskManager {
}
}
}
// 获取当前同步账户名称的方法，通过调用GTaskClient的实例获取当前同步账户对象，然后返回其账户名称，外部可通过此方法获取当前正在用于同步的账户信息。
public String getSyncAccount() {
return GTaskClient.getInstance().getSyncAccount().name;
}
// 用于取消正在进行的同步操作的方法，将同步取消标记（mCancelled）设置为true，在同步过程中的各个关键步骤都会检查这个标记，
// 一旦发现被设置为true，则会及时终止相应的同步操作，避免不必要的资源消耗和数据不一致问题。
public void cancelSync() {
mCancelled = true;
}

61
src/Notes-master/src/net/micode/notes/gtask/remote/GTaskSyncService.java
Unescape View File

@ -22,26 +22,37 @@ import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
// GTaskSyncService类继承自Service，是一个用于处理任务同步相关操作的后台服务类，它可以接收不同的意图（Intent）来启动或取消任务同步，
// 并且在同步过程中能够发送广播来通知同步状态、进度等信息，同时对外提供了一些静态方法方便在不同的地方控制同步操作以及获取同步相关的状态信息。
public class GTaskSyncService extends Service {
// 用于在Intent中传递同步操作类型的字符串常量名称，外部组件（如Activity等）可以通过在Intent中设置该名称对应的额外数据来指定要执行的同步相关操作。
public final static String ACTION_STRING_NAME = "sync_action_type";
// 表示启动同步操作的常量值，在通过Intent传递同步操作类型时使用该值表示要开始进行任务同步。
public final static int ACTION_START_SYNC = 0;
// 表示取消同步操作的常量值，用于指示服务取消正在进行的任务同步过程。
public final static int ACTION_CANCEL_SYNC = 1;
// 表示无效的同步操作类型的常量值，当接收到无法识别的操作类型时可能用到。
public final static int ACTION_INVALID = 2;
// 用于发送广播的意图（Intent）的动作（Action）名称，通过这个名称可以在应用内识别来自该服务发送的广播，其他组件可以注册接收该广播来获取同步服务相关的信息。
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
// 用于在广播中传递是否正在同步这个状态信息的键（Key）名称，接收广播的组件可以通过该键从广播附带的数据中获取当前是否正在进行同步的状态。
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
// 用于在广播中传递同步进度消息的键（Key）名称，服务可以在同步过程中更新并发送相应的进度消息，其他组件接收广播后能展示给用户同步的进展情况。
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
// 静态变量，用于存储当前正在执行的同步任务（GTaskASyncTask类型）实例，初始化为null，在启动同步时创建并赋值，取消或完成同步后设置为null，用于跟踪同步任务的执行情况。
private static GTaskASyncTask mSyncTask = null;
// 静态变量，用于存储同步进度相关的消息字符串，初始为空字符串，服务在同步过程中可以更新该字符串内容，并通过广播发送出去，方便外部组件展示同步进度给用户。
private static String mSyncProgress = "";
// 私有方法，用于启动同步任务的逻辑，首先判断当前是否已经存在正在执行的同步任务（mSyncTask是否为null），
// 如果不存在，则创建一个新的GTaskASyncTask实例，并传入当前服务（this）以及一个完成监听器（OnCompleteListener），
// 在监听器中，当同步任务完成时，会将mSyncTask设置为null，发送一个空消息的广播，并停止该服务自身，然后发送广播通知同步开始，最后执行同步任务。
private void startSync() {
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@ -55,18 +66,24 @@ public class GTaskSyncService extends Service {
mSyncTask.execute();
}
}
// 私有方法，用于取消正在进行的同步任务，如果当前存在正在执行的同步任务（mSyncTask不为null），则调用其cancelSync方法来取消同步操作。
private void cancelSync() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
// 重写Service的onCreate方法，在服务创建时被调用，这里将mSyncTask设置为null，确保每次服务启动时都处于初始状态，准备执行新的同步任务。
@Override
public void onCreate() {
mSyncTask = null;
}
// 重写Service的onStartCommand方法，当通过startService方法启动服务时会调用此方法，用于处理传入的意图（Intent）并根据其中携带的同步操作类型执行相应操作，
// 首先从意图中获取额外数据的Bundle对象，然后判断Bundle是否存在且包含指定的同步操作类型键（ACTION_STRING_NAME），
// 如果满足条件，则根据操作类型的值进行switch判断，若是ACTION_START_SYNC则调用startSync方法启动同步，若是ACTION_CANCEL_SYNC则调用cancelSync方法取消同步，
// 最后返回START_STICKY表示服务在被系统意外终止后应该尝试重新启动，以保证同步功能的持续可用性，若不满足条件则调用父类的onStartCommand方法进行默认处理。
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Bundle bundle = intent.getExtras();
@ -85,18 +102,22 @@ public class GTaskSyncService extends Service {
}
return super.onStartCommand(intent, flags, startId);
}
// 重写Service的onLowMemory方法，当系统内存不足时会调用此方法，在这里如果存在正在执行的同步任务（mSyncTask不为null），则调用其cancelSync方法取消同步操作，
// 以释放内存资源，避免因内存不足导致应用出现异常或性能问题。
@Override
public void onLowMemory() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
}
}
// 重写Service的onBind方法，用于处理服务的绑定操作，这里返回null表示该服务不支持绑定操作，即它是通过startService方式启动来执行后台任务的，而不是通过绑定来与其他组件交互。
public IBinder onBind(Intent intent) {
return null;
}
// 用于发送广播的方法，更新同步进度消息（mSyncProgress），创建一个新的意图（Intent），设置其动作（Action）为预定义的广播名称（GTASK_SERVICE_BROADCAST_NAME），
// 并将是否正在同步（mSyncTask是否为null）以及同步进度消息（mSyncProgress）作为额外数据添加到意图中，最后通过sendBroadcast方法发送广播，
// 以便其他组件能够接收到这些同步相关的状态和进度信息。
public void sendBroadcast(String msg) {
mSyncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@ -104,6 +125,8 @@ public class GTaskSyncService extends Service {
intent.putExtra(GTASK_SERVICE_BROADCAST_PROGRESS_MSG, msg);
sendBroadcast(intent);
}
// 静态方法，用于方便地从Activity中启动同步操作，首先通过GTaskManager的单例实例设置关联的Activity上下文对象（用于后续可能的与账户认证等相关操作），
// 然后创建一个意图（Intent），指定要启动的服务为GTaskSyncService，并在意图中设置同步操作类型为ACTION_START_SYNC，最后通过Activity的startService方法启动服务来开始同步。
public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity);
@ -111,17 +134,21 @@ public class GTaskSyncService extends Service {
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_START_SYNC);
activity.startService(intent);
}
// 静态方法，用于从任意上下文（Context）中取消同步操作，创建一个意图（Intent），指定要操作的服务为GTaskSyncService，并在意图中设置同步操作类型为ACTION_CANCEL_SYNC，
// 最后通过上下文的startService方法启动服务来触发取消同步的逻辑，这样在应用的不同地方都可以方便地取消正在进行的同步任务。
public static void cancelSync(Context context) {
Intent intent = new Intent(context, GTaskSyncService.class);
intent.putExtra(GTaskSyncService.ACTION_STRING_NAME, GTaskSyncService.ACTION_CANCEL_SYNC);
context.startService(intent);
}
// 静态方法，用于外部组件判断当前是否正在进行同步操作，通过检查静态变量mSyncTask是否为null来返回相应的布尔值，表示当前是否有同步任务正在执行。
public static boolean isSyncing() {
return mSyncTask != null;
}
// 静态方法，用于外部组件获取当前的同步进度消息字符串，直接返回存储同步进度消息的静态变量mSyncProgress，以便展示给用户同步的进展情况。
public static String getProgressString() {
return mSyncProgress;
}

88
src/Notes-master/src/net/micode/notes/model/Note.java
Unescape View File

@ -33,11 +33,24 @@ import net.micode.notes.data.Notes.TextNote;
import java.util.ArrayList;
// Note类代表笔记的数据模型，用于管理笔记的各种属性数据（如文本数据、通话记录数据等）以及与本地数据库（通过Content Provider）的交互操作，
// 包括创建新笔记、更新笔记、判断笔记是否有本地修改等功能，内部还嵌套了一个NoteData类用于更细致地管理笔记相关的数据内容。
public class Note {
// 用于存储笔记中发生变化的属性值（以键值对形式），通过ContentValues来方便后续与内容提供者进行更新操作，记录笔记在本地修改后产生的数据差异。
private ContentValues mNoteDiffValues;
// NoteData类型的实例，用于管理笔记中的具体数据内容，如文本数据、通话数据等，将不同类型的数据操作封装在这个内部类中，使代码结构更清晰。
private NoteData mNoteData;
// 用于日志记录的标签，方便在日志中识别该类相关的输出信息，取固定的字符串"Note"。
private static final String TAG = "Note";
// 静态同步方法，用于创建一个新的笔记并返回其在数据库中的唯一标识符（ID），接收应用上下文（Context）和所属文件夹的ID作为参数，
// 在方法内部首先创建一个ContentValues对象，设置笔记的创建时间、修改时间、类型、本地修改标记以及父文件夹ID等初始属性值，
// 然后通过内容解析器（ContentResolver）将这些数据插入到本地数据库对应的笔记内容URI（Notes.CONTENT_NOTE_URI）中，
// 接着尝试从插入后返回的Uri中解析出笔记的ID，如果解析出现异常或者ID值为非法值（如 -1）则进行相应的错误处理并返回0或抛出异常，正常情况下返回新创建笔记的ID。
public static synchronized long getNewNoteId(Context context, long folderId) {
/**
* Create a new note id for adding a new note to databases
*/
@ -64,42 +77,55 @@ public class Note {
}
return noteId;
}
// Note类的默认构造函数，用于初始化Note对象，创建一个新的ContentValues对象用于存储笔记的差异数据，同时创建一个NoteData对象来管理具体的笔记数据内容。
public Note() {
mNoteDiffValues = new ContentValues();
mNoteData = new NoteData();
}
// 用于设置笔记的通用属性值的方法，接收属性的键（key）和值（value）作为参数，将键值对添加到mNoteDiffValues中，
// 同时更新笔记的本地修改标记（LOCAL_MODIFIED）为已修改状态，并设置修改日期（MODIFIED_DATE）为当前时间，以便后续能准确判断笔记是否有修改以及进行相应的更新操作。
public void setNoteValue(String key, String value) {
mNoteDiffValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
// 用于设置笔记文本数据的方法，调用内部NoteData对象的setTextData方法，将文本数据的键值对传递给它进行处理，内部会根据情况更新相关的修改标记和日期等信息。
public void setTextData(String key, String value) {
mNoteData.setTextData(key, value);
}
// 用于设置笔记文本数据的唯一标识符（ID）的方法，直接调用内部NoteData对象的setTextDataId方法，将传入的ID值传递给它进行设置，同时会进行参数合法性检查（ID需大于0）。
public void setTextDataId(long id) {
mNoteData.setTextDataId(id);
}
// 用于获取笔记文本数据的唯一标识符（ID）的方法，直接返回内部NoteData对象中存储的文本数据ID（mTextDataId）。
public long getTextDataId() {
return mNoteData.mTextDataId;
}
// 用于设置笔记通话数据的唯一标识符（ID）的方法，调用内部NoteData对象的setCallDataId方法，将传入的ID值传递给它进行设置，同时会进行参数合法性检查（ID需大于0）。
public void setCallDataId(long id) {
mNoteData.setCallDataId(id);
}
// 用于设置笔记通话数据的方法，调用内部NoteData对象的setCallData方法，将通话数据的键值对传递给它进行处理，内部会根据情况更新相关的修改标记和日期等信息。
public void setCallData(String key, String value) {
mNoteData.setCallData(key, value);
}
// 用于判断笔记是否在本地有修改的方法，通过检查mNoteDiffValues中是否有数据（即是否有属性被修改）以及内部NoteData对象是否有本地修改来综合判断，
// 如果两者中任意一个有数据变化，则表示笔记在本地有修改，返回true，否则返回false。
public boolean isLocalModified() {
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
}
// 用于将本地修改后的笔记数据同步到本地数据库的方法，接收应用上下文（Context）和笔记的ID（noteId）作为参数，首先进行参数合法性检查（noteId需大于0），
// 如果笔记没有本地修改则直接返回true，表示无需同步操作。若有本地修改，则先尝试通过内容解析器（ContentResolver）根据mNoteDiffValues中的数据更新笔记的基本属性信息，
// 如果更新失败（返回0表示影响的行数为0，即更新未成功）则记录错误日志但不立即返回，继续往下执行，接着清空mNoteDiffValues已同步的数据。
// 然后检查内部NoteData对象是否有本地修改，如果有且将其数据推送到内容解析器（通过pushIntoContentResolver方法）失败，则返回false表示同步失败，
// 否则返回true表示整个笔记数据（包括基本属性和具体数据内容）同步成功。
public boolean syncNote(Context context, long noteId) {
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
@ -129,35 +155,44 @@ public class Note {
return true;
}
// 内部私有类NoteData，用于更细致地管理笔记中的具体数据内容，包括文本数据和通话数据相关的属性、操作以及与内容提供者的交互逻辑，将这些与数据内容相关的操作封装在内部类中，
// 使Note类整体结构更清晰，职责更明确，避免不同类型数据操作的代码相互混杂。
private class NoteData {
private long mTextDataId;
// 用于存储笔记文本数据的唯一标识符（ID），初始化为0，在插入或更新文本数据时会根据情况进行赋值或更新。
// 用于存储笔记文本数据的具体属性值（以键值对形式），通过ContentValues方便后续与内容提供者进行插入或更新操作，记录文本数据的相关内容。
private ContentValues mTextDataValues;
// 用于存储笔记通话数据的唯一标识符（ID），初始化为0，在插入或更新通话数据时会根据情况进行赋值或更新。
private long mCallDataId;
// 用于存储笔记通话数据的具体属性值（以键值对形式），通过ContentValues方便后续与内容提供者进行插入或更新操作，记录通话数据的相关内容。
private ContentValues mCallDataValues;
// 用于日志记录的标签，方便在日志中识别该内部类相关的输出信息，取固定的字符串"NoteData"。
private static final String TAG = "NoteData";
// NoteData类的默认构造函数，用于初始化NoteData对象，创建新的ContentValues对象分别用于存储文本数据和通话数据的属性值，同时将文本数据和通话数据的ID初始化为0。
public NoteData() {
mTextDataValues = new ContentValues();
mCallDataValues = new ContentValues();
mTextDataId = 0;
mCallDataId = 0;
}
// 用于判断NoteData对象中的文本数据或通话数据是否有本地修改的方法，通过检查mTextDataValues和mCallDataValues中是否有数据（即是否有属性被修改）来综合判断，
// 如果两者中任意一个有数据变化，则表示有本地修改，返回true，否则返回false。
boolean isLocalModified() {
return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
}
// 用于设置笔记文本数据的唯一标识符（ID）的方法，进行参数合法性检查（ID需大于0），如果合法则将传入的ID值赋值给mTextDataId，用于后续对文本数据的操作定位等。
void setTextDataId(long id) {
if(id <= 0) {
throw new IllegalArgumentException("Text data id should larger than 0");
}
mTextDataId = id;
}
} // 用于设置笔记通话数据的唯一标识符（ID）的方法，进行参数合法性检查（ID需大于0），如果合法则将传入的ID值赋值给mCallDataId，用于后续对通话数据的操作定位等。
void setCallDataId(long id) {
if (id <= 0) {
@ -165,19 +200,30 @@ public class Note {
}
mCallDataId = id;
}
// 用于设置笔记通话数据的方法，接收通话数据的键（key）和值（value）作为参数，将键值对添加到mCallDataValues中，
// 同时更新笔记的本地修改标记（通过外部的mNoteDiffValues间接更新，因为NoteData是内部类可以访问外部类的成员）以及修改日期为当前时间，以便能准确判断笔记整体是否有修改以及进行相应的更新操作。
void setCallData(String key, String value) {
mCallDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
// 用于设置笔记文本数据的方法，接收文本数据的键（key）和值（value）作为参数，将键值对添加到mTextDataValues中，
// 同时更新笔记的本地修改标记（通过外部的mNoteDiffValues间接更新）以及修改日期为当前时间，以便能准确判断笔记整体是否有修改以及进行相应的更新操作。
void setTextData(String key, String value) {
mTextDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
// 用于将NoteData对象中管理的文本数据和通话数据推送到内容解析器（即更新或插入到本地数据库）的方法，接收应用上下文（Context）和笔记的ID（noteId）作为参数，
// 首先进行参数合法性检查（noteId需大于0），然后创建一个ContentProviderOperation列表（用于批量操作），根据mTextDataValues和mCallDataValues中的数据情况进行不同的操作：
// 如果文本数据有值（mTextDataValues.size() > 0），则设置笔记ID到文本数据属性中，如果文本数据的ID为0（表示是新数据需要插入），则设置文本数据的MIME类型，
// 通过内容解析器将文本数据插入到本地数据库对应的内容URI（Notes.CONTENT_DATA_URI）中，并尝试从插入后返回的Uri中解析出文本数据的ID，如果解析失败则记录错误日志并清空文本数据属性值，返回null表示操作失败；
// 如果文本数据的ID不为0（表示是已有数据需要更新），则构建一个更新操作并添加到操作列表中。然后对通话数据进行类似的处理（根据mCallDataValues的情况进行插入或更新操作）。
// 最后如果操作列表中有操作需要执行，则通过内容解析器批量应用这些操作（applyBatch方法），根据操作结果返回相应的Uri（如果成功则返回笔记对应的Uri，失败则返回null），
// 如果在批量操作过程中出现RemoteException或OperationApplicationException异常则记录错误日志并返回null表示操作失败。如果操作列表为空则直接返回null表示无需进行数据推送操作。
Uri pushIntoContentResolver(Context context, long noteId) {
/**
* Check for safety

195
src/Notes-master/src/net/micode/notes/model/WorkingNote.java
Unescape View File

@ -30,38 +30,55 @@ import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.tool.ResourceParser.NoteBgResources;
// `WorkingNote` 类代表正在操作（编辑、修改等）的笔记对象，它封装了笔记的各种属性（如内容、ID、提醒日期、背景颜色等）以及相关的操作方法（如保存、加载、设置属性值等），
// 同时定义了一个接口用于监听笔记设置相关属性变化的情况，以便在属性改变时能做出相应的业务逻辑处理，是笔记在应用中实际使用场景下的一个综合数据和操作模型。
public class WorkingNote {
// 关联的 `Note` 类对象，用于处理笔记底层的数据操作（如同步到数据库等），借助 `Note` 类已有的功能来实现 `WorkingNote` 的相关持久化等操作。
// Note for the working note
private Note mNote;
// 笔记的唯一标识符（ID），用于在数据库等场景中唯一标识该笔记，初始值根据不同的构造函数可能为0（新创建笔记时）或从已有数据中获取的具体ID值。
// Note Id
private long mNoteId;
// 笔记的具体内容，比如用户输入的文本等信息，用于展示和编辑笔记的核心文本数据。
// Note content
private String mContent;
// 笔记的模式，可能用于表示不同的展示或编辑模式（例如是否为清单模式等），具体含义由应用业务逻辑决定，初始化为0。
// Note mode
private int mMode;
// 笔记的提醒日期，用于设置和记录该笔记是否有提醒以及提醒的时间点，初始化为0表示无提醒。
private long mAlertDate;
// 笔记的最后修改日期，用于记录笔记最后一次被修改的时间，初始化为当前系统时间（在构造新笔记时）。
private long mModifiedDate;
// 笔记的背景颜色资源ID，用于设置和获取笔记展示时的背景颜色，初始值会根据具体业务场景设定或默认值赋值。
private int mBgColorId;
// 关联的桌面小部件（Widget）的ID，用于标识该笔记是否与某个桌面小部件相关联以及是哪个小部件，初始值根据情况设定，若未关联则可能为无效值（`AppWidgetManager.INVALID_APPWIDGET_ID`）。
private int mWidgetId;
// 桌面小部件的类型，用于区分不同类型的小部件与笔记的关联情况，初始值根据业务逻辑设定，可能有特定的枚举值（如 `Notes.TYPE_WIDGET_INVALIDE` 表示无效类型等）。
private int mWidgetType;
// 笔记所属文件夹的ID，用于表示笔记在文件系统结构中的所属位置，便于分类管理笔记，初始值根据构造函数传入参数确定。
private long mFolderId;
// 应用的上下文（Context）对象，用于获取系统服务、资源以及与内容提供者（Content Provider）等进行交互，是整个类中很多操作的基础依赖。
private Context mContext;
// 用于日志记录的标签，方便在日志中识别该类相关的输出信息，取固定的字符串"WorkingNote"。
private static final String TAG = "WorkingNote";
// 标记笔记是否已被删除的布尔值，初始化为 `false`，通过相关方法可以设置为 `true` 来表示笔记已被删除状态，在保存等操作中会根据此标记进行相应处理。
private boolean mIsDeleted;
// 定义一个接口类型的变量，用于监听笔记设置相关属性（如背景颜色、提醒等）变化的情况，外部类可以实现该接口并注册进来，以便在属性改变时能收到通知并执行相应逻辑。
private NoteSettingChangedListener mNoteSettingStatusListener;
// 定义一个字符串数组，用于查询笔记数据时指定要获取的列，包含了数据的ID、内容、MIME类型以及一些其他自定义的数据字段（DATA1 - DATA4），方便从数据库中获取完整的笔记数据信息。
public static final String[] DATA_PROJECTION = new String[] {
DataColumns.ID,
DataColumns.CONTENT,
@ -71,7 +88,8 @@ public class WorkingNote {
DataColumns.DATA3,
DataColumns.DATA4,
};
// 定义一个字符串数组，用于查询笔记基本属性时指定要获取的列，包含了父文件夹ID、提醒日期、背景颜色ID、小部件ID、小部件类型以及修改日期等字段，用于从数据库中获取笔记的关键属性信息。
public static final String[] NOTE_PROJECTION = new String[] {
NoteColumns.PARENT_ID,
NoteColumns.ALERTED_DATE,
@ -80,27 +98,39 @@ public class WorkingNote {
NoteColumns.WIDGET_TYPE,
NoteColumns.MODIFIED_DATE
};
// 定义一个常量，表示在 `DATA_PROJECTION` 数组中数据ID列的索引位置，方便在查询结果的游标（Cursor）中准确获取对应的数据，值为0，对应数组的第一个元素位置。
private static final int DATA_ID_COLUMN = 0;
// 定义一个常量，表示在 `DATA_PROJECTION` 数组中数据内容列的索引位置，用于从游标中获取笔记的具体内容数据，值为1。
private static final int DATA_CONTENT_COLUMN = 1;
// 定义一个常量，表示在 `DATA_PROJECTION` 数组中数据MIME类型列的索引位置，用于判断数据的类型（如文本笔记、通话笔记等），值为2。
private static final int DATA_MIME_TYPE_COLUMN = 2;
// 定义一个常量，表示在 `DATA_PROJECTION` 数组中数据模式列（可能用于表示笔记的特定展示或编辑模式）的索引位置，值为3。
private static final int DATA_MODE_COLUMN = 3;
// 定义一个常量，表示在 `NOTE_PROJECTION` 数组中父文件夹ID列的索引位置，用于从游标中获取笔记所属文件夹的ID信息，值为0。
private static final int NOTE_PARENT_ID_COLUMN = 0;
// 定义一个常量，表示在 `NOTE_PROJECTION` 数组中提醒日期列的索引位置，用于获取笔记的提醒时间信息，值为1。
private static final int NOTE_ALERTED_DATE_COLUMN = 1;
// 定义一个常量，表示在 `NOTE_PROJECTION` 数组中背景颜色ID列的索引位置，用于获取笔记的背景颜色设置信息，值为2。
private static final int NOTE_BG_COLOR_ID_COLUMN = 2;
// 定义一个常量，表示在 `NOTE_PROJECTION` 数组中小部件ID列的索引位置，用于获取与笔记关联的小部件的ID信息，值为3。
private static final int NOTE_WIDGET_ID_COLUMN = 3;
private static final int NOTE_WIDGET_TYPE_COLUMN = 4;
// 定义一个常量，表示在 `NOTE_PROJECTION` 数组中小部件类型列的索引位置，用于获取小部件的类型信息，值为4。
private static fina int NOTE_WIDGET_TYPE_COLUMN = 4;
// 定义一个常量，表示在 `NOTE_PROJECTION` 数组中修改日期列的索引位置，用于获取笔记最后一次被修改的时间信息，值为5。
private static final int NOTE_MODIFIED_DATE_COLUMN = 5;
// 私有构造函数，用于创建一个新的（空的）工作笔记对象，接收应用上下文（Context）和所属文件夹的ID作为参数，初始化各种属性的初始值，
// 如提醒日期设为0，修改日期设为当前系统时间，创建一个新的 `Note` 对象用于后续数据操作，笔记ID初始化为0，标记为未删除状态，笔记模式设为0，小部件类型设为无效类型等。
// New note construct
private WorkingNote(Context context, long folderId) {
mContext = context;
@ -113,7 +143,9 @@ public class WorkingNote {
mMode = 0;
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
}
// 私有构造函数，用于加载一个已存在的笔记对象，接收应用上下文（Context）、笔记的ID（noteId）以及所属文件夹的ID作为参数，初始化相关属性，
// 然后调用 `loadNote` 方法从数据库中加载笔记的基本属性信息，再调用 `loadNoteData` 方法加载笔记的具体数据内容（如文本内容等）。
// Existing note construct
private WorkingNote(Context context, long noteId, long folderId) {
mContext = context;
@ -124,7 +156,11 @@ public class WorkingNote {
loadNote();
}
private void loadNote() {
// 私有方法，用于从数据库中加载笔记的基本属性信息，通过内容解析器（ContentResolver）根据笔记的ID查询指定列（`NOTE_PROJECTION`）的数据，
// 如果查询到游标（Cursor）不为空且能移动到第一条记录（表示有数据），则从游标中获取父文件夹ID、背景颜色ID、小部件ID、小部件类型、提醒日期以及修改日期等属性值，
// 最后关闭游标，若游标为空则表示找不到对应的笔记，记录错误日志并抛出异常表示无法找到指定ID的笔记。
private void loadNote()
Cursor cursor = mContext.getContentResolver().query(
ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, mNoteId), NOTE_PROJECTION, null,
null, null);
@ -145,7 +181,10 @@ public class WorkingNote {
}
loadNoteData();
}
// 私有方法，用于从数据库中加载笔记的具体数据内容，通过内容解析器查询笔记对应的数据（根据 `DATA_PROJECTION` 指定列），条件是数据所属的笔记ID与当前笔记ID匹配，
// 如果查询到游标不为空且能移动到第一条记录，则循环遍历游标（因为可能有多条数据，比如不同类型的数据），根据数据的MIME类型判断是文本笔记还是通话笔记等，
// 分别进行相应的处理（如设置文本数据ID、通话数据ID或者记录错误日志表示类型错误），最后关闭游标，若游标为空则表示找不到对应笔记的数据，记录错误日志并抛出异常。
private void loadNoteData() {
Cursor cursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI, DATA_PROJECTION,
DataColumns.NOTE_ID + "=?", new String[] {
@ -173,7 +212,9 @@ public class WorkingNote {
throw new IllegalArgumentException("Unable to find note's data with id " + mNoteId);
}
}
// 静态工厂方法，用于创建一个新的空笔记对象，接收应用上下文（Context）、所属文件夹的ID、小部件ID、小部件类型以及默认背景颜色资源ID作为参数，
// 创建一个 `WorkingNote` 对象，设置其背景颜色ID、小部件ID和小部件类型属性值，最后返回创建好的对象，方便在需要创建新笔记时统一调用此方法进行初始化操作。
public static WorkingNote createEmptyNote(Context context, long folderId, int widgetId,
int widgetType, int defaultBgColorId) {
WorkingNote note = new WorkingNote(context, folderId);
@ -182,7 +223,9 @@ public class WorkingNote {
note.setWidgetType(widgetType);
return note;
}
// 静态工厂方法，用于加载一个已存在的笔记对象，接收应用上下文（Context）和笔记的ID作为参数，通过调用私有构造函数（传入相应参数）创建并返回对应的 `WorkingNote` 对象，
// 方便在需要获取并操作已有笔记时统一使用此方法进行加载操作。
public static WorkingNote load(Context context, long id) {
return new WorkingNote(context, id, 0);
}
@ -211,11 +254,17 @@ public class WorkingNote {
return false;
}
}
// 同步方法，用于保存笔记的相关数据到数据库，首先通过 `isWorthSaving` 方法判断笔记是否值得保存（比如是否已删除、内容是否为空且不存在于数据库、是否有本地修改等情况），
// 如果值得保存，若笔记不存在于数据库中（通过 `existInDatabase` 方法判断，即笔记ID小于等于0），则调用 `Note` 类的 `getNewNoteId` 方法尝试创建一个新的笔记ID，
// 如果创建失败则记录错误日志并返回 `false`，若创建成功则获取到新的笔记ID。然后调用 `mNote`（`Note` 类对象）的 `syncNote` 方法将笔记数据同步到数据库中。
// 最后，如果笔记关联了有效的小部件（小部件ID不为无效值且小部件类型有效）并且设置了 `NoteSettingChangedListener` 监听器，则调用监听器的 `onWidgetChanged` 方法通知小部件相关内容可能已改变，
// 整个保存操作成功则返回 `true`，否则返回 `false`。
public boolean existInDatabase() {
return mNoteId > 0;
}
// 用于判断笔记是否已经存在于数据库中的方法，通过检查笔记的ID是否大于0来返回相应的布尔值，如果大于0则表示已存在，否则表示不存在。
private boolean isWorthSaving() {
if (mIsDeleted || (!existInDatabase() && TextUtils.isEmpty(mContent))
|| (existInDatabase() && !mNote.isLocalModified())) {
@ -224,11 +273,15 @@ public class WorkingNote {
return true;
}
}
// 私有方法，用于判断笔记是否值得保存，根据多种情况综合判断，比如如果笔记已被标记为删除（`mIsDeleted` 为 `true`），
// 或者笔记不存在于数据库中且内容为空（通过 `TextUtils.isEmpty` 判断内容是否为空字符串），或者笔记已存在于数据库中但没有本地修改（通过 `mNote.isLocalModified` 判断），
// 这些情况下返回 `false`，表示不值得保存，否则返回 `true`，表示值得保存。
public void setOnSettingStatusChangedListener(NoteSettingChangedListener l) {
mNoteSettingStatusListener = l;
}
// 用于设置笔记设置状态变化监听器的方法，接收一个实现了 `NoteSettingChangedListener` 接口的对象作为参数，
// 将其赋值给 `mNoteSettingStatusListener` 变量，这样当笔记的相关设置属性（如背景颜色、提醒等）发生变化时，对应的实现类中的方法就会被调用，实现相应的业务逻辑处理。
public void setAlertDate(long date, boolean set) {
if (date != mAlertDate) {
mAlertDate = date;
@ -238,7 +291,10 @@ public class WorkingNote {
mNoteSettingStatusListener.onClockAlertChanged(date, set);
}
}
// 用于标记笔记是否被删除的方法，接收一个布尔值（`mark`）作为参数，将 `mIsDeleted` 属性设置为传入的布尔值，
// 如果笔记关联了有效的小部件（小部件ID不为无效值且小部件类型有效）并且设置了 `NoteSettingChangedListener` 监听器，则调用监听器的 `onWidgetChanged` 方法通知小部件相关内容可能已改变，
// 以此来应对笔记删除状态变化后可能需要的业务逻辑处理（比如小部件中对应笔记的显示更新等）。
public void markDeleted(boolean mark) {
mIsDeleted = mark;
if (mWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID
@ -246,7 +302,10 @@ public class WorkingNote {
mNoteSettingStatusListener.onWidgetChanged();
}
}
// 用于设置笔记背景颜色资源ID的方法，接收一个整数（`id`）作为参数，
// 首先比较传入的ID和当前的背景颜色ID是否不同，如果不同则更新 `mBgColorId` 属性为传入的ID，并通过 `mNote` 对象调用 `setNoteValue` 方法将背景颜色ID的值设置到笔记的对应属性中，
// 然后如果设置了 `NoteSettingChangedListener` 监听器，则调用其 `onBackgroundColorChanged` 方法通知背景颜色已改变，以便外部进行相应的界面更新等操作。
public void setBgColorId(int id) {
if (id != mBgColorId) {
mBgColorId = id;
@ -256,7 +315,10 @@ public class WorkingNote {
mNote.setNoteValue(NoteColumns.BG_COLOR_ID, String.valueOf(id));
}
}
// 用于设置笔记的清单模式（可能用于切换笔记的展示或编辑模式为清单形式等）的方法，接收一个整数（`mode`）作为参数，
// 首先比较传入的模式和当前的模式是否不同，如果不同则更新 `mMode` 属性为传入的模式，并通过 `mNote` 对象调用 `setTextData` 方法将模式的值设置到笔记的对应属性中，
// 然后如果设置了 `NoteSettingChangedListener` 监听器，则调用其 `onCheckListModeChanged` 方法通知清单模式已改变，同时传入旧模式和新模式的值，方便外部进行相应的业务逻辑处理（比如界面切换显示等）。
public void setCheckListMode(int mode) {
if (mMode != mode) {
if (mNoteSettingStatusListener != null) {
@ -266,13 +328,17 @@ public class WorkingNote {
mNote.setTextData(TextNote.MODE, String.valueOf(mMode));
}
}
// 用于设置笔记关联的桌面小部件类型的方法，接收一个整数（`type`）作为参数，
// 比较传入的类型和当前的小部件类型是否不同，如果不同则更新 `mWidgetType` 属性为传入的类型，并通过 `mNote` 对象调用 `setNoteValue` 方法将小部件类型的值设置到笔记的对应属性中。
public void setWidgetType(int type) {
if (type != mWidgetType) {
mWidgetType = type;
mNote.setNoteValue(NoteColumns.WIDGET_TYPE, String.valueOf(mWidgetType));
}
}
} // 用于设置笔记关联的桌面小部件ID的方法，接收一个整数（`id`）作为参数，
// 比较传入的ID和当前的小部件ID是否不同，如果不同则更新 `mWidgetId` 属性为传入的ID，并通过 `mNote` 对象调用 `setNoteValue` 方法将小部件ID的值设置到笔记的对应属性中。
public void setWidgetId(int id) {
if (id != mWidgetId) {
@ -280,68 +346,89 @@ public class WorkingNote {
mNote.setNoteValue(NoteColumns.WIDGET_ID, String.valueOf(mWidgetId));
}
}
// 用于设置笔记的工作文本内容（即核心文本数据）的方法，接收一个字符串（`text`）作为参数，
// 比较传入的文本和当前的文本内容是否相同（通过 `TextUtils.equals` 判断），如果不同则更新 `mContent` 属性为传入的文本，并通过 `mNote` 对象调用 `setTextData` 方法将文本内容设置到笔记的对应属性中。
public void setWorkingText(String text) {
if (!TextUtils.equals(mContent, text)) {
mContent = text;
mNote.setTextData(DataColumns.CONTENT, mContent);
}
}
// 用于将笔记转换为通话笔记的方法，接收电话号码（`phoneNumber`）和通话日期（`callDate`）作为参数，
// 通过 `mNote` 对象分别调用 `setCallData` 方法设置通话日期和电话号码到笔记的对应属性中，同时调用 `setNoteValue` 方法将笔记的父文件夹ID设置为通话记录文件夹的ID（`Notes.ID_CALL_RECORD_FOLDER`），
// 以此来完成笔记类型向通话笔记的转换，可能涉及到对应数据结构和展示等方面的改变，具体由应用的业务逻辑决定。
public void convertToCallNote(String phoneNumber, long callDate) {
mNote.setCallData(CallNote.CALL_DATE, String.valueOf(callDate));
mNote.setCallData(CallNote.PHONE_NUMBER, phoneNumber);
mNote.setNoteValue(NoteColumns.PARENT_ID, String.valueOf(Notes.ID_CALL_RECORD_FOLDER));
}
// 用于判断笔记是否设置了时钟提醒的方法，通过检查 `mAlertDate` 是否大于0来返回相应的布尔值，如果大于0则表示设置了提醒，返回 `true`，否则返回 `false`。
public boolean hasClockAlert() {
return (mAlertDate > 0 ? true : false);
}
// 用于获取笔记内容的方法，直接返回 `mContent` 属性，即笔记的核心文本数据，方便外部获取并展示笔记的具体内容。
public String getContent() {
return mContent;
}
// 用于获取笔记提醒日期的方法，直接返回 `mAlertDate` 属性，即笔记设置的提醒时间点，方便外部查询和使用该提醒日期信息。
public long getAlertDate() {
return mAlertDate;
}
// 用于获取笔记最后修改日期的方法，直接返回 `mModifiedDate` 属性，即笔记最后一次被修改的时间记录，可用于展示、排序等业务场景。
public long getModifiedDate() {
return mModifiedDate;
}
// 用于获取笔记背景颜色资源ID对应的实际背景颜色资源的方法，通过调用 `NoteBgResources` 类的 `getNoteBgResource` 方法（具体实现可能根据资源映射等逻辑获取实际颜色资源），
// 将 `mBgColorId` 作为参数传入，返回获取到的背景颜色资源ID，方便外部进行界面绘制等操作时使用正确的背景颜色资源。
public int getBgColorResId() {
return NoteBgResources.getNoteBgResource(mBgColorId);
}
// 用于获取笔记背景颜色资源ID的方法，直接返回 `mBgColorId` 属性，方便外部获取并记录笔记的背景颜色设置情况。
public int getBgColorId() {
return mBgColorId;
}
// 用于获取笔记标题背景颜色资源ID的方法，通过调用 `NoteBgResources` 类的 `getNoteTitleBgResource` 方法（具体实现类似获取背景颜色资源的逻辑，根据ID获取对应的标题背景颜色资源），
// 将 `mBgColorId` 作为参数传入，返回获取到的标题背景颜色资源ID，方便外部进行界面绘制等操作时使用正确的标题背景颜色资源。
public int getTitleBgResId() {
return NoteBgResources.getNoteTitleBgResource(mBgColorId);
}
// 用于获取笔记的清单模式的方法，直接返回 `mMode` 属性，即笔记当前设置的清单模式值，方便外部获取并判断笔记处于何种展示或编辑模式。
public int getCheckListMode() {
return mMode;
}
} // 用于获取笔记的唯一标识符（ID）的方法，直接返回 `mNoteId` 属性，方便外部在数据库操作、关联查询等场景中使用该笔记的唯一标识。
public long getNoteId() {
return mNoteId;
}
// 用于获取笔记所属文件夹的ID的方法，直接返回 `mFolderId` 属性，方便外部了解笔记在文件系统结构中的位置分类情况，比如用于文件夹相关的查询、统计等操作。
public long getFolderId() {
return mFolderId;
}
// 用于获取笔记关联的桌面小部件ID的方法，直接返回 `mWidgetId` 属性，方便外部获取并操作与笔记相关联的桌面小部件（比如更新小部件显示内容等）。
public int getWidgetId() {
return mWidgetId;
}
// 用于获取笔记关联的桌面小部件类型的方法，直接返回 `mWidgetType` 属性，方便外部获取并判断笔记关联的小部件属于何种类型，以进行相应的业务逻辑处理。
public int getWidgetType() {
return mWidgetType;
}
// 定义一个接口，用于监听笔记设置相关属性变化的情况，外部类需要实现该接口并通过 `setOnSettingStatusChangedListener` 方法注册进来，
// 接口中定义了多个方法，分别对应不同属性变化时的回调通知，比如背景颜色改变、时钟提醒改变、小部件相关改变以及清单模式改变等情况，方便在这些属性变化时执行相应的业务逻辑处理。
public interface NoteSettingChangedListener {
/**
* Called when the background color of current note has just changed

75
src/Notes-master/src/net/micode/notes/tool/BackupUtils.java
Unescape View File

@ -35,57 +35,66 @@ import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
// BackupUtils类用于处理笔记数据的备份相关功能，支持将笔记数据导出为文本格式等操作
public class BackupUtils {
private static final String TAG = "BackupUtils";
// 单例模式相关，用于保存唯一的BackupUtils实例
// Singleton stuff
private static BackupUtils sInstance;
// 获取BackupUtils的单例实例，若不存在则创建新的实例
public static synchronized BackupUtils getInstance(Context context) {
if (sInstance == null) {
sInstance = new BackupUtils(context);
}
return sInstance;
}
/**
* 以下是用于表示备份或恢复状态的常量定义
*/
// 当前外部存储（SD卡）未挂载的状态码
/**
* Following states are signs to represents backup or restore
* status
*/
// Currently, the sdcard is not mounted
public static final int STATE_SD_CARD_UNMOUONTED = 0;
// 备份文件不存在的状态码
// The backup file not exist
public static final int STATE_BACKUP_FILE_NOT_EXIST = 1;
// The data is not well formated, may be changed by other programs
// 数据格式不正确，可能被其他程序修改的状态码
public static final int STATE_DATA_DESTROIED = 2;
// Some run-time exception which causes restore or backup fails
// 运行时出现异常导致备份或恢复失败的状态码
public static final int STATE_SYSTEM_ERROR = 3;
// Backup or restore success
// 备份或恢复成功的状态码
public static final int STATE_SUCCESS = 4;
private TextExport mTextExport;
// 私有构造函数，初始化时创建TextExport对象，用于文本导出相关操作
private BackupUtils(Context context) {
mTextExport = new TextExport(context);
}
// 判断外部存储（通常指SD卡）是否可用，通过比较外部存储状态与MEDIA_MOUNTED常量来判断
private static boolean externalStorageAvailable() {
return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
}
// 调用TextExport的exportToText方法进行文本导出，并返回导出结果状态码
public int exportToText() {
return mTextExport.exportToText();
}
// 获取导出的文本文件名，实际是通过TextExport对象获取其内部保存的文件名
public String getExportedTextFileName() {
return mTextExport.mFileName;
}
// 获取导出的文本文件所在目录，通过TextExport对象获取其内部保存的文件目录
public String getExportedTextFileDir() {
return mTextExport.mFileDirectory;
}
// TextExport内部类，主要负责具体的文本导出逻辑实现
private static class TextExport {
// 查询笔记相关信息的投影数组，定义了要从数据库中获取的笔记字段
private static final String[] NOTE_PROJECTION = {
NoteColumns.ID,
NoteColumns.MODIFIED_DATE,
@ -98,7 +107,7 @@ public class BackupUtils {
private static final int NOTE_COLUMN_MODIFIED_DATE = 1;
private static final int NOTE_COLUMN_SNIPPET = 2;
// 查询笔记数据相关信息的投影数组，定义了要从数据库中获取的笔记数据字段
private static final String[] DATA_PROJECTION = {
DataColumns.CONTENT,
DataColumns.MIME_TYPE,
@ -116,6 +125,7 @@ public class BackupUtils {
private static final int DATA_COLUMN_PHONE_NUMBER = 4;
// 用于格式化导出文本内容的字符串数组，通过资源获取，不同索引对应不同的格式化用途
private final String [] TEXT_FORMAT;
private static final int FORMAT_FOLDER_NAME = 0;
private static final int FORMAT_NOTE_DATE = 1;
@ -124,22 +134,25 @@ public class BackupUtils {
private Context mContext;
private String mFileName;
private String mFileDirectory;
// 构造函数，初始化TEXT_FORMAT数组以及保存传入的上下文对象等信息
public TextExport(Context context) {
TEXT_FORMAT = context.getResources().getStringArray(R.array.format_for_exported_note);
mContext = context;
mFileName = "";
mFileDirectory = "";
}
// 根据传入的索引获取对应的格式化字符串
private String getFormat(int id) {
return TEXT_FORMAT[id];
}
/**
* 将指定文件夹（通过folderId标识）中的笔记导出为文本格式，并写入到给定的PrintStream中
*/
/**
* Export the folder identified by folder id to text
*/
private void exportFolderToText(String folderId, PrintStream ps) {
// 通过内容解析器查询属于该文件夹的笔记信息
// Query notes belong to this folder
Cursor notesCursor = mContext.getContentResolver().query(Notes.CONTENT_NOTE_URI,
NOTE_PROJECTION, NoteColumns.PARENT_ID + "=?", new String[] {
@ -148,24 +161,29 @@ public class BackupUtils {
if (notesCursor != null) {
if (notesCursor.moveToFirst()) {
do {
do { // 格式化并打印笔记的最后修改日期
// Print note's last modified date
ps.println(String.format(getFormat(FORMAT_NOTE_DATE), DateFormat.format(
mContext.getString(R.string.format_datetime_mdhm),
notesCursor.getLong(NOTE_COLUMN_MODIFIED_DATE))));
// 获取当前笔记的ID，用于进一步查询该笔记相关的数据信息并导出
// Query data belong to this note
String noteId = notesCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps);
} while (notesCursor.moveToNext());
}
// 关闭游标，释放资源
notesCursor.close();
}
}
/**
* 将指定ID的笔记导出为文本格式，并写入到给定的PrintStream中
*/
/**
* Export note identified by id to a print stream
*/
private void exportNoteToText(String noteId, PrintStream ps) {
// 通过内容解析器查询属于该笔记的相关数据信息
Cursor dataCursor = mContext.getContentResolver().query(Notes.CONTENT_DATA_URI,
DATA_PROJECTION, DataColumns.NOTE_ID + "=?", new String[] {
noteId
@ -174,6 +192,7 @@ public class BackupUtils {
if (dataCursor != null) {
if (dataCursor.moveToFirst()) {
do {
// 获取电话号码并打印（如果非空）
String mimeType = dataCursor.getString(DATA_COLUMN_MIME_TYPE);
if (DataConstants.CALL_NOTE.equals(mimeType)) {
// Print phone number
@ -185,10 +204,12 @@ public class BackupUtils {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
phoneNumber));
}
// 格式化并打印通话日期
// Print call date
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT), DateFormat
.format(mContext.getString(R.string.format_datetime_mdhm),
callDate)));
// 打印通话附件位置（如果非空）
// Print call attachment location
if (!TextUtils.isEmpty(location)) {
ps.println(String.format(getFormat(FORMAT_NOTE_CONTENT),
@ -203,8 +224,10 @@ public class BackupUtils {
}
} while (dataCursor.moveToNext());
}
// 关闭游标，释放资源
dataCursor.close();
}
// 在每个笔记内容之间写入换行符，用于分隔不同笔记内容
// print a line separator between note
try {
ps.write(new byte[] {
@ -214,11 +237,14 @@ public class BackupUtils {
Log.e(TAG, e.toString());
}
}
/**
* 执行将笔记导出为用户可读的文本格式的主要逻辑，整合了文件夹和笔记的导出操作
*/
/**
* Note will be exported as text which is user readable
*/
public int exportToText() {
// 首先判断外部存储是否可用，如果不可用则返回对应状态码并记录日志
if (!externalStorageAvailable()) {
Log.d(TAG, "Media was not mounted");
return STATE_SD_CARD_UNMOUONTED;
@ -229,6 +255,7 @@ public class BackupUtils {
Log.e(TAG, "get print stream error");
return STATE_SYSTEM_ERROR;
}
// 第一步：查询并导出文件夹（特定条件筛选的文件夹，如通话记录文件夹等）及其内部笔记信息
// First export folder and its notes
Cursor folderCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
@ -253,10 +280,10 @@ public class BackupUtils {
String folderId = folderCursor.getString(NOTE_COLUMN_ID);
exportFolderToText(folderId, ps);
} while (folderCursor.moveToNext());
}
} // 关闭游标，释放资源
folderCursor.close();
}
// 第二步：查询并导出根文件夹下的笔记信息
// Export notes in root's folder
Cursor noteCursor = mContext.getContentResolver().query(
Notes.CONTENT_NOTE_URI,
@ -274,14 +301,16 @@ public class BackupUtils {
String noteId = noteCursor.getString(NOTE_COLUMN_ID);
exportNoteToText(noteId, ps);
} while (noteCursor.moveToNext());
}
} // 关闭游标，释放资源
noteCursor.close();
}
ps.close();
// 关闭PrintStream，完成文件写入操作
return STATE_SUCCESS;
}
/**
* 获取一个指向要导出的文本文件的PrintStream对象，用于后续写入导出内容
*/
/**
* Get a print stream pointed to the file {@generateExportedTextFile}
*/
@ -308,7 +337,9 @@ public class BackupUtils {
return ps;
}
}
/**
* 在外部存储（SD卡）上生成用于存储导入数据的文本文件，如果生成过程出现异常则返回null
*/
/**
* Generate the text file to store imported data
*/

113
src/Notes-master/src/net/micode/notes/tool/DataUtils.java
Unescape View File

@ -33,88 +33,118 @@ import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute;
import java.util.ArrayList;
import java.util.HashSet;
// DataUtils类提供了一系列与笔记数据操作相关的实用方法，例如批量删除笔记、移动笔记到文件夹、查询各种数据状态等
public class DataUtils {
public static final String TAG = "DataUtils";
// 批量删除给定ID集合对应的笔记，跳过系统根文件夹（Notes.ID_ROOT_FOLDER）的删除操作
public static boolean batchDeleteNotes(ContentResolver resolver, HashSet<Long> ids) {
// 如果传入的ID集合为null，记录日志并返回true，表示无需执行删除操作
if (ids == null) {
Log.d(TAG, "the ids is null");
return true;
}
}// 如果ID集合为空，记录日志并返回true，表示没有要删除的笔记
if (ids.size() == 0) {
Log.d(TAG, "no id is in the hashset");
return true;
}
// 用于存储一系列内容提供器操作的列表，后续将批量执行这些操作来删除笔记
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
for (long id : ids) {
// 不允许删除系统根文件夹，若当前ID是系统根文件夹ID，则记录错误日志并跳过该ID的删除操作
if(id == Notes.ID_ROOT_FOLDER) {
Log.e(TAG, "Don't delete system folder root");
continue;
}
} // 创建一个用于删除指定笔记的内容提供器操作构建器，指定要删除的笔记的URI（通过ID构建）
ContentProviderOperation.Builder builder = ContentProviderOperation
.newDelete(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
// 将构建好的操作添加到操作列表中
operationList.add(builder.build());
}
try {
// 批量应用内容提供器操作列表，执行删除笔记的操作，并获取操作结果数组
ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
// 如果结果数组为null，或者长度为0，或者第一个结果为null，表示删除笔记失败，记录日志并返回false
if (results == null || results.length == 0 || results[0] == null) {
Log.d(TAG, "delete notes failed, ids:" + ids.toString());
return false;
}
// 如果成功执行删除操作，返回true
return true;
} catch (RemoteException e) {
// 捕获远程异常，记录详细的错误日志（包含异常的toString和getMessage信息）
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
} catch (OperationApplicationException e) {
// 捕获操作应用异常，记录详细的错误日志（包含异常的toString和getMessage信息）
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
}
return false;
}
// 将指定ID的笔记从源文件夹移动到目标文件夹，通过更新笔记的相关字段来实现移动操作
public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) {
// 创建一个ContentValues对象，用于存储要更新的字段和对应的值
ContentValues values = new ContentValues();
// 设置笔记的新父文件夹ID（目标文件夹ID）
values.put(NoteColumns.PARENT_ID, desFolderId);
// 设置笔记的原始父文件夹ID（源文件夹ID）
values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId);
// 设置本地修改标志为1，表示该笔记有本地修改操作
values.put(NoteColumns.LOCAL_MODIFIED, 1);
// 通过内容解析器更新指定笔记（根据ID确定）的相关字段信息
resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null);
}
// 批量将给定ID集合中的笔记移动到指定的文件夹，通过构建一系列更新操作并批量执行来实现
public static boolean batchMoveToFolder(ContentResolver resolver, HashSet<Long> ids,
long folderId) {
// 如果传入的ID集合为null，记录日志并返回true，表示无需执行移动操作
if (ids == null) {
Log.d(TAG, "the ids is null");
return true;
}
// 用于存储一系列内容提供器操作的列表，后续将批量执行这些操作来移动笔记
ArrayList<ContentProviderOperation> operationList = new ArrayList<ContentProviderOperation>();
for (long id : ids) {
// 创建一个用于更新指定笔记的内容提供器操作构建器，指定要更新的笔记的URI（通过ID构建）
ContentProviderOperation.Builder builder = ContentProviderOperation
.newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id));
// 设置笔记的新父文件夹ID（目标文件夹ID）
builder.withValue(NoteColumns.PARENT_ID, folderId);
// 设置本地修改标志为1，表示该笔记有本地修改操作
builder.withValue(NoteColumns.LOCAL_MODIFIED, 1);
// 将构建好的操作添加到操作列表中
operationList.add(builder.build());
}
try {
// 批量应用内容提供器操作列表，执行移动笔记的操作，并获取操作结果数组
ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList);
// 如果结果数组为null，或者长度为0，或者第一个结果为null，表示移动笔记失败，记录日志并返回false
if (results == null || results.length == 0 || results[0] == null) {
Log.d(TAG, "delete notes failed, ids:" + ids.toString());
return false;
}
// 如果成功执行移动操作，返回true
return true;
} catch (RemoteException e) {
// 捕获远程异常，记录详细的错误日志（包含异常的toString和getMessage信息）
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
} catch (OperationApplicationException e) {
// 捕获操作应用异常，记录详细的错误日志（包含异常的toString和getMessage信息）
Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage()));
}
return false;
}
/**
* 获取除系统文件夹（{@link Notes#TYPE_SYSTEM}类型的文件夹）之外的所有文件夹数量，通过数据库查询统计符合条件的文件夹数量
*/
/**
* Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}}
*/
public static int getUserFolderCount(ContentResolver resolver) {
// 执行数据库查询，从Notes.CONTENT_NOTE_URI对应的表中查询符合条件的文件夹数量，
// 查询条件是文件夹类型为普通文件夹（Notes.TYPE_FOLDER）且父文件夹ID不是回收站文件夹ID（Notes.ID_TRASH_FOLER）
Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI,
new String[] { "COUNT(*)" },
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?",
@ -125,18 +155,23 @@ public class DataUtils {
if(cursor != null) {
if(cursor.moveToFirst()) {
try {
// 尝试从查询结果游标中获取第一列（即统计的数量值）并赋值给count变量
count = cursor.getInt(0);
} catch (IndexOutOfBoundsException e) {
// 若获取数据时出现越界异常，记录错误日志
Log.e(TAG, "get folder count failed:" + e.toString());
} finally {
// 无论是否出现异常，都关闭游标，释放资源
cursor.close();
}
}
}
return count;
}
// 检查指定ID和类型的笔记是否在笔记数据库中可见（不在回收站文件夹中），通过查询数据库判断是否存在符合条件的笔记
public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) {
// 执行数据库查询，从Notes.CONTENT_NOTE_URI对应的表中查询指定ID和类型且不在回收站文件夹中的笔记是否存在
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null,
NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER,
@ -145,60 +180,73 @@ public class DataUtils {
boolean exist = false;
if (cursor != null) {
// 如果查询结果游标中的记录数量大于0，表示存在符合条件的笔记，将exist设为true
if (cursor.getCount() > 0) {
exist = true;
}
// 关闭游标，释放资源
cursor.close();
}
return exist;
}
// 检查指定ID的笔记是否存在于笔记数据库中，通过简单查询判断是否有对应记录
public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
// 执行数据库查询，从Notes.CONTENT_NOTE_URI对应的表中查询指定ID的笔记是否存在，无其他额外查询条件
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId),
null, null, null, null);
boolean exist = false;
if (cursor != null) {
// 如果查询结果游标中的记录数量大于0，表示存在符合条件的笔记，将exist设为true
if (cursor.getCount() > 0) {
exist = true;
}
// 关闭游标，释放资源
cursor.close();
}
return exist;
}
// 检查指定ID的数据是否存在于数据数据库中（此处指与笔记相关的数据，例如可能是附件等数据），通过查询判断是否有对应记录
public static boolean existInDataDatabase(ContentResolver resolver, long dataId) {
// 执行数据库查询，从Notes.CONTENT_DATA_URI对应的表中查询指定ID的数据是否存在，无其他额外查询条件
Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId),
null, null, null, null);
boolean exist = false;
if (cursor != null) {
// 如果查询结果游标中的记录数量大于0，表示存在符合条件的数据，将exist设为true
if (cursor.getCount() > 0) {
exist = true;
}
// 关闭游标，释放资源
cursor.close();
}
return exist;
}
// 检查指定名称的文件夹是否在可见文件夹中（非系统文件夹且不在回收站文件夹中），通过查询数据库判断是否存在符合条件的文件夹
public static boolean checkVisibleFolderName(ContentResolver resolver, String name) {
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
// 执行数据库查询，从Notes.CONTENT_NOTE_URI对应的表中查询指定名称、类型为文件夹且不在回收站文件夹中的文件夹是否存在
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null,
NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER +
" AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER +
" AND " + NoteColumns.SNIPPET + "=?",
new String[] { name }, null);
boolean exist = false;
if(cursor != null) {
// 如果查询结果游标中的记录数量大于0，表示存在符合条件的文件夹，将exist设为true
if(cursor.getCount() > 0) {
exist = true;
}
// 关闭游标，释放资源
cursor.close();
}
return exist;
}
// 获取指定文件夹下所有笔记对应的小部件属性集合，通过查询数据库获取相关信息并构建属性集合
public static HashSet<AppWidgetAttribute> getFolderNoteWidget(ContentResolver resolver, long folderId) {
Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
// 执行数据库查询，从Notes.CONTENT_NOTE_URI对应的表中查询指定文件夹下笔记的小部件ID和小部件类型信息
Cursor c = resolver.query(Notes.CONTENT_NOTE_URI,
new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE },
NoteColumns.PARENT_ID + "=?",
new String[] { String.valueOf(folderId) },
@ -210,40 +258,48 @@ public class DataUtils {
set = new HashSet<AppWidgetAttribute>();
do {
try {
// 构建一个AppWidgetAttribute对象，用于存储小部件的属性信息
AppWidgetAttribute widget = new AppWidgetAttribute();
// 从查询结果游标中获取小部件ID并赋值给widget对象的对应属性
widget.widgetId = c.getInt(0);
// 从查询结果游标中获取小部件类型并赋值给widget对象的对应属性
widget.widgetType = c.getInt(1);
// 将构建好的widget对象添加到属性集合中
set.add(widget);
} catch (IndexOutOfBoundsException e) {
// 若获取数据时出现越界异常，记录错误日志
Log.e(TAG, e.toString());
}
} while (c.moveToNext());
}
} // 关闭游标，释放资源
c.close();
}
return set;
}
} // 根据笔记ID获取对应的电话号码（从通话记录相关的笔记数据中获取），通过数据库查询获取电话号码信息
public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) {
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
// 执行数据库查询，从Notes.CONTENT_DATA_URI对应的表中查询指定笔记ID且类型为通话记录相关的电话号码信息
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.PHONE_NUMBER },
CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?",
new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE },
null);
if (cursor != null && cursor.moveToFirst()) {
try {
try { // 尝试从查询结果游标中获取电话号码字符串并返回
return cursor.getString(0);
} catch (IndexOutOfBoundsException e) {
} catch (IndexOutOfBoundsException e) { // 若获取数据时出现越界异常，记录错误日志
Log.e(TAG, "Get call number fails " + e.toString());
} finally {
} finally { // 关闭游标，释放资源
cursor.close();
}
}
return "";
}
// 根据电话号码和通话日期获取对应的笔记ID（从通话记录相关数据中查找匹配的笔记），通过数据库查询获取笔记ID信息
public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) {
// 执行数据库查询，从Notes.CONTENT_DATA_URI对应的表中查询指定电话号码、通话日期且类型为通话记录相关的笔记ID信息
Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI,
new String [] { CallNote.NOTE_ID },
CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL("
@ -253,18 +309,19 @@ public class DataUtils {
if (cursor != null) {
if (cursor.moveToFirst()) {
try {
try { // 尝试从查询结果游标中获取笔记ID并返回
return cursor.getLong(0);
} catch (IndexOutOfBoundsException e) {
} catch (IndexOutOfBoundsException e) { // 若获取数据时出现越界异常，记录错误日志
Log.e(TAG, "Get call note id fails " + e.toString());
}
}
} // 关闭游标，释放资源
cursor.close();
}
return 0;
}
// 根据笔记ID获取对应的摘要信息（通常是笔记的简短描述等内容），通过数据库查询获取摘要字符串
public static String getSnippetById(ContentResolver resolver, long noteId) {
// 执行数据库查询，从Notes.CONTENT_NOTE_URI对应的表中查询指定笔记ID的摘要信息
Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI,
new String [] { NoteColumns.SNIPPET },
NoteColumns.ID + "=?",
@ -272,16 +329,18 @@ public class DataUtils {
null);
if (cursor != null) {
// 若查询到结果，从游标中获取摘要字符串
String snippet = "";
if (cursor.moveToFirst()) {
snippet = cursor.getString(0);
}
// 关闭游标，释放资源
cursor.close();
return snippet;
}
} // 如果查询失败（游标为null，表示没有找到对应笔记），抛出异常表示未找到指定ID的笔记
throw new IllegalArgumentException("Note is not found with id: " + noteId);
}
// 对传入的摘要字符串进行格式化处理，去除两端空白字符，并截取到换行符之前的内容（如果有换行符）
public static String getFormattedSnippet(String snippet) {
if (snippet != null) {
snippet = snippet.trim();

139
src/Notes-master/src/net/micode/notes/tool/GTaskStringUtils.java
Unescape View File

@ -15,99 +15,154 @@
*/
package net.micode.notes.tool;
// GTaskStringUtils类用于定义一系列与GTask操作、数据结构以及相关文件夹、元数据等有关的字符串常量。
// 这些常量在涉及到GTask相关的JSON数据处理、文件夹标识和元数据管理等功能中会被使用到。
public class GTaskStringUtils {
// 以下是与GTask JSON数据中动作（action）相关的字段名及对应动作类型值的常量定义
// JSON数据中表示动作（action）的唯一标识符的字段名，在整个操作流程中可用于区分不同的具体操作。
public final static String GTASK_JSON_ACTION_ID = "action_id";
// JSON数据中表示动作列表（action_list）的字段名，通常可能用来存放一组操作相关信息的集合，
// 比如包含多个具体操作的详细描述等内容。
public final static String GTASK_JSON_ACTION_LIST = "action_list";
// JSON数据中表示动作类型（action_type）的字段名，通过不同的值来区分具体是哪种操作行为，
// 例如创建、获取、移动、更新等操作。
public final static String GTASK_JSON_ACTION_TYPE = "action_type";
// JSON数据中表示创建（create）类型动作的具体值，当"action_type"字段取值为此常量时，
// 意味着对应的操作是创建相关的数据实体等操作。
public final static String GTASK_JSON_ACTION_TYPE_CREATE = "create";
// JSON数据中表示获取全部（get_all）类型动作的具体值，用于指示要获取所有相关数据的操作，
// 比如获取所有任务、所有列表等情况。
public final static String GTASK_JSON_ACTION_TYPE_GETALL = "get_all";
// JSON数据中表示移动（move）类型动作的具体值，表明对应的操作是将某个数据实体从一个位置移动到另一个位置，
// 例如移动任务到不同的列表等情况。
public final static String GTASK_JSON_ACTION_TYPE_MOVE = "move";
// JSON数据中表示更新（update）类型动作的具体值，代表要对已存在的数据实体进行更新修改的操作，
// 像更新任务的名称、属性等操作会用到此标识。
public final static String GTASK_JSON_ACTION_TYPE_UPDATE = "update";
// JSON数据中表示创建者（creator）的ID字段名，可用于确定执行创建操作的具体用户或者相关主体的唯一标识，
// 在涉及多用户或者多来源数据创建时，可借此追踪创建源头
public final static String GTASK_JSON_CREATOR_ID = "creator_id";
// JSON数据中表示子实体（child_entity）的字段名，可能用于描述某个主实体下包含的子级相关的数据结构，
// 例如一个任务列表下包含的多个子任务等情况可以通过此字段来关联和表示。
public final static String GTASK_JSON_CHILD_ENTITY = "child_entity";
// JSON数据中表示客户端版本（client_version）的字段名，主要用于记录使用该GTask相关功能的客户端应用的版本信息，
// 在数据同步、兼容性处理等场景中可根据此版本信息来判断是否支持某些操作或进行相应的适配。
public final static String GTASK_JSON_CLIENT_VERSION = "client_version";
// JSON数据中表示是否完成（completed）的字段名，常用于任务相关的数据中，用来标记某个任务是否已经完成，
// 例如任务完成状态的记录与判断会依赖于此字段。
public final static String GTASK_JSON_COMPLETED = "completed";
// JSON数据中表示当前列表（current_list_id）的ID字段名，可能用于标识当前操作所涉及的列表的唯一标识，
// 比如在任务移动操作中，可指明当前所在的列表以及要移动到的目标列表等情况。
public final static String GTASK_JSON_CURRENT_LIST_ID = "current_list_id";
// JSON数据中表示默认列表（default_list_id）的ID字段名，用于指定某个默认的列表，
// 例如新创建任务时默认归属的列表等情况可以通过此标识来确定。
public final static String GTASK_JSON_DEFAULT_LIST_ID = "default_list_id";
// JSON数据中表示是否已删除（deleted）的字段名，可用于标记某个数据实体是否已经被删除，
// 在数据清理、回收站相关功能或者同步时判断数据是否已不存在等场景中会用到。
public final static String GTASK_JSON_DELETED = "deleted";
// JSON数据中表示目标列表（dest_list）的字段名，常用于操作涉及到将数据移动或关联到其他列表的情况，
// 比如在移动任务操作中，此字段指明任务要移动到的目标列表的相关信息。
public final static String GTASK_JSON_DEST_LIST = "dest_list";
// JSON数据中表示目标父级（dest_parent）的字段名，可用于表示某个数据实体在移动、关联等操作后的目标父级对象相关信息，
// 例如任务移动后所属的新的父任务或者父列表等情况通过此字段来体现。
public final static String GTASK_JSON_DEST_PARENT = "dest_parent";
// JSON数据中表示目标父级类型（dest_parent_type）的字段名，配合"dest_parent"字段使用，
// 用于明确目标父级对象具体是什么类型，比如是任务组还是普通任务列表等类型区分。
public final static String GTASK_JSON_DEST_PARENT_TYPE = "dest_parent_type";
// JSON数据中表示实体变化量（entity_delta）的字段名，可能用于记录某个数据实体在更新、修改等操作前后的变化差异情况，
// 例如任务的某些属性值发生了改变，通过此字段可以详细记录具体的变化内容。
public final static String GTASK_JSON_ENTITY_DELTA = "entity_delta";
// JSON数据中表示实体类型（entity_type）的字段名，用于区分不同的数据实体类型，
// 像任务（TASK）、任务组（GROUP）等不同类型的数据实体可以通过此字段来标识区分。
public final static String GTASK_JSON_ENTITY_TYPE = "entity_type";
// JSON数据中表示获取已删除数据（get_deleted）的字段名，可能用于发起获取已被标记为删除的数据的相关操作，
// 比如在回收站功能或者数据同步时，查看哪些数据已被删除等情况会用到。
public final static String GTASK_JSON_GET_DELETED = "get_deleted";
// JSON数据中表示数据实体的唯一标识符（id）的字段名，用于唯一确定某个具体的数据实体，
// 无论是任务、列表还是其他相关数据结构，都可以通过此ID进行查找、关联等操作。
public final static String GTASK_JSON_ID = "id";
// JSON数据中表示索引（index）的字段名，可用于在有序的数据集合（如任务列表等）中确定某个数据实体的位置顺序，
// 例如在排序、定位特定位置的任务等场景中会使用到。
public final static String GTASK_JSON_INDEX = "index";
// JSON数据中表示最后修改时间（last_modified）的字段名，用于记录某个数据实体最后一次被修改的时间戳，
// 在数据同步、版本控制以及判断数据是否有更新等场景中，此时间信息非常关键。
public final static String GTASK_JSON_LAST_MODIFIED = "last_modified";
// JSON数据中表示最新同步点（latest_sync_point）的字段名，用于标记在数据同步过程中的最新有效同步位置或者时间点，
// 可帮助确定下次同步从何处开始、哪些数据需要重新同步等情况。
public final static String GTASK_JSON_LATEST_SYNC_POINT = "latest_sync_point";
// JSON数据中表示列表（list_id）的ID字段名，用于唯一标识不同的列表，
// 在涉及到多个列表管理、任务在不同列表间移动等操作时，通过此ID来区分不同的列表。
public final static String GTASK_JSON_LIST_ID = "list_id";
// JSON数据中表示列表（lists）的字段名，通常可能用来存放多个列表相关信息的集合，
// 例如获取所有列表信息或者返回一组列表数据时，可通过此字段进行表示。
public final static String GTASK_JSON_LISTS = "lists";
// JSON数据中表示名称（name）的字段名，常用于表示数据实体（如任务、列表等）的名称属性，
// 方便展示、查找以及用户识别不同的数据实体。
public final static String GTASK_JSON_NAME = "name";
// JSON数据中表示新的标识符（new_id）的字段名，可能在某些操作（如数据复制、克隆或者重新生成ID等情况）下，
// 用于标记新产生的数据实体的唯一标识。
public final static String GTASK_JSON_NEW_ID = "new_id";
// JSON数据中表示笔记（notes）的字段名，可能用于存放与任务、列表等相关的笔记信息，
// 比如用户针对某个任务添加的备注、说明等内容可通过此字段关联存储。
public final static String GTASK_JSON_NOTES = "notes";
// JSON数据中表示父级ID（parent_id）的字段名，用于确定某个数据实体所属的父级对象的唯一标识，
// 例如任务所属的任务组或者列表的ID等情况通过此字段关联表示。
public final static String GTASK_JSON_PARENT_ID = "parent_id";
// JSON数据中表示前一个兄弟节点ID（prior_sibling_id）的字段名，在有序的数据结构（如任务列表按顺序排列）中，
// 可用于定位某个数据实体前一个相邻的兄弟节点的标识，方便进行顺序调整、插入等操作。
public final static String GTASK_JSON_PRIOR_SIBLING_ID = "prior_sibling_id";
// JSON数据中表示操作结果（results）的字段名，常用于存放执行某个操作（如创建、更新、移动等操作）后的返回结果信息，
// 比如操作是否成功、返回的数据等情况通过此字段进行传递和展示。
public final static String GTASK_JSON_RESULTS = "results";
// JSON数据中表示源列表（source_list）的字段名，在涉及数据移动、复制等操作时，
// 用于指明操作数据的原始来源列表的相关信息，与目标列表（dest_list）相对应。
public final static String GTASK_JSON_SOURCE_LIST = "source_list";
// JSON数据中表示任务（tasks）的字段名，通常用于存放一组任务相关信息的集合，
// 比如获取所有任务列表、返回一批任务数据等情况会通过此字段来表示。
public final static String GTASK_JSON_TASKS = "tasks";
// JSON数据中表示类型（type）的字段名，和前面提到的"entity_type"类似，用于区分不同的数据实体类型，
// 不过可能使用场景更通用一些，可用于各种需要区分类型的情况。
public final static String GTASK_JSON_TYPE = "type";
// JSON数据中表示任务组（GROUP）类型的具体值，用于明确某个数据实体是任务组类型，
// 在通过"type"或者"entity_type"字段判断类型时，此常量可作为对应的值来标识任务组。
public final static String GTASK_JSON_TYPE_GROUP = "GROUP";
// JSON数据中表示任务（TASK）类型的具体值，用于确定某个数据实体是普通任务类型，
// 同样在类型判断场景中，以此常量来标识任务类型的数据实体。
public final static String GTASK_JSON_TYPE_TASK = "TASK";
// JSON数据中表示用户（user）的字段名，可能用于存放与操作相关的用户信息，
// 比如操作执行者的用户名、用户ID等相关属性，便于记录操作的归属主体等情况。
public final static String GTASK_JSON_USER = "user";
// 以下是与特定文件夹相关的字符串常量定义，可能用于标识不同功能或用途的文件夹
// 表示与MIUI笔记相关的文件夹前缀字符串，用于在文件夹命名或者标识中区分出属于MIUI笔记相关的文件夹，
// 方便进行针对性的处理或者识别。
public final static String MIUI_FOLDER_PREFFIX = "[MIUI_Notes]";
// 表示默认文件夹的名称常量，可能用于指代某个默认创建或者默认使用的文件夹，
// 例如新笔记、新任务等默认存放的文件夹可以用此名称来表示。
public final static String FOLDER_DEFAULT = "Default";
// 表示通话记录笔记相关的文件夹名称常量，用于专门存放与通话记录笔记相关内容的文件夹标识，
// 便于对通话记录相关笔记进行分类管理和查找等操作。
public final static String FOLDER_CALL_NOTE = "Call_Note";
// 表示元数据（METADATA）相关的文件夹名称常量，可能用于存放各种数据的元数据信息的文件夹，
// 在数据管理、备份恢复以及数据关联等场景中，此文件夹的元数据起着重要作用。
public final static String FOLDER_META = "METADATA";
// 以下是与元数据头部相关的字段名常量定义，用于明确元数据中不同部分的标识
// 表示元数据中GTask的ID（meta_gid）的字段名，在元数据结构里用于存放与之关联的GTask的唯一标识信息，
// 可用于数据关联、同步以及根据GTask查找对应元数据等操作。
public final static String META_HEAD_GTASK_ID = "meta_gid";
// 表示元数据中笔记（meta_note）相关信息的字段名，可能用于存放具体的笔记内容或者笔记相关属性等元数据信息，
// 在处理笔记的元数据时，通过此字段来获取对应的笔记相关数据。
public final static String META_HEAD_NOTE = "meta_note";
// 表示元数据中其他数据（meta_data）相关信息的字段名，可用于存放除了前面特定标识之外的其他各种数据的元数据，
// 例如一些自定义的扩展数据、辅助数据等的元数据都可以通过此字段来表示和管理。
public final static String META_HEAD_DATA = "meta_data";
// 表示元数据中其他数据（meta_data）相关信息的字段名，可用于存放除了前面特定标识之外的其他各种数据的元数据，
// 例如一些自定义的扩展数据、辅助数据等的元数据都可以通过此字段来表示和管理。
public final static String META_NOTE_NAME = "[META INFO] DON'T UPDATE AND DELETE";
}

44
src/Notes-master/src/net/micode/notes/tool/ResourceParser.java
Unescape View File

@ -22,24 +22,39 @@ import android.preference.PreferenceManager;
import net.micode.notes.R;
import net.micode.notes.ui.NotesPreferenceActivity;
// ResourceParser类，主要用于解析和获取各种与资源相关的配置信息，比如背景颜色、字体大小、不同界面元素对应的资源ID等
public class ResourceParser {
// 定义表示黄色的常量，值为0，可能用于标识某种颜色选项或者颜色相关的索引等，具体依业务而定
public static final int YELLOW = 0;
// 定义表示蓝色的常量，值为1，同理可用于颜色相关的标识
public static final int BLUE = 1;
// 定义表示白色的常量，值为2，用于颜色相关的标识
public static final int WHITE = 2;
// 定义表示绿色的常量，值为3，用于颜色相关的标识
public static final int GREEN = 3;
// 定义表示红色的常量，值为4，用于颜色相关的标识
public static final int RED = 4;
// 定义默认的背景颜色ID，初始化为黄色（对应上面定义的YELLOW常量），表示默认情况下使用的背景颜色
public static final int BG_DEFAULT_COLOR = YELLOW;
// 定义表示小字体的常量，值为0，可能用于标识字体大小的不同选项，具体依业务而定
public static final int TEXT_SMALL = 0;
// 定义表示中字体的常量，值为1，用于字体大小相关的标识
public static final int TEXT_MEDIUM = 1;
// 定义表示大字体的常量，值为2，用于字体大小相关的标识
public static final int TEXT_LARGE = 2;
// 定义表示超大字体的常量，值为3，用于字体大小相关的标识
public static final int TEXT_SUPER = 3;
// 定义默认的字体大小ID，初始化为中字体（对应上面定义的TEXT_MEDIUM常量），表示默认情况下使用的字体大小
public static final int BG_DEFAULT_FONT_SIZE = TEXT_MEDIUM;
// NoteBgResources内部类，主要用于管理和获取与笔记背景相关的资源ID，比如编辑笔记时不同颜色对应的背景资源等
public static class NoteBgResources {
// 定义一个静态数组，存储编辑笔记时不同颜色对应的背景资源ID，按照顺序分别对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_EDIT_RESOURCES = new int [] {
R.drawable.edit_yellow,
R.drawable.edit_blue,
@ -48,6 +63,7 @@ public class ResourceParser {
R.drawable.edit_red
};
// 定义一个静态数组，存储编辑笔记时不同颜色对应的标题背景资源ID，同样对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_EDIT_TITLE_RESOURCES = new int [] {
R.drawable.edit_title_yellow,
R.drawable.edit_title_blue,
@ -56,15 +72,19 @@ public class ResourceParser {
R.drawable.edit_title_red
};
// 根据传入的索引id，返回对应的编辑笔记背景资源ID，用于获取特定颜色的编辑笔记背景资源
public static int getNoteBgResource(int id) {
return BG_EDIT_RESOURCES[id];
}
// 根据传入的索引id，返回对应的编辑笔记标题背景资源ID，用于获取特定颜色的编辑笔记标题背景资源
public static int getNoteTitleBgResource(int id) {
return BG_EDIT_TITLE_RESOURCES[id];
}
}
// 根据传入的Context获取默认的背景颜色ID，逻辑是先检查是否在共享偏好设置中设置了特定的背景颜色键值（由NotesPreferenceActivity中的常量指定），
// 如果设置了，则随机返回NoteBgResources中背景资源数组长度范围内的一个索引对应的颜色ID作为背景色；如果没设置，则返回默认的背景颜色ID（BG_DEFAULT_COLOR）
public static int getDefaultBgId(Context context) {
if (PreferenceManager.getDefaultSharedPreferences(context).getBoolean(
NotesPreferenceActivity.PREFERENCE_SET_BG_COLOR_KEY, false)) {
@ -74,7 +94,10 @@ public class ResourceParser {
}
}
// NoteItemBgResources内部类，主要用于管理和获取与笔记列表项背景相关的资源ID，例如列表项不同位置（首个、中间、最后、单独显示等）对应的背景资源
public static class NoteItemBgResources {
// 定义一个静态数组，存储列表项中第一个元素对应的不同颜色背景资源ID，对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_FIRST_RESOURCES = new int [] {
R.drawable.list_yellow_up,
R.drawable.list_blue_up,
@ -83,6 +106,7 @@ public class ResourceParser {
R.drawable.list_red_up
};
// 定义一个静态数组，存储列表项中正常（非首个和最后一个）元素对应的不同颜色背景资源ID，对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_NORMAL_RESOURCES = new int [] {
R.drawable.list_yellow_middle,
R.drawable.list_blue_middle,
@ -91,6 +115,7 @@ public class ResourceParser {
R.drawable.list_red_middle
};
// 定义一个静态数组，存储列表项中最后一个元素对应的不同颜色背景资源ID，对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_LAST_RESOURCES = new int [] {
R.drawable.list_yellow_down,
R.drawable.list_blue_down,
@ -99,6 +124,7 @@ public class ResourceParser {
R.drawable.list_red_down,
};
// 定义一个静态数组，存储单独显示的列表项对应的不同颜色背景资源ID，对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_SINGLE_RESOURCES = new int [] {
R.drawable.list_yellow_single,
R.drawable.list_blue_single,
@ -107,28 +133,36 @@ public class ResourceParser {
R.drawable.list_red_single
};
// 根据传入的索引id，返回对应的列表项首个元素背景资源ID，用于获取特定颜色的列表项首个元素背景资源
public static int getNoteBgFirstRes(int id) {
return BG_FIRST_RESOURCES[id];
}
// 根据传入的索引id，返回对应的列表项最后一个元素背景资源ID，用于获取特定颜色的列表项最后一个元素背景资源
public static int getNoteBgLastRes(int id) {
return BG_LAST_RESOURCES[id];
}
// 根据传入的索引id，返回对应的单独显示的列表项背景资源ID，用于获取特定颜色的单独显示列表项背景资源
public static int getNoteBgSingleRes(int id) {
return BG_SINGLE_RESOURCES[id];
}
// 根据传入的索引id，返回对应的列表项正常元素背景资源ID，用于获取特定颜色的列表项正常元素背景资源
public static int getNoteBgNormalRes(int id) {
return BG_NORMAL_RESOURCES[id];
}
// 返回文件夹对应的背景资源ID，用于获取文件夹显示的背景资源
public static int getFolderBgRes() {
return R.drawable.list_folder;
}
}
// WidgetBgResources内部类，主要用于管理和获取与小部件背景相关的资源ID，例如不同尺寸（2x、4x等）小部件对应的背景资源
public static class WidgetBgResources {
// 定义一个静态数组，存储2x尺寸小部件对应的不同颜色背景资源ID，对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_2X_RESOURCES = new int [] {
R.drawable.widget_2x_yellow,
R.drawable.widget_2x_blue,
@ -137,10 +171,12 @@ public class ResourceParser {
R.drawable.widget_2x_red,
};
// 根据传入的索引id，返回对应的2x尺寸小部件背景资源ID，用于获取特定颜色的2x尺寸小部件背景资源
public static int getWidget2xBgResource(int id) {
return BG_2X_RESOURCES[id];
}
// 定义一个静态数组，存储4x尺寸小部件对应的不同颜色背景资源ID，对应黄色、蓝色、白色、绿色、红色
private final static int [] BG_4X_RESOURCES = new int [] {
R.drawable.widget_4x_yellow,
R.drawable.widget_4x_blue,
@ -149,12 +185,15 @@ public class ResourceParser {
R.drawable.widget_4x_red
};
// 根据传入的索引id，返回对应的4x尺寸小部件背景资源ID，用于获取特定颜色的4x尺寸小部件背景资源
public static int getWidget4xBgResource(int id) {
return BG_4X_RESOURCES[id];
}
}
public static class TextAppearanceResources {
// TextAppearanceResources内部类，主要用于管理和获取与文本外观相关的资源ID，例如不同字体大小对应的文本外观资源，同时处理了一些资源ID获取的边界情况
public static class TextAppearanceResources {
// 定义一个静态数组，存储不同字体大小对应的文本外观资源ID，对应正常、中、大、超大字体外观
private final static int [] TEXTAPPEARANCE_RESOURCES = new int [] {
R.style.TextAppearanceNormal,
R.style.TextAppearanceMedium,
@ -162,6 +201,8 @@ public class ResourceParser {
R.style.TextAppearanceSuper
};
// 根据传入的索引id，返回对应的文本外观资源ID，若传入的id超出了资源数组长度范围，则返回默认的字体大小资源ID（BG_DEFAULT_FONT_SIZE），
// 这里可能是为了处理共享偏好设置中存储的资源ID可能出现越界的情况
public static int getTexAppearanceResource(int id) {
/**
* HACKME: Fix bug of store the resource id in shared preference.
@ -174,6 +215,7 @@ public class ResourceParser {
return TEXTAPPEARANCE_RESOURCES[id];
}
// 返回文本外观资源数组的长度，用于获取文本外观资源的数量情况，比如可以用于循环遍历等操作判断边界
public static int getResourcesSize() {
return TEXTAPPEARANCE_RESOURCES.length;
}

52
src/Notes-master/src/net/micode/notes/ui/AlarmAlertActivity.java
Unescape View File

@ -41,19 +41,26 @@ import java.io.IOException;
public class AlarmAlertActivity extends Activity implements OnClickListener, OnDismissListener {
// 用于存储与提醒相关的笔记等数据的ID（长整型
private long mNoteId;
// 用于存储一段文本内容的字符串，比如笔记的摘要信息等
private String mSnippet;
// 定义文本摘要的最大长度为60个字符
private static final int SNIPPET_PREW_MAX_LEN = 60;
// MediaPlayer对象，用于播放闹钟相关的声音
MediaPlayer mPlayer;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 设置窗口无标题栏
requestWindowFeature(Window.FEATURE_NO_TITLE);
final Window win = getWindow();
// 添加标志使得窗口在屏幕锁定时也能显示
win.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
// 判断屏幕是否亮起，如果没亮，添加额外的窗口标志（保持屏幕常亮等相关设置）
if (!isScreenOn()) {
win.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
| WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
@ -64,77 +71,111 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
Intent intent = getIntent();
try {
// 从传入的Intent中获取数据，解析出路径段中的第二个元素作为mNoteId（假设路径格式符合要求）
mNoteId = Long.valueOf(intent.getData().getPathSegments().get(1));
// 根据mNoteId从内容解析器获取对应的文本摘要mSnippet
mSnippet = DataUtils.getSnippetById(this.getContentResolver(), mNoteId);
// 如果摘要长度超过最大限制，进行截断处理，并添加特定提示字符串
mSnippet = mSnippet.length() > SNIPPET_PREW_MAX_LEN ? mSnippet.substring(0,
SNIPPET_PREW_MAX_LEN) + getResources().getString(R.string.notelist_string_info)
: mSnippet;
} catch (IllegalArgumentException e) {
// 捕获参数异常，打印异常栈信息，并直接返回，不再继续执行后续初始化操作
e.printStackTrace();
return;
}
mPlayer = new MediaPlayer();
// 判断笔记在数据库中的可见性，如果可见
if (DataUtils.visibleInNoteDatabase(getContentResolver(), mNoteId, Notes.TYPE_NOTE)) {
// 弹出操作对话框
showActionDialog();
// 播放闹钟声音
playAlarmSound();
} else {
// 如果不可见，直接结束当前Activity
finish();
}
}
// 判断屏幕是否处于开启状态的方法
private boolean isScreenOn() {
// 获取PowerManager服务
PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
return pm.isScreenOn();
}
// 播放闹钟声音的方法
private void playAlarmSound() {
// 获取默认的闹钟铃声的Uri
Uri url = RingtoneManager.getActualDefaultRingtoneUri(this, RingtoneManager.TYPE_ALARM);
// 获取系统设置中与铃声静音模式相关的流设置参数
int silentModeStreams = Settings.System.getInt(getContentResolver(),
Settings.System.MODE_RINGER_STREAMS_AFFECTED, 0);
// 根据静音模式流设置参数来设置MediaPlayer的音频流类型，确保在合适的音频流上播放声音
if ((silentModeStreams & (1 << AudioManager.STREAM_ALARM)) != 0) {
mPlayer.setAudioStreamType(silentModeStreams);
} else {
mPlayer.setAudioStreamType(AudioManager.STREAM_ALARM);
}
try {
// 设置MediaPlayer的数据源为获取到的铃声Uri
mPlayer.setDataSource(this, url);
// 准备MediaPlayer，使其进入可播放状态
mPlayer.prepare();
// 设置为循环播放模式
mPlayer.setLooping(true);
// 启动MediaPlayer开始播放声音
mPlayer.start();
} catch (IllegalArgumentException e) {
// 捕获参数异常，打印异常栈信息，此处可考虑添加更友好的错误提示等处理
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// 捕获安全异常，打印异常栈信息
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalStateException e) {
// 捕获状态异常，打印异常栈信息
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// 捕获IO异常，打印异常栈信息
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 创建并显示操作对话框的方法
private void showActionDialog() {
// 创建AlertDialog的构建器对象
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
// 设置对话框的标题为应用名称（这里假设对应的字符串资源已正确定义）
dialog.setTitle(R.string.app_name);
// 设置对话框的消息内容为之前获取的文本摘要mSnippet
dialog.setMessage(mSnippet);
// 添加一个“确定”按钮（对应notealert_ok字符串资源），并设置当前类为点击监听器
dialog.setPositiveButton(R.string.notealert_ok, this);
// 如果屏幕处于开启状态，添加一个“进入”按钮（对应notealert_enter字符串资源），同样设置当前类为点击监听器
if (isScreenOn()) {
dialog.setNegativeButton(R.string.notealert_enter, this);
}
// 显示对话框，并设置当前类为对话框关闭监听器
dialog.show().setOnDismissListener(this);
}
// 实现OnClickListener接口的点击事件处理方法
public void onClick(DialogInterface dialog, int which) {
switch (which) {
case DialogInterface.BUTTON_NEGATIVE:
// 当点击了对话框的“取消”按钮（对应BUTTON_NEGATIVE）时
// 创建一个意图，准备启动NoteEditActivity
Intent intent = new Intent(this, NoteEditActivity.class);
intent.setAction(Intent.ACTION_VIEW);
// 将mNoteId作为额外参数传递过去
intent.putExtra(Intent.EXTRA_UID, mNoteId);
startActivity(intent);
break;
@ -142,16 +183,23 @@ public class AlarmAlertActivity extends Activity implements OnClickListener, OnD
break;
}
}
// 实现OnDismissListener接口的对话框关闭事件处理方法
public void onDismiss(DialogInterface dialog) {
// 当对话框关闭时，调用方法停止播放闹钟声音
stopAlarmSound();
// 结束当前Activity
finish();
}
}
// 停止并释放MediaPlayer资源的方法
private void stopAlarmSound() {
if (mPlayer != null) {
// 停止MediaPlayer播放
mPlayer.stop();
// 释放MediaPlayer占用的资源
mPlayer.release();
// 将mPlayer置为null，避免内存泄漏等问题
mPlayer = null;
}
}

38
src/Notes-master/src/net/micode/notes/ui/AlarmInitReceiver.java
Unescape View File

@ -30,35 +30,69 @@ import net.micode.notes.data.Notes.NoteColumns;
public class AlarmInitReceiver extends BroadcastReceiver {
// 定义一个字符串数组，用于指定查询数据库时需要获取的列名
// 这里包含了笔记的ID列和提醒触发日期列
private static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.ALERTED_DATE
};
// 定义常量，表示在查询结果的游标中，笔记ID列所在的索引位置（从0开始计数）
private static final int COLUMN_ID = 0;
// 定义常量，表示在查询结果的游标中，提醒触发日期列所在的索引位置（从0开始计数）
private static final int COLUMN_ALERTED_DATE = 1;
@Override
public void onReceive(Context context, Intent intent) {
// 获取当前的系统时间（以毫秒为单位，从1970年1月1日00:00:00 UTC到当前时间的差值）
long currentDate = System.currentTimeMillis();
// 通过内容解析器查询数据库，获取满足条件的笔记数据
// 参数依次为：
// - Notes.CONTENT_NOTE_URI：要查询的内容提供器的Uri，指向笔记相关的数据表
// - PROJECTION：前面定义的要查询的列名数组
// - NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE：查询条件，筛选出提醒触发日期大于当前时间且类型为普通笔记（假设Notes.TYPE_NOTE表示普通笔记类型）的记录，"?" 是占位符，后续会用具体值替换
// - new String[] { String.valueOf(currentDate) }：用于替换查询条件中占位符 "?" 的实际值，这里传入当前时间的字符串表示
// - null：表示按照默认顺序排序，不需要额外指定排序规则
Cursor c = context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.ALERTED_DATE + ">? AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE,
new String[] { String.valueOf(currentDate) },
null);
// 如果查询结果游标不为空，说明有满足条件的数据
if (c != null) {
// 将游标移动到第一条数据位置，如果有数据则返回true，否则返回false
if (c.moveToFirst()) {
do {
// 从游标中获取提醒触发日期对应的长整型值，根据前面定义的列索引获取
long alertDate = c.getLong(COLUMN_ALERTED_DATE);
// 创建一个新的Intent，用于启动AlarmReceiver这个广播接收器（可能是用于处理闹钟提醒相关逻辑的广播接收器）
Intent sender = new Intent(context, AlarmReceiver.class);
// 给Intent设置数据，通过ContentUris工具类将笔记的ID附加到对应的内容提供器Uri上，这样接收方可以根据这个Uri获取到具体是哪个笔记的提醒
sender.setData(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c.getLong(COLUMN_ID)));
// 创建一个PendingIntent，用于包装前面创建的Intent，以便在合适的时间触发广播
// 参数依次为：
// - context：上下文对象
// - 0：请求码，这里暂时设为0，可以根据实际情况修改，用于区分不同的PendingIntent
// - sender：要包装的Intent
// - 0：标志位，这里暂时设为0，可根据具体需求设置不同标志，比如是否可更新等
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, sender, 0);
// 获取系统的AlarmManager服务，用于设置闹钟提醒相关的操作
AlarmManager alermManager = (AlarmManager) context
.getSystemService(Context.ALARM_SERVICE);
// 使用AlarmManager设置闹钟提醒，根据不同的Android版本可能有不同的处理方式（这里简化处理，实际应用中可能需要更多兼容性考虑）
// 参数依次为：
// - AlarmManager.RTC_WAKEUP：表示闹钟类型，这个类型会在指定的时间唤醒设备（如果设备处于睡眠状态）来触发提醒
// - alertDate：提醒触发的时间戳（毫秒数），即前面从游标中获取到的提醒日期对应的时间
// - pendingIntent：前面创建的用于触发广播的PendingIntent
alermManager.set(AlarmManager.RTC_WAKEUP, alertDate, pendingIntent);
} while (c.moveToNext());
}
} while (c.moveToNext());// 循环处理游标中的每一条满足条件的数据，直到没有下一条数据为止
}
// 关闭游标，释放相关资源
c.close();
}
}

14
src/Notes-master/src/net/micode/notes/ui/AlarmReceiver.java
Unescape View File

@ -21,10 +21,24 @@ import android.content.Context;
import android.content.Intent;
public class AlarmReceiver extends BroadcastReceiver {
/**
* 当接收到广播时会触发该方法，此方法是BroadcastReceiver接口中定义的抽象方法，必须实现。
* 在这里的功能主要是处理闹钟提醒相关广播被触发后的逻辑，启动对应的Activity来展示闹钟提醒界面等相关操作。
*
* @param context 上下文对象，用于获取系统服务、启动Activity等操作，它提供了与应用所在的环境相关的信息。
* @param intent 接收到的广播Intent，里面可能包含了一些与闹钟提醒相关的数据，比如触发闹钟的来源等信息（虽然此代码中未体现对其数据的获取使用）。
*/
@Override
public void onReceive(Context context, Intent intent) {
// 通过setClass方法修改Intent的目标组件，将原本可能指向其他地方（或者没有明确指向）的Intent，
// 重新设置为指向AlarmAlertActivity，也就是将广播触发后的下一步操作引导到展示闹钟提醒界面的Activity上。
intent.setClass(context, AlarmAlertActivity.class);
// 给Intent添加一个标志位FLAG_ACTIVITY_NEW_TASK，这个标志表示当启动Activity时，
// 如果当前任务栈（Task）不存在或者不适合启动该Activity，系统会创建一个新的任务栈来启动这个Activity。
// 因为BroadcastReceiver的生命周期比较特殊，它没有自己的UI界面相关的任务栈，所以需要添加这个标志确保Activity能正常启动。
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
// 使用传入的上下文对象启动设置好的Intent对应的Activity，这样就会从接收到闹钟提醒广播，
// 跳转到展示具体闹钟提醒信息的AlarmAlertActivity界面，让用户看到闹钟提醒相关的内容（如对话框、提示信息等）。
context.startActivity(intent);
}
}

205
src/Notes-master/src/net/micode/notes/ui/DateTimePicker.java
Unescape View File

@ -28,85 +28,129 @@ import android.view.View;
import android.widget.FrameLayout;
import android.widget.NumberPicker;
// DateTimePicker类继承自FrameLayout，可作为界面中的布局容器使用，用于实现日期和时间选择的功能
public class DateTimePicker extends FrameLayout {
// 默认的启用状态，设置为true，表示默认启用该控件
private static final boolean DEFAULT_ENABLE_STATE = true;
// 半天包含的小时数，即12小时（用于12小时制相关逻辑）
private static final int HOURS_IN_HALF_DAY = 12;
// 一整天包含的小时数，即24小时（用于24小时制相关逻辑）
private static final int HOURS_IN_ALL_DAY = 24;
// 一周包含的天数，用于日期选择器相关逻辑，例如循环显示一周内的日期等情况
private static final int DAYS_IN_ALL_WEEK = 7;
// 日期选择器的最小可选值，通常设为0（比如对应一周内第一天的索引等情况）
private static final int DATE_SPINNER_MIN_VAL = 0;
// 日期选择器的最大可选值，根据一周的天数减1来设置，因为索引从0开始
private static final int DATE_SPINNER_MAX_VAL = DAYS_IN_ALL_WEEK - 1;
// 24小时制视图下小时选择器的最小可选值，即0点
private static final int HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW = 0;
// 24小时制视图下小时选择器的最大可选值，即23点
private static final int HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW = 23;
// 12小时制视图下小时选择器的最小可选值，即1点（12小时制中通常显示1 - 12
private static final int HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW = 1;
// 12小时制视图下小时选择器的最大可选值，即12点
private static final int HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW = 12;
// 分钟选择器的最小可选值，即0分钟
private static final int MINUT_SPINNER_MIN_VAL = 0;
// 分钟选择器的最大可选值，即59分钟
private static final int MINUT_SPINNER_MAX_VAL = 59;
// AM/PM选择器的最小可选值，通常设为0（对应AM
private static final int AMPM_SPINNER_MIN_VAL = 0;
// AM/PM选择器的最大可选值，设为1（对应PM）
private static final int AMPM_SPINNER_MAX_VAL = 1;
// 用于选择日期的NumberPicker控件，显示在界面上供用户选择具体日期
private final NumberPicker mDateSpinner;
// 用于选择小时的NumberPicker控件，根据是24小时制还是12小时制显示不同范围的小时值供选择
private final NumberPicker mHourSpinner;
// 用于选择分钟的NumberPicker控件，可选择0 - 59分钟范围内的值
private final NumberPicker mMinuteSpinner;
// 用于选择上午/下午（在12小时制下）的NumberPicker控件，显示AM或PM供选择
private final NumberPicker mAmPmSpinner;
// Calendar对象，用于记录当前选中的日期和时间，方便进行各种时间相关的计算和操作
private Calendar mDate;
// 用于存储要在日期选择器中显示的一周内各天的字符串表示，例如"周一"、"周二"等
private String[] mDateDisplayValues = new String[DAYS_IN_ALL_WEEK];
// 标记当前是否是上午，用于12小时制下时间显示和逻辑处理
private boolean mIsAm;
// 标记当前是否是24小时制视图，如果为true则按24小时制显示时间，否则按12小时制显示
private boolean mIs24HourView;
// 记录该DateTimePicker控件的启用状态，初始化为默认启用状态
private boolean mIsEnabled = DEFAULT_ENABLE_STATE;
// 标记是否正在初始化控件，用于在一些设置方法中避免不必要的重复操作
private boolean mInitialising;
// 定义一个接口，用于监听日期和时间发生变化的事件，外部类可实现该接口来响应时间变化
private OnDateTimeChangedListener mOnDateTimeChangedListener;
// 日期选择器的值变化监听器，当日期选择器的值改变时触发相应逻辑
private NumberPicker.OnValueChangeListener mOnDateChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
// 根据新旧值的差值，在Calendar对象中调整日期，实现日期的增减操作
mDate.add(Calendar.DAY_OF_YEAR, newVal - oldVal);
// 更新日期选择器的显示内容，确保显示的是正确的日期信息
updateDateControl();
// 通知外部监听器（如果有设置的话）日期发生了变化，传递相关时间参数
onDateTimeChanged();
}
};
// 小时选择器的值变化监听器，处理小时值改变时的相关逻辑，如跨天、切换上午/下午等情况
private NumberPicker.OnValueChangeListener mOnHourChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
boolean isDateChanged = false;
Calendar cal = Calendar.getInstance();
// 如果不是24小时制视图（即12小时制）
if (!mIs24HourView) {
// 如果当前不是上午，且旧值是11（12小时制下半天的最后一小时），新值变为12（切换到下午）
if (!mIsAm && oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY) {
cal.setTimeInMillis(mDate.getTimeInMillis());
// 将日期增加一天，因为从上午切换到下午跨越了中午12点，到了下一天
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
} else if (mIsAm && oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis());
// 将日期减少一天，因为从下午切换到上午跨越了中午12点，回到了前一天
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
// 如果是从上午切换到下午或者从下午切换到上午的情况
if (oldVal == HOURS_IN_HALF_DAY - 1 && newVal == HOURS_IN_HALF_DAY ||
oldVal == HOURS_IN_HALF_DAY && newVal == HOURS_IN_HALF_DAY - 1) {
// 切换上午/下午的标记
mIsAm = !mIsAm;
// 更新上午/下午选择器的显示内容，确保显示正确的AM/PM状态
updateAmPmControl();
}
} else {
// 如果是24小时制视图，且从23点变为0点（跨天情况）
if (oldVal == HOURS_IN_ALL_DAY - 1 && newVal == 0) {
cal.setTimeInMillis(mDate.getTimeInMillis());
// 将日期增加一天，因为跨越了一天的边界
cal.add(Calendar.DAY_OF_YEAR, 1);
isDateChanged = true;
} else if (oldVal == 0 && newVal == HOURS_IN_ALL_DAY - 1) {
cal.setTimeInMillis(mDate.getTimeInMillis());
// 将日期减少一天，因为跨越了一天的边界反向变化
cal.add(Calendar.DAY_OF_YEAR, -1);
isDateChanged = true;
}
}
// 根据当前是否是上午以及小时选择器的值，计算出正确的小时数（用于设置到Calendar对象中）
int newHour = mHourSpinner.getValue() % HOURS_IN_HALF_DAY + (mIsAm ? 0 : HOURS_IN_HALF_DAY);
mDate.set(Calendar.HOUR_OF_DAY, newHour);
// 通知外部监听器（如果有设置的话）时间发生了变化，传递相关时间参数
onDateTimeChanged();
// 如果日期有改变，更新年、月、日等相关设置，确保整体时间的准确性
if (isDateChanged) {
setCurrentYear(cal.get(Calendar.YEAR));
setCurrentMonth(cal.get(Calendar.MONTH));
@ -115,12 +159,14 @@ public class DateTimePicker extends FrameLayout {
}
};
// 分钟选择器的值变化监听器，处理分钟值改变时涉及的时间调整逻辑，如可能导致小时、日期变化等情况
private NumberPicker.OnValueChangeListener mOnMinuteChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
int minValue = mMinuteSpinner.getMinValue();
int maxValue = mMinuteSpinner.getMaxValue();
int offset = 0;
// 如果分钟从最大值变为最小值，意味着时间跨越了一个小时边界（可能需要调整小时、日期等）
if (oldVal == maxValue && newVal == minValue) {
offset += 1;
} else if (oldVal == minValue && newVal == maxValue) {
@ -131,6 +177,7 @@ public class DateTimePicker extends FrameLayout {
mHourSpinner.setValue(getCurrentHour());
updateDateControl();
int newHour = getCurrentHourOfDay();
// 如果新的小时数大于等于12（半天的小时数），则标记为下午
if (newHour >= HOURS_IN_HALF_DAY) {
mIsAm = false;
updateAmPmControl();
@ -140,85 +187,113 @@ public class DateTimePicker extends FrameLayout {
}
}
mDate.set(Calendar.MINUTE, newVal);
// 通知外部监听器（如果有设置的话）时间发生了变化，传递相关时间参数
onDateTimeChanged();
}
};
// 上午/下午选择器的值变化监听器，处理上午/下午切换时涉及的小时数调整等逻辑
private NumberPicker.OnValueChangeListener mOnAmPmChangedListener = new NumberPicker.OnValueChangeListener() {
@Override
public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
mIsAm = !mIsAm;
// 如果切换到下午，将小时数增加半天的小时数（12小时）
if (mIsAm) {
mDate.add(Calendar.HOUR_OF_DAY, -HOURS_IN_HALF_DAY);
} else {
// 如果切换到上午，将小时数减少半天的小时数（12小时）
mDate.add(Calendar.HOUR_OF_DAY, HOURS_IN_HALF_DAY);
}
updateAmPmControl();
// 通知外部监听器（如果有设置的话）时间发生了变化，传递相关时间参数
onDateTimeChanged();
}
};
// 定义一个接口，用于外部类监听DateTimePicker的日期和时间变化事件
public interface OnDateTimeChangedListener {
void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute);
}
// 构造方法，接受一个Context参数，使用当前时间作为初始日期创建DateTimePicker实例
public DateTimePicker(Context context) {
this(context, System.currentTimeMillis());
}
// 构造方法，接受一个Context参数和日期的时间戳（long类型），根据指定日期创建DateTimePicker实例，默认按当前系统设置的时间格式（24小时制或12小时制）显示
public DateTimePicker(Context context, long date) {
this(context, date, DateFormat.is24HourFormat(context));
}
// 完整的构造方法，接受Context、日期时间戳和是否是24小时制视图的布尔值作为参数，用于创建DateTimePicker实例并进行初始化设置
public DateTimePicker(Context context, long date, boolean is24HourView) {
super(context);
// 获取当前时间作为初始的日期和时间设置
mDate = Calendar.getInstance();
mInitialising = true;
// 根据当前小时数判断是否是上午（如果大于等于12小时则为下午）
mIsAm = getCurrentHourOfDay() >= HOURS_IN_HALF_DAY;
// 加载datetime_picker布局文件到该控件中，构建其内部的视图结构
inflate(context, R.layout.datetime_picker, this);
// 获取布局中的日期选择器控件，并进行相关设置
mDateSpinner = (NumberPicker) findViewById(R.id.date);
mDateSpinner.setMinValue(DATE_SPINNER_MIN_VAL);
mDateSpinner.setMaxValue(DATE_SPINNER_MAX_VAL);
mDateSpinner.setOnValueChangedListener(mOnDateChangedListener);
// 获取布局中的小时选择器控件，并设置其值变化监听器
mHourSpinner = (NumberPicker) findViewById(R.id.hour);
mHourSpinner.setOnValueChangedListener(mOnHourChangedListener);
// 获取布局中的分钟选择器控件，设置其最小、最大值以及长按更新间隔等属性，并设置值变化监听器
mMinuteSpinner = (NumberPicker) findViewById(R.id.minute);
mMinuteSpinner.setMinValue(MINUT_SPINNER_MIN_VAL);
mMinuteSpinner.setMaxValue(MINUT_SPINNER_MAX_VAL);
mMinuteSpinner.setOnLongPressUpdateInterval(100);
mMinuteSpinner.setOnValueChangedListener(mOnMinuteChangedListener);
// 获取用于显示上午/下午的字符串数组（根据系统语言等设置获取对应的AM/PM字符串
String[] stringsForAmPm = new DateFormatSymbols().getAmPmStrings();
// 获取布局中的上午/下午选择器控件，设置其最小、最大值以及显示的字符串数组，并设置值变化监听器
mAmPmSpinner = (NumberPicker) findViewById(R.id.amPm);
mAmPmSpinner.setMinValue(AMPM_SPINNER_MIN_VAL);
mAmPmSpinner.setMaxValue(AMPM_SPINNER_MAX_VAL);
mAmPmSpinner.setDisplayedValues(stringsForAmPm);
mAmPmSpinner.setOnValueChangedListener(mOnAmPmChangedListener);
// 更新日期选择器的显示内容，使其显示初始的正确日期信息
// update controls to initial state
updateDateControl();
// 更新小时选择器的显示范围等设置，根据是否是24小时制进行相应调整
updateHourControl();
// 更新上午/下午选择器的显示状态，根据是否是24小时制显示或隐藏该控件
updateAmPmControl();
// 设置是否是24小时制视图，根据传入参数进行相应的显示和逻辑调整
set24HourView(is24HourView);
// 设置当前日期为传入的指定日期
// set to current time
setCurrentDate(date);
// 设置该DateTimePicker控件及其内部各个选择器的启用状态
setEnabled(isEnabled());
// 初始化完成，将初始化标记设为false
// set the content descriptions
mInitialising = false;
}
// 重写父类的setEnabled方法，用于设置整个DateTimePicker控件及其内部各个时间选择器的启用状态
@Override
public void setEnabled(boolean enabled) {
if (mIsEnabled == enabled) {
return;
}
super.setEnabled(enabled);
mDateSpinner.setEnabled(enabled);
mMinuteSpinner.setEnabled(enabled);
@ -227,11 +302,13 @@ public class DateTimePicker extends FrameLayout {
mIsEnabled = enabled;
}
// 重写父类的isEnabled方法，用于获取整个DateTimePicker控件的启用状态
@Override
public boolean isEnabled() {
return mIsEnabled;
}
// 获取当前日期的时间戳（以毫秒为单位），返回当前记录在mDate中的日期对应的时间戳
/**
* Get the current date in millis
*
@ -241,6 +318,7 @@ public class DateTimePicker extends FrameLayout {
return mDate.getTimeInMillis();
}
// 根据传入的日期时间戳（long类型）设置当前日期，内部会进一步解析并设置具体的年、月、日、时、分等信息
/**
* Set the current date
*
@ -252,6 +330,7 @@ public class DateTimePicker extends FrameLayout {
setCurrentDate(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH),
cal.get(Calendar.HOUR_OF_DAY), cal.get(Calendar.MINUTE));
}
// 设置当前日期的具体年、月、日、时、分信息，同时会更新
/**
* Set the current date
@ -262,28 +341,37 @@ public class DateTimePicker extends FrameLayout {
* @param hourOfDay The current hourOfDay
* @param minute The current minute
*/
// 设置当前日期的具体年、月、日、时、分信息，通过分别调用对应的设置方法来完成各项设置
public void setCurrentDate(int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
// 调用设置年份的方法
setCurrentYear(year);
// 调用设置月份的方法
setCurrentMonth(month);
// 调用设置日的方法
setCurrentDay(dayOfMonth);
// 调用设置小时的方法
setCurrentHour(hourOfDay);
// 调用设置分钟的方法
setCurrentMinute(minute);
}
/**
* Get current year
* 获取当前日期中的年份信息
*
* @return The current year
* @return 当前的年份，通过Calendar对象获取对应的年份字段值
*/
public int getCurrentYear() {
return mDate.get(Calendar.YEAR);
}
/**
* Set current year
* 设置当前日期的年份
*
* @param year The current year
* @param year 要设置的年份值
* 逻辑说明：如果当前不是在初始化阶段（mInitialising为false），并且传入的年份与当前记录的年份相同，
* 则不进行任何操作直接返回，避免不必要的重复设置。否则，将Calendar对象中的年份字段设置为传入的年份值，
* 接着调用updateDateControl方法更新日期显示相关内容，最后通过onDateTimeChanged方法通知外部监听器（如果有的话）日期发生了变化。
*/
public void setCurrentYear(int year) {
if (!mInitialising && year == getCurrentYear()) {
@ -295,18 +383,21 @@ public class DateTimePicker extends FrameLayout {
}
/**
* Get current month in the year
* 获取当前日期中的月份信息（注意，返回值范围是0 - 11，0表示一月，11表示十二月）
*
* @return The current month in the year
* @return 当前的月份，通过Calendar对象获取对应的月份字段值
*/
public int getCurrentMonth() {
return mDate.get(Calendar.MONTH);
}
/**
* Set current month in the year
* 设置当前日期的月份
*
* @param month The month in the year
* @param month 要设置的月份值（范围同样是0 - 11，对应不同的月份）
* 逻辑说明：如果当前不是在初始化阶段（mInitialising为false），并且传入的月份与当前记录的月份相同，
* 则不进行任何操作直接返回，避免不必要的重复设置。否则，将Calendar对象中的月份字段设置为传入的月份值，
* 接着调用updateDateControl方法更新日期显示相关内容，最后通过onDateTimeChanged方法通知外部监听器（如果有的话）日期发生了变化。
*/
public void setCurrentMonth(int month) {
if (!mInitialising && month == getCurrentMonth()) {
@ -318,18 +409,21 @@ public class DateTimePicker extends FrameLayout {
}
/**
* Get current day of the month
* 获取当前日期是该月中的第几天
*
* @return The day of the month
* @return 当前日在月中的天数，通过Calendar对象获取对应的日字段值
*/
public int getCurrentDay() {
return mDate.get(Calendar.DAY_OF_MONTH);
}
/**
* Set current day of the month
* 设置当前日期是该月中的第几天
*
* @param dayOfMonth The day of the month
* @param dayOfMonth 要设置的日数值（在合理的范围内，根据不同月份的天数限制）
* 逻辑说明：如果当前不是在初始化阶段（mInitialising为false），并且传入的日数值与当前记录的日数值相同，
* 则不进行任何操作直接返回，避免不必要的重复设置。否则，将Calendar对象中的日字段设置为传入的日数值，
* 接着调用updateDateControl方法更新日期显示相关内容，最后通过onDateTimeChanged方法通知外部监听器（如果有的话）日期发生了变化。
*/
public void setCurrentDay(int dayOfMonth) {
if (!mInitialising && dayOfMonth == getCurrentDay()) {
@ -341,13 +435,21 @@ public class DateTimePicker extends FrameLayout {
}
/**
* Get current hour in 24 hour mode, in the range (0~23)
* @return The current hour in 24 hour mode
* 获取当前在24小时制模式下的小时数，范围是0 - 23
*
* @return 当前24小时制下的小时数值，通过Calendar对象获取对应的小时字段值（HOUR_OF_DAY字段）
*/
public int getCurrentHourOfDay() {
return mDate.get(Calendar.HOUR_OF_DAY);
}
/**
* 根据是否是24小时制视图，获取当前的小时数表示
* 如果是24小时制视图，直接返回24小时制下的小时数（与getCurrentHourOfDay方法返回值一致）；
* 如果是12小时制视图，对24小时制下的小时数进行转换，将大于12的小时数减去12，0点转换为12点，以符合12小时制的显示习惯。
*
* @return 根据时间制转换后的当前小时数
*/
private int getCurrentHour() {
if (mIs24HourView){
return getCurrentHourOfDay();
@ -362,9 +464,14 @@ public class DateTimePicker extends FrameLayout {
}
/**
* Set current hour in 24 hour mode, in the range (0~23)
* 设置当前在24小时制模式下的小时数
*
* @param hourOfDay
* @param hourOfDay 要设置的24小时制下的小时数值（范围0 - 23）
* 逻辑说明：如果当前不是在初始化阶段（mInitialising为false），并且传入的小时数值与当前记录的24小时制小时数值相同，
* 则不进行任何操作直接返回，避免不必要的重复设置。否则，先将Calendar对象中的小时字段（HOUR_OF_DAY）设置为传入的小时数值。
* 若不是24小时制视图（即12小时制），根据传入的小时数值判断是上午还是下午，并更新相应的上午/下午标记（mIsAm），
* 同时对传入的小时数值进行调整（如大于12点的情况减去12），然后调用updateAmPmControl方法更新上午/下午选择器的显示内容。
* 最后将小时选择器的值设置为调整后的小时数值，并通过onDateTimeChanged方法通知外部监听器（如果有的话）时间发生了变化。
*/
public void setCurrentHour(int hourOfDay) {
if (!mInitialising && hourOfDay == getCurrentHourOfDay()) {
@ -390,16 +497,19 @@ public class DateTimePicker extends FrameLayout {
}
/**
* Get currentMinute
* 获取当前的分钟数
*
* @return The Current Minute
* @return 当前分钟数值，通过Calendar对象获取对应的分钟字段值
*/
public int getCurrentMinute() {
return mDate.get(Calendar.MINUTE);
}
/**
* Set current minute
* 设置当前的分钟数
* 逻辑说明：如果当前不是在初始化阶段（mInitialising为false），并且传入的分钟数值与当前记录的分钟数值相同，
* 则不进行任何操作直接返回，避免不必要的重复设置。否则，先将分钟选择器的值设置为传入的分钟数值，
* 再将Calendar对象中的分钟字段设置为传入的分钟数值，最后通过onDateTimeChanged方法通知外部监听器（如果有的话）时间发生了变化。
*/
public void setCurrentMinute(int minute) {
if (!mInitialising && minute == getCurrentMinute()) {
@ -411,16 +521,22 @@ public class DateTimePicker extends FrameLayout {
}
/**
* @return true if this is in 24 hour view else false.
* 判断当前是否处于24小时制视图
*
* @return 如果是24小时制视图返回true，否则返回false
*/
public boolean is24HourView () {
return mIs24HourView;
}
/**
* Set whether in 24 hour or AM/PM mode.
* 设置当前是采用24小时制还是AM/PM（12小时制）模式显示时间
*
* @param is24HourView True for 24 hour mode. False for AM/PM mode.
* @param is24HourView 传入true表示设置为24小时制模式，传入false表示设置为12小时制（AM/PM）模式
* 逻辑说明：如果传入的设置值与当前的时间制视图状态（mIs24HourView）相同，则不进行任何操作直接返回。
* 否则，更新mIs24HourView标记为传入的设置值，根据新的时间制设置上午/下午选择器（mAmPmSpinner）的可见性（24小时制下隐藏，12小时制下显示），
* 获取当前24小时制下的小时数，调用updateHourControl方法更新小时选择器的范围设置（根据24小时制或12小时制调整最小值和最大值），
* 调用setCurrentHour方法更新小时选择器的显示值，最后调用updateAmPmControl方法再次确保上午/下午选择器的显示状态正确。
*/
public void set24HourView(boolean is24HourView) {
if (mIs24HourView == is24HourView) {
@ -434,6 +550,17 @@ public class DateTimePicker extends FrameLayout {
updateAmPmControl();
}
/**
* 用于更新日期选择器（mDateSpinner）的显示内容，实现按周循环显示日期的功能
* 具体操作如下：
* 1. 获取一个新的Calendar实例，并将其时间设置为当前记录的日期时间（mDate中的时间）。
* 2. 将该Calendar实例的日期往前推（DAYS_IN_ALL_WEEK / 2 + 1）天，为后续循环生成一周内的日期做准备。
* 3. 清空日期选择器当前显示的内容（设置为null）。
* 4. 通过循环，每次将Calendar实例的日期往后推一天，使用DateFormat对日期进行格式化（格式为"MM.dd EEEE"，即显示月.日 星期X的格式），
* 并将格式化后的字符串存储到mDateDisplayValues数组中，该数组用于设置日期选择器要显示的内容。
* 5. 将日期选择器的显示内容设置为生成的mDateDisplayValues数组，将日期选择器的值设置为一周中间的位置（DAYS_IN_ALL_WEEK / 2），
* 最后调用invalidate方法使日期选择器重新绘制，以显示更新后的内容。
*/
private void updateDateControl() {
Calendar cal = Calendar.getInstance();
cal.setTimeInMillis(mDate.getTimeInMillis());
@ -448,6 +575,12 @@ public class DateTimePicker extends FrameLayout {
mDateSpinner.invalidate();
}
/**
* 根据当前是否是24小时制视图，更新上午/下午选择器（mAmPmSpinner）的显示状态
* 如果是24小时制视图，将上午/下午选择器设置为不可见（GONE）；
* 如果不是24小时制视图（即12小时制），根据当前的上午/下午标记（mIsAm）设置上午/下午选择器的值（AM对应0，PM对应1），
* 并将上午/下午选择器设置为可见（VISIBLE）。
*/
private void updateAmPmControl() {
if (mIs24HourView) {
mAmPmSpinner.setVisibility(View.GONE);
@ -458,6 +591,13 @@ public class DateTimePicker extends FrameLayout {
}
}
/**
* 根据当前是否是24小时制视图，更新小时选择器（mHourSpinner）的范围设置（最小值和最大值）
* 如果是24小时制视图，将小时选择器的最小值设置为HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW（即0），
* 最大值设置为HOUR_SPINNER_MAX_VAL_24_HOUR_VIEW（即23）；
* 如果不是24小时制视图（即12小时制），将小时选择器的最小值设置为HOUR_SPINNER_MIN_VAL_12_HOUR_VIEW（即1），
* 最大值设置为HOUR_SPINNER_MAX_VAL_12_HOUR_VIEW（即12）。
*/
private void updateHourControl() {
if (mIs24HourView) {
mHourSpinner.setMinValue(HOUR_SPINNER_MIN_VAL_24_HOUR_VIEW);
@ -469,13 +609,20 @@ public class DateTimePicker extends FrameLayout {
}
/**
* Set the callback that indicates the 'Set' button has been pressed.
* @param callback the callback, if null will do nothing
* 设置用于监听日期和时间变化的回调接口，外部类可通过实现OnDateTimeChangedListener接口，
* 并将实现类的实例传入该方法，来接收DateTimePicker控件中时间发生变化的通知。
* 如果传入的回调参数为null，则不进行任何操作。
*
* @param callback 实现了OnDateTimeChangedListener接口的实例，用于接收时间变化的回调通知
*/
public void setOnDateTimeChangedListener(OnDateTimeChangedListener callback) {
mOnDateTimeChangedListener = callback;
}
/**
* 内部方法，用于在日期、时间相关属性发生变化时，通知外部监听器（如果有设置的话）时间发生了变化，
* 传递当前DateTimePicker的实例以及当前的年、月、日、时、分等时间信息给外部监听器的onDateTimeChanged方法。
*/
private void onDateTimeChanged() {
if (mOnDateTimeChangedListener != null) {
mOnDateTimeChangedListener.onDateTimeChanged(this, getCurrentYear(),

43
src/Notes-master/src/net/micode/notes/ui/DateTimePickerDialog.java
Unescape View File

@ -28,22 +28,33 @@ import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.text.format.DateFormat;
import android.text.format.DateUtils;
// DateTimePickerDialog类继承自AlertDialog，同时实现了OnClickListener接口，用于创建一个带有日期和时间选择功能的对话框
public class DateTimePickerDialog extends AlertDialog implements OnClickListener {
// Calendar对象，用于记录当前选择的日期和时间，初始化为当前系统时间
private Calendar mDate = Calendar.getInstance();
// 标记当前是否是24小时制视图，用于控制时间的显示格式
private boolean mIs24HourView;
// 定义一个接口类型的变量，用于监听用户设置好日期和时间后的操作，外部类可实现该接口来响应设置事件
private OnDateTimeSetListener mOnDateTimeSetListener;
// 用于实际进行日期和时间选择操作的DateTimePicker控件实例
private DateTimePicker mDateTimePicker;
// 定义一个接口，用于在用户点击对话框中的确定按钮，设置好日期和时间后进行回调，外部类需实现该接口来处理具体逻辑
public interface OnDateTimeSetListener {
void OnDateTimeSet(AlertDialog dialog, long date);
}
// 构造方法，接受一个Context参数和日期的时间戳（long类型），用于创建DateTimePickerDialog实例并进行初始化设置
public DateTimePickerDialog(Context context, long date) {
super(context);
// 创建一个DateTimePicker实例，用于在对话框中展示日期和时间选择的界面
mDateTimePicker = new DateTimePicker(context);
// 将DateTimePicker控件设置为对话框的内容视图，使其显示在对话框中供用户操作
setView(mDateTimePicker);
// 为DateTimePicker设置日期和时间变化的监听器，当用户在DateTimePicker中选择的日期或时间发生变化时，
// 会触发该监听器中的onDateTimeChanged方法，在该方法内更新mDate对象记录的日期和时间信息，并调用updateTitle方法更新对话框标题显示的当前日期和时间
mDateTimePicker.setOnDateTimeChangedListener(new OnDateTimeChangedListener() {
public void onDateTimeChanged(DateTimePicker view, int year, int month,
int dayOfMonth, int hourOfDay, int minute) {
@ -55,32 +66,56 @@ public class DateTimePickerDialog extends AlertDialog implements OnClickListener
updateTitle(mDate.getTimeInMillis());
}
});
// 设置当前日期和时间为传入的指定日期时间戳对应的时间，同时将秒数设置为0（通常在选择时间时精确到分钟即可）
mDate.setTimeInMillis(date);
mDate.set(Calendar.SECOND, 0);
// 将DateTimePicker显示的当前日期和时间设置为mDate所记录的时间，确保初始显示与传入的指定时间一致
mDateTimePicker.setCurrentDate(mDate.getTimeInMillis());
// 设置对话框的确定按钮，按钮文本通过资源字符串获取（R.string.datetime_dialog_ok），并将当前类（实现了OnClickListener接口）作为点击监听器传入，
// 当用户点击确定按钮时会触发onClick方法进行相应处理
setButton(context.getString(R.string.datetime_dialog_ok), this);
// 设置对话框的取消按钮，按钮文本通过资源字符串获取（R.string.datetime_dialog_cancel），传入null作为点击监听器，表示使用默认的取消行为（关闭对话框）
setButton2(context.getString(R.string.datetime_dialog_cancel), (OnClickListener)null);
// 根据系统当前的时间格式设置（是否是24小时制）来设置该对话框的时间显示格式，调用set24HourView方法进行设置
set24HourView(DateFormat.is24HourFormat(this.getContext()));
// 初次创建对话框时，根据传入的初始日期时间戳更新对话框标题显示的当前日期和时间
updateTitle(mDate.getTimeInMillis());
}
// 设置该对话框的时间显示格式是否为24小时制，传入true表示设置为24小时制，传入false表示设置为12小时制（AM/PM）
public void set24HourView(boolean is24HourView) {
mIs24HourView = is24HourView;
}
// 设置用于监听用户设置好日期和时间后的回调接口，外部类实现OnDateTimeSetListener接口后，将实例传入该方法，
// 以便在用户点击确定按钮完成设置时接收通知并进行相应处理
public void setOnDateTimeSetListener(OnDateTimeSetListener callBack) {
mOnDateTimeSetListener = callBack;
}
// 私有方法，用于根据当前日期时间以及是否是24小时制视图等信息，更新对话框标题显示的日期和时间字符串
private void updateTitle(long date) {
private void updateTitle(long date) {
int flag =
DateUtils.FORMAT_SHOW_YEAR |
DateUtils.FORMAT_SHOW_DATE |
DateUtils.FORMAT_SHOW_TIME;
DateUtils.FORMAT_SHOW_YEAR |// 表示在格式化日期时间字符串时显示年份
DateUtils.FORMAT_SHOW_DATE |// 表示显示日期（月、日等）
DateUtils.FORMAT_SHOW_TIME;// 表示显示时间（时、分等）
// 根据当前是否是24小时制视图，添加相应的格式化标志，用于控制时间的显示格式（24小时制或12小时制带AM/PM）
flag |= mIs24HourView? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_12HOUR;
flag |= mIs24HourView ? DateUtils.FORMAT_24HOUR : DateUtils.FORMAT_24HOUR;
setTitle(DateUtils.formatDateTime(this.getContext(), date, flag));
}
// 实现OnClickListener接口的onClick方法，当用户点击对话框中的按钮（这里主要是确定按钮）时触发该方法，
// 如果设置了OnDateTimeSetListener监听器，会调用其OnDateTimeSet方法，将当前对话框实例以及选择好的日期时间戳传递给外部监听器，
// 以便外部类进行相应的后续处理（比如保存选择的时间等操作）
public void onClick(DialogInterface arg0, int arg1) {
if (mOnDateTimeSetListener != null) {
mOnDateTimeSetListener.OnDateTimeSet(this, mDate.getTimeInMillis());

25
src/Notes-master/src/net/micode/notes/ui/DropdownMenu.java
Unescape View File

@ -27,17 +27,35 @@ import android.widget.PopupMenu.OnMenuItemClickListener;
import net.micode.notes.R;
// DropdownMenu类用于创建一个下拉菜单的功能组件，通常可以关联一个按钮，点击按钮弹出包含相应菜单项的菜单
public class DropdownMenu {
// 用于显示下拉菜单的按钮，用户点击该按钮会触发弹出菜单的操作
private Button mButton;
// PopupMenu实例，用于实现弹出式菜单的功能，它会依附在指定的View（这里是mButton）上显示
private PopupMenu mPopupMenu;
// 代表菜单对象，用于操作和获取菜单中的具体菜单项等相关信息
private Menu mMenu;
// 构造方法，用于初始化DropdownMenu实例，接受上下文环境（Context）、关联的按钮（Button）以及菜单资源ID（int类型）作为参数
public DropdownMenu(Context context, Button button, int menuId) {
// 将传入的按钮赋值给成员变量mButton，后续操作会基于这个按钮来触发弹出菜单等行为
mButton = button;
// 为按钮设置背景资源，这里使用的是名为"dropdown_icon"的资源（通常是一个图标，用于提示用户该按钮可弹出菜单）
mButton.setBackgroundResource(R.drawable.dropdown_icon);
// 创建一个PopupMenu实例，将传入的上下文环境和关联的按钮作为参数传入，使得弹出菜单能够在正确的界面环境下依附该按钮显示
mPopupMenu = new PopupMenu(context, mButton);
// 获取PopupMenu中的Menu对象，赋值给成员变量mMenu，以便后续对菜单进行各种操作，比如添加菜单项、查找菜单项等
mMenu = mPopupMenu.getMenu();
// 通过菜单填充器（MenuInflater）将指定资源ID对应的菜单布局文件（通常定义了菜单项等信息）填充到mMenu中，
// 这样就构建好了具有具体菜单项的菜单
mPopupMenu.getMenuInflater().inflate(menuId, mMenu);
// 为按钮设置点击事件监听器，当按钮被点击时，会触发onClick方法，在该方法内调用PopupMenu的show方法，
// 从而显示弹出式菜单供用户选择菜单项
mButton.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
mPopupMenu.show();
@ -45,16 +63,23 @@ public class DropdownMenu {
});
}
// 设置下拉菜单中菜单项的点击事件监听器，外部类实现OnMenuItemClickListener接口后，
// 通过传入该接口的实现实例，可以监听每个菜单项被点击时的事件，并进行相应的处理逻辑
// 如果PopupMenu实例不为空，则将传入的监听器设置给PopupMenu，使其能够响应菜单项的点击操作
public void setOnDropdownMenuItemClickListener(OnMenuItemClickListener listener) {
if (mPopupMenu != null) {
mPopupMenu.setOnMenuItemClickListener(listener);
}
}
// 根据传入的菜单项ID，在菜单（mMenu）中查找对应的MenuItem实例并返回，方便外部类对特定菜单项进行进一步操作，
// 比如获取菜单项的属性、设置菜单项的状态等
public MenuItem findItem(int id) {
return mMenu.findItem(id);
}
// 设置按钮上显示的文本内容，通常可以用于显示当前选中的菜单项相关信息或者作为菜单的标题等，
// 通过修改按钮的文本（setText方法）来实现显示效果的更新
public void setTitle(CharSequence title) {
mButton.setText(title);
}

25
src/Notes-master/src/net/micode/notes/ui/FoldersListAdapter.java
Unescape View File

@ -28,26 +28,37 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
// FoldersListAdapter类继承自CursorAdapter，用于为包含文件夹相关数据的Cursor（通常来自数据库查询结果）提供适配，
// 以便在ListView等列表视图组件中展示文件夹信息。
public class FoldersListAdapter extends CursorAdapter {
// 定义一个字符串数组，用于指定从数据库查询时需要获取的列信息，这里包含了文件夹的ID和片段（可能是名称等相关信息）列
public static final String [] PROJECTION = {
NoteColumns.ID,
NoteColumns.SNIPPET
};
// 定义一个常量，表示在查询结果的Cursor中，文件夹ID所在列的索引，值为0，方便后续从Cursor中准确获取对应的数据
public static final int ID_COLUMN = 0;
// 定义一个常量，表示在查询结果的Cursor中，文件夹名称（这里用NAME_COLUMN指代，可能实际对应NoteColumns.SNIPPET等相关列）所在列的索引，值为1
public static final int NAME_COLUMN = 1;
// 构造方法，接受上下文环境（Context）和一个Cursor对象作为参数，调用父类（CursorAdapter）的构造方法进行初始化，
// 这里的TODO注释表示后续可能需要完善该构造方法的具体逻辑，目前仅完成了基本的初始化调用父类构造函数操作。
public FoldersListAdapter(Context context, Cursor c) {
super(context, c);
// TODO Auto-generated constructor stub
}
// 重写CursorAdapter的newView方法，该方法用于创建一个新的视图（View）对象，用于展示列表中的每一项数据。
// 在这里返回一个新的FolderListItem实例，意味着每个列表项的视图将由FolderListItem来构建和管理。
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
return new FolderListItem(context);
}
// 重写CursorAdapter的bindView方法，该方法用于将数据绑定到已经创建好的视图（View）上，即将Cursor中的数据填充到对应的视图控件中进行显示。
// 首先判断传入的视图是否是FolderListItem类型，如果是，则根据Cursor中获取的数据来设置文件夹名称显示的文本内容。
// 如果文件夹的ID等于特定的根文件夹ID（Notes.ID_ROOT_FOLDER），则显示一个特定的字符串（从资源中获取，可能是表示根文件夹的提示文本），
// 否则显示从Cursor中获取的对应名称列（NAME_COLUMN）的字符串内容，并通过FolderListItem的bind方法将名称设置到对应的TextView控件中进行显示。
@Override
public void bindView(View view, Context context, Cursor cursor) {
if (view instanceof FolderListItem) {
@ -57,21 +68,31 @@ public class FoldersListAdapter extends CursorAdapter {
}
}
// 自定义的方法，用于获取指定位置（position）的文件夹名称。
// 通过调用getItem方法（继承自CursorAdapter）获取对应位置的Cursor对象，然后根据与bindView方法类似的逻辑，
// 判断文件夹ID是否为根文件夹ID，来决定返回特定字符串还是从Cursor中获取的名称列字符串内容。
public String getFolderName(Context context, int position) {
Cursor cursor = (Cursor) getItem(position);
return (cursor.getLong(ID_COLUMN) == Notes.ID_ROOT_FOLDER) ? context
.getString(R.string.menu_move_parent_folder) : cursor.getString(NAME_COLUMN);
}
// 定义一个内部类FolderListItem，继承自LinearLayout，用于表示列表中每个文件夹项对应的视图布局结构以及相关操作。
private class FolderListItem extends LinearLayout {
// 定义一个TextView控件，用于显示文件夹的名称信息。
private TextView mName;
// 构造方法，接受上下文环境（Context）作为参数，调用父类（LinearLayout）的构造方法进行初始化，
// 然后通过inflate方法加载名为R.layout.folder_list_item的布局文件到当前视图中，
// 最后从加载后的布局中找到ID为R.id.tv_folder_name的TextView控件并赋值给mName成员变量，以便后续操作。
public FolderListItem(Context context) {
super(context);
inflate(context, R.layout.folder_list_item, this);
mName = (TextView) findViewById(R.id.tv_folder_name);
}
// 自定义的方法，用于将传入的文件夹名称字符串设置到mName（TextView）控件上进行显示，实现数据与视图的绑定操作。
public void bind(String name) {
mName.setText(name);
}

211
src/Notes-master/src/net/micode/notes/ui/NoteEditActivity.java
Unescape View File

@ -15,7 +15,7 @@
*/
package net.micode.notes.ui;
// 这里假设你的包名是com.example.yourpackage，实际需替换为正确的包名
import android.app.Activity;
import android.app.AlarmManager;
import android.app.AlertDialog;
@ -71,19 +71,23 @@ import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
// NoteEditActivity类，继承自Activity（或AppCompatActivity，取决于实际的父类继承情况），实现了多个接口，用于处理笔记编辑相关的各种交互逻辑，
// 例如点击事件、设置变更监听、文本变更监听等，是一个用于编辑笔记的Activity
public class NoteEditActivity extends Activity implements OnClickListener,
NoteSettingChangedListener, OnTextViewChangeListener {
// 内部类HeadViewHolder，用于封装笔记头部视图相关的UI组件，方便管理和操作
private class HeadViewHolder {
public TextView tvModified;
// 用于显示笔记修改时间的TextView组件
public ImageView ivAlertIcon;
// 用于显示提醒图标（如闹钟图标等）的ImageView组件
public TextView tvAlertDate;
// 用于显示提醒时间相关信息的TextView组件
public ImageView ibSetBgColor;
// 用于设置背景颜色的ImageView按钮组件
}
// 静态的Map，用于将背景颜色选择按钮的资源ID（如R.id.iv_bg_yellow等）映射到对应的颜色常量（如ResourceParser.YELLOW等），方便根据按钮ID获取对应的颜色标识
private static final Map<Integer, Integer> sBgSelectorBtnsMap = new HashMap<Integer, Integer>();
static {
sBgSelectorBtnsMap.put(R.id.iv_bg_yellow, ResourceParser.YELLOW);
@ -93,6 +97,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorBtnsMap.put(R.id.iv_bg_white, ResourceParser.WHITE);
}
// 静态的Map，用于将颜色常量（如ResourceParser.YELLOW等）映射到对应的背景颜色选择按钮被选中时的显示资源ID（如R.id.iv_bg_yellow_select等），
// 用于在选择颜色后显示相应的选中效果
private static final Map<Integer, Integer> sBgSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sBgSelectorSelectionMap.put(ResourceParser.YELLOW, R.id.iv_bg_yellow_select);
@ -102,6 +108,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sBgSelectorSelectionMap.put(ResourceParser.WHITE, R.id.iv_bg_white_select);
}
// 静态的Map，用于将字体大小选择按钮所在的布局资源ID（如R.id.ll_font_large等）映射到对应的字体大小常量（如ResourceParser.TEXT_LARGE等），方便根据按钮布局ID获取对应的字体大小标识
private static final Map<Integer, Integer> sFontSizeBtnsMap = new HashMap<Integer, Integer>();
static {
sFontSizeBtnsMap.put(R.id.ll_font_large, ResourceParser.TEXT_LARGE);
@ -110,6 +117,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSizeBtnsMap.put(R.id.ll_font_super, ResourceParser.TEXT_SUPER);
}
// 静态的Map，用于将字体大小常量（如ResourceParser.TEXT_LARGE等）映射到对应的字体大小选择按钮被选中时的显示资源ID（如R.id.iv_large_select等），
// 用于在选择字体大小后显示相应的选中效果
private static final Map<Integer, Integer> sFontSelectorSelectionMap = new HashMap<Integer, Integer>();
static {
sFontSelectorSelectionMap.put(ResourceParser.TEXT_LARGE, R.id.iv_large_select);
@ -118,46 +127,68 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sFontSelectorSelectionMap.put(ResourceParser.TEXT_SUPER, R.id.iv_super_select);
}
// 用于日志记录的标签，方便在日志中识别该Activity相关的输出信息
private static final String TAG = "NoteEditActivity";
// 用于存储笔记头部视图相关组件的实例，方便后续操作和更新头部视图的显示内容
private HeadViewHolder mNoteHeaderHolder;
// 笔记头部视图的整体布局，包含标题、修改时间、提醒相关等组件的外层容器
private View mHeadViewPanel;
// 用于显示背景颜色选择器的视图，包含各种背景颜色选项按钮等
private View mNoteBgColorSelector;
// 用于显示字体大小选择器的视图，包含各种字体大小选项按钮等
private View mFontSizeSelector;
// 用于编辑笔记内容的EditText组件，用户在此输入和修改笔记的文本内容
private EditText mNoteEditor;
// 包含笔记编辑区域（如mNoteEditor）以及相关滚动等功能的外层布局视图，用于整体的笔记编辑界面布局管理
private View mNoteEditorPanel;
// 代表正在编辑的笔记对象，包含笔记的各种属性（如内容、修改时间、背景颜色等）以及相关操作方法（如保存、加载等）
private WorkingNote mWorkingNote;
// 用于获取和操作应用的共享偏好设置，可用于存储和读取如字体大小、用户个性化设置等相关信息
private SharedPreferences mSharedPrefs;
// 当前选择的字体大小ID，对应于ResourceParser中定义的字体大小常量，用于确定笔记编辑区域显示的字体大小
private int mFontSizeId;
// 存储在共享偏好设置中用于标识字体大小偏好设置的键名常量
private static final String PREFERENCE_FONT_SIZE = "pref_font_size";
// 快捷方式图标标题的最大长度限制，用于生成发送到桌面的快捷方式图标时，截取合适长度的笔记内容作为标题
private static final int SHORTCUT_ICON_TITLE_MAX_LEN = 10;
// 表示复选框被选中状态的字符常量，用于处理复选框列表模式下的笔记内容显示和解析
public static final String TAG_CHECKED = String.valueOf('\u221A');
// 表示复选框未被选中状态的字符常量，用于处理复选框列表模式下的笔记内容显示和解析
public static final String TAG_UNCHECKED = String.valueOf('\u25A1');
// 用于存储笔记编辑中多行文本（如果是列表模式等情况）的LinearLayout，每个子项可能是一个包含文本和复选框的自定义布局，方便处理多行文本编辑逻辑
private LinearLayout mEditTextList;
// 用户查询的文本内容，可能用于搜索、筛选等功能相关，比如在笔记中查找特定内容等场景
private String mUserQuery;
// 用于正则表达式匹配的Pattern对象，可能用于在笔记内容中按照特定规则查找、匹配文本等操作，具体取决于业务逻辑中如何使用
private Pattern mPattern;
// Activity创建时调用的方法，进行一些初始化操作，如设置布局、恢复Activity状态等
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 设置该Activity对应的布局文件，即加载笔记编辑界面的UI布局
this.setContentView(R.layout.note_edit);
// 如果是首次创建（savedInstanceState为null）且初始化Activity状态失败，则直接结束该Activity并返回
if (savedInstanceState == null && !initActivityState(getIntent())) {
finish();
return;
}
// 初始化各种资源，如查找UI组件、设置点击事件监听器等
initResources();
}
@ -168,6 +199,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
super.onRestoreInstanceState(savedInstanceState);
// 如果保存的实例状态不为null且包含特定的用户ID信息（通过Intent.EXTRA_UID标识），则尝试恢复Activity状态
if (savedInstanceState != null && savedInstanceState.containsKey(Intent.EXTRA_UID)) {
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.putExtra(Intent.EXTRA_UID, savedInstanceState.getLong(Intent.EXTRA_UID));
@ -179,16 +211,21 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
// 根据传入的Intent初始化Activity的状态，根据不同的Intent动作（如查看、新建/编辑等）来加载相应的笔记数据或者创建新的笔记对象
private boolean initActivityState(Intent intent) {
// 初始化正在编辑的笔记对象为null
/**
* If the user specified the {@link Intent#ACTION_VIEW} but not provided with id,
* then jump to the NotesListActivity
*/
mWorkingNote = null;
// 如果Intent的动作是查看笔记（Intent.ACTION_VIEW）
if (TextUtils.equals(Intent.ACTION_VIEW, intent.getAction())) {
// 获取笔记的ID，如果没有传入则默认为0
long noteId = intent.getLongExtra(Intent.EXTRA_UID, 0);
mUserQuery = "";
// 如果Intent中包含搜索结果相关的额外数据（通过SearchManager.EXTRA_DATA_KEY标识），则更新笔记ID和用户查询文本
/**
* Starting from the searched result
*/
@ -197,6 +234,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mUserQuery = intent.getStringExtra(SearchManager.USER_QUERY);
}
// 检查该笔记ID对应的笔记在数据库中是否可见（是否存在且满足一定可见条件），如果不可见，则跳转到笔记列表页面，并提示笔记不存在，然后结束当前Activity
if (!DataUtils.visibleInNoteDatabase(getContentResolver(), noteId, Notes.TYPE_NOTE)) {
Intent jump = new Intent(this, NotesListActivity.class);
startActivity(jump);
@ -204,6 +242,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
finish();
return false;
} else {
// 从数据库加载对应笔记ID的笔记对象，如果加载失败则记录错误日志并结束当前Activity
mWorkingNote = WorkingNote.load(this, noteId);
if (mWorkingNote == null) {
Log.e(TAG, "load note failed with note id" + noteId);
@ -211,19 +250,28 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
}
// 设置软键盘的显示模式，初始隐藏软键盘，并且根据内容调整布局大小
getWindow().setSoftInputMode(
WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN
| WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
} else if(TextUtils.equals(Intent.ACTION_INSERT_OR_EDIT, intent.getAction())) {
// 如果Intent的动作是新建或编辑笔记（Intent.ACTION_INSERT_OR_EDIT）
// 获取文件夹ID，如果没有传入则默认为0
// New note
long folderId = intent.getLongExtra(Notes.INTENT_EXTRA_FOLDER_ID, 0);
// 获取小部件ID，如果没有传入则默认为无效的小部件ID（AppWidgetManager.INVALID_APPWIDGET_ID）
int widgetId = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_ID,
AppWidgetManager.INVALID_APPWIDGET_ID);
// 获取小部件类型，如果没有传入则默认为无效的小部件类型（Notes.TYPE_WIDGET_INVALIDE）
int widgetType = intent.getIntExtra(Notes.INTENT_EXTRA_WIDGET_TYPE,
Notes.TYPE_WIDGET_INVALIDE);
// 获取背景资源ID，如果没有传入则调用ResourceParser获取默认的背景颜色资源ID
int bgResId = intent.getIntExtra(Notes.INTENT_EXTRA_BACKGROUND_ID,
ResourceParser.getDefaultBgId(this));
// 解析通话记录笔记相关信息，如果Intent中包含电话号码和通话日期，则尝试根据这些信息获取对应的笔记ID，
// 如果找到对应笔记ID则加载该笔记对象，否则创建一个空的笔记对象并转换为通话笔记格式
// Parse call-record note
String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
long callDate = intent.getLongExtra(Notes.INTENT_EXTRA_CALL_DATE, 0);
@ -241,11 +289,15 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
} else {
// 如果没有通话记录相关信息，则创建一个空的笔记对象
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId,
widgetType, bgResId);
mWorkingNote.convertToCallNote(phoneNumber, callDate);
}
// 设置软键盘的显示模式，初始显示软键盘并且根据内容调整布局大小
} else {
// 如果Intent没有指定有效的动作，则记录错误日志并结束当前Activity，因为不支持这种情况
mWorkingNote = WorkingNote.createEmptyNote(this, folderId, widgetId, widgetType,
bgResId);
}
@ -258,66 +310,96 @@ public class NoteEditActivity extends Activity implements OnClickListener,
finish();
return false;
}
// 设置正在编辑的笔记对象的设置状态变更监听器为当前Activity（实现了NoteSettingChangedListener接口）
mWorkingNote.setOnSettingStatusChangedListener(this);
return true;
}
// Activity重新恢复到前台可见时调用的方法，用于重新初始化笔记编辑界面的显示内容等
@Override
protected void onResume() {
super.onResume();
initNoteScreen();
}
// 初始化笔记编辑界面的显示内容，如设置字体大小、根据笔记模式（是否为复选框列表模式等）显示相应内容、更新头部视图的时间显示等
private void initNoteScreen() {
// 设置笔记编辑区域的文本外观，根据当前选择的字体大小ID获取对应的文本外观资源并应用
mNoteEditor.setTextAppearance(this, TextAppearanceResources
.getTexAppearanceResource(mFontSizeId));
// 如果笔记处于复选框列表模式，则切换到列表模式显示界面，并传入笔记内容进行相应处理
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
switchToListMode(mWorkingNote.getContent());
} else {
// 如果不是列表模式，则在编辑区域显示笔记内容，并对用户查询的文本进行高亮显示，然后将光标定位到文本末尾
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
mNoteEditor.setSelection(mNoteEditor.getText().length());
}
// 遍历背景颜色选择按钮选中状态对应的资源ID映射表，将所有选中状态的显示组件设置为不可见，用于清除之前可能的选中显示效果
for (Integer id : sBgSelectorSelectionMap.keySet()) {
findViewById(sBgSelectorSelectionMap.get(id)).setVisibility(View.GONE);
}
// 设置笔记头部视图的背景资源，根据正在编辑的笔记对象获取对应的标题背景资源ID并应用
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
// 设置笔记编辑区域的背景资源，根据正在编辑的笔记对象获取对应的背景颜色资源ID并应用
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
// 设置笔记头部视图中修改时间的显示文本，根据笔记的修改时间格式化并显示相应的日期和时间信息
mNoteHeaderHolder.tvModified.setText(DateUtils.formatDateTime(this,
mWorkingNote.getModifiedDate(), DateUtils.FORMAT_SHOW_DATE
| DateUtils.FORMAT_NUMERIC_DATE | DateUtils.FORMAT_SHOW_TIME
| DateUtils.FORMAT_SHOW_YEAR));
// 显示提醒相关的头部信息（如提醒图标和提醒时间等），根据笔记是否设置了提醒以及当前时间等情况进行相应的显示
/**
* TODO: Add the menu for setting alert. Currently disable it because the DateTimePicker
* is not ready
*/
// 显示提醒相关的头部信息（如提醒图标和提醒时间等），根据笔记是否设置了提醒以及当前时间等情况进行相应的显示
showAlertHeader();
}
// 此方法用于根据笔记是否设置了提醒以及当前时间与提醒时间的关系，来设置笔记头部提醒相关视图（提醒时间文本和提醒图标）的显示状态及内容
private void showAlertHeader() {
private void showAlertHeader() {
// 判断正在编辑的笔记对象（mWorkingNote）是否设置了时钟提醒（hasClockAlert方法返回true表示设置了提醒）
if (mWorkingNote.hasClockAlert()) {
// 获取当前系统时间（以毫秒为单位，从1970年1月1日00:00:00 UTC到当前时间的毫秒数）
long time = System.currentTimeMillis();
// 如果当前时间大于笔记设置的提醒时间
if (time > mWorkingNote.getAlertDate()) {
// 将提醒时间文本视图（mNoteHeaderHolder.tvAlertDate）的内容设置为表示提醒已过期的字符串资源（R.string.note_alert_expired
mNoteHeaderHolder.tvAlertDate.setText(R.string.note_alert_expired);
} else {
// 如果当前时间未超过提醒时间，则调用DateUtils的方法获取相对时间跨度字符串，用于显示距离提醒时间还有多久，
// 参数分别为提醒时间、当前时间以及时间跨度的单位（这里是以分钟为单位，DateUtils.MINUTE_IN_MILLIS表示一分钟对应的毫秒数）
mNoteHeaderHolder.tvAlertDate.setText(DateUtils.getRelativeTimeSpanString(
mWorkingNote.getAlertDate(), time, DateUtils.MINUTE_IN_MILLIS));
}
// 将提醒时间文本视图设置为可见状态，以便用户能看到提醒相关的时间信息
mNoteHeaderHolder.tvAlertDate.setVisibility(View.VISIBLE);
// 将提醒图标视图设置为可见状态，展示相应的提醒图标，提示用户有提醒设置
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.VISIBLE);
} else {
// 如果笔记没有设置时钟提醒，则将提醒时间文本视图设置为不可见状态，隐藏相关文本显示
mNoteHeaderHolder.tvAlertDate.setVisibility(View.GONE);
// 将提醒图标视图设置为不可见状态，隐藏提醒图标
mNoteHeaderHolder.ivAlertIcon.setVisibility(View.GONE);
};
}
// 当Activity接收到新的Intent时会调用此方法，它首先调用父类的onNewIntent方法，然后根据新传入的Intent重新初始化Activity的状态
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
// 调用initActivityState方法，传入新的Intent，根据Intent中的信息来重新加载笔记数据、设置相关属性等，以适应新的启动意图，
// 比如从其他地方重新启动该Activity并传递了不同的参数，就会在此处更新Activity的状态
initActivityState(intent);
}
// 当系统即将销毁Activity以回收内存或者进行配置变更（如屏幕旋转）等情况时，会调用此方法来保存Activity的当前状态信息，
// 以便后续可以恢复到当前状态。这里先调用父类的onSaveInstanceState方法来执行默认的保存操作，然后进行自定义的保存逻辑
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
@ -328,51 +410,73 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
if (!mWorkingNote.existInDatabase()) {
saveNote();
// 将正在编辑的笔记对象的ID存入传出的Bundle（outState）中，键为Intent.EXTRA_UID，以便后续恢复状态时能获取到该笔记的标识信息
}
outState.putLong(Intent.EXTRA_UID, mWorkingNote.getNoteId());
// 在日志中记录正在保存的工作笔记的ID信息，方便调试和查看状态保存情况，使用TAG作为日志标签方便识别是该Activity相关的日志输出
Log.d(TAG, "Save working note id: " + mWorkingNote.getNoteId() + " onSaveInstanceState");
}
// 用于分发触摸事件，Activity接收到触摸事件后会先经过此方法处理，在这里可以拦截触摸事件或者将其传递给子视图进行处理。
// 主要用于处理背景颜色选择器和字体大小选择器在显示时，触摸事件在其范围外的情况
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
// 如果背景颜色选择器（mNoteBgColorSelector）当前处于可见状态，并且触摸事件不在其显示范围内（通过inRangeOfView方法判断）
if (mNoteBgColorSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mNoteBgColorSelector, ev)) {
// 则将背景颜色选择器设置为不可见，隐藏该选择器视
mNoteBgColorSelector.setVisibility(View.GONE);
// 返回true表示已经处理了该触摸事件，不会再继续传递给其他视图进行处理，即拦截了此次触摸事件对背景颜色选择器的后续影响
return true;
}
if (mFontSizeSelector.getVisibility() == View.VISIBLE
&& !inRangeOfView(mFontSizeSelector, ev)) {
// 将字体大小选择器设置为不可见，隐藏该选择器视图
mFontSizeSelector.setVisibility(View.GONE);
// 返回true表示已经处理了该触摸事件，拦截了此次触摸事件对字体大小选择器的后续影响，不再继续传递给其他视图
return true;
}
// 如果上述条件都不满足，即触摸事件不在需要特殊处理的选择器范围外，或者选择器本身就不可见等情况，
// 则调用父类的dispatchTouchEvent方法，将触摸事件按照默认的分发逻辑继续传递给其他视图进行处理
return super.dispatchTouchEvent(ev);
}
// 此方法用于判断给定的触摸事件（MotionEvent）是否在指定的视图（view）范围内，通过比较触摸点的坐标与视图在屏幕上的坐标及尺寸来确定
private boolean inRangeOfView(View view, MotionEvent ev) {
int []location = new int[2];
// 获取指定视图在屏幕上的坐标位置，将结果存入location数组中，通过这种方式可以得到视图左上角顶点相对于屏幕左上角的坐标值
view.getLocationOnScreen(location);
// 获取视图在屏幕上的横坐标（x坐标），即location数组的第一个元素
int x = location[0];
// 获取视图在屏幕上的纵坐标（y坐标），即location数组的第二个元素
int y = location[1];
// 判断触摸事件的横坐标（ev.getX()获取触摸点相对于触发触摸事件的视图的横坐标）是否小于视图的横坐标（x），
// 如果小于则说明触摸点在视图的左侧，不在视图范围内，返回false
if (ev.getX() < x
|| ev.getX() > (x + view.getWidth())
|| ev.getY() < y
|| ev.getY() > (y + view.getHeight())) {
return false;
}
// 判断触摸事件的横坐标是否大于视图的横坐标加上视图的宽度（x + view.getWidth()表示视图的右侧边界横坐标），
// 如果大于则说明触摸点在视图的右侧，不在视图范围内，返回false
return true;
}
// 判断触摸事件的纵坐标（ev.getY()获取触摸点相对于触发触摸事件的视图的纵坐标）是否小于视图的纵坐标（y），
// 如果小于则说明触摸点在视图的上方，不在视图范围内，返回false
private void initResources() {
mHeadViewPanel = findViewById(R.id.note_title);
// 创建一个HeadViewHolder实例，用于存储笔记头部视图相关的各个子组件，方便后续统一操作和管理这些组件
mNoteHeaderHolder = new HeadViewHolder();
// 通过findViewById方法查找布局文件中ID为tv_modified_date的TextView组件，该组件通常用于显示笔记的修改时间，
// 并将其赋值给mNoteHeaderHolder中的tvModified变量，方便后续操作该文本视图（如设置显示的文本内容等）
mNoteHeaderHolder.tvModified = (TextView) findViewById(R.id.tv_modified_date);
mNoteHeaderHolder.ivAlertIcon = (ImageView) findViewById(R.id.iv_alert_icon);
mNoteHeaderHolder.tvAlertDate = (TextView) findViewById(R.id.tv_alert_date);
mNoteHeaderHolder.ibSetBgColor = (ImageView) findViewById(R.id.btn_set_bg_color);
mNoteHeaderHolder.ibSetBgColor.setOnClickListener(this);
mNoteEditor = (EditText) findViewById(R.id.note_edit_view);
mNoteEditorPanel = findViewById(R.id.sv_note_edit);
mNoteEditorPanel = findViewById(R.id.sv_ note_edit);
mNoteBgColorSelector = findViewById(R.id.note_bg_color_selector);
for (int id : sBgSelectorBtnsMap.keySet()) {
ImageView iv = (ImageView) findViewById(id);
@ -397,15 +501,20 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mEditTextList = (LinearLayout) findViewById(R.id.note_edit_list);
}
// 当Activity失去焦点即将进入暂停状态时调用此方法，例如用户切换到其他应用或者按下Home键等情况。
// 先调用父类的onPause方法执行默认的暂停操作，然后进行自定义的保存笔记数据和清理设置状态相关操作
@Override
protected void onPause() {
super.onPause();
// 调用saveNote方法保存笔记数据，如果保存成功（saveNote方法返回true）
if(saveNote()) {
Log.d(TAG, "Note data was saved with length:" + mWorkingNote.getContent().length());
}
clearSettingState();
}
// 用于更新桌面小部件的显示内容，根据正在编辑的笔记对象（mWorkingNote）的小部件类型，
// 构建相应的Intent并发送广播通知系统更新对应的小部件显示
private void updateWidget() {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
if (mWorkingNote.getWidgetType() == Notes.TYPE_WIDGET_2X) {
@ -417,10 +526,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return;
}
// 将正在编辑的笔记对象的小部件ID添加到Intent的额外数据中，键为AppWidgetManager.EXTRA_APPWIDGET_IDS，
// 这样接收广播的小部件更新逻辑可以知道要更新哪个具体的小部件实例
intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, new int[] {
mWorkingNote.getWidgetId()
});
// 处理界面上各个视图的点击事件，根据点击的视图ID来执行相应的操作逻辑，例如显示或隐藏相关视图、更新笔记的属性（如背景颜色、字体大小等）
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
@ -452,12 +564,17 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
// 当用户按下返回键时调用此方法，先尝试清理设置状态（如隐藏背景颜色选择器、字体大小选择器等），
// 如果清理成功则直接返回，不再执行默认的返回操作；如果清理失败则先保存笔记数据，再执行默认的返回操作
@Override
public void onBackPressed() {
if(clearSettingState()) {
return;
}
// 用于清理设置状态，检查背景颜色选择器和字体大小选择器是否处于可见状态，如果处于可见则将其设置为不可见，
// 根据是否有进行隐藏操作来返回相应的布尔值（true表示有隐藏操作，false表示没有需要隐藏的视图）
// 如果清理设置状态失败，则调用saveNote方法保存笔记数据
saveNote();
super.onBackPressed();
}
@ -473,13 +590,19 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return false;
}
// 当笔记的背景颜色发生改变时调用此方法，用于更新界面上相关视图的显示，以反映背景颜色的变化，
// 例如显示对应的背景颜色选中状态提示、设置笔记编辑区域和头部视图的背景资源等
public void onBackgroundColorChanged() {
// 根据正在编辑的笔记对象（mWorkingNote）当前的背景颜色ID，找到对应的背景颜色选择按钮选中状态显示的视图，并将其设置为可见状态，
// 用于提示用户当前选择的是哪种背景颜色（显示选中效果）
findViewById(sBgSelectorSelectionMap.get(mWorkingNote.getBgColorId())).setVisibility(
View.VISIBLE);
mNoteEditorPanel.setBackgroundResource(mWorkingNote.getBgColorResId());
mHeadViewPanel.setBackgroundResource(mWorkingNote.getTitleBgResId());
}
// 在准备显示选项菜单（Options Menu）时调用此方法，进行一些菜单相关的初始化操作，例如清理菜单、根据笔记的属性（如是否为通话记录笔记、是否有提醒等）加载不同的菜单布局、
// 更新菜单项的标题显示等，最后返回true表示菜单准备就绪可以显示
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
if (isFinishing()) {
@ -505,10 +628,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
return true;
}
// 处理选项菜单中各个菜单项的点击事件，根据点击的菜单项ID来执行相应的操作逻辑，例如创建新笔记、删除笔记、设置提醒、分享笔记等
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_new_note:
// 如果点击的菜单项是“新建笔记”（menu_new_note），则调用createNewNote方法创建一个新的笔记
createNewNote();
break;
case R.id.menu_delete:
@ -523,6 +648,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
finish();
}
});
// 设置对话框的“取消”按钮（NegativeButton），点击时不执行任何操作（传入null）
builder.setNegativeButton(android.R.string.cancel, null);
builder.show();
break;
@ -531,10 +657,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
findViewById(sFontSelectorSelectionMap.get(mFontSizeId)).setVisibility(View.VISIBLE);
break;
case R.id.menu_list_mode:
// 如果点击的菜单项是“列表模式”（menu_list_mode），则切换正在编辑的笔记对象的复选框列表模式状态，
// 如果当前是普通模式（getCheckListMode返回0）则切换为复选框列表模式（TextNote.MODE_CHECK_LIST），否则切换回普通模式（0）
mWorkingNote.setCheckListMode(mWorkingNote.getCheckListMode() == 0 ?
TextNote.MODE_CHECK_LIST : 0);
break;
case R.id.menu_share:
// 如果点击的菜单项是“分享”（menu_share），则先调用getWorkingText方法获取笔记的文本内容，
// 然后调用sendTo方法将笔记内容分享到支持Intent.ACTION_SEND动作且类型为text/plain的其他应用中
getWorkingText();
sendTo(this, mWorkingNote.getContent());
break;
@ -554,7 +684,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
private void setReminder() {
// 创建一个DateTimePickerDialog实例，用于显示日期时间选择对话框，传入当前Activity的上下文
DateTimePickerDialog d = new DateTimePickerDialog(this, System.currentTimeMillis());
// 为DateTimePickerDialog设置日期时间设置监听器，当用户在对话框中选择好日期时间并点击确定后，会触发该监听器的OnDateTimeSet方法。
d.setOnDateTimeSetListener(new OnDateTimeSetListener() {
public void OnDateTimeSet(AlertDialog dialog, long date) {
mWorkingNote.setAlertDate(date , true);
@ -563,6 +695,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
d.show();
}
// 此方法用于将笔记内容分享到支持指定Intent动作（Intent.ACTION_SEND）和文本类型（text/plain）的其他应用中，比如分享到短信、邮件等应用。
/**
* Share note to apps that support {@link Intent#ACTION_SEND} action
* and {@text/plain} type
@ -574,6 +707,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
context.startActivity(intent);
}
// 此方法用于创建一个新的笔记，操作流程为先保存当前正在编辑的笔记（如果有），然后关闭当前的NoteEditActivity，再启动一个新的NoteEditActivity进入新建笔记的流程。
private void createNewNote() {
// Firstly, save current editing notes
saveNote();
@ -586,6 +720,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
startActivity(intent);
}
// 此方法用于删除当前正在编辑的笔记，根据笔记是否存在于数据库以及当前应用是否处于同步模式等情况
private void deleteCurrentNote() {
if (mWorkingNote.existInDatabase()) {
HashSet<Long> ids = new HashSet<Long>();
@ -608,10 +743,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
mWorkingNote.markDeleted(true);
}
// 此方法用于判断当前应用是否处于同步模式，通过获取同步账户名称（调用NotesPreferenceActivity的getSyncAccountName方法）并检查其去除空格后的长度是否大于0来确定。
private boolean isSyncMode() {
return NotesPreferenceActivity.getSyncAccountName(this).trim().length() > 0;
}
// 此方法用于处理笔记的时钟提醒相关设置的变更，例如设置或取消提醒时间等操作，在操作前会先确保笔记已保存（如果未保存则先保存），然后根据不同情况与系统的闹钟服务（AlarmManager）交互来设置或取消提醒。
public void onClockAlertChanged(long date, boolean set) {
/**
* User could set clock to an unsaved note, so before setting the
@ -642,10 +779,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
// 此方法用于处理在笔记编辑的多行文本列表中删除某一行文本的操作，会调整后续行的索引，并将删除行的文本内容合并到前一行（如果是第一行则直接处理该行），同时更新焦点和光标位置等。
public void onWidgetChanged() {
updateWidget();
}
// 遍历从要删除行的下一行（index + 1）开始到最后一行的所有行，调整它们的索引，将其索引减1，使其与新的行数顺序对应。
public void onEditTextDelete(int index, String text) {
int childCount = mEditTextList.getChildCount();
if (childCount == 1) {
@ -657,6 +796,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
.setIndex(i - 1);
}
// 从多行文本列表中移除指定索引（index）的行视图。
mEditTextList.removeViewAt(index);
NoteEditText edit = null;
if(index == 0) {
@ -672,6 +812,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
edit.setSelection(length);
}
// 此方法用于处理在笔记编辑的多行文本列表中插入一行新文本的操作，会在指定索引位置添加新的行视图，更新相关行的索引，并设置新行的文本内容、焦点以及光标位置等。
public void onEditTextEnter(int index, String text) {
/**
* Should not happen, check for debug
@ -691,7 +832,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
private void switchToListMode(String text) {
// 首先移除多行文本列表（mEditTextList）中已有的所有视图，清空列表内容，为重新构建列表做准备。
mEditTextList.removeAllViews();
String[] items = text.split("\n");
int index = 0;
@ -701,17 +844,24 @@ public class NoteEditActivity extends Activity implements OnClickListener,
index++;
}
}
// 在多行文本列表末尾添加一个空的列表项视图，可能用于方便用户后续继续添加新的内容，提供一个空白的可编辑项。
mEditTextList.addView(getListItem("", index));
// 获取多行文本列表中最后一个添加的列表项（即索引为 index 的项）中的文本编辑框（NoteEditText）组件，并请求获取焦点，
// 使得用户切换到列表模式后，光标默认处于最后一个可编辑项处，方便用户直接输入内容。
mEditTextList.getChildAt(index).findViewById(R.id.et_edit_text).requestFocus();
mNoteEditor.setVisibility(View.GONE);
mEditTextList.setVisibility(View.VISIBLE);
}
// 此方法用于在给定的完整文本（fullText）中，根据用户输入的查询文本（userQuery）查找匹配的内容，并将匹配的内容设置为高亮显示，最后返回处理后的包含高亮显示效果的 Spannable 对象。
private Spannable getHighlightQueryResult(String fullText, String userQuery) {
// 创建一个 SpannableString 对象，将传入的完整文本（如果传入的 fullText 为 null，则初始化为空字符串）包装起来，
// 以便后续可以对其内容进行样式设置（如设置高亮显示等）操作，SpannableString 类实现了 Spannable 接口，支持设置文本样式。
SpannableString spannable = new SpannableString(fullText == null ? "" : fullText);
if (!TextUtils.isEmpty(userQuery)) {
mPattern = Pattern.compile(userQuery);
// 创建一个 Matcher 对象，通过调用 Pattern 对象的 matcher 方法并传入完整文本（fullText），用于在文本中执行具体的匹配查找任务，
// 可以通过其方法判断是否找到匹配内容以及获取匹配的位置等信息。
Matcher m = mPattern.matcher(fullText);
int start = 0;
while (m.find(start)) {
@ -723,10 +873,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
return spannable;
// 返回处理后的包含高亮显示效果的 SpannableString 对象，该对象可以用于在界面上展示带有高亮查询结果的文本内容。
}
private View getListItem(String item, int index) {
// 通过LayoutInflater从当前Activity的上下文（this）加载一个布局资源（R.layout.note_edit_list_item）创建一个视图对象，
// 该布局资源定义了列表项的具体界面结构，包含文本编辑框、复选框等组件的布局样式。
View view = LayoutInflater.from(this).inflate(R.layout.note_edit_list_item, null);
// 从创建的视图中获取文本编辑框（NoteEditText）组件，用于后续设置文本外观、内容以及添加事件监听器等操作。
final NoteEditText edit = (NoteEditText) view.findViewById(R.id.et_edit_text);
edit.setTextAppearance(this, TextAppearanceResources.getTexAppearanceResource(mFontSizeId));
CheckBox cb = ((CheckBox) view.findViewById(R.id.cb_edit_item));
@ -735,11 +889,14 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (isChecked) {
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
} else {
// 如果复选框未被选中，设置文本编辑框（edit）的绘制标志为默认的文本抗锯齿（Paint.ANTI_ALIAS_FLAG）和字距调整（Paint.DEV_KERN_TEXT_FLAG）标志，
// 恢复文本的正常显示样式
edit.setPaintFlags(Paint.ANTI_ALIAS_FLAG | Paint.DEV_KERN_TEXT_FLAG);
}
}
});
// 判断列表项文本（item）是否以特定的标记（TAG_CHECKED）开头，如果是，表示该项初始状态为已选中状态。
if (item.startsWith(TAG_CHECKED)) {
cb.setChecked(true);
edit.setPaintFlags(edit.getPaintFlags() | Paint.STRIKE_THRU_TEXT_FLAG);
@ -750,20 +907,31 @@ public class NoteEditActivity extends Activity implements OnClickListener,
item = item.substring(TAG_UNCHECKED.length(), item.length()).trim();
}
// 为文本编辑框（edit）设置文本内容变化的监听器（OnTextViewChangeListener），这里传入当前Activity（this），可能在监听器中实现了相应的逻辑，
// 用于在文本编辑框内容改变时进行一些处理，比如实时更新相关数据等操作。
edit.setOnTextViewChangeListener(this);
edit.setIndex(index);
// 设置文本编辑框（edit）的文本内容，通过调用 getHighlightQueryResult 方法，根据当前列表项文本（item）和用户查询文本（mUserQuery）获取带有高亮显示效果的文本内容，
// 并设置到文本编辑框中展示给用户。
edit.setText(getHighlightQueryResult(item, mUserQuery));
return view;
}
public void onTextChange(int index, boolean hasText) {
// 判断传入的索引（index）是否大于等于多行文本列表（mEditTextList）中的子项数量（即行数），如果大于等于则说明索引超出范围，
// 记录错误日志提示不应该出现这种情况，然后直接返回，不进行后续操作。
if (index >= mEditTextList.getChildCount()) {
Log.e(TAG, "Wrong index, should not happen");
return;
}
// 如果文本编辑框中有文本内容（hasText 为 true），则获取多行文本列表中对应索引位置的视图，并找到其中的复选框（CheckBox）组件，将其设置为可见状态，
// 以便用户可以看到并操作该复选框，通常用于有文本内容时可进行选中相关操作。
if(hasText) {
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.VISIBLE);
} else {
// 如果文本编辑框中没有文本内容（hasText 为 false），则获取多行文本列表中对应索引位置的视图，并找到其中的复选框（CheckBox）组件，将其设置为不可见状态，
// 隐藏复选框，因为没有文本内容时可能不需要显示复选框进行相关操作。
mEditTextList.getChildAt(index).findViewById(R.id.cb_edit_item).setVisibility(View.GONE);
}
}
@ -777,6 +945,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
""));
}
mNoteEditor.setText(getHighlightQueryResult(mWorkingNote.getContent(), mUserQuery));
// 设置笔记编辑框（mNoteEditor）的文本内容，通过调用 getHighlightQueryResult 方法，根据正在编辑的笔记对象（mWorkingNote）的内容和用户查询文本（mUserQuery），
// 获取带有高亮显示效果的文本内容，并设置到笔记编辑框中展示给用户，恢复普通文本编辑模式下的文本显示。
mEditTextList.setVisibility(View.GONE);
mNoteEditor.setVisibility(View.VISIBLE);
}
@ -784,6 +954,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
private boolean getWorkingText() {
boolean hasChecked = false;
// 判断正在编辑的笔记对象（mWorkingNote）的复选框列表模式（通过 getCheckListMode 方法获取）是否为 TextNote.MODE_CHECK_LIST（即处于复选框列表模式）。
if (mWorkingNote.getCheckListMode() == TextNote.MODE_CHECK_LIST) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < mEditTextList.getChildCount(); i++) {
@ -792,8 +963,12 @@ public class NoteEditActivity extends Activity implements OnClickListener,
if (!TextUtils.isEmpty(edit.getText())) {
if (((CheckBox) view.findViewById(R.id.cb_edit_item)).isChecked()) {
sb.append(TAG_CHECKED).append(" ").append(edit.getText()).append("\n");
// 如果复选框处于选中状态，将特定的选中标记（TAG_CHECKED）、空格以及文本编辑框中的文本内容拼接起来，并添加换行符，
// 按照特定格式构建列表项文本内容，添加到 StringBuilder 中，同时将 hasChecked 标记为 true，表示存在已选中的列表项。
hasChecked = true;
} else {
// 如果笔记对象不处于复选框列表模式，则直接将笔记编辑框（mNoteEditor）中的文本内容（通过调用其 getText 方法获取文本内容并转换为字符串），
// 设置为正在编辑的笔记对象（mWorkingNote）的工作文本内容，通过调用其 setWorkingText 方法实现。
sb.append(TAG_UNCHECKED).append(" ").append(edit.getText()).append("\n");
}
}
@ -818,6 +993,7 @@ public class NoteEditActivity extends Activity implements OnClickListener,
*/
setResult(RESULT_OK);
}
// 返回保存操作是否成功的布尔值，以便调用此方法的地方根据返回值进行相应的后续处理，比如提示用户保存成功与否等情况。
return saved;
}
@ -844,6 +1020,8 @@ public class NoteEditActivity extends Activity implements OnClickListener,
sender.putExtra("duplicate", true);
sender.setAction("com.android.launcher.action.INSTALL_SHORTCUT");
showToast(R.string.info_note_enter_desktop);
// 此方法用于将正在编辑的笔记相关的快捷方式发送到桌面，在操作前会先确保笔记已保存（如果是新笔记则先调用saveNote方法保存），
// 然后根据笔记的ID是否有效（大于0表示有效）构建相应的Intent并发送广播来创建桌面快捷方式，若笔记ID无效则提示用户输入内容。
sendBroadcast(sender);
} else {
/**
@ -856,9 +1034,13 @@ public class NoteEditActivity extends Activity implements OnClickListener,
}
}
// 此方法用于处理正在编辑的笔记内容文本，去除其中特定的标记（如选中、未选中标记），并根据设定的最大长度限制（SHORTCUT_ICON_TITLE_MAX_LEN）对文本进行截断处理，
// 最终返回处理后的适合作为桌面快捷方式图标的标题文本。
private String makeShortcutIconTitle(String content) {
content = content.replace(TAG_CHECKED, "");
content = content.replace(TAG_UNCHECKED, "");
// 判断处理后的内容文本长度是否大于设定的快捷方式图标标题最大长度（SHORTCUT_ICON_TITLE_MAX_LEN），如果大于，则截取从开头到最大长度位置的子字符串作为最终结果，
// 对文本进行截断处理，以满足长度限制要求；如果不大于，则直接返回原内容文本作为最终的快捷方式图标标题文本。
return content.length() > SHORTCUT_ICON_TITLE_MAX_LEN ? content.substring(0,
SHORTCUT_ICON_TITLE_MAX_LEN) : content;
}
@ -867,6 +1049,9 @@ public class NoteEditActivity extends Activity implements OnClickListener,
showToast(resId, Toast.LENGTH_SHORT);
}
// 此重载方法用于根据传入的提示信息对应的资源ID（resId）以及显示时长参数（duration），创建并显示一个Toast提示信息，
// 通过调用Toast的makeText方法传入当前Activity的上下文（this）、提示信息资源ID以及显示时长，然后调用show方法将Toast显示出来，
// 用于在应用中向用户展示简短的提示信息，如操作成功、失败等提示内容。
private void showToast(int resId, int duration) {
Toast.makeText(this, resId, duration).show();
}

69
src/Notes-master/src/net/micode/notes/ui/NoteEditText.java
Unescape View File

@ -37,22 +37,35 @@ import net.micode.notes.R;
import java.util.HashMap;
import java.util.Map;
// NoteEditText类继承自EditText，是一个自定义的文本编辑视图类，在基础的文本编辑功能上添加了一些自定义的交互逻辑和事件处理机制。
public class NoteEditText extends EditText {
// 用于日志记录的标签，方便在调试时识别该类输出的日志信息
private static final String TAG = "NoteEditText";
// 用于记录当前NoteEditText实例在一组编辑文本中的索引位置，可能用于区分不同的编辑文本块等场景
private int mIndex;
// 记录在按下删除键（KEYCODE_DEL）之前文本选择的起始位置，用于后续判断删除操作相关的逻辑
private int mSelectionStartBeforeDelete;
// 定义表示电话号码链接的协议头字符串，用于识别文本中是否包含电话号码链接
private static final String SCHEME_TEL = "tel:" ;
// 定义表示超链接（HTTP协议）的协议头字符串，用于识别文本中是否包含网页链接
private static final String SCHEME_HTTP = "http:" ;
// 定义表示邮件链接的协议头字符串，用于识别文本中是否包含邮件链接
private static final String SCHEME_EMAIL = "mailto:" ;
// 创建一个HashMap，用于存储不同协议头字符串与对应的资源ID的映射关系，
// 资源ID可能对应着不同链接类型在界面上显示的提示字符串等信息，方便后续根据链接类型获取相应的显示资源。
private static final Map<String, Integer> sSchemaActionResMap = new HashMap<String, Integer>();
// 静态代码块，用于初始化sSchemaActionResMap，将不同协议头字符串与对应的资源ID进行关联。
static {
sSchemaActionResMap.put(SCHEME_TEL, R.string.note_link_tel);
sSchemaActionResMap.put(SCHEME_HTTP, R.string.note_link_web);
sSchemaActionResMap.put(SCHEME_EMAIL, R.string.note_link_email);
}
// 定义一个内部接口OnTextViewChangeListener，用于与外部类进行交互，通知外部关于文本编辑视图的一些重要事件变化，
// 外部类需要实现该接口来响应这些事件。
/**
* Call by the {@link NoteEditActivity} to delete or add edit text
*/
@ -60,60 +73,88 @@ public class NoteEditText extends EditText {
/**
* Delete current edit text when {@link KeyEvent#KEYCODE_DEL} happens
* and the text is null
* 当按下删除键（KEYCODE_DEL）并且文本内容为空时，调用该方法删除当前的编辑文本，外部实现类可在此方法中执行相应的删除逻辑，
* 参数index表示当前NoteEditText实例的索引，text表示当前编辑文本的内容字符串。
*/
void onEditTextDelete(int index, String text);
/**
/**
* Add edit text after current edit text when {@link KeyEvent#KEYCODE_ENTER}
* happen
* 当按下回车键（KEYCODE_ENTER）时，调用该方法在当前编辑文本之后添加新的编辑文本，外部实现类可在此方法中执行相应的添加逻辑，
* 参数index表示当前NoteEditText实例的索引，text表示当前编辑文本中光标位置之后的文本内容字符串（可能用于新添加编辑文本的初始内容等）。
*/
void onEditTextEnter(int index, String text);
/**
/**
* Hide or show item option when text change
* 当文本内容发生变化时，调用该方法来决定是否隐藏或显示相关的选项（具体取决于外部实现逻辑），
* 参数index表示当前NoteEditText实例的索引，hasText表示当前编辑文本是否有内容（true表示有内容，false表示无内容）。
*/
void onTextChange(int index, boolean hasText);
}
// 用于存储实现了OnTextViewChangeListener接口的实例，通过设置该实例，使得外部类能够监听该文本编辑视图的相关事件变化。
private OnTextViewChangeListener mOnTextViewChangeListener;
// 构造方法，接受一个Context参数，用于创建NoteEditText实例，调用父类（EditText）的构造方法进行初始化，
// 同时将当前实例的索引mIndex初始化为0。
public NoteEditText(Context context) {
super(context, null);
mIndex = 0;
}
// 设置当前NoteEditText实例在一组编辑文本中的索引位置，方便在事件处理等逻辑中区分不同的文本编辑区域。
public void setIndex(int index) {
mIndex = index;
}
// 设置用于监听文本编辑视图相关事件变化的监听器实例，外部类实现OnTextViewChangeListener接口后，通过传入该实例，
// 使得本类能够在相应事件发生时通知外部类进行处理。
public void setOnTextViewChangeListener(OnTextViewChangeListener listener) {
mOnTextViewChangeListener = listener;
}
// 构造方法，接受一个Context和一个AttributeSet参数，用于创建NoteEditText实例，
// 调用父类（EditText）带有特定样式属性（android.R.attr.editTextStyle）的构造方法进行初始化，
// 该样式属性会应用默认的EditText样式到当前实例上。
public NoteEditText(Context context, AttributeSet attrs) {
super(context, attrs, android.R.attr.editTextStyle);
}
// 构造方法，接受一个Context、AttributeSet和defStyle参数，用于创建NoteEditText实例，
// 调用父类（EditText）的构造方法进行初始化，这里的TODO注释表示后续可能需要完善该构造方法的具体逻辑，目前仅完成了基本的调用父类构造函数操作。
public NoteEditText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
// TODO Auto-generated constructor stub
}
// 重写onTouchEvent方法，用于处理触摸事件。主要功能是在用户按下（ACTION_DOWN）屏幕时，根据触摸点的位置来设置文本的选择位置。
// 通过一系列坐标计算，获取触摸点所在的文本行以及在该行中的水平偏移位置，进而将文本选择位置设置到对应的位置上，方便用户进行后续操作，
// 最后调用父类的onTouchEvent方法继续处理其他触摸相关的逻辑。
@Override
public boolean onTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
// 获取触摸点相对于视图左上角的X坐标
int x = (int) event.getX();
// 获取触摸点相对于视图左上角的Y坐标
int y = (int) event.getY();
// 减去视图左边的内边距，将坐标转换为相对于文本内容区域的坐标
x -= getTotalPaddingLeft();
// 减去视图上边的内边距，将坐标转换为相对于文本内容区域的坐标
y -= getTotalPaddingTop();
// 加上视图的水平滚动偏移量，考虑到文本内容可能存在滚动情况
x += getScrollX();
// 加上视图的垂直滚动偏移量，考虑到文本内容可能存在滚动情况
y += getScrollY();
// 获取当前文本的布局信息对象，用于后续根据坐标计算文本位置相关信息
Layout layout = getLayout();
// 根据触摸点的垂直坐标获取所在的文本行索引
int line = layout.getLineForVertical(y);
// 根据触摸点所在的文本行以及水平坐标获取对应的文本偏移位置（字符索引位置）
int off = layout.getOffsetForHorizontal(line, x);
// 将文本选择位置设置为计算得到的偏移位置，使得用户触摸到的位置对应的文本被选中
Selection.setSelection(getText(), off);
break;
}
@ -121,6 +162,9 @@ public class NoteEditText extends EditText {
return super.onTouchEvent(event);
}
// 重写onKeyDown方法，用于处理按键按下事件。主要针对回车键（KEYCODE_ENTER）和删除键（KEYCODE_DEL）进行特殊处理，
// 当按下回车键时，如果设置了OnTextViewChangeListener监听器，则直接返回false（可能后续由外部决定是否处理回车键按下的逻辑）；
// 当按下删除键时，记录下当前文本选择的起始位置，以便后续在删除键抬起时判断相关删除逻辑，其他按键则按照父类默认逻辑处理。
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
@ -138,6 +182,12 @@ public class NoteEditText extends EditText {
return super.onKeyDown(keyCode, event);
}
// 重写onKeyUp方法，用于处理按键抬起事件。针对删除键（KEYCODE_DEL）和回车键（KEYCODE_ENTER）进行特定逻辑处理，
// 当删除键抬起时，如果设置了OnTextViewChangeListener监听器，并且当前文本选择起始位置为0且当前实例索引不为0（可能表示删除当前文本块的情况），
// 则调用监听器的onEditTextDelete方法通知外部进行删除操作，并返回true表示已处理该事件；
// 当回车键抬起时，如果设置了OnTextViewChangeListener监听器，则获取当前文本选择位置后的文本内容，将当前文本内容截取到选择位置之前，
// 然后调用监听器的onEditTextEnter方法通知外部添加新的编辑文本，并传入相关参数，最后返回父类的onKeyUp方法处理结果继续处理其他按键抬起相关逻辑。
@Override
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch(keyCode) {
@ -167,6 +217,9 @@ public class NoteEditText extends EditText {
return super.onKeyUp(keyCode, event);
}
// 重写onFocusChanged方法，用于处理焦点变化事件。当焦点发生变化时，如果设置了OnTextViewChangeListener监听器，
// 根据当前是否失去焦点以及文本内容是否为空，调用监听器的onTextChange方法通知外部进行相应的显示选项等逻辑处理，
// 最后调用父类的onFocusChanged方法继续处理其他焦点变化相关逻辑。
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
if (mOnTextViewChangeListener != null) {
@ -179,6 +232,12 @@ public class NoteEditText extends EditText {
super.onFocusChanged(focused, direction, previouslyFocusedRect);
}
// 重写onCreateContextMenu方法，用于创建上下文菜单（通常长按文本等操作时弹出）。
// 如果当前编辑文本内容是Spanned类型（表示包含富文本信息，比如链接等），则获取当前文本选择区域内的URLSpan对象数组（可能包含多个链接），
// 如果只有一个链接，则根据链接的URL判断其协议头（如是否是tel、http、mailto等），从sSchemaActionResMap中获取对应的资源ID，
// 如果没有匹配的协议头，则使用默认资源ID（R.string.note_link_other），然后创建一个菜单项添加到上下文菜单中，
// 并设置菜单项的点击监听器，当点击该菜单项时，调用对应的URLSpan的onClick方法（通常会触发相应的链接跳转等操作），
// 最后调用父类的onCreateContextMenu方法继续添加其他默认的上下文菜单选项等操作。
@Override
protected void onCreateContextMenu(ContextMenu menu) {
if (getText() instanceof Spanned) {

239
src/Notes-master/src/net/micode/notes/ui/NoteItemData.java
Unescape View File

@ -25,8 +25,9 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.DataUtils;
// NoteItemData类用于封装笔记相关的数据信息，从数据库查询结果（Cursor）中提取并整理数据，同时提供了一些方法用于获取和判断这些数据的相关属性。
public class NoteItemData {
// 定义一个字符串数组，用于指定从数据库查询笔记相关信息时需要获取的列名，涵盖了笔记的各种属性，如ID、提醒日期、背景颜色ID、创建日期等等。
static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.ALERTED_DATE,
@ -42,6 +43,7 @@ public class NoteItemData {
NoteColumns.WIDGET_TYPE,
};
// 定义一系列常量，用于表示各个数据列在查询结果的Cursor中的索引位置，方便后续从Cursor中准确获取对应的数据，提高代码的可读性和可维护性。
private static final int ID_COLUMN = 0;
private static final int ALERTED_DATE_COLUMN = 1;
private static final int BG_COLOR_ID_COLUMN = 2;
@ -55,14 +57,249 @@ public class NoteItemData {
private static final int WIDGET_ID_COLUMN = 10;
private static final int WIDGET_TYPE_COLUMN = 11;
// 笔记的唯一标识符，存储从数据库获取的笔记ID值。
private long mId;
// 笔记的提醒日期，存储对应的时间戳信息，若没有提醒则可能为0等特定值。
private long mAlertDate;
// 笔记的背景颜色ID，用于确定笔记在界面上显示的背景颜色相关设置。
private int mBgColorId;
// 笔记的创建日期，存储对应的时间戳信息，用于记录笔记创建的时间。
private long mCreatedDate;
// 标记笔记是否有附件，通过从数据库获取的值转换为布尔类型（大于0表示有附件，设为true，否则为false）。
private boolean mHasAttachment;
// 笔记的最后修改日期，存储对应的时间戳信息，用于记录笔记最后一次被修改的时间。
private long mModifiedDate;
// 与笔记相关的数量信息（具体含义可能根据业务逻辑确定，比如关联的子笔记数量等），从数据库获取对应整数值。
private int mNotesCount;
// 笔记的父级ID，用于表示笔记所属的文件夹等上级容器的ID，通过数据库查询获取对应长整数值。
private long mParentId;
// 笔记的摘要信息（可能是简短描述等内容），从数据库获取字符串内容，并进行一些特定字符串替换操作（去除一些标记字符串）。
private String mSnippet;
// 笔记的类型，通过从数据库获取的整数值来表示不同类型的笔记（具体类型值的含义由业务逻辑定义，如普通笔记、系统笔记等）。
private int mType;
// 笔记关联的小部件ID（如果有相关小部件的话），从数据库获取对应整数值。
private int mWidgetId;
// 笔记关联的小部件类型（同样根据业务逻辑确定不同类型小部件的表示值），从数据库获取对应整数值。
private int mWidgetType;
// 联系人姓名相关信息，初始为空字符串，后续根据笔记所属文件夹等情况可能从联系人数据中获取并赋值。
private String mName;
// 电话号码相关信息，初始为空字符串，若笔记属于通话记录文件夹等相关情况，会尝试获取对应的电话号码。
private String mPhoneNumber;
// 标记当前笔记数据对应的记录是否是查询结果中的最后一项，通过在构造方法中根据Cursor判断并赋值。
private boolean mIsLastItem;
// 标记当前笔记数据对应的记录是否是查询结果中的第一项，通过在构造方法中根据Cursor判断并赋值。
private boolean mIsFirstItem;
// 标记查询结果中是否只有一条记录（即当前笔记数据是否是唯一的一条记录），通过在构造方法中根据Cursor记录数量判断并赋值。
private boolean mIsOnlyOneItem;
// 标记当前笔记是否是某个文件夹后面仅跟随的一条笔记（根据笔记类型以及前后记录的情况判断），通过在构造方法中特定逻辑判断并赋值。
private boolean mIsOneNoteFollowingFolder;
// 标记当前笔记是否是某个文件夹后面跟随的多条笔记中的一条（根据笔记类型以及前后记录的情况判断），通过在构造方法中特定逻辑判断并赋值。
private boolean mIsMultiNotesFollowingFolder;
// 构造方法，接受上下文环境（Context）和一个Cursor对象作为参数，用于从Cursor中提取并初始化笔记相关的数据信息，同时进行一些额外的逻辑判断和数据处理。
public NoteItemData(Context context, Cursor cursor) {
// 从Cursor中获取笔记的ID值，并赋值给成员变量mId。
mId = cursor.getLong(ID_COLUMN);
// 从Cursor中获取笔记的提醒日期时间戳，并赋值给成员变量mAlertDate。
mAlertDate = cursor.getLong(ALERTED_DATE_COLUMN);
// 从Cursor中获取笔记的背景颜色ID，并赋值给成员变量mBgColorId。
mBgColorId = cursor.getInt(BG_COLOR_ID_COLUMN);
// 从Cursor中获取笔记的创建日期时间戳，并赋值给成员变量mCreatedDate。
mCreatedDate = cursor.getLong(CREATED_DATE_COLUMN);
// 根据从Cursor中获取的表示是否有附件的整数值，转换为布尔类型赋值给mHasAttachment，大于0表示有附件，设为true，否则为false。
mHasAttachment = (cursor.getInt(HAS_ATTACHMENT_COLUMN) > 0)? true : false;
// 从Cursor中获取笔记的最后修改日期时间戳，并赋值给成员变量mModifiedDate。
mModifiedDate = cursor.getLong(MODIFIED_DATE_COLUMN);
// 从Cursor中获取笔记相关的数量信息（如子笔记数量等），并赋值给成员变量mNotesCount。
mNotesCount = cursor.getInt(NOTES_COUNT_COLUMN);
// 从Cursor中获取笔记的父级ID，并赋值给成员变量mParentId。
mParentId = cursor.getLong(PARENT_ID_COLUMN);
// 从Cursor中获取笔记的摘要信息字符串，赋值给成员变量mSnippet，并进行特定字符串替换操作，去除可能存在的一些标记字符串（如NoteEditActivity.TAG_CHECKED和NoteEditActivity.TAG_UNCHECKED）。
mSnippet = cursor.getString(SNIPPET_COLUMN);
mSnippet = mSnippet.replace(NoteEditActivity.TAG_CHECKED, "").replace(
NoteEditActivity.TAG_UNCHECKED, "");
// 从Cursor中获取笔记的类型整数值，并赋值给成员变量mType。
mType = cursor.getInt(TYPE_COLUMN);
// 从Cursor中获取笔记关联的小部件ID，并赋值给成员变量mWidgetId。
mWidgetId = cursor.getInt(WIDGET_ID_COLUMN);
// 从Cursor中获取笔记关联的小部件类型整数值，并赋值给成员变量mWidgetType。
mWidgetType = cursor.getInt(WIDGET_TYPE_COLUMN);
// 初始化电话号码为空字符串，后续根据笔记所属文件夹情况判断是否获取实际电话号码。
mPhoneNumber = "";
// 如果笔记的父级ID等于特定的通话记录文件夹ID（Notes.ID_CALL_RECORD_FOLDER），则尝试从数据中获取对应的电话号码。
if (mParentId == Notes.ID_CALL_RECORD_FOLDER) {
mPhoneNumber = DataUtils.getCallNumberByNoteId(context.getContentResolver(), mId);
// 如果获取到的电话号码不为空字符串，尝试通过电话号码获取对应的联系人姓名。
if (!TextUtils.isEmpty(mPhoneNumber)) {
mName = Contact.getContact(context, mPhoneNumber);
// 如果获取联系人姓名失败（返回null），则将电话号码作为联系人姓名显示（可能是一种兜底处理方式）。
if (mName == null) {
mName = mPhoneNumber;
}
}
}
// 如果联系人姓名仍为null（可能前面获取过程都失败了），则将其设置为空字符串，确保该成员变量有合理的默认值。
if (mName == null) {
mName = "";
}
// 调用checkPostion方法，根据Cursor的相关信息判断并设置当前笔记数据在查询结果中的位置相关属性，如是否是第一项、最后一项等以及与文件夹关联的笔记数量情况等属性。
checkPostion(cursor);
}
// 私有方法，用于根据Cursor的相关信息判断并设置当前笔记数据在查询结果中的位置相关属性，如是否是第一项、最后一项等以及与文件夹关联的笔记数量情况等属性。
private void checkPostion(Cursor cursor) {
// 根据Cursor的isLast方法判断当前记录是否是最后一项，将结果赋值给mIsLastItem成员变量。
mIsLastItem = cursor.isLast()? true : false;
// 根据Cursor的isFirst方法判断当前记录是否是第一项，将结果赋值给mIsFirstItem成员变量。
mIsFirstItem = cursor.isFirst()? true : false;
// 根据Cursor的记录数量判断是否只有一条记录，将结果赋值给mIsOnlyOneItem成员变量。
mIsOnlyOneItem = (cursor.getCount() == 1);
// 初始设置为当前笔记不是某个文件夹后面跟随的多条笔记中的一条，后续根据具体逻辑判断是否更改该值。
mIsMultiNotesFollowingFolder = false;
// 初始设置为当前笔记不是某个文件夹后面仅跟随的一条笔记，后续根据具体逻辑判断是否更改该值。
mIsOneNoteFollowingFolder = false;
// 如果笔记类型是普通笔记（Notes.TYPE_NOTE）并且不是第一项记录（说明前面可能有其他记录），则进行以下判断逻辑。
if (mType == Notes.TYPE_NOTE &&!mIsFirstItem) {
// 获取当前记录在Cursor中的位置索引。
int position = cursor.getPosition();
// 将Cursor指针移动到前一条记录（用于查看前一条记录的类型等信息）。
if (cursor.moveToPrevious()) {
// 判断前一条记录的类型是否是文件夹类型（Notes.TYPE_FOLDER）或者系统类型（Notes.TYPE_SYSTEM），如果是，则说明当前笔记可能与文件夹存在关联情况，继续后续判断。
if (cursor.getInt(TYPE_COLUMN) == Notes.TYPE_FOLDER
|| cursor.getInt(TYPE_COLUMN) == Notes.TYPE_SYSTEM) {
// 判断Cursor的总记录数是否大于当前位置索引加1（即当前笔记后面是否还有其他记录），如果是，则说明当前笔记是某个文件夹后面跟随的多条笔记中的一条，设置相应标记为true。
if (cursor.getCount() > (position + 1)) {
mIsMultiNotesFollowingFolder = true;
} else {
// 否则说明当前笔记是某个文件夹后面仅跟随的一条笔记，设置相应标记为true。
mIsOneNoteFollowingFolder = true;
}
}
// 将Cursor指针再移回原来的位置（确保后续操作不受影响，因为前面移动了指针），如果移动失败则抛出异常（表示出现了不合理的游标操作情况）。
if (!cursor.moveToNext()) {
throw new IllegalStateException("cursor move to previous but can't move back");
}
}
}
}
// 判断当前笔记是否是某个文件夹后面仅跟随的一条笔记，返回对应的布尔值。
public boolean isOneFollowingFolder() {
return mIsOneNoteFollowingFolder;
}
// 判断当前笔记是否是某个文件夹后面跟随的多条笔记中的一条，返回对应的布尔值。
public boolean isMultiFollowingFolder() {
return mIsMultiNotesFollowingFolder;
}
// 判断当前笔记数据对应的记录是否是查询结果中的最后一项，返回对应的布尔值。
public boolean isLast() {
return mIsLastItem;
}
// 获取联系人姓名（可能是与笔记关联的通话记录对应的联系人姓名等情况），返回对应的字符串。
public String getCallName() {
return mName;
}
// 判断当前笔记数据对应的记录是否是查询结果中的第一项，返回对应的布尔值。
public boolean isFirst() {
return mIsFirstItem;
}
// 判断查询结果中是否只有当前这一条笔记数据记录，返回对应的布尔值。
public boolean isSingle() {
return mIsOnlyOneItem;
}
// 获取笔记的唯一标识符ID，返回对应的长整数值。
public long getId() {
return mId;
}
// 获取笔记的提醒日期时间戳，返回对应的长整数值。
public long getAlertDate() {
return mAlertDate;
}
// 获取笔记的创建日期时间戳，返回对应的长整数值。
public long getCreatedDate() {
return mCreatedDate;
}
// 判断笔记是否有附件，返回对应的布尔值。
public boolean hasAttachment() {
return mHasAttachment;
}
// 获取笔记的最后修改日期时间戳，返回对应的长整数值。
public long getModifiedDate() {
return mModifiedDate;
}
// 获取笔记的背景颜色ID，返回对应的整数值。
public int getBgColorId() {
return mBgColorId;
}
// 获取笔记的父级ID，返回对应的长整数值。
public long getParentId() {
return mParentId;
}
// 获取笔记相关的数量信息（如子笔记数量等），返回对应的整数值。
public int getNotesCount() {
return mNotesCount;
}
// 获取笔记所属文件夹的ID（与getParentId方法返回值相同，可能为了语义更清晰在不同场景使用），返回对应的长整数值。
public long getFolderId () {
return mParentId;
}
// 获取笔记的类型（如普通笔记、文件夹类型等，根据业务逻辑定义的类型值），返回对应的整数值。
public int getType() {
return mType;
}
// 获取笔记关联的小部件类型（根据业务逻辑定义的不同小部件类型值），返回对应的整数值。
public int getWidgetType() {
return mWidgetType;
}
// 获取笔记关联的小部件ID，返回对应的整数值。
public int getWidgetId() {
return mWidgetId;
}
// 获取笔记的摘要信息字符串，返回对应的字符串内容。
public String getSnippet() {
return mSnippet;
}
// 判断笔记是否设置了提醒（通过提醒日期是否大于0来判断），返回对应的布尔值。
public boolean hasAlert() {
return (mAlertDate > 0);
}
// 判断笔记是否属于通话记录（通过父级ID是否是通话记录文件夹ID以及电话号码是否为空来判断），返回对应的布尔值。
public boolean isCallRecord() {
return (mParentId == Notes.ID_CALL_RECORD_FOLDER &&!TextUtils.isEmpty(mPhoneNumber));
}
// 静态方法，用于从给定的Cursor中获取笔记的类型（通过获取对应类型列的整数值），返回对应的整数值，方便在其他地方直接获取笔记类型信息而无需创建NoteItemData实例。
public static int getNoteType(Cursor cursor) {
return cursor.getInt(TYPE_COLUMN);
}
}
希望上述注释后的代码能帮助你清晰地理解 NoteItemData 类的具体功能、数据处理逻辑以及各个方法的作用。如果还有其他疑问，请随时向我提问。需要注意的是，代码中涉及到的部分类（如 NoteColumns、Notes、DataUtils、Contact、NoteEditActivity）的具体实现没有给出，可能需要结合它们的完整定义来进一步深入理解相关业务逻辑细节。
private String mSnippet;
private int mType;
private int mWidgetId;

111
src/Notes-master/src/net/micode/notes/ui/NotesListActivity.java
Unescape View File

@ -147,6 +147,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
setAppInfoFromRawRes();
}
// 当启动的其他Activity返回结果时调用此方法，用于处理返回的结果数据，根据请求码（requestCode）和结果码（resultCode）来执行相应的逻辑。
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == RESULT_OK
@ -157,6 +158,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
// 此方法用于从原始资源文件（可能是文本文件等）中读取应用的介绍信息，并将其保存为一条笔记记录，同时将一个表示是否已添加介绍信息的共享偏好设置项设置为true，
// 用于标记已经完成了首次使用时介绍信息的插入操作，下次启动应用时就不会重复执行此操作。
private void setAppInfoFromRawRes() {
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
if (!sp.getBoolean(PREFERENCE_ADD_INTRODUCTION, false)) {
@ -190,6 +193,9 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
// 创建一个空的WorkingNote对象，通过调用WorkingNote的createEmptyNote静态方法，传入当前Activity的上下文（this）、根文件夹ID（Notes.ID_ROOT_FOLDER）、
// 无效的桌面小部件ID（AppWidgetManager.INVALID_APPWIDGET_ID）、无效的小部件类型（Notes.TYPE_WIDGET_INVALIDE）以及默认的颜色资源（ResourceParser.RED）等参数，
// 用于构建一个初始的笔记对象，准备保存介绍信息到该笔记中。
WorkingNote note = WorkingNote.createEmptyNote(this, Notes.ID_ROOT_FOLDER,
AppWidgetManager.INVALID_APPWIDGET_ID, Notes.TYPE_WIDGET_INVALIDE,
ResourceParser.RED);
@ -210,7 +216,12 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
private void initResources() {
// 获取系统的内容解析器（ContentResolver），通过调用当前Activity的 `getContentResolver` 方法，
// 内容解析器用于与应用的内容提供器（Content Provider）交互，可对数据库等数据源进行查询、插入、更新、删除等操作，
// 在这里可能用于后续查询笔记数据等相关操作。
mContentResolver = this.getContentResolver();
// 创建一个 `BackgroundQueryHandler` 实例，传入刚才获取的内容解析器，这个类可能是自定义的用于在后台线程处理查询操作的处理器，
// 以便在执行一些耗时的数据查询等操作时，不会阻塞主线程，保证界面的流畅性。
mBackgroundQueryHandler = new BackgroundQueryHandler(this.getContentResolver());
mCurrentFolderId = Notes.ID_ROOT_FOLDER;
mNotesListView = (ListView) findViewById(R.id.notes_list);
@ -232,8 +243,11 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
private class ModeCallback implements ListView.MultiChoiceModeListener, OnMenuItemClickListener {
// 定义一个 `DropdownMenu` 类型的成员变量，用于展示下拉菜单，可能包含一些与多选操作相关的额外功能选项，
// 具体功能和样式由 `DropdownMenu` 类的实现决定，比如全选、反选等操作可能会放在这个下拉菜单中。
private DropdownMenu mDropDownMenu;
private ActionMode mActionMode;
// 当进入多选操作模式时（例如用户长按 `ListView` 中的某个项后进入多选模式），会调用此方法来创建操作菜单等初始化操作。
private MenuItem mMoveMenu;
public boolean onCreateActionMode(ActionMode mode, Menu menu) {
@ -252,6 +266,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mNotesListView.setLongClickable(false);
mAddNewNote.setVisibility(View.GONE);
// 通过 `LayoutInflater` 从当前Activity的上下文（NotesListActivity.this，这里使用外部类名来明确上下文）加载一个布局资源（R.layout.note_list_dropdown_menu）创建一个视图，
// 这个视图将作为操作模式的自定义视图，用于展示一些额外的操作界面元素，比如上述提到的下拉菜单等内容。
View customView = LayoutInflater.from(NotesListActivity.this).inflate(
R.layout.note_list_dropdown_menu, null);
mode.setCustomView(customView);
@ -262,6 +278,7 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
public boolean onMenuItemClick(MenuItem item) {
mNotesListAdapter.selectAll(!mNotesListAdapter.isAllSelected());
updateMenu();
// 返回 `true` 表示操作模式创建成功，系统可以继续进行后续的多选模式相关操作，比如显示操作菜单等。
return true;
}
@ -286,6 +303,10 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
// 此方法是 `ListView.MultiChoiceModeListener` 接口中的方法，当用户在多选操作模式下点击了操作菜单中的某个菜单项时会被调用，
// 开发者需要在此方法中编写逻辑来处理不同菜单项点击对应的具体业务操作，比如点击“删除”菜单项执行删除选中笔记的操作等。
// 目前方法体中是自动生成的 `TODO` 注释，意味着还需要根据实际需求添加相应的业务逻辑代码来处理菜单项点击事件，
// 返回值为 `false`，同样按照接口的默认约定，如果返回 `false` 可能表示未处理该点击事件（具体也要看使用场景和框架的要求）。
public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
// TODO Auto-generated method stub
return false;
@ -296,12 +317,16 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return false;
}
// 此方法是 `ListView.MultiChoiceModeListener` 接口中的方法，当多选操作模式被销毁（例如用户按下返回键或者完成多选操作等情况退出多选模式）时会被调用，
// 用于在操作模式结束后进行一些清理和恢复界面初始状态的操作。
public void onDestroyActionMode(ActionMode mode) {
mNotesListAdapter.setChoiceMode(false);
mNotesListView.setLongClickable(true);
mAddNewNote.setVisibility(View.VISIBLE);
}
// 此方法用于手动结束当前的操作模式，通过调用 `mActionMode`（在 `onCreateActionMode` 方法中初始化的 `ActionMode` 对象）的 `finish` 方法来实现，
// 触发操作模式的销毁流程，会进而调用 `onDestroyActionMode` 等相关方法进行后续的清理和界面恢复操作。
public void finishActionMode() {
mActionMode.finish();
}
@ -313,10 +338,17 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
public boolean onMenuItemClick(MenuItem item) {
// 调用 `NotesListAdapter` 的 `setCheckedItem` 方法，传入发生选中状态改变的列表项的位置（`position`）以及新的选中状态（`checked`）参数，
// 适配器内部会根据这些信息更新其内部记录的选中项相关的数据结构，以便准确统计选中的数量、判断是否全选等情况。
// 此方法实现了 `OnMenuItemClickListener` 接口，用于处理菜单项点击事件，当用户点击了设置了此点击监听器的菜单项时会被调用，
// 在这里主要用于判断当前是否有选中的笔记项，如果没有选中任何笔记项，显示一个提示 `Toast`，告知用户需要先选择笔记项才能进行操作，并返回 `true` 表示已处理该点击事件，
// 避免事件继续向上传递导致其他不必要的处理逻辑执行。
if (mNotesListAdapter.getSelectedCount() == 0) {
Toast.makeText(NotesListActivity.this, getString(R.string.menu_select_none),
Toast.LENGTH_SHORT).show();
return true;
// 如果有选中的笔记项，这里后续应该添加具体的业务逻辑代码来处理不同菜单项点击对应的操作，目前代码没有完整实现这部分逻辑，需要开发者进一步补充完善。
// 返回值目前未明确设定，按正常逻辑应该根据具体业务处理情况返回 `true`（表示已处理）或 `false`（表示未处理）相应的点击事件。
}
switch (item.getItemId()) {
@ -343,14 +375,21 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
return false;
}
return true;
// 如果成功处理了对应的菜单项点击事件（即点击的是“删除”或“移动”菜单项并执行了相应的逻辑），则返回 `true`，
// 表示已经处理了该点击操作，通常可以告知调用者或者框架不需要再对该点击事件进行其他额外处理了。
return true;
}
}
private class NewNoteOnTouchListener implements OnTouchListener {
// 重写 `OnTouchListener` 接口中的 `onTouch` 方法，当触摸事件发生在绑定了此监听器的视图（这里是 `mAddNewNote` 按钮对应的视图 `v`）上时，该方法会被调用，
// 并传入触摸事件相关的信息（视图 `v` 和 `MotionEvent` 对象 `event`），根据触摸事件的不同类型（如按下、移动、抬起等）来执行相应的逻辑处理，返回值表示是否消费了该触摸事件（`true` 表示消费，`false` 表示未消费，事件可能会继续传递）。
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN: {
// 获取当前设备屏幕的默认显示对象，通过调用 `getWindowManager().getDefaultDisplay()` 方法，
// 用于后续获取屏幕相关的尺寸信息等操作，例如屏幕的高度、宽度等，不同设备的屏幕显示属性可能不同，这里获取默认的显示配置。
Display display = getWindowManager().getDefaultDisplay();
int screenHeight = display.getHeight();
int newNoteViewHeight = mAddNewNote.getHeight();
@ -404,6 +443,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
return false;
// 如果触摸事件没有在上述任何一个 `switch` 分支中被消费（即没有返回 `true`），则返回 `false`，表示当前监听器没有处理该触摸事件，
// 触摸事件可能会继续向上传递给其他的触摸监听器或者父视图等进行处理，具体行为取决于整个视图层级的触摸事件传递机制。
}
};
@ -416,7 +457,20 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
String.valueOf(mCurrentFolderId)
}, NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC");
}
// `FOLDER_NOTE_LIST_QUERY_TOKEN`：是一个自定义的查询令牌（Token），用于标识此次查询的类型，方便在查询完成后根据这个令牌来区分不同的查询结果并进行相应处理，
// 例如在 `onQueryComplete` 方法中会通过这个令牌判断是哪个查询任务完成了。
// `null`：是一个可以传递给查询处理器的额外对象（通常称为Cookie），在这里没有使用，所以传入 `null`，如果有需要可以传入一个自定义的对象，
// 在查询完成后的回调中可以获取到这个对象进行一些额外的相关操作（具体取决于业务逻辑需求）。
// `Notes.CONTENT_NOTE_URI`：应该是一个定义好的表示笔记内容的内容提供者（Content Provider）的统一资源标识符（URI），
// 指明了要从哪里查询笔记数据，也就是告诉系统要去哪个数据源（通常是数据库对应的内容提供者）查询相应的笔记信息。
// `NoteItemData.PROJECTION`：是一个字符串数组，定义了查询结果中要返回的列名，也就是指定了从数据库中查询笔记数据时，具体要获取哪些字段的信息，
// 例如可能包含笔记的标题、内容、创建时间等字段，只获取需要的字段可以提高查询效率，减少不必要的数据传输和处理。
// `selection`：就是前面根据当前文件夹情况确定的查询筛选条件字符串，用于在数据库中筛选出符合条件的笔记记录，比如筛选出某个文件夹下的笔记等。
// `new String[] { String.valueOf(mCurrentFolderId) }`：是一个字符串数组，用于给查询筛选条件中的占位符（通常在 `selection` 字符串中用 `?` 表示）赋值，
// 在这里将当前文件夹的ID转换为字符串后放入数组中，传递给查询操作，使得筛选条件能够准确地基于当前文件夹ID进行筛选，例如筛选出父ID等于当前文件夹ID的笔记。
// `NoteColumns.TYPE + " DESC," + NoteColumns.MODIFIED_DATE + " DESC"`：是一个排序规则字符串，指定了查询结果按照笔记的类型（`NoteColumns.TYPE`）降序排列，
// 并且在类型相同的情况下，按照修改日期（`NoteColumns.MODIFIED_DATE`）降序排列，这样查询出来的笔记列表数据在展示时会按照特定的顺序呈现给用户，
// 比如先展示某种特定类型的最新修改的笔记等情况。
private final class BackgroundQueryHandler extends AsyncQueryHandler {
public BackgroundQueryHandler(ContentResolver contentResolver) {
super(contentResolver);
@ -460,6 +514,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
});
builder.show();
// 最后调用 `builder` 对象的 `show` 方法，将构建好的包含文件夹列表的对话框显示在界面上，让用户可以进行文件夹选择操作，
// 根据用户的选择执行相应的业务逻辑，实现将笔记移动到所选文件夹等功能。
}
private void createNewNote() {
@ -555,6 +611,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
mTitleBar.setText(data.getSnippet());
}
mTitleBar.setVisibility(View.VISIBLE);
// 创建一个意图（Intent）对象，用于启动一个新的Activity，指定要启动的Activity类为 `NoteEditActivity.class`，
// 意味着点击相应按钮或者触发相关操作后，系统将启动 `NoteEditActivity` 这个Activity，让用户可以在其中查看和编辑指定的笔记。
}
public void onClick(View v) {
@ -563,9 +621,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
createNewNote();
break;
default:
// 向意图中添加额外的数据信息，通过 `putExtra` 方法，将笔记的唯一标识符（`data.getId()`，这里的 `data` 应该是包含笔记相关信息的对象，通过其 `getId` 方法获取笔记ID）添加进去，键为 `Intent.EXTRA_UID`，
// 这样在 `NoteEditActivity` 中可以获取到这个参数，根据笔记ID从数据库等数据源查询并加载相应的笔记数据，进行展示和编辑操作。
break;
}
}
// 使用当前Activity（`this`）启动刚才创建的意图对应的Activity，并传入请求码 `REQUEST_CODE_OPEN_NODE`，
// 请求码用于在 `onActivityResult` 方法中区分不同的启动Activity返回的结果，这里特定的请求码（`REQUEST_CODE_OPEN_NODE`）表示是打开已有笔记这个操作返回的结果，
// 启动后，用户将进入 `NoteEditActivity` 查看和编辑指定的笔记，完成后会返回到当前Activity，可在 `onActivityResult` 方法中处理返回的相关数据和结果。
private void showSoftInput() {
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
@ -578,11 +641,14 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
}
// 此方法用于显示一个创建或修改文件夹的对话框，根据传入的参数 `create` 判断是创建还是修改操作，在对话框中进行相应的界面设置、事件监听以及数据处理逻辑，
// 比如设置标题、按钮文本、文本框初始内容等，并且处理用户点击确定和取消按钮的操作，包括验证文件夹名称的合法性、执行插入或更新文件夹数据等操作。
private void showCreateOrModifyFolderDialog(final boolean create) {
final AlertDialog.Builder builder = new AlertDialog.Builder(this);
View view = LayoutInflater.from(this).inflate(R.layout.dialog_edit_text, null);
final EditText etName = (EditText) view.findViewById(R.id.et_foler_name);
// 此方法用于显示一个创建或修改文件夹的对话框，根据传入的参数 `create` 判断是创建还是修改操作，在对话框中进行相应的界面设置、事件监听以及数据处理逻辑，
// 比如设置标题、按钮文本、文本框初始内容等，并且处理用户点击确定和取消按钮的操作，包括验证文件夹名称的合法性、执行插入或更新文件夹数据等操作。
showSoftInput();
if (!create) {
if (mFocusNoteDataItem != null) {
@ -596,7 +662,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
etName.setText("");
builder.setTitle(this.getString(R.string.menu_create_folder));
}
// 此方法用于显示一个创建或修改文件夹的对话框，根据传入的参数 `create` 判断是创建还是修改操作，在对话框中进行相应的界面设置、事件监听以及数据处理逻辑，
// 比如设置标题、按钮文本、文本框初始内容等，并且处理用户点击确定和取消按钮的操作，包括验证文件夹名称的合法性、执行插入或更新文件夹数据等操作。
builder.setPositiveButton(android.R.string.ok, null);
builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
@ -608,7 +675,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
final Button positive = (Button)dialog.findViewById(android.R.id.button1);
positive.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
hideSoftInput(etName);
hideSoftInput(etName);// 此方法用于显示一个创建或修改文件夹的对话框，根据传入的参数 `create` 判断是创建还是修改操作，在对话框中进行相应的界面设置、事件监听以及数据处理逻辑，
// 比如设置标题、按钮文本、文本框初始内容等，并且处理用户点击确定和取消按钮的操作，包括验证文件夹名称的合法性、执行插入或更新文件夹数据等操作。
String name = etName.getText().toString();
if (DataUtils.checkVisibleFolderName(mContentResolver, name)) {
Toast.makeText(NotesListActivity.this, getString(R.string.folder_exist, name),
@ -639,6 +707,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
if (TextUtils.isEmpty(etName.getText())) {
positive.setEnabled(false);
// 获取系统的输入方法管理器（InputMethodManager）实例，通过调用 `getSystemService` 方法传入 `Context.INPUT_METHOD_SERVICE` 作为服务类型标识来获取，
// 该管理器用于控制软键盘的显示、隐藏等相关操作，是与系统输入方法交互的重要组件。
}
/**
* When the name edit text is null, disable the positive button
@ -648,7 +718,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
// TODO Auto-generated method stub
}
// 调用输入方法管理器的 `hideSoftInputFromWindow` 方法来隐藏软键盘，传入参数 `view.getWindowToken()`，它代表与指定视图（`view`）关联的窗口令牌，
// 用于标识要操作的软键盘所属的窗口，第二个参数 `0` 表示隐藏软键盘的相关选项（这里 `0` 通常表示默认的隐藏方式，不进行额外的特殊处理）。
public void onTextChanged(CharSequence s, int start, int before, int count) {
if (TextUtils.isEmpty(etName.getText())) {
positive.setEnabled(false);
@ -662,7 +733,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
});
}
}// 调用输入方法管理器的 `hideSoftInputFromWindow` 方法来隐藏软键盘，传入参数 `view.getWindowToken()`，它代表与指定视图（`view`）关联的窗口令牌，
// 用于标识要操作的软键盘所属的窗口，第二个参数 `0` 表示隐藏软键盘的相关选项（这里 `0` 通常表示默认的隐藏方式，不进行额外的特殊处理）。
@Override
public void onBackPressed() {
@ -686,7 +758,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
default:
break;
}
}
}// 调用输入方法管理器的 `hideSoftInputFromWindow` 方法来隐藏软键盘，传入参数 `view.getWindowToken()`，它代表与指定视图（`view`）关联的窗口令牌，
// 用于标识要操作的软键盘所属的窗口，第二个参数 `0` 表示隐藏软键盘的相关选项（这里 `0` 通常表示默认的隐藏方式，不进行额外的特殊处理）。
private void updateWidget(int appWidgetId, int appWidgetType) {
Intent intent = new Intent(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
@ -706,7 +779,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
sendBroadcast(intent);
setResult(RESULT_OK, intent);
}
// 调用输入方法管理器的 `hideSoftInputFromWindow` 方法来隐藏软键盘，传入参数 `view.getWindowToken()`，它代表与指定视图（`view`）关联的窗口令牌，
// 用于标识要操作的软键盘所属的窗口，第二个参数 `0` 表示隐藏软键盘的相关选项（这里 `0` 通常表示默认的隐藏方式，不进行额外的特殊处理）。
private final OnCreateContextMenuListener mFolderOnCreateContextMenuListener = new OnCreateContextMenuListener() {
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
if (mFocusNoteDataItem != null) {
@ -715,7 +789,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
menu.add(0, MENU_FOLDER_DELETE, 0, R.string.menu_folder_delete);
menu.add(0, MENU_FOLDER_CHANGE_NAME, 0, R.string.menu_folder_change_name);
}
}
}// 获取系统的输入方法管理器（InputMethodManager）实例，通过调用 `getSystemService` 方法传入 `Context.INPUT_METHOD_SERVICE` 作为服务类型标识来获取，
// 该管理器用于控制软键盘的显示、隐藏等相关操作，是与系统输入方法交互的重要组件。
};
@Override
@ -758,7 +833,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
return true;
}
}// 获取系统的输入方法管理器（InputMethodManager）实例，通过调用 `getSystemService` 方法传入 `Context.INPUT_METHOD_SERVICE` 作为服务类型标识来获取，
// 该管理器用于控制软键盘的显示、隐藏等相关操作，是与系统输入方法交互的重要组件。
@Override
public boolean onPrepareOptionsMenu(Menu menu) {
@ -777,7 +853,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
return true;
}
// 调用输入方法管理器的 `hideSoftInputFromWindow` 方法来隐藏软键盘，传入参数 `view.getWindowToken()`，它代表与指定视图（`view`）关联的窗口令牌，
// 用于标识要操作的软键盘所属的窗口，第二个参数 `0` 表示隐藏软键盘的相关选项（这里 `0` 通常表示默认的隐藏方式，不进行额外的特殊处理）。
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
@ -817,13 +894,15 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
return true;
}
// 获取系统的输入方法管理器（InputMethodManager）实例，通过调用 `getSystemService` 方法传入 `Context.INPUT_METHOD_SERVICE` 作为服务类型标识来获取，
// 该管理器用于控制软键盘的显示、隐藏等相关操作，是与系统输入方法交互的重要组件。
@Override
public boolean onSearchRequested() {
startSearch(null, false, null /* appData */, false);
return true;
}
// 调用输入方法管理器的 `hideSoftInputFromWindow` 方法来隐藏软键盘，传入参数 `view.getWindowToken()`，它代表与指定视图（`view`）关联的窗口令牌，
// 用于标识要操作的软键盘所属的窗口，第二个参数 `0` 表示隐藏软键盘的相关选项（这里 `0` 通常表示默认的隐藏方式，不进行额外的特殊处理）。
private void exportNoteToText() {
final BackupUtils backup = BackupUtils.getInstance(NotesListActivity.this);
new AsyncTask<Void, Void, Integer>() {
@ -875,7 +954,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
Intent intent = new Intent(from, NotesPreferenceActivity.class);
from.startActivityIfNeeded(intent, -1);
}
// 获取系统的输入方法管理器（InputMethodManager）实例，通过调用 `getSystemService` 方法传入 `Context.INPUT_METHOD_SERVICE` 作为服务类型标识来获取，
// 该管理器用于控制软键盘的显示、隐藏等相关操作，是与系统输入方法交互的重要组件。
private class OnListItemClickListener implements OnItemClickListener {
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
@ -916,7 +996,8 @@ public class NotesListActivity extends Activity implements OnClickListener, OnIt
}
}
// 获取系统的输入方法管理器（InputMethodManager）实例，通过调用 `getSystemService` 方法传入 `Context.INPUT_METHOD_SERVICE` 作为服务类型标识来获取，
// 该管理器用于控制软键盘的显示、隐藏等相关操作，是与系统输入方法交互的重要组件。
private void startQueryDestinationFolders() {
String selection = NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>? AND " + NoteColumns.ID + "<>?";
selection = (mState == ListEditState.NOTE_LIST) ? selection:

62
src/Notes-master/src/net/micode/notes/ui/NotesListAdapter.java
Unescape View File

@ -32,56 +32,82 @@ import java.util.Iterator;
public class NotesListAdapter extends CursorAdapter {
// 用于日志输出的标记，方便在调试等情况下识别该类相关的日志信息
private static final String TAG = "NotesListAdapter";
// 上下文对象，用于获取系统相关资源等操作
private Context mContext;
// 用于记录每个位置（对应数据项）是否被选中的映射表，键为位置索引（整数），值为是否选中（布尔值）
private HashMap<Integer, Boolean> mSelectedIndex;
// 记录笔记的数量
private int mNotesCount;
// 表示是否处于选择模式（例如多选模式等情况）
private boolean mChoiceMode;
// 内部类，用于封装与应用小部件相关的属性（如小部件的ID和类型）
public static class AppWidgetAttribute {
public int widgetId;
public int widgetType;
};
// 构造函数，接收一个上下文对象，初始化一些成员变量
public NotesListAdapter(Context context) {
// 调用父类（CursorAdapter）的构造函数，传入上下文和初始化为null的游标
super(context, null);
// 创建一个新的HashMap用于存储选中状态信息
mSelectedIndex = new HashMap<Integer, Boolean>();
mContext = context;
mNotesCount = 0;
}
// 创建一个新的视图（View）对象，用于显示列表中的一项数据
@Override
public View newView(Context context, Cursor cursor, ViewGroup parent) {
// 创建并返回一个NotesListItem类型的视图，该视图应该是用于展示笔记列表项的自定义视图
return new NotesListItem(context);
}
// 将数据绑定到给定的视图上，用于显示具体的数据内容
@Override
public void bindView(View view, Context context, Cursor cursor) {
// 判断视图是否是NotesListItem类型的实例
if (view instanceof NotesListItem) {
// 根据给定的上下文和游标创建一个NoteItemData对象，用于获取笔记相关的数据
NoteItemData itemData = new NoteItemData(context, cursor);
// 调用NotesListItem的bind方法，将相关数据、选择模式状态以及该项是否被选中的信息传递进去，进行数据绑定显示等操作
((NotesListItem) view).bind(context, itemData, mChoiceMode,
isSelectedItem(cursor.getPosition()));
}
}
// 设置指定位置的项的选中状态
public void setCheckedItem(final int position, final boolean checked) {
// 将指定位置的选中状态存入mSelectedIndex映射表中
mSelectedIndex.put(position, checked);
// 通知数据集已发生改变，以便相关的UI组件（如ListView等）能相应地更新显示
notifyDataSetChanged();
}
// 判断是否处于选择模式
public boolean isInChoiceMode() {
return mChoiceMode;
}
// 设置选择模式，同时清空之前的选中状态记录
public void setChoiceMode(boolean mode) {
mSelectedIndex.clear();
mChoiceMode = mode;
}
// 全选或全不选所有符合条件（笔记类型为Notes.TYPE_NOTE）的项
public void selectAll(boolean checked) {
// 获取当前游标对象，用于遍历数据
Cursor cursor = getCursor();
// 遍历数据集的每一项
for (int i = 0; i < getCount(); i++) {
// 将游标移动到指定位置
if (cursor.moveToPosition(i)) {
// 判断该项对应的笔记类型是否为Notes.TYPE_NOTE，如果是，则设置其选中状态
if (NoteItemData.getNoteType(cursor) == Notes.TYPE_NOTE) {
setCheckedItem(i, checked);
}
@ -89,14 +115,21 @@ public class NotesListAdapter extends CursorAdapter {
}
}
// 获取所有已选中项的ID，存储在一个HashSet中返回
public HashSet<Long> getSelectedItemIds() {
// 创建一个用于存储已选中项ID的HashSet对象
HashSet<Long> itemSet = new HashSet<Long>();
// 遍历mSelectedIndex中记录的所有位置（键）
for (Integer position : mSelectedIndex.keySet()) {
// 如果该位置对应的项是被选中的
if (mSelectedIndex.get(position) == true) {
// 获取该项对应的ID
Long id = getItemId(position);
// 如果ID是Notes.ID_ROOT_FOLDER（可能是一个特殊的、不符合预期的ID），则在日志中记录错误信息（通常表示不应该出现这种情况）
if (id == Notes.ID_ROOT_FOLDER) {
Log.d(TAG, "Wrong item id, should not happen");
} else {
// 将符合条件的ID添加到HashSet中
itemSet.add(id);
}
}
@ -105,21 +138,32 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
// 获取所有已选中的应用小部件相关属性信息，存储在一个HashSet中返回
public HashSet<AppWidgetAttribute> getSelectedWidget() {
// 创建一个用于存储已选中小部件属性的HashSet对象
HashSet<AppWidgetAttribute> itemSet = new HashSet<AppWidgetAttribute>();
// 遍历mSelectedIndex中记录的所有位置（键）
for (Integer position : mSelectedIndex.keySet()) {
// 如果该位置对应的项是被选中的
if (mSelectedIndex.get(position) == true) {
// 获取对应位置的数据项（游标形式）
Cursor c = (Cursor) getItem(position);
if (c != null) {
// 创建一个AppWidgetAttribute对象，用于存储小部件相关属性
AppWidgetAttribute widget = new AppWidgetAttribute();
// 根据游标创建一个NoteItemData对象，用于获取小部件相关的数据
NoteItemData item = new NoteItemData(mContext, c);
// 设置小部件的ID属性
widget.widgetId = item.getWidgetId();
// 设置小部件的类型属性
widget.widgetType = item.getWidgetType();
// 将封装好的小部件属性对象添加到HashSet中
itemSet.add(widget);
/**
* Don't close cursor here, only the adapter could close it
* 此处不要关闭游标，只有适配器本身才能关闭它，避免外部错误关闭游标导致问题
*/
} else {
// 如果游标为空，记录错误日志信息，表示游标无效
Log.e(TAG, "Invalid cursor");
return null;
}
@ -128,13 +172,18 @@ public class NotesListAdapter extends CursorAdapter {
return itemSet;
}
// 获取已选中项的数量
public int getSelectedCount() {
// 获取mSelectedIndex中所有值（即每个位置对应的选中状态布尔值）的集合
Collection<Boolean> values = mSelectedIndex.values();
// 如果集合为空（可能没有任何选中记录等情况），返回0
if (null == values) {
return 0;
}
// 获取集合的迭代器，用于遍历集合中的元素（布尔值）
Iterator<Boolean> iter = values.iterator();
int count = 0;
// 遍历集合中的每个布尔值元素，如果为true，表示该项被选中，数量加1
while (iter.hasNext()) {
if (true == iter.next()) {
count++;
@ -143,30 +192,39 @@ public class NotesListAdapter extends CursorAdapter {
return count;
}
// 判断是否所有项都被选中
public boolean isAllSelected() {
// 获取已选中项的数量
int checkedCount = getSelectedCount();
// 如果选中数量不为0（有选中项）且选中数量等于笔记的总数量，说明所有项都被选中了，返回true，否则返回false
return (checkedCount != 0 && checkedCount == mNotesCount);
}
// 判断指定位置的项是否被选中
public boolean isSelectedItem(final int position) {
// 如果该位置对应的选中状态记录为null（可能还未设置等情况），则返回false，表示未选中
if (null == mSelectedIndex.get(position)) {
return false;
}
// 返回该位置对应的实际选中状态（布尔值）
return mSelectedIndex.get(position);
}
// 当内容发生改变时调用的方法，这里调用了calcNotesCount方法来重新计算笔记数量
@Override
protected void onContentChanged() {
super.onContentChanged();
calcNotesCount();
}
// 当游标发生改变时调用的方法，同样调用calcNotesCount方法来重新计算笔记数量
@Override
public void changeCursor(Cursor cursor) {
super.changeCursor(cursor);
calcNotesCount();
}
// 计算笔记的数量，遍历数据集，统计符合条件（笔记类型为Notes.TYPE_NOTE）的项的数量
private void calcNotesCount() {
mNotesCount = 0;
for (int i = 0; i < getCount(); i++) {

50
src/Notes-master/src/net/micode/notes/ui/NotesListItem.java
Unescape View File

@ -37,85 +37,133 @@ public class NotesListItem extends LinearLayout {
private TextView mCallName;
private NoteItemData mItemData;
private CheckBox mCheckBox;
// NotesListItem类的构造函数，用于初始化该列表项相关的视图组件
public NotesListItem(Context context) {
// 调用父类（应该是某个视图类的构造函数，传递上下文对象进行初始化）
super(context);
// 从给定的布局资源（R.layout.note_item）中加载视图层次结构，并将其填充到当前的视图（this）中
inflate(context, R.layout.note_item, this);
// 通过ID查找并获取布局中的ImageView组件，用于显示提醒图标等，ID为R.id.iv_alert_icon
mAlert = (ImageView) findViewById(R.id.iv_alert_icon);
// 通过ID查找并获取布局中的TextView组件，用于显示标题内容，ID为R.id.tv_title
mTitle = (TextView) findViewById(R.id.tv_title);
// 通过ID查找并获取布局中的TextView组件，用于显示时间相关信息，ID为R.id.tv_time
mTime = (TextView) findViewById(R.id.tv_time);
// 通过ID查找并获取布局中的TextView组件，用于显示呼叫名称相关信息，ID为R.id.tv_name
mCallName = (TextView) findViewById(R.id.tv_name);
// 通过安卓系统内置的ID（android.R.id.checkbox）查找并获取布局中的CheckBox组件，用于表示该项是否被选中
mCheckBox = (CheckBox) findViewById(android.R.id.checkbox);
}
// 用于将数据绑定到该列表项视图上，根据不同的数据情况设置视图的显示内容和状态
public void bind(Context context, NoteItemData data, boolean choiceMode, boolean checked) {
// 如果处于选择模式（choiceMode为true）并且数据对应的类型是笔记类型（Notes.TYPE_NOTE）
if (choiceMode && data.getType() == Notes.TYPE_NOTE) {
// 设置复选框（CheckBox）可见，用于在选择模式下让用户选择该项
mCheckBox.setVisibility(View.VISIBLE);
// 根据传入的checked参数设置复选框的选中状态
mCheckBox.setChecked(checked);
} else {
// 如果不满足上述条件，隐藏复选框，表示不在选择模式或者不是笔记类型的项不需要显示复选框
mCheckBox.setVisibility(View.GONE);
}
// 将传入的数据对象保存到成员变量mItemData中，方便后续获取和使用
mItemData = data;
// 如果数据的ID等于Notes.ID_CALL_RECORD_FOLDER（可能是特定的文件夹类型的标识）
if (data.getId() == Notes.ID_CALL_RECORD_FOLDER) {
// 隐藏呼叫名称相关的TextView，因为可能不需要显示
mCallName.setVisibility(View.GONE);
// 显示提醒图标相关的ImageView，可能用于提示特殊情况
mAlert.setVisibility(View.VISIBLE);
// 设置标题的文本外观样式，采用R.style.TextAppearancePrimaryItem样式
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
// 设置标题的文本内容，由固定字符串（通话记录文件夹名称）和格式化后的包含文件数量的字符串拼接而成，文件数量从数据对象中获取
mTitle.setText(context.getString(R.string.call_record_folder_name)
+ context.getString(R.string.format_folder_files_count, data.getNotesCount()));
// 设置提醒图标对应的图片资源，这里使用R.drawable.call_record图片资源
mAlert.setImageResource(R.drawable.call_record);
} else if (data.getParentId() == Notes.ID_CALL_RECORD_FOLDER) {
// 如果数据的父ID等于Notes.ID_CALL_RECORD_FOLDER，表示该项属于通话记录文件夹下的子项
// 显示呼叫名称相关的TextView，并设置其文本内容为从数据对象中获取的呼叫名称
mCallName.setVisibility(View.VISIBLE);
mCallName.setText(data.getCallName());
// 设置标题的文本外观样式，采用R.style.TextAppearanceSecondaryItem样式
mTitle.setTextAppearance(context,R.style.TextAppearanceSecondaryItem);
// 设置标题的文本内容，通过DataUtils工具类对数据中的摘要（snippet）进行格式化后设置
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
// 如果数据有提醒（通过hasAlert方法判断），则设置提醒图标相关的ImageView可见，并设置对应的图片资源为R.drawable.clock
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock);
mAlert.setVisibility(View.VISIBLE);
} else {
// 如果没有提醒，则隐藏提醒图标
mAlert.setVisibility(View.GONE);
}
} else {
// 如果不属于上述两种情况（既不是通话记录文件夹本身，也不是其直接子项）
// 隐藏呼叫名称相关的TextView，因为不需要显示
mCallName.setVisibility(View.GONE);
// 设置标题的文本外观样式，采用R.style.TextAppearancePrimaryItem样式
mTitle.setTextAppearance(context, R.style.TextAppearancePrimaryItem);
// 如果数据的类型是文件夹类型（Notes.TYPE_FOLDER）
if (data.getType() == Notes.TYPE_FOLDER) {
// 设置标题的文本内容，由数据中的摘要（snippet）和格式化后的包含文件数量的字符串拼接而成，文件数量从数据对象中获取
mTitle.setText(data.getSnippet()
+ context.getString(R.string.format_folder_files_count,
data.getNotesCount()));
// 隐藏提醒图标相关的ImageView，文件夹类型可能不需要显示提醒图标
mAlert.setVisibility(View.GONE);
} else {
// 如果是笔记类型（非文件夹类型）
// 设置标题的文本内容，通过DataUtils工具类对数据中的摘要（snippet）进行格式化后设置
mTitle.setText(DataUtils.getFormattedSnippet(data.getSnippet()));
// 如果数据有提醒（通过hasAlert方法判断），则设置提醒图标相关的ImageView可见，并设置对应的图片资源为R.drawable.clock
if (data.hasAlert()) {
mAlert.setImageResource(R.drawable.clock);
mAlert.setVisibility(View.VISIBLE);
} else {
// 如果没有提醒，则隐藏提醒图标
mAlert.setVisibility(View.GONE);
}
}
}
// 设置时间相关的TextView的文本内容，通过DateUtils工具类根据数据中的修改日期获取相对时间格式的字符串进行设置
mTime.setText(DateUtils.getRelativeTimeSpanString(data.getModifiedDate()));
// 调用setBackground方法，根据数据情况设置该项的背景样式
setBackground(data);
}
// 根据传入的NoteItemData数据对象设置该项的背景资源，根据不同的条件选择不同的背景资源进行设置
private void setBackground(NoteItemData data) {
// 获取数据中对应的背景颜色ID
int id = data.getBgColorId();
// 如果数据的类型是笔记类型（Notes.TYPE_NOTE）
if (data.getType() == Notes.TYPE_NOTE) {
// 如果该项是单独的（通过isSingle方法判断）或者只有一个后续文件夹（通过isOneFollowingFolder方法判断）
if (data.isSingle() || data.isOneFollowingFolder()) {
// 设置该项的背景资源，通过NoteItemBgResources工具类根据背景颜色ID获取对应的单个笔记背景资源进行设置
if (data.isSingle() || data.isOneFollowingFolder()) {
setBackgroundResource(NoteItemBgResources.getNoteBgSingleRes(id));
} else if (data.isLast()) {
// 如果该项是最后一个（通过isLast方法判断），则设置该项的背景资源，通过NoteItemBgResources工具类根据背景颜色ID获取对应的最后一个笔记背景资源进行设置
setBackgroundResource(NoteItemBgResources.getNoteBgLastRes(id));
} else if (data.isFirst() || data.isMultiFollowingFolder()) {
// 如果该项是第一个（通过isFirst方法判断）或者有多个后续文件夹（通过isMultiFollowingFolder方法判断），则设置该项的背景资源，通过NoteItemBgResources工具类根据背景颜色ID获取对应的第一个笔记背景资源进行设置
setBackgroundResource(NoteItemBgResources.getNoteBgFirstRes(id));
} else {
// 如果不符合上述任何特殊情况，则设置该项的背景资源，通过NoteItemBgResources工具类根据背景颜色ID获取对应的普通笔记背景资源进行设置
setBackgroundResource(NoteItemBgResources.getNoteBgNormalRes(id));
}
// 如果数据的类型不是笔记类型（即文件夹类型等情况），则设置该项的背景资源，通过NoteItemBgResources工具类获取对应的文件夹背景资源进行设置
} else {
setBackgroundResource(NoteItemBgResources.getFolderBgRes());
}
}
// 获取当前列表项绑定的数据对象，用于在外部获取该列表项对应的数据信息
public NoteItemData getItemData() {
return mItemData;
}

143
src/Notes-master/src/net/micode/notes/ui/NotesPreferenceActivity.java
Unescape View File

@ -47,64 +47,86 @@ import net.micode.notes.data.Notes;
import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.gtask.remote.GTaskSyncService;
// NotesPreferenceActivity类继承自PreferenceActivity，用于管理应用中与偏好设置相关的功能和界面展示
public class NotesPreferenceActivity extends PreferenceActivity {
public static final String PREFERENCE_NAME = "notes_preferences";
// 定义偏好设置文件的名称，用于存储和获取应用相关的偏好设置数据
public static final String PREFERENCE_NAME = "notes_preferences";
// 偏好设置中用于存储同步账户名称的键
public static final String PREFERENCE_SYNC_ACCOUNT_NAME = "pref_key_account_name";
// 偏好设置中用于存储上次同步时间的键
public static final String PREFERENCE_LAST_SYNC_TIME = "pref_last_sync_time";
// 偏好设置中用于设置背景颜色相关的键（可能与随机背景颜色显示等功能有关）
public static final String PREFERENCE_SET_BG_COLOR_KEY = "pref_key_bg_random_appear";
// 偏好设置中与同步账户相关的另一个键（可能用于区分不同的同步账户相关设置项等）
private static final String PREFERENCE_SYNC_ACCOUNT_KEY = "pref_sync_account_key";
// 用于过滤账户相关权限等的键（可能在获取账户信息等操作中使用）
private static final String AUTHORITIES_FILTER_KEY = "authorities";
// 用于管理偏好设置中账户相关分类的视图组件（可能在界面上对账户相关的偏好设置项进行分组展示等）
private PreferenceCategory mAccountCategory;
// 广播接收器，用于接收与同步任务相关的广播消息，以便更新界面等操作
private GTaskReceiver mReceiver;
// 用于记录原始的账户列表（可能用于对比账户变化情况等）
private Account[] mOriAccounts;
// 标记是否添加了新账户，用于后续相关逻辑判断
private boolean mHasAddedAccount;
// 在Activity创建时调用的方法，进行一些初始化操作
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
// 设置ActionBar上的返回按钮可用，使用应用图标来实现导航返回功能（通常是返回上级界面）
/* using the app icon for navigation */
getActionBar().setDisplayHomeAsUpEnabled(true);
// 从指定的XML资源文件（R.xml.preferences）加载偏好设置界面的布局和相关设置项
addPreferencesFromResource(R.xml.preferences);
// 通过键（PREFERENCE_SYNC_ACCOUNT_KEY）查找并获取对应的PreferenceCategory组件，用于后续操作账户相关的偏好设置项
mAccountCategory = (PreferenceCategory) findPreference(PREFERENCE_SYNC_ACCOUNT_KEY);
// 创建一个GTaskReceiver实例，用于接收同步相关广播
mReceiver = new GTaskReceiver();
// 创建一个IntentFilter，用于定义要接收的广播动作
IntentFilter filter = new IntentFilter();
// 添加要接收的广播动作，这里接收GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME对应的广播
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
// 注册广播接收器，使其能够接收符合条件的广播消息
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
registerReceiver(mReceiver, filter);
// 初始化为null，后续会根据实际情况获取账户信息进行赋值
mOriAccounts = null;
// 通过LayoutInflater加载一个自定义的头部视图（R.layout.settings_header），并添加到当前Activity的ListView中作为头部视
View header = LayoutInflater.from(this).inflate(R.layout.settings_header, null);
getListView().addHeaderView(header, null, true);
}
// 在Activity重新恢复可见时调用的方法（例如从其他Activity返回等情况），进行一些更新操作
@Override
protected void onResume() {
super.onResume();
// 如果添加了新账户（mHasAddedAccount为true），则进行以下操作
// need to set sync account automatically if user has added a new
// account
if (mHasAddedAccount) {
// 获取当前的谷歌账户列表
Account[] accounts = getGoogleAccounts();
// 如果原始账户列表不为null且当前账户数量大于原始账户数量，说明可能添加了新账户
if (mOriAccounts != null && accounts.length > mOriAccounts.length) {
// 遍历新的账户列表
for (Account accountNew : accounts) {
// 标记是否找到匹配的旧账户，初始化为false
boolean found = false;
// 遍历原始账户列表，对比账户名称，查找是否已存在相同名称的账户
for (Account accountOld : mOriAccounts) {
if (TextUtils.equals(accountOld.name, accountNew.name)) {
found = true;
break;
}
}
// 如果没有找到匹配的旧账户，说明是新添加的账户，则设置为同步账户，并跳出循环
if (!found) {
setSyncAccount(accountNew.name);
break;
@ -113,36 +135,50 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
}
// 调用refreshUI方法，更新界面显示（加载账户偏好设置项、同步按钮等相关UI元素）
refreshUI();
}
// 在Activity销毁时调用的方法，进行一些清理操作，如注销广播接收器
@Override
protected void onDestroy() {
if (mReceiver != null) {
// 注销广播接收器，避免内存泄漏等问题
unregisterReceiver(mReceiver);
}
super.onDestroy();
}
// 加载账户偏好设置相关的视图组件和逻辑，例如添加账户相关的偏好设置项到界面上
private void loadAccountPreference() {
// 移除账户分类下的所有已有偏好设置项（可能是为了重新加载最新的设置项等情况）
mAccountCategory.removeAll();
// 创建一个新的Preference对象，用于表示账户相关的偏好设置项
Preference accountPref = new Preference(this);
// 获取当前设置的同步账户名称（如果有的话），作为默认账户名称
final String defaultAccount = getSyncAccountName(this);
// 设置偏好设置项的标题，从字符串资源（R.string.preferences_account_title）中获取
accountPref.setTitle(getString(R.string.preferences_account_title));
// 设置偏好设置项的摘要内容，从字符串资源（R.string.preferences_account_summary）中获取
accountPref.setSummary(getString(R.string.preferences_account_summary));
// 设置偏好设置项的点击监听器，当用户点击该设置项时执行以下逻辑
accountPref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
public boolean onPreferenceClick(Preference preference) {
// 如果同步服务没有正在同步（通过GTaskSyncService.isSyncing()判断）
if (!GTaskSyncService.isSyncing()) {
// 如果默认账户名称为空，说明是第一次设置账户，弹出选择账户的提示对话框
if (TextUtils.isEmpty(defaultAccount)) {
// the first time to set account
showSelectAccountAlertDialog();
} else {
// 如果已经设置过账户，弹出确认更改账户的提示对话框，提示用户相关风险
// if the account has already been set, we need to promp
// user about the risk
showChangeAccountConfirmAlertDialog();
}
} else {
// 如果正在同步，弹出提示Toast，告知用户不能更改账户
Toast.makeText(NotesPreferenceActivity.this,
R.string.preferences_toast_cannot_change_account, Toast.LENGTH_SHORT)
.show();
@ -151,85 +187,121 @@ public class NotesPreferenceActivity extends PreferenceActivity {
}
});
// 将创建好的账户偏好设置项添加到账户分类（mAccountCategory）中，以便在界面上显示
mAccountCategory.addPreference(accountPref);
}
// 加载同步按钮相关的逻辑和状态设置，包括按钮文本、点击事件以及同步状态显示等
private void loadSyncButton() {
// 通过ID查找并获取同步按钮（Button）组件，ID为R.id.preference_sync_button
Button syncButton = (Button) findViewById(R.id.preference_sync_button);
// 通过ID查找并获取显示上次同步时间的TextView组件，ID为R.id.prefenerece_sync_status_textview
TextView lastSyncTimeView = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
// set button state
// 根据同步服务是否正在同步来设置同步按钮的文本和点击事件
if (GTaskSyncService.isSyncing()) {
// 如果正在同步，设置按钮文本为取消同步相关的文本（从字符串资源中获取）
syncButton.setText(getString(R.string.preferences_button_sync_cancel));
// 设置按钮的点击事件，点击时调用GTaskSyncService.cancelSync方法取消同步
syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
GTaskSyncService.cancelSync(NotesPreferenceActivity.this);
}
});
} else {
// 如果没有正在同步，设置按钮文本为立即同步相关的文本（从字符串资源中获取）
syncButton.setText(getString(R.string.preferences_button_sync_immediately));
// 设置按钮的点击事件，点击时调用GTaskSyncService.startSync方法启动同步
syncButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
GTaskSyncService.startSync(NotesPreferenceActivity.this);
}
});
}
// 根据是否设置了同步账户来启用或禁用同步按钮，如果同步账户名称为空则禁用按钮
syncButton.setEnabled(!TextUtils.isEmpty(getSyncAccountName(this)));
// 根据同步服务状态设置上次同步时间的显示内容和可见性
// set last sync time
if (GTaskSyncService.isSyncing()) {
// 如果正在同步，设置显示上次同步时间的TextView的文本为同步进度相关的字符串（从同步服务获取），并设置为可见
lastSyncTimeView.setText(GTaskSyncService.getProgressString());
lastSyncTimeView.setVisibility(View.VISIBLE);
} else {
// 如果没有正在同步，获取上次同步时间（通过getLastSyncTime方法）
long lastSyncTime = getLastSyncTime(this);
if (lastSyncTime != 0) {
// 如果上次同步时间不为0，格式化并设置显示上次同步时间的TextView的文本内容，然后设置为可见
lastSyncTimeView.setText(getString(R.string.preferences_last_sync_time,
DateFormat.format(getString(R.string.preferences_last_sync_time_format),
lastSyncTime)));
lastSyncTimeView.setVisibility(View.VISIBLE);
} else {
// 如果上次同步时间为0，隐藏该TextView组件
lastSyncTimeView.setVisibility(View.GONE);
}
}
}
// 用于更新整个界面的显示，调用加载账户偏好设置和同步按钮相关的方法
private void refreshUI() {
loadAccountPreference();
loadSyncButton();
}
// 弹出选择账户的提示对话框，用于让用户选择要设置的同步账户
private void showSelectAccountAlertDialog() {
// 创建一个AlertDialog.Builder对象，用于构建提示对话框
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
// 通过LayoutInflater加载一个自定义的标题视图（R.layout.account_dialog_title），用于设置对话框的标题部分
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
// 通过ID查找并获取标题TextView组件，设置其文本内容为选择账户相关的标题文本（从字符串资源中获取）
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_select_account_title));
// 通过ID查找并获取副标题TextView组件，设置其文本内容为选择账户相关的提示文本（从字符串资源中获取）
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_select_account_tips));
// 设置对话框的自定义标题视图
dialogBuilder.setCustomTitle(titleView);
// 设置对话框的确定按钮（这里先设置为null，后续可能根据具体需求再处理）
dialogBuilder.setPositiveButton(null, null);
// 获取当前的谷歌账户列表
Account[] accounts = getGoogleAccounts();
// 获取当前设置的同步账户名称（如果有的话）
String defAccount = getSyncAccountName(this);
// 将当前账户列表赋值给mOriAccounts，用于后续对比等操作
mOriAccounts = accounts;
// 标记还没有添加新账户
mHasAddedAccount = false;
// 如果账户列表长度大于0，说明有可用账户，进行以下操作
if (accounts.length > 0) {
// 创建一个字符序列数组，用于存储账户名称，长度与账户列表长度相同
CharSequence[] items = new CharSequence[accounts.length];
// 将items数组赋值给itemMapping，方便后续在点击事件中使用（这里可能是为了保持引用一致等原因）
final CharSequence[] itemMapping = items;
// 标记默认选中的账户索引，初始化为 -1，表示没有默认选中项
final CharSequence[] itemMapping = items;
int checkedItem = -1;
int index = 0;
// 遍历账户列表，设置每个账户名称到items数组中，并查找默认选中的账户（与当前同步账户名称相同的账户）
for (Account account : accounts) {
if (TextUtils.equals(account.name, defAccount)) {
checkedItem = index;
}
items[index++] = account.name;
}
// 设置对话框的单选列表项，传入账户名称数组、默认选中索引以及点击事件监听器
dialogBuilder.setSingleChoiceItems(items, checkedItem,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
// 当用户点击某个账户项时，设置选择的账户为同步账户，关闭对话框，并更新界面显示
setSyncAccount(itemMapping[which].toString());
dialog.dismiss();
refreshUI();
@ -237,10 +309,13 @@ public class NotesPreferenceActivity extends PreferenceActivity {
});
}
// 通过LayoutInflater加载一个添加账户的视图（R.layout.add_account_text），并添加到对话框中
View addAccountView = LayoutInflater.from(this).inflate(R.layout.add_account_text, null);
dialogBuilder.setView(addAccountView);
// 创建并显示对话框
final AlertDialog dialog = dialogBuilder.show();
// 设置添加账户视图的点击事件，当用户点击时，标记添加了新账户，启动添加账户的系统设置界面，并关闭当前对话框
addAccountView.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
mHasAddedAccount = true;
@ -254,98 +329,138 @@ public class NotesPreferenceActivity extends PreferenceActivity {
});
}
// 弹出确认更改账户的提示对话框，用于提示用户更改账户的相关操作和风险等信息
private void showChangeAccountConfirmAlertDialog() {
// 创建一个AlertDialog.Builder对象，用于构建提示对话框
AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(this);
// 通过LayoutInflater加载一个自定义的标题视图（R.layout.account_dialog_title），用于设置对话框的标题部分
View titleView = LayoutInflater.from(this).inflate(R.layout.account_dialog_title, null);
// 通过ID查找并获取标题TextView组件，设置其文本内容为更改账户相关的标题文本（包含当前同步账户名称，从字符串资源中获取并格式化）
TextView titleTextView = (TextView) titleView.findViewById(R.id.account_dialog_title);
titleTextView.setText(getString(R.string.preferences_dialog_change_account_title,
getSyncAccountName(this)));
// 通过ID查找并获取副标题TextView组件，设置其文本内容为更改账户相关的警告提示文本（从字符串资源中获取）
TextView subtitleTextView = (TextView) titleView.findViewById(R.id.account_dialog_subtitle);
subtitleTextView.setText(getString(R.string.preferences_dialog_change_account_warn_msg));
// 设置对话框的自定义标题视图
dialogBuilder.setCustomTitle(titleView);
// 创建一个字符序列数组，包含更改账户、移除账户、取消等菜单项文本（从字符串资源中获取）
CharSequence[] menuItemArray = new CharSequence[] {
getString(R.string.preferences_menu_change_account),
getString(R.string.preferences_menu_remove_account),
getString(R.string.preferences_menu_cancel)
};
// 设置对话框的菜单项和点击事件监听器，根据用户点击的不同菜单项执行相应操作
dialogBuilder.setItems(menuItemArray, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
if (which == 0) {
// 如果点击的是更改账户菜单项，弹出选择账户的提示对话框
showSelectAccountAlertDialog();
} else if (which == 1) {
// 如果点击的是移除账户菜单项，调用removeSyncAccount方法移除同步账户，并更新界面显示
removeSyncAccount();
refreshUI();
}
}
});
// 显示对话框
dialogBuilder.show();
}
// 获取当前设备上的谷歌账户列表，通过AccountManager获取指定类型（"com.google"）的账户
private Account[] getGoogleAccounts() {
AccountManager accountManager = AccountManager.get(this);
return accountManager.getAccountsByType("com.google");
}
// 设置同步账户名称，将指定的账户名称保存到偏好设置中，并进行一些相关的清理和更新操作
private void setSyncAccount(String account) {
if (!getSyncAccountName(this).equals(account)) {
// 获取偏好设置对象，用于存储和读取应用的偏好设置数据
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
// 获取偏好设置的编辑器，用于修改偏好设置的值
SharedPreferences.Editor editor = settings.edit();
if (account != null) {
// 如果账户名称不为null，将账户名称保存到偏好设置中（键为PREFERENCE_SYNC_ACCOUNT_NAME）
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, account);
} else {
// 如果传入的账户名称为null，将同步账户名称设置为空字符串，存入偏好设置中
editor.putString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
// 提交对偏好设置的修改，使其生效
editor.commit();
// clean up last sync time
// 调用setLastSyncTime方法将上次同步时间设置为0，可能是为了在更改同步账户时重置同步相关的时间记录
setLastSyncTime(this, 0);
setLastSyncTime(this, 0);
// 清理本地与GTask相关的信息，通过开启一个新线程来执行更新操作
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
// 创建一个ContentValues对象，用于存储要更新的数据
ContentValues values = new ContentValues();
// 将NoteColumns.GTASK_ID对应的值设置为空字符串，可能是清除之前关联的GTask ID信息
values.put(NoteColumns.GTASK_ID, "");
// 将NoteColumns.SYNC_ID对应的值设置为0，可能是重置同步相关的ID等信息
values.put(NoteColumns.SYNC_ID, 0);
// 使用内容解析器（getContentResolver）更新Notes.CONTENT_NOTE_URI对应的内容，将上述设置的值进行更新，条件为null（可能是更新所有符合该URI的记录）
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
// 弹出一个Toast提示信息，告知用户成功设置账户，提示内容通过字符串资源格式化传入账户名称来生成
Toast.makeText(NotesPreferenceActivity.this,
getString(R.string.preferences_toast_success_set_accout, account),
Toast.LENGTH_SHORT).show();
}
}
// 移除同步账户相关的偏好设置信息以及清理本地与GTask相关的信息
private void removeSyncAccount() {
SharedPreferences settings = getSharedPreferences(PREFERENCE_NAME, Context.MODE_PRIVATE);
SharedPreferences settings = get
// 获取应用的共享偏好设置对象，用于操作偏好设置数据
SharedPreferences.(PREFERENCE_NAME, Context.MODE_PRIVATE);
// 获取偏好设置的编辑器，用于修改偏好设置中的值
SharedPreferences.Editor editor = settings.edit();
// 如果偏好设置中包含同步账户名称这个键（说明之前有设置过），则移除该键值对
if (settings.contains(PREFERENCE_SYNC_ACCOUNT_NAME)) {
editor.remove(PREFERENCE_SYNC_ACCOUNT_NAME);
}
// 如果偏好设置中包含上次同步时间这个键（说明之前有记录），则移除该键值对
if (settings.contains(PREFERENCE_LAST_SYNC_TIME)) {
editor.remove(PREFERENCE_LAST_SYNC_TIME);
}
// 提交对偏好设置的修改，使其生效
editor.commit();
// 清理本地与GTask相关的信息，通过开启一个新线程来执行更新操作
// clean up local gtask related info
new Thread(new Runnable() {
public void run() {
// 创建一个ContentValues对象，用于存储要更新的数据
ContentValues values = new ContentValues();
// 将NoteColumns.GTASK_ID对应的值设置为空字符串，可能是清除之前关联的GTask ID信息
values.put(NoteColumns.GTASK_ID, "");
// 将NoteColumns.SYNC_ID对应的值设置为0，可能是重置同步相关的ID等信息
values.put(NoteColumns.SYNC_ID, 0);
// 使用内容解析器（getContentResolver）更新Notes.CONTENT_NOTE_URI对应的内容，将上述设置的值进行更新，条件为null（可能是更新所有符合该URI的记录）
getContentResolver().update(Notes.CONTENT_NOTE_URI, values, null, null);
}
}).start();
}
// 获取当前设置的同步账户名称，从应用的共享偏好设置中读取对应键（PREFERENCE_SYNC_ACCOUNT_NAME）的值，如果不存在则返回空字符串
public static String getSyncAccountName(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getString(PREFERENCE_SYNC_ACCOUNT_NAME, "");
}
// 设置上次同步时间，将指定的时间值保存到应用的共享偏好设置中
public static void setLastSyncTime(Context context, long time) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
@ -354,18 +469,24 @@ public class NotesPreferenceActivity extends PreferenceActivity {
editor.commit();
}
// 获取上次同步时间，从应用的共享偏好设置中读取对应键（PREFERENCE_LAST_SYNC_TIME）的值，如果不存在则返回0
public static long getLastSyncTime(Context context) {
SharedPreferences settings = context.getSharedPreferences(PREFERENCE_NAME,
Context.MODE_PRIVATE);
return settings.getLong(PREFERENCE_LAST_SYNC_TIME, 0);
}
// 内部类，继承自BroadcastReceiver，用于接收与GTask同步服务相关的广播消息，并进行相应的界面更新操作
private class GTaskReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
// 接收到广播后，调用refreshUI方法更新界面显示，例如加载账户偏好设置、同步按钮状态等
refreshUI();
// 判断广播中携带的是否正在同步的额外信息（键为GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING）是否为true，如果是则进行以下操作
if (intent.getBooleanExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_IS_SYNCING, false)) {
// 通过ID查找并获取用于显示同步状态的TextView组件，ID为R.id.prefenerece_sync_status_textview
TextView syncStatus = (TextView) findViewById(R.id.prefenerece_sync_status_textview);
syncStatus.setText(intent
.getStringExtra(GTaskSyncService.GTASK_SERVICE_BROADCAST_PROGRESS_MSG));

31
src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider.java
Unescape View File

@ -31,78 +31,100 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.tool.ResourceParser;
import net.micode.notes.ui.NoteEditActivity;
import net.micode.notes.ui.NotesListActivity;
// 定义一个抽象类NoteWidgetProvider，它继承自AppWidgetProvider，用于处理桌面小部件相关逻辑
public abstract class NoteWidgetProvider extends AppWidgetProvider {
// 定义一个字符串数组PROJECTION，用于查询数据库时指定需要获取的列
public static final String [] PROJECTION = new String [] {
NoteColumns.ID,
NoteColumns.BG_COLOR_ID,
NoteColumns.SNIPPET
};
// 定义常量，分别对应PROJECTION数组中的列索引，方便后续代码引用
public static final int COLUMN_ID = 0;
public static final int COLUMN_BG_COLOR_ID = 1;
public static final int COLUMN_SNIPPET = 2;
// 定义一个日志标签，用于在日志输出中标识该类
private static final String TAG = "NoteWidgetProvider";
// 重写AppWidgetProvider的onDeleted方法，当桌面小部件被删除时调用
@Override
public void onDeleted(Context context, int[] appWidgetIds) {
// 创建一个ContentValues对象，用于更新数据库中的值
ContentValues values = new ContentValues();
// 将Widget相关的ID设置为无效值
values.put(NoteColumns.WIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID);
for (int i = 0; i < appWidgetIds.length; i++) {
// 使用ContentResolver更新数据库，将对应的Widget ID标记为无效
context.getContentResolver().update(Notes.CONTENT_NOTE_URI,
values,
NoteColumns.WIDGET_ID + "=?",
new String[] { String.valueOf(appWidgetIds[i])});
}
}
// 获取与指定桌面小部件相关的笔记信息的Cursor
private Cursor getNoteWidgetInfo(Context context, int widgetId) {
// 使用ContentResolver查询数据库，获取符合条件的笔记数据
return context.getContentResolver().query(Notes.CONTENT_NOTE_URI,
PROJECTION,
NoteColumns.WIDGET_ID + "=? AND " + NoteColumns.PARENT_ID + "<>?",
new String[] { String.valueOf(widgetId), String.valueOf(Notes.ID_TRASH_FOLER) },
null);
}
// 更新桌面小部件的公共方法，调用了另一个重载的update方法
protected void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
update(context, appWidgetManager, appWidgetIds, false);
}
// 实际执行桌面小部件更新的私有方法
private void update(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds,
boolean privacyMode) {
for (int i = 0; i < appWidgetIds.length; i++) {
// 检查小部件ID是否有效
if (appWidgetIds[i] != AppWidgetManager.INVALID_APPWIDGET_ID) {
// 获取默认的背景ID
int bgId = ResourceParser.getDefaultBgId(context);
String snippet = "";
// 创建一个启动NoteEditActivity的Intent
Intent intent = new Intent(context, NoteEditActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
// 将小部件ID和小部件类型作为额外数据放入Intent
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_ID, appWidgetIds[i]);
intent.putExtra(Notes.INTENT_EXTRA_WIDGET_TYPE, getWidgetType());
// 获取与该小部件相关的笔记信息
Cursor c = getNoteWidgetInfo(context, appWidgetIds[i]);
if (c != null && c.moveToFirst()) {
// 检查是否存在多个对应同一小部件ID的消息
if (c.getCount() > 1) {
Log.e(TAG, "Multiple message with same widget id:" + appWidgetIds[i]);
c.close();
return;
}
// 提取笔记片段和背景ID，并设置Intent的相关额外数据
snippet = c.getString(COLUMN_SNIPPET);
bgId = c.getInt(COLUMN_BG_COLOR_ID);
intent.putExtra(Intent.EXTRA_UID, c.getLong(COLUMN_ID));
intent.setAction(Intent.ACTION_VIEW);
} else {
// 如果没有相关笔记，设置默认的提示文本，并设置Intent的操作类型
snippet = context.getResources().getString(R.string.widget_havenot_content);
intent.setAction(Intent.ACTION_INSERT_OR_EDIT);
}
// 关闭Cursor，释放资源
if (c != null) {
c.close();
}
// 创建RemoteViews对象，用于更新小部件的UI
RemoteViews rv = new RemoteViews(context.getPackageName(), getLayoutId());
// 设置小部件背景图片资源
rv.setImageViewResource(R.id.widget_bg_image, getBgResourceId(bgId));
intent.putExtra(Notes.INTENT_EXTRA_BACKGROUND_ID, bgId);
// 创建PendingIntent，根据隐私模式设置不同的行为
/**
* Generate the pending intent to start host for the widget
*/
@ -118,15 +140,20 @@ public abstract class NoteWidgetProvider extends AppWidgetProvider {
PendingIntent.FLAG_UPDATE_CURRENT);
}
// 为小部件文本视图设置点击事件的PendingIntent
rv.setOnClickPendingIntent(R.id.widget_text, pendingIntent);
// 更新桌面小部件
appWidgetManager.updateAppWidget(appWidgetIds[i], rv);
}
}
}
// 抽象方法，用于获取指定背景ID对应的背景资源ID，由子类实现
protected abstract int getBgResourceId(int bgId);
// 抽象方法，用于获取小部件的布局资源ID，由子类实现
protected abstract int getLayoutId();
// 抽象方法，用于获取小部件的类型，由子类实现
protected abstract int getWidgetType();
}

18
src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_2x.java
Unescape View File

@ -15,31 +15,41 @@
*/
package net.micode.notes.widget;
// 导入相关的Android系统类，用于处理桌面小部件相关功能
import android.appwidget.AppWidgetManager;
// 导入Android上下文类，用于获取应用资源、系统服务等
import android.content.Context;
// 导入项目自定义的资源类R，用于访问布局、图片等资源
import net.micode.notes.R;
// 导入项目自定义的数据类Notes，可能包含和笔记相关的数据结构与常量
import net.micode.notes.data.Notes;
// 导入项目自定义的工具类ResourceParser，用于解析资源相关内容
import net.micode.notes.tool.ResourceParser;
// NoteWidgetProvider_2x类继承自NoteWidgetProvider类，大概率是处理特定尺寸（2x）的桌面小部件逻辑
public class NoteWidgetProvider_2x extends NoteWidgetProvider {
// 重写父类的onUpdate方法，当桌面小部件需要更新时会触发此方法
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
// 调用父类的update方法，执行通用的更新逻辑，具体更新内容由父类实现
super.update(context, appWidgetManager, appWidgetIds);
}
// 获取当前桌面小部件对应的布局资源ID
@Override
protected int getLayoutId() {
// 返回2x尺寸桌面小部件对应的布局资源ID
return R.layout.widget_2x;
}
// 根据传入的背景ID，获取对应的2x尺寸桌面小部件的背景资源ID
@Override
protected int getBgResourceId(int bgId) {
// 通过ResourceParser工具类中的WidgetBgResources静态内部类获取对应的背景资源
return ResourceParser.WidgetBgResources.getWidget2xBgResource(bgId);
}
// 获取当前桌面小部件的类型，这里返回的是2x类型桌面小部件的标识
@Override
protected int getWidgetType() {
return Notes.TYPE_WIDGET_2X;

14
src/Notes-master/src/net/micode/notes/widget/NoteWidgetProvider_4x.java
Unescape View File

@ -23,22 +23,26 @@ import net.micode.notes.R;
import net.micode.notes.data.Notes;
import net.micode.notes.tool.ResourceParser;
// NoteWidgetProvider_4x类，它继承自NoteWidgetProvider
public class NoteWidgetProvider_4x extends NoteWidgetProvider {
@Override
// 当App Widget需要更新时会调用此方法
@Override
public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds) {
// 调用父类的update方法来执行更新操作
super.update(context, appWidgetManager, appWidgetIds);
}
// 获取此App Widget对应的布局资源ID
protected int getLayoutId() {
// 返回对应的4x尺寸的布局资源ID
return R.layout.widget_4x;
}
// 根据给定的背景ID，获取对应的4x尺寸的背景资源ID
@Override
protected int getBgResourceId(int bgId) {
// 通过ResourceParser工具类获取4x尺寸的Widget背景资源
return ResourceParser.WidgetBgResources.getWidget4xBgResource(bgId);
}
// 获取此Widget的类型，这里返回4x类型的Widget标识
@Override
protected int getWidgetType() {
return Notes.TYPE_WIDGET_4X;

Write Preview
Loading…
Cancel
Save