pwvq3bt4r
/
MInote
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1

Browse Source
sun_branch
碧阳的帕克 3 months ago
parent 14329c4ada
commit 8333793ef2
3 changed files with 215 additions and 74 deletions
Show Stats Download Patch File Download Diff File

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

@ -24,34 +24,61 @@ import net.micode.notes.tool.GTaskStringUtils;
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 {
// 将关联的Google Task ID添加到元数据中
metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
} catch (JSONException e) {
Log.e(TAG, "failed to put related gid");
}
// 将元数据JSON对象转换为字符串并设置为notes
setNotes(metaInfo.toString());
// 设置元数据的名称
setName(GTaskStringUtils.META_NOTE_NAME);
}
/**
* 获取关联的Google Task ID
* @return 关联的Google Task ID
*/
public String getRelatedGid() {
return mRelatedGid;
}
/**
* 判断是否需要保存
* @return 如果notes不为null则返回true，否则返回false
*/
@Override
public boolean isWorthSaving() {
return getNotes() != null;
}
/**
* 根据远程JSON数据设置内容
* @param js 包含远程数据的JSON对象
*/
@Override
public void setContentByRemoteJSON(JSONObject js) {
// 调用父类方法设置基本内容
super.setContentByRemoteJSON(js);
// 如果notes不为空，尝试解析其中的关联Google Task ID
if (getNotes() != null) {
try {
JSONObject metaInfo = new JSONObject(getNotes().trim());
@ -63,20 +90,35 @@ 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对象（不应被调用）
* @throws IllegalAccessError 总是抛出此异常
*/
@Override
public JSONObject getLocalJSONFromContent() {
// 此方法不应被调用，因为元数据不存储本地内容
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
}
/**
* 获取同步操作（不应被调用）
* @param c 数据库游标
* @throws IllegalAccessError 总是抛出此异常
*/
@Override
public int getSyncAction(Cursor c) {
// 此方法不应被调用，因为元数据不需要同步操作
throw new IllegalAccessError("MetaData:getSyncAction should not be called");
}
}
}

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

@ -20,33 +20,31 @@ import android.database.Cursor;
import org.json.JSONObject;
/**
* 抽象节点类，表示同步任务中的基本节点结构
* 定义了同步操作的基本行为和节点通用属性
*/
public abstract class Node {
public static final int SYNC_ACTION_NONE = 0;
public static final int SYNC_ACTION_ADD_REMOTE = 1;
public static final int SYNC_ACTION_ADD_LOCAL = 2;
public static final int SYNC_ACTION_DEL_REMOTE = 3;
public static final int SYNC_ACTION_DEL_LOCAL = 4;
public static final int SYNC_ACTION_UPDATE_REMOTE = 5;
public static final int SYNC_ACTION_UPDATE_LOCAL = 6;
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;
public static final int SYNC_ACTION_ERROR = 8;
private String mGid;
private String mName;
private long mLastModified;
private boolean mDeleted;
// 同步操作常量定义
public static final int SYNC_ACTION_NONE = 0; // 无同步操作
public static final int SYNC_ACTION_ADD_REMOTE = 1; // 添加远程节点
public static final int SYNC_ACTION_ADD_LOCAL = 2; // 添加本地节点
public static final int SYNC_ACTION_DEL_REMOTE = 3; // 删除远程节点
public static final int SYNC_ACTION_DEL_LOCAL = 4; // 删除本地节点
public static final int SYNC_ACTION_UPDATE_REMOTE = 5; // 更新远程节点
public static final int SYNC_ACTION_UPDATE_LOCAL = 6; // 更新本地节点
public static final int SYNC_ACTION_UPDATE_CONFLICT = 7; // 更新冲突
public static final int SYNC_ACTION_ERROR = 8; // 同步错误
// 节点属性
private String mGid; // 全局唯一标识符
private String mName; // 节点名称
private long mLastModified; // 最后修改时间戳
private boolean mDeleted; // 删除标记
/**
* 构造函数，初始化节点属性
*/
public Node() {
mGid = null;
mName = "";
@ -54,48 +52,108 @@ 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);
// 以下是属性的getter和setter方法
/**
* 设置全局唯一标识符
* @param gid 全局唯一标识符
*/
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;
}
/**
* 获取全局唯一标识符
* @return 全局唯一标识符
*/
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;
}
}
}

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

