pjao9fvxr
/
Notes-Xiaomi
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

对部分类进行了注释分析 #8

Merged
pjao9fvxr merged 1 commits from zhouzexin_branch into master 3 weeks ago
Conversation 0 Commits 1 Files Changed 5
5 changed files with 368 additions and 1 deletions
Show Stats Download Patch File Download Diff File

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

@ -25,11 +25,22 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* 元数据类，继承自Task，用于存储任务相关的元信息
* 主要用于保存与远程Google Task相关联的本地任务元数据
*/
public class MetaData extends Task {
// 日志标签
private final static String TAG = MetaData.class.getSimpleName();
// 关联的Google Task ID
private String mRelatedGid = null;
/**
* 设置元数据信息
* @param gid Google Task ID
* @param metaInfo 元数据JSON对象
*/
public void setMeta(String gid, JSONObject metaInfo) {
try {
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
@ -40,15 +51,27 @@ public class MetaData extends Task {
setName(GTaskStringUtils.META_NOTE_NAME);
}
/**
* 获取关联的Google Task ID
* @return 关联的Google Task ID
*/
public String getRelatedGid() {
return mRelatedGid;
}
/**
* 判断元数据是否值得保存
* @return 如果元数据不为null则返回true
*/
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
/**
* 从远程JSON设置内容
* @param js 远程JSON对象
*/
@Override
public void setContentByRemoteJSON(JSONObject js) {
super.setContentByRemoteJSON(js);
@ -63,17 +86,33 @@ public class MetaData extends Task {
}
}
/**
* 从本地JSON设置内容，该方法不应被调用
* @param js 本地JSON对象
* @throws IllegalAccessError 总是抛出该异常
*/
@Override
public void setContentByLocalJSON(JSONObject js) {
// this function should not be called
throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
}
/**
* 从内容获取本地JSON，该方法不应被调用
* @return 本地JSON对象
* @throws IllegalAccessError 总是抛出该异常
*/
@Override
public JSONObject getLocalJSONFromContent() {
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");

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

@ -20,33 +20,53 @@ import android.database.Cursor;
import org.json.JSONObject;
/**
* 抽象同步节点类，定义了同步操作的基本结构和接口
* 是Task和TaskList的父类，用于处理本地与远程Google Tasks的同步
*/
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 Task唯一标识符
private String mGid;
// 节点名称
private String mName;
// 最后修改时间
private long mLastModified;
// 是否已删除
private boolean mDeleted;
/**
* 构造函数，初始化节点基本属性
*/
public Node() {
mGid = null;
mName = "";
@ -54,46 +74,105 @@ 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 远程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 同步操作类型
*/
public abstract int getSyncAction(Cursor c);
/**
* 设置Google Task唯一标识符
* @param gid Google Task 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 Task唯一标识符
* @return Google Task 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;
}

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

@ -35,42 +35,66 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* 数据库数据处理类，用于管理笔记的数据部分
* 提供与ContentResolver的交互，实现数据的创建、更新和提交
*/
public class SqlData {
// 日志标签
private static final String TAG = SqlData.class.getSimpleName();
// 无效ID常量
private static final int INVALID_ID = -99999;
// 数据查询投影数组
public static final String[] PROJECTION_DATA = new String[] {
DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
DataColumns.DATA3
};
// 投影数组中ID列的索引
public static final int DATA_ID_COLUMN = 0;
// 投影数组中MIME类型列的索引
public static final int DATA_MIME_TYPE_COLUMN = 1;
// 投影数组中内容列的索引
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;
// 是否为创建操作
private boolean mIsCreate;
// 数据ID
private long mDataId;
// 数据MIME类型
private String mDataMimeType;
// 数据内容
private String mDataContent;
// 数据内容DATA1字段
private long mDataContentData1;
// 数据内容DATA3字段
private String mDataContentData3;
// 差异数据值，用于记录需要更新的字段
private ContentValues mDiffDataValues;
/**
* 构造函数，创建新的数据对象
* @param context 上下文对象
*/
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
@ -82,6 +106,11 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 构造函数，从游标创建数据对象
* @param context 上下文对象
* @param c 数据库游标
*/
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
@ -89,6 +118,10 @@ public class SqlData {
mDiffDataValues = new ContentValues();
}
/**
* 从游标加载数据
* @param c 数据库游标
*/
private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN);
mDataMimeType = c.getString(DATA_MIME_TYPE_COLUMN);
@ -97,6 +130,11 @@ 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) {
@ -130,6 +168,11 @@ 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");
@ -144,6 +187,13 @@ 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) {
@ -183,6 +233,10 @@ public class SqlData {
mIsCreate = false;
}
/**
* 获取数据ID
* @return 数据ID
*/
public long getId() {
return mDataId;
}

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

@ -38,11 +38,18 @@ import org.json.JSONObject;
import java.util.ArrayList;
/**
* 数据库笔记处理类，用于管理笔记的完整数据结构
* 包括笔记基本信息和关联的数据内容，提供与ContentResolver的交互
*/
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,
@ -52,76 +59,115 @@ public class SqlNote {
NoteColumns.VERSION
};
// 投影数组中ID列的索引
public static final int ID_COLUMN = 0;
// 投影数组中提醒日期列的索引
public static final int ALERTED_DATE_COLUMN = 1;
// 投影数组中背景颜色ID列的索引
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;
// 投影数组中父ID列的索引
public static final int PARENT_ID_COLUMN = 7;
// 投影数组中摘要列的索引
public static final int SNIPPET_COLUMN = 8;
// 投影数组中类型列的索引
public static final int TYPE_COLUMN = 9;
// 投影数组中小组件ID列的索引
public static final int WIDGET_ID_COLUMN = 10;
// 投影数组中小组件类型列的索引
public static final int WIDGET_TYPE_COLUMN = 11;
// 投影数组中同步ID列的索引
public static final int SYNC_ID_COLUMN = 12;
// 投影数组中本地修改标记列的索引
public static final int LOCAL_MODIFIED_COLUMN = 13;
// 投影数组中原始父ID列的索引
public static final int ORIGIN_PARENT_ID_COLUMN = 14;
// 投影数组中Google Task ID列的索引
public static final int GTASK_ID_COLUMN = 15;
// 投影数组中版本列的索引
public static final int VERSION_COLUMN = 16;
// 上下文对象
private Context mContext;
// 内容解析器
private ContentResolver mContentResolver;
// 是否为创建操作
private boolean mIsCreate;
// 笔记ID
private long mId;
// 提醒日期
private long mAlertDate;
// 背景颜色ID
private int mBgColorId;
// 创建日期
private long mCreatedDate;
// 是否有附件（0：无，1：有）
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;
// 数据内容列表
private ArrayList<SqlData> mDataList;
/**
* 构造函数，创建新的笔记对象
* @param context 上下文对象
*/
public SqlNote(Context context) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -143,6 +189,11 @@ public class SqlNote {
mDataList = new ArrayList<SqlData>();
}
/**
* 构造函数，从游标创建笔记对象
* @param context 上下文对象
* @param c 数据库游标
*/
public SqlNote(Context context, Cursor c) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -154,6 +205,11 @@ public class SqlNote {
mDiffNoteValues = new ContentValues();
}
/**
* 构造函数，通过ID加载笔记对象
* @param context 上下文对象
* @param id 笔记ID
*/
public SqlNote(Context context, long id) {
mContext = context;
mContentResolver = context.getContentResolver();
@ -163,9 +219,12 @@ public class SqlNote {
if (mType == Notes.TYPE_NOTE)
loadDataContent();
mDiffNoteValues = new ContentValues();
}
/**
* 通过ID从数据库加载笔记数据
* @param id 笔记ID
*/
private void loadFromCursor(long id) {
Cursor c = null;
try {
@ -185,6 +244,10 @@ public class SqlNote {
}
}
/**
* 从数据库游标加载笔记数据
* @param c 数据库查询游标
*/
private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -200,6 +263,9 @@ public class SqlNote {
mVersion = c.getLong(VERSION_COLUMN);
}
/**
* 加载笔记的关联数据内容
*/
private void loadDataContent() {
Cursor c = null;
mDataList.clear();
@ -226,6 +292,11 @@ public class SqlNote {
}
}
/**
* 设置笔记内容，从JSON对象中解析数据
* @param js 包含笔记信息的JSON对象
* @return 操作是否成功
*/
public boolean setContent(JSONObject js) {
try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
@ -359,6 +430,10 @@ public class SqlNote {
return true;
}
/**
* 获取笔记内容，转换为JSON对象
* @return 包含笔记信息的JSON对象，若未创建则返回null
*/
public JSONObject getContent() {
try {
JSONObject js = new JSONObject();
@ -407,39 +482,76 @@ public class SqlNote {
return null;
}
/**
* 设置笔记的父文件夹ID
* @param id 父文件夹ID
*/
public void setParentId(long id) {
mParentId = id;
mDiffNoteValues.put(NoteColumns.PARENT_ID, id);
}
/**
* 设置Google Task ID
* @param gid Google Task 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);
}
/**
* 重置本地修改标记
*/
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)) {

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

@ -32,19 +32,32 @@ import org.json.JSONException;
import org.json.JSONObject;
/**
* 表示Google Tasks中的任务项，继承自Node类
* 用于管理任务的各种属性和操作，包括创建、更新、同步等功能
*/
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;
@ -54,6 +67,12 @@ 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();
@ -103,6 +122,12 @@ 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();
@ -135,6 +160,11 @@ public class Task extends Node {
return js;
}
/**
* 根据远程JSON对象设置任务内容
* @param js 远程JSON对象
* @throws ActionFailureException 解析JSON对象失败时抛出
*/
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
try {
@ -175,6 +205,10 @@ 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)) {
@ -204,6 +238,10 @@ public class Task extends Node {
}
}
/**
* 从任务内容生成本地JSON对象
* @return 本地JSON对象，若生成失败则返回null
*/
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
@ -247,6 +285,10 @@ public class Task extends Node {
}
}
/**
* 设置任务的元数据
* @param metaData 元数据对象
*/
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
try {
@ -258,6 +300,11 @@ public class Task extends Node {
}
}
/**
* 获取同步操作类型
* @param c 数据库游标
* @return 同步操作类型（SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_REMOTE等）
*/
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
@ -311,39 +358,75 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
/**
* 判断任务是否值得保存
* @return 是否值得保存
*/
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;
}

Write Preview
Loading…
Cancel
Save