MetaData.java

@@ -0,0 +1,104 @@
+package net.micode.notes.gtask.data;
+ 
+public class MetaData extends Task {
+	/*
+	 * 功能描述：得到类的简写名称存入字符串TAG中
+	 * 实现过程：调用getSimpleName ()函数
+	 */
+    private final static String TAG = MetaData.class.getSimpleName();
+    private String mRelatedGid = null;
+    /*
+     * 功能描述：设置数据，即生成元数据库
+     * 实现过程：调用JSONObject库函数put ()，Task类中的setNotes ()和setName ()函数
+     * 参数注解：
+     */
+    public void setMeta(String gid, JSONObject metaInfo) 
+    {
+    	//对函数块进行注释
+        try {
+            metaInfo.put(GTaskStringUtils.META_HEAD_GTASK_ID, gid);
+            /*
+             * 将这对键值放入metaInfo这个jsonobject对象中
+             */
+        } catch (JSONException e) {
+            Log.e(TAG, "failed to put related gid");
+            /*
+             * 输出错误信息
+             */
+        }
+        setNotes(metaInfo.toString());
+        setName(GTaskStringUtils.META_NOTE_NAME);
+    }
+    /*
+     * 功能描述：获取相关联的Gid
+     */
+    public String getRelatedGid() {
+        return mRelatedGid;
+    }
+    /*
+     * 功能描述：判断当前数据是否为空，若为空则返回真即值得保存
+     * Made By CuiCan
+     */
+    @Override
+    public boolean isWorthSaving() {
+        return getNotes() != null;
+    }
+    /*
+     * 功能描述：使用远程json数据对象设置元数据内容
+     * 实现过程：调用父类Task中的setContentByRemoteJSON ()函数，并
+     * 参数注解： 
+     */
+    @Override
+    public void setContentByRemoteJSON(JSONObject js) {
+        super.setContentByRemoteJSON(js);
+        if (getNotes() != null) {
+            try {
+                JSONObject metaInfo = new JSONObject(getNotes().trim());
+                mRelatedGid = metaInfo.getString(GTaskStringUtils.META_HEAD_GTASK_ID);
+            } catch (JSONException e) {
+                Log.w(TAG, "failed to get related gid");
+                /*
+                 * 输出警告信息
+                 */
+                mRelatedGid = null;
+            }
+        }
+    }
+    /*
+     * 功能描述：使用本地json数据对象设置元数据内容，一般不会用到，若用到，则抛出异常
+     * Made By CuiCan
+     */
+    @Override
+    public void setContentByLocalJSON(JSONObject js) {
+        // this function should not be called
+        throw new IllegalAccessError("MetaData:setContentByLocalJSON should not be called");
+        /*
+         * 传递非法参数异常
+         */
+    }
+    /*
+     * 功能描述：从元数据内容中获取本地json对象，一般不会用到，若用到，则抛出异常
+     * Made By CuiCan
+     */
+    @Override
+    public JSONObject getLocalJSONFromContent() {
+        throw new IllegalAccessError("MetaData:getLocalJSONFromContent should not be called");
+        /*
+         * 传递非法参数异常
+         * Made By Cui Can
+         */
+    }
+    /*
+     * 功能描述：获取同步动作状态，一般不会用到，若用到，则抛出异常
+     * Made By CuiCan
+     */
+    @Override
+    public int getSyncAction(Cursor c) {
+        throw new IllegalAccessError("MetaData:getSyncAction should not be called");
+        /*
+         * 传递非法参数异常
+         * Made By Cui Can
+         */
+    }
+ 
+}

Node.java

