ptgkr64sc
/
notes
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ptgkr64sc:master
Branches Tags
ptgkr64sc:master
ptgkr64sc:zengweiran_branch
ptgkr64sc:ranhao_branch
ptgkr64sc:develop
..
compare: ptgkr64sc:ranhao_branch
Branches Tags
ptgkr64sc:master
ptgkr64sc:zengweiran_branch
ptgkr64sc:ranhao_branch
ptgkr64sc:develop

No commits in common. 'master' and 'ranhao_branch' have entirely different histories.
master ... ranhao_bra

22 changed files with 115 additions and 1627 deletions
Show Stats

BIN
doc/小米便签开源代码泛读报告.docx
View File

Binary file not shown.

BIN
doc/开源软件的质量分析报告.docx
View File

Binary file not shown.

3
src/notes/MainActivity.java
Unescape View File

@ -21,5 +21,4 @@ public class MainActivity extends AppCompatActivity {
return insets;
});
}
}
}

37
src/notes/data/Contact.java
Unescape View File

@ -25,17 +25,10 @@ import android.util.Log;
import java.util.HashMap;
/**
* 联系人信息获取类，通过联系人电话获取姓名
**/
public class Contact {
// 用于存储已查询过的电话号码和对应的联系人姓名
private static HashMap<String, String> sContactCache;
// 用于标识日志输出来源
private static final String TAG = "Contact";
// 查询条件字符串，用于通过电话号码从数据库中查询联系人信息
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 "
@ -43,52 +36,38 @@ public class Contact {
+ " FROM phone_lookup"
+ " WHERE min_match = '+')";
/**
* 根据电话号码获取联系人姓名
* @param context 应用上下文
* @param phoneNumber 电话号码
* @return 联系人姓名，如果未找到则返回null
*/
public static String getContact(Context context, String phoneNumber) {
if( sContactCache == null) {
if(sContactCache == null) {
sContactCache = new HashMap<String, String>();
}
// 先从缓存中查找，如果存在则直接返回，避免重复查询数据库
if(sContactCache.containsKey(phoneNumber)) {
return sContactCache.get(phoneNumber);
}
// 如果缓存中不存在，则执行数据库查询
String selection = CALLER_ID_SELECTION.replace("+",
PhoneNumberUtils.toCallerIDMinMatch(phoneNumber));
// 执行查询操作，返回一个游标对象
Cursor cursor = context.getContentResolver().query(
Data.CONTENT_URI, // 查询的URI
new String [] { Phone.DISPLAY_NAME }, // 返回的列名：联系人显示名称
selection, // 查询条件
new String[] { phoneNumber }, // 查询参数
null); // 排序方式
Data.CONTENT_URI,
new String [] { Phone.DISPLAY_NAME },
selection,
new String[] { phoneNumber },
null);
// 处理查询结果
if (cursor != null && cursor.moveToFirst()) {
try {
// 获取查询结果中的联系人姓名
String name = cursor.getString(0);
// 将结果存入缓存，供下次查询使用
sContactCache.put(phoneNumber, name);
return name;
} catch (IndexOutOfBoundsException e) {
// 处理索引越界异常，记录错误日志
Log.e(TAG, " Cursor get string error " + e.toString());
return null;
} finally {
// 确保游标被正确关闭，释放资源
cursor.close();
}
} else {
// 未查询到匹配的联系人，记录调试日志
Log.d(TAG, "No contact matched with number:" + phoneNumber);
return null;
}
}
}
}

115
src/notes/data/Notes.java
Unescape View File

