pbf5wpevj
/
Notes-master
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

0518

Browse Source
ZhengLiJie_branch
zlj 3 months ago
parent 94767859bc
commit 1490924c8c
5 changed files with 338 additions and 105 deletions
Show Stats Download Patch File Download Diff File

70
src/net/micode/notes/gtask/data/Node.java
Unescape View File

@ -19,8 +19,21 @@ package net.micode.notes.gtask.data;
import android.database.Cursor; import android.database.Cursor;
import org.json.JSONObject; import org.json.JSONObject;
/**
* Node 是一个抽象类，作为数据节点的基类，用于同步本地和远程数据。
* 它定义了通用的同步操作和字段，并提供了需要子类实现的抽象方法。
*/
public abstract class Node { public abstract class Node {
/**
* 同步动作类型常量，表示不同场景下的同步操作：
* - NONE: 无需同步
* - ADD_REMOTE/LOCAL: 添加操作（远程/本地）
* - DEL_REMOTE/LOCAL: 删除操作（远程/本地）
* - UPDATE_REMOTE/LOCAL: 更新操作（远程/本地）
* - UPDATE_CONFLICT: 数据冲突
* - ERROR: 同步错误
*/
public static final int SYNC_ACTION_NONE = 0; public static final int SYNC_ACTION_NONE = 0;
public static final int SYNC_ACTION_ADD_REMOTE = 1; public static final int SYNC_ACTION_ADD_REMOTE = 1;
@ -38,34 +51,75 @@ public abstract class Node {
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
public static final int SYNC_ACTION_ERROR = 8; public static final int SYNC_ACTION_ERROR = 8;
/** 节点在远程服务器上的唯一标识符 */
private String mGid; private String mGid;
/** 节点名称 */
private String mName; private String mName;
/** 最后修改时间戳 */
private long mLastModified; private long mLastModified;
/** 是否被标记为删除 */
private boolean mDeleted; private boolean mDeleted;
/**
* 默认构造函数，初始化节点的基本属性值。
*/
public Node() { public Node() {
mGid = null; mGid = null;
mName = ""; mName = "";
mLastModified = 0; mLastModified = 0;
mDeleted = false; mDeleted = false;
} }
/**
* 获取创建操作的 JSON 对象，供同步使用。
*
* @param actionId 操作 ID
* @return 创建操作的 JSON 对象
*/
public abstract JSONObject getCreateAction(int actionId); public abstract JSONObject getCreateAction(int actionId);
/**
* 获取更新操作的 JSON 对象，供同步使用。
*
* @param actionId 操作 ID
* @return 更新操作的 JSON 对象
*/
public abstract JSONObject getUpdateAction(int actionId); public abstract JSONObject getUpdateAction(int actionId);
/**
* 从远程 JSON 设置节点内容。
*
* @param js 远程 JSON 数据
*/
public abstract void setContentByRemoteJSON(JSONObject js); public abstract void setContentByRemoteJSON(JSONObject js);
/**
* 从本地 JSON 设置节点内容。
*
* @param js 本地 JSON 数据
*/
public abstract void setContentByLocalJSON(JSONObject js); public abstract void setContentByLocalJSON(JSONObject js);
/**
* 将当前节点内容转换为本地 JSON 数据。
*
* @return 本地 JSON 数据
*/
public abstract JSONObject getLocalJSONFromContent(); public abstract JSONObject getLocalJSONFromContent();
/**
* 根据数据库游标获取同步操作类型。
*
* @param c 数据库游标
* @return 同步操作类型
*/
public abstract int getSyncAction(Cursor c); public abstract int getSyncAction(Cursor c);
/**
* 设置远程唯一标识符 GID。
*
* @param gid 新的 GID 值
*/
public void setGid(String gid) { public void setGid(String gid) {
this.mGid = gid; this.mGid = gid;
} }
@ -81,7 +135,11 @@ public abstract class Node {
public void setDeleted(boolean deleted) { public void setDeleted(boolean deleted) {
this.mDeleted = deleted; this.mDeleted = deleted;
} }
/**
* 获取远程唯一标识符 GID。
*
* @return mGid 当前节点的 GID
*/
public String getGid() { public String getGid() {
return this.mGid; return this.mGid;
} }

53
src/net/micode/notes/gtask/data/SqlData.java
Unescape View File

@ -33,18 +33,24 @@ import net.micode.notes.gtask.exception.ActionFailureException;
import org.json.JSONException; import org.json.JSONException;
import org.json.JSONObject; import org.json.JSONObject;
/**
* SqlData 是用于操作 SQLite 数据库中的数据对象，支持从 JSON 设置内容、提交更改到数据库等功能。
* 它主要用于本地与远程数据同步时的数据持久化操作。
*/
public class SqlData { public class SqlData {
/** 日志标签，标识当前类名 */
private static final String TAG = SqlData.class.getSimpleName(); private static final String TAG = SqlData.class.getSimpleName();
/** 表示无效的 ID 值 */
private static final int INVALID_ID = -99999; private static final int INVALID_ID = -99999;
/** 查询语句中使用的列投影 */
public static final String[] PROJECTION_DATA = new String[] { public static final String[] PROJECTION_DATA = new String[] {
DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1, DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
DataColumns.DATA3 DataColumns.DATA3
}; };
/** 列索引常量 */
public static final int DATA_ID_COLUMN = 0; public static final int DATA_ID_COLUMN = 0;
public static final int DATA_MIME_TYPE_COLUMN = 1; public static final int DATA_MIME_TYPE_COLUMN = 1;
@ -55,22 +61,34 @@ public class SqlData {
public static final int DATA_CONTENT_DATA_3_COLUMN = 4; public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
/** 内容解析器，用于访问 ContentProvider */
private ContentResolver mContentResolver; private ContentResolver mContentResolver;
/** 是否是新建的数据项 */
private boolean mIsCreate; private boolean mIsCreate;
/** 数据项 ID */
private long mDataId; private long mDataId;
/** 数据项 MIME 类型 */
private String mDataMimeType; private String mDataMimeType;
/** 数据内容 */
private String mDataContent; private String mDataContent;
/** 数据字段 DATA1 的值 */
private long mDataContentData1; private long mDataContentData1;
/** 数据字段 DATA3 的值 */
private String mDataContentData3; private String mDataContentData3;
/** 存储差异内容的 ContentValues 对象 */
private ContentValues mDiffDataValues; private ContentValues mDiffDataValues;
/**
* 创建一个新的 SqlData 实例，用于插入新数据。
*
* @param context 上下文对象
*/
public SqlData(Context context) { public SqlData(Context context) {
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
mIsCreate = true; mIsCreate = true;
@ -81,7 +99,12 @@ public class SqlData {
mDataContentData3 = ""; mDataContentData3 = "";
mDiffDataValues = new ContentValues(); mDiffDataValues = new ContentValues();
} }
/**
* 从游标创建一个 SqlData 实例，用于更新已有数据。
*
* @param context 上下文对象
* @param c 数据库游标
*/
public SqlData(Context context, Cursor c) { public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
mIsCreate = false; mIsCreate = false;
@ -96,7 +119,12 @@ public class SqlData {
mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN); mDataContentData1 = c.getLong(DATA_CONTENT_DATA_1_COLUMN);
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN); mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
} }
/**
* 从 JSON 对象加载数据到当前 SqlData 实例。
*
* @param js JSON 数据源
* @throws JSONException 如果解析失败
*/
public void setContent(JSONObject js) throws JSONException { public void setContent(JSONObject js) throws JSONException {
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID; long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) { if (mIsCreate || mDataId != dataId) {
@ -129,7 +157,12 @@ public class SqlData {
} }
mDataContentData3 = dataContentData3; mDataContentData3 = dataContentData3;
} }
/**
* 将当前 SqlData 的内容转换为 JSON 对象。
*
* @return 包含数据的 JSON 对象
* @throws JSONException 如果转换失败
*/
public JSONObject getContent() throws JSONException { public JSONObject getContent() throws JSONException {
if (mIsCreate) { if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet"); Log.e(TAG, "it seems that we haven't created this in database yet");
@ -143,7 +176,13 @@ public class SqlData {
js.put(DataColumns.DATA3, mDataContentData3); js.put(DataColumns.DATA3, mDataContentData3);
return js; return js;
} }
/**
* 提交数据变更到数据库。
*
* @param noteId 笔记 ID
* @param validateVersion 是否验证版本号
* @param version 版本号
*/
public void commit(long noteId, boolean validateVersion, long version) { public void commit(long noteId, boolean validateVersion, long version) {
if (mIsCreate) { if (mIsCreate) {

58
src/net/micode/notes/gtask/data/SqlNote.java
Unescape View File

@ -37,12 +37,18 @@ import org.json.JSONObject;
import java.util.ArrayList; import java.util.ArrayList;
/**
* SqlNote 是用于操作 SQLite 数据库中的笔记数据对象，支持从 JSON 设置内容、提交更改到数据库等功能。
* 它主要用于本地与远程数据同步时的数据持久化操作。
*/
public class SqlNote { public class SqlNote {
/** 日志标签，标识当前类名 */
private static final String TAG = SqlNote.class.getSimpleName(); private static final String TAG = SqlNote.class.getSimpleName();
/** 表示无效的 ID 值 */
private static final int INVALID_ID = -99999; private static final int INVALID_ID = -99999;
/** 查询语句中使用的列投影数组 */
public static final String[] PROJECTION_NOTE = new String[] { public static final String[] PROJECTION_NOTE = new String[] {
NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID, NoteColumns.ID, NoteColumns.ALERTED_DATE, NoteColumns.BG_COLOR_ID,
NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE, NoteColumns.CREATED_DATE, NoteColumns.HAS_ATTACHMENT, NoteColumns.MODIFIED_DATE,
@ -86,42 +92,64 @@ public class SqlNote {
public static final int VERSION_COLUMN = 16; public static final int VERSION_COLUMN = 16;
/** 上下文对象 */
private Context mContext; private Context mContext;
/** 内容解析器，用于访问 ContentProvider */
private ContentResolver mContentResolver; private ContentResolver mContentResolver;
/** 是否是新建的笔记项 */
private boolean mIsCreate; private boolean mIsCreate;
/** 笔记 ID */
private long mId; private long mId;
/** 警告时间 */
private long mAlertDate; private long mAlertDate;
/** 背景颜色 ID */
private int mBgColorId; private int mBgColorId;
/** 创建时间 */
private long mCreatedDate; private long mCreatedDate;
/** 是否有附件 */
private int mHasAttachment; private int mHasAttachment;
/** 最后修改时间 */
private long mModifiedDate; private long mModifiedDate;
/** 父节点 ID */
private long mParentId; private long mParentId;
/** 摘要内容 */
private String mSnippet; private String mSnippet;
/** 类型（如普通笔记、文件夹等） */
private int mType; private int mType;
/** 小部件 ID */
private int mWidgetId; private int mWidgetId;
/** 小部件类型 */
private int mWidgetType; private int mWidgetType;
/** 原始父节点 ID */
private long mOriginParent; private long mOriginParent;
/** 版本号，用于同步控制 */
private long mVersion; private long mVersion;
/** 存储差异内容的 ContentValues 对象 */
private ContentValues mDiffNoteValues; private ContentValues mDiffNoteValues;
/** 当前笔记包含的数据列表 */
private ArrayList<SqlData> mDataList; private ArrayList<SqlData> mDataList;
/**
* 创建一个新的 SqlNote 实例，用于插入新笔记。
*
* @param context 上下文对象
*/
public SqlNote(Context context) { public SqlNote(Context context) {
mContext = context; mContext = context;
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
@ -142,7 +170,12 @@ public class SqlNote {
mDiffNoteValues = new ContentValues(); mDiffNoteValues = new ContentValues();
mDataList = new ArrayList<SqlData>(); mDataList = new ArrayList<SqlData>();
} }
/**
* 从游标创建一个 SqlNote 实例，用于更新已有笔记。
*
* @param context 上下文对象
* @param c 数据库游标
*/
public SqlNote(Context context, Cursor c) { public SqlNote(Context context, Cursor c) {
mContext = context; mContext = context;
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
@ -165,7 +198,11 @@ public class SqlNote {
mDiffNoteValues = new ContentValues(); mDiffNoteValues = new ContentValues();
} }
/**
* 从游标加载笔记数据。
*
* @param c 数据库游标
*/
private void loadFromCursor(long id) { private void loadFromCursor(long id) {
Cursor c = null; Cursor c = null;
try { try {
@ -184,7 +221,11 @@ public class SqlNote {
c.close(); c.close();
} }
} }
/**
* 从指定 ID 加载笔记数据。
*
* @param id 笔记 ID
*/
private void loadFromCursor(Cursor c) { private void loadFromCursor(Cursor c) {
mId = c.getLong(ID_COLUMN); mId = c.getLong(ID_COLUMN);
mAlertDate = c.getLong(ALERTED_DATE_COLUMN); mAlertDate = c.getLong(ALERTED_DATE_COLUMN);
@ -225,7 +266,12 @@ public class SqlNote {
c.close(); c.close();
} }
} }
/**
* 从 JSON 设置笔记内容，包括元信息和子数据。
*
* @param js JSON 数据源
* @return 是否设置成功
*/
public boolean setContent(JSONObject js) { public boolean setContent(JSONObject js) {
try { try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);

43
src/net/micode/notes/gtask/data/Task.java
Unescape View File

@ -30,21 +30,30 @@ import net.micode.notes.tool.GTaskStringUtils;
import org.json.JSONArray; import org.json.JSONArray;
import org.json.JSONException; import org.json.JSONException;
import org.json.JSONObject; import org.json.JSONObject;
/**
* Task 是 Node 的子类，表示一个任务条目，用于同步本地和远程的任务数据。
* 它实现了 Node 中定义的抽象方法，并提供了与任务相关的功能如完成状态、备注等。
*/
public class Task extends Node { public class Task extends Node {
/** 日志标签，标识当前类名 */
private static final String TAG = Task.class.getSimpleName(); private static final String TAG = Task.class.getSimpleName();
/** 是否已完成 */
private boolean mCompleted; private boolean mCompleted;
/** 备注信息 */
private String mNotes; private String mNotes;
/** 元数据信息（JSON 格式） */
private JSONObject mMetaInfo; private JSONObject mMetaInfo;
/** 上一个同级任务 */
private Task mPriorSibling; private Task mPriorSibling;
/** 父任务列表 */
private TaskList mParent; private TaskList mParent;
/**
* 创建一个新的 Task 实例，初始化默认值。
*/
public Task() { public Task() {
super(); super();
mCompleted = false; mCompleted = false;
@ -53,7 +62,12 @@ public class Task extends Node {
mParent = null; mParent = null;
mMetaInfo = null; mMetaInfo = null;
} }
/**
* 生成创建任务的远程同步操作 JSON 对象。
*
* @param actionId 操作 ID
* @return 包含创建操作信息的 JSON 对象
*/
public JSONObject getCreateAction(int actionId) { public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
@ -102,7 +116,12 @@ public class Task extends Node {
return js; return js;
} }
/**
* 生成更新任务的远程同步操作 JSON 对象。
*
* @param actionId 操作 ID
* @return 包含更新操作信息的 JSON 对象
*/
public JSONObject getUpdateAction(int actionId) { public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
@ -257,6 +276,12 @@ public class Task extends Node {
} }
} }
} }
/**
* 根据游标判断当前任务需要执行的同步动作类型。
*
* @param c 数据库游标
* @return 同步动作类型（SYNC_ACTION_XXX）
*/
public int getSyncAction(Cursor c) { public int getSyncAction(Cursor c) {
try { try {
@ -310,7 +335,11 @@ public class Task extends Node {
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
/**
* 判断该任务是否值得保存（非空任务）。
*
* @return 是否值得保存
*/
public boolean isWorthSaving() { public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0); || (getNotes() != null && getNotes().trim().length() > 0);

87
src/net/micode/notes/gtask/data/TaskList.java
Unescape View File

@ -29,14 +29,21 @@ import org.json.JSONObject;
import java.util.ArrayList; import java.util.ArrayList;
/**
* TaskList 是 Node 的子类，表示一个任务列表（即任务组），用于同步本地和远程的任务列表数据。
* 它管理一组 Task 子项，并提供了添加、删除、移动任务的方法。
*/
public class TaskList extends Node { public class TaskList extends Node {
/** 日志标签，标识当前类名 */
private static final String TAG = TaskList.class.getSimpleName(); private static final String TAG = TaskList.class.getSimpleName();
/** 列表在远程服务器上的索引位置 */
private int mIndex; private int mIndex;
/** 当前任务列表中的子任务集合 */
private ArrayList<Task> mChildren; private ArrayList<Task> mChildren;
/**
* 创建一个新的 TaskList 实例，初始化子任务列表和索引。
*/
public TaskList() { public TaskList() {
super(); super();
mChildren = new ArrayList<Task>(); mChildren = new ArrayList<Task>();
@ -73,7 +80,12 @@ public class TaskList extends Node {
return js; return js;
} }
/**
* 生成更新任务列表的远程同步操作 JSON 对象。
*
* @param actionId 操作 ID
* @return 包含更新操作信息的 JSON 对象
*/
public JSONObject getUpdateAction(int actionId) { public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
@ -102,7 +114,11 @@ public class TaskList extends Node {
return js; return js;
} }
/**
* 从远程 JSON 设置任务列表内容（如名称、ID、最后修改时间等）。
*
* @param js 远程 JSON 数据
*/
public void setContentByRemoteJSON(JSONObject js) { public void setContentByRemoteJSON(JSONObject js) {
if (js != null) { if (js != null) {
try { try {
@ -128,7 +144,11 @@ public class TaskList extends Node {
} }
} }
} }
/**
* 从本地 JSON 设置任务列表内容（通常从数据库加载）。
*
* @param js 本地 JSON 数据
*/
public void setContentByLocalJSON(JSONObject js) { public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) { if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
@ -156,7 +176,11 @@ public class TaskList extends Node {
e.printStackTrace(); e.printStackTrace();
} }
} }
/**
* 将当前任务列表内容转换为本地 JSON 格式，用于存储或同步。
*
* @return 包含任务列表内容的 JSON 对象
*/
public JSONObject getLocalJSONFromContent() { public JSONObject getLocalJSONFromContent() {
try { try {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
@ -182,7 +206,12 @@ public class TaskList extends Node {
return null; return null;
} }
} }
/**
* 根据游标判断当前任务列表需要执行的同步动作类型。
*
* @param c 数据库游标
* @return 同步动作类型（SYNC_ACTION_XXX）
*/
public int getSyncAction(Cursor c) { public int getSyncAction(Cursor c) {
try { try {
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
@ -219,7 +248,12 @@ public class TaskList extends Node {
public int getChildTaskCount() { public int getChildTaskCount() {
return mChildren.size(); return mChildren.size();
} }
/**
* 添加一个子任务到任务列表末尾，并设置其父级和前一兄弟节点。
*
* @param task 要添加的任务
* @return 是否成功添加
*/
public boolean addChildTask(Task task) { public boolean addChildTask(Task task) {
boolean ret = false; boolean ret = false;
if (task != null && !mChildren.contains(task)) { if (task != null && !mChildren.contains(task)) {
@ -233,7 +267,13 @@ public class TaskList extends Node {
} }
return ret; return ret;
} }
/**
* 在指定位置插入一个子任务，并调整兄弟节点关系。
*
* @param task 要添加的任务
* @param index 插入的位置
* @return 是否成功插入
*/
public boolean addChildTask(Task task, int index) { public boolean addChildTask(Task task, int index) {
if (index < 0 || index > mChildren.size()) { if (index < 0 || index > mChildren.size()) {
Log.e(TAG, "add child task: invalid index"); Log.e(TAG, "add child task: invalid index");
@ -280,7 +320,13 @@ public class TaskList extends Node {
} }
return ret; return ret;
} }
/**
* 将指定任务移动到新的位置。
*
* @param task 要移动的任务
* @param index 新的位置
* @return 是否成功移动
*/
public boolean moveChildTask(Task task, int index) { public boolean moveChildTask(Task task, int index) {
if (index < 0 || index >= mChildren.size()) { if (index < 0 || index >= mChildren.size()) {
@ -308,11 +354,21 @@ public class TaskList extends Node {
} }
return null; return null;
} }
/**
* 获取指定任务在子任务列表中的索引。
*
* @param task 子任务
* @return 索引位置，若未找到则返回 -1
*/
public int getChildTaskIndex(Task task) { public int getChildTaskIndex(Task task) {
return mChildren.indexOf(task); return mChildren.indexOf(task);
} }
/**
* 根据索引获取子任务。
*
* @param index 索引位置
* @return 子任务对象，若索引无效则返回 null
*/
public Task getChildTaskByIndex(int index) { public Task getChildTaskByIndex(int index) {
if (index < 0 || index >= mChildren.size()) { if (index < 0 || index >= mChildren.size()) {
Log.e(TAG, "getTaskByIndex: invalid index"); Log.e(TAG, "getTaskByIndex: invalid index");
@ -321,6 +377,11 @@ public class TaskList extends Node {
return mChildren.get(index); return mChildren.get(index);
} }
/**
* 获取所有子任务的列表。
*
* @return 子任务集合
*/
public Task getChilTaskByGid(String gid) { public Task getChilTaskByGid(String gid) {
for (Task task : mChildren) { for (Task task : mChildren) {
if (task.getGid().equals(gid)) if (task.getGid().equals(gid))

Write Preview
Loading…
Cancel
Save