@@ -0,0 +1,90 @@
+package net.micode.notes.gtask.data;
+ 
+import android.database.Cursor;
+ 
+import org.json.JSONObject;
+ 
+/**
+ * 应该是同步操作的基础数据类型，定义了相关指示同步操作的常量
+ * 关键字：abstract
+ */
+public abstract class Node {
+	//定义了各种用于表征同步状态的常量
+    public static final int SYNC_ACTION_NONE = 0;// 本地和云端都无可更新内容（即本地和云端内容一致）
+    
+    public static final int SYNC_ACTION_ADD_REMOTE = 1;// 需要在远程云端增加内容
+ 
+    public static final int SYNC_ACTION_ADD_LOCAL = 2;// 需要在本地增加内容
+ 
+    public static final int SYNC_ACTION_DEL_REMOTE = 3;// 需要在远程云端删除内容
+ 
+    public static final int SYNC_ACTION_DEL_LOCAL = 4;// 需要在本地删除内容
+ 
+    public static final int SYNC_ACTION_UPDATE_REMOTE = 5;// 需要将本地内容更新到远程云端
+ 
+    public static final int SYNC_ACTION_UPDATE_LOCAL = 6;// 需要将远程云端内容更新到本地
+ 
+    public static final int SYNC_ACTION_UPDATE_CONFLICT = 7;// 同步出现冲突
+ 
+    public static final int SYNC_ACTION_ERROR = 8;// 同步出现错误
+ 
+    private String mGid;
+ 
+    private String mName;
+ 
+    private long mLastModified;//记录最后一次修改时间
+ 
+    private boolean mDeleted;//表征是否被删除
+ 
+    public Node() {
+        mGid = null;
+        mName = "";
+        mLastModified = 0;
+        mDeleted = false;
+    }
+ 
+    public abstract JSONObject getCreateAction(int actionId);
+ 
+    public abstract JSONObject getUpdateAction(int actionId);
+ 
+    public abstract void setContentByRemoteJSON(JSONObject js);
+ 
+    public abstract void setContentByLocalJSON(JSONObject js);
+ 
+    public abstract JSONObject getLocalJSONFromContent();
+ 
+    public abstract int getSyncAction(Cursor c);
+ 
+    public void setGid(String gid) {
+        this.mGid = gid;
+    }
+ 
+    public void setName(String name) {
+        this.mName = name;
+    }
+ 
+    public void setLastModified(long lastModified) {
+        this.mLastModified = lastModified;
+    }
+ 
+    public void setDeleted(boolean deleted) {
+        this.mDeleted = deleted;
+    }
+ 
+    public String getGid() {
+        return this.mGid;
+    }
+ 
+    public String getName() {
+        return this.mName;
+    }
+ 
+    public long getLastModified() {
+        return this.mLastModified;
+    }
+ 
+    public boolean getDeleted() {
+        return this.mDeleted;
+    }
+ 
+}

Task.java