@ -17,142 +17,50 @@
package net.micode.notes.data;
import android.net.Uri;
/**
* 小米便签数据层核心定义类，包含所有常量、URI、数据库列定义和内部类
* 该类是整个应用数据层的基础，被其他模块广泛引用
*/
public class Notes {
/**
* ContentProvider的权限名称，用于构建URI
*/
public static final String AUTHORITY = "micode_notes";
/**
* 日志标签，用于标识该类的日志输出
*/
public static final String TAG = "Notes";
/**
* 笔记类型：普通笔记
*/
public static final int TYPE_NOTE = 0;
/**
* 笔记类型：文件夹
*/
public static final int TYPE_FOLDER = 1;
/**
* 笔记类型：系统文件夹（如根目录、临时文件夹等）
*/
public static final int TYPE_SYSTEM = 2;
/**
* 系统文件夹ID定义
*/
/**
* 根文件夹ID，默认文件夹
* Following IDs are system folders' identifiers
* {@link Notes#ID_ROOT_FOLDER } is default folder
* {@link Notes#ID_TEMPARAY_FOLDER } is for notes belonging no folder
* {@link Notes#ID_CALL_RECORD_FOLDER} is to store call records
*/
public static final int ID_ROOT_FOLDER = 0;
/**
* 临时文件夹ID，用于存放无归属的笔记
*/
public static final int ID_TEMPARAY_FOLDER = -1;
/**
* 通话记录文件夹ID，用于存储通话记录笔记
*/
public static final int ID_CALL_RECORD_FOLDER = -2;
/**
* 回收站文件夹ID，用于存放已删除的笔记
*/
public static final int ID_TRASH_FOLER = -3;
/**
* Intent额外参数定义，用于组件间传递数据
*/
/**
* 提醒日期参数
*/
public static final String INTENT_EXTRA_ALERT_DATE = "net.micode.notes.alert_date";
/**
* 背景颜色ID参数
*/
public static final String INTENT_EXTRA_BACKGROUND_ID = "net.micode.notes.background_color_id";
/**
* 小部件ID参数
*/
public static final String INTENT_EXTRA_WIDGET_ID = "net.micode.notes.widget_id";
/**
* 小部件类型参数
*/
public static final String INTENT_EXTRA_WIDGET_TYPE = "net.micode.notes.widget_type";
/**
* 文件夹ID参数
*/
public static final String INTENT_EXTRA_FOLDER_ID = "net.micode.notes.folder_id";
/**
* 通话日期参数
*/
public static final String INTENT_EXTRA_CALL_DATE = "net.micode.notes.call_date";
/**
* 小部件类型定义
*/
/**
* 无效小部件类型
*/
public static final int TYPE_WIDGET_INVALIDE = -1;
/**
* 2x大小的小部件
*/
public static final int TYPE_WIDGET_2X = 0;
/**
* 4x大小的小部件
*/
public static final int TYPE_WIDGET_4X = 1;
/**
* 数据类型常量类，定义了不同类型笔记的MIME类型
*/
public static class DataConstants {
/**
* 普通文本笔记的MIME类型
*/
public static final String NOTE = TextNote.CONTENT_ITEM_TYPE;
/**
* 通话记录笔记的MIME类型
*/
public static final String CALL_NOTE = CallNote.CONTENT_ITEM_TYPE;
}
/**
* 用于查询所有笔记和文件夹的Uri
* Uri to query all notes and folders
*/
public static final Uri CONTENT_NOTE_URI = Uri.parse("content://" + AUTHORITY + "/note");
/**
* 用于查询数据的Uri
* Uri to query data
*/
public static final Uri CONTENT_DATA_URI = Uri.parse("content://" + AUTHORITY + "/data");
/**
* 笔记表列名定义接口
*/
public interface NoteColumns {
/**
* The unique ID for a row
@ -259,9 +167,6 @@ public class Notes {
public static final String VERSION = "version";
}
/**
* 数据表列名定义接口
*/
public interface DataColumns {
/**
* The unique ID for a row
@ -336,9 +241,6 @@ public class Notes {
public static final String DATA5 = "data5";
}
/**
* 文本笔记类，实现了DataColumns接口
*/
public static final class TextNote implements DataColumns {
/**
* Mode to indicate the text in check list mode or not
@ -354,10 +256,7 @@ public class Notes {
public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/text_note");
}
/**
* 通话记录笔记类，实现了DataColumns接口
*/
public static final class CallNote implements DataColumns {
/**
* Call date for this record

86
src/notes/data/NotesDatabaseHelper.java
Unescape View File

@ -27,44 +27,19 @@ import net.micode.notes.data.Notes.DataConstants;
import net.micode.notes.data.Notes.NoteColumns;
/**
* 数据库帮助类，负责数据库的创建、升级和管理
* 单例模式实现，提供了创建表、管理触发器和系统文件夹的功能
*/
public class NotesDatabaseHelper extends SQLiteOpenHelper {
/**
* 数据库名称
*/
private static final String DB_NAME = "note.db";
/**
* 数据库版本号
*/
private static final int DB_VERSION = 4;
/**
* 数据库表名定义接口
*/
public interface TABLE {
/**
* 笔记表名
*/
public static final String NOTE = "note";
/**
* 数据表名
*/
public static final String DATA = "data";
}
/**
* 日志标签
*/
private static final String TAG = "NotesDatabaseHelper";
/**
* 单例实例
*/
private static NotesDatabaseHelper mInstance;
private static final String CREATE_NOTE_TABLE_SQL =
@ -231,34 +206,18 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
" WHERE " + NoteColumns.PARENT_ID + "=old." + NoteColumns.ID + ";" +
" END";
/**
* 私有构造函数，防止外部实例化
* @param context 上下文
*/
public NotesDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
/**
* 创建笔记表
* @param db 数据库实例
*/
public void createNoteTable(SQLiteDatabase db) {
// 执行创建表SQL
db.execSQL(CREATE_NOTE_TABLE_SQL);
// 重新创建笔记表相关触发器
reCreateNoteTableTriggers(db);
// 创建系统文件夹
createSystemFolder(db);
Log.d(TAG, "note table has been created");
}
/**
* 重新创建笔记表相关触发器
* @param db 数据库实例
*/
private void reCreateNoteTableTriggers(SQLiteDatabase db) {
// 删除旧触发器（如果存在）
db.execSQL("DROP TRIGGER IF EXISTS increase_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_update");
db.execSQL("DROP TRIGGER IF EXISTS decrease_folder_count_on_delete");
@ -267,7 +226,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL("DROP TRIGGER IF EXISTS folder_delete_notes_on_delete");
db.execSQL("DROP TRIGGER IF EXISTS folder_move_notes_on_trash");
// 创建新触发器
db.execSQL(NOTE_INCREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_UPDATE_TRIGGER);
db.execSQL(NOTE_DECREASE_FOLDER_COUNT_ON_DELETE_TRIGGER);
@ -277,10 +235,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(FOLDER_MOVE_NOTES_ON_TRASH_TRIGGER);
}
/**
* 创建系统文件夹
* @param db 数据库实例
*/
private void createSystemFolder(SQLiteDatabase db) {
ContentValues values = new ContentValues();
@ -316,24 +270,13 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.insert(TABLE.NOTE, null, values);
}
/**
* 创建数据表
* @param db 数据库实例
*/
public void createDataTable(SQLiteDatabase db) {
// 执行创建表SQL
db.execSQL(CREATE_DATA_TABLE_SQL);
// 重新创建数据表相关触发器
reCreateDataTableTriggers(db);
// 创建note_id索引
db.execSQL(CREATE_DATA_NOTE_ID_INDEX_SQL);
Log.d(TAG, "data table has been created");
}
/**
* 重新创建数据表相关触发器
* @param db 数据库实例
*/
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");
@ -344,11 +287,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.execSQL(DATA_UPDATE_NOTE_CONTENT_ON_DELETE_TRIGGER);
}
/**
* 获取单例实例
* @param context 上下文
* @return 数据库帮助类实例
*/
static synchronized NotesDatabaseHelper getInstance(Context context) {
if (mInstance == null) {
mInstance = new NotesDatabaseHelper(context);
@ -356,24 +294,12 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
return mInstance;
}
/**
* 创建数据库
* @param db 数据库实例
*/
@Override
public void onCreate(SQLiteDatabase db) {
// 创建笔记表
createNoteTable(db);
// 创建数据表
createDataTable(db);
}
/**
* 升级数据库
* @param db 数据库实例
* @param oldVersion 旧版本号
* @param newVersion 新版本号
*/
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
boolean reCreateTriggers = false;
@ -407,10 +333,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
}
}
/**
* 升级到版本2
* @param db 数据库实例
*/
private void upgradeToV2(SQLiteDatabase db) {
db.execSQL("DROP TABLE IF EXISTS " + TABLE.NOTE);
db.execSQL("DROP TABLE IF EXISTS " + TABLE.DATA);
@ -418,10 +340,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
createDataTable(db);
}
/**
* 升级到版本3
* @param db 数据库实例
*/
private void upgradeToV3(SQLiteDatabase db) {
// drop unused triggers
db.execSQL("DROP TRIGGER IF EXISTS update_note_modified_date_on_insert");
@ -437,10 +355,6 @@ public class NotesDatabaseHelper extends SQLiteOpenHelper {
db.insert(TABLE.NOTE, null, values);
}
/**
* 升级到版本4
* @param db 数据库实例
*/
private void upgradeToV4(SQLiteDatabase db) {
db.execSQL("ALTER TABLE " + TABLE.NOTE + " ADD COLUMN " + NoteColumns.VERSION
+ " INTEGER NOT NULL DEFAULT 0");

111
src/notes/data/NotesProvider.java
Unescape View File

@ -35,74 +35,35 @@ import net.micode.notes.data.Notes.NoteColumns;
import net.micode.notes.data.NotesDatabaseHelper.TABLE;
/**
* 笔记内容提供者，实现了ContentProvider接口
* 提供对笔记和数据的CRUD操作，使用UriMatcher处理不同的URI请求
* 是应用与数据库之间的桥梁，被其他模块通过ContentResolver调用
*/
public class NotesProvider extends ContentProvider {
/**
* Uri匹配器，用于匹配不同的URI请求
*/
private static final UriMatcher mMatcher;
/**
* 数据库帮助类实例
*/
private NotesDatabaseHelper mHelper;
/**
* 日志标签
*/
private static final String TAG = "NotesProvider";
/**
* URI类型：所有笔记
*/
private static final int URI_NOTE = 1;
/**
* URI类型：单条笔记
*/
private static final int URI_NOTE_ITEM = 2;
/**
* URI类型：所有数据
*/
private static final int URI_DATA = 3;
/**
* URI类型：单条数据
*/
private static final int URI_DATA_ITEM = 4;
/**
* URI类型：搜索
*/
private static final int URI_SEARCH = 5;
/**
* URI类型：搜索建议
*/
private static final int URI_SEARCH_SUGGEST = 6;
/**
* 静态初始化块，初始化UriMatcher
*/
static {
mMatcher = new UriMatcher(UriMatcher.NO_MATCH);
// 添加URI匹配规则
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE); // content://micode_notes/note
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM); // content://micode_notes/note/1
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA); // content://micode_notes/data
mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM); // content://micode_notes/data/1
mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH); // content://micode_notes/search
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST); // 搜索建议
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST); // 带参数的搜索建议
mMatcher.addURI(Notes.AUTHORITY, "note", URI_NOTE);
mMatcher.addURI(Notes.AUTHORITY, "note/#", URI_NOTE_ITEM);
mMatcher.addURI(Notes.AUTHORITY, "data", URI_DATA);
mMatcher.addURI(Notes.AUTHORITY, "data/#", URI_DATA_ITEM);
mMatcher.addURI(Notes.AUTHORITY, "search", URI_SEARCH);
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY, URI_SEARCH_SUGGEST);
mMatcher.addURI(Notes.AUTHORITY, SearchManager.SUGGEST_URI_PATH_QUERY + "/*", URI_SEARCH_SUGGEST);
}
/**
* 搜索结果投影定义：替换换行符并修剪空白，确保搜索结果显示完整信息
* x'0A' represents the '\n' character in sqlite. For title and content in the search result,
* we will trim '\n' and white space in order to show more information.
*/
private static final String NOTES_SEARCH_PROJECTION = NoteColumns.ID + ","
+ NoteColumns.ID + " AS " + SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA + ","
@ -112,35 +73,18 @@ public class NotesProvider extends ContentProvider {
+ "'" + Intent.ACTION_VIEW + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_ACTION + ","
+ "'" + Notes.TextNote.CONTENT_TYPE + "' AS " + SearchManager.SUGGEST_COLUMN_INTENT_DATA;
/**
* 笔记内容搜索查询语句
*/
private static String NOTES_SNIPPET_SEARCH_QUERY = "SELECT " + NOTES_SEARCH_PROJECTION
+ " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.SNIPPET + " LIKE ?"
+ " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER
+ " AND " + NoteColumns.TYPE + "=" + Notes.TYPE_NOTE;
/**
* 初始化ContentProvider
* @return 是否初始化成功
*/
@Override
public boolean onCreate() {
// 获取数据库帮助类实例
mHelper = NotesDatabaseHelper.getInstance(getContext());
return true;
}
/**
* 查询数据
* @param uri 查询的URI
* @param projection 要查询的列
* @param selection 查询条件
* @param selectionArgs 查询条件参数
* @param sortOrder 排序方式
* @return 查询结果游标
*/
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
String sortOrder) {
@ -203,12 +147,6 @@ public class NotesProvider extends ContentProvider {
return c;
}
/**
* 插入数据
* @param uri 插入的URI
* @param values 要插入的数据
* @return 插入数据的URI
*/
@Override
public Uri insert(Uri uri, ContentValues values) {
SQLiteDatabase db = mHelper.getWritableDatabase();
@ -243,13 +181,6 @@ public class NotesProvider extends ContentProvider {
return ContentUris.withAppendedId(uri, insertedId);
}
/**
* 删除数据
* @param uri 删除的URI
* @param selection 删除条件
* @param selectionArgs 删除条件参数
* @return 删除的行数
*/
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
int count = 0;
@ -296,14 +227,6 @@ public class NotesProvider extends ContentProvider {
return count;
}
/**
* 更新数据
* @param uri 更新的URI
* @param values 要更新的数据
* @param selection 更新条件
* @param selectionArgs 更新条件参数
* @return 更新的行数
*/
@Override
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
int count = 0;
@ -344,21 +267,10 @@ public class NotesProvider extends ContentProvider {
return count;
}
/**
* 解析查询条件
* @param selection 查询条件
* @return 解析后的查询条件
*/
private String parseSelection(String selection) {
return (!TextUtils.isEmpty(selection) ? " AND (" + selection + ')' : "");
}
/**
* 增加笔记版本号
* @param id 笔记ID
* @param selection 查询条件
* @param selectionArgs 查询条件参数
*/
private void increaseNoteVersion(long id, String selection, String[] selectionArgs) {
StringBuilder sql = new StringBuilder(120);
sql.append("UPDATE ");
@ -384,11 +296,6 @@ public class NotesProvider extends ContentProvider {
mHelper.getWritableDatabase().execSQL(sql.toString());
}
/**
* 获取MIME类型
* @param uri URI
* @return MIME类型
*/
@Override
public String getType(Uri uri) {
// TODO Auto-generated method stub

55
src/notes/gtask/data/MetaData.java
Unescape View File

@ -25,65 +25,33 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* MetaData类 - 继承自Task类，用于存储与GTask同步相关的元数据信息
*
* 该类主要用于在GTask同步过程中存储和管理元数据，包含与特定GTask相关联的ID信息
* 重写了Task类的部分方法，以适应元数据的特殊处理需求
*/
public class MetaData extends Task {
private final static String TAG = MetaData.class.getSimpleName();
// 与当前元数据关联的GTask ID
private String mRelatedGid = null;
/**
* 设置元数据信息
*
* @param gid 相关联的GTask ID
* @param metaInfo 元数据JSON对象
*/
public void setMeta(String gid, JSONObject metaInfo) {
try {
// 将GTask ID添加到元数据中
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
} catch (JSONException e) {
Log.e(TAG, "failed to put related gid");
}
// 将元数据以字符串形式存储到Task的notes字段中
setNotes(metaInfo.toString());
// 设置元数据任务的名称
setName(GTaskStringUtils.META_NOTE_NAME);
}
/**
* 获取与当前元数据关联的GTask ID
*
* @return 关联的GTask ID
*/
public String getRelatedGid() {
return mRelatedGid;
}
/**
* 判断元数据是否值得保存
*
* @return 如果有notes内容则返回true，否则返回false
*/
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
/**
* 从远程JSON对象设置内容
*
* @param js 远程JSON对象
*/
@Override
public void setContentByRemoteJSON(JSONObject js) {
super.setContentByRemoteJSON(js);
// 如果有notes内容，则解析获取关联的GTask ID
if (getNotes() != null) {
try {
JSONObject metaInfo = new JSONObject(getNotes().trim());
@ -95,40 +63,19 @@ public class MetaData extends Task {
}
}
/**
* 从本地JSON对象设置内容 - 该方法不应被调用
*
* @param js 本地JSON对象
* @throws IllegalAccessError 总是抛出该异常，表示方法不应被调用
*/
@Override
public void setContentByLocalJSON(JSONObject js) {
// 元数据不支持从本地JSON设置内容
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
}
/**
* 从内容获取本地JSON对象 - 该方法不应被调用
*
* @return 本地JSON对象
* @throws IllegalAccessError 总是抛出该异常，表示方法不应被调用
*/
@Override
public JSONObject getLocalJSONFromContent() {
// 元数据不支持获取本地JSON对象
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
}
/**
* 获取同步操作类型 - 该方法不应被调用
*
* @param c 数据库游标
* @return 同步操作类型
* @throws IllegalAccessError 总是抛出该异常，表示方法不应被调用
*/
@Override
public int getSyncAction(Cursor c) {
// 元数据不支持获取同步操作类型
throw new IllegalAccessError("MetaData:getSyncAction should not be called");
}

121
src/notes/gtask/data/Node.java
Unescape View File

@ -20,81 +20,33 @@ import android.database.Cursor;
import org.json.JSONObject;
/**
* Node类 - GTask同步系统中的抽象基类，定义了所有同步节点的基本属性和行为
*
* 该抽象类为TaskList、Task和MetaData等具体类提供了统一的接口和基础功能，
* 主要用于管理GTask同步系统中的节点对象及其与服务器的同步操作。
*/
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;
/**
* 节点在Google Tasks系统中的全局唯一ID
*/
private String mGid;
/**
* 节点名称
*/
private String mName;
/**
* 节点最后修改时间戳
*/
private long mLastModified;
/**
* 节点是否已删除的标记
*/
private boolean mDeleted;
/**
* 构造函数 - 初始化节点的基本属性
*/
public Node() {
mGid = null;
mName = "";
@ -102,119 +54,46 @@ public abstract class Node {
mDeleted = false;
}
/**
* 生成创建节点的JSON操作对象（抽象方法，子类必须实现）
*
* @param actionId 操作ID，用于标识该同步操作
* @return 包含创建节点所需信息的JSON对象
*/
public abstract JSONObject getCreateAction(int actionId);
/**
* 生成更新节点的JSON操作对象（抽象方法，子类必须实现）
*
* @param actionId 操作ID，用于标识该同步操作
* @return 包含更新节点所需信息的JSON对象
*/
public abstract JSONObject getUpdateAction(int actionId);
/**
* 根据远程JSON对象设置节点内容（抽象方法，子类必须实现）
*
* @param js 从Google Tasks服务器获取的JSON对象
*/
public abstract void setContentByRemoteJSON(JSONObject js);
/**
* 根据本地JSON对象设置节点内容（抽象方法，子类必须实现）
*
* @param js 本地存储的JSON对象
*/
public abstract void setContentByLocalJSON(JSONObject js);
/**
* 从节点内容生成本地JSON对象（抽象方法，子类必须实现）
*
* @return 包含节点本地存储信息的JSON对象
*/
public abstract JSONObject getLocalJSONFromContent();
/**
* 根据本地数据库游标判断同步操作类型（抽象方法，子类必须实现）
*
* @param c 本地数据库游标，包含节点的本地存储信息
* @return 同步操作类型（使用SYNC_ACTION_*常量）
*/
public abstract int getSyncAction(Cursor c);
/**
* 设置节点在Google Tasks系统中的全局唯一ID
*
* @param gid 全局唯一ID
*/
public void setGid(String gid) {
this.mGid = gid;
}
/**
* 设置节点名称
*
* @param name 节点名称
*/
public void setName(String name) {
this.mName = name;
}
/**
* 设置节点最后修改时间戳
*
* @param lastModified 最后修改时间戳
*/
public void setLastModified(long lastModified) {
this.mLastModified = lastModified;
}
/**
* 设置节点是否已删除
*
* @param deleted 是否已删除
*/
public void setDeleted(boolean deleted) {
this.mDeleted = deleted;
}
/**
* 获取节点在Google Tasks系统中的全局唯一ID
*
* @return 全局唯一ID
*/
public String getGid() {
return this.mGid;
}
/**
* 获取节点名称
*
* @return 节点名称
*/
public String getName() {
return this.mName;
}
/**
* 获取节点最后修改时间戳
*
* @return 最后修改时间戳
*/
public long getLastModified() {
return this.mLastModified;
}
/**
* 获取节点是否已删除
*
* @return 是否已删除
*/
public boolean getDeleted() {
return this.mDeleted;
}

95
src/notes/gtask/data/SqlData.java
Unescape View File

@ -35,101 +35,42 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* SqlData类 - 用于管理与笔记数据相关的SQL操作，处理Notes应用中数据行的创建、更新和内容同步
*
* 该类主要负责：
* 1. 管理笔记数据的基本信息（ID、MIME类型、内容等）
* 2. 支持从Cursor加载数据和生成JSON格式内容
* 3. 处理数据的创建和更新操作，使用ContentValues跟踪差异变化
* 4. 将数据提交到数据库，支持版本验证
*/
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
};
/**
* PROJECTION_DATA中ID列的索引
*/
public static final int DATA_ID_COLUMN = 0;
/**
* PROJECTION_DATA中MIME类型列的索引
*/
public static final int DATA_MIME_TYPE_COLUMN = 1;
/**
* PROJECTION_DATA中内容列的索引
*/
public static final int DATA_CONTENT_COLUMN = 2;
/**
* PROJECTION_DATA中DATA1列的索引
*/
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
/**
* PROJECTION_DATA中DATA3列的索引
*/
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
/**
* 用于访问Android ContentProvider的ContentResolver对象
*/
private ContentResolver mContentResolver;
/**
* 标记当前数据是否为新创建的数据
*/
private boolean mIsCreate;
/**
* 数据的唯一标识符
*/
private long mDataId;
/**
* 数据的MIME类型
*/
private String mDataMimeType;
/**
* 数据的内容
*/
private String mDataContent;
/**
* 数据的额外信息字段1
*/
private long mDataContentData1;
/**
* 数据的额外信息字段3
*/
private String mDataContentData3;
/**
* 用于存储差异更新的ContentValues对象，只包含需要更新的字段
*/
private ContentValues mDiffDataValues;
/**
* 构造函数 - 创建一个新的SqlData对象
*
* @param context 上下文对象，用于获取ContentResolver
*/
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
@ -141,12 +82,6 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 构造函数 - 从Cursor创建SqlData对象
*
* @param context 上下文对象，用于获取ContentResolver
* @param c 包含数据的Cursor对象
*/
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
@ -154,11 +89,6 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 从Cursor加载数据到成员变量
*
* @param c 包含数据的Cursor对象
*/
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@ -167,12 +97,6 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
/**
* 根据JSON对象设置数据内容
*
* @param js 包含数据内容的JSON对象
* @throws JSONException 如果解析JSON失败
*/
public void setContent(JSONObject js) throws JSONException {
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
@ -206,12 +130,6 @@ public class SqlData {
mDataContentData3 = dataContentData3;
}
/**
* 生成包含数据内容的JSON对象
*
* @return 包含数据内容的JSON对象
* @throws JSONException 如果生成JSON失败
*/
public JSONObject getContent() throws JSONException {
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
@ -226,14 +144,6 @@ public class SqlData {
return js;
}
/**
* 将数据提交到数据库
*
* @param noteId 所属笔记的ID
* @param validateVersion 是否验证版本号
* @param version 验证的版本号
* @throws ActionFailureException 如果创建数据失败
*/
public void commit(long noteId, boolean validateVersion, long version) {
if (mIsCreate) {
@ -273,11 +183,6 @@ public class SqlData {
mIsCreate = false;
}
/**
* 获取数据ID
*
* @return 数据的唯一标识符
*/
public long getId() {
return mDataId;
}

256
src/notes/gtask/data/SqlNote.java
Unescape View File

@ -38,19 +38,11 @@ import org.json.JSONObject;
import java.util.ArrayList;
/**
* SqlNote类 - 用于管理本地笔记数据的核心类
*
* 该类负责处理笔记数据的加载、存储、更新和转换，是GTask同步机制与本地数据库之间的桥梁
* 支持从Cursor加载数据、从JSON设置内容、提交更改到数据库等功能
*/
public class SqlNote {
private static final String TAG = SqlNote.class.getSimpleName();
// 无效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,
@ -60,154 +52,139 @@ public class SqlNote {
NoteColumns.VERSION
};
// 投影数组中各列的索引常量定义
public static final int ID_COLUMN = 0;
public static final int ALERTED_DATE_COLUMN = 1;
public static final int BG_COLOR_ID_COLUMN = 2;
public static final int CREATED_DATE_COLUMN = 3;
public static final int HAS_ATTACHMENT_COLUMN = 4;
public static final int MODIFIED_DATE_COLUMN = 5;
public static final int NOTES_COUNT_COLUMN = 6;
public static final int PARENT_ID_COLUMN = 7;
public static final int SNIPPET_COLUMN = 8;
public static final int TYPE_COLUMN = 9;
public static final int WIDGET_ID_COLUMN = 10;
public static final int WIDGET_TYPE_COLUMN = 11;
public static final int SYNC_ID_COLUMN = 12;
public static final int LOCAL_MODIFIED_COLUMN = 13;
public static final int ORIGIN_PARENT_ID_COLUMN = 14;
public static final int GTASK_ID_COLUMN = 15;
public static final int VERSION_COLUMN = 16;
// 上下文对象，用于访问系统服务
private Context mContext;
// 内容解析器，用于与ContentProvider交互
private ContentResolver mContentResolver;
// 是否为新创建的笔记
private boolean mIsCreate;
// 笔记ID
private long mId;
// 提醒日期
private long mAlertDate;
// 背景颜色ID
private int mBgColorId;
// 创建日期
private long mCreatedDate;
// 是否有附件
private int mHasAttachment;
// 修改日期
private long mModifiedDate;
// 父文件夹ID
private long mParentId;
// 笔记摘要
private String mSnippet;
// 笔记类型（普通笔记、文件夹等）
private int mType;
// 小部件ID
private int mWidgetId;
// 小部件类型
private int mWidgetType;
// 原始父文件夹ID
private long mOriginParent;
// 版本号，用于并发控制
private long mVersion;
// 差异内容值，用于记录需要更新的字段
private ContentValues mDiffNoteValues;
// 私有成员变量，用于存储SqlData类型的数据列表
// 使用ArrayList作为数据结构，可以动态存储SqlData对象
private ArrayList<SqlData> mDataList;
/**
* 创建新笔记的构造函数
*
* @param context 上下文对象，用于访问系统服务
*/
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = true; // 标记为新创建的笔记
mId = INVALID_ID; // 初始化为无效ID
mAlertDate = 0; // 无提醒日期
mBgColorId = ResourceParser.getDefaultBgId(context); // 使用默认背景颜色
mCreatedDate = System.currentTimeMillis(); // 创建日期设为当前时间
mHasAttachment = 0; // 初始没有附件
mModifiedDate = System.currentTimeMillis(); // 修改日期设为当前时间
mParentId = 0; // 默认父文件夹ID为0
mSnippet = ""; // 摘要为空
mType = Notes.TYPE_NOTE; // 默认类型为普通笔记
mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; // 无效小部件ID
mWidgetType = Notes.TYPE_WIDGET_INVALIDE; // 无效小部件类型
mOriginParent = 0; // 原始父文件夹ID
mVersion = 0; // 初始版本号
mDiffNoteValues = new ContentValues(); // 用于记录差异的内容值
mDataList = new ArrayList<SqlData>(); // 初始化数据列表
mIsCreate = true;
mId = INVALID_ID;
mAlertDate = 0;
mBgColorId = ResourceParser.getDefaultBgId(context);
mCreatedDate = System.currentTimeMillis();
mHasAttachment = 0;
mModifiedDate = System.currentTimeMillis();
mParentId = 0;
mSnippet = "";
mType = Notes.TYPE_NOTE;
mWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
mWidgetType = Notes.TYPE_WIDGET_INVALIDE;
mOriginParent = 0;
mVersion = 0;
mDiffNoteValues = new ContentValues();
mDataList = new ArrayList<SqlData>();
}
/**
* 从Cursor创建SqlNote对象的构造函数
*
* @param context 上下文对象
* @param c 包含笔记数据的Cursor对象
*/
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false; // 标记为已存在的笔记
loadFromCursor(c); // 从Cursor加载数据
mDataList = new ArrayList<SqlData>(); // 初始化数据列表
if (mType == Notes.TYPE_NOTE) // 如果是普通笔记，加载其数据内容
mIsCreate = false;
loadFromCursor(c);
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues = new ContentValues(); // 用于记录差异的内容值
mDiffNoteValues = new ContentValues();
}
/**
* 根据ID创建SqlNote对象的构造函数
*
* @param context 上下文对象
* @param id 笔记的ID
*/
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
mIsCreate = false; // 标记为已存在的笔记
loadFromCursor(id); // 根据ID从数据库加载数据
mDataList = new ArrayList<SqlData>(); // 初始化数据列表
if (mType == Notes.TYPE_NOTE) // 如果是普通笔记，加载其数据内容
mIsCreate = false;
loadFromCursor(id);
mDataList = new ArrayList<SqlData>();
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues = new ContentValues(); // 用于记录差异的内容值
mDiffNoteValues = new ContentValues();
}
/**
* 根据ID从数据库加载笔记数据
*
* @param id 笔记的ID
*/
private void loadFromCursor(long id) {
Cursor c = null;
try {
// 查询指定ID的笔记数据
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, PROJECTION_NOTE, "(_id=?)",
new String[] {
String.valueOf(id)
}, null);
if (c != null) {
c.moveToNext();
loadFromCursor(c); // 调用Cursor版本的loadFromCursor方法
loadFromCursor(c);
} else {
Log.w(TAG, "loadFromCursor: cursor = null");
}
} finally {
if (c != null)
c.close(); // 确保Cursor被关闭
c.close();
}
}
/**
* 从Cursor对象加载笔记数据到成员变量
*
* @param c 包含笔记数据的Cursor对象
*/
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -223,16 +200,10 @@ public class SqlNote {
mVersion = c.getLong(VERSION_COLUMN);
}
/**
* 加载笔记的具体数据内容
*
* 该方法从数据库中查询与当前笔记关联的所有数据项，并将它们加载到mDataList中
*/
private void loadDataContent() {
Cursor c = null;
mDataList.clear(); // 清空现有数据列表
mDataList.clear();
try {
// 查询与当前笔记ID关联的所有数据项
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA,
"(note_id=?)", new String[] {
String.valueOf(mId)
@ -242,7 +213,6 @@ public class SqlNote {
Log.w(TAG, "it seems that the note has not data");
return;
}
// 遍历Cursor，创建SqlData对象并添加到数据列表
while (c.moveToNext()) {
SqlData data = new SqlData(mContext, c);
mDataList.add(data);
@ -252,25 +222,17 @@ public class SqlNote {
}
} finally {
if (c != null)
c.close(); // 确保Cursor被关闭
c.close();
}
}
/**
* 从JSON对象设置笔记内容
*
* @param js 包含笔记数据的JSON对象
* @return 是否成功设置内容
*/
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
// 根据笔记类型进行不同处理
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
Log.w(TAG, "cannot set system folder");
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// 文件夹类型只能更新摘要和类型
// for folder we can only update the snnipet and type
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || !mSnippet.equals(snippet)) {
@ -285,10 +247,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) {
mDiffNoteValues.put(NoteColumns.ID, id);
@ -372,12 +331,9 @@ public class SqlNote {
}
mOriginParent = originParent;
// 处理笔记关联的数据项
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
SqlData sqlData = null;
// 尝试在现有数据列表中找到匹配的SqlData对象
if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) {
@ -387,13 +343,11 @@ public class SqlNote {
}
}
// 如果找不到匹配的SqlData对象，则创建新的
if (sqlData == null) {
sqlData = new SqlData(mContext);
mDataList.add(sqlData);
}
// 设置SqlData的内容
sqlData.setContent(data);
}
}
@ -405,26 +359,17 @@ public class SqlNote {
return true;
}
/**
* 获取笔记内容的JSON表示
*
* @return 包含笔记内容的JSON对象，如果获取失败则返回null
*/
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
// 如果是新创建的笔记（尚未保存到数据库），则无法获取内容
if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet");
return null;
}
JSONObject note = new JSONObject();
// 根据笔记类型构建不同的JSON结构
if (mType == Notes.TYPE_NOTE) {
// 普通笔记类型，包含完整的笔记信息和关联数据
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate);
note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -439,7 +384,6 @@ public class SqlNote {
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
// 添加关联的数据项
JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) {
JSONObject data = sqlData.getContent();
@ -449,7 +393,6 @@ public class SqlNote {
}
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {
// 文件夹或系统类型，只包含基本信息
note.put(NoteColumns.ID, mId);
note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet);
@ -464,97 +407,48 @@ public class SqlNote {
return null;
}
/**
* 设置笔记的父文件夹ID
*
* @param id 父文件夹的ID
*/
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
/**
* 设置笔记的GTask ID（用于同步）
*
* @param gid GTask ID
*/
public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
}
/**
* 设置笔记的同步ID
*
* @param syncId 同步ID
*/
public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
}
/**
* 重置本地修改标志
*
* 将本地修改标志设置为0，表示当前内容与服务器同步
*/
public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
}
/**
* 获取笔记的ID
*
* @return 笔记的ID
*/
public long getId() {
return mId;
}
/**
* 获取笔记的父文件夹ID
*
* @return 父文件夹的ID
*/
public long getParentId() {
return mParentId;
}
/**
* 获取笔记的摘要
*
* @return 笔记的摘要
*/
public String getSnippet() {
return mSnippet;
}
/**
* 检查笔记是否为普通笔记类型
*
* @return 是否为普通笔记类型
*/
public boolean isNoteType() {
return mType == Notes.TYPE_NOTE;
}
/**
* 将笔记内容提交到数据库
*
* @param validateVersion 是否验证版本号
* @throws ActionFailureException 如果创建笔记失败
* @throws IllegalStateException 如果更新笔记时ID无效
*/
public void commit(boolean validateVersion) {
if (mIsCreate) {
// 新创建的笔记，执行插入操作
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID); // 移除无效ID
mDiffNoteValues.remove(NoteColumns.ID);
}
// 插入笔记到数据库
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
try {
mId = Long.valueOf(uri.getPathSegments().get(1)); // 获取自动生成的ID
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
@ -563,29 +457,27 @@ public class SqlNote {
throw new IllegalStateException("Create thread id failed");
}
// 如果是普通笔记，提交其关联的数据
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, false, -1);
}
}
} else {
// 已存在的笔记，执行更新操作
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
Log.e(TAG, "No such note");
throw new IllegalStateException("Try to update note with invalid id");
}
if (mDiffNoteValues.size() > 0) {
mVersion ++; // 版本号递增
mVersion ++;
int result = 0;
if (!validateVersion) {
// 不验证版本，直接更新
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?)", new String[] {
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?)", new String[] {
String.valueOf(mId)
});
} else {
// 验证版本，防止并发更新冲突
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" + NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
new String[] {
String.valueOf(mId), String.valueOf(mVersion)
});
@ -595,7 +487,6 @@ public class SqlNote {
}
}
// 如果是普通笔记，提交其关联的数据
if (mType == Notes.TYPE_NOTE) {
for (SqlData sqlData : mDataList) {
sqlData.commit(mId, validateVersion, mVersion);
@ -603,12 +494,11 @@ public class SqlNote {
}
}
// 刷新本地信息，确保与数据库一致
// refresh local info
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
// 清空差异内容值并标记为已存在
mDiffNoteValues.clear();
mIsCreate = false;
}