@ -34,54 +34,60 @@ import net.micode.notes.gtask.exception.ActionFailureException;
import org.json.JSONException;
import org.json.JSONObject;
/**
* 数据库数据操作类，负责Note数据的CRUD操作
* 封装了对SQLite数据库的访问逻辑
*/
public class SqlData {
private static final String TAG = SqlData.class.getSimpleName();
private static final String TAG = SqlData.class.getSimpleName(); // 日志标签
private static final int INVALID_ID = -99999;
private static final int INVALID_ID = -99999; // 无效ID标识
// 数据列投影定义，用于查询操作
public static final String[] PROJECTION_DATA = new String[] {
DataColumns.ID, DataColumns.MIME_TYPE, DataColumns.CONTENT, DataColumns.DATA1,
DataColumns.DATA3
DataColumns.ID, // 0: 数据ID
DataColumns.MIME_TYPE, // 1: MIME类型
DataColumns.CONTENT, // 2: 内容
DataColumns.DATA1, // 3: 数据字段1
DataColumns.DATA3 // 4: 数据字段3
};
public static final int DATA_ID_COLUMN = 0;
public static final int DATA_MIME_TYPE_COLUMN = 1;
public static final int DATA_CONTENT_COLUMN = 2;
public static final int DATA_CONTENT_DATA_1_COLUMN = 3;
public static final int DATA_CONTENT_DATA_3_COLUMN = 4;
private ContentResolver mContentResolver;
private boolean mIsCreate;
private long mDataId;
private String mDataMimeType;
private String mDataContent;
private long mDataContentData1;
private String mDataContentData3;
private ContentValues mDiffDataValues;
// 列索引常量定义
public static final int DATA_ID_COLUMN = 0; // ID列索引
public static final int DATA_MIME_TYPE_COLUMN = 1; // MIME类型列索引
public static final int DATA_CONTENT_COLUMN = 2; // 内容列索引
public static final int DATA_CONTENT_DATA_1_COLUMN = 3; // 数据字段1列索引
public static final int DATA_CONTENT_DATA_3_COLUMN = 4; // 数据字段3列索引
private ContentResolver mContentResolver; // 内容解析器，用于访问ContentProvider
private boolean mIsCreate; // 是否为新创建记录标志
private long mDataId; // 数据ID
private String mDataMimeType; // MIME类型
private String mDataContent; // 内容数据
private long mDataContentData1; // 数据字段1
private String mDataContentData3; // 数据字段3
private ContentValues mDiffDataValues; // 存储差异数据的键值对
/**
* 构造函数，用于创建新记录
* @param context 上下文对象
*/
public SqlData(Context context) {
mContentResolver = context.getContentResolver();
mIsCreate = true;
mDataId = INVALID_ID;
mDataMimeType = DataConstants.NOTE;
mDataMimeType = DataConstants.NOTE; // 默认MIME类型为NOTE
mDataContent = "";
mDataContentData1 = 0;
mDataContentData3 = "";
mDiffDataValues = new ContentValues();
}
/**
* 构造函数，从游标加载已有记录
* @param context 上下文对象
* @param c 数据库游标，包含已有记录数据
*/
public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver();
mIsCreate = false;
@ -89,6 +95,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,13 +107,20 @@ public class SqlData {
mDataContentData3 = c.getString(DATA_CONTENT_DATA_3_COLUMN);
}
/**
* 设置内容数据
* @param js 包含数据的JSON对象
* @throws JSONException JSON解析异常
*/
public void setContent(JSONObject js) throws JSONException {
// 设置ID字段
long dataId = js.has(DataColumns.ID) ? js.getLong(DataColumns.ID) : INVALID_ID;
if (mIsCreate || mDataId != dataId) {
mDiffDataValues.put(DataColumns.ID, dataId);
}
mDataId = dataId;
// 设置MIME类型字段
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE;
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
@ -111,18 +128,21 @@ public class SqlData {
}
mDataMimeType = dataMimeType;
// 设置内容字段
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
if (mIsCreate || !mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent);
}
mDataContent = dataContent;
// 设置数据字段1
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
}
mDataContentData1 = dataContentData1;
// 设置数据字段3
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
@ -130,6 +150,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,9 +169,15 @@ public class SqlData {
return js;
}
/**
* 提交数据到数据库
* @param noteId 关联的Note ID
* @param validateVersion 是否验证版本
* @param version 版本号
*/
public void commit(long noteId, boolean validateVersion, long version) {
if (mIsCreate) {
// 创建新记录
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID);
}
@ -154,24 +185,29 @@ public class SqlData {
mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try {
// 从返回的URI中解析出新记录的ID
mDataId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed");
}
} else {
// 更新现有记录
if (mDiffDataValues.size() > 0) {
int result = 0;
if (!validateVersion) {
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
// 不验证版本直接更新
result = mContentResolver.update(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId),
mDiffDataValues, null, null);
} else {
result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[] {
String.valueOf(noteId), String.valueOf(version)
});
// 带版本验证的更新
result = mContentResolver.update(
ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, mDataId),
mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.VERSION + "=?)",
new String[] { String.valueOf(noteId), String.valueOf(version) });
}
if (result == 0) {
Log.w(TAG, "there is no update. maybe user updates note when syncing");
@ -179,11 +215,16 @@ public class SqlData {
}
}
// 重置状态
mDiffDataValues.clear();
mIsCreate = false;
}
/**
* 获取数据ID
* @return 数据ID
*/
public long getId() {
return mDataId;
}
}
}
Write Preview
Loading…
Cancel
Save