@@ -0,0 +1,323 @@
+package net.micode.notes.gtask.data;
+ 
+public class Task extends Node {
+    private static final String TAG = Task.class.getSimpleName();
+ 
+    private boolean mCompleted;//是否完成
+ 
+    private String mNotes;
+ 
+    private JSONObject mMetaInfo;//将在实例中存储数据的类型
+ 
+    private Task mPriorSibling;//对应的优先兄弟Task的指针（待完善）
+ 
+    private TaskList mParent;//所在的任务列表的指针
+ 
+    public Task() {
+        super();
+        mCompleted = false;
+        mNotes = null;
+        mPriorSibling = null;//TaskList中当前Task前面的Task的指针
+        mParent = null;//当前Task所在的TaskList
+        mMetaInfo = null;
+    }
+ 
+    public JSONObject getCreateAction(int actionId) {
+        JSONObject js = new JSONObject();
+ 
+        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);
+ 
+            // index
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mParent.getChildTaskIndex(this));
+ 
+            // entity_delta
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_TASK);
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            }
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+ 
+            // parent_id
+            if (mParent!= null) {
+            js.put(GTaskStringUtils.GTASK_JSON_PARENT_ID, mParent.getGid());
+            }
+ 
+            // dest_parent_type
+            js.put(GTaskStringUtils.GTASK_JSON_DEST_PARENT_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+ 
+            // list_id
+            if (mParent!= null) {
+            js.put(GTaskStringUtils.GTASK_JSON_LIST_ID, mParent.getGid());
+            }
+ 
+            // prior_sibling_id
+            if (mPriorSibling != null) {
+                js.put(GTaskStringUtils.GTASK_JSON_PRIOR_SIBLING_ID, mPriorSibling.getGid());
+            }
+ 
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate task-create jsonobject");
+        }
+ 
+        return js;
+    }
+ 
+    public JSONObject getUpdateAction(int actionId) {
+        JSONObject js = new JSONObject();
+ 
+        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
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+ 
+            // entity_delta
+            JSONObject entity = new JSONObject();
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            if (getNotes() != null) {
+                entity.put(GTaskStringUtils.GTASK_JSON_NOTES, getNotes());
+            }
+            entity.put(GTaskStringUtils.GTASK_JSON_DELETED, getDeleted());
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+ 
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate task-update jsonobject");
+        }
+ 
+        return js;
+    }
+ 
+    public void setContentByRemoteJSON(JSONObject js) {
+        if (js != null) {
+            try {
+                // id
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_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));
+                }
+ 
+                // notes
+                if (js.has(GTaskStringUtils.GTASK_JSON_NOTES)) {
+                    setNotes(js.getString(GTaskStringUtils.GTASK_JSON_NOTES));
+                }
+ 
+                // deleted
+                if (js.has(GTaskStringUtils.GTASK_JSON_DELETED)) {
+                    setDeleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_DELETED));
+                }
+ 
+                // completed
+                if (js.has(GTaskStringUtils.GTASK_JSON_COMPLETED)) {
+                    setCompleted(js.getBoolean(GTaskStringUtils.GTASK_JSON_COMPLETED));
+                }
+            } catch (JSONException e) {
+                Log.e(TAG, e.toString());
+                e.printStackTrace();
+                throw new ActionFailureException("fail to get task content from jsonobject");
+            }
+        }
+    }
+ 
+    public void setContentByLocalJSON(JSONObject js) {    //<2F><>metadata<74><61><EFBFBD><EFBFBD>ʵʩ
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)
+                || !js.has(GTaskStringUtils.META_HEAD_DATA)) {
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }
+ 
+        try {
+            JSONObject note = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            JSONArray dataArray = js.getJSONArray(GTaskStringUtils.META_HEAD_DATA);
+ 
+            if (note.getInt(NoteColumns.TYPE) != Notes.TYPE_NOTE) {
+                Log.e(TAG, "invalid type"); 
+                return;
+            }
+ 
+            for (int i = 0; i < dataArray.length(); i++) {
+                JSONObject data = dataArray.getJSONObject(i);
+                if (TextUtils.equals(data.getString(DataColumns.MIME_TYPE), DataConstants.NOTE)) {
+                    setName(data.getString(DataColumns.CONTENT));
+                    break;
+                }
+            }
+ 
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+    }
+ 
+    public JSONObject getLocalJSONFromContent() {
+        String name = getName();
+        try {
+            if (mMetaInfo == null) {
+                // new task created from web
+                if (name == null) {
+                    Log.w(TAG, "the note seems to be an empty one");
+                    return null;
+                }
+ 
+                JSONObject js = new JSONObject();
+                JSONObject note = new JSONObject();
+                JSONArray dataArray = new JSONArray();
+                JSONObject data = new JSONObject();
+                data.put(DataColumns.CONTENT, name);
+                dataArray.put(data);
+                js.put(GTaskStringUtils.META_HEAD_DATA, dataArray);
+                note.put(NoteColumns.TYPE, Notes.TYPE_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.put(NoteColumns.TYPE, Notes.TYPE_NOTE);
+                return mMetaInfo;
+            }
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return null;
+        }
+    }
+ 
+    public void setMetaInfo(MetaData metaData) {
+        if (metaData != null && metaData.getNotes() != null) {
+            try {
+                mMetaInfo = new JSONObject(metaData.getNotes());
+            } catch (JSONException e) {
+                Log.w(TAG, e.toString());
+                mMetaInfo = null;
+            }
+        }
+    }
+ 
+    public int getSyncAction(Cursor c) {
+        try {
+            JSONObject noteInfo = null;
+            if (mMetaInfo != null && mMetaInfo.has(GTaskStringUtils.META_HEAD_NOTE)) {
+                noteInfo = mMetaInfo.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+            }
+ 
+            if (noteInfo == null) {
+                Log.w(TAG, "it seems that note meta has been deleted");
+                return SYNC_ACTION_UPDATE_REMOTE;
+            }
+ 
+            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)) {
+                Log.w(TAG, "note id doesn't match");
+                return SYNC_ACTION_UPDATE_LOCAL;
+            }
+ 
+            if (c.getInt(SqlNote.LOCAL_MODIFIED_COLUMN) == 0) {
+                // there is no local update
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // 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())) {
+                    Log.e(TAG, "gtask id doesn't match");
+                    return SYNC_ACTION_ERROR;
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // 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);
+    }
+ 
+    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;
+    }
+ 
+}

TaskList.java

