MiNote/gtask/data/TaskList.java

/*
 * 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.util.Log;
 
 import net.micode.notes.data.Notes;
 import net.micode.notes.data.Notes.NoteColumns;
 import net.micode.notes.gtask.exception.ActionFailureException;
 import net.micode.notes.tool.GTaskStringUtils;
 
 import org.json.JSONException;
 import org.json.JSONObject;
 
 import java.util.ArrayList;
 
 public class TaskList extends Node {
     private static final String TAG = TaskList.class.getSimpleName(); // 用于日志记录的标签
 
     private int mIndex; // 任务列表的索引
     private ArrayList<Task> mChildren; // 存储子任务的列表
 
     // 构造函数，初始化任务列表
     public TaskList() {
         super(); // 调用父类构造函数
         mChildren = new ArrayList<Task>(); // 初始化子任务列表
         mIndex = 1; // 默认索引为1
     }
 
     // 获取创建任务列表的JSON对象
     public JSONObject getCreateAction(int actionId) {
         JSONObject js = new JSONObject(); // 创建JSON对象
 
         try {
             // action_type
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_CREATE); // 设置操作类型为创建
 
             // action_id
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 设置操作ID
 
             // index
             js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex); // 设置任务列表的索引
 
             // entity_delta
             JSONObject entity = new JSONObject(); // 创建实体对象
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置任务列表名称
             entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null"); // 设置创建者ID
             entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
                     GTaskStringUtils.GTASK_JSON_TYPE_GROUP); // 设置实体类型为组
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体对象添加到JSON对象
 
         } catch (JSONException e) {
             Log.e(TAG, e.toString()); // 记录错误
             e.printStackTrace(); // 打印堆栈跟踪
             throw new ActionFailureException("fail to generate tasklist-create jsonobject"); // 抛出异常
         }
 
         return js; // 返回创建任务列表的JSON对象
     }
 
     // 获取更新任务列表的JSON对象
     public JSONObject getUpdateAction(int actionId) {
         JSONObject js = new JSONObject(); // 创建JSON对象
 
         try {
             // action_type
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_TYPE,
                     GTaskStringUtils.GTASK_JSON_ACTION_TYPE_UPDATE); // 设置操作类型为更新
 
             // action_id
             js.put(GTaskStringUtils.GTASK_JSON_ACTION_ID, actionId); // 设置操作ID
 
             // id
             js.put(GTaskStringUtils.GTASK_JSON_ID, getGid()); // 设置任务列表ID
 
             // entity_delta
             JSONObject entity = new JSONObject(); // 创建实体对象
             entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName()); // 设置任务列表名称
             entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted()); // 设置删除标志
             js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity); // 将实体对象添加到JSON对象
 
         } catch (JSONException e) {
             Log.e(TAG, e.toString()); // 记录错误
             e.printStackTrace(); // 打印堆栈跟踪
             throw new ActionFailureException("fail to generate tasklist-update jsonobject"); // 抛出异常
         }
 
         return js; // 返回更新任务列表的JSON对象
     }
 
     // 从远程JSON设置内容
     public void setContentByRemoteJSON(JSONObject js) {
         if (js != null) {
             try {
                 // id
                 if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
                     setGid(js.getString(GTaskStringUtils.GTASK_JSON_ID)); // 设置任务列表ID
                 }
 
                 // last_modified
                 if (js.has(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)) {
                     setLastModified(js.getLong(GTaskStringUtils.GTASK_JSON_LAST_MODIFIED)); // 设置最后修改时间
                 }
 
                 // name
                 if (js.has(GTaskStringUtils.GTASK_JSON_NAME)) {
                     setName(js.getString(GTaskStringUtils.GTASK_JSON_NAME)); // 设置任务列表名称
                 }
 
             } catch (JSONException e) {
                 Log.e(TAG, e.toString()); // 记录错误
                 e.printStackTrace(); // 打印堆栈跟踪
                 throw new ActionFailureException("fail to get tasklist content from jsonobject"); // 抛出异常
             }
         }
     }
 
     // 从本地JSON设置内容
     public void setContentByLocalJSON(JSONObject js) {
         if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
             Log.w(TAG, "setContentByLocalJSON: nothing is available"); // 记录警告
         }
 
         try {
             JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE); // 获取笔记对象
 
             if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) { // 如果是文件夹
                 String name = folder.getString(NoteColumns.SNIPPET); // 获取摘要
                 setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name); // 设置任务列表名称
             } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) { // 如果是系统文件夹
                 if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT); // 设置根文件夹名称
                 else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
                     setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_CALL_NOTE); // 设置通话记录文件夹名称
                 else
                     Log.e(TAG, "invalid system folder"); // 记录错误
             } else {
                 Log.e(TAG, "error type"); // 记录错误
             }
         } catch (JSONException e) {
             Log.e(TAG, e.toString()); // 记录错误
             e.printStackTrace(); // 打印堆栈跟踪
         }
     }
 
     // 从内容生成本地JSON对象
     public JSONObject getLocalJSONFromContent() {
         try {
             JSONObject js = new JSONObject(); // 创建JSON对象
             JSONObject folder = new JSONObject(); // 创建文件夹对象
 
             String folderName = getName(); // 获取任务列表名称
             if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
                 folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
                         folderName.length()); // 去掉前缀
             folder.put(NoteColumns.SNIPPET, folderName); // 设置摘要
             if (folderName.equals(GTaskStringUtils.FOLDER_DEFAULT)
                     || folderName.equals(GTaskStringUtils.FOLDER_CALL_NOTE))
                 folder.put(NoteColumns.TYPE, Notes.TYPE_SYSTEM); // 设置类型为系统
             else
                 folder.put(NoteColumns.TYPE, Notes.TYPE_FOLDER); // 设置类型为文件夹
 
             js.put(GTaskStringUtils.META_HEAD_NOTE, folder); // 将文件夹对象添加到JSON对象
 
             return js; // 返回JSON对象
         } catch (JSONException e) {
             Log.e(TAG, e.toString()); // 记录错误
             e.printStackTrace(); // 打印堆栈跟踪
             return null; // 返回null
         }
     }
 
     // 获取同步操作
     public int getSyncAction(Cursor c) {
         try {
             if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) { // 如果没有本地更新
                 // there is no local update
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { // 如果同步ID未改变
                     return SYNC_ACTION_NONE; // 返回无操作
                 } else {
                     return SYNC_ACTION_UPDATE_LOCAL; // 返回更新本地操作
                 }
             } else { // 如果有本地更新
                 // validate gtask id
                 if (!c.getString(SqlNote.GTASK_ID_COLUMN).equals(getGid())) { // 验证GTask ID
                     Log.e(TAG, "gtask id doesn't match"); // 记录错误
                     return SYNC_ACTION_ERROR; // 返回错误操作
                 }
                 if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) { // 如果同步ID未改变
                     return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程操作
                 } else {
                     // 对于文件夹冲突，仅应用本地修改
                     return SYNC_ACTION_UPDATE_REMOTE; // 返回更新远程操作
                 }
             }
         } catch (Exception e) {
             Log.e(TAG, e.toString()); // 记录错误
             e.printStackTrace(); // 打印堆栈跟踪
         }
 
         return SYNC_ACTION_ERROR; // 返回错误操作
     }
 
     // 获取子任务数量
     public int getChildTaskCount() {
         return mChildren.size(); // 返回子任务数量
     }
 
     // 添加子任务
     public boolean addChildTask(Task task) {
         boolean ret = false; // 返回值
         if (task != null && !mChildren.contains(task)) { // 如果任务不为空且不在子任务列表中
             ret = mChildren.add(task); // 添加子任务
             if (ret) {
                 // 需要设置前一个兄弟任务和父任务
                 task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
                         .get(mChildren.size() - 1)); // 设置前一个兄弟任务
                 task.setParent(this); // 设置父任务
             }
         }
         return ret; // 返回添加结果
     }
 
     // 在指定索引添加子任务
     public boolean addChildTask(Task task, int index) {
         if (index < 0 || index > mChildren.size()) { // 验证索引有效性
             Log.e(TAG, "add child task: invalid index"); // 记录错误
             return false; // 返回失败
         }
 
         int pos = mChildren.indexOf(task); // 获取任务在列表中的位置
         if (task != null && pos == -1) { // 如果任务不为空且不在列表中
             mChildren.add(index, task); // 在指定索引添加子任务
 
             // 更新任务列表
             Task preTask = null; // 前一个任务
             Task afterTask = null; // 后一个任务
             if (index != 0)
                 preTask = mChildren.get(index - 1); // 获取前一个任务
             if (index != mChildren.size() - 1)
                 afterTask = mChildren.get(index + 1); // 获取后一个任务
 
             task.setPriorSibling(preTask); // 设置前一个兄弟任务
             if (afterTask != null)
                 afterTask.setPriorSibling(task); // 设置后一个兄弟任务
         }
 
         return true; // 返回成功
     }
 
     // 移除子任务
     public boolean removeChildTask(Task task) {
         boolean ret = false; // 返回值
         int index = mChildren.indexOf(task); // 获取任务在列表中的位置
         if (index != -1) { // 如果任务在列表中
             ret = mChildren.remove(task); // 移除子任务
 
             if (ret) {
                 // 重置前一个兄弟任务和父任务
                 task.setPriorSibling(null); // 设置前一个兄弟任务为空
                 task.setParent(null); // 设置父任务为空
 
                 // 更新任务列表
                 if (index != mChildren.size()) {
                     mChildren.get(index).setPriorSibling(
                             index == 0 ? null : mChildren.get(index - 1)); // 更新前一个兄弟任务
                 }
             }
         }
         return ret; // 返回移除结果
     }
 
     // 移动子任务到指定索引
     public boolean moveChildTask(Task task, int index) {
         if (index < 0 || index >= mChildren.size()) { // 验证索引有效性
             Log.e(TAG, "move child task: invalid index"); // 记录错误
             return false; // 返回失败
         }
 
         int pos = mChildren.indexOf(task); // 获取任务在列表中的位置
         if (pos == -1) { // 如果任务不在列表中
             Log.e(TAG, "move child task: the task should in the list"); // 记录错误
             return false; // 返回失败
         }
 
         if (pos == index) // 如果位置相同
             return true; // 返回成功
         return (removeChildTask(task) && addChildTask(task, index)); // 移除并添加任务
     }
 
     // 根据GID查找子任务
     public Task findChildTaskByGid(String gid) {
         for (int i = 0; i < mChildren.size(); i++) { // 遍历子任务列表
             Task t = mChildren.get(i); // 获取子任务
             if (t.getGid().equals(gid)) { // 如果GID匹配
                 return t; // 返回匹配的子任务
             }
         }
         return null; // 返回null
     }
 
     // 获取子任务的索引
     public int getChildTaskIndex(Task task) {
         return mChildren.indexOf(task); // 返回子任务在列表中的索引
     }
 
     // 根据索引获取子任务
     public Task getChildTaskByIndex(int index) {
         if (index < 0 || index >= mChildren.size()) { // 验证索引有效性
             Log.e(TAG, "getTaskByIndex: invalid index"); // 记录错误
             return null; // 返回null
         }
         return mChildren.get(index); // 返回子任务
     }
 
     // 根据GID获取子任务
     public Task getChilTaskByGid(String gid) {
         for (Task task : mChildren) { // 遍历子任务列表
             if (task.getGid().equals(gid)) // 如果GID匹配
                 return task; // 返回匹配的子任务
         }
         return null; // 返回null
     }
 
     // 获取子任务列表
     public ArrayList<Task> getChildTaskList() {
         return this.mChildren; // 返回子任务列表
     }
 
     // 设置任务列表的索引
     public void setIndex(int index) {
         this.mIndex = index; // 更新索引
     }
 
     // 获取任务列表的索引
     public int getIndex() {
         return this.mIndex; // 返回索引
     }
 }