p7iam4w8v
/
MiNote
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Labels Milestones
New Pull Request

更新 #4

Merged
p7iam4w8v merged 12 commits from dev into main 2 years ago
Conversation 0 Commits 12 Files Changed 10
10 changed files with 652 additions and 497 deletions
Show Stats Download Patch File Download Diff File

6
src/gtask/data/MetaData.java
Unescape View File

@ -38,7 +38,6 @@ public class MetaData extends Task {
} }
/* /*
* 功能描述：判断当前数据是否为空，若为空则返回真即值得保存 * 功能描述：判断当前数据是否为空，若为空则返回真即值得保存
* Made By CuiCan
*/ */
@Override @Override
public boolean isWorthSaving() { public boolean isWorthSaving() {
@ -67,7 +66,6 @@ public class MetaData extends Task {
} }
/* /*
* 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常 * 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常
* Made By CuiCan
*/ */
@Override @Override
public void setContentByLocalJSON(JSONObject js) { public void setContentByLocalJSON(JSONObject js) {
@ -79,26 +77,22 @@ public class MetaData extends Task {
} }
/* /*
* 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常 * 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常
* Made By CuiCan
*/ */
@Override @Override
public JSONObject getLocalJSONFromContent() { public JSONObject getLocalJSONFromContent() {
throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called"); throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
/* /*
* 传递非法参数异常 * 传递非法参数异常
* Made By Cui Can
*/ */
} }
/* /*
* 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常 * 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常
* Made By CuiCan
*/ */
@Override @Override
public int getSyncAction(Cursor c) { public int getSyncAction(Cursor c) {
throw new IllegalAccessError("MetaData:getSyncAction should not be called"); throw new IllegalAccessError("MetaData:getSyncAction should not be called");
/* /*
* 传递非法参数异常 * 传递非法参数异常
* Made By Cui Can
*/ */
} }

73
src/gtask/data/SqlData.java
Unescape View File

@ -6,18 +6,11 @@
*/ */
package net.micode.notes.gtask.data; package net.micode.notes.gtask.data;
/*
* 功能描述：
* 实现过程：
* 参数注解：
* Made By CuiCan
*/
public class SqlData { public class SqlData {
/* /*
* 功能描述：得到类的简写名称存入字符串TAG中 * 功能描述：得到类的简写名称存入字符串TAG中
* 实现过程：调用getSimpleName ()函数 * 实现过程：调用getSimpleName ()函数
* Made By CuiCan
*/ */
private static final String TAG = SqlData.class.getSimpleName(); private static final String TAG = SqlData.class.getSimpleName();
@ -67,8 +60,6 @@ public class SqlData {
* 功能描述：构造函数，用于初始化数据 * 功能描述：构造函数，用于初始化数据
* 参数注解：mContentResolver用于获取ContentProvider提供的数据 * 参数注解：mContentResolver用于获取ContentProvider提供的数据
* 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同） * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
* 参数注解：
* Made By CuiCan
*/ */
public SqlData(Context context) { public SqlData(Context context) {
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
@ -86,8 +77,6 @@ public class SqlData {
* 功能描述：构造函数，初始化数据 * 功能描述：构造函数，初始化数据
* 参数注解：mContentResolver用于获取ContentProvider提供的数据 * 参数注解：mContentResolver用于获取ContentProvider提供的数据
* 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同） * 参数注解： mIsCreate表征当前数据是用哪种方式创建（两种构造函数的参数不同）
* 参数注解：
* Made By CuiCan
*/ */
public SqlData(Context context, Cursor c) { public SqlData(Context context, Cursor c) {
mContentResolver = context.getContentResolver(); mContentResolver = context.getContentResolver();
@ -99,7 +88,6 @@ public class SqlData {
/* /*
* 功能描述：从光标处加载数据 * 功能描述：从光标处加载数据
* 从当前的光标处将五列的数据加载到该类的对象 * 从当前的光标处将五列的数据加载到该类的对象
* Made By CuiCan
*/ */
private void loadFromCursor(Cursor c) { private void loadFromCursor(Cursor c) {
mDataId = c.getLong(DATA_ID_COLUMN); mDataId = c.getLong(DATA_ID_COLUMN);
@ -110,50 +98,54 @@ public class SqlData {
} }
/* /**
* 功能描述：设置用于共享的数据，并提供异常抛出与处理机制 * 设置用于共享的数据，并提供异常抛出与处理机制
* 参数注解： *
* Made By CuiCan * @param js 传入的 JSONObject 对象
*/ * @throws JSONException JSON 解析异常
*/
public void setContent(JSONObject js) throws JSONException { public void setContent(JSONObject js) throws JSONException {
//如果传入的JSONObject对象中有DataColumns.ID这一项，则设置，否则设为INVALID_ID // 如果传入的 JSONObject 对象中有 DataColumns.ID 这一项，则设置，否则设为 INVALID_ID
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) {
mDiffDataValues.put(DataColumns.ID, dataId); mDiffDataValues.put(DataColumns.ID, dataId);
} }
mDataId = dataId; mDataId = dataId;
// 获取数据 MIME 类型，默认为 DataConstants.NOTE
String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE) String dataMimeType = js.has(DataColumns.MIME_TYPE) ? js.getString(DataColumns.MIME_TYPE)
: DataConstants.NOTE; : DataConstants.NOTE;
if (mIsCreate || !mDataMimeType.equals(dataMimeType)) { if (mIsCreate || !mDataMimeType.equals(dataMimeType)) {
mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType); mDiffDataValues.put(DataColumns.MIME_TYPE, dataMimeType);
} }
mDataMimeType = dataMimeType; mDataMimeType = dataMimeType;
// 获取数据内容，默认为空字符串
String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : ""; String dataContent = js.has(DataColumns.CONTENT) ? js.getString(DataColumns.CONTENT) : "";
if (mIsCreate || !mDataContent.equals(dataContent)) { if (mIsCreate || !mDataContent.equals(dataContent)) {
mDiffDataValues.put(DataColumns.CONTENT, dataContent); mDiffDataValues.put(DataColumns.CONTENT, dataContent);
} }
mDataContent = dataContent; mDataContent = dataContent;
// 获取数据附加内容 1，默认为 0
long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0; long dataContentData1 = js.has(DataColumns.DATA1) ? js.getLong(DataColumns.DATA1) : 0;
if (mIsCreate || mDataContentData1 != dataContentData1) { if (mIsCreate || mDataContentData1 != dataContentData1) {
mDiffDataValues.put(DataColumns.DATA1, dataContentData1); mDiffDataValues.put(DataColumns.DATA1, dataContentData1);
} }
mDataContentData1 = dataContentData1; mDataContentData1 = dataContentData1;
// 获取数据附加内容 3，默认为空字符串
String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : ""; String dataContentData3 = js.has(DataColumns.DATA3) ? js.getString(DataColumns.DATA3) : "";
if (mIsCreate || !mDataContentData3.equals(dataContentData3)) { if (mIsCreate || !mDataContentData3.equals(dataContentData3)) {
mDiffDataValues.put(DataColumns.DATA3, dataContentData3); mDiffDataValues.put(DataColumns.DATA3, dataContentData3);
} }
mDataContentData3 = dataContentData3; mDataContentData3 = dataContentData3;
} }
/* /*
* 功能描述：获取共享的数据内容，并提供异常抛出与处理机制 * 功能描述：获取共享的数据内容，并提供异常抛出与处理机制
* 参数注解：
* Made By CuiCan
*/ */
public JSONObject getContent() throws JSONException { public JSONObject getContent() throws JSONException {
if (mIsCreate) { if (mIsCreate) {
@ -170,37 +162,45 @@ public class SqlData {
return js; return js;
} }
/* /**
* 功能描述：commit函数用于把当前造作所做的修改保存到数据库 * 提交数据变更到数据库
* 参数注解： *
* Made By CuiCan * @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) {
// 如果数据 ID 无效且差异数据集合包含数据 ID，则移除数据 ID
if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) { if (mDataId == INVALID_ID && mDiffDataValues.containsKey(DataColumns.ID)) {
mDiffDataValues.remove(DataColumns.ID); mDiffDataValues.remove(DataColumns.ID);
} }
// 设置笔记 ID，将差异数据插入到数据表
mDiffDataValues.put(DataColumns.NOTE_ID, noteId); mDiffDataValues.put(DataColumns.NOTE_ID, noteId);
Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues); Uri uri = mContentResolver.insert(Notes.CONTENT_DATA_URI, mDiffDataValues);
try { try {
// 从 URI 中获取插入的数据 ID
mDataId = Long.valueOf(uri.getPathSegments().get(1)); mDataId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
Log.e(TAG, "Get note id error :" + e.toString()); Log.e(TAG, "Get note id error :" + e.toString());
throw new ActionFailureException("create note failed"); throw new ActionFailureException("create note failed");
} }
} else { } else {
// 如果有数据更新
if (mDiffDataValues.size() > 0) { if (mDiffDataValues.size() > 0) {
int result = 0; int result = 0;
if (!validateVersion) { if (!validateVersion) {
// 如果不需要验证版本，直接更新数据表
result = mContentResolver.update(ContentUris.withAppendedId( result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null); Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, null, null);
} else { } else {
// 需要验证版本，构造 SQL 语句进行更新
result = mContentResolver.update(ContentUris.withAppendedId( result = mContentResolver.update(ContentUris.withAppendedId(
Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues, Notes.CONTENT_DATA_URI, mDataId), mDiffDataValues,
" ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE " ? in (SELECT " + NoteColumns.ID + " FROM " + TABLE.NOTE
+ " WHERE " + NoteColumns.VERSION + "=?)", new String[] { + " WHERE " + NoteColumns.VERSION + "=?)", new String[]{
String.valueOf(noteId), String.valueOf(version) String.valueOf(noteId), String.valueOf(version)
}); });
} }
@ -209,16 +209,15 @@ public class SqlData {
} }
} }
} }
// 清空差异数据集合和创建标志
mDiffDataValues.clear(); mDiffDataValues.clear();
mIsCreate = false; mIsCreate = false;
} }
/* /*
* 功能描述：获取当前id * 功能描述：获取当前id
* 实现过程：
* 参数注解：
* Made By CuiCan
*/ */
public long getId() { public long getId() {
return mDataId; return mDataId;

507
src/gtask/data/SqlNote.java
Unescape View File

@ -5,18 +5,11 @@
*/ */
package net.micode.notes.gtask.data; package net.micode.notes.gtask.data;
/*
* 功能描述：
* 实现过程：
* 参数注解：
* Made By CuiCan
*/
public class SqlNote { public class SqlNote {
/* /*
* 功能描述：得到类的简写名称存入字符串TAG中 * 功能描述：得到类的简写名称存入字符串TAG中
* 实现过程：调用getSimpleName ()函数 * 实现过程：调用getSimpleName ()函数
* Made By CuiCan
*/ */
private static final String TAG = SqlNote.class.getSimpleName(); private static final String TAG = SqlNote.class.getSimpleName();
@ -106,8 +99,6 @@ public class SqlNote {
/* /*
* 功能描述：构造函数 * 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式 * 参数注解： mIsCreate用于标示构造方式
* 参数注解：
* Made By CuiCan
*/ */
//构造函数只有context，对所有的变量进行初始化 //构造函数只有context，对所有的变量进行初始化
public SqlNote(Context context) { public SqlNote(Context context) {
@ -135,8 +126,6 @@ public class SqlNote {
/* /*
* 功能描述：构造函数 * 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式 * 参数注解： mIsCreate用于标示构造方式
* 参数注解：
* Made By CuiCan
*/ */
//构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化 //构造函数有context和一个数据库的cursor，多数变量通过cursor指向的一条记录直接进行初始化
public SqlNote(Context context, Cursor c) { public SqlNote(Context context, Cursor c) {
@ -155,8 +144,6 @@ public class SqlNote {
/* /*
* 功能描述：构造函数 * 功能描述：构造函数
* 参数注解： mIsCreate用于标示构造方式 * 参数注解： mIsCreate用于标示构造方式
* 参数注解：
* Made By CuiCan
*/ */
public SqlNote(Context context, long id) { public SqlNote(Context context, long id) {
mContext = context; mContext = context;
@ -172,7 +159,6 @@ public class SqlNote {
/* /*
* 功能描述：通过id从光标处加载数据 * 功能描述：通过id从光标处加载数据
* Made By CuiCan
*/ */
private void loadFromCursor(long id) { private void loadFromCursor(long id) {
Cursor c = null; Cursor c = null;
@ -196,7 +182,6 @@ public class SqlNote {
/* /*
* 功能描述：通过游标从光标处加载数据 * 功能描述：通过游标从光标处加载数据
* Made By CuiCan
*/ */
private void loadFromCursor(Cursor c) { private void loadFromCursor(Cursor c) {
//直接从一条记录中的获得以下变量的初始值 //直接从一条记录中的获得以下变量的初始值
@ -216,188 +201,216 @@ public class SqlNote {
/* /*
* 功能描述：通过content机制获取共享数据并加载到数据库当前游标处 * 功能描述：通过content机制获取共享数据并加载到数据库当前游标处
* 参数注解：
* Made By CuiCan
*/ */
private void loadDataContent() { private void loadDataContent() {
Cursor c = null; Cursor c = null; // 初始化一个游标对象 c
mDataList.clear();
mDataList.clear(); // 清空 mDataList，这可能是一个用于存储从内容提供者检索到的数据的列表
try { try {
c = mContentResolver.query(Notes.CONTENT_DATA_URI, SqlData.PROJECTION_DATA, // 使用内容解析器（mContentResolver）查询 Notes.CONTENT_DATA_URI，根据指定的 note_id 检索数据
"(note_id=?)", new String[] { c = mContentResolver.query(
String.valueOf(mId) Notes.CONTENT_DATA_URI, // 数据的 URI
}, null); SqlData.PROJECTION_DATA, // 要检索的列投影
"(note_id=?)", // 选择条件，基于 note_id
new String[] { String.valueOf(mId) }, // 选择条件中的参数，替换 note_id 的占位符
null
);
if (c != null) { if (c != null) {
if (c.getCount() == 0) { if (c.getCount() == 0) {
Log.w(TAG, "it seems that the note has not data"); Log.w(TAG, "似乎该笔记没有数据"); // 如果游标中没有数据，记录一个警告日志
return; return;
} }
// 遍历游标中的数据，创建 SqlData 对象并添加到 mDataList 中
while (c.moveToNext()) { while (c.moveToNext()) {
SqlData data = new SqlData(mContext, c); SqlData data = new SqlData(mContext, c);
mDataList.add(data); mDataList.add(data);
} }
} else { } else {
Log.w(TAG, "loadDataContent: cursor = null"); Log.w(TAG, "loadDataContent: cursor = null"); // 如果游标为空，记录一个警告日志
} }
} finally { } finally {
if (c != null) if (c != null)
c.close(); c.close(); // 在最终块中确保关闭游标，释放资源
} }
} }
/* /*
* 功能描述：设置通过content机制用于共享的数据信息 * 功能描述：设置通过content机制用于共享的数据信息
* 参数注解：
* Made By CuiCan
*/ */
public boolean setContent(JSONObject js) { public boolean setContent(JSONObject js) {
try { try {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 从传入的 JSON 对象中获取笔记对象
if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
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 if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
String snippet = note.has(NoteColumns.SNIPPET) ? note Log.w(TAG, "无法设置系统文件夹");
.getString(NoteColumns.SNIPPET) : ""; } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
if (mIsCreate || !mSnippet.equals(snippet)) { // 对于文件夹，只能更新摘要和类型
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
} // 获取摘要，如果没有则设置为空字符串
mSnippet = snippet; String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : "";
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) // 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中
: Notes.TYPE_NOTE; if (mIsCreate || !mSnippet.equals(snippet)) {
if (mIsCreate || mType != type) { mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
mDiffNoteValues.put(NoteColumns.TYPE, type); }
} mSnippet = snippet;
mType = type;
} else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) { // 获取类型，如果没有则默认为 Notes.TYPE_NOTE
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;
long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
if (mIsCreate || mId != id) { // 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中
mDiffNoteValues.put(NoteColumns.ID, id); if (mIsCreate || mType != type) {
} mDiffNoteValues.put(NoteColumns.TYPE, type);
mId = id; }
mType = type;
long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note } else if (note.getInt(NoteColumns.TYPE) == Notes.TYPE_NOTE) {
.getLong(NoteColumns.ALERTED_DATE) : 0; // 处理笔记类型为 Note 的情况
if (mIsCreate || mAlertDate != alertDate) {
mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate); // 从 JSON 中获取数据数组
} JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
mAlertDate = alertDate;
// 获取笔记 ID，如果没有则设置为 INVALID_ID
int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note long id = note.has(NoteColumns.ID) ? note.getLong(NoteColumns.ID) : INVALID_ID;
.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
if (mIsCreate || mBgColorId != bgColorId) { // 如果是创建操作或者 ID 发生变化，则将 ID 加入 mDiffNoteValues 中
mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId); if (mIsCreate || mId != id) {
} mDiffNoteValues.put(NoteColumns.ID, id);
mBgColorId = bgColorId; }
long createDate = note.has(NoteColumns.CREATED_DATE) ? note mId = id;
.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
if (mIsCreate || mCreatedDate != createDate) { // 获取提醒日期，如果没有则设置为 0
mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate); long alertDate = note.has(NoteColumns.ALERTED_DATE) ? note.getLong(NoteColumns.ALERTED_DATE) : 0;
}
mCreatedDate = createDate; // 如果是创建操作或者提醒日期发生变化，则将提醒日期加入 mDiffNoteValues 中
if (mIsCreate || mAlertDate != alertDate) {
int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note mDiffNoteValues.put(NoteColumns.ALERTED_DATE, alertDate);
.getInt(NoteColumns.HAS_ATTACHMENT) : 0; }
if (mIsCreate || mHasAttachment != hasAttachment) { mAlertDate = alertDate;
mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
} // 获取背景颜色 ID，如果没有则设置为默认值
mHasAttachment = hasAttachment; int bgColorId = note.has(NoteColumns.BG_COLOR_ID) ? note.getInt(NoteColumns.BG_COLOR_ID) : ResourceParser.getDefaultBgId(mContext);
long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note // 如果是创建操作或者背景颜色 ID 发生变化，则将背景颜色 ID 加入 mDiffNoteValues 中
.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis(); if (mIsCreate || mBgColorId != bgColorId) {
if (mIsCreate || mModifiedDate != modifiedDate) { mDiffNoteValues.put(NoteColumns.BG_COLOR_ID, bgColorId);
mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate); }
} mBgColorId = bgColorId;
mModifiedDate = modifiedDate;
// 获取创建日期，如果没有则设置为当前时间
long parentId = note.has(NoteColumns.PARENT_ID) ? note long createDate = note.has(NoteColumns.CREATED_DATE) ? note.getLong(NoteColumns.CREATED_DATE) : System.currentTimeMillis();
.getLong(NoteColumns.PARENT_ID) : 0;
if (mIsCreate || mParentId != parentId) { // 如果是创建操作或者创建日期发生变化，则将创建日期加入 mDiffNoteValues 中
mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId); if (mIsCreate || mCreatedDate != createDate) {
} mDiffNoteValues.put(NoteColumns.CREATED_DATE, createDate);
mParentId = parentId; }
mCreatedDate = createDate;
String snippet = note.has(NoteColumns.SNIPPET) ? note
.getString(NoteColumns.SNIPPET) : ""; // 获取是否有附件，如果没有则设置为 0
if (mIsCreate || !mSnippet.equals(snippet)) { int hasAttachment = note.has(NoteColumns.HAS_ATTACHMENT) ? note.getInt(NoteColumns.HAS_ATTACHMENT) : 0;
mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
} // 如果是创建操作或者是否有附件发生变化，则将是否有附件加入 mDiffNoteValues 中
mSnippet = snippet; if (mIsCreate || mHasAttachment != hasAttachment) {
mDiffNoteValues.put(NoteColumns.HAS_ATTACHMENT, hasAttachment);
int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) }
: Notes.TYPE_NOTE; mHasAttachment = hasAttachment;
if (mIsCreate || mType != type) {
mDiffNoteValues.put(NoteColumns.TYPE, type); // 获取修改日期，如果没有则设置为当前时间
} long modifiedDate = note.has(NoteColumns.MODIFIED_DATE) ? note.getLong(NoteColumns.MODIFIED_DATE) : System.currentTimeMillis();
mType = type;
// 如果是创建操作或者修改日期发生变化，则将修改日期加入 mDiffNoteValues 中
int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) if (mIsCreate || mModifiedDate != modifiedDate) {
: AppWidgetManager.INVALID_APPWIDGET_ID; mDiffNoteValues.put(NoteColumns.MODIFIED_DATE, modifiedDate);
if (mIsCreate || mWidgetId != widgetId) { }
mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId); mModifiedDate = modifiedDate;
}
mWidgetId = widgetId; // 获取父级 ID，如果没有则设置为 0
long parentId = note.has(NoteColumns.PARENT_ID) ? note.getLong(NoteColumns.PARENT_ID) : 0;
int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note
.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE; // 如果是创建操作或者父级 ID 发生变化，则将父级 ID 加入 mDiffNoteValues 中
if (mIsCreate || mWidgetType != widgetType) { if (mIsCreate || mParentId != parentId) {
mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType); mDiffNoteValues.put(NoteColumns.PARENT_ID, parentId);
} }
mWidgetType = widgetType; mParentId = parentId;
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note // 获取摘要，如果没有则设置为空字符串
.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0; String snippet = note.has(NoteColumns.SNIPPET) ? note.getString(NoteColumns.SNIPPET) : "";
if (mIsCreate || mOriginParent != originParent) {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent); // 如果是创建操作或者摘要发生变化，则将摘要加入 mDiffNoteValues 中
} if (mIsCreate || !mSnippet.equals(snippet)) {
mOriginParent = originParent; mDiffNoteValues.put(NoteColumns.SNIPPET, snippet);
}
for (int i = 0; i < dataArray.length(); i++) { mSnippet = snippet;
JSONObject data = dataArray.getJSONObject(i);
SqlData sqlData = null; // 获取类型，如果没有则默认为 Notes.TYPE_NOTE
if (data.has(DataColumns.ID)) { int type = note.has(NoteColumns.TYPE) ? note.getInt(NoteColumns.TYPE) : Notes.TYPE_NOTE;
long dataId = data.getLong(DataColumns.ID);
for (SqlData temp : mDataList) { // 如果是创建操作或者类型发生变化，则将类型加入 mDiffNoteValues 中
if (dataId == temp.getId()) { if (mIsCreate || mType != type) {
sqlData = temp; mDiffNoteValues.put(NoteColumns.TYPE, type);
} }
} mType = type;
}
// 获取小部件 ID，如果没有则设置为 AppWidgetManager.INVALID_APPWIDGET_ID
if (sqlData == null) { int widgetId = note.has(NoteColumns.WIDGET_ID) ? note.getInt(NoteColumns.WIDGET_ID) : AppWidgetManager.INVALID_APPWIDGET_ID;
sqlData = new SqlData(mContext);
mDataList.add(sqlData); // 如果是创建操作或者小部件 ID 发生变化，则将小部件 ID 加入 mDiffNoteValues 中
} if (mIsCreate || mWidgetId != widgetId) {
mDiffNoteValues.put(NoteColumns.WIDGET_ID, widgetId);
sqlData.setContent(data); }
} mWidgetId = widgetId;
}
} catch (JSONException e) { // 获取小部件类型，如果没有则设置为 Notes.TYPE_WIDGET_INVALIDE
Log.e(TAG, e.toString()); int widgetType = note.has(NoteColumns.WIDGET_TYPE) ? note.getInt(NoteColumns.WIDGET_TYPE) : Notes.TYPE_WIDGET_INVALIDE;
e.printStackTrace();
return false; // 如果是创建操作或者小部件类型发生变化，则将小部件类型加入 mDiffNoteValues 中
} if (mIsCreate || mWidgetType != widgetType) {
return true; mDiffNoteValues.put(NoteColumns.WIDGET_TYPE, widgetType);
} }
mWidgetType = widgetType;
// 获取原始父级 ID，如果没有则设置为 0
long originParent = note.has(NoteColumns.ORIGIN_PARENT_ID) ? note.getLong(NoteColumns.ORIGIN_PARENT_ID) : 0;
// 如果是创建操作或者原始父级 ID 发生变化，则将原始父级 ID 加入 mDiffNoteValues 中
if (mIsCreate || mOriginParent != originParent) {
mDiffNoteValues.put(NoteColumns.ORIGIN_PARENT_ID, originParent);
}
mOriginParent = originParent;
}
} catch (JSONException e) {
// 如果发生异常，记录错误日志并返回 false
Log.e(TAG, e.toString());
e.printStackTrace();
return false;
}
return true; // 如果没有发生异常，返回 true 表示设置成功
}
/* /*
* 功能描述：获取content机制提供的数据并加载到note中 * 功能描述：获取content机制提供的数据并加载到note中
* 参数注解：
* Made By CuiCan
*/ */
public JSONObject getContent() { public JSONObject getContent() {
try { try {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
// 如果是创建操作而没有在数据库中创建记录，记录一个错误日志并返回 null
if (mIsCreate) { if (mIsCreate) {
Log.e(TAG, "it seems that we haven't created this in database yet"); Log.e(TAG, "似乎我们还没有在数据库中创建这个记录");
return null; return null;
} }
JSONObject note = new JSONObject(); JSONObject note = new JSONObject();
if (mType == Notes.TYPE_NOTE) {//类型为note时
// 根据笔记的类型填充 note 对象的属性
if (mType == Notes.TYPE_NOTE) { // 类型为 Note 时
note.put(NoteColumns.ID, mId); note.put(NoteColumns.ID, mId);
note.put(NoteColumns.ALERTED_DATE, mAlertDate); note.put(NoteColumns.ALERTED_DATE, mAlertDate);
note.put(NoteColumns.BG_COLOR_ID, mBgColorId); note.put(NoteColumns.BG_COLOR_ID, mBgColorId);
@ -411,7 +424,7 @@ public class SqlNote {
note.put(NoteColumns.WIDGET_TYPE, mWidgetType); note.put(NoteColumns.WIDGET_TYPE, mWidgetType);
note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent); note.put(NoteColumns.ORIGIN_PARENT_ID, mOriginParent);
js.put(GTaskStringUtils.META_HEAD_NOTE, note); js.put(GTaskStringUtils.META_HEAD_NOTE, note);
JSONArray dataArray = new JSONArray(); JSONArray dataArray = new JSONArray();
for (SqlData sqlData : mDataList) { for (SqlData sqlData : mDataList) {
JSONObject data = sqlData.getContent(); JSONObject data = sqlData.getContent();
@ -420,13 +433,13 @@ public class SqlNote {
} }
} }
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
} else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) {//类型为文件夹或者 } else if (mType == Notes.TYPE_FOLDER || mType == Notes.TYPE_SYSTEM) { // 类型为文件夹或系统
note.put(NoteColumns.ID, mId); note.put(NoteColumns.ID, mId);
note.put(NoteColumns.TYPE, mType); note.put(NoteColumns.TYPE, mType);
note.put(NoteColumns.SNIPPET, mSnippet); note.put(NoteColumns.SNIPPET, mSnippet);
js.put(GTaskStringUtils.META_HEAD_NOTE, note); js.put(GTaskStringUtils.META_HEAD_NOTE, note);
} }
return js; return js;
} catch (JSONException e) { } catch (JSONException e) {
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
@ -434,11 +447,10 @@ public class SqlNote {
} }
return null; return null;
} }
/* /*
* 功能描述：给当前id设置父id * 功能描述：给当前id设置父id
* 参数注解：
* Made By CuiCan
*/ */
public void setParentId(long id) { public void setParentId(long id) {
mParentId = id; mParentId = id;
@ -447,8 +459,6 @@ public class SqlNote {
/* /*
* 功能描述：给当前id设置Gtaskid * 功能描述：给当前id设置Gtaskid
* 参数注解：
* Made By CuiCan
*/ */
public void setGtaskId(String gid) { public void setGtaskId(String gid) {
mDiffNoteValues.put(NoteColumns.GTASK_ID, gid); mDiffNoteValues.put(NoteColumns.GTASK_ID, gid);
@ -456,8 +466,6 @@ public class SqlNote {
/* /*
* 功能描述：给当前id设置同步id * 功能描述：给当前id设置同步id
* 参数注解：
* Made By CuiCan
*/ */
public void setSyncId(long syncId) { public void setSyncId(long syncId) {
mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId); mDiffNoteValues.put(NoteColumns.SYNC_ID, syncId);
@ -465,8 +473,6 @@ public class SqlNote {
/* /*
* 功能描述：初始化本地修改，即撤销所有当前修改 * 功能描述：初始化本地修改，即撤销所有当前修改
* 参数注解：
* Made By CuiCan
*/ */
public void resetLocalModified() { public void resetLocalModified() {
mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0); mDiffNoteValues.put(NoteColumns.LOCAL_MODIFIED, 0);
@ -474,8 +480,6 @@ public class SqlNote {
/* /*
* 功能描述：获得当前id * 功能描述：获得当前id
* 参数注解：
* Made By CuiCan
*/ */
public long getId() { public long getId() {
return mId; return mId;
@ -483,8 +487,6 @@ public class SqlNote {
/* /*
* 功能描述：获得当前id的父id * 功能描述：获得当前id的父id
* 参数注解：
* Made By CuiCan
*/ */
public long getParentId() { public long getParentId() {
return mParentId; return mParentId;
@ -492,8 +494,6 @@ public class SqlNote {
/* /*
* 功能描述：获取小片段即用于显示的部分便签内容 * 功能描述：获取小片段即用于显示的部分便签内容
* 参数注解：
* Made By CuiCan
*/ */
public String getSnippet() { public String getSnippet() {
return mSnippet; return mSnippet;
@ -501,8 +501,6 @@ public class SqlNote {
/* /*
* 功能描述：判断是否为便签类型 * 功能描述：判断是否为便签类型
* 参数注解：
* Made By CuiCan
*/ */
public boolean isNoteType() { public boolean isNoteType() {
return mType == Notes.TYPE_NOTE; return mType == Notes.TYPE_NOTE;
@ -510,69 +508,78 @@ public class SqlNote {
/* /*
* 功能描述：commit函数用于把当前造作所做的修改保存到数据库 * 功能描述：commit函数用于把当前造作所做的修改保存到数据库
* 参数注解：
* Made By CuiCan
*/ */
public void commit(boolean validateVersion) { public void commit(boolean validateVersion) {
if (mIsCreate) { if (mIsCreate) {
if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) { if (mId == INVALID_ID && mDiffNoteValues.containsKey(NoteColumns.ID)) {
mDiffNoteValues.remove(NoteColumns.ID); mDiffNoteValues.remove(NoteColumns.ID);
} }
Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues); // 将差异的笔记值插入数据库
try { Uri uri = mContentResolver.insert(Notes.CONTENT_NOTE_URI, mDiffNoteValues);
mId = Long.valueOf(uri.getPathSegments().get(1));
} catch (NumberFormatException e) { try {
Log.e(TAG, "Get note id error :" + e.toString()); // 获取插入记录的ID并更新到当前对象的mId属性
throw new ActionFailureException("create note failed"); mId = Long.valueOf(uri.getPathSegments().get(1));
} } catch (NumberFormatException e) {
if (mId == 0) { Log.e(TAG, "获取笔记ID出错：" + e.toString());
throw new IllegalStateException("Create thread id failed"); throw new ActionFailureException("创建笔记失败");
} }
if (mType == Notes.TYPE_NOTE) { if (mId == 0) {
for (SqlData sqlData : mDataList) {//直接使用sqldata中的实现 throw new IllegalStateException("创建笔记ID失败");
sqlData.commit(mId, false, -1); }
}
} // 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表
} else { if (mType == Notes.TYPE_NOTE) {
if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) { for (SqlData sqlData : mDataList) {
Log.e(TAG, "No such note"); sqlData.commit(mId, false, -1);
throw new IllegalStateException("Try to update note with invalid id"); }
} }
if (mDiffNoteValues.size() > 0) { } else {
mVersion ++; // 更新已存在的笔记
int result = 0; if (mId <= 0 && mId != Notes.ID_ROOT_FOLDER && mId != Notes.ID_CALL_RECORD_FOLDER) {
if (!validateVersion) {//构造字符串 Log.e(TAG, "没有这样的笔记");
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "(" throw new IllegalStateException("尝试使用无效ID更新笔记");
+ NoteColumns.ID + "=?)", new String[] { }
String.valueOf(mId)
}); if (mDiffNoteValues.size() > 0) {
} else { mVersion++;
result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)", // 构造更新条件和参数
new String[] { int result = 0;
String.valueOf(mId), String.valueOf(mVersion) if (!validateVersion) {
}); result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
} + NoteColumns.ID + "=?)", new String[] {
if (result == 0) { String.valueOf(mId)
Log.w(TAG, "there is no update. maybe user updates note when syncing"); });
} } else {
} result = mContentResolver.update(Notes.CONTENT_NOTE_URI, mDiffNoteValues, "("
+ NoteColumns.ID + "=?) AND (" + NoteColumns.VERSION + "<=?)",
if (mType == Notes.TYPE_NOTE) { new String[] {
for (SqlData sqlData : mDataList) { String.valueOf(mId), String.valueOf(mVersion)
sqlData.commit(mId, validateVersion, mVersion); });
} }
}
} if (result == 0) {
Log.w(TAG, "没有更新。可能是用户在同步时更新了笔记");
// refresh local info }
loadFromCursor(mId); }
if (mType == Notes.TYPE_NOTE)
loadDataContent(); // 如果笔记类型为 Notes.TYPE_NOTE，提交关联的 SqlData 列表
if (mType == Notes.TYPE_NOTE) {
mDiffNoteValues.clear(); for (SqlData sqlData : mDataList) {
mIsCreate = false; sqlData.commit(mId, validateVersion, mVersion);
} }
} }
}
// 刷新本地信息
loadFromCursor(mId);
if (mType == Notes.TYPE_NOTE)
loadDataContent();
// 清空差异值、重置创建标志
mDiffNoteValues.clear();
mIsCreate = false;
}

225
src/gtask/data/Task.java
Unescape View File

@ -24,170 +24,220 @@ public class Task extends Node {
mMetaInfo = null; mMetaInfo = null;
} }
/**
* 生成创建任务操作的 JSON 对象
*
* @param actionId 操作的唯一标识符
* @return 包含创建任务操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象时发生异常，则抛出 ActionFailureException 异常
*/
public JSONObject getCreateAction(int actionId) { public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为创建任务
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// action_id // 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// index // 设置任务在父任务中的索引
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this)); js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
// entity_delta // 设置实体的变化信息
JSONObject entity = new JSONObject(); JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_TASK); GTaskStringUtils.GTASK_JSON_TYPE_TASK);
// 如果任务有附加注释，则设置注释信息
if (getNotes() != null) { if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
} }
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
// parent_id // 设置父任务的唯一标识符
if (mParent!= null) { if (mParent != null) {
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid()); js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
} }
// dest_parent_type // 设置目标父任务的类型为 GROUP
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE, js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP); GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// list_id // 设置任务所属列表的唯一标识符
if (mParent!= null) { if (mParent != null) {
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid()); js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
} }
// prior_sibling_id // 设置相邻任务的唯一标识符，用于确定任务在兄弟任务中的位置
if (mPriorSibling != null) { if (mPriorSibling != null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid()); js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
} }
} catch (JSONException e) { } catch (JSONException e) {
// 如果生成 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to generate task-create jsonobject"); throw new ActionFailureException("生成任务创建 JSON 对象失败");
} }
return js; return js;
} }
/**
* 生成更新任务操作的 JSON 对象
*
* @param actionId 操作的唯一标识符
* @return 包含更新任务操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象时发生异常，则抛出 ActionFailureException 异常
*/
public JSONObject getUpdateAction(int actionId) { public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为更新任务
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// action_id // 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// id // 设置任务的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// entity_delta // 设置实体的变化信息
JSONObject entity = new JSONObject(); JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
// 如果任务有附加注释，则设置注释信息
if (getNotes() != null) { if (getNotes() != null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes()); entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
} }
// 设置任务是否被删除
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) { } catch (JSONException e) {
// 如果生成 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to generate task-update jsonobject"); throw new ActionFailureException("生成任务更新 JSON 对象失败");
} }
return js; return js;
} }
/**
* 根据远程 JSON 对象设置任务内容
*
* @param js 包含任务内容信息的远程 JSON 对象
* @throws ActionFailureException 如果解析 JSON 对象时发生异常，则抛出 ActionFailureException 异常
*/
public void setContentByRemoteJSON(JSONObject js) { public void setContentByRemoteJSON(JSONObject js) {
if (js != null) { if (js != null) {
try { try {
// id // 设置任务的唯一标识符
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
} }
// last_modified // 设置任务的最后修改时间
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
} }
// name // 设置任务的名称
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
} }
// notes // 设置任务的注释
if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES)); setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
} }
// deleted // 设置任务是否被删除
if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
} }
// completed // 设置任务是否已完成
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) { if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
} }
} catch (JSONException e) { } catch (JSONException e) {
// 如果解析 JSON 对象时发生异常，则记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to get task content from jsonobject"); throw new ActionFailureException("从 JSON 对象获取任务内容失败");
} }
} }
} }
public void setContentByLocalJSON(JSONObject js) { // metadata ʵʩ /**
* 根据本地 JSON 对象设置任务内容
*
* @param js 包含任务内容信息的本地 JSON 对象
*/
public void setContentByLocalJSON(JSONObject js) {
// 检查 JSON 对象是否有效，以及是否包含必要的信息
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE) if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) { || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable"); Log.w(TAG, "setContentByLocalJSON: 没有可用的信息");
} }
try { try {
// 获取任务的元数据
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
// 检查任务类型是否为 Notes.TYPE_NOTE
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) { if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
Log.e(TAG, "invalid type"); Log.e(TAG, "无效的类型");
return; return;
} }
// 遍历数据数组，查找包含 MIME_TYPE 为 DataConstants.NOTE 的数据项
for (int i = 0; i < dataArray.length(); i++) { for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i); JSONObject data = dataArray.getJSONObject(i);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
// 将数据项的内容设置为任务的名称
setName(data.getString(DataColumns.CONTENT)); setName(data.getString(DataColumns.CONTENT));
break; break;
} }
} }
} catch (JSONException e) { } catch (JSONException e) {
// 如果解析 JSON 对象时发生异常，则记录错误日志
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
} }
} }
/**
* 从任务内容生成本地 JSON 对象
*
* @return 包含任务元数据的本地 JSON 对象
*/
public JSONObject getLocalJSONFromContent() { public JSONObject getLocalJSONFromContent() {
String name = getName(); String name = getName();
try { try {
// 如果任务的元数据为空，表示是从 web 创建的新任务
if (mMetaInfo == null) { if (mMetaInfo == null) {
// new task created from web // 新任务为空，记录警告日志并返回 null
if (name == null) { if (name == null) {
Log.w(TAG, "the note seems to be an empty one"); Log.w(TAG, "任务似乎是一个空任务");
return null; return null;
} }
// 构建 JSON 对象包含任务元数据和数据数组
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
JSONObject note = new JSONObject(); JSONObject note = new JSONObject();
JSONArray dataArray = new JSONArray(); JSONArray dataArray = new JSONArray();
@ -199,10 +249,10 @@ public class Task extends Node {
js.put(GTaskStringUtils.META_HEAD_NOTE, note); js.put(GTaskStringUtils.META_HEAD_NOTE, note);
return js; return js;
} else { } else {
// synced task // 如果是已同步的任务，更新数据数组中 MIME_TYPE 为 DataConstants.NOTE 的数据项的内容
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
for (int i = 0; i < dataArray.length(); i++) { for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i); JSONObject data = dataArray.getJSONObject(i);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
@ -210,80 +260,105 @@ public class Task extends Node {
break; break;
} }
} }
// 更新任务类型为 Notes.TYPE_NOTE，并返回元数据 JSON 对象
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
return mMetaInfo; return mMetaInfo;
} }
} catch (JSONException e) { } catch (JSONException e) {
// 如果生成 JSON 对象时发生异常，则记录错误日志并返回 null
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
return null; return null;
} }
} }
/**
* 根据 MetaData 对象设置元数据信息
*
* @param metaData 包含元数据信息的 MetaData 对象
*/
public void setMetaInfo(MetaData metaData) { public void setMetaInfo(MetaData metaData) {
// 检查 MetaData 对象是否有效，且是否包含注释信息
if (metaData != null && metaData.getNotes() != null) { if (metaData != null && metaData.getNotes() != null) {
try { try {
// 将注释信息转换为 JSON 对象并赋值给 mMetaInfo
mMetaInfo = new JSONObject(metaData.getNotes()); mMetaInfo = new JSONObject(metaData.getNotes());
} catch (JSONException e) { } catch (JSONException e) {
// 如果转换为 JSON 对象时发生异常，则记录警告日志并将 mMetaInfo 置为 null
Log.w(TAG, e.toString()); Log.w(TAG, e.toString());
mMetaInfo = null; mMetaInfo = null;
} }
} }
} }
/**
* 获取同步操作类型
*
* @param c 包含本地数据库信息的 Cursor 对象
* @return 同步操作类型，可能的值有 SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_REMOTE、
* SYNC_ACTION_UPDATE_LOCAL、SYNC_ACTION_UPDATE_CONFLICT 和 SYNC_ACTION_ERROR
*/
public int getSyncAction(Cursor c) { public int getSyncAction(Cursor c) {
try { try {
JSONObject noteInfo = null; JSONObject noteInfo = null;
// 检查元数据是否存在且包含注释信息
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
} }
// 如果注释信息不存在，记录警告日志并返回 SYNC_ACTION_UPDATE_REMOTE
if (noteInfo == null) { if (noteInfo == null) {
Log.w(TAG, "it seems that note meta has been deleted"); Log.w(TAG, "似乎已删除注释元数据");
return SYNC_ACTION_UPDATE_REMOTE; return SYNC_ACTION_UPDATE_REMOTE;
} }
// 如果注释信息中不包含 NoteColumns.ID，记录警告日志并返回 SYNC_ACTION_UPDATE_LOCAL
if (!noteInfo.has(NoteColumns.ID)) { if (!noteInfo.has(NoteColumns.ID)) {
Log.w(TAG, "remote note id seems to be deleted"); Log.w(TAG, "远程注释 ID 似乎已删除");
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
// validate the note id now // 验证注释 ID 是否与本地数据库中的 ID 匹配
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) { if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
Log.w(TAG, "note id doesn't match"); Log.w(TAG, "注释 ID 不匹配");
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// there is no local update // 本地没有更新
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// no update both side // 两边都没有更新
return SYNC_ACTION_NONE; return SYNC_ACTION_NONE;
} else { } else {
// apply remote to local // 应用远程更新到本地
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
} else { } else {
// validate gtask id // 验证 gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match"); Log.e(TAG, "gtask ID 不匹配");
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only // 仅本地修改
return SYNC_ACTION_UPDATE_REMOTE; return SYNC_ACTION_UPDATE_REMOTE;
} else { } else {
return SYNC_ACTION_UPDATE_CONFLICT; return SYNC_ACTION_UPDATE_CONFLICT;
} }
} }
} catch (Exception e) { } catch (Exception e) {
// 如果发生异常，记录错误日志并返回 SYNC_ACTION_ERROR
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
} }
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
public boolean isWorthSaving() { public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0) return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)

176
src/gtask/data/TaskList.java
Unescape View File

@ -13,186 +13,250 @@ public class TaskList extends Node {
mIndex = 1; mIndex = 1;
} }
/* (non-Javadoc) /**
* @see net.micode.notes.gtask.data.Node#getCreateAction(int) * 获取创建任务列表操作的 JSON 对象
* 生成并返回一个包含了一定数据的JSONObject实体 *
* @param actionId 操作的唯一标识符
* @return 包含创建任务列表操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象过程中发生异常
*/ */
public JSONObject getCreateAction(int actionId) { public JSONObject getCreateAction(int actionId) throws ActionFailureException {
// 创建空的 JSON 对象
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为创建任务列表
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// action_id // 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// index // 设置任务列表的索引
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
// entity_delta // 创建实体信息的 JSON 对象
JSONObject entity = new JSONObject();//entity实体 JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE, entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP); GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// 将实体信息添加到操作中
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) { } catch (JSONException e) {
// 如果生成 JSON 对象过程中发生异常，记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to generate tasklist-create jsonobject"); throw new ActionFailureException("生成任务列表创建操作的 JSON 对象失败");
} }
return js; return js;
} }
/* (non-Javadoc) /**
* @see net.micode.notes.gtask.data.Node#getUpdateAction(int) * 获取更新任务列表操作的 JSON 对象
* 生成并返回一个包含了一定数据的JSONObject实体 *
* @param actionId 操作的唯一标识符
* @return 包含更新任务列表操作信息的 JSON 对象
* @throws ActionFailureException 如果生成 JSON 对象过程中发生异常
*/ */
public JSONObject getUpdateAction(int actionId) { public JSONObject getUpdateAction(int actionId) throws ActionFailureException {
// 创建空的 JSON 对象
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
try { try {
// action_type // 设置操作类型为更新任务列表
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE, js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// action_id // 设置操作的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// id // 设置任务列表的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// entity_delta // 创建实体信息的 JSON 对象
JSONObject entity = new JSONObject(); JSONObject entity = new JSONObject();
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
// 将实体信息添加到操作中
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) { } catch (JSONException e) {
// 如果生成 JSON 对象过程中发生异常，记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to generate tasklist-update jsonobject"); throw new ActionFailureException("生成任务列表更新操作的 JSON 对象失败");
} }
return js; return js;
} }
public void setContentByRemoteJSON(JSONObject js) { /**
* 通过远程 JSON 对象设置任务列表内容
*
* @param js 包含任务列表信息的 JSON 对象
* @throws ActionFailureException 如果在设置任务列表内容过程中发生异常
*/
public void setContentByRemoteJSON(JSONObject js) throws ActionFailureException {
if (js != null) { if (js != null) {
try { try {
// id // 设置任务列表的唯一标识符
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
} }
// last_modified // 设置任务列表的最后修改时间
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
} }
// name // 设置任务列表的名称
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) { if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
} }
} catch (JSONException e) { } catch (JSONException e) {
// 如果在设置任务列表内容过程中发生异常，记录错误日志并抛出 ActionFailureException 异常
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
throw new ActionFailureException("fail to get tasklist content from jsonobject"); throw new ActionFailureException("从 JSON 对象获取任务列表内容失败");
} }
} }
} }
/**
* 通过本地 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"); // 如果 JSON 对象为空或不包含任务列表信息，记录警告日志
Log.w(TAG, "setContentByLocalJSON: 没有可用的信息");
} }
try { try {
// 获取任务列表的元数据信息
JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
// 如果是文件夹类型的任务列表
String name = folder.getString(NoteColumns.SNIPPET); String name = folder.getString(NoteColumns.SNIPPET);
// 设置任务列表名称为 MIUI 文件夹前缀加上文件夹的片段信息
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name); setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
} else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
// 如果是系统文件夹类型的任务列表
if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER) if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
// 根文件夹
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT); setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER) else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX // 通话记录文件夹
+ GTaskStringUtils.FOLDER_CALL_NOTE); setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE);
else else
Log.e(TAG, "invalid system folder"); // 无效的系统文件夹
Log.e(TAG, "无效的系统文件夹");
} else { } else {
Log.e(TAG, "error type"); // 错误的类型
Log.e(TAG, "错误的类型");
} }
} catch (JSONException e) { } catch (JSONException e) {
// 如果在设置任务列表内容的过程中发生异常，记录错误日志
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
} }
} }
/**
* 根据任务列表内容生成本地 JSON 对象
*
* @return 包含任务列表信息的本地 JSON 对象
*/
public JSONObject getLocalJSONFromContent() { public JSONObject getLocalJSONFromContent() {
try { try {
// 创建 JSON 对象用于存储任务列表信息
JSONObject js = new JSONObject(); JSONObject js = new JSONObject();
// 创建 JSON 对象用于存储任务列表元数据
JSONObject folder = new JSONObject(); JSONObject folder = new JSONObject();
// 获取任务列表名称
String folderName = getName(); String folderName = getName();
// 如果名称以 MIUI 文件夹前缀开头，去掉前缀部分
if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX)) if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(), folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
folderName.length()); folderName.length());
// 设置任务列表元数据的片段信息和类型
folder.put(NoteColumns.SNIPPET, folderName); folder.put(NoteColumns.SNIPPET, folderName);
if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT) if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
|| folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE)) || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
// 如果是默认文件夹或通话记录文件夹，设置为系统文件夹类型
folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM);
else else
// 否则设置为文件夹类型
folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER);
// 将任务列表元数据放入 JSON 对象
js.put(GTaskStringUtils.META_HEAD_NOTE, folder); js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
return js; return js;
} catch (JSONException e) { } catch (JSONException e) {
// 如果在生成本地 JSON 对象的过程中发生异常，记录错误日志
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
return null; return null;
} }
} }
/**
* 获取同步操作类型
*
* @param c 游标对象，包含本地数据库中的任务信息
* @return 同步操作类型，可能的取值有 SYNC_ACTION_NONE、SYNC_ACTION_UPDATE_LOCAL、
* SYNC_ACTION_UPDATE_REMOTE 和 SYNC_ACTION_ERROR
*/
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) {
// there is no local update // 本地无更新
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// no update both side // 本地和远程都无更新
return SYNC_ACTION_NONE; return SYNC_ACTION_NONE;
} else { } else {
// apply remote to local // 将远程更新应用到本地
return SYNC_ACTION_UPDATE_LOCAL; return SYNC_ACTION_UPDATE_LOCAL;
} }
} else { } else {
// validate gtask id // 验证 gtask id
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match"); Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only // 仅有本地修改
return SYNC_ACTION_UPDATE_REMOTE; return SYNC_ACTION_UPDATE_REMOTE;
} else { } else {
// for folder conflicts, just apply local modification // 对于文件夹冲突，仅应用本地修改
return SYNC_ACTION_UPDATE_REMOTE; return SYNC_ACTION_UPDATE_REMOTE;
} }
} }
} catch (Exception e) { } catch (Exception e) {
// 如果在获取同步操作类型的过程中发生异常，记录错误日志
Log.e(TAG, e.toString()); Log.e(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
} }
return SYNC_ACTION_ERROR; return SYNC_ACTION_ERROR;
} }
/** /**
* @return * @return

2
src/gtask/exception/ActionFailureException.java
Unescape View File

@ -11,7 +11,6 @@ public class ActionFailureException extends RuntimeException {
/* /*
* serialVersionUID相当于java类的身份证。主要用于版本控制。 * serialVersionUID相当于java类的身份证。主要用于版本控制。
* serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。 * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
* Made By Cuican
*/ */
public ActionFailureException() { public ActionFailureException() {
@ -22,7 +21,6 @@ public class ActionFailureException extends RuntimeException {
* 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。 * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
* 怎么去引用里面的父类对象呢？使用super来引用 * 怎么去引用里面的父类对象呢？使用super来引用
* 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString) * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
* Made By Cuican
*/ */
public ActionFailureException(String paramString) { public ActionFailureException(String paramString) {
super(paramString); super(paramString);

2
src/gtask/exception/NetworkFailureException.java
Unescape View File

@ -10,7 +10,6 @@ public class NetworkFailureException extends Exception {
/* /*
* serialVersionUID相当于java类的身份证。主要用于版本控制。 * serialVersionUID相当于java类的身份证。主要用于版本控制。
* serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。 * serialVersionUID作用是序列化时保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
* Made By Cuican
*/ */
public NetworkFailureException() { public NetworkFailureException() {
@ -22,7 +21,6 @@ public class NetworkFailureException extends Exception {
* 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。 * 如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。
* 怎么去引用里面的父类对象呢？使用super来引用 * 怎么去引用里面的父类对象呢？使用super来引用
* 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString) * 也就是说，此处super()以及super (paramString)可认为是Exception ()和Exception (paramString)
* Made By Cuican
*/ */
public NetworkFailureException(String paramString) { public NetworkFailureException(String paramString) {
super(paramString); super(paramString);

38
src/gtask/remote/GTaskASyncTask.java
Unescape View File

@ -25,31 +25,43 @@ import net.micode.notes.ui.NotesPreferenceActivity;
public class GTaskASyncTask extends AsyncTask<Void, String, Integer> { public class GTaskASyncTask extends AsyncTask<Void, String, Integer> {
/*
* 通知的ID，用于同步通知
*/
private static int GTASK_SYNC_NOTIFICATION_ID = 5234235; private static int GTASK_SYNC_NOTIFICATION_ID = 5234235;
/**
* 完成监听器接口，用于在任务完成时回调
*/
public interface OnCompleteListener { public interface OnCompleteListener {
void onComplete(); void onComplete();
} }
private Context mContext; private Context mContext; // 上下文对象
private NotificationManager mNotifiManager; // 通知管理器
private NotificationManager mNotifiManager; private GTaskManager mTaskManager; // GTask管理器
private OnCompleteListener mOnCompleteListener; // 完成监听器
private GTaskManager mTaskManager;
/**
private OnCompleteListener mOnCompleteListener; * 构造函数，初始化异步任务
*
* @param context 上下文对象
* @param listener 完成监听器
*/
public GTaskASyncTask(Context context, OnCompleteListener listener) { public GTaskASyncTask(Context context, OnCompleteListener listener) {
mContext = context; mContext = context;
mOnCompleteListener = listener; mOnCompleteListener = listener;
mNotifiManager = (NotificationManager) mContext mNotifiManager = (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
.getSystemService(Context.NOTIFICATION_SERVICE);
mTaskManager = GTaskManager.getInstance(); mTaskManager = GTaskManager.getInstance();
} }
/**
* 取消同步任务
*/
public void cancelSync() { public void cancelSync() {
mTaskManager.cancelSync(); mTaskManager.cancelSync();
} }
public void publishProgess(String message) { // 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值 public void publishProgess(String message) { // 发布进度单位，系统将会调用onProgressUpdate()方法更新这些值
publishProgress(new String[] { publishProgress(new String[] {

118
src/gtask/remote/GTaskManager.java
Unescape View File

@ -38,7 +38,6 @@ public class GTaskManager {
/** /**
* 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。 * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
* 功能：类初始化函数 * 功能：类初始化函数
* @author TTS
* @return GtaskManger * @return GtaskManger
*/ */
public static synchronized GTaskManager getInstance() { //可能运行在多线程环境下，使用语言级同步--synchronized public static synchronized GTaskManager getInstance() { //可能运行在多线程环境下，使用语言级同步--synchronized
@ -50,7 +49,6 @@ public class GTaskManager {
/** /**
* 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。 * 包含关键字synchronized，语言级同步，指明该函数可能运行在多线程的环境下。
* @author TTS
* @param activity * @param activity
*/ */
public synchronized void setActivityContext(Activity activity) { public synchronized void setActivityContext(Activity activity) {
@ -61,7 +59,6 @@ public class GTaskManager {
/** /**
* 核心函数 * 核心函数
* 功能：实现了本地同步操作和远端同步操作 * 功能：实现了本地同步操作和远端同步操作
* @author TTS
* @param context-----获取上下文 * @param context-----获取上下文
* @param asyncTask-------用于同步的异步操作类 * @param asyncTask-------用于同步的异步操作类
* @return int * @return int
@ -126,7 +123,6 @@ public class GTaskManager {
/** /**
*功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。 *功能：初始化GtaskList，获取Google上的JSONtasklist转为本地TaskList。
*获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap *获得的数据存储在mMetaList，mGTaskListHashMap，mGTaskHashMap
*@author TTS
*@exception NetworkFailureException *@exception NetworkFailureException
*@return void *@return void
*/ */
@ -320,22 +316,20 @@ public class GTaskManager {
} }
/** /*
* 功能： * 同步文件夹的方法，抛出网络异常
* @author TTS
* @throws NetworkFailureException
*/ */
private void syncFolder() throws NetworkFailureException { private void syncFolder() throws NetworkFailureException {
Cursor c = null; Cursor c = null;
String gid; String gid;
Node node; Node node;
int syncType; int syncType;
if (mCancelled) { if (mCancelled) {
return; return;
} }
// for root folder // 同步根目录
try { try {
c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, c = mContentResolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI,
Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null); Notes.ID_ROOT_FOLDER), SqlNote.PROJECTION_NOTE, null, null, null);
@ -347,7 +341,7 @@ public class GTaskManager {
mGTaskHashMap.remove(gid); mGTaskHashMap.remove(gid);
mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER); mGidToNid.put(gid, (long) Notes.ID_ROOT_FOLDER);
mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid); mNidToGid.put((long) Notes.ID_ROOT_FOLDER, gid);
// for system folder, only update remote name if necessary // 仅在必要时更新远程名称
if (!node.getName().equals( if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT))
doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c); doContentSync(Node.SYNC_ACTION_UPDATE_REMOTE, node, c);
@ -363,12 +357,12 @@ public class GTaskManager {
c = null; c = null;
} }
} }
// for call-note folder // 同步通话记录文件夹
try { try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)", c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, "(_id=?)",
new String[] { new String[] {
String.valueOf(Notes.ID_CALL_RECORD_FOLDER) String.valueOf(Notes.ID_CALL_RECORD_FOLDER)
}, null); }, null);
if (c != null) { if (c != null) {
if (c.moveToNext()) { if (c.moveToNext()) {
@ -378,8 +372,7 @@ public class GTaskManager {
mGTaskHashMap.remove(gid); mGTaskHashMap.remove(gid);
mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER); mGidToNid.put(gid, (long) Notes.ID_CALL_RECORD_FOLDER);
mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid); mNidToGid.put((long) Notes.ID_CALL_RECORD_FOLDER, gid);
// for system folder, only update remote name if // 仅在必要时更新远程名称
// necessary
if (!node.getName().equals( if (!node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX GTaskStringUtils.MIUI_FOLDER_PREFFIX
+ GTaskStringUtils.FOLDER_CALL_NOTE)) + GTaskStringUtils.FOLDER_CALL_NOTE))
@ -397,8 +390,8 @@ public class GTaskManager {
c = null; c = null;
} }
} }
// for local existing folders // 同步本地已存在的文件夹
try { try {
c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE, c = mContentResolver.query(Notes.CONTENT_NOTE_URI, SqlNote.PROJECTION_NOTE,
"(type=? AND parent_id<>?)", new String[] { "(type=? AND parent_id<>?)", new String[] {
@ -415,10 +408,10 @@ public class GTaskManager {
syncType = node.getSyncAction(c); syncType = node.getSyncAction(c);
} else { } else {
if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) { if (c.getString(SqlNote.GTASK_ID_COLUMN).trim().length() == 0) {
// local add // 本地添加
syncType = Node.SYNC_ACTION_ADD_REMOTE; syncType = Node.SYNC_ACTION_ADD_REMOTE;
} else { } else {
// remote delete // 远程删除
syncType = Node.SYNC_ACTION_DEL_LOCAL; syncType = Node.SYNC_ACTION_DEL_LOCAL;
} }
} }
@ -433,8 +426,8 @@ public class GTaskManager {
c = null; c = null;
} }
} }
// for remote add folders // 同步远程添加的文件夹
Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator(); Iterator<Map.Entry<String, TaskList>> iter = mGTaskListHashMap.entrySet().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
Map.Entry<String, TaskList> entry = iter.next(); Map.Entry<String, TaskList> entry = iter.next();
@ -445,33 +438,38 @@ public class GTaskManager {
doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null); doContentSync(Node.SYNC_ACTION_ADD_LOCAL, node, null);
} }
} }
if (!mCancelled) if (!mCancelled)
GTaskClient.getInstance().commitUpdate(); GTaskClient.getInstance().commitUpdate();
} }
/** /**
* 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode * 功能：syncType分类，addLocalNode，addRemoteNode，deleteNode，updateLocalNode，updateRemoteNode
* @author TTS
* @param syncType * @param syncType
* @param node * @param node
* @param c * @param c
* @throws NetworkFailureException * @throws NetworkFailureException
*/ */
/*
* 执行内容同步操作
*/
private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException { private void doContentSync(int syncType, Node node, Cursor c) throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
} }
MetaData meta; MetaData meta;
switch (syncType) { switch (syncType) {
case Node.SYNC_ACTION_ADD_LOCAL: case Node.SYNC_ACTION_ADD_LOCAL:
// 添加本地节点
addLocalNode(node); addLocalNode(node);
break; break;
case Node.SYNC_ACTION_ADD_REMOTE: case Node.SYNC_ACTION_ADD_REMOTE:
// 添加远程节点
addRemoteNode(node, c); addRemoteNode(node, c);
break; break;
case Node.SYNC_ACTION_DEL_LOCAL: case Node.SYNC_ACTION_DEL_LOCAL:
// 获取本地删除节点的元数据，然后删除
meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN)); meta = mMetaHashMap.get(c.getString(SqlNote.GTASK_ID_COLUMN));
if (meta != null) { if (meta != null) {
GTaskClient.getInstance().deleteNode(meta); GTaskClient.getInstance().deleteNode(meta);
@ -479,6 +477,7 @@ public class GTaskManager {
mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN)); mLocalDeleteIdMap.add(c.getLong(SqlNote.ID_COLUMN));
break; break;
case Node.SYNC_ACTION_DEL_REMOTE: case Node.SYNC_ACTION_DEL_REMOTE:
// 获取远程删除节点的元数据，然后删除节点
meta = mMetaHashMap.get(node.getGid()); meta = mMetaHashMap.get(node.getGid());
if (meta != null) { if (meta != null) {
GTaskClient.getInstance().deleteNode(meta); GTaskClient.getInstance().deleteNode(meta);
@ -486,63 +485,77 @@ public class GTaskManager {
GTaskClient.getInstance().deleteNode(node); GTaskClient.getInstance().deleteNode(node);
break; break;
case Node.SYNC_ACTION_UPDATE_LOCAL: case Node.SYNC_ACTION_UPDATE_LOCAL:
// 更新本地节点
updateLocalNode(node, c); updateLocalNode(node, c);
break; break;
case Node.SYNC_ACTION_UPDATE_REMOTE: case Node.SYNC_ACTION_UPDATE_REMOTE:
// 更新远程节点
updateRemoteNode(node, c); updateRemoteNode(node, c);
break; break;
case Node.SYNC_ACTION_UPDATE_CONFLICT: case Node.SYNC_ACTION_UPDATE_CONFLICT:
// merging both modifications maybe a good idea // 合并两者的修改，目前仅简单使用本地更新
// right now just use local update simply
updateRemoteNode(node, c); updateRemoteNode(node, c);
break; break;
case Node.SYNC_ACTION_NONE: case Node.SYNC_ACTION_NONE:
// 无动作
break; break;
case Node.SYNC_ACTION_ERROR: case Node.SYNC_ACTION_ERROR:
default: default:
throw new ActionFailureException("unkown sync action type"); // 未知的同步操作类型，抛出异常
throw new ActionFailureException("unknown sync action type");
} }
} }
/**
* 功能：本地增加Node /*
* @author TTS * 功能描述：添加本地节点
* @param node * 参数：node - 节点对象
* @throws NetworkFailureException * 返回：无
* 异常：NetworkFailureException - 网络异常
*/ */
private void addLocalNode(Node node) throws NetworkFailureException { private void addLocalNode(Node node) throws NetworkFailureException {
if (mCancelled) { if (mCancelled) {
return; return;
} }
SqlNote sqlNote; SqlNote sqlNote;
// 如果节点为任务列表
if (node instanceof TaskList) { if (node instanceof TaskList) {
if (node.getName().equals( if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) { GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT)) {
// 根据任务列表的名称判断是否为默认文件夹，创建对应的 SqlNote 对象
sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER); sqlNote = new SqlNote(mContext, Notes.ID_ROOT_FOLDER);
} else if (node.getName().equals( } else if (node.getName().equals(
GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) { GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE)) {
// 根据任务列表的名称判断是否为通话记录文件夹，创建对应的 SqlNote 对象
sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER); sqlNote = new SqlNote(mContext, Notes.ID_CALL_RECORD_FOLDER);
} else { } else {
// 其他情况创建普通任务列表对应的 SqlNote 对象
sqlNote = new SqlNote(mContext); sqlNote = new SqlNote(mContext);
sqlNote.setContent(node.getLocalJSONFromContent()); sqlNote.setContent(node.getLocalJSONFromContent());
sqlNote.setParentId(Notes.ID_ROOT_FOLDER); sqlNote.setParentId(Notes.ID_ROOT_FOLDER);
} }
} else { } else {
// 如果节点为任务
sqlNote = new SqlNote(mContext); sqlNote = new SqlNote(mContext);
JSONObject js = node.getLocalJSONFromContent(); JSONObject js = node.getLocalJSONFromContent();
try { try {
// 处理 META_HEAD_NOTE 中的 ID，确保本地数据库中不存在该 ID
if (js.has(GTaskStringUtils.META_HEAD_NOTE)) { if (js.has(GTaskStringUtils.META_HEAD_NOTE)) {
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
if (note.has(NoteColumns.ID)) { if (note.has(NoteColumns.ID)) {
long id = note.getLong(NoteColumns.ID); long id = note.getLong(NoteColumns.ID);
if (DataUtils.existInNoteDatabase(mContentResolver, id)) { if (DataUtils.existInNoteDatabase(mContentResolver, id)) {
// the id is not available, have to create a new one // 如果 ID 在本地数据库中存在，则移除该 ID，创建新的任务 ID
note.remove(NoteColumns.ID); note.remove(NoteColumns.ID);
} }
} }
} }
// 处理 META_HEAD_DATA 中的 ID，确保本地数据库中不存在该 ID
if (js.has(GTaskStringUtils.META_HEAD_DATA)) { if (js.has(GTaskStringUtils.META_HEAD_DATA)) {
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA); JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
for (int i = 0; i < dataArray.length(); i++) { for (int i = 0; i < dataArray.length(); i++) {
@ -550,20 +563,21 @@ public class GTaskManager {
if (data.has(DataColumns.ID)) { if (data.has(DataColumns.ID)) {
long dataId = data.getLong(DataColumns.ID); long dataId = data.getLong(DataColumns.ID);
if (DataUtils.existInDataDatabase(mContentResolver, dataId)) { if (DataUtils.existInDataDatabase(mContentResolver, dataId)) {
// the data id is not available, have to create // 如果 ID 在本地数据库中存在，则移除该 ID，创建新的数据 ID
// a new one
data.remove(DataColumns.ID); data.remove(DataColumns.ID);
} }
} }
} }
} }
} catch (JSONException e) { } catch (JSONException e) {
Log.w(TAG, e.toString()); Log.w(TAG, e.toString());
e.printStackTrace(); e.printStackTrace();
} }
// 设置 SqlNote 对象的内容为节点的本地 JSON 表示
sqlNote.setContent(js); sqlNote.setContent(js);
// 获取节点的父节点的本地 ID，用于设置 SqlNote 对象的父 ID
Long parentId = mGidToNid.get(((Task) node).getParent().getGid()); Long parentId = mGidToNid.get(((Task) node).getParent().getGid());
if (parentId == null) { if (parentId == null) {
Log.e(TAG, "cannot find task's parent id locally"); Log.e(TAG, "cannot find task's parent id locally");
@ -571,22 +585,22 @@ public class GTaskManager {
} }
sqlNote.setParentId(parentId.longValue()); sqlNote.setParentId(parentId.longValue());
} }
// create the local node // 设置 SqlNote 对象的 GTask ID，并提交到本地数据库
sqlNote.setGtaskId(node.getGid()); sqlNote.setGtaskId(node.getGid());
sqlNote.commit(false); sqlNote.commit(false);
// update gid-nid mapping // 更新 GTask ID 到本地 ID 的映射关系
mGidToNid.put(node.getGid(), sqlNote.getId()); mGidToNid.put(node.getGid(), sqlNote.getId());
mNidToGid.put(sqlNote.getId(), node.getGid()); mNidToGid.put(sqlNote.getId(), node.getGid());
// update meta // 更新远程 Meta 信息
updateRemoteMeta(node.getGid(), sqlNote); updateRemoteMeta(node.getGid(), sqlNote);
} }
/** /**
* 功能：update本地node * 功能：update本地node
* @author TTS
* @param node * @param node
* ----同步操作的基础数据类型 * ----同步操作的基础数据类型
* @param c * @param c
@ -619,7 +633,6 @@ public class GTaskManager {
/** /**
* 功能：远程增加Node * 功能：远程增加Node
* 需要updateRemoteMeta * 需要updateRemoteMeta
* @author TTS
* @param node * @param node
* ----同步操作的基础数据类型 * ----同步操作的基础数据类型
* @param c * @param c
@ -703,7 +716,6 @@ public class GTaskManager {
/** /**
* 功能：更新远端的Node，包含meta更新(updateRemoteMeta) * 功能：更新远端的Node，包含meta更新(updateRemoteMeta)
* @author TTS
* @param node * @param node
* ----同步操作的基础数据类型 * ----同步操作的基础数据类型
* @param c * @param c
@ -755,7 +767,6 @@ public class GTaskManager {
/** /**
* 功能：升级远程meta。 meta---元数据----计算机文件系统管理数据---管理数据的数据。 * 功能：升级远程meta。 meta---元数据----计算机文件系统管理数据---管理数据的数据。
* @author TTS
* @param gid * @param gid
* ---GoogleID为String类型 * ---GoogleID为String类型
* @param sqlNote * @param sqlNote
@ -780,7 +791,6 @@ public class GTaskManager {
/** /**
* 功能：刷新本地，给sync的ID对应上最后更改过的对象 * 功能：刷新本地，给sync的ID对应上最后更改过的对象
* @author TTS
* @return void * @return void
* @throws NetworkFailureException * @throws NetworkFailureException
*/ */
@ -830,7 +840,6 @@ public class GTaskManager {
/** /**
* 功能：获取同步账号,mAccount.name * 功能：获取同步账号,mAccount.name
* @author TTS
* @return String * @return String
*/ */
public String getSyncAccount() { public String getSyncAccount() {
@ -839,7 +848,6 @@ public class GTaskManager {
/** /**
* 功能：取消同步，置mCancelled为true * 功能：取消同步，置mCancelled为true
* @author TTS
*/ */
public void cancelSync() { public void cancelSync() {
mCancelled = true; mCancelled = true;

2
src/gtask/remote/GTaskSyncService.java
Unescape View File

@ -91,7 +91,7 @@ public class GTaskSyncService extends Service {
} }
} }
public IBinder onBind(Intent intent) { //不知道干吗用的 public IBinder onBind(Intent intent) {
return null; return null;
} }

Write Preview
Loading…
Cancel
Save