phbaois7m
/
xiaomi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update Task.java

Browse Source
main
phbaois7m 8 months ago
parent 26e59c786a
commit 7200230850
1 changed files with 95 additions and 61 deletions
Show Stats Download Patch File Download Diff File

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

@ -1,21 +1,4 @@
/*
* Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.micode.notes.gtask.data;
import android.database.Cursor;
import android.text.TextUtils;
import android.util.Log;
@ -31,20 +14,23 @@ import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
// 定义Task类，继承自Node类，代表一个任务相关的实体，可能用于任务管理等功能，比如和远程或本地数据交互来处理任务信息
public class Task extends Node {
// 用于日志输出的标签，方便在日志中识别是这个类输出的相关信息，值为类的简单名称
private static final String TAG = Task.class.getSimpleName();
// 表示任务是否已完成的布尔变量，初始化为false
private boolean mCompleted;
// 用于存储任务相关备注信息的字符串，初始化为null
private String mNotes;
// 用于存储任务元信息的JSON对象，初始化为null
private JSONObject mMetaInfo;
// 指向该任务的前一个兄弟任务的引用，初始化为null
private Task mPriorSibling;
// 指向该任务所属的父任务列表的引用，初始化为null
private TaskList mParent;
// 任务类的默认构造函数，初始化任务的各项属性
public Task() {
super();
mCompleted = false;
@ -54,47 +40,54 @@ public class Task extends Node {
mMetaInfo = null;
}
// 根据给定的actionId创建一个用于表示创建任务操作的JSONObject对象
public JSONObject getCreateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// action_type
// 设置action_type字段，表示操作类型为创建任务，使用GTaskStringUtils中定义的常量
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
// action_id
// 设置action_id字段，传入给定的actionId
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// index
// 设置index字段，通过父任务列表获取该任务在其中的索引位置
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
// entity_delta
// 创建一个表示任务实体信息的JSONObject对象
JSONObject entity = new JSONObject();
// 设置任务名称，调用getName方法获取
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
// 设置创建者ID为"null"，具体含义可能根据业务逻辑确定
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
// 设置实体类型为任务类型，使用GTaskStringUtils中定义的常量
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_TASK);
if (getNotes() != null) {
// 如果任务备注信息不为空，则将备注信息添加到entity对象中
if (getNotes()!= null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
// 将任务实体信息对象添加到总的操作对象js中，对应字段为entity_delta
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
// parent_id
// 设置父任务ID，通过父任务列表获取其Gid
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
// dest_parent_type
// 设置目标父类型为分组类型，使用GTaskStringUtils中定义的常量
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
// list_id
// 设置列表ID，通过父任务列表获取其Gid
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
// prior_sibling_id
if (mPriorSibling != null) {
// 如果存在前一个兄弟任务，则设置前一个兄弟任务的ID，通过前一个兄弟任务获取其Gid
if (mPriorSibling!= null) {
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
}
} catch (JSONException e) {
// 如果出现JSON解析异常，记录错误日志，打印堆栈信息，并抛出一个操作失败异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate task-create jsonobject");
@ -103,30 +96,36 @@ public class Task extends Node {
return js;
}
// 根据给定的actionId创建一个用于表示更新任务操作的JSONObject对象
public JSONObject getUpdateAction(int actionId) {
JSONObject js = new JSONObject();
try {
// action_type
// 设置action_type字段，表示操作类型为更新任务，使用GTaskStringUtils中定义的常量
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
// action_id
// 设置action_id字段，传入给定的actionId
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
// id
// 设置id字段，通过调用getGid方法获取任务的唯一标识符
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
// entity_delta
// 创建一个表示任务实体信息更新内容的JSONObject对象
JSONObject entity = new JSONObject();
// 设置任务名称，调用getName方法获取
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
if (getNotes() != null) {
// 如果任务备注信息不为空，则将备注信息添加到entity对象中
if (getNotes()!= null) {
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
}
// 设置任务是否已删除的状态，调用getDeleted方法获取（此处未看到其定义，推测是Task或其父类的方法）
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
// 将任务实体信息更新对象添加到总的操作对象js中，对应字段为entity_delta
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
} catch (JSONException e) {
// 如果出现JSON解析异常，记录错误日志，打印堆栈信息，并抛出一个操作失败异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to generate task-update jsonobject");
@ -135,39 +134,41 @@ public class Task extends Node {
return js;
}
// 根据远程传来的JSONObject对象设置任务的内容信息
public void setContentByRemoteJSON(JSONObject js) {
if (js != null) {
if (js!= null) {
try {
// id
// 如果JSON对象中包含id字段，则设置任务的唯一标识符，通过getString方法获取对应的值
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID));
}
// last_modified
// 如果JSON对象中包含last_modified字段，则设置任务的最后修改时间，通过getLong方法获取对应的值
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED));
}
// name
// 如果JSON对象中包含name字段，则设置任务的名称，通过getString方法获取对应的值
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME));
}
// notes
// 如果JSON对象中包含notes字段，则设置任务的备注信息，通过getString方法获取对应的值
if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
}
// deleted
// 如果JSON对象中包含deleted字段，则设置任务是否已删除的状态，通过getBoolean方法获取对应的值
if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
}
// completed
// 如果JSON对象中包含completed字段，则设置任务是否已完成的状态，通过getBoolean方法获取对应的值
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
}
} catch (JSONException e) {
// 如果出现JSON解析异常，记录错误日志，打印堆栈信息，并抛出一个操作失败异常
Log.e(TAG, e.toString());
e.printStackTrace();
throw new ActionFailureException("fail to get task content from jsonobject");
@ -175,40 +176,51 @@ public class Task extends Node {
}
}
// 根据本地的JSONObject对象设置任务的内容信息
public void setContentByLocalJSON(JSONObject js) {
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {
// 如果传入的JSON对象为空，或者不包含关键的元数据头信息，则记录一个警告日志并返回
if (js == null ||!js.has(GTaskStringUtils.META_HEAD_NOTE)
||!js.has(GTaskStringUtils.META_HEAD_DATA)) {
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
}
try {
// 获取JSON对象中的note相关信息的JSONObject对象
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
// 获取JSON对象中的data数组信息的JSONArray对象
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
// 如果note的类型不是预期的笔记类型（此处Notes.TYPE_NOTE具体含义由业务逻辑确定），记录错误日志并返回
if (note.getInt(NoteColumns.TYPE)!= Notes.TYPE_NOTE) {
Log.e(TAG, "invalid type");
return;
}
// 遍历data数组
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
// 如果数据的MIME类型匹配预期的笔记类型（DataConstants.NOTE具体含义由业务逻辑确定）
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
// 设置任务的名称为对应的数据内容
setName(data.getString(DataColumns.CONTENT));
break;
}
}
} catch (JSONException e) {
// 如果出现JSON解析异常，记录错误日志并打印堆栈信息
Log.e(TAG, e.toString());
e.printStackTrace();
}
}
// 根据任务当前的内容生成对应的本地JSONObject表示，用于存储或传输本地任务相关信息
public JSONObject getLocalJSONFromContent() {
String name = getName();
try {
// 如果任务的元信息为空，可能表示是新从网络创建的任务
if (mMetaInfo == null) {
// new task created from web
// 如果任务名称为空，记录一个警告日志并返回null，表示这个任务可能为空任务
if (name == null) {
Log.w(TAG, "the note seems to be an empty one");
return null;
@ -218,37 +230,46 @@ public class Task extends Node {
JSONObject note = new JSONObject();
JSONArray dataArray = new JSONArray();
JSONObject data = new JSONObject();
// 设置数据内容为任务名称
data.put(DataColumns.CONTENT, name);
dataArray.put(data);
// 将数据数组添加到总的JSON对象中，对应字段为META_HEAD_DATA
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
// 设置note的类型为笔记类型（Notes.TYPE_NOTE具体含义由业务逻辑确定）
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
// 将note对象添加到总的JSON对象中，对应字段为META_HEAD_NOTE
js.put(GTaskStringUtils.META_HEAD_NOTE, note);
return js;
} else {
// synced task
// 如果任务有元信息，表示是已同步过的任务
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
// 遍历数据数组，查找匹配的笔记类型的数据
for (int i = 0; i < dataArray.length(); i++) {
JSONObject data = dataArray.getJSONObject(i);
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
// 设置对应的数据内容为任务当前名称
data.put(DataColumns.CONTENT, getName());
break;
}
}
// 设置note的类型为笔记类型（Notes.TYPE_NOTE具体含义由业务逻辑确定）
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
return mMetaInfo;
}
} catch (JSONException e) {
// 如果出现JSON解析异常，记录错误日志并打印堆栈信息，返回null
Log.e(TAG, e.toString());
e.printStackTrace();
return null;
}
}
// 设置任务的元信息，从传入的MetaData对象中获取并解析其包含的笔记信息（如果有）来设置mMetaInfo
public void setMetaInfo(MetaData metaData) {
if (metaData != null && metaData.getNotes() != null) {
if (metaData!= null && metaData.getNotes()!= null) {
try {
mMetaInfo = new JSONObject(metaData.getNotes());
} catch (JSONException e) {
@ -258,46 +279,50 @@ public class Task extends Node {
}
}
// 根据传入的Cursor（可能是数据库查询结果游标）确定任务的同步操作类型，比如是否需要更新本地、远程等情况
public int getSyncAction(Cursor c) {
try {
JSONObject noteInfo = null;
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
// 如果任务有元信息并且包含关键的note信息，则获取对应的JSONObject对象
if (mMetaInfo!= null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
}
// 如果note信息为空，记录一个警告日志，并表示需要更新远程（可能本地有变化但远程对应信息丢失了之类情况）
if (noteInfo == null) {
Log.w(TAG, "it seems that note meta has been deleted");
return SYNC_ACTION_UPDATE_REMOTE;
}
// 如果note信息中不包含ID字段，记录一个警告日志，并表示需要更新本地（可能远程ID信息缺失等情况）
if (!noteInfo.has(NoteColumns.ID)) {
Log.w(TAG, "remote note id seems to be deleted");
return SYNC_ACTION_UPDATE_LOCAL;
}
// validate the note id now
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {
// 验证note的ID是否匹配，不匹配则记录警告日志并表示需要更新本地
if (c.getLong(SqlNote.ID_COLUMN)!= noteInfo.getLong(NoteColumns.ID)) {
Log.w(TAG, "note id doesn't match");
return SYNC_ACTION_UPDATE_LOCAL;
}
// 如果本地没有更新（本地修改时间为0）
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
// there is no local update
// 如果同步ID和任务最后修改时间相等，表示两边都没有更新
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// no update both side
return SYNC_ACTION_NONE;
} else {
// apply remote to local
// 如果同步ID和任务最后修改时间不相等，表示需要将远程应用到本地
return SYNC_ACTION_UPDATE_LOCAL;
}
} else {
// validate gtask id
// 验证gtask的ID是否匹配，不匹配则记录错误日志并返回错误类型
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {
Log.e(TAG, "gtask id doesn't match");
return SYNC_ACTION_ERROR;
}
// 如果同步ID和任务最后修改时间相等，表示只有本地有修改，需要更新远程
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
// local modification only
return SYNC_ACTION_UPDATE_REMOTE;
} else {
return SYNC_ACTION_UPDATE_CONFLICT;
@ -311,41 +336,50 @@ public class Task extends Node {
return SYNC_ACTION_ERROR;
}
// 判断任务是否值得保存，根据是否有元信息、任务名称是否有效、备注信息是否有效等来综合判断
public boolean isWorthSaving() {
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|| (getNotes() != null && getNotes().trim().length() > 0);
return mMetaInfo!= null || (getName()!= null && getName().trim().length() > 0)
|| (getNotes()!= null && getNotes().trim().length() > 0);
}
// 设置任务是否已完成的状态
public void setCompleted(boolean completed) {
this.mCompleted = completed;
}
// 设置任务的备注信息
public void setNotes(String notes) {
this.mNotes = notes;
}
// 设置任务的前一个兄弟任务
public void setPriorSibling(Task priorSibling) {
this.mPriorSibling = priorSibling;
}
// 设置任务所属的父任务列表
public void setParent(TaskList parent) {
this.mParent = parent;
}
// 获取任务是否已完成的状态并返回
public boolean getCompleted() {
return this.mCompleted;
}
// 获取任务的备注信息并返回
public String getNotes() {
return this.mNotes;
}
// 获取任务的前一个兄弟任务并返回
public Task getPriorSibling() {
return this.mPriorSibling;
}
// 获取任务所属的父任务列表并返回
public TaskList getParent() {
return this.mParent;
}
}
}
Write Preview
Loading…
Cancel
Save