119
src/notes/gtask/data/Task.java
Unescape View File

@ -32,47 +32,19 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* Task类 - 继承自Node类，用于表示GTask同步系统中的单个任务
*
* 该类主要负责：
* 1. 管理任务的基本信息（名称、备注、完成状态等）
* 2. 维护任务之间的关系（前一个兄弟任务、父任务列表）
* 3. 处理与GTask服务器的同步操作（创建、更新、同步状态判断）
* 4. 支持本地与远程JSON格式的相互转换
* 5. 管理任务的元信息，用于与本地笔记系统关联
*/
public class Task extends Node {
private static final String TAG = Task.class.getSimpleName();
/**
* 任务的完成状态
*/
private boolean mCompleted;
/**
* 任务的备注信息
*/
private String mNotes;
/**
* 任务的元信息，以JSON格式存储，用于与本地笔记系统关联
*/
private JSONObject mMetaInfo;
/**
* 当前任务的前一个兄弟任务，用于维护任务列表中的顺序
*/
private Task mPriorSibling;
/**
* 当前任务所属的父任务列表
*/
private TaskList mParent;
/**
* 构造函数 - 初始化任务的基本属性
*/
public Task() {
super();
mCompleted = false;
@ -82,13 +54,6 @@ public class Task extends Node {
mMetaInfo = null;
}
/**
* 生成创建任务的JSON操作对象
*
* @param actionId 操作ID，用于标识该同步操作
* @return 包含创建任务所需信息的JSON对象
* @throws ActionFailureException 如果生成JSON失败
*/
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
@ -138,13 +103,6 @@ public class Task extends Node {
return js;
}
/**
* 生成更新任务的JSON操作对象
*
* @param actionId 操作ID，用于标识该同步操作
* @return 包含更新任务所需信息的JSON对象
* @throws ActionFailureException 如果生成JSON失败
*/
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
@ -177,12 +135,6 @@ public class Task extends Node {
return js;
}
/**
* 根据远程JSON对象设置任务内容
*
* @param js 从Google Tasks服务器获取的JSON对象
* @throws ActionFailureException 如果解析JSON失败
*/
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
@ -223,11 +175,6 @@ public class Task extends Node {
}
}
/**
* 根据本地JSON对象设置任务内容
*
* @param js 本地存储的JSON对象
*/
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
@ -257,11 +204,6 @@ public class Task extends Node {
}
}
/**
* 从任务内容生成本地JSON对象
*
* @return 包含任务本地存储信息的JSON对象，如果生成失败则返回null
*/
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
@ -305,11 +247,6 @@ public class Task extends Node {
}
}
/**
* 设置任务的元信息
*
* @param metaData 包含任务元信息的MetaData对象
*/
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
try {
@ -321,17 +258,6 @@ public class Task extends Node {
}
}
/**
* 根据本地数据库游标判断同步操作类型
*
* @param c 本地数据库游标，包含任务的本地存储信息
* @return 同步操作类型：
* - SYNC_ACTION_NONE: 无需同步
* - SYNC_ACTION_UPDATE_LOCAL: 更新本地数据
* - SYNC_ACTION_UPDATE_REMOTE: 更新远程数据
* - SYNC_ACTION_UPDATE_CONFLICT: 同步冲突
* - SYNC_ACTION_ERROR: 同步错误
*/
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
@ -385,84 +311,39 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
/**
* 判断任务是否值得保存
*
* @return 如果任务有元信息、名称或备注，则返回true，否则返回false
*/
public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0);
}
/**
* 设置任务的完成状态
*
* @param completed 任务的完成状态
*/
public void setCompleted(boolean completed) {
this.mCompleted = completed;
}
/**
* 设置任务的备注信息
*
* @param notes 任务的备注信息
*/
public void setNotes(String notes) {
this.mNotes = notes;
}
/**
* 设置任务的前一个兄弟任务
*
* @param priorSibling 前一个兄弟任务
*/
public void setPriorSibling(Task priorSibling) {
this.mPriorSibling = priorSibling;
}
/**
* 设置任务的父任务列表
*
* @param parent 父任务列表
*/
public void setParent(TaskList parent) {
this.mParent = parent;
}
/**
* 获取任务的完成状态
*
* @return 任务的完成状态
*/
public boolean getCompleted() {
return this.mCompleted;
}
/**
* 获取任务的备注信息
*
* @return 任务的备注信息
*/
public String getNotes() {
return this.mNotes;
}
/**
* 获取任务的前一个兄弟任务
*
* @return 前一个兄弟任务
*/
public Task getPriorSibling() {
return this.mPriorSibling;
}
/**
* 获取任务的父任务列表
*
* @return 父任务列表
*/
public TaskList getParent() {
return this.mParent;
}

128
src/notes/gtask/data/TaskList.java
Unescape View File

@ -30,44 +30,19 @@ import org.json.JSONObject;
import java.util.ArrayList;
/**
* TaskList类 - 继承自Node类，用于表示任务列表并管理其中的Task对象集合
*
* 该类主要负责：
* 1. 管理任务列表的基本信息（名称、ID、修改时间等）
* 2. 维护子Task对象的集合及其关系
* 3. 处理与GTask服务器的同步操作（创建、更新、同步状态判断）
* 4. 支持本地与远程JSON格式的相互转换
*/
public class TaskList extends Node {
private static final String TAG = TaskList.class.getSimpleName();
/**
* 任务列表在Google Tasks中的索引位置，用于排序
*/
private int mIndex;
/**
* 存储当前任务列表包含的所有Task对象
*/
private ArrayList<Task> mChildren;
/**
* 构造函数 - 初始化空的Task列表，设置默认索引为1
*/
public TaskList() {
super();
mChildren = new ArrayList<Task>();
mIndex = 1;
}
/**
* 生成创建任务列表的JSON操作对象
*
* @param actionId 操作ID，用于标识该同步操作
* @return 包含创建任务列表所需信息的JSON对象
* @throws ActionFailureException 如果生成JSON失败
*/
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
@ -99,13 +74,6 @@ public class TaskList extends Node {
return js;
}
/**
* 生成更新任务列表的JSON操作对象
*
* @param actionId 操作ID，用于标识该同步操作
* @return 包含更新任务列表所需信息的JSON对象
* @throws ActionFailureException 如果生成JSON失败
*/
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
@ -135,12 +103,6 @@ public class TaskList extends Node {
return js;
}
/**
* 根据远程JSON对象设置任务列表内容
*
* @param js 从Google Tasks服务器获取的JSON对象
* @throws ActionFailureException 如果解析JSON失败
*/
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
@ -167,11 +129,6 @@ public class TaskList extends Node {
}
}
/**
* 根据本地JSON对象设置任务列表内容
*
* @param js 本地存储的JSON对象
*/
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
@ -200,11 +157,6 @@ public class TaskList extends Node {
}
}
/**
* 从任务列表内容生成本地JSON对象
*
* @return 包含任务列表本地存储信息的JSON对象，如果生成失败则返回null
*/
public JSONObject getLocalJSONFromContent() {
try {
JSONObject js = new JSONObject();
@ -231,16 +183,6 @@ public class TaskList extends Node {
}
}
/**
* 根据本地数据库游标判断同步操作类型
*
* @param c 本地数据库游标，包含任务列表的本地存储信息
* @return 同步操作类型：
* - SYNC_ACTION_NONE: 无需同步
* - SYNC_ACTION_UPDATE_LOCAL: 更新本地数据
* - SYNC_ACTION_UPDATE_REMOTE: 更新远程数据
* - SYNC_ACTION_ERROR: 同步错误
*/
public int getSyncAction(Cursor c) {
try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
@ -274,21 +216,10 @@ public class TaskList extends Node {
return SYNC_ACTION_ERROR;
}
/**
* 获取子任务数量
*
* @return 子任务的总数
*/
public int getChildTaskCount() {
return mChildren.size();
}
/**
* 添加子任务到任务列表末尾
*
* @param task 要添加的子任务
* @return 是否添加成功
*/
public boolean addChildTask(Task task) {
boolean ret = false;
if (task != null && !mChildren.contains(task)) {
@ -303,13 +234,6 @@ public class TaskList extends Node {
return ret;
}
/**
* 在指定位置添加子任务
*
* @param task 要添加的子任务
* @param index 要插入的位置索引
* @return 是否添加成功
*/
public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index");
@ -336,12 +260,6 @@ public class TaskList extends Node {
return true;
}
/**
* 从任务列表中移除子任务
*
* @param task 要移除的子任务
* @return 是否移除成功
*/
public boolean removeChildTask(Task task) {
boolean ret = false;
int index = mChildren.indexOf(task);
@ -363,13 +281,6 @@ public class TaskList extends Node {
return ret;
}
/**
* 移动子任务到指定位置
*
* @param task 要移动的子任务
* @param index 目标位置索引
* @return 是否移动成功
*/
public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) {
@ -388,12 +299,6 @@ public class TaskList extends Node {
return (removeChildTask(task) && addChildTask(task, index));
}
/**
* 根据Gid查找子任务
*
* @param gid 要查找的任务Gid
* @return 找到的Task对象，如果未找到则返回null
*/
public Task findChildTaskByGid(String gid) {
for (int i = 0; i < mChildren.size(); i++) {
Task t = mChildren.get(i);
@ -404,22 +309,10 @@ public class TaskList extends Node {
return null;
}
/**
* 获取子任务在列表中的索引位置
*
* @param task 要查找的子任务
* @return 子任务在列表中的索引，未找到则返回-1
*/
public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task);
}
/**
* 根据索引获取子任务
*
* @param index 子任务的索引位置
* @return 对应索引的Task对象，如果索引无效则返回null
*/
public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index");
@ -428,12 +321,6 @@ public class TaskList extends Node {
return mChildren.get(index);
}
/**
* 根据Gid查找子任务（与findChildTaskByGid功能相同，为了兼容性保留）
*
* @param gid 要查找的任务Gid
* @return 找到的Task对象，如果未找到则返回null
*/
public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) {
if (task.getGid().equals(gid))
@ -442,29 +329,14 @@ public class TaskList extends Node {
return null;
}
/**
* 获取所有子任务的列表
*
* @return 包含所有子任务的ArrayList
*/
public ArrayList<Task> getChildTaskList() {
return this.mChildren;
}
/**
* 设置任务列表的索引位置
*
* @param index 新的索引位置
*/
public void setIndex(int index) {
this.mIndex = index;
}
/**
* 获取任务列表的索引位置
*
* @return 当前索引位置
*/
public int getIndex() {
return this.mIndex;
}

22
src/notes/gtask/exception/ActionFailureException.java
Unescape View File

@ -16,39 +16,17 @@
package net.micode.notes.gtask.exception;
/**
* ActionFailureException类 - 继承自RuntimeException，用于表示GTask同步操作失败的异常
*
* 该异常主要在GTask同步过程中，当执行任务列表或任务的创建、更新、删除等操作失败时抛出
* 作为运行时异常，可以由上层调用者选择性捕获，用于处理同步操作失败的情况
*
* @author MiCode Open Source Community
*/
public class ActionFailureException extends RuntimeException {
private static final long serialVersionUID = 4425249765923293627L;
/**
* 无参构造方法，创建一个没有详细消息和原因的ActionFailureException
*/
public ActionFailureException() {
super();
}
/**
* 构造方法，创建一个包含指定详细消息的ActionFailureException
*
* @param paramString 详细错误消息，描述异常发生的原因
*/
public ActionFailureException(String paramString) {
super(paramString);
}
/**
* 构造方法，创建一个包含指定详细消息和原因的ActionFailureException
*
* @param paramString 详细错误消息，描述异常发生的原因
* @param paramThrowable 导致当前异常的原因异常
*/
public ActionFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

22
src/notes/gtask/exception/NetworkFailureException.java
Unescape View File

@ -16,39 +16,17 @@
package net.micode.notes.gtask.exception;
/**
* NetworkFailureException类 - 继承自Exception，用于表示GTask同步过程中的网络故障异常
*
* 该异常主要在GTask同步过程中，当与Google Tasks服务器通信时出现网络问题（如连接超时、网络不可用等）时抛出
* 作为受检异常，必须由调用者显式捕获并处理，用于处理网络相关的错误情况
*
* @author MiCode Open Source Community
*/
public class NetworkFailureException extends Exception {
private static final long serialVersionUID = 2107610287180234136L;
/**
* 无参构造方法，创建一个没有详细消息和原因的NetworkFailureException
*/
public NetworkFailureException() {
super();
}
/**
* 构造方法，创建一个包含指定详细消息的NetworkFailureException
*
* @param paramString 详细错误消息，描述网络故障的原因
*/
public NetworkFailureException(String paramString) {
super(paramString);
}
/**
* 构造方法，创建一个包含指定详细消息和原因的NetworkFailureException
*
* @param paramString 详细错误消息，描述网络故障的原因
* @param paramThrowable 导致当前异常的原因异常（如IOException等）
*/
public NetworkFailureException(String paramString, Throwable paramThrowable) {
super(paramString, paramThrowable);
}

72
src/notes/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -29,35 +29,11 @@ import net.micode.notes.ui.NotesListActivity;
import net.micode.notes.ui.NotesPreferenceActivity;
/**
* GTaskASyncTask类 - 继承自AsyncTask，用于在后台执行Google Tasks同步操作
*
* 该类负责在后台线程中执行Google Tasks的同步工作，并在UI线程中更新同步进度和结果
* 主要功能包括：
* - 在后台执行同步操作
* - 显示同步进度通知
* - 发送同步状态广播
* - 处理同步完成后的回调
* - 支持取消同步操作
*
* @author MiCode Open Source Community
*/
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
/**
* 同步通知的唯一标识符
*/
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
/**
* OnCompleteListener接口 - 同步完成事件的监听器
*
* 该接口用于在同步操作完成后接收回调通知
*/
public interface OnCompleteListener {
/**
* 同步完成时调用的方法
*/
void onComplete();
}
@ -69,12 +45,6 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
private OnCompleteListener mOnCompleteListener;
/**
* 构造方法，创建一个GTaskASyncTask实例
*
* @param context 上下文对象，用于获取系统服务和资源
* @param listener 同步完成监听器，用于接收同步完成的回调
*/
public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context;
mOnCompleteListener = listener;
@ -83,36 +53,16 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
mTaskManager = GTaskManager.getInstance();
}
/**
* 取消正在进行的同步操作
*
* 该方法通过调用GTaskManager的cancelSync方法来取消同步
*/
public void cancelSync() {
mTaskManager.cancelSync();
}
/**
* 发布同步进度消息
*
* 该方法用于向UI线程发送同步进度更新
*
* @param message 进度消息内容
*/
public void publishProgess(String message) {
publishProgress(new String[] {
message
});
}
/**
* 显示同步通知
*
* 该方法用于显示同步状态的通知消息，包括进度通知和结果通知
*
* @param tickerId 通知标题的资源ID
* @param content 通知内容
*/
private void showNotification(int tickerId, String content) {
// 1. 创建通知构建器（替代旧构造函数）
Notification.Builder builder = new Notification.Builder(mContext)
@ -144,14 +94,6 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
mNotifiManager.notify(GTASK_SYNC_NOTIFICATION_ID, notification);
}
/**
* 在后台线程中执行同步操作
*
* 该方法是AsyncTask的核心方法，在后台线程中执行Google Tasks的同步工作
*
* @param unused 未使用的参数
* @return 同步结果状态码，对应GTaskManager中的状态常量
*/
@Override
protected Integer doInBackground(Void... unused) {
publishProgess(mContext.getString(R.string.sync_progress_login, NotesPreferenceActivity
@ -159,13 +101,6 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
return mTaskManager.sync(mContext, this);
}
/**
* 在UI线程中更新同步进度
*
* 当后台线程调用publishProgress方法时，该方法会在UI线程中被调用
*
* @param progress 进度消息数组，包含最新的进度消息
*/
@Override
protected void onProgressUpdate(String... progress) {
showNotification(R.string.ticker_syncing, progress[0]);
@ -174,13 +109,6 @@ public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
}
}
/**
* 在UI线程中处理同步完成后的结果
*
* 当后台线程的doInBackground方法执行完成后，该方法会在UI线程中被调用
*
* @param result 同步结果状态码，对应GTaskManager中的状态常量
*/
@Override
protected void onPostExecute(Integer result) {
if (result == GTaskManager.STATE_SUCCESS) {

116
src/notes/gtask/remote/GTaskClient.java
Unescape View File

@ -61,14 +61,6 @@ import java.util.zip.Inflater;
import java.util.zip.InflaterInputStream;
/**
* GTaskClient类 - Google Tasks服务器通信的核心客户端类，使用单例模式实现
*
* 该类负责与Google Tasks服务器进行通信，处理用户认证、任务列表和任务的创建、更新、删除等操作
* 封装了HTTP请求和响应处理，JSON数据解析，以及与Google Tasks API的交互逻辑
*
* @author MiCode Open Source Community
*/
public class GTaskClient {
private static final String TAG = GTaskClient.class.getSimpleName();
@ -110,14 +102,6 @@ public class GTaskClient {
mUpdateArray = null;
}
/**
* 获取GTaskClient的单例实例
*
* 该方法采用同步机制，确保在多线程环境下只有一个GTaskClient实例
* 单例模式保证了全局只有一个客户端实例，避免了重复创建连接和资源浪费
*
* @return GTaskClient的单例实例
*/
public static synchronized GTaskClient getInstance() {
if (mInstance == null) {
mInstance = new GTaskClient();
@ -125,16 +109,6 @@ public class GTaskClient {
return mInstance;
}
/**
* 登录Google Tasks服务
*
* 该方法负责处理用户认证，包括获取Google账户令牌、设置认证cookie等
* 支持自定义域名和官方域名登录尝试，确保在各种环境下都能成功登录
* 登录成功后会记录客户端版本和登录时间
*
* @param activity 上下文Activity，用于获取账户管理器
* @return 登录成功返回true，否则返回false
*/
public boolean login(Activity activity) {
// we suppose that the cookie would expire after 5 minutes
// then we need to re-login
@ -386,16 +360,6 @@ public class GTaskClient {
}
}
/**
* 创建Google Tasks任务
*
* 该方法将本地任务对象同步到Google Tasks服务器，创建新的任务
* 创建成功后会从服务器返回的响应中获取并设置任务的全局唯一ID（GID）
*
* @param task 要创建的任务对象，包含任务的各种属性
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 任务创建操作失败时抛出此异常
*/
public void createTask(Task task) throws NetworkFailureException {
commitUpdate();
try {
@ -422,16 +386,6 @@ public class GTaskClient {
}
}
/**
* 创建Google Tasks任务列表
*
* 该方法将本地任务列表对象同步到Google Tasks服务器，创建新的任务列表
* 创建成功后会从服务器返回的响应中获取并设置任务列表的全局唯一ID（GID）
*
* @param tasklist 要创建的任务列表对象，包含任务列表的各种属性
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 任务列表创建操作失败时抛出此异常
*/
public void createTaskList(TaskList tasklist) throws NetworkFailureException {
commitUpdate();
try {
@ -458,15 +412,6 @@ public class GTaskClient {
}
}
/**
* 提交所有待更新的节点到服务器
*
* 该方法将缓存的更新操作批量发送到Google Tasks服务器，实现批量更新
* 主要用于优化性能，减少网络请求次数
*
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 更新提交操作失败时抛出此异常
*/
public void commitUpdate() throws NetworkFailureException {
if (mUpdateArray != null) {
try {
@ -488,16 +433,6 @@ public class GTaskClient {
}
}
/**
* 添加待更新的节点到缓存中
*
* 该方法将需要更新的节点添加到缓存数组中，当缓存达到一定数量（10个）时自动提交
* 用于实现批量更新，减少网络请求次数
*
* @param node 要更新的节点对象
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 添加节点操作失败时抛出此异常
*/
public void addUpdateNode(Node node) throws NetworkFailureException {
if (node != null) {
// too many update items may result in an error
@ -512,19 +447,6 @@ public class GTaskClient {
}
}
/**
* 移动任务到指定的任务列表或同一列表内的新位置
*
* 该方法支持两种移动操作：
* 1. 在同一任务列表内移动任务（调整任务顺序）
* 2. 在不同任务列表之间移动任务
*
* @param task 要移动的任务对象
* @param preParent 移动前的父任务列表
* @param curParent 移动后的父任务列表
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 任务移动操作失败时抛出此异常
*/
public void moveTask(Task task, TaskList preParent, TaskList curParent)
throws NetworkFailureException {
commitUpdate();
@ -564,15 +486,6 @@ public class GTaskClient {
}
}
/**
* 删除指定的节点（任务或任务列表）
*
* 该方法将节点标记为已删除，并发送删除请求到Google Tasks服务器
*
* @param node 要删除的节点对象
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 节点删除操作失败时抛出此异常
*/
public void deleteNode(Node node) throws NetworkFailureException {
commitUpdate();
try {
@ -596,15 +509,6 @@ public class GTaskClient {
}
}
/**
* 获取所有任务列表
*
* 该方法从Google Tasks服务器获取用户的所有任务列表
*
* @return 包含所有任务列表信息的JSONArray
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 获取任务列表操作失败时抛出此异常
*/
public JSONArray getTaskLists() throws NetworkFailureException {
if (!mLoggedin) {
Log.e(TAG, "please login first");
@ -643,16 +547,6 @@ public class GTaskClient {
}
}
/**
* 获取指定任务列表的所有任务
*
* 该方法从Google Tasks服务器获取指定任务列表中的所有任务
*
* @param listGid 任务列表的全局唯一ID
* @return 包含指定任务列表所有任务信息的JSONArray
* @throws NetworkFailureException 网络通信失败时抛出此异常
* @throws ActionFailureException 获取任务列表内容操作失败时抛出此异常
*/
public JSONArray getTaskList(String listGid) throws NetworkFailureException {
commitUpdate();
try {
@ -681,20 +575,10 @@ public class GTaskClient {
}
}
/**
* 获取当前同步使用的Google账户
*
* @return 当前同步使用的Google账户对象
*/
public Account getSyncAccount() {
return mAccount;
}
/**
* 重置更新数组，清空所有待更新的节点
*
* 该方法用于取消所有未提交的更新操作
*/
public void resetUpdateArray() {
mUpdateArray = null;
}

71
src/notes/gtask/remote/GTaskManager.java
Unescape View File

@ -48,45 +48,17 @@ import java.util.Iterator;
import java.util.Map;
/**
* GTaskManager类 - Google Tasks同步管理的核心类，使用单例模式实现
*
* 该类负责协调本地笔记数据与Google Tasks服务器之间的同步工作
* 主要功能包括：
* - 管理同步生命周期和状态
* - 协调本地与远程数据的增删改查操作
* - 处理同步冲突和错误
* - 维护本地与远程数据的映射关系
* - 管理元数据和同步状态
*
* @author MiCode Open Source Community
*/
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;
private static GTaskManager mInstance = null;
@ -127,14 +99,6 @@ public class GTaskManager {
mNidToGid = new HashMap<Long, String>();
}
/**
* 获取GTaskManager的单例实例
*
* 该方法采用同步机制，确保在多线程环境下只有一个GTaskManager实例
* 单例模式保证了全局只有一个同步管理器实例，避免了重复创建和资源浪费
*
* @return GTaskManager的单例实例
*/
public static synchronized GTaskManager getInstance() {
if (mInstance == null) {
mInstance = new GTaskManager();
@ -142,36 +106,11 @@ public class GTaskManager {
return mInstance;
}
/**
* 设置Activity上下文
*
* 该方法用于设置获取Google认证令牌所需的Activity上下文
*
* @param activity 上下文Activity，用于获取账户管理器和认证令牌
*/
public synchronized void setActivityContext(Activity activity) {
// used for getting authtoken
mActivity = activity;
}
/**
* 执行Google Tasks同步操作
*
* 该方法是同步的入口点，负责协调整个同步流程：
* 1. 登录Google Tasks服务
* 2. 初始化任务列表
* 3. 执行内容同步
* 4. 处理同步结果和错误
*
* @param context 上下文对象，用于获取内容解析器
* @param asyncTask 异步任务对象，用于发布同步进度
* @return 同步状态码：
* - STATE_SUCCESS：同步成功
* - STATE_NETWORK_ERROR：网络错误
* - STATE_INTERNAL_ERROR：内部错误
* - STATE_SYNC_IN_PROGRESS：同步已在进行中
* - STATE_SYNC_CANCELLED：同步已取消
*/
public int sync(Context context, GTaskASyncTask asyncTask) {
if (mSyncing) {
Log.d(TAG, "Sync is in progress");
@ -851,20 +790,10 @@ public class GTaskManager {
}
}
/**
* 获取当前同步使用的Google账户名
*
* @return 当前同步使用的Google账户名
*/
public String getSyncAccount() {
return GTaskClient.getInstance().getSyncAccount().name;
}
/**
* 取消正在进行的同步操作
*
* 设置取消标志，使同步过程在适当的时机停止
*/
public void cancelSync() {
mCancelled = true;
}

104
src/notes/gtask/remote/GTaskSyncService.java
Unescape View File

@ -23,66 +23,25 @@ import android.content.Intent;
import android.os.Bundle;
import android.os.IBinder;
/**
* GTaskSyncService类 - 继承自Android Service，用于管理Google Tasks同步服务
*
* 该服务负责处理Google Tasks的同步生命周期，包括启动同步、取消同步以及发送同步状态广播
* 它通过GTaskASyncTask在后台执行同步操作，并通过广播通知UI组件同步状态和进度
*
* @author MiCode Open Source Community
*/
public class GTaskSyncService extends Service {
/**
* 同步操作类型的Intent额外数据键名
*/
public final static String ACTION_STRING_NAME = "sync_action_type";
/**
* 同步操作类型：开始同步
*/
public final static int ACTION_START_SYNC = 0;
/**
* 同步操作类型：取消同步
*/
public final static int ACTION_CANCEL_SYNC = 1;
/**
* 同步操作类型：无效操作
*/
public final static int ACTION_INVALID = 2;
/**
* 同步服务广播的Action名称
*/
public final static String GTASK_SERVICE_BROADCAST_NAME = "net.micode.notes.gtask.remote.gtask_sync_service";
/**
* 广播中表示同步状态的额外数据键名
*/
public final static String GTASK_SERVICE_BROADCAST_IS_SYNCING = "isSyncing";
/**
* 广播中表示同步进度消息的额外数据键名
*/
public final static String GTASK_SERVICE_BROADCAST_PROGRESS_MSG = "progressMsg";
/**
* 当前正在执行的同步任务实例
*/
private static GTaskASyncTask mSyncTask = null;
/**
* 当前同步进度消息
*/
private static String mSyncProgress = "";
/**
* 开始同步操作
*
* 如果当前没有正在执行的同步任务，则创建新的GTaskASyncTask实例并执行同步
* 同步完成后会清理任务实例并停止服务
*/
private void startSync() {
if (mSyncTask == null) {
mSyncTask = new GTaskASyncTask(this, new GTaskASyncTask.OnCompleteListener() {
@ -97,11 +56,6 @@ public class GTaskSyncService extends Service {
}
}
/**
* 取消当前同步操作
*
* 如果当前有正在执行的同步任务，则调用其cancelSync方法取消同步
*/
private void cancelSync() {
if (mSyncTask != null) {
mSyncTask.cancelSync();
@ -113,16 +67,6 @@ public class GTaskSyncService extends Service {
mSyncTask = null;
}
/**
* 处理服务启动命令
*
* 根据Intent中携带的操作类型，执行对应的同步操作（开始或取消）
*
* @param intent 启动服务的Intent，包含操作类型
* @param flags 启动标志
* @param startId 服务启动ID
* @return 服务启动模式，此处返回START_STICKY表示服务被杀死后会自动重启
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Bundle bundle = intent.getExtras();
@ -142,11 +86,6 @@ public class GTaskSyncService extends Service {
return super.onStartCommand(intent, flags, startId);
}
/**
* 当系统内存不足时调用
*
* 在此方法中取消当前正在执行的同步任务，以释放系统资源
*/
@Override
public void onLowMemory() {
if (mSyncTask != null) {
@ -154,25 +93,10 @@ public class GTaskSyncService extends Service {
}
}
/**
* 绑定服务时调用
*
* 该服务不支持绑定，因此返回null
*
* @param intent 绑定服务的Intent
* @return 服务的IBinder接口，此处返回null
*/
public IBinder onBind(Intent intent) {
return null;
}
/**
* 发送同步状态广播
*
* 将当前同步状态和进度消息通过广播发送给所有监听该广播的组件
*
* @param msg 当前同步进度消息
*/
public void sendBroadcast(String msg) {
mSyncProgress = msg;
Intent intent = new Intent(GTASK_SERVICE_BROADCAST_NAME);
@ -181,13 +105,6 @@ public class GTaskSyncService extends Service {
sendBroadcast(intent);
}
/**
* 静态方法：启动同步服务
*
* 通过Activity上下文启动GTaskSyncService并发送开始同步的命令
*
* @param activity 用于启动服务的Activity上下文
*/
public static void startSync(Activity activity) {
GTaskManager.getInstance().setActivityContext(activity);
Intent intent = new Intent(activity, GTaskSyncService.class);
@ -195,37 +112,16 @@ public class GTaskSyncService extends Service {
activity.startService(intent);
}
/**
* 静态方法：取消同步服务
*
* 通过Context上下文启动GTaskSyncService并发送取消同步的命令
*
* @param context 用于启动服务的上下文
*/
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);
}
/**
* 静态方法：检查是否正在同步
*
* 判断当前是否有正在执行的同步任务
*
* @return true表示正在同步，false表示未同步
*/
public static boolean isSyncing() {
return mSyncTask != null;
}
/**
* 静态方法：获取当前同步进度消息
*
* 获取当前同步进度的字符串消息
*
* @return 当前同步进度消息
*/
public static String getProgressString() {
return mSyncProgress;
}

142
src/notes/model/Note.java
Unescape View File

@ -34,38 +34,12 @@ import net.micode.notes.data.Notes.TextNote;
import java.util.ArrayList;
/**
* Note类 - 表示应用中的笔记数据模型
*
* 该类是笔记应用的核心数据模型，用于封装笔记的基本信息和内容数据
* 支持文本笔记和通话笔记两种类型，提供了笔记的创建、更新和同步功能
* 采用ContentResolver与ContentProvider进行数据交互，实现数据的持久化存储
*
* @author MiCode Open Source Community
*/
public class Note {
/**
* 笔记基本信息的变更值
*/
private ContentValues mNoteDiffValues;
/**
* 笔记内容数据（文本和通话）
*/
private NoteData mNoteData;
/**
* 日志标签
*/
private static final String TAG = "Note";
/**
* 创建一个新的笔记ID并在数据库中插入新笔记
*
* 该方法会在数据库中创建一个新的笔记记录，并返回生成的笔记ID
* 新笔记会设置默认的创建时间、修改时间和类型
*
* @param context 上下文对象，用于获取ContentResolver
* @param folderId 笔记所属的文件夹ID
* @return 新创建的笔记ID
* @throws IllegalStateException 如果创建笔记失败
* Create a new note id for adding a new note to databases
*/
public static synchronized long getNewNoteId(Context context, long folderId) {
// Create a new note in the database
@ -91,92 +65,41 @@ public class Note {
return noteId;
}
/**
* 默认构造方法
*
* 初始化笔记的基本信息和内容数据对象
*/
public Note() {
mNoteDiffValues = new ContentValues();
mNoteData = new NoteData();
}
/**
* 设置笔记的基本信息值
*
* @param key 字段名
* @param value 字段值
*/
public void setNoteValue(String key, String value) {
mNoteDiffValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
/**
* 设置笔记的文本数据
*
* @param key 文本数据字段名
* @param value 文本数据字段值
*/
public void setTextData(String key, String value) {
mNoteData.setTextData(key, value);
}
/**
* 设置笔记文本数据的ID
*
* @param id 文本数据ID
*/
public void setTextDataId(long id) {
mNoteData.setTextDataId(id);
}
/**
* 获取笔记文本数据的ID
*
* @return 文本数据ID
*/
public long getTextDataId() {
return mNoteData.mTextDataId;
}
/**
* 设置笔记通话数据的ID
*
* @param id 通话数据ID
*/
public void setCallDataId(long id) {
mNoteData.setCallDataId(id);
}
/**
* 设置笔记的通话数据
*
* @param key 通话数据字段名
* @param value 通话数据字段值
*/
public void setCallData(String key, String value) {
mNoteData.setCallData(key, value);
}
/**
* 检查笔记是否在本地被修改
*
* @return true表示本地已修改，false表示未修改
*/
public boolean isLocalModified() {
return mNoteDiffValues.size() > 0 || mNoteData.isLocalModified();
}
/**
* 将笔记的本地修改同步到数据库
*
* @param context 上下文对象，用于获取ContentResolver
* @param noteId 笔记ID
* @return true表示同步成功，false表示同步失败
* @throws IllegalArgumentException 如果笔记ID无效
*/
public boolean syncNote(Context context, long noteId) {
if (noteId <= 0) {
throw new IllegalArgumentException("Wrong note id:" + noteId);
@ -207,43 +130,17 @@ public class Note {
return true;
}
/**
* NoteData类 - 表示笔记的内容数据（内部类）
*
* 该内部类用于封装笔记的内容数据，包括文本数据和通话数据
* 提供了数据的设置、修改检查和同步到ContentResolver的功能
*/
private class NoteData {
/**
* 文本数据的ID
*/
private long mTextDataId;
/**
* 文本数据的变更值
*/
private ContentValues mTextDataValues;
/**
* 通话数据的ID
*/
private long mCallDataId;
/**
* 通话数据的变更值
*/
private ContentValues mCallDataValues;
/**
* 日志标签
*/
private static final String TAG = "NoteData";
/**
* 默认构造方法
*
* 初始化文本数据和通话数据的内容值对象
*/
public NoteData() {
mTextDataValues = new ContentValues();
mCallDataValues = new ContentValues();
@ -251,21 +148,10 @@ public class Note {
mCallDataId = 0;
}
/**
* 检查内容数据是否在本地被修改
*
* @return true表示本地已修改，false表示未修改
*/
boolean isLocalModified() {
return mTextDataValues.size() > 0 || mCallDataValues.size() > 0;
}
/**
* 设置文本数据的ID
*
* @param id 文本数据ID
* @throws IllegalArgumentException 如果ID无效
*/
void setTextDataId(long id) {
if(id <= 0) {
throw new IllegalArgumentException("Text data id should larger than 0");
@ -273,12 +159,6 @@ public class Note {
mTextDataId = id;
}
/**
* 设置通话数据的ID
*
* @param id 通话数据ID
* @throws IllegalArgumentException 如果ID无效
*/
void setCallDataId(long id) {
if (id <= 0) {
throw new IllegalArgumentException("Call data id should larger than 0");
@ -286,38 +166,18 @@ public class Note {
mCallDataId = id;
}
/**
* 设置通话数据
*
* @param key 通话数据字段名
* @param value 通话数据字段值
*/
void setCallData(String key, String value) {
mCallDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
/**
* 设置文本数据
*
* @param key 文本数据字段名
* @param value 文本数据字段值
*/
void setTextData(String key, String value) {
mTextDataValues.put(key, value);
mNoteDiffValues.put(NoteColumns.LOCAL_MODIFIED, 1);
mNoteDiffValues.put(NoteColumns.MODIFIED_DATE, System.currentTimeMillis());
}
/**
* 将内容数据同步到ContentResolver
*
* @param context 上下文对象，用于获取ContentResolver
* @param noteId 所属笔记的ID
* @return 同步成功返回笔记URI，失败返回null
* @throws IllegalArgumentException 如果笔记ID无效
*/
Uri pushIntoContentResolver(Context context, long noteId) {
/**
* Check for safety

65
src/notes/model/WorkingNote.java
Unescape View File

@ -32,71 +32,34 @@ import net.micode.notes.data.Notes.TextNote;
import net.micode.notes.tool.ResourceParser.NoteBgResources;
/**
* WorkingNote类 - 表示正在编辑或使用中的笔记
*
* 该类是Note类的包装器，提供了更丰富的功能和更便捷的操作方式
* 用于处理笔记的创建、加载、保存、属性设置等操作，支持文本笔记和通话笔记
* 管理笔记的各种属性，如背景颜色、提醒时间、小部件信息等
*
* @author MiCode Open Source Community
*/
public class WorkingNote {
/**
* 内部封装的Note对象
*/
// Note for the working note
private Note mNote;
/**
* 笔记ID
*/
// Note Id
private long mNoteId;
/**
* 笔记内容
*/
// Note content
private String mContent;
/**
* 笔记模式（如普通模式、清单模式）
*/
// Note mode
private int mMode;
/**
* 提醒时间
*/
private long mAlertDate;
/**
* 修改时间
*/
private long mModifiedDate;
/**
* 背景颜色ID
*/
private int mBgColorId;
/**
* 小部件ID
*/
private int mWidgetId;
/**
* 小部件类型
*/
private int mWidgetType;
/**
* 所属文件夹ID
*/
private long mFolderId;
/**
* 上下文对象
*/
private Context mContext;
/**
* 日志标签
*/
private static final String TAG = "WorkingNote";
/**
* 是否已删除标志
*/
private boolean mIsDeleted;
/**
* 笔记设置变化监听器
*/
private NoteSettingChangedListener mNoteSettingStatusListener;
public static final String[] DATA_PROJECTION = new String[] {

2
src/notes/ui/NotesPreferenceActivity.java
Unescape View File

@ -92,7 +92,7 @@ public class NotesPreferenceActivity extends PreferenceActivity {
=======
filter.addAction(GTaskSyncService.GTASK_SERVICE_BROADCAST_NAME);
// 修复：兼容 Android 13+ 的广播注册方式
// ✅ 修复：兼容 Android 13+ 的广播注册方式（无需 if/else）
ContextCompat.registerReceiver(
this,
mReceiver,

Write Preview
Loading…
Cancel
Save