@@ -0,0 +1,390 @@
+package net.micode.notes.gtask.data;
+ 
+public class TaskList extends Node {
+    private static final String TAG = TaskList.class.getSimpleName();//tag标记
+ 
+    private int mIndex;//当前TaskList的指针
+ 
+    private ArrayList<Task> mChildren;//类中主要的保存数据的单元，用来实现一个以Task为元素的ArrayList
+ 
+    public TaskList() {
+        super();
+        mChildren = new ArrayList<Task>();
+        mIndex = 1;
+    }
+ 
+    /* (non-Javadoc)
+     * @see net.micode.notes.gtask.data.Node#getCreateAction(int)
+     * 生成并返回一个包含了一定数据的JSONObject实体
+     */
+    public JSONObject getCreateAction(int actionId) {
+        JSONObject js = new JSONObject();
+ 
+        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);
+ 
+            // index
+            js.put(GTaskStringUtils.GTASK_JSON_INDEX, mIndex);
+ 
+            // entity_delta
+            JSONObject entity = new JSONObject();//entity实体
+            entity.put(GTaskStringUtils.GTASK_JSON_NAME, getName());
+            entity.put(GTaskStringUtils.GTASK_JSON_CREATOR_ID, "null");
+            entity.put(GTaskStringUtils.GTASK_JSON_ENTITY_TYPE,
+                    GTaskStringUtils.GTASK_JSON_TYPE_GROUP);
+            js.put(GTaskStringUtils.GTASK_JSON_ENTITY_DELTA, entity);
+ 
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate tasklist-create jsonobject");
+        }
+ 
+        return js;
+    }
+ 
+    /* (non-Javadoc)
+     * @see net.micode.notes.gtask.data.Node#getUpdateAction(int)
+     * 生成并返回一个包含了一定数据的JSONObject实体
+     */
+    public JSONObject getUpdateAction(int actionId) {
+        JSONObject js = new JSONObject();
+ 
+        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
+            js.put(GTaskStringUtils.GTASK_JSON_ID, getGid());
+ 
+            // 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);
+ 
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            throw new ActionFailureException("fail to generate tasklist-update jsonobject");
+        }
+ 
+        return js;
+    }
+ 
+    public void setContentByRemoteJSON(JSONObject js) {
+        if (js != null) {
+            try {
+                // id
+                if (js.has(GTaskStringUtils.GTASK_JSON_ID)) {
+                    setGid(js.getString(GTaskStringUtils.GTASK_JSON_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");
+            }
+        }
+    }
+ 
+   public void setContentByLocalJSON(JSONObject js) {
+        // 判断js是否为空，或者js中是否有GTaskStringUtils.META_HEAD_NOTE
+        if (js == null || !js.has(GTaskStringUtils.META_HEAD_NOTE)) {
+            Log.w(TAG, "setContentByLocalJSON: nothing is avaiable");
+        }
+ 
+        try {
+            // 获取js中的JSONObject
+            JSONObject folder = js.getJSONObject(GTaskStringUtils.META_HEAD_NOTE);
+ 
+            // 判断folder的类型是否为folder
+            if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_FOLDER) {
+                // 获取folder的name
+                String name = folder.getString(NoteColumns.SNIPPET);
+                // 设置name
+                setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + name);
+            } else if (folder.getInt(NoteColumns.TYPE) == Notes.TYPE_SYSTEM) {
+                // 判断folder的id是否为Notes.ID_ROOT_FOLDER
+                if (folder.getLong(NoteColumns.ID) == Notes.ID_ROOT_FOLDER)
+                    // 设置name
+                    setName(GTaskStringUtils.MIUI_FOLDER_PREFFIX + GTaskStringUtils.FOLDER_DEFAULT);
+                // 判断folder的id是否为Notes.ID_CALL_RECORD_FOLDER
+                else if (folder.getLong(NoteColumns.ID) == Notes.ID_CALL_RECORD_FOLDER)
+                    // 设置name
+                    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();
+        }
+    }
+ 
+   public JSONObject getLocalJSONFromContent() {
+        try {
+            // 创建一个JSONObject对象
+            JSONObject js = new JSONObject();
+            // 创建一个JSONObject对象，用于存放文件夹信息
+            JSONObject folder = new JSONObject();
+ 
+            // 获取文件夹名
+            String folderName = getName();
+            // 如果文件夹名以MIUI_FOLDER_PREFFIX开头，则截取文件夹名
+            if (getName().startsWith(GTaskStringUtils.MIUI_FOLDER_PREFFIX))
+                folderName = folderName.substring(GTaskStringUtils.MIUI_FOLDER_PREFFIX.length(),
+                        folderName.length());
+            // 将文件夹名放入JSONObject对象中
+            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);
+ 
+            // 将文件夹信息放入JSONObject对象中
+            js.put(GTaskStringUtils.META_HEAD_NOTE, folder);
+ 
+            // 返回JSONObject对象
+            return js;
+        } catch (JSONException e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+            return 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()) {
+                    // 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())) {
+                    Log.e(TAG, "gtask id doesn't match");
+                    return SYNC_ACTION_ERROR;
+                }
+                if (c.getLong(SqlNote.SYNC_ID_COLUMN) == getLastModified()) {
+                    // local modification only
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                } else {
+                    // for folder conflicts, just apply local modification
+                    return SYNC_ACTION_UPDATE_REMOTE;
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, e.toString());
+            e.printStackTrace();
+        }
+ 
+        return SYNC_ACTION_ERROR;
+    }
+ 
+    /**
+     * @return
+     * 功能：获得TaskList的大小，即mChildren的大小
+     */
+    public int getChildTaskCount() {
+        return mChildren.size();
+    }
+ 
+    /**
+     * @param task
+     * @return 返回值为是否成功添加任务。
+     * 功能：在当前任务表末尾添加新的任务。
+     */
+    public boolean addChildTask(Task task) {
+        boolean ret = false;
+        if (task != null && !mChildren.contains(task)) {
+            ret = mChildren.add(task);
+            if (ret) {
+                // need to set prior sibling and parent
+                task.setPriorSibling(mChildren.isEmpty() ? null : mChildren
+                        .get(mChildren.size() - 1));
+                task.setParent(this);
+                //注意：每一次ArrayList的变化都要紧跟相关Task中PriorSibling的更改
+                //，接下来几个函数都有相关操作
+            }
+        }
+        return ret;
+    }
+ 
+    /**
+     * @param task
+     * @param index
+     * @return
+     * 功能：在当前任务表的指定位置添加新的任务。
+     */
+    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);
+ 
+            // update the task list
+            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;
+    }
+ 
+    /**
+     * @param task
+     * @return 返回删除是否成功
+     * 功能：删除TaskList中的一个Task
+     */
+    public boolean removeChildTask(Task task) {
+        boolean ret = false;
+        int index = mChildren.indexOf(task);
+        if (index != -1) {
+            ret = mChildren.remove(task);
+ 
+            if (ret) {
+                // reset prior sibling and parent
+                task.setPriorSibling(null);
+                task.setParent(null);
+ 
+                // update the task list
+                if (index != mChildren.size()) {
+                    mChildren.get(index).setPriorSibling(
+                            index == 0 ? null : mChildren.get(index - 1));
+                }
+            }
+        }
+        return ret;
+    }
+ 
+    /**
+     * @param task
+     * @param index
+     * @return
+     * 功能：将当前TaskList中含有的某个Task移到index位置
+     */
+    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));
+        //利用已实现好的功能完成当下功能；
+    }
+ 
+    /**
+     * @param gid
+     * @return返回寻找结果
+     * 功能：按gid寻找Task
+     */
+    public Task findChildTaskByGid(String gid) {
+        for (int i = 0; i < mChildren.size(); i++) {
+            Task t = mChildren.get(i);
+            if (t.getGid().equals(gid)) {
+                return t;
+            }
+        }
+        return null;
+    }
+ 
+    /**
+     * @param task
+     * @return
+     * 功能：返回指定Task的index
+     */
+    public int getChildTaskIndex(Task task) {
+        return mChildren.indexOf(task);
+    }
+ 
+    /**
+     * @param index
+     * @return
+     * 功能：返回指定index的Task
+     */
+    public Task getChildTaskByIndex(int index) {
+        if (index < 0 || index >= mChildren.size()) {
+            Log.e(TAG, "getTaskByIndex: invalid index");
+            return null;
+        }
+        return mChildren.get(index);
+    }
+ 
+    /**
+     * @param gid
+     * @return
+     * 功能：返回指定gid的Task
+     */
+    public Task getChilTaskByGid(String gid) {
+        for (Task task : mChildren) {//一种常见的ArrayList的遍历方法（四种，见精读笔记）
+            if (task.getGid().equals(gid))
+                return task;
+        }
+        return null;
+    }
+ 
+   //获取子任务列表
+    public ArrayList<Task> getChildTaskList() {
+        return this.mChildren;
+    }
+ 
+    //设置索引
+    public void setIndex(int index) {
+        this.mIndex = index;
+    }
+ 
+    //获取索引
+    public int getIndex() {
+        return this.mIndex;
+    }
+}