|
|
/*
|
|
|
* 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;//定义了该Java类所属的包名为net.micode.notes.gtask.data
|
|
|
|
|
|
import android.database.Cursor;//引入Android数据库游标（Cursor）类，用于在数据库查询结果中遍历数据
|
|
|
import android.text.TextUtils;//引入Android的文本工具类TextUtils，它提供了一些处理文本的实用方法，比如判断文本是否为空等操作
|
|
|
import android.util.Log;//引入Android的日志工具类Log，用于在应用程序中输出日志信息，方便调试等用途
|
|
|
|
|
|
import net.micode.notes.data.Notes;//入名为Notes的类，它应该是来自net.micode.notes.data包下的，可能用于处理笔记相关的数据或操作
|
|
|
import net.micode.notes.data.Notes.DataColumns;//引入Notes类中的DataColumns内部类或静态成员类，可能定义了与数据列相关的常量或属性，用于在数据库操作等场景下明确数据列的标识
|
|
|
import net.micode.notes.data.Notes.DataConstants;//引入Notes类中的DataConstants内部类或静态成员类，可能包含了一些与数据相关的常量定义，用于在整个应用程序中统一使用这些常量值来表示特定的数据相关概念
|
|
|
import net.micode.notes.data.Notes.NoteColumns;//引入Notes类中的NoteColumns内部类或静态成员类，可能用于定义笔记相关的数据列信息，比如笔记的标题、内容等各列在数据库中的标识等
|
|
|
import net.micode.notes.gtask.exception.ActionFailureException;//引入名为ActionFailureException的异常类，它应该是来自net.micode.notes.gtask.exception包下的，用于在特定操作失败时抛出相应的异常以便进行错误处理
|
|
|
import net.micode.notes.tool.GTaskStringUtils;//引入名为GTaskStringUtils的工具类，它应该是来自net.micode.notes.tool包下的，可能提供了一些与处理字符串相关的实用方法，用于在与GTask相关的字符串操作场景中使用
|
|
|
|
|
|
import org.json.JSONArray;//引入JSON数组处理类JSONArray，用于在Java程序中处理JSON格式数据中的数组类型数据
|
|
|
import org.json.JSONException;//引入JSON异常处理类JSONException，用于在处理JSON数据时捕获可能出现的异常，比如JSON格式不正确等情况导致的异常
|
|
|
import org.json.JSONObject;//引入JSON对象处理类JSONObject，用于在Java程序中处理JSON格式数据中的对象类型数据
|
|
|
|
|
|
|
|
|
public class Task extends Node {// // 定义一个公共的类Task，它继承自Node类
|
|
|
private static final String TAG = Task.class.getSimpleName(); // 定义一个私有静态常量TAG，其值为Task类的简单名称（即类名本身，不包含包名等），通常用于在日志输出等场景中标识当前类
|
|
|
|
|
|
private boolean mCompleted;// 定义一个私有布尔型变量mCompleted，用于表示任务是否已完成
|
|
|
|
|
|
private String mNotes; // 定义一个私有字符串变量mNotes，可能用于存储与任务相关的备注信息
|
|
|
|
|
|
private JSONObject mMetaInfo; // 定义一个私有JSONObject类型的变量mMetaInfo，可能用于存储任务的一些元信息（以JSON对象的形式）
|
|
|
|
|
|
private Task mPriorSibling;// 定义一个私有Task类型的变量mPriorSibling，用于指向当前任务的前一个兄弟任务（在任务列表等场景下，同一层级的前一个任务）
|
|
|
|
|
|
private TaskList mParent; // 定义一个私有TaskList类型的变量mParent，用于指向当前任务所属的任务列表（即当前任务的父级任务列表对象）
|
|
|
|
|
|
public Task() {// 定义Task类的构造函数
|
|
|
super();// 调用父类（Node类）的构造函数
|
|
|
|
|
|
mCompleted = false;// 将任务完成状态mCompleted初始化为false，表示任务初始未完成
|
|
|
mNotes = null; // 将任务备注信息mNotes初始化为null
|
|
|
mPriorSibling = null; // 将前一个兄弟任务mPriorSibling初始化为null
|
|
|
mParent = null;// 将所属任务列表mParent初始化为null
|
|
|
mMetaInfo = null; // 将任务元信息mMetaInfo初始化为null
|
|
|
}
|
|
|
|
|
|
public JSONObject getCreateAction(int actionId) {// 定义一个公共方法getCreateAction，它接受一个整数类型的参数actionId，用于生成创建任务的相关操作信息（以JSONObject的形式返回）
|
|
|
JSONObject js = new JSONObject();// 创建一个新的JSONObject对象js，用于构建要返回的操作信息
|
|
|
|
|
|
try { // 开始一个try块，用于捕获可能出现的JSONException异常
|
|
|
// action_type
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
|
|
|
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE);
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_TYPE（通过工具类GTaskStringUtils获取的表示操作类型的常量字符串），
|
|
|
// 值为GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE（同样通过工具类获取的表示创建操作类型的常量字符串），用于标识此次操作是创建任务的操作类型
|
|
|
|
|
|
// action_id
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
|
|
|
|
|
|
// index
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_ID（通过工具类获取的表示操作ID的常量字符串），
|
|
|
// 值为传入的参数actionId，用于标识此次创建任务操作的唯一ID
|
|
|
// entity_delta
|
|
|
JSONObject entity = new JSONObject();
|
|
|
// 创建一个新的JSONObject对象entity，用于构建任务实体相关的差异信息（在创建或更新任务等操作中，可能用于表示任务实体的新增、修改等情况的信息）
|
|
|
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());// 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_CREATOR_ID（通过工具类获取的表示创建者ID的常量字符串），
|
|
|
|
|
|
entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");// 值为字符串"null"，可能用于表示当前任务创建者的ID信息，这里暂时设置为"null"（具体含义可能根据业务逻辑而定）
|
|
|
entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
|
|
|
GTaskStringUtils.GTASK_JSON_TYPE_TASK); // 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ENTITY_TYPE（通过工具类获取的表示实体类型的常量字符串），
|
|
|
// 值为GTaskStringUtils.GTASK_JSON_TYPE_TASK（通过工具类获取的表示任务类型的常量字符串），用于明确当前实体是任务类型
|
|
|
if (getNotes() != null) {
|
|
|
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
|
|
|
}
|
|
|
// 如果通过调用getNotes方法（获取任务备注信息的方法）得到的结果不为null，就在entity这个JSONObject对象中添加一个键值对，
|
|
|
// 键为GTaskStringUtils.GTASK_JSON_NOTES（通过工具类获取的表示任务备注的常量字符串），值为通过getNotes方法得到的任务备注信息
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ENTITY_DELTA（通过工具类获取的表示实体差异的常量字符串），
|
|
|
// 值为前面构建好的entity这个JSONObject对象，用于将任务实体相关的差异信息添加到整体的操作信息中
|
|
|
// parent_id
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_PARENT_ID（通过工具类获取的表示父级ID的常量字符串），
|
|
|
// 值为通过mParent（当前任务所属的任务列表对象）调用getGid方法得到的结果，用于设置当前任务所属任务列表的唯一标识（GID），可能用于关联任务和其所属任务列表
|
|
|
// dest_parent_type
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
|
|
|
GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE（通过工具类获取的表示目标父级类型的常量字符串），
|
|
|
// 值为GTaskStringUtils.GTASK_JSON_TYPE_GROUP（通过工具类获取的表示组类型的常量字符串），可能用于在某些操作场景下（比如移动任务等）标识目标父级的类型为组类型
|
|
|
java
|
|
|
复制
|
|
|
// list_id
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_LIST_ID（通过工具类获取的表示列表ID的常量字符串），
|
|
|
// 值为通过mParent（当前任务所属的任务列表对象）调用getGid方法得到的结果，用于设置当前任务所属任务列表的唯一标识（GID），可能用于在某些操作场景下（比如查询任务所在列表等）标识任务所属的列表
|
|
|
// prior_sibling_id
|
|
|
if (mPriorSibling != null) {
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
|
|
|
}
|
|
|
// 如果mPriorSibling（当前任务的前一个兄弟任务对象）不为null，就在JSONObject对象js中添加一个键值对，
|
|
|
// 键为GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID（通过工具类获取的表示前一个兄弟任务ID的常量字符串），
|
|
|
// 值为通过mPriorSibling调用getGid方法得到的结果，用于设置当前任务前一个兄弟任务的唯一标识（GID），可能用于在某些操作场景下（比如排序任务等）标识前一个兄弟任务
|
|
|
} catch (JSONException e) {
|
|
|
// 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
|
|
|
Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
|
|
|
java
|
|
|
复制
|
|
|
e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
|
|
|
throw new ActionFailureException("fail to generate task-create jsonobject");// 抛出一个ActionFailureException异常，并传入一个字符串参数"fail to generate task-create jsonobject"，表示生成创建任务的JSONObject对象失败
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return js;// 如果上述操作过程中没有出现异常，就返回构建好的JSONObject对象js，它包含了创建任务的相关操作信息
|
|
|
}
|
|
|
|
|
|
public JSONObject getUpdateAction(int actionId) {// 定义一个公共方法getUpdateAction，它接受一个整数类型的参数actionId，用于生成更新任务的相关操作信息（以JSONObject的形式返回）
|
|
|
JSONObject js = new JSONObject(); // 创建一个新的JSONObject对象js，用于构建要返回的操作信息
|
|
|
|
|
|
try { // 开始一个try块，用于捕获可能出现的JSONException异常
|
|
|
// action_type
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
|
|
|
GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE);
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_TYPE（通过工具类获取的表示操作类型的常量字符串），
|
|
|
// 值为GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE（同样通过工具类获取的表示更新操作类型的常量字符串），用于标识此次操作是更新任务的操作类型
|
|
|
// action_id
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId);
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ACTION_ID（通过工具类获取的表示操作ID的常量字符串），
|
|
|
// 值为传入的参数actionId，用于标识此次更新任务操作的唯一ID
|
|
|
// id
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
|
|
|
// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ID（通过工具类获取的表示任务ID的常量字符串），
|
|
|
// 值为通过调用getGid方法（应该是从父类继承或在当前类中定义的获取任务唯一标识的方法）得到的结果，用于设置要更新的任务的唯一标识（GID）
|
|
|
// entity_delta
|
|
|
JSONObject entity = new JSONObject();
|
|
|
// 创建一个新的JSONObject对象entity，用于构建任务实体相关的差异信息（在创建或更新任务等操作中，可能用于表示任务实体的新增、修改等情况的信息）
|
|
|
entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
|
|
|
// 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_NAME（通过工具类获取的表示任务名称的常量字符串），
|
|
|
// 值为通过调用getName方法（应该是从父类继承或在当前类中定义的获取任务名称的方法）得到的结果，用于设置任务的名称信息
|
|
|
|
|
|
if (getNotes() != null) {
|
|
|
entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
|
|
|
} // 如果通过调用getNotes()方法（获取任务备注信息的方法）得到的结果不为null，就在entity这个JSONObject对象中添加一个键值对，
|
|
|
// 键为GTaskStringUtils.GTASK_JSON_NOTES（通过工具类获取的表示任务备注的常量字符串），值为通过getNotes()方法得到的任务备注信息
|
|
|
entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());// 在entity这个JSONObject对象中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_DELETED（通过工具类获取的表示是否删除的常量字符串），
|
|
|
// 值为通过调用getDeleted()方法（应该是从父类继承或在当前类中定义的获取任务是否删除状态的方法）得到的结果，用于设置任务的删除状态信息
|
|
|
js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);// 在JSONObject对象js中添加一个键值对，键为GTaskStringUtils.GTASK_JSON_ENTITY_DELTA（通过工具类获取的表示实体差异的常量字符串），
|
|
|
// 值为前面构建好的entity这个JSONObject对象，用于将任务实体相关的差异信息添加到整体的操作信息中
|
|
|
|
|
|
} catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
|
|
|
Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
|
|
|
e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
|
|
|
throw new ActionFailureException("fail to generate task-update jsonobject"); // 抛出一个ActionFailureException异常，并传入一个字符串参数"fail to generate task-update jsonobject"，表示生成更新任务的JSONObject对象失败
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return js;// 如果上述操作过程中没有出现异常，就返回构建好的JSONObject对象js，它包含了更新任务的相关操作信息
|
|
|
}
|
|
|
|
|
|
public void setContentByRemoteJSON(JSONObject js) {// 定义一个公共方法setContentByRemoteJSON，它接受一个JSONObject类型的参数js，用于根据远程传来的JSON数据设置任务的相关内容
|
|
|
if (js!= null) { // 如果传入的JSONObject对象js不为空
|
|
|
|
|
|
try { // 开始一个try块，用于捕获可能出现的JSONException异常
|
|
|
// id
|
|
|
if (js.has(GTaskStringUtils.GTASK_JSON_ID)) { // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_ID（通过工具类获取的表示任务ID的常量字符串）的键值对
|
|
|
setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); // 调用setGid方法（应该是在当前类或其父类中定义的设置任务唯一标识的方法），并传入从JSON对象js中获取到的对应键的值（以字符串形式），用于设置任务的唯一标识（GID）
|
|
|
}
|
|
|
|
|
|
// last_modified
|
|
|
if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) { // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_LAST_MODIFIED（通过工具类获取的表示最后修改时间的常量字符串）的键值对
|
|
|
setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); // 调用setLastModified方法（应该是在当前类或其父类中定义的设置最后修改时间的方法），并传入从JSON对象js中获取到的对应键的值（以长整型形式），用于设置任务的最后修改时间
|
|
|
}
|
|
|
|
|
|
// name
|
|
|
if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {// 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_NAME（通过工具类获取的表示任务名称的常量字符串）的键值对
|
|
|
setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); // 调用setName方法（应该是在当前类或其父类中定义的设置任务名称的方法），并传入从JSON对象js中获取到的对应键的值（以字符串形式），用于设置任务的名称
|
|
|
}
|
|
|
|
|
|
// notes
|
|
|
if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) { // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_NOTES（通过工具类获取的表示任务备注的常量字符串）的键值对
|
|
|
setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));// 调用setNotes方法（应该是在当前类或其父类中定义的设置任务备注的方法），并传入从JSON对象js中获取到的对应键的值（以字符串形式），用于设置任务的备注信息
|
|
|
}
|
|
|
|
|
|
// deleted
|
|
|
if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) { // 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_DELETED（通过工具类获取的表示是否删除的常量字符串）的键值对
|
|
|
setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED)); // 调用setDeleted方法（应该是在当前类或其父类中定义的设置任务是否删除状态的方法），并传入从JSON对象js中获取到的对应键的值（以布尔型形式），用于设置任务的删除状态
|
|
|
}
|
|
|
|
|
|
// completed
|
|
|
if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {// 如果传入的JSON对象js包含键为GTaskStringUtils.GTASK_JSON_COMPLETED（通过工具类获取的表示是否完成的常量字符串）的键值对
|
|
|
setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED)); // 调用setCompleted方法（应该是在当前类或其父类中定义的设置任务是否完成状态的 method），并传入从JSON对象js中获取到的对应键的值（以布尔型形式），用于设置任务的完成状态
|
|
|
}
|
|
|
} catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
|
|
|
Log.e(TAG, e.toString()); // 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
|
|
|
e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
|
|
|
throw new ActionFailureException("fail to get task content from jsonobject");// 抛出一个ActionFailureException异常，并传入一个字符串参数"fail to get task content from jsonobject"，表示从JSON对象中获取任务内容失败
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void setContentByLocalJSON(JSONObject js) {// 定义一个公共方法setContentByLocalJSON，它接受一个JSONObject类型的参数js，用于根据本地的JSON数据设置任务的相关内容
|
|
|
if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
|
|
|
|| !js.has(GTaskStringUtils.META_HEAD_DATA)) {// 如果传入的JSONObject对象js为空，或者不包含键为GTaskStringUtils.META_HEAD_NOTE（通过工具类获取的特定头部信息相关的常量字符串）的键值对，
|
|
|
// 或者不包含键为GTaskStringUtils.META_HEAD_DATA（通过工具类获取的特定数据相关的常量字符串）的键值对
|
|
|
Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
|
|
|
}// 使用Log类的w方法（用于输出警告级别日志），输出一条警告日志，内容为"setContentByLocalJSON: nothing is avaiable"，表示设置本地JSON内容时没有可用信息
|
|
|
|
|
|
try {
|
|
|
JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);// 从传入的JSONObject对象js中获取键为GTaskStringUtils.META_HEAD_NOTE的键值对，并将其值（也是一个JSONObject类型）赋给note变量，用于获取特定的笔记相关信息
|
|
|
JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);// 从传入的JSONObject对象js中获取键为GTaskStringUtils.META_HEAD_DATA的键值对，并将其值（也是一个JSONArray类型）赋给dataArray变量，用于获取特定的数据数组相关信息
|
|
|
|
|
|
if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {// 如果从note这个JSONObject对象中获取到的键为NoteColumns.TYPE（通过工具类获取的表示类型的常量字符串）的值不等于Notes.TYPE_NOTE（应该是在Notes类中定义的表示笔记类型的常量）
|
|
|
Log.e(TAG, "invalid type");// 使用Log类的e方法（用于输出错误级别日志），输出一条错误日志，内容为"invalid type"，表示类型无效
|
|
|
return;// 直接返回，不再执行后续代码
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < dataArray.length(); i++) { // 遍历dataArray这个JSONArray对象中的每个元素
|
|
|
JSONObject data = dataArray.getJSONObject(i);// 获取当前遍历到的元素（也是一个JSONObject类型），并赋给data变量
|
|
|
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { // 如果通过TextUtils工具类的equals方法比较data这个JSONObject对象中键为DataColumns.MIME_TYPE（通过工具类获取的表示MIME类型的常量字符串）的值
|
|
|
// 与DataConstants.NOTE（应该是在DataConstants类中定义的表示笔记的常量）相等
|
|
|
setName(data.getString(DataColumns.CONTENT));// 调用setName方法（应该是在当前类或其父类中定义的设置任务名称的方法），并传入从data这个JSONObject对象中获取到的键为DataColumns.CONTENT（通过工具类获取的表示内容的常量字符串）的值（以字符串形式），用于设置任务的名称
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
} catch (JSONException e) {// 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
|
|
|
Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
|
|
|
e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public JSONObject getLocalJSONFromContent() { // 定义一个公共方法getLocalJSONFromContent，用于根据任务的内容生成本地的JSON对象
|
|
|
String name = getName(); // 获取任务的名称，并赋给name变量
|
|
|
try { // 开始一个try块，用于捕获可能出现的JSONException异常
|
|
|
if (mMetaInfo == null) {// 如果任务的元信息mMetaInfo为空
|
|
|
// new task created from web
|
|
|
if (name == null) { // 如果任务的名称name也为空
|
|
|
Log.w(TAG, "the note seems to be an empty one"); // 使用Log类的w方法（用于输出警告级别日志），输出一条警告日志，内容为"the note seems to be an empty one"，表示这个笔记似乎是空的
|
|
|
return null;// 直接返回null，表示无法生成有效的本地JSON对象
|
|
|
}
|
|
|
}
|
|
|
|
|
|
JSONObject js = new JSONObject(); // 创建一个新的JSONObject对象js，用于构建要返回的本地JSON对象
|
|
|
JSONObject note = new JSONObject(); // 创建一个新的JSONObject对象note，用于构建笔记相关的信息部分
|
|
|
JSONArray dataArray = new JSONArray(); // 创建一个新的JSONArray对象dataArray，用于构建数据数组相关的信息部分
|
|
|
JSONObject data = new JSONObject(); // 创建一个新的JSONObject对象data，用于构建具体的数据信息部分
|
|
|
data.put(DataColumns.CONTENT, name);// 在data这个JSONObject对象中添加一个键值对，键为DataColumns.CONTENT（通过工具类获取的表示内容的常量字符串），值为前面获取到的任务名称name，用于设置数据的内容信息
|
|
|
dataArray.put(data);// 将data这个JSONObject对象添加到dataArray这个JSONArray对象中，作为其中的一个元素
|
|
|
js.put(GTaskStringUtils.META_HEAD_DATA, dataArray); // 在js这个JSONObject对象中添加一个键值对，键为GTreeStringUtils.META_HEAD_DATA（通过工具类获取的表示特定数据头部信息的常量字符串），值为前面构建好的dataArray这个JSONArray对象，用于设置本地JSON对象中的数据数组部分
|
|
|
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 在note这个JSONObject对象中添加一个键值对，键为NoteColumns.TYPE（通过工具类获取的表示类型的常量字符串），值为Notes.TYPE_NOTE（应该是在Notes类中定义的表示笔记类型的常量），用于设置笔记的类型信息
|
|
|
js.put(GTaskStringUtils.META_HEAD_NOTE, note); // 在js这个JSONObject对象中添加一个键值对，键为GTreeStringUtils.META_HEAD_NOTE（通过工具类获取的表示特定笔记头部信息的常量字符串），值为前面构建好的note这个JSONObject对象，用于设置本地JSON对象中的笔记部分
|
|
|
return js; // 返回构建好的js这个JSONObject对象，它就是根据任务内容生成的本地JSON对象
|
|
|
} else {
|
|
|
} else {
|
|
|
// synced task
|
|
|
JSONObject note = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 从任务的元信息mMetaInfo中获取键为GTreeStringUtils.META_HEAD_NOTE的键值对，并将其值（也是一个JSONObject类型）赋给note变量，用于获取特定的笔记相关信息
|
|
|
JSONArray dataArray = mMetaInfo.getJSONArray(GTaskStringUtils.META_HEAD_DATA); // 从任务的元信息mMetaInfo中获取键为GTreeStringUtils.META_HEAD_DATA的键值对，并将其值（也是一个JSONArray类型）赋给dataArray变量，用于获取特定的数据数组相关信息
|
|
|
|
|
|
for (int i = 0; i < dataArray.length(); i++) { // 遍历dataArray这个JSONArray对象中的每个元素
|
|
|
JSONObject data = dataArray.getJSONObject(i); // 获取当前遍历到的元素（也是一个JSONObject类型），并赋给data变量
|
|
|
if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) { // 如果通过TextUtils工具类的equals方法比较data这个JSONObject对象中键为DataColumns.MIME_TYPE（通过工具类获取的表示MIME类型的常量字符串）的值
|
|
|
data.put(DataColumns.CONTENT, getName()); // 在data这个JSONObject对象中添加一个键值对，键为DataColumns.CONTENT（通过工具类获取的表示内容的常量字符串），值为通过getName方法获取到的任务名称，用于更新数据的内容信息
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
note.put(NoteColumns.TYPE, Notes.TYPE_NOTE); // 在note这个JSONObject对象中添加一个键值对，键为NoteColumns.TYPE（通过工具类获取的表示类型的常量字符串），值为Notes.TYPE_NOTE（应该是在Notes类中定义的表示笔记类型的常量），用于更新笔记的类型信息
|
|
|
return mMetaInfo;
|
|
|
}
|
|
|
} catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
|
|
|
Log.e(TAG, e.toString());// 使用Log类的e方法（用于输出错误级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出错误日志，以便在调试时查看出现异常的情况
|
|
|
|
|
|
e.printStackTrace(); // 打印异常的堆栈跟踪信息，用于更详细地了解异常出现的位置和调用栈情况，方便调试
|
|
|
return null; // 返回null，表示生成本地JSON对象失败
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void setMetaInfo(MetaData metaData) {// 定义一个公共方法setMetaInfo，它接受一个MetaData类型的参数metaData，用于设置任务的元信息
|
|
|
if (metaData != null && metaData.getNotes() != null) { // 如果传入的MetaData对象metaData不为空，并且通过调用其getNotes方法获取到的笔记信息也不为空
|
|
|
try {// 开始一个try块，用于捕获可能出现的JSONException异常
|
|
|
mMetaInfo = new JSONObject(metaData.getNotes()); // 创建一个新的JSONObject对象mMetaInfo，并将通过metaData.getNotes()获取到的笔记信息（应该是字符串形式）转换为JSONObject类型后赋给mMetaInfo变量，用于设置任务的元信息
|
|
|
} catch (JSONException e) { // 如果在上述操作过程中出现了JSONException异常，就执行以下代码块
|
|
|
Log.w(TAG, e.toString()); // 使用Log类的w方法（用于输出警告级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出警告日志，以便在调试时查看出现异常的情况
|
|
|
mMetaInfo = null; // 使用Log类的w方法（用于输出警告级别日志），将TAG（当前类的标识）和异常e的字符串表示形式（e.toString()）作为参数，输出警告日志，以便在调试时查看出现异常的情况
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public int getSyncAction(Cursor c) {// 定义一个公共方法getSyncAction，它接受一个Cursor类型的参数c，用于根据数据库游标（Cursor）中的信息获取同步操作的类型
|
|
|
try { // 开始一个try块，用于捕获可能出现的Exception异常
|
|
|
JSONObject noteInfo = null; // 定义一个JSONObject类型的变量noteInfo，并初始化为null，用于存储笔记相关的信息
|
|
|
if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) { // 如果任务的元信息mMetaInfo不为空，并且包含键为GTaskStringUtils.META_HEAD_NOTE（通过工具类获取的表示特定笔记头部信息的常量字符串）的键值对
|
|
|
noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);// 从mMetaInfo这个JSONObject对象中获取键为GTreeStringUtils.META_HEAD_NOTE的键值对，并将其值（也是一个JSONObject类型）赋给noteInfo变量，用于获取特定的笔记相关信息
|
|
|
}
|
|
|
|
|
|
if (noteInfo == null) { // 如果noteInfo变量为null，即没有获取到有效的笔记相关信息
|
|
|
Log.w(TAG, "it seems that note meta has been deleted"); // 使用Log类的
|
|
|
return SYNC_ACTION_UPDATE_REMOTE;//返回同步操作更新远程。
|
|
|
}
|
|
|
|
|
|
if (!noteInfo.has(NoteColumns.ID)) {//如果笔记信息不包含（笔记列的 ID）。
|
|
|
Log.w(TAG, "remote note id seems to be deleted");//记录警告日志，“远程笔记 ID 似乎已被删除”。
|
|
|
return SYNC_ACTION_UPDATE_LOCAL;//返回同步操作更新本地。
|
|
|
}
|
|
|
|
|
|
// validate the note id now
|
|
|
if (c.getLong(SqlNote.ID_COLUMN) != noteInfo.getLong(NoteColumns.ID)) {//如果 c 中获取的长整型（SQL 笔记的 ID 列）与笔记信息获取的长整型（笔记列的 ID）不相等。
|
|
|
Log.w(TAG, "note id doesn't match");//记录警告日志，“笔记 ID 不匹配”。
|
|
|
return SYNC_ACTION_UPDATE_LOCAL;
|
|
|
}
|
|
|
|
|
|
if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {//如果 c 中获取的整型（SQL 笔记的本地修改列）为 0。
|
|
|
// there is no local update
|
|
|
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//如果 c 中获取的长整型（SQL 笔记的同步 ID 列）等于最后修改的时间。
|
|
|
// no update both side
|
|
|
return SYNC_ACTION_NONE;//返回同步操作无。
|
|
|
} else {
|
|
|
// apply remote to local
|
|
|
return SYNC_ACTION_UPDATE_LOCAL;//返回同步操作更新本地。
|
|
|
}
|
|
|
} else {
|
|
|
// validate gtask id
|
|
|
if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) {//如果 c 中获取的字符串（SQL 笔记的谷歌任务 ID 列）不等于获取的谷歌任务 ID。
|
|
|
Log.e(TAG, "gtask id doesn't match");//记录错误日志，“谷歌任务 ID 不匹配”。
|
|
|
return SYNC_ACTION_ERROR;//返回同步操作更新远程。
|
|
|
}
|
|
|
if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {//如果 c 中获取的长整型（SQL 笔记的同步 ID 列）等于最后修改的时间。
|
|
|
// local modification only
|
|
|
return SYNC_ACTION_UPDATE_REMOTE;//返回同步操作更新远程。
|
|
|
} else {
|
|
|
return SYNC_ACTION_UPDATE_CONFLICT;
|
|
|
}//返回同步操作更新冲突。
|
|
|
}
|
|
|
} catch (Exception e) {//捕获异常。
|
|
|
Log.e(TAG, e.toString());//记录错误日志，标签和异常的字符串表示。
|
|
|
e.printStackTrace();//打印异常堆栈跟踪。
|
|
|
}
|
|
|
|
|
|
return SYNC_ACTION_ERROR;//返回同步操作错误。
|
|
|
}
|
|
|
|
|
|
public boolean isWorthSaving() {//公共方法，判断是否值得保存。
|
|
|
return mMetaInfo != null || (getName() != null && getName().trim().length() > 0)
|
|
|
|| (getNotes() != null && getNotes().trim().length() > 0);
|
|
|
}//返回元信息不为空，或者名称不为空且经过修剪后的长度大于 0，或者笔记不为空且经过修剪后的长度大于 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;//返回父任务列表。
|
|
|
|
|
|
}
|
|
|
|
|
